awesome/objects/screen.c

/*
 * screen.c - screen management
 *
 * Copyright © 2007-2009 Julien Danjou <julien@danjou.info>
 *
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */

/** awesome screen API
 *
 * Screen objects can be added and removed over time. To get a callback for all
 * current and future screens, use `awful.screen.connect_for_each_screen`:
 *
 *    awful.screen.connect_for_each_screen(function(s)
 *        -- do something
 *    end)
 *
 * It is also possible loop over all current screens using:
 *
 *    for s in screen do
 *        -- do something
 *    end
 *
 * Most basic Awesome objects also have a screen property, see `mouse.screen`
 * `client.screen`, `wibox.screen` and `tag.screen`.
 *
 * Furthermore to the classes described here, one can also use signals as
 * described in @{signals}.
 *
 * @author Julien Danjou &lt;julien@danjou.info&gt;
 * @copyright 2008-2009 Julien Danjou
 * @coreclassmod screen
 */

#include "objects/screen.h"
#include "banning.h"
#include "objects/client.h"
#include "objects/drawin.h"
#include "event.h"

#include <stdio.h>

#include <xcb/xcb.h>
#include <xcb/xinerama.h>
#include <xcb/randr.h>

/* The XID that is used on fake screens. X11 guarantees that the top three bits
 * of a valid XID are zero, so this will not clash with anything.
 */
#define FAKE_SCREEN_XID ((uint32_t) 0xffffffff)

/** AwesomeWM is about to scan for existing screens.
 *
 * Connect to this signal when code needs to be executed after the Lua context
 * is initialized and modules are loaded, but before screens are added.
 *
 * To manage screens manually, set `screen.automatic_factory = false` and
 * connect to the `property::viewports` signal. It is then possible to use
 * `screen.fake_add` to create virtual screens. Be careful when using this,
 * when done incorrectly, no screens will be created. Using Awesome with zero
 * screens is **not** supported.
 *
 * @signal scanning
 * @see property::viewports
 * @see screen.fake_add
 */

/** AwesomeWM is done scanning for screens.
 *
 * Connect to this signal to execute code after the screens have been created,
 * but before the clients are added. This signal can also be used to split
 * physical screens into multiple virtual screens before the clients (and their
 * rules) are executed.
 *
 * Note that if no screens exist at this point, the fallback code will be
 * triggered and the default (detected) screens will be added.
 *
 * @signal scanned
 * @see screen.fake_resize
 * @see screen.fake_add
 */

/** Screen is a table where indexes are screen numbers. You can use `screen[1]`
 * to get access to the first screen, etc. Alternatively, if RANDR information
 * is available, you can use output names for finding screen objects.
 * The primary screen can be accessed as `screen.primary`.
 * Each screen has a set of properties.
 *
 */

/**
 * @signal primary_changed
 */

/**
 * This signal is emitted when a new screen is added to the current setup.
 * @signal added
 */

/**
 * This signal is emitted when a screen is removed from the setup.
 * @signal removed
 */

/** This signal is emitted when the list of available screens changes.
 * @signal list
 */

/** When 2 screens are swapped
 * @tparam screen screen The other screen
 * @tparam boolean is_source If self is the source or the destination of the swap
 * @signal swapped
 */

/** This signal is emitted when the list of physical screen viewport changes.
 *
 * Each viewport in the list corresponds to a **physical** screen rectangle, which
 * is **not** the `viewports` property of the `screen` objects.
 *
 * Each entry in the `viewports` entry has the following keys:
 *
 * * `geometry` *(table)*: A table with an `x`, `y`, `width` and `height` keys.
 * * `outputs` *(table)*: All outputs sharing this viewport.
 * * `maximum_dpi` *(number)*: The DPI of the most dense output.
 * * `minimum_dpi` *(number)*: The DPI of the least dense output.
 * * `preferred_dpi` *(number)*: The optimal DPI.
 *
 * @signal property::viewports
 * @tparam table viewports A table containing all physical viewports.
 * @see automatic_factory
 */

 /**
  * The primary screen.
  *
  * @tfield screen primary
  */

/**
 * If `screen` objects are created automatically when new viewports are detected.
 *
 * Be very, very careful when setting this to false. You might end up with
 * no screens. This is **not** supported. Always connect to the `scanned`
 * signal to make sure to create a fallback screen if none were created.
 *
 * @tfield[opt=true] boolean screen.automatic_factory
 * @see property::viewports
 */

/**
 * The screen coordinates.
 *
 * **Signal:**
 *
 *  * *property::geometry*
 *
 * **Immutable:** true
 *
 * @DOC_screen_geometry_EXAMPLE@
 *
 * @property geometry
 * @param table
 * @tfield integer table.x The horizontal position
 * @tfield integer table.y The vertical position
 * @tfield integer table.width The width
 * @tfield integer table.height The height
 */

/**
 * The internal screen number.
 *
 * * The indeces are a continuous sequence from 1 to `screen.count()`.
 * * It is **NOT** related to the actual screen position relative to each
 *   other.
 * * 1 is **NOT** necessarily the primary screen.
 * * When screens are added and removed indices **CAN** change.
 *
 * If you really want to keep an array of screens you should use something
 * along:
 *
 *     local myscreens = setmetatable({}. {__mode="k"})
 *     myscreens[ screen[1] ] = "mydata"
 *
 * But it might be a better option to simply store the data directly in the
 * screen object as:
 *
 *     screen[1].mydata = "mydata"
 *
 * Remember that screens are also objects, so if you only want to store a simple
 * property, you can do it directly:
 *
 *     screen[1].answer = 42
 *
 * **Immutable:** true
 * @property index
 * @param integer
 * @see screen
 */

/**
 * The screen workarea.
 *
 * The workarea is a subsection of the screen where clients can be placed. It
 * usually excludes the toolbars (see `awful.wibar`) and dockable clients
 * (see `client.dockable`) like WindowMaker DockAPP.
 *
 * It can be modified be altering the `wibox` or `client` struts.
 *
 * **Signal:**
 *
 *  * *property::workarea*
 *
 * @DOC_screen_workarea_EXAMPLE@
 *
 * @property workarea
 * @see client.struts
 * @param table
 * @tfield integer table.x The horizontal position
 * @tfield integer table.y The vertical position
 * @tfield integer table.width The width
 * @tfield integer table.height The height
 */


/** Get the number of instances.
 *
 * @return The number of screen objects alive.
 * @staticfct instances
 */

/* Set a __index metamethod for all screen instances.
 * @tparam function cb The meta-method
 * @staticfct set_index_miss_handler
 */

/* Set a __newindex metamethod for all screen instances.
 * @tparam function cb The meta-method
 * @staticfct set_newindex_miss_handler
 */

DO_ARRAY(xcb_randr_output_t, randr_output, DO_NOTHING);

struct screen_output_t
{
    /** The XRandR names of the output */
    char *name;
    /** The size in millimeters */
    uint32_t mm_width, mm_height;
    /** The XID */
    randr_output_array_t outputs;
};

static void
screen_output_wipe(screen_output_t *output)
{
    p_delete(&output->name);

    randr_output_array_wipe(&output->outputs);
}

ARRAY_FUNCS(screen_output_t, screen_output, screen_output_wipe)

static lua_class_t screen_class;
LUA_OBJECT_FUNCS(screen_class, screen_t, screen)

/** Check if a screen is valid */
static bool
screen_checker(screen_t *s)
{
    return s->valid;
}

/** Get a screen argument from the lua stack */
screen_t *
luaA_checkscreen(lua_State *L, int sidx)
{
    if (lua_isnumber(L, sidx))
    {
        int screen = lua_tointeger(L, sidx);
        if(screen < 1 || screen > globalconf.screens.len)
        {
            luaA_warn(L, "invalid screen number: %d (of %d existing)", screen, globalconf.screens.len);
            lua_pushnil(L);
            return NULL;
        }
        return globalconf.screens.tab[screen - 1];
    } else
        return luaA_checkudata(L, sidx, &screen_class);
}

static void
screen_deduplicate(lua_State *L, screen_array_t *screens)
{
    /* Remove duplicate screens */
    for(int first = 0; first < screens->len; first++) {
        screen_t *first_screen = screens->tab[first];
        for(int second = 0; second < screens->len; second++) {
            screen_t *second_screen = screens->tab[second];
            if (first == second)
                continue;

            if (first_screen->geometry.width < second_screen->geometry.width
                    && first_screen->geometry.height < second_screen->geometry.height)
                /* Don't drop a smaller screen */
                continue;

            if (first_screen->geometry.x == second_screen->geometry.x
                    && first_screen->geometry.y == second_screen->geometry.y) {
                /* Found a duplicate */
                first_screen->geometry.width = MAX(first_screen->geometry.width, second_screen->geometry.width);
                first_screen->geometry.height = MAX(first_screen->geometry.height, second_screen->geometry.height);

                screen_array_take(screens, second);
                luaA_object_unref(L, second_screen);

                /* Restart the search */
                screen_deduplicate(L, screens);
                return;
            }
        }
    }
}

/** Keep track of the screen viewport(s) independently from the screen objects.
 *
 * A viewport is a collection of `outputs` objects and their associated
 * metadata. This structure is copied into Lua and then further extended from
 * there. The `id` field allows to differentiate between viewports that share
 * the same position and dimensions without having to rely on userdata pointer
 * comparison.
 *
 * Screen objects are widely used by the public API and imply a very "visible"
 * concept. A viewport is a subset of what the concerns the "screen" class
 * previously handled. It is meant to be used by some low level Lua logic to
 * create screens from Lua rather than from C. This is required to increase the
 * flexibility of multi-screen setup or when screens are connected and
 * disconnected often.
 *
 * Design rationals:
 *
 * * The structure is not directly shared with Lua to avoid having to use the
 *   slow "miss_handler" and unsafe "valid" systems used by other CAPI objects.
 * * The `viewport_t` implements a linked-list because its main purpose is to
 *   offers a deduplication algorithm. Random access is never required.
 * * Everything that can be done in Lua is done in Lua.
 * * Since the legacy and "new" way to initialize screens share a lot of steps,
 *   the C code is bent to share as much code as possible. This will reduce the
 *   "dead code" and improve code coverage by the tests.
 *
 */
typedef struct viewport_t
{
    bool marked;
    int x;
    int y;
    int width;
    int height;
    int id;
    struct viewport_t *next;
    screen_t *screen;
    screen_output_array_t outputs;
} viewport_t;

static viewport_t *first_screen_viewport = NULL;
static viewport_t *last_screen_viewport = NULL;
static int screen_area_gid = 1;

static void
luaA_viewport_get_outputs(lua_State *L, viewport_t *a)
{
    lua_createtable(L, 0, a ? a->outputs.len : 0);

    if (!a)
        return;

    int count = 1;

    foreach(output, a->outputs) {
        lua_createtable(L, 3, 0);

        lua_pushstring(L, "mm_width");
        lua_pushinteger(L, output->mm_width);
        lua_settable(L, -3);

        lua_pushstring(L, "mm_height");
        lua_pushinteger(L, output->mm_height);
        lua_settable(L, -3);

        lua_pushstring(L, "name");
        lua_pushstring(L, output->name);
        lua_settable(L, -3);

        lua_pushstring(L, "viewport_id");
        lua_pushinteger(L, a->id);
        lua_settable(L, -3);

        /* Add to the outputs */
        lua_rawseti(L, -2, count++);
    }
}

static int
luaA_viewports(lua_State *L)
{
    /* All viewports */
    lua_newtable(L);

    viewport_t *a = first_screen_viewport;

    if (!a)
        return 1;

    int count = 1;

    do {
        lua_newtable(L);

        /* The geometry */
        lua_pushstring(L, "geometry");

        lua_newtable(L);

        lua_pushstring(L, "x");
        lua_pushinteger(L, a->x);
        lua_settable(L, -3);
        lua_pushstring(L, "y");
        lua_pushinteger(L, a->y);
        lua_settable(L, -3);
        lua_pushstring(L, "width");
        lua_pushinteger(L, a->width);
        lua_settable(L, -3);
        lua_pushstring(L, "height");
        lua_pushinteger(L, a->height);
        lua_settable(L, -3);

        /* Add the geometry table to the arguments */
        lua_settable(L, -3);

        /* Add the outputs table to the arguments */
        lua_pushstring(L, "outputs");
        luaA_viewport_get_outputs(L, a);
        lua_settable(L, -3);

        /* Add an identifier to better detect when screens are removed */
        lua_pushstring(L, "id");
        lua_pushinteger(L, a->id);
        lua_settable(L, -3);

        lua_rawseti(L, -2, count++);
    } while ((a = a->next));

    return 1;
}

/* Give Lua a chance to handle or blacklist a viewport before creating the
 * screen object.
 */
static void
viewports_notify(lua_State *L)
{
    if (!first_screen_viewport)
        return;

    luaA_viewports(L);

    luaA_class_emit_signal(L, &screen_class, "property::_viewports", 1);
}

static viewport_t *
viewport_add(lua_State *L, int x, int y, int w, int h)
{
    /* Search existing to avoid having to deduplicate later */
    viewport_t *a = first_screen_viewport;


    do
    {
        if (a && a->x == x && a->y == y && a->width == w && a->height == h)
        {
            a->marked = true;
            return a;
        }
    } while (a && (a = a->next));

    viewport_t *node = malloc(sizeof(viewport_t));
    node->x      = x;
    node->y      = y;
    node->width  = w;
    node->height = h;
    node->id     = screen_area_gid++;
    node->next   = NULL;
    node->screen = NULL;
    node->marked = true;

    screen_output_array_init(&node->outputs);

    if (!first_screen_viewport) {
        first_screen_viewport = node;
        last_screen_viewport  = node;
    } else {
        last_screen_viewport->next = node;
        last_screen_viewport       = node;
    }

    assert(first_screen_viewport && last_screen_viewport);

    return node;
}

static void
monitor_unmark(void)
{
    viewport_t *a = first_screen_viewport;

    if (!a)
        return;

    do
    {
        a->marked = false;
    } while((a = a->next));
}


static void
viewport_purge(void)
{
    viewport_t *cur = first_screen_viewport;

    /* Move the head of the list */
    while (first_screen_viewport && !first_screen_viewport->marked) {
        cur = first_screen_viewport;
        first_screen_viewport = cur->next;

        foreach(existing_screen, globalconf.screens)
            if ((*existing_screen)->viewport == cur)
                (*existing_screen)->viewport = NULL;

        screen_output_array_wipe(&cur->outputs);

        free(cur);
    }

    if (!first_screen_viewport) {
        last_screen_viewport = NULL;
        return;
    }

    cur = first_screen_viewport;

    /* Drop unmarked entries */
    do {
        if (cur->next && !cur->next->marked) {
            viewport_t *tmp = cur->next;
            cur->next = cur->next->next;

            if (tmp == last_screen_viewport)
                last_screen_viewport = cur;

            foreach(existing_screen, globalconf.screens)
                if ((*existing_screen)->viewport == tmp)
                    (*existing_screen)->viewport = NULL;

            screen_output_array_wipe(&tmp->outputs);

            free(tmp);
        } else
            cur = cur->next;

    } while(cur);
}

static screen_t *
screen_add(lua_State *L, screen_array_t *screens)
{
    screen_t *new_screen = screen_new(L);
    luaA_object_ref(L, -1);
    screen_array_append(screens, new_screen);
    new_screen->xid = XCB_NONE;
    new_screen->lifecycle = SCREEN_LIFECYCLE_USER;
    return new_screen;
}

/* Monitors were introduced in RandR 1.5 */
#ifdef XCB_RANDR_GET_MONITORS

static screen_output_t
screen_get_randr_output(lua_State *L, xcb_randr_monitor_info_iterator_t *it)
{
    screen_output_t output;
    xcb_randr_output_t *randr_outputs;
    xcb_get_atom_name_cookie_t name_c;
    xcb_get_atom_name_reply_t *name_r;

    output.mm_width  = it->data->width_in_millimeters;
    output.mm_height = it->data->height_in_millimeters;

    name_c = xcb_get_atom_name_unchecked(globalconf.connection, it->data->name);
    name_r = xcb_get_atom_name_reply(globalconf.connection, name_c, NULL);

    if (name_r) {
        const char *name = xcb_get_atom_name_name(name_r);
        size_t len = xcb_get_atom_name_name_length(name_r);

        output.name = memcpy(p_new(char *, len + 1), name, len);
        output.name[len] = '\0';
        p_delete(&name_r);
    } else {
        output.name = a_strdup("unknown");
    }

    randr_output_array_init(&output.outputs);

    randr_outputs = xcb_randr_monitor_info_outputs(it->data);

    for(int i = 0; i < xcb_randr_monitor_info_outputs_length(it->data); i++) {
        randr_output_array_append(&output.outputs, randr_outputs[i]);
    }

    return output;
}

static void
screen_scan_randr_monitors(lua_State *L, screen_array_t *screens)
{
    xcb_randr_get_monitors_cookie_t monitors_c = xcb_randr_get_monitors(globalconf.connection, globalconf.screen->root, 1);
    xcb_randr_get_monitors_reply_t *monitors_r = xcb_randr_get_monitors_reply(globalconf.connection, monitors_c, NULL);
    xcb_randr_monitor_info_iterator_t monitor_iter;

    if (monitors_r == NULL) {
        warn("RANDR GetMonitors failed; this should not be possible");
        return;
    }

    for(monitor_iter = xcb_randr_get_monitors_monitors_iterator(monitors_r);
            monitor_iter.rem; xcb_randr_monitor_info_next(&monitor_iter))
    {
        screen_t *new_screen;

        if(!xcb_randr_monitor_info_outputs_length(monitor_iter.data))
            continue;

        screen_output_t output = screen_get_randr_output(L, &monitor_iter);

        viewport_t *viewport = viewport_add(L,
            monitor_iter.data->x,
            monitor_iter.data->y,
            monitor_iter.data->width,
            monitor_iter.data->height
        );

        screen_output_array_append(&viewport->outputs, output);

        if (globalconf.ignore_screens)
            continue;

        new_screen = screen_add(L, screens);
        new_screen->lifecycle |= SCREEN_LIFECYCLE_C;
        viewport->screen = new_screen;
        new_screen->viewport = viewport;
        new_screen->geometry.x = monitor_iter.data->x;
        new_screen->geometry.y = monitor_iter.data->y;
        new_screen->geometry.width = monitor_iter.data->width;
        new_screen->geometry.height = monitor_iter.data->height;
        new_screen->xid = monitor_iter.data->name;
    }

    p_delete(&monitors_r);
}
#else
static void
screen_scan_randr_monitors(lua_State *L, screen_array_t *screens)
{
}
#endif

static void
screen_get_randr_crtcs_outputs(lua_State *L, xcb_randr_get_crtc_info_reply_t *crtc_info_r, screen_output_array_t *outputs)
{
    xcb_randr_output_t *randr_outputs = xcb_randr_get_crtc_info_outputs(crtc_info_r);

    for(int j = 0; j < xcb_randr_get_crtc_info_outputs_length(crtc_info_r); j++)
    {
        xcb_randr_get_output_info_cookie_t output_info_c = xcb_randr_get_output_info(globalconf.connection, randr_outputs[j], XCB_CURRENT_TIME);
        xcb_randr_get_output_info_reply_t *output_info_r = xcb_randr_get_output_info_reply(globalconf.connection, output_info_c, NULL);
        screen_output_t output;

        if (!output_info_r) {
            warn("RANDR GetOutputInfo failed; this should not be possible");
            continue;
        }

        int len = xcb_randr_get_output_info_name_length(output_info_r);
        /* name is not NULL terminated */
        char *name = memcpy(p_new(char *, len + 1), xcb_randr_get_output_info_name(output_info_r), len);
        name[len] = '\0';

        output.name = name;
        output.mm_width = output_info_r->mm_width;
        output.mm_height = output_info_r->mm_height;
        randr_output_array_init(&output.outputs);
        randr_output_array_append(&output.outputs, randr_outputs[j]);

        screen_output_array_append(outputs, output);

        p_delete(&output_info_r);
    }
}

static void
screen_scan_randr_crtcs(lua_State *L, screen_array_t *screens)
{
    /* A quick XRandR recall:
     * You have CRTC that manages a part of a SCREEN.
     * Each CRTC can draw stuff on one or more OUTPUT. */
    xcb_randr_get_screen_resources_cookie_t screen_res_c = xcb_randr_get_screen_resources(globalconf.connection, globalconf.screen->root);
    xcb_randr_get_screen_resources_reply_t *screen_res_r = xcb_randr_get_screen_resources_reply(globalconf.connection, screen_res_c, NULL);

    if (screen_res_r == NULL) {
        warn("RANDR GetScreenResources failed; this should not be possible");
        return;
    }

    /* We go through CRTC, and build a screen for each one. */
    xcb_randr_crtc_t *randr_crtcs = xcb_randr_get_screen_resources_crtcs(screen_res_r);

    for(int i = 0; i < screen_res_r->num_crtcs; i++)
    {
        /* Get info on the output crtc */
        xcb_randr_get_crtc_info_cookie_t crtc_info_c = xcb_randr_get_crtc_info(globalconf.connection, randr_crtcs[i], XCB_CURRENT_TIME);
        xcb_randr_get_crtc_info_reply_t *crtc_info_r = xcb_randr_get_crtc_info_reply(globalconf.connection, crtc_info_c, NULL);

        if(!crtc_info_r) {
            warn("RANDR GetCRTCInfo failed; this should not be possible");
            continue;
        }

        /* If CRTC has no OUTPUT, ignore it */
        if(!xcb_randr_get_crtc_info_outputs_length(crtc_info_r))
            continue;

        viewport_t *viewport = viewport_add(L,
            crtc_info_r->x,
            crtc_info_r->y,
            crtc_info_r->width,
            crtc_info_r->height
        );

        screen_get_randr_crtcs_outputs(L, crtc_info_r, &viewport->outputs);

        if (globalconf.ignore_screens)
        {
            p_delete(&crtc_info_r);
            continue;
        }

        /* Prepare the new screen */
        screen_t *new_screen = screen_add(L, screens);
        new_screen->lifecycle |= SCREEN_LIFECYCLE_C;
        viewport->screen = new_screen;
        new_screen->viewport = viewport;
        new_screen->geometry.x = crtc_info_r->x;
        new_screen->geometry.y = crtc_info_r->y;
        new_screen->geometry.width= crtc_info_r->width;
        new_screen->geometry.height= crtc_info_r->height;
        new_screen->xid = randr_crtcs[i];

        /* Detect the older NVIDIA blobs */
        foreach(output, new_screen->viewport->outputs) {
            if (A_STREQ(output->name, "default")) {
                /* non RandR 1.2+ X driver don't return any usable multihead
                 * data. I'm looking at you, nvidia binary blob!
                 */
                warn("Ignoring RandR, only a compatibility layer is present.");

                /* Get rid of the screens that we already created */
                foreach(screen, *screens)
                    luaA_object_unref(L, *screen);

                screen_array_wipe(screens);
                screen_array_init(screens);

                p_delete(&screen_res_r);

                return;
            }
        }

        p_delete(&crtc_info_r);
    }

    p_delete(&screen_res_r);
}

static void
screen_scan_randr(lua_State *L, screen_array_t *screens)
{
    const xcb_query_extension_reply_t *extension_reply;
    xcb_randr_query_version_reply_t *version_reply;
    uint32_t major_version;
    uint32_t minor_version;

    /* Check for extension before checking for XRandR */
    extension_reply = xcb_get_extension_data(globalconf.connection, &xcb_randr_id);
    if(!extension_reply || !extension_reply->present)
        return;

    version_reply =
        xcb_randr_query_version_reply(globalconf.connection,
                                      xcb_randr_query_version(globalconf.connection, 1, 5), 0);
    if(!version_reply)
        return;


    major_version = version_reply->major_version;
    minor_version = version_reply->minor_version;
    p_delete(&version_reply);

    /* Do we agree on a supported version? */
    if (major_version != 1 || minor_version < 2)
        return;

    globalconf.have_randr_13 = minor_version >= 3;
#if XCB_RANDR_MAJOR_VERSION > 1 || XCB_RANDR_MINOR_VERSION >= 5
    globalconf.have_randr_15 = minor_version >= 5;
#else
    globalconf.have_randr_15 = false;
#endif

    /* We want to know when something changes */
    xcb_randr_select_input(globalconf.connection,
                           globalconf.screen->root,
                           XCB_RANDR_NOTIFY_MASK_OUTPUT_CHANGE);

    if (globalconf.have_randr_15)
        screen_scan_randr_monitors(L, screens);
    else
        screen_scan_randr_crtcs(L, screens);

    if (screens->len == 0 && !globalconf.ignore_screens)
    {
        /* Scanning failed, disable randr again */
        xcb_randr_select_input(globalconf.connection,
                               globalconf.screen->root,
                               0);
        globalconf.have_randr_13 = false;
        globalconf.have_randr_15 = false;
    }
}

static void
screen_scan_xinerama(lua_State *L, screen_array_t *screens)
{
    bool xinerama_is_active;
    const xcb_query_extension_reply_t *extension_reply;
    xcb_xinerama_is_active_reply_t *xia;
    xcb_xinerama_query_screens_reply_t *xsq;
    xcb_xinerama_screen_info_t *xsi;
    int xinerama_screen_number;

    /* Check for extension before checking for Xinerama */
    extension_reply = xcb_get_extension_data(globalconf.connection, &xcb_xinerama_id);
    if(!extension_reply || !extension_reply->present)
        return;

    xia = xcb_xinerama_is_active_reply(globalconf.connection, xcb_xinerama_is_active(globalconf.connection), NULL);
    xinerama_is_active = xia && xia->state;
    p_delete(&xia);
    if(!xinerama_is_active)
        return;

    xsq = xcb_xinerama_query_screens_reply(globalconf.connection,
                                           xcb_xinerama_query_screens_unchecked(globalconf.connection),
                                           NULL);

    if(!xsq) {
        warn("Xinerama QueryScreens failed; this should not be possible");
        return;
    }

    xsi = xcb_xinerama_query_screens_screen_info(xsq);
    xinerama_screen_number = xcb_xinerama_query_screens_screen_info_length(xsq);

    for(int screen = 0; screen < xinerama_screen_number; screen++)
    {
        viewport_t *viewport = viewport_add(L,
            xsi[screen].x_org,
            xsi[screen].y_org,
            xsi[screen].width,
            xsi[screen].height
        );

        if (globalconf.ignore_screens)
            continue;

        screen_t *s = screen_add(L, screens);
        viewport->screen = s;
        s->viewport = viewport;
        s->lifecycle |= SCREEN_LIFECYCLE_C;
        s->geometry.x = xsi[screen].x_org;
        s->geometry.y = xsi[screen].y_org;
        s->geometry.width = xsi[screen].width;
        s->geometry.height = xsi[screen].height;
    }

    p_delete(&xsq);
}

static void screen_scan_x11(lua_State *L, screen_array_t *screens)
{
    xcb_screen_t *xcb_screen = globalconf.screen;

    viewport_t *viewport = viewport_add(L,
        0,
        0,
        xcb_screen->width_in_pixels,
        xcb_screen->height_in_pixels
    );

    if (globalconf.ignore_screens)
        return;

    screen_t *s = screen_add(L, screens);
    viewport->screen = s;
    s->lifecycle |= SCREEN_LIFECYCLE_C;
    s->viewport = viewport;
    s->geometry.x = 0;
    s->geometry.y = 0;
    s->geometry.width = xcb_screen->width_in_pixels;
    s->geometry.height = xcb_screen->height_in_pixels;
}

static void
screen_added(lua_State *L, screen_t *screen)
{
    screen->workarea = screen->geometry;
    screen->valid = true;
    luaA_object_push(L, screen);
    luaA_object_emit_signal(L, -1, "added", 0);
    lua_pop(L, 1);
}

void
screen_emit_scanned(void)
{
    lua_State *L = globalconf_get_lua_State();
    luaA_class_emit_signal(L, &screen_class, "scanned", 0);
}

void
screen_emit_scanning(void)
{
    lua_State *L = globalconf_get_lua_State();
    luaA_class_emit_signal(L, &screen_class, "scanning", 0);
}

static void
screen_scan_common(bool quiet)
{
    lua_State *L;

    L = globalconf_get_lua_State();

    monitor_unmark();

    screen_scan_randr(L, &globalconf.screens);
    if (globalconf.screens.len == 0)
        screen_scan_xinerama(L, &globalconf.screens);
    if (globalconf.screens.len == 0)
        screen_scan_x11(L, &globalconf.screens);

    check(globalconf.screens.len > 0 || globalconf.ignore_screens);

    screen_deduplicate(L, &globalconf.screens);

    foreach(screen, globalconf.screens) {
        screen_added(L, *screen);
    }

    viewport_purge();

    if (!quiet)
        viewports_notify(L);

    screen_update_primary();
}

/** Get screens informations and fill global configuration.
 */
void
screen_scan(void)
{
    screen_emit_scanning();
    screen_scan_common(false);
}

static int
luaA_scan_quiet(lua_State *L)
{
    screen_scan_common(true);
    return 0;
}

/* Called when a screen is removed, removes references to the old screen */
static void
screen_removed(lua_State *L, int sidx)
{
    screen_t *screen = luaA_checkudata(L, sidx, &screen_class);

    luaA_object_emit_signal(L, sidx, "removed", 0);

    if (globalconf.primary_screen == screen)
        globalconf.primary_screen = NULL;

    foreach(c, globalconf.clients) {
        if((*c)->screen == screen)
            screen_client_moveto(*c, screen_getbycoord(
                        (*c)->geometry.x, (*c)->geometry.y), false);
    }
}

void screen_cleanup(void)
{
    while(globalconf.screens.len)
        screen_array_take(&globalconf.screens, 0);

    monitor_unmark();
    viewport_purge();
}

static void
screen_modified(screen_t *existing_screen, screen_t *other_screen)
{
    lua_State *L = globalconf_get_lua_State();

    if(!AREA_EQUAL(existing_screen->geometry, other_screen->geometry)) {
        area_t old_geometry = existing_screen->geometry;
        existing_screen->geometry = other_screen->geometry;
        luaA_object_push(L, existing_screen);
        luaA_pusharea(L, old_geometry);
        luaA_object_emit_signal(L, -2, "property::geometry", 1);
        lua_pop(L, 1);
        screen_update_workarea(existing_screen);
    }

    const int other_len = other_screen->viewport ?
        other_screen->viewport->outputs.len : 0;

    const int existing_len = existing_screen->viewport ?
        existing_screen->viewport->outputs.len : 0;

    bool outputs_changed = (!(existing_screen->viewport && other_screen->viewport))
        || existing_len != other_len;

    if(existing_screen->viewport && other_screen->viewport && !outputs_changed)
        for(int i = 0; i < existing_screen->viewport->outputs.len; i++) {
            screen_output_t *existing_output = &existing_screen->viewport->outputs.tab[i];
            screen_output_t *other_output = &other_screen->viewport->outputs.tab[i];
            outputs_changed |= existing_output->mm_width != other_output->mm_width;
            outputs_changed |= existing_output->mm_height != other_output->mm_height;
            outputs_changed |= A_STRNEQ(existing_output->name, other_output->name);
        }

    /* Brute-force update the outputs by swapping */
    if(existing_screen->viewport || other_screen->viewport) {
        viewport_t *tmp = other_screen->viewport;
        other_screen->viewport = existing_screen->viewport;

        existing_screen->viewport = tmp;

        if(outputs_changed) {
            luaA_object_push(L, existing_screen);
            luaA_object_emit_signal(L, -1, "property::_outputs", 0);
            lua_pop(L, 1);
        }
    }
}

static gboolean
screen_refresh(gpointer unused)
{
    globalconf.screen_refresh_pending = false;

    monitor_unmark();

    screen_array_t new_screens;
    screen_array_t removed_screens;
    lua_State *L = globalconf_get_lua_State();
    bool list_changed = false;

    screen_array_init(&new_screens);
    if (globalconf.have_randr_15)
        screen_scan_randr_monitors(L, &new_screens);
    else
        screen_scan_randr_crtcs(L, &new_screens);

    viewport_purge();

    viewports_notify(L);

    screen_deduplicate(L, &new_screens);

    /* Running without any screens at all is no fun. */
    if (new_screens.len == 0)
        screen_scan_x11(L, &new_screens);

    /* Add new screens */
    foreach(new_screen, new_screens) {
        bool found = false;
        foreach(old_screen, globalconf.screens)
            found |= (*new_screen)->xid == (*old_screen)->xid;
        if(!found) {
            screen_array_append(&globalconf.screens, *new_screen);
            screen_added(L, *new_screen);
            /* Get an extra reference since both new_screens and
             * globalconf.screens reference this screen now */
            luaA_object_push(L, *new_screen);
            luaA_object_ref(L, -1);

            list_changed = true;
        }
    }

    /* Remove screens which are gone */
    screen_array_init(&removed_screens);
    for(int i = 0; i < globalconf.screens.len; i++) {
        screen_t *old_screen = globalconf.screens.tab[i];
        bool found = old_screen->xid == FAKE_SCREEN_XID;

        foreach(new_screen, new_screens)
            found |= (*new_screen)->xid == old_screen->xid;

        if(old_screen->lifecycle & SCREEN_LIFECYCLE_C && !found) {
            screen_array_take(&globalconf.screens, i);
            i--;

            screen_array_append(&removed_screens, old_screen);
            list_changed = true;
        }
    }
    foreach(old_screen, removed_screens) {
        luaA_object_push(L, *old_screen);
        screen_removed(L, -1);
        lua_pop(L, 1);
        (*old_screen)->valid = false;
        luaA_object_unref(L, *old_screen);
    }
    screen_array_wipe(&removed_screens);

    /* Update changed screens */
    foreach(existing_screen, globalconf.screens)
        foreach(new_screen, new_screens)
            if((*existing_screen)->xid == (*new_screen)->xid)
                screen_modified(*existing_screen, *new_screen);

    foreach(screen, new_screens)
        luaA_object_unref(L, *screen);
    screen_array_wipe(&new_screens);

    screen_update_primary();

    if (list_changed)
        luaA_class_emit_signal(L, &screen_class, "list", 0);

    return G_SOURCE_REMOVE;
}

void
screen_schedule_refresh(void)
{
    if(globalconf.screen_refresh_pending || !globalconf.have_randr_13)
        return;

    globalconf.screen_refresh_pending = true;
    g_idle_add_full(G_PRIORITY_LOW, screen_refresh, NULL, NULL);
}

/** Return the squared distance of the given screen to the coordinates.
 * \param screen The screen
 * \param x X coordinate
 * \param y Y coordinate
 * \return Squared distance of the point to the screen.
 */
static unsigned int
screen_get_distance_squared(screen_t *s, int x, int y)
{
    int sx = s->geometry.x, sy = s->geometry.y;
    int sheight = s->geometry.height, swidth = s->geometry.width;
    unsigned int dist_x, dist_y;

    /* Calculate distance in X coordinate */
    if (x < sx)
        dist_x = sx - x;
    else if (x < sx + swidth)
        dist_x = 0;
    else
        dist_x = x - sx - swidth;

    /* Calculate distance in Y coordinate */
    if (y < sy)
        dist_y = sy - y;
    else if (y < sy + sheight)
        dist_y = 0;
    else
        dist_y = y - sy - sheight;

    return dist_x * dist_x + dist_y * dist_y;
}

/** Return the first screen number where the coordinates belong to.
 * \param x X coordinate
 * \param y Y coordinate
 * \return Screen pointer or screen param if no match or no multi-head.
 */
screen_t *
screen_getbycoord(int x, int y)
{
    foreach(s, globalconf.screens)
        if(screen_coord_in_screen(*s, x, y))
            return *s;

    /* No screen found, find nearest screen. */
    screen_t *nearest_screen = NULL;
    unsigned int nearest_dist = UINT_MAX;
    foreach(s, globalconf.screens)
    {
        unsigned int dist_sq = screen_get_distance_squared(*s, x, y);
        if(dist_sq < nearest_dist)
        {
            nearest_dist = dist_sq;
            nearest_screen = *s;
        }
    }
    return nearest_screen;
}

/** Are the given coordinates in a given screen?
 * \param screen The logical screen number.
 * \param x X coordinate
 * \param y Y coordinate
 * \return True if the X/Y coordinates are in the given screen.
 */
bool
screen_coord_in_screen(screen_t *s, int x, int y)
{
    return (x >= s->geometry.x && x < s->geometry.x + s->geometry.width)
           && (y >= s->geometry.y && y < s->geometry.y + s->geometry.height);
}

/** Is there any overlap between the given geometry and a given screen?
 * \param screen The logical screen number.
 * \param geom The geometry
 * \return True if there is any overlap between the geometry and a given screen.
 */
bool
screen_area_in_screen(screen_t *s, area_t geom)
{
    return (geom.x < s->geometry.x + s->geometry.width)
            && (geom.x + geom.width > s->geometry.x )
            && (geom.y < s->geometry.y + s->geometry.height)
            && (geom.y + geom.height > s->geometry.y);
}

void screen_update_workarea(screen_t *screen)
{
    area_t area = screen->geometry;
    uint16_t top = 0, bottom = 0, left = 0, right = 0;

#define COMPUTE_STRUT(o) \
    { \
        if((o)->strut.top_start_x || (o)->strut.top_end_x || (o)->strut.top) \
        { \
            if((o)->strut.top) \
                top = MAX(top, (o)->strut.top); \
            else \
                top = MAX(top, ((o)->geometry.y - area.y) + (o)->geometry.height); \
        } \
        if((o)->strut.bottom_start_x || (o)->strut.bottom_end_x || (o)->strut.bottom) \
        { \
            if((o)->strut.bottom) \
                bottom = MAX(bottom, (o)->strut.bottom); \
            else \
                bottom = MAX(bottom, (area.y + area.height) - (o)->geometry.y); \
        } \
        if((o)->strut.left_start_y || (o)->strut.left_end_y || (o)->strut.left) \
        { \
            if((o)->strut.left) \
                left = MAX(left, (o)->strut.left); \
            else \
                left = MAX(left, ((o)->geometry.x - area.x) + (o)->geometry.width); \
        } \
        if((o)->strut.right_start_y || (o)->strut.right_end_y || (o)->strut.right) \
        { \
            if((o)->strut.right) \
                right = MAX(right, (o)->strut.right); \
            else \
                right = MAX(right, (area.x + area.width) - (o)->geometry.x); \
        } \
    }

    foreach(c, globalconf.clients)
        if((*c)->screen == screen && client_isvisible(*c))
            COMPUTE_STRUT(*c)

    foreach(drawin, globalconf.drawins)
        if((*drawin)->visible)
        {
            screen_t *d_screen =
                screen_getbycoord((*drawin)->geometry.x, (*drawin)->geometry.y);
            if (d_screen == screen)
                COMPUTE_STRUT(*drawin)
        }

#undef COMPUTE_STRUT

    area.x += left;
    area.y += top;
    area.width -= MIN(area.width, left + right);
    area.height -= MIN(area.height, top + bottom);

    if (AREA_EQUAL(area, screen->workarea))
        return;

    area_t old_workarea = screen->workarea;
    screen->workarea = area;
    lua_State *L = globalconf_get_lua_State();
    luaA_object_push(L, screen);
    luaA_pusharea(L, old_workarea);
    luaA_object_emit_signal(L, -2, "property::workarea", 1);
    lua_pop(L, 1);
}

/** Move a client to a virtual screen.
 * \param c The client to move.
 * \param new_screen The destination screen.
 * \param doresize Set to true if we also move the client to the new x and
 *        y of the new screen.
 */
void
screen_client_moveto(client_t *c, screen_t *new_screen, bool doresize)
{
    lua_State *L = globalconf_get_lua_State();
    screen_t *old_screen = c->screen;
    area_t from, to;
    bool had_focus = false;

    if(new_screen == c->screen)
        return;

    if (globalconf.focus.client == c)
        had_focus = true;

    c->screen = new_screen;

    if(!doresize)
    {
        luaA_object_push(L, c);
        if(old_screen != NULL)
            luaA_object_push(L, old_screen);
        else
            lua_pushnil(L);
        luaA_object_emit_signal(L, -2, "property::screen", 1);
        lua_pop(L, 1);
        if(had_focus)
            client_focus(c);
        return;
    }

    from = old_screen->geometry;
    to = c->screen->geometry;

    area_t new_geometry = c->geometry;

    new_geometry.x = to.x + new_geometry.x - from.x;
    new_geometry.y = to.y + new_geometry.y - from.y;

    /* resize the client if it doesn't fit the new screen */
    if(new_geometry.width > to.width)
        new_geometry.width = to.width;
    if(new_geometry.height > to.height)
        new_geometry.height = to.height;

    /* make sure the client is still on the screen */
    if(new_geometry.x + new_geometry.width > to.x + to.width)
        new_geometry.x = to.x + to.width - new_geometry.width;
    if(new_geometry.y + new_geometry.height > to.y + to.height)
        new_geometry.y = to.y + to.height - new_geometry.height;
    if(!screen_area_in_screen(new_screen, new_geometry))
    {
        /* If all else fails, force the client to end up on screen. */
        new_geometry.x = to.x;
        new_geometry.y = to.y;
    }

    /* move / resize the client */
    client_resize(c, new_geometry, false);

    /* emit signal */
    luaA_object_push(L, c);
    if(old_screen != NULL)
        luaA_object_push(L, old_screen);
    else
        lua_pushnil(L);
    luaA_object_emit_signal(L, -2, "property::screen", 1);
    lua_pop(L, 1);

    if(had_focus)
        client_focus(c);
}

/** Get a screen's index. */
int
screen_get_index(screen_t *s)
{
    int res = 0;
    foreach(screen, globalconf.screens)
    {
        res++;
        if (*screen == s)
            return res;
    }

    return 0;
}

void
screen_update_primary(void)
{
    if (!globalconf.have_randr_13)
        return;

    screen_t *primary_screen = NULL;
    xcb_randr_get_output_primary_reply_t *primary =
        xcb_randr_get_output_primary_reply(globalconf.connection,
                xcb_randr_get_output_primary(globalconf.connection, globalconf.screen->root),
                NULL);

    if (!primary)
        return;

    foreach(screen, globalconf.screens)
    {
        if ((*screen)->viewport)
            foreach(output, (*screen)->viewport->outputs)
                foreach (randr_output, output->outputs)
                    if (*randr_output == primary->output)
                        primary_screen = *screen;
    }
    p_delete(&primary);

    if (!primary_screen || primary_screen == globalconf.primary_screen)
        return;

    lua_State *L = globalconf_get_lua_State();
    screen_t *old = globalconf.primary_screen;
    globalconf.primary_screen = primary_screen;

    if (old)
    {
        luaA_object_push(L, old);
        luaA_object_emit_signal(L, -1, "primary_changed", 0);
        lua_pop(L, 1);
    }
    luaA_object_push(L, primary_screen);
    luaA_object_emit_signal(L, -1, "primary_changed", 0);
    lua_pop(L, 1);
}

screen_t *
screen_get_primary(void)
{
    if (!globalconf.primary_screen && globalconf.screens.len > 0)
    {
        globalconf.primary_screen = globalconf.screens.tab[0];

        lua_State *L = globalconf_get_lua_State();
        luaA_object_push(L, globalconf.primary_screen);
        luaA_object_emit_signal(L, -1, "primary_changed", 0);
        lua_pop(L, 1);
    }
    return globalconf.primary_screen;
}

/** Screen module.
 * \param L The Lua VM state.
 * \return The number of elements pushed on stack.
 * \luastack
 * \lfield number The screen number, to get a screen.
 */
static int
luaA_screen_module_index(lua_State *L)
{
    const char *name;

    if(lua_type(L, 2) == LUA_TSTRING && (name = lua_tostring(L, 2)))
    {
        if(A_STREQ(name, "primary"))
            return luaA_object_push(L, screen_get_primary());
        else if (A_STREQ(name, "automatic_factory"))
        {
            lua_pushboolean(L, !globalconf.ignore_screens);
            return 1;
        }

        foreach(screen, globalconf.screens)
            if ((*screen)->viewport)
                foreach(output, (*screen)->viewport->outputs)
                    if(A_STREQ(output->name, name))
                        return luaA_object_push(L, *screen);

        luaA_warn(L, "Unknown screen output name: %s", name);
        lua_pushnil(L);
        return 1;
    }

    return luaA_object_push(L, luaA_checkscreen(L, 2));
}

static int
luaA_screen_module_newindex(lua_State *L)
{
    const char *buf = luaL_checkstring(L, 2);

    if (A_STREQ(buf, "automatic_factory"))
    {
        globalconf.ignore_screens = !luaA_checkboolean(L, 3);

        /* It *can* be useful if screens are added/removed later, but generally,
         * setting this should be done before screens are added
         */
        if (globalconf.ignore_screens && !globalconf.no_auto_screen)
            luaA_warn(L,
                "Setting automatic_factory only makes sense when AwesomeWM is"
                " started with `--screen off`"
            );
    }

    return luaA_default_newindex(L);
}

/** Iterate over screens.
 * @usage
 * for s in screen do
 *     print("Oh, wow, we have screen " .. tostring(s))
 * end
 * @staticfct screen
 */
static int
luaA_screen_module_call(lua_State *L)
{
    int idx;

    if (lua_isnoneornil(L, 3))
        idx = 0;
    else
        idx = screen_get_index(luaA_checkscreen(L, 3));
    if (idx >= 0 && idx < globalconf.screens.len)
        /* No +1 needed, index starts at 1, C array at 0 */
        luaA_object_push(L, globalconf.screens.tab[idx]);
    else
        lua_pushnil(L);
    return 1;
}

LUA_OBJECT_EXPORT_PROPERTY(screen, screen_t, geometry, luaA_pusharea)

static int
luaA_screen_get_index(lua_State *L, screen_t *s)
{
    lua_pushinteger(L, screen_get_index(s));
    return 1;
}

static int
luaA_screen_get_outputs(lua_State *L, screen_t *s)
{
    luaA_viewport_get_outputs(L, s->viewport);

    /* The table of tables we created. */
    return 1;
}

static int
luaA_screen_get_managed(lua_State *L, screen_t *s)
{
    if (s->lifecycle & SCREEN_LIFECYCLE_LUA)
        lua_pushstring(L, "Lua");
    else if (s->lifecycle & SCREEN_LIFECYCLE_C)
        lua_pushstring(L, "C");
    else
        lua_pushstring(L, "none");

    return 1;
}

static int
luaA_screen_get_workarea(lua_State *L, screen_t *s)
{
    luaA_pusharea(L, s->workarea);
    return 1;
}

/** Get the number of screens.
 *
 * @return The screen count, at least 1.
 * @staticfct count
 */
static int
luaA_screen_count(lua_State *L)
{
    lua_pushinteger(L, globalconf.screens.len);
    return 1;
}

/** Add a fake screen.
 *
 * To vertically split the first screen in 2 equal parts, use:
 *
 *    local geo = screen[1].geometry
 *    local new_width = math.ceil(geo.width/2)
 *    local new_width2 = geo.width - new_width
 *    screen[1]:fake_resize(geo.x, geo.y, new_width, geo.height)
 *    screen.fake_add(geo.x + new_width, geo.y, new_width2, geo.height)
 *
 * Both virtual screens will have their own taglist and wibars.
 *
 * @tparam integer x X-coordinate for screen.
 * @tparam integer y Y-coordinate for screen.
 * @tparam integer width width for screen.
 * @tparam integer height height for screen.
 * @return The new screen.
 * @constructorfct fake_add
 */
static int
luaA_screen_fake_add(lua_State *L)
{
    int x = luaL_checkinteger(L, 1);
    int y = luaL_checkinteger(L, 2);
    int width = luaL_checkinteger(L, 3);
    int height = luaL_checkinteger(L, 4);

    /* If the screen is managed by internal Lua code */
    bool managed = false;

    /* Allow undocumented arguments for internal use only */
    if(lua_istable(L, 5)) {
        lua_getfield(L, 5, "_managed");
        managed = lua_isboolean(L, 6) && luaA_checkboolean(L, 6);

        lua_pop(L, 1);
    }

    screen_t *s;

    s = screen_add(L, &globalconf.screens);
    s->lifecycle |= managed ? SCREEN_LIFECYCLE_LUA : SCREEN_LIFECYCLE_USER;
    s->geometry.x = x;
    s->geometry.y = y;
    s->geometry.width = width;
    s->geometry.height = height;
    s->xid = FAKE_SCREEN_XID;

    screen_added(L, s);
    luaA_class_emit_signal(L, &screen_class, "list", 0);
    luaA_object_push(L, s);

    foreach(c, globalconf.clients) {
        screen_client_moveto(*c, screen_getbycoord(
                    (*c)->geometry.x, (*c)->geometry.y), false);
    }

    return 1;
}

/** Remove a screen.
 * @method fake_remove
 */
static int
luaA_screen_fake_remove(lua_State *L)
{
    screen_t *s = luaA_checkudata(L, 1, &screen_class);
    int idx = screen_get_index(s) - 1;
    if (idx < 0)
        /* WTF? */
        return 0;

    if (globalconf.screens.len == 1) {
        luaA_warn(L, "Removing last screen through fake_remove(). "
                "This is a very, very, very bad idea!");
    }

    screen_array_take(&globalconf.screens, idx);
    luaA_object_push(L, s);
    screen_removed(L, -1);
    lua_pop(L, 1);
    luaA_class_emit_signal(L, &screen_class, "list", 0);
    luaA_object_unref(L, s);
    s->valid = false;

    return 0;
}

/** Fake-resize a screen
 * @tparam integer x The new X-coordinate for screen.
 * @tparam integer y The new Y-coordinate for screen.
 * @tparam integer width The new width for screen.
 * @tparam integer height The new height for screen.
 * @method fake_resize
 */
static int
luaA_screen_fake_resize(lua_State *L)
{
    screen_t *screen = luaA_checkudata(L, 1, &screen_class);
    int x = luaL_checkinteger(L, 2);
    int y = luaL_checkinteger(L, 3);
    int width = luaL_checkinteger(L, 4);
    int height = luaL_checkinteger(L, 5);
    area_t old_geometry = screen->geometry;

    screen->geometry.x = x;
    screen->geometry.y = y;
    screen->geometry.width = width;
    screen->geometry.height = height;

    screen_update_workarea(screen);

    luaA_pusharea(L, old_geometry);
    luaA_object_emit_signal(L, 1, "property::geometry", 1);

    /* Note: calling `screen_client_moveto` from here will create more issues
     * than it would fix. Keep in mind that it means `c.screen` will be wrong
     * until Lua it `fake_add` fixes it.
     */

    return 0;
}

/** Swap a screen with another one in global screen list.
 * @client s A screen to swap with.
 * @method swap
 */
static int
luaA_screen_swap(lua_State *L)
{
    screen_t *s = luaA_checkudata(L, 1, &screen_class);
    screen_t *swap = luaA_checkudata(L, 2, &screen_class);

    if(s != swap)
    {
        screen_t **ref_s = NULL, **ref_swap = NULL;
        foreach(item, globalconf.screens)
        {
            if(*item == s)
                ref_s = item;
            else if(*item == swap)
                ref_swap = item;
            if(ref_s && ref_swap)
                break;
        }
        if(!ref_s || !ref_swap)
            return luaL_error(L, "Invalid call to screen:swap()");

        /* swap ! */
        *ref_s = swap;
        *ref_swap = s;

        luaA_class_emit_signal(L, &screen_class, "list", 0);

        luaA_object_push(L, swap);
        lua_pushboolean(L, true);
        luaA_object_emit_signal(L, -4, "swapped", 2);

        luaA_object_push(L, swap);
        luaA_object_push(L, s);
        lua_pushboolean(L, false);
        luaA_object_emit_signal(L, -3, "swapped", 2);
    }

    return 0;
}

void
screen_class_setup(lua_State *L)
{
    static const struct luaL_Reg screen_methods[] =
    {
        LUA_CLASS_METHODS(screen)
        { "count", luaA_screen_count },
        { "_viewports", luaA_viewports },
        { "_scan_quiet", luaA_scan_quiet },
        { "__index", luaA_screen_module_index },
        { "__newindex", luaA_screen_module_newindex },
        { "__call", luaA_screen_module_call },
        { "fake_add", luaA_screen_fake_add },
        { NULL, NULL }
    };

    static const struct luaL_Reg screen_meta[] =
    {
        LUA_OBJECT_META(screen)
        LUA_CLASS_META
        { "fake_remove", luaA_screen_fake_remove },
        { "fake_resize", luaA_screen_fake_resize },
        { "swap", luaA_screen_swap },
        { NULL, NULL },
    };

    luaA_class_setup(L, &screen_class, "screen", NULL,
                     (lua_class_allocator_t) screen_new,
                     (lua_class_collector_t) NULL,
                     (lua_class_checker_t) screen_checker,
                     luaA_class_index_miss_property, luaA_class_newindex_miss_property,
                     screen_methods, screen_meta);
    luaA_class_add_property(&screen_class, "geometry",
                            NULL,
                            (lua_class_propfunc_t) luaA_screen_get_geometry,
                            NULL);
    luaA_class_add_property(&screen_class, "index",
                            NULL,
                            (lua_class_propfunc_t) luaA_screen_get_index,
                            NULL);
    luaA_class_add_property(&screen_class, "_outputs",
                            NULL,
                            (lua_class_propfunc_t) luaA_screen_get_outputs,
                            NULL);
    luaA_class_add_property(&screen_class, "_managed",
                            NULL,
                            (lua_class_propfunc_t) luaA_screen_get_managed,
                            NULL);
    luaA_class_add_property(&screen_class, "workarea",
                            NULL,
                            (lua_class_propfunc_t) luaA_screen_get_workarea,
                            NULL);
}

/* @DOC_cobject_COMMON@ */

// vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80