dispswitch/sun-src/dispswitch.c

/*
 * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc.
 * Copyright © 2002 Hewlett Packard Company, Inc.
 * Copyright © 2006 Intel Corporation
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting documentation, and
 * that the name of the copyright holders not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  The copyright holders make no representations
 * about the suitability of this software for any purpose.  It is provided "as
 * is" without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 *
 */

/*
 * Copyright (c) 2009, 2015, Oracle and/or its affiliates. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */


#include <stdio.h>
#include <X11/Xlib.h>
#include <X11/Xlibint.h>
#include <X11/Xproto.h>
#include <X11/extensions/Xrandr.h>
#include <X11/Xos.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/proc.h>
#include <unistd.h>


static char *program_name;
static Display  *dpy = NULL;
static Window   root, win;
static int  screen;
static Bool nosideview = False;
static Bool verbose = False;
static Bool testrun = False;
static int  had_error = 0;
static XErrorHandler    prev_handler;
static int  cur_keycode;
static struct timeval   time_val;
static Rotation init_rotation;
static int  init_x;
static int  init_y;
static Bool use_init_pos = False;
static Bool need_off_deferred = False;

static void
usage(void)
{
    fprintf(stderr, "usage: %s [options]\n", program_name);
    fprintf(stderr, "  where options are:\n");
    fprintf(stderr, "  -toggle or -t\n");
    fprintf(stderr, "  -listen or -l\n");
    fprintf(stderr, "  -display <display> or -d <display>\n");
    fprintf(stderr, "  -key <key> or -k <key>\n");
    fprintf(stderr, "  -mod <modifier> or -m <modifier>\n");
    fprintf(stderr, "  -help\n");
    fprintf(stderr, "  -nosideview\n");
    fprintf(stderr, "  -verbose or -v\n");
    fprintf(stderr, "  -testrun\n");
    exit(1);
    /*NOTREACHED*/
}

static void
fatal (const char *format, ...)
{
    va_list ap;

    va_start (ap, format);
    fprintf (stderr, "%s exiting: ", program_name);
    vfprintf (stderr, format, ap);
    va_end (ap);
    exit (1);
    /*NOTREACHED*/
}

static int
cur_handler (
    Display *const err_display,
    XErrorEvent *const err_event)
{
    had_error = err_event -> error_code;
    return (0);
}

typedef enum _relation {
    left_of, right_of, above, below, same_as,
} relation_t;

typedef enum _changes {
    changes_none = 0,
    changes_crtc = (1 << 0),
    changes_mode = (1 << 1),
    changes_relation = (1 << 2),
    changes_position = (1 << 3),
} changes_t;

typedef enum _name_kind {
    name_none = 0,
    name_string = (1 << 0),
    name_xid = (1 << 1),
    name_index = (1 << 2),
} name_kind_t;

typedef struct {
    name_kind_t     kind;
    char            *string;
    XID             xid;
    int         index;
} name_t;

typedef struct _crtc crtc_t;
typedef struct _output  output_t;

struct _crtc {
    name_t      crtc;
    XRRCrtcInfo     *crtc_info;

    XRRModeInfo     *mode_info;
    int         x;
    int         y;
    Rotation        rotation;
    output_t        **outputs;
    int         noutput;
};

struct _output {
    struct _output  *next;

    changes_t       changes;

    name_t      output;
    XRROutputInfo   *output_info;

    name_t      crtc;
    crtc_t      *crtc_info;
    crtc_t      *current_crtc_info;

    name_t      mode;
    float       refresh;
    XRRModeInfo     *mode_info;

    name_t      addmode;

    relation_t      relation;
    struct _output  *relative_to;

    int         x, y;
    Rotation        rotation;
};

static output_t *outputs = NULL;
static output_t **outputs_tail = &outputs;
static crtc_t   *crtcs = NULL;
static int  num_crtcs;
static XRRScreenResources  *res = NULL;
static int  fb_width = 0, fb_height = 0;
static int  fb_width_mm = 0, fb_height_mm = 0;
static float    dpi = 0.0;
static Bool dryrun = False;
static int  minWidth, maxWidth, minHeight, maxHeight;

#define     MAX_OUTPUT  3
#define     MAX_MODIFIERS   10

typedef struct _con_output  con_output_t;

struct _con_output {
    output_t        *output;
    XRRModeInfo     **smodes;
    int         nsmodes;
    Bool        on;
};

typedef struct _mod_key_table  mod_key_table_t;

struct _mod_key_table {
    char        *modname;
    unsigned int    mod;
};

static  con_output_t    con_outputs[MAX_OUTPUT];
static  con_output_t    dis_con_outputs[MAX_OUTPUT];
static  XRRModeInfo *start_mode[MAX_OUTPUT];
static  XRRModeInfo *new_mode[MAX_OUTPUT];
static  int     start = 0;
static  int ncon;
static  int dis_ncon;
static  Bool    do_not_switch = False;
static  Bool    did_init = False;

static mod_key_table_t  mod_key_table [MAX_MODIFIERS] = {
    {"none",    0},
    {"shift",   ShiftMask},
    {"lock",    LockMask},
    {"control", ControlMask},
    {"mod1",    Mod1Mask},
    {"mod2",    Mod2Mask},
    {"mod3",    Mod3Mask},
    {"mod4",    Mod4Mask},
    {"mod5",    Mod5Mask},
    {"any",     AnyModifier}
};

static int
mode_height (XRRModeInfo *mode_info, Rotation rotation)
{
    switch (rotation & 0xf) {
    case RR_Rotate_0:
    case RR_Rotate_180:
    return mode_info->height;
    case RR_Rotate_90:
    case RR_Rotate_270:
    return mode_info->width;
    default:
    return 0;
    }
}

static int
mode_width (XRRModeInfo *mode_info, Rotation rotation)
{
    switch (rotation & 0xf) {
    case RR_Rotate_0:
    case RR_Rotate_180:
    return mode_info->width;
    case RR_Rotate_90:
    case RR_Rotate_270:
    return mode_info->height;
    default:
    return 0;
    }
}

/* v refresh frequency in Hz */
static float
mode_refresh (XRRModeInfo *mode_info)
{
    float rate;

    if (mode_info->hTotal && mode_info->vTotal)
    rate = ((float) mode_info->dotClock /
        ((float) mode_info->hTotal * (float) mode_info->vTotal));
    else
        rate = 0;
    return rate;
}


static void
init_name (name_t *name)
{
    name->kind = name_none;
}

static void
set_name_string (name_t *name, char *string)
{
    name->kind |= name_string;
    name->string = string;
}

static void
set_name_xid (name_t *name, XID xid)
{
    name->kind |= name_xid;
    name->xid = xid;
}

static void
set_name_index (name_t *name, int index)
{
    name->kind |= name_index;
    name->index = index;
}

static void
set_name_all (name_t *name, name_t *old)
{
    if (old->kind & name_xid)
    name->xid = old->xid;
    if (old->kind & name_string)
    name->string = old->string;
    if (old->kind & name_index)
    name->index = old->index;
    name->kind |= old->kind;
}

static output_t *
add_output (void)
{
    output_t *output = calloc (1, sizeof (output_t));

    if (!output)
    fatal ("out of memory");
    output->next = NULL;
    *outputs_tail = output;
    outputs_tail = &output->next;
    return output;
}

static output_t *
find_output (name_t *name)
{
    output_t *output;

    for (output = outputs; output; output = output->next)
    {
    name_kind_t common = name->kind & output->output.kind;

    if ((common & name_xid) && name->xid == output->output.xid)
        break;
    if ((common & name_string) && !strcmp (name->string, output->output.string))
        break;
    if ((common & name_index) && name->index == output->output.index)
        break;
    }
    return output;
}

static output_t *
find_output_by_xid (RROutput output)
{
    name_t  output_name;

    init_name (&output_name);
    set_name_xid (&output_name, output);
    return find_output (&output_name);
}

static crtc_t *
find_crtc (name_t *name)
{
    int     c;
    crtc_t  *crtc = NULL;

    for (c = 0; c < num_crtcs; c++)
    {
    name_kind_t common;

    crtc = &crtcs[c];
    common = name->kind & crtc->crtc.kind;

    if ((common & name_xid) && name->xid == crtc->crtc.xid)
        break;
    if ((common & name_string) && !strcmp (name->string, crtc->crtc.string))
        break;
    if ((common & name_index) && name->index == crtc->crtc.index)
        break;
    crtc = NULL;
    }
    return crtc;
}

static crtc_t *
find_crtc_by_xid (RRCrtc crtc)
{
    name_t  crtc_name;

    init_name (&crtc_name);
    set_name_xid (&crtc_name, crtc);
    return find_crtc (&crtc_name);
}

static XRRModeInfo *
find_mode (name_t *name)
{
    int     m;
    XRRModeInfo *best = NULL;

    for (m = 0; m < res->nmode; m++)
    {
    XRRModeInfo *mode = &res->modes[m];
    if ((name->kind & name_xid) && name->xid == mode->id)
    {
        best = mode;
        break;
    }
    }
    return best;
}

static XRRModeInfo *
find_mode_by_xid (RRMode mode)
{
    name_t  mode_name;

    init_name (&mode_name);
    set_name_xid (&mode_name, mode);
    return find_mode (&mode_name);
}

static void
set_output_info (output_t *output, RROutput xid, XRROutputInfo *output_info)
{
    crtc_t  *crtc;

    /* sanity check output info */
    if (output_info->connection != RR_Disconnected && !output_info->nmode)
    fatal ("Output %s is not disconnected but has no modes\n",
           output_info->name);

    /* set output name and info */
    if (!(output->output.kind & name_xid))
    set_name_xid (&output->output, xid);
    if (!(output->output.kind & name_string))
    set_name_string (&output->output, output_info->name);
    output->output_info = output_info;

    crtc = find_crtc_by_xid (output->output_info->crtc);
    /* set position */
    if (crtc && crtc->crtc_info) {
    output->x = crtc->crtc_info->x;
    output->y = crtc->crtc_info->y;
    }

    /* set rotation */
    output->rotation &= ~0xf;
    if (crtc && crtc->crtc_info)
    output->rotation |= (crtc->crtc_info->rotation & 0xf);
    else
    output->rotation = RR_Rotate_0;

}

static void
get_crtcs (void)
{
    int     c;

    num_crtcs = res->ncrtc;
    if (crtcs)
    {
    for (c = 0; c < res->ncrtc; c++)
    {
        if (crtcs[c].crtc_info)
        XRRFreeCrtcInfo (crtcs[c].crtc_info);
    }
    free (crtcs);
    crtcs = NULL;
    }

    crtcs = calloc (num_crtcs, sizeof (crtc_t));
    if (!crtcs) fatal ("out of memory");

    for (c = 0; c < res->ncrtc; c++)
    {
    XRRCrtcInfo *crtc_info = XRRGetCrtcInfo (dpy, res, res->crtcs[c]);
    set_name_xid (&crtcs[c].crtc, res->crtcs[c]);
    set_name_index (&crtcs[c].crtc, c);
    if (!crtc_info) fatal ("could not get crtc 0x%x information", res->crtcs[c]);
    crtcs[c].crtc_info = crtc_info;
    if (crtc_info->mode == None)
    {
        crtcs[c].mode_info = NULL;
        crtcs[c].x = 0;
        crtcs[c].y = 0;
        crtcs[c].rotation = RR_Rotate_0;
    }
    }
}

static void
crtc_add_output (crtc_t *crtc, output_t *output)
{
    if (crtc->outputs)
    crtc->outputs = realloc (crtc->outputs, (crtc->noutput + 1) * sizeof (output_t *));
    else
    {
    crtc->outputs = calloc (1, sizeof (output_t *));
    crtc->x = output->x;
    crtc->y = output->y;
    crtc->rotation = output->rotation;
    crtc->mode_info = output->mode_info;
    }
    if (!crtc->outputs) fatal ("out of memory");
    crtc->outputs[crtc->noutput++] = output;
}

static void
set_crtcs (void)
{
    output_t    *output;
    int     i;

    for (i = 0; i < ncon; i++) {
    output = con_outputs[i].output;
    if (!output->mode_info) continue;
        if (output->crtc_info)
        crtc_add_output (output->crtc_info, output);
    }
}

static void
reset_crtcs_for_outputs (void)
{
    output_t    *output;

    for (output = outputs; output; output = output->next)
    {
        if ((output->crtc_info) && (output->crtc_info->outputs)) {
            free (output->crtc_info->outputs);
            output->crtc_info = NULL;
        }
    }
}

static Status
crtc_disable (crtc_t *crtc)
{
    if (verbose)
        fprintf (stderr, "crtc %d (0x%lx) : disable\n", crtc->crtc.index, crtc->crtc.xid);

    if (dryrun)
    return RRSetConfigSuccess;

    return XRRSetCrtcConfig (dpy, res, crtc->crtc.xid, CurrentTime,
                 0, 0, None, RR_Rotate_0, NULL, 0);
}

static Status
crtc_revert (crtc_t *crtc)
{
    XRRCrtcInfo *crtc_info = crtc->crtc_info;

    if (verbose)
        fprintf (stderr, "crtc %d: revert\n", crtc->crtc.index);

    if (dryrun)
    return RRSetConfigSuccess;
    return XRRSetCrtcConfig (dpy, res, crtc->crtc.xid, CurrentTime,
                crtc_info->x, crtc_info->y,
                crtc_info->mode, crtc_info->rotation,
                crtc_info->outputs, crtc_info->noutput);
}

static Status
crtc_apply (crtc_t *crtc)
{
    RROutput    *rr_outputs;
    int     o;
    Status  s;
    RRMode  mode = None;

    if (!crtc->mode_info)
    return RRSetConfigSuccess;

    rr_outputs = calloc (crtc->noutput, sizeof (RROutput));
    if (!rr_outputs)
    return BadAlloc;
    for (o = 0; o < crtc->noutput; o++)
    rr_outputs[o] = crtc->outputs[o]->output.xid;
    mode = crtc->mode_info->id;
    if (verbose) {
    fprintf (stderr, "crtc %d (0x%lx) : %12s %6.1f +%d+%d", crtc->crtc.index,
        crtc->crtc.xid,
        crtc->mode_info->name, mode_refresh (crtc->mode_info),
        crtc->x, crtc->y);
    for (o = 0; o < crtc->noutput; o++)
        fprintf (stderr, " \"%s\"", crtc->outputs[o]->output.string);
        fprintf (stderr, "\n");
    }
    if (dryrun)
    s = RRSetConfigSuccess;
    else
    s = XRRSetCrtcConfig (dpy, res, crtc->crtc.xid, CurrentTime,
                  crtc->x, crtc->y, mode, crtc->rotation,
                  rr_outputs, crtc->noutput);
    free (rr_outputs);
    return s;
}

static void
screen_revert (void)
{
    if (verbose)
    fprintf (stderr, "screen %d: revert\n", screen);

    if (dryrun)
    return;
    XRRSetScreenSize (dpy, root,
              DisplayWidth (dpy, screen),
              DisplayHeight (dpy, screen),
              DisplayWidthMM (dpy, screen),
              DisplayHeightMM (dpy, screen));
}

static void
screen_apply (void)
{
    /* comment it out because DisplayWidth() does not reflect the
       change of fb_width and fb_height previously set by
       XRRSetScreenSize()
    */
    /*
    if (fb_width == DisplayWidth (dpy, screen) &&
    fb_height == DisplayHeight (dpy, screen) &&
    fb_width_mm == DisplayWidthMM (dpy, screen) &&
    fb_height_mm == DisplayHeightMM (dpy, screen))
    {
    return;
    }
    */

    if (verbose)
    fprintf (stderr, "screen %d: %dx%d %dx%d mm %6.2fdpi\n", screen,
        fb_width, fb_height, fb_width_mm, fb_height_mm, dpi);
    if (dryrun)
    return;
    XRRSetScreenSize (dpy, root, fb_width, fb_height,
              fb_width_mm, fb_height_mm);

}

static void
revert (void)
{
    int c;

    /* first disable all crtcs */
    for (c = 0; c < res->ncrtc; c++)
    crtc_disable (&crtcs[c]);
    /* next reset screen size */
    screen_revert ();
    /* now restore all crtcs */
    for (c = 0; c < res->ncrtc; c++)
    crtc_revert (&crtcs[c]);
}

/*
 * uh-oh, something bad happened in the middle of changing
 * the configuration. Revert to the previous configuration
 * and bail
 */
static void
panic (Status s, crtc_t *crtc)
{
    int     c = crtc->crtc.index;
    char    *message;

    switch (s) {
    case RRSetConfigSuccess:        message = "succeeded";          break;
    case BadAlloc:          message = "out of memory";      break;
    case RRSetConfigFailed:     message = "failed";         break;
    case RRSetConfigInvalidConfigTime:  message = "invalid config time";    break;
    case RRSetConfigInvalidTime:    message = "invalid time";       break;
    default:                message = "unknown failure";        break;
    }

    fprintf (stderr, "%s: Configure crtc %d %s\n", program_name, c, message);
    revert ();
    exit (1);
}

static void
apply (void)
{
    Status  s;
    int     c;

    /*
     * Turn off any crtcs which are to be disabled or which are
     * larger than the target size
     */
    for (c = 0; c < res->ncrtc; c++)
    {
    crtc_t      *crtc = &crtcs[c];
    XRRCrtcInfo *crtc_info = crtc->crtc_info;

    /*
     * if this crtc is already disabled, skip it
     * Note server sets crtc_info->mode (before change)
     */
    if (crtc_info->mode == None)
        continue;

    /*
     * If this crtc is to be left enabled, make
     * sure the old size fits then new screen
     * When crtc->mode_info is null, the crtc is to be
     * disabled. Note set_crtcs () sets crtc->mode_info for
     * new mode (to be changed to).
     */
    if (crtc->mode_info)
    {
        XRRModeInfo *old_mode = find_mode_by_xid (crtc_info->mode);
        int x, y, w, h;

        if (!old_mode)
        panic (RRSetConfigFailed, crtc);

        /* old position and size information */
        x = crtc_info->x;
        y = crtc_info->y;
        w = mode_width (old_mode, crtc_info->rotation);
        h = mode_height (old_mode, crtc_info->rotation);

        /* if it fits, skip it */
        if (x + w <= fb_width && y + h <= fb_height)
        continue;
    }

    if (need_off_deferred)
        /* Defer taking off */
        continue;

    s = crtc_disable (crtc);
    if (s != RRSetConfigSuccess)
        panic (s, crtc);
    }

    /*
     * Hold the server grabbed while messing with
     * the screen so that apps which notice the resize
     * event and ask for xinerama information from the server
     * receive up-to-date information
     */
    XGrabServer (dpy);

    /*
     * Set the screen size
     */
    screen_apply ();

    /*
     * Set crtcs
     */

    for (c = 0; c < res->ncrtc; c++)
    {
    crtc_t  *crtc = &crtcs[c];

    s = crtc_apply (crtc);
    if (s != RRSetConfigSuccess)
        panic (s, crtc);
    }
    /*
     * Release the server grab and let all clients
     * respond to the updated state
     */
    XUngrabServer (dpy);
}

/*
 * Use current output state to complete the output list
 */
static void
get_outputs (void)
{
    int     o;

    for (o = 0; o < res->noutput; o++)
    {
    XRROutputInfo   *output_info = XRRGetOutputInfo (dpy, res, res->outputs[o]);
    output_t    *output;
    name_t      output_name;

    if (!output_info) fatal ("could not get output 0x%x information", res->outputs[o]);
    set_name_xid (&output_name, res->outputs[o]);
    set_name_index (&output_name, o);
    set_name_string (&output_name, output_info->name);
    output = find_output (&output_name);
    if (!output)
    {
        output = add_output ();
        set_name_all (&output->output, &output_name);
    }

    set_output_info (output, res->outputs[o], output_info);
    }
}


/*
 * Test whether 'crtc' can be used for 'output'
 */
static Bool
check_crtc_for_output (crtc_t *crtc, output_t *output)
{
    int     i;
    int     l;
    output_t    *other;

    for (i = 0; i < ncon; i++)
    {
    other = con_outputs[i].output;

    if (other == output)
        continue;

    if (other->mode_info == NULL)
        continue;

    if (other->crtc_info != crtc)
        continue;

    /* see if the output connected to the crtc can clone to this output */
    for (l = 0; l < output->output_info->nclone; l++)
        if (output->output_info->clones[l] == other->output.xid)
        break;
    /* not on the list, can't clone */
    if (l == output->output_info->nclone)
        return False;
    }

    if (crtc->noutput)
    {
    for (i = 0; i < crtc->noutput; i++)
        /* Check if the output is to be turned on */
        if (crtc->outputs[i]->mode_info) {
        /* make sure the state matches */
        if (crtc->mode_info != output->mode_info)
                return False;
        if (crtc->x != output->x)
                return False;
        if (crtc->y != output->y)
                return False;
        if (crtc->rotation != output->rotation)
                return False;
        }
    }
    return True;
}

static crtc_t *
find_crtc_for_output (output_t *output)
{
    int     c;

    for (c = 0; c < output->output_info->ncrtc; c++)
    {
    crtc_t      *crtc;

    crtc = find_crtc_by_xid (output->output_info->crtcs[c]);
    if (!crtc) fatal ("cannot find crtc 0x%x\n", output->output_info->crtcs[c]);

    if (check_crtc_for_output (crtc, output))
        return crtc;
    }
    return NULL;
}

static void
set_positions (void)
{
    Bool    keep_going;
    Bool    any_set;
    int     min_x, min_y;
    int     i;

    for (;;)
    {
    any_set = False;
    keep_going = False;
    for (i = 0; i < ncon; i++)
    {
        output_t    *output = con_outputs[i].output;
        output_t    *relation;

        if (!(output->changes & changes_relation)) continue;

        if (output->mode_info == NULL) continue;

        relation = output->relative_to;

        if (relation->mode_info == NULL)
        {
        output->x = 0;
        output->y = 0;
        output->changes |= changes_position;
        any_set = True;
        continue;
        }
        /*
         * Make sure the dependent object has been set in place
         */
        if ((relation->changes & changes_relation) &&
        !(relation->changes & changes_position))
        {
        keep_going = True;
        continue;
        }

        switch (output->relation) {
        case left_of:
        output->y = relation->y;
        output->x = relation->x - mode_width (output->mode_info, output->rotation);
        break;
        case right_of:
        output->y = relation->y;
        output->x = relation->x + mode_width (relation->mode_info, relation->rotation);
        break;
        case above:
        output->x = relation->x;
        output->y = relation->y - mode_height (output->mode_info, output->rotation);
        break;
        case below:
        output->x = relation->x;
        output->y = relation->y + mode_height (relation->mode_info, relation->rotation);
        break;
        case same_as:
        output->x = relation->x;
        output->y = relation->y;
        }
        output->changes |= changes_position;
        relation->changes |= changes_position;
        any_set = True;
    }
    if (!keep_going)
        break;
    if (!any_set)
        fatal ("loop in relative position specifications\n");
    }

    /*
     * Now normalize positions so the upper left corner of all outputs is at 0,0
     */
    min_x = 32768;
    min_y = 32768;
    for (i = 0; i < ncon; i++)
    {
    output_t    *output = con_outputs[i].output;

    if (output->mode_info == NULL) continue;

    if (output->x < min_x) min_x = output->x;
    if (output->y < min_y) min_y = output->y;
    }
    if (min_x || min_y)
    {
    /* move all outputs */
    for (i = 0; i < ncon; i++)
    {
        output_t    *output = con_outputs[i].output;

        if (output->mode_info == NULL) continue;

        output->x -= min_x;
        output->y -= min_y;
        output->changes |= changes_position;
    }
    }
}

static Bool
set_screen_size (void)
{
    int i;

    fb_width = fb_height = 0;

    for (i = 0; i < ncon; i++)
    {
        output_t    *output = con_outputs[i].output;
    XRRModeInfo *mode_info = output->mode_info;
    int     x, y, w, h;

    if (!mode_info) continue;

    x = output->x;
    y = output->y;
    w = mode_width (mode_info, output->rotation);
    h = mode_height (mode_info, output->rotation);
    if (x + w > fb_width) fb_width = x + w;
    if (y + h > fb_height) fb_height = y + h;
    }

    if (fb_width > maxWidth || fb_height > maxHeight) {
    if (verbose)
            fprintf (stderr, "screen cannot be larger than %dx%d (desired size %dx%d)\n",
           maxWidth, maxHeight, fb_width, fb_height);
    return False;
    }

    if (fb_width < minWidth) fb_width = minWidth;
    if (fb_height < minHeight) fb_height = minHeight;

    return True;
}

static void
disable_outputs (output_t *outputs)
{
    while (outputs)
    {
    outputs->crtc_info = NULL;
    outputs = outputs->next;
    }
}

/*
 * find the best mapping from output to crtc available
 */
static int
pick_crtcs_score (output_t *outputs)
{
    output_t    *output;
    int     best_score;
    int     my_score;
    int     score;
    crtc_t  *best_crtc;
    int     c;

    if (!outputs)
    return 0;

    output = outputs;
    outputs = outputs->next;
    /*
     * Score with this output disabled
     */
    output->crtc_info = NULL;
    best_score = pick_crtcs_score (outputs);
    if (output->mode_info == NULL)
    return best_score;

    best_crtc = NULL;
    /*
     * Now score with this output any valid crtc
     */
    for (c = 0; c < output->output_info->ncrtc; c++)
    {
    crtc_t      *crtc;

    crtc = find_crtc_by_xid (output->output_info->crtcs[c]);
    if (!crtc)
        fatal ("cannot find crtc 0x%x\n", output->output_info->crtcs[c]);

    /* reset crtc allocation for following outputs */
    disable_outputs (outputs);
    if (!check_crtc_for_output (crtc, output))
        continue;

    my_score = 1000;
    /* slight preference for existing connections */
    if (crtc == output->current_crtc_info)
        my_score++;

    output->crtc_info = crtc;
    score = my_score + pick_crtcs_score (outputs);
    if (score > best_score)
    {
        best_crtc = crtc;
        best_score = score;
    }
    }
    if (output->crtc_info != best_crtc)
    output->crtc_info = best_crtc;
    /*
     * Reset other outputs based on this one using the best crtc
     */
    (void) pick_crtcs_score (outputs);

    return best_score;
}

/*
 * Pick crtcs for any changing outputs that don't have one
 */
static Bool
pick_crtcs (void)
{
    output_t    *output;
    int i;

    /*
     * First try to match up newly enabled outputs with spare crtcs
     */
    for (i = 0; i < ncon; i++)
    {
    output = con_outputs[i].output;

    if (output->mode_info)
    {
        if (output->crtc_info)  {
        if (output->crtc_info->crtc_info->noutput > 0 &&
            (output->crtc_info->crtc_info->noutput > 1 ||
             output != find_output_by_xid (output->crtc_info->crtc_info->outputs[0])))
            break;
        } else {
        output->crtc_info = find_crtc_for_output (output);
        if (!output->crtc_info)
            break;
        else {
            if (verbose)
            fprintf(stderr, "picked crtc 0x%lx for output %d (%s)\n",
                output->crtc_info->crtc.xid, i, output->output_info->name);
        }
        }
    }
    }

    /*
     * Everyone is happy
     */
    if (i == ncon)
    return True;
    /*
     * When the simple way fails, see if there is a way
     * to swap crtcs around and make things work
     */
    for (output = outputs; output; output = output->next)
    output->current_crtc_info = output->crtc_info;
    pick_crtcs_score (outputs);
    for (output = outputs; output; output = output->next)
    {
    if (output->mode_info && !output->crtc_info) {
        if (verbose)
        fprintf (stderr, "cannot find crtc for output %s\n",
            output->output.string);
        return False;
    }
    }

    return True;
}

static Bool
probe_and_check_output_changes (void) {
    XRRScreenResources  *new_res = NULL;
    int  changed = False;
    int  i;

    new_res = XRRGetScreenResources (dpy, root);
    if (!new_res)
        fatal ("could not get screen resources");

    if ((new_res->noutput != res->noutput) || (new_res->nmode != res->nmode) ||
    (new_res->ncrtc != res->ncrtc))
    changed = True;
    else {
    for (i = 0; i < new_res->noutput; i++)
        if (new_res->outputs[i] != res->outputs[i]) {
        changed = True;
        break;
        }
    for (i = 0; i < new_res->nmode; i++)
        if (new_res->modes[i].id != res->modes[i].id) {
        changed = True;
        break;
        }
    for (i = 0; i < new_res->ncrtc; i++) {
        crtc_t  *crtc = NULL;       /* old */
        XRRCrtcInfo *crtc_info = NULL;  /* new */

        crtc = find_crtc_by_xid (res->crtcs[i]);
        crtc_info = XRRGetCrtcInfo (dpy, new_res,
        new_res->crtcs[i]);

        if (!crtc || !crtc_info) {
            changed = True;
            break;
        }
        if (!crtc->mode_info && !find_mode_by_xid (crtc_info->mode))
        continue;
            if ((crtc_info->x != crtc->x) ||
            (crtc_info->y != crtc->y) ||
            (find_mode_by_xid (crtc_info->mode) != crtc->mode_info) ||
            (crtc_info->rotation != crtc->rotation)) {
            changed = True;
            break;
        }
    }
    }

    if (changed) {
    if (res)
        XRRFreeScreenResources(res);
    res = new_res;

    if (verbose)
        fprintf(stderr, "probed: output status changed\n");
    return True;
    }

    if (verbose)
    fprintf(stderr, "probed: no output status change\n");
    return False;
}

static Bool
need_probe (void) {
    struct timeval  cur_time_val;
    long long   cur, prev;

    X_GETTIMEOFDAY(&cur_time_val);
    cur = (long long) cur_time_val.tv_sec * 1000000 + cur_time_val.tv_usec;
    prev =(long long) time_val.tv_sec * 1000000 + time_val.tv_usec;
    if (((cur - prev) < 0) || ((cur - prev) > 5000000))
    return True;
    else
    return False;
}

static int
mode_sort (const void *p1, void *p2)
{
    XRRModeInfo *mi1 = * (XRRModeInfo **) p1;
    XRRModeInfo *mi2 = * (XRRModeInfo **) p2;

    if ((mi1->width == mi2->width) && (mi1->height == mi2->height)) {
    if (mode_refresh(mi1) && mode_refresh(mi2)) {
        if (mode_refresh(mi1) < mode_refresh(mi2))
        return 1;
        if (mode_refresh(mi1) > mode_refresh(mi2))
        return -1;
    } else
            return 0;
    }

    if ((mi1->width == mi2->width) && (mi1->height < mi2->height))
        return 1;
    if ((mi1->width == mi2->width) && (mi1->height > mi2->height))
        return -1;
    if (mi1->width < mi2->width)
        return 1;
    if (mi1->width > mi2->width)
        return -1;

    return 0;
}

static int
output_sort (const void *p1, const void *p2) {
    con_output_t co1 = * (con_output_t *) p1;
    con_output_t co2 = * (con_output_t *) p2;
    int ncrtc1 = co1.output->output_info->ncrtc;
    int ncrtc2 = co2.output->output_info->ncrtc;
    char *name1 = co1.output->output_info->name;
    char *name2 = co2.output->output_info->name;

    if (ncrtc1 == ncrtc2)
    return (strcmp(name1, name2));
    if (ncrtc1 <  ncrtc2)
    return -1;

    return 1;
}

static Bool
get_common_mode(con_output_t *c0, con_output_t *c1, int *m0, int *m1) {
    int     i, j;
    int     i1 = -1, j1 = -1, i2 = -1, j2 = -1;
    int     x, y, w, h;
    output_t    *output = c0->output;

    *m0 = -1;
    *m0 = -1;
    if (!c0 ||!c1 || !c0->smodes || !c1->smodes)
    return False;

    /* first try to find mode with common same size */
    for (i = 0; i < c0->nsmodes; i ++) {
    for (j = 0; j < c1->nsmodes; j ++)
        if ((c0->smodes[i]->width == c1->smodes[j]->width) &&
        (c0->smodes[i]->height == c1->smodes[j]->height)) {
        x = output->x;
        y = output->y;
        w = mode_width (c0->smodes[i], output->rotation);
        h = mode_height (c0->smodes[i], output->rotation);
        if ((x + w <=  maxWidth) && (y + h <= maxHeight)) {
            i1 = i; j1 = j;
            break;
        }
        }
    if ((i1 != -1) && (j1 != -1))
        break;
    }

    if ((i1 == -1) && (j1 == -1))
    return False;

    /* then try to find mode with common id for possible cloning */
    for (i = 0; i < c0->nsmodes; i ++) {
    for (j = 0; j < c1->nsmodes; j ++)
        if (c0->smodes[i] == c1->smodes[j]) {
        x = output->x;
        y = output->y;
        w = mode_width (c0->smodes[i], output->rotation);
        h = mode_height (c0->smodes[i], output->rotation);
        if ((x + w <=  maxWidth) && (y + h <= maxHeight)) {
            i2 = i; j2 = j;
            break;
        }
        }
    if ((i2 != -1) && (j2 != -1))
        break;
    }

    if ((i2 == -1) && (j2 == -1)) {
    *m0 = i1;
    *m1 = j1;
    } else {
    /* use common id if it is not smaller */
    if ((mode_width (c0->smodes[i1], output->rotation) >
        mode_width (c0->smodes[i2], output->rotation)) &&
        (mode_height (c0->smodes[i1], output->rotation) >
        mode_height (c0->smodes[i2], output->rotation))) {
        *m0 = i1;
        *m1 = j1;
    } else {
        *m0 = i2;
        *m1 = j2;
    }
    }

    return True;
}

static XRRModeInfo *
get_largest_mode (con_output_t *c, XRRModeInfo *start_mode) {
    int     i, found = False;
    output_t    *output = c->output;

    for (i = 0; i < c->nsmodes; i++) {
    XRRModeInfo *mode_info = c->smodes[i];
    int     x, y, w, h;

    if (!found && (start_mode != mode_info))
        continue;
    else
        found = True;

    if (mode_info) {
        x = output->x;
            y = output->y;
            w = mode_width (mode_info, output->rotation);
            h = mode_height (mode_info, output->rotation);
        if ((x + w <=  maxWidth) && (y + h <= maxHeight))
        break;
    }
    }

    if (i < c->nsmodes)
    return c->smodes[i];
    else
    fatal("cannot find mode");

}

static Bool
valid_mode(con_output_t *con, XRRModeInfo *mode) {
    int i;

    for (i = 0; i < con->nsmodes; i++)
    if (con->smodes[i] == mode)
        return True;

    return False;
}

static void
do_init (void)
{
    int         i, j;
    output_t    *output;

    /* Initialize con_outputs array */
    for (i = 0; i < MAX_OUTPUT; i++) {
    con_outputs[i].output = NULL;
    con_outputs[i].on = False;
    start_mode[i] = NULL;
    new_mode[i] = NULL;
    }

    ncon = 0;
    dis_ncon = 0;
    init_rotation = RR_Rotate_0;
    init_x = 0;
    init_y = 0;
    get_crtcs ();
    get_outputs ();

    for (output = outputs; output; output = output->next) {
    XRROutputInfo   *output_info = output->output_info;

    if (output_info->connection == RR_Connected) {
        con_outputs[ncon].output = output;
        con_outputs[ncon].nsmodes = 0;
        for (j = 0; j < output_info->nmode; j++) {
        XRRModeInfo *rmode = find_mode_by_xid (output_info->modes[j]);

        con_outputs[ncon].smodes =
            realloc(con_outputs[ncon].smodes,
            (con_outputs[ncon].nsmodes + 1) * sizeof (XRRModeInfo *));
        con_outputs[ncon].smodes[j] = rmode;
        con_outputs[ncon].nsmodes ++;
        }

        /* Sort the modes */
            qsort((void *) con_outputs[ncon].smodes,
        con_outputs[ncon].nsmodes, sizeof(XRRModeInfo *),
        (int (*) (const void *, const void *)) mode_sort);

        if (output_info->crtc) {
        crtc_t      *crtc;

        con_outputs[ncon].on = True;
        for (j = 0; j < output_info->ncrtc; j++) {
            if (output_info->crtcs[j] == output_info->crtc)
                            break;
                    if (j == output_info->ncrtc) {
            if (verbose)
                            fatal ("crtc does not match for output\n");
                    }
        }
        /* set initial mode_info */
        crtc = find_crtc_by_xid (output_info->crtc);
        if (crtc)
            con_outputs[ncon].output->mode_info =
            find_mode_by_xid (crtc->crtc_info->mode);
        }
        else
        con_outputs[ncon].on = False;
        ncon ++;
    } else if (output_info->connection == RR_Disconnected) {
        dis_con_outputs[dis_ncon].output = output;
        dis_ncon ++;
    }
    }

    qsort((void **) con_outputs, ncon,
    sizeof(con_output_t), (int (*) (const void *, const void *)) output_sort);

    if (verbose) {
    fprintf(stderr, "Total connected outputs = %d :\n", ncon);
    for (j = 0; j < ncon; j++) {
        fprintf(stderr, "%d (%s): top mode = %s, rotation = %d, crtcs =", j,
        con_outputs[j].output->output_info->name,
        con_outputs[j].smodes[0]->name,
        con_outputs[j].output->rotation);
        for (i = 0; i < con_outputs[j].output->output_info->ncrtc; i++)
        fprintf(stderr, " 0x%lx", con_outputs[j].output->output_info->crtcs[i]);
        fprintf(stderr, ", using 0x%lx", con_outputs[j].output->output_info->crtc);
        fprintf(stderr, "\n");
    }
    fprintf(stderr, "Total disconnected outputs = %d :\n", dis_ncon);
    for (j = 0; j < dis_ncon; j++) {
        fprintf(stderr, "%d (%s) : number of crtcs %d =", j,
        dis_con_outputs[j].output->output_info->name,
        dis_con_outputs[j].output->output_info->ncrtc);
        for (i = 0; i < dis_con_outputs[j].output->output_info->ncrtc; i++)
        fprintf(stderr, " 0x%lx", dis_con_outputs[j].output->output_info->crtcs[i]);
        fprintf(stderr, ", using 0x%lx", dis_con_outputs[j].output->output_info->crtc);
        fprintf(stderr, "\n");
    }
    }

    i = con_outputs[2].on * 4 + con_outputs[1].on * 2 + con_outputs[0].on;

    if ((i == 1) || (i == 2) || (i == 4)) {
    use_init_pos = True;
    j = i >> 1;

    /* remember position and mode info in single state */
        start_mode[j] = con_outputs[j].output->mode_info;
    init_rotation = con_outputs[j].output->rotation;
    init_x = con_outputs[j].output->x;
    init_y = con_outputs[j].output->y;
    } else
    use_init_pos = False;

    if ((ncon != 2) || (start < 3))
    start = i;

    if ((ncon < 1) || (ncon > 3)) {
    if ((ncon < 1) && verbose)
        fprintf (stderr, "warn: no connection\n");
    else if ((ncon > 3) && verbose)
        fprintf (stderr, "warn: too many (more than 3) connections: %d: can't switch\n", ncon);
    do_not_switch = True;
    }

    did_init = True;

    return;
}

static int
grab_key (Display *dpy, int keysym, unsigned int modifier,
    Window grab_window)
{
    char    msg[256];
    int keycode = XKeysymToKeycode(dpy, keysym);

    if (keycode ==  NoSymbol)
    fatal ("grab_key: keycode not defined for keysym 0x%x\n", keysym);

    had_error = 0;
    prev_handler = XSetErrorHandler (cur_handler);

    if (!testrun) {
        XGrabKey(dpy,
        keycode,
        modifier,
        root, True, GrabModeAsync, GrabModeAsync);
        XSync (dpy, False);
    }

    XSetErrorHandler (prev_handler);
    if (had_error) {
    XGetErrorText (dpy, had_error, msg, sizeof (msg));
    fatal ("XGrabKey: %s\n", msg);
    }

    if (verbose)
    fprintf(stderr, "keycode to grab: %d\n", keycode);

    return keycode;
}

static Bool
do_switch (void)
{
    int     i, j;
    int     single;
    int     save = -1;

    if (ncon <= 0)
    return True;

    for (i = 0; i < ncon; i++) {
    output_t    *output = con_outputs[i].output;

    new_mode[i] = NULL;
    output->relation = same_as;
    output->relative_to = NULL;
    if (use_init_pos) {
        output->x = init_x;
        output->y = init_y;
        output->rotation = init_rotation;
    } else {
        output->x = 0;
        output->y = 0;
    }
    }

    if (ncon == 2) {
    if (!nosideview) {
        if (++start > 5)    start = 1;
    }
    else {
        if (++start > 3)    start = 1;
    }

    if (verbose)
        fprintf(stderr, "current state = %d\n", start);
    if (start >= 3) {
        int m0, m1;

            if (get_common_mode(&con_outputs[0], &con_outputs[1], &m0, &m1)) {
        new_mode[0] = con_outputs[0].smodes[m0];
                new_mode[1] = con_outputs[1].smodes[m1];
        } else {
        new_mode[0] = get_largest_mode (&con_outputs[0],
            con_outputs[0].smodes[0]);
        new_mode[1] = get_largest_mode (&con_outputs[1],
            con_outputs[1].smodes[0]);
        }
    } else {
        if (start_mode[start -1] && valid_mode(&con_outputs[start -1],
        start_mode[start -1]))
            new_mode[start -1] = start_mode[start -1];
        else {
            if (con_outputs[start -1].smodes[0])
            new_mode[start -1] =
            get_largest_mode (&con_outputs[start-1],
            con_outputs[start -1].smodes[0]);
        }
    }
    }

    if (ncon == 3) {
    if (++start > 6)    start = 1;
    if (verbose)
        fprintf(stderr, "current state = %d\n", start);
    if ((start == 1) || (start == 2) || (start == 4)) {
        single = 1;
        i = start >> 1;
        j = 0;
    }
    else {
        single = 0;
        if (start > 4)
        j = 2;
        else
        j = 1;
        if (start > 5)
        i = 1;
        else
        i = 0;
    }

    if (single) {
        if (start_mode[i] && valid_mode(&con_outputs[i], start_mode[i]))
        new_mode[i] = start_mode[i];
        else {
            if (con_outputs[i].smodes[0])
            new_mode[i] = get_largest_mode (&con_outputs[i],
            con_outputs[i].smodes[0]);
        }
    }
    else {
        int m0, m1;

            if (get_common_mode(&con_outputs[i], &con_outputs[j], &m0, &m1)) {
        new_mode[i] = con_outputs[i].smodes[m0];
        new_mode[j] = con_outputs[j].smodes[m1];
            } else {
        new_mode[i] = get_largest_mode (&con_outputs[i],
            con_outputs[i].smodes[0]);
        new_mode[j] = get_largest_mode (&con_outputs[j],
            con_outputs[j].smodes[0]);
        }
    }
    }

    if (ncon == 1) {
    if (start_mode[0] && valid_mode(&con_outputs[0], start_mode[0]))
        new_mode[0] = start_mode[0];
    else {
        if (con_outputs[0].smodes[0])
        new_mode[0] = get_largest_mode (&con_outputs[0],
            con_outputs[0].smodes[0]);
    }
    }

    /* Set mode */
    for (i = 0; i < ncon; i++) {
        output_t    *output;

        output = con_outputs[i].output;
    if (new_mode[i]) {
        if ((!output->mode_info) || (output->mode_info != new_mode[i])) {
            output->mode_info = new_mode[i];
            con_outputs[i].on = True;
        if (verbose)
            fprintf(stderr, "set output %d (%s) to mode %s rotation %d\n", i,
            con_outputs[i].output->output_info->name,
            con_outputs[i].output->mode_info->name,
            con_outputs[i].output->rotation);
            }
    } else if (con_outputs[i].on ) {
        if (!need_off_deferred) {
        output->mode_info = NULL;
        con_outputs[i].on = False;
        if (verbose)
            fprintf(stderr, "turn off output %d (%s) \n",
            i, con_outputs[i].output->output_info->name);
        } else
        save = i;
    }
    }

    if ((ncon == 2) && (start >= 4)) {
    if (start == 4) {
        con_outputs[1].output->relative_to = con_outputs[0].output;
        con_outputs[1].output->relation = right_of;
        con_outputs[1].output->changes = changes_relation;
        con_outputs[0].output->changes = 0;
    }
    else if (start == 5) {
        con_outputs[0].output->relative_to = con_outputs[1].output;
        con_outputs[0].output->relation = right_of;
        con_outputs[0].output->changes = changes_relation;
        con_outputs[1].output->changes = 0;
    }

    set_positions();
    }

    if (!set_screen_size ())
    return False;


    /* reset crtcs before allocation */
    reset_crtcs_for_outputs();

    if (!did_init)
    get_crtcs();

    if (!pick_crtcs()) {
    if (verbose)
        fprintf(stderr, "pick_crtcs failed\n");
    return True;
    }

    set_crtcs ();
    apply();

    if (need_off_deferred && (save != -1)) {
    /* Now, take the deferred output off */
    output_t    *output;
    crtc_t      *crtc;
    Status      s;

    output = con_outputs[save].output;
    output->mode_info = NULL;
    con_outputs[save].on = False;
    if (verbose)
        fprintf(stderr, "turn off output %d (%s) \n",
        save, con_outputs[save].output->output_info->name);

    crtc = output->crtc_info;
    s = crtc_disable (crtc);
    if (s != RRSetConfigSuccess)
        panic (s, crtc);
    }

    XSync (dpy, False);

    did_init = False;

    return True;

}

static Bool
do_toggle (void)
{
    Atom        atom;
    XEvent      xev;
    int         ret;

    atom = XInternAtom (dpy, "DISPLAYSWITCH_DAEMON", True);
    if (!atom) {
    fprintf(stderr, "dispswitch daemon not running\n");
    return False;
    }

    win = XGetSelectionOwner (dpy, atom);
    if (!win) {
    fprintf(stderr, "dispswitch: No owner of dispswitch daemon is found\n");
    return False;
    }

    bzero (&xev, sizeof (XEvent));
    xev.xkey.type = KeyPress;
    xev.xkey.send_event = True;
    xev.xkey.display = dpy;
    /* Any keycode */
    xev.xkey.keycode = 71;


    /*
     * Send another instance of dispswitch (a daemon) an event to
     * request a switch
     */
    ret = XSendEvent(dpy, win, False, KeyPressMask, &xev);
    XFlush(dpy);

    if (!ret)
    fprintf(stderr, "dispswitch: XSendEvent error\n");

    return (!ret);
}

int
main (int argc, char **argv)
{
    char    *display_name = NULL;
    int     major, minor;
    int     i;
    char    msg[256];
    XEvent  ev;
    unsigned int    modifier = 0;
    Bool    key_given = False;
    Bool    mod_given = False;
    int     keysym = 0, toggle = False, listen = False;

    Atom    atom;

    program_name = argv[0];

    for (i = 1; i < argc; i++) {
    if (!strcmp ("-display", argv[i]) || !strcmp ("-d", argv[i])) {
        if (++i>=argc) usage ();
            display_name = argv[i];
        continue;
        }
    if (!strcmp ("-key", argv[i]) || !strcmp ("-k", argv[i])) {
        if (++i>=argc) usage ();
        if ((keysym = XStringToKeysym(argv[i])) == NoSymbol) {
        fprintf(stderr, "invalid keysym: -key %s\n", argv[i]);
        usage();
        }
        key_given = True;
        continue;
    }
    if (!strcmp ("-mod", argv[i]) || !strcmp ("-m", argv[i])) {
        int     j;
        char    *s, *p, *q;
        int     end = 0;

        if (++i>=argc) usage ();
        s = strdup (argv[i]);
        if (!s) {
        if (verbose)
            fprintf(stderr, "modifier failed, will use default modifier\n");
        continue;
        }
        while (*s == ' ') s++;
        p = s + strlen(s) - 1;
        while (*p == ' ') *p-- = 0;
        q = s;
        for (; ;) {
            if (p = strchr(s, '+')) {
            *p = ' ';
            while ((p > s) && (*(p-1) == ' ')) p--;
            *p = 0;
        }
        else
            end = 1;
            for (j = 0; j < MAX_MODIFIERS; j++) {
                if (!strcmp(mod_key_table[j].modname, s)) {
            modifier |= mod_key_table[j].mod;
            break;
            }
        }
        if (j == MAX_MODIFIERS) {
            fprintf(stderr, "invalid modifier: -mod %s\n", q);
            usage();
        }
        if (end)
            break;
        else {
            s = ++p;
            while (*s == ' ') s++;
        }
        }
        mod_given = True;
        free (q);
        continue;
        }
    if (!strcmp ("-nosideview", argv[i])) {
        nosideview = True;
        continue;
        }
    if (!strcmp ("-verbose", argv[i]) || !strcmp ("-v", argv[i])) {
        verbose = True;
        continue;
        }
    if (!strcmp ("-testrun", argv[i])) {
        testrun = True;
        verbose = True;
        continue;
        }
    if (!strcmp ("-toggle", argv[i]) || !strcmp ("-t", argv[i])) {
        toggle = True;
        continue;
        }
    if (!strcmp ("-listen", argv[i]) || !strcmp ("-l", argv[i])) {
        listen = True;
        continue;
        }
    usage();
    }

    dpy = XOpenDisplay (display_name);

    if (dpy == NULL)
    fatal ("can't open display %s\n", XDisplayName(display_name));

    screen = DefaultScreen (dpy);
    root = RootWindow (dpy, screen);

    if (!XRRQueryVersion (dpy, &major, &minor))
    fatal ("randr extension missing\n");

    if ((major <= 1) &&  (major != 1 || minor < 2))
    fatal ("wrong randr version: %d.%d\n", major, minor);


    if (toggle)
    exit (do_toggle());

    /*
     * Create an atom, a trivial window, and make it selection owner.
     * Ready to accept a client event request for switch
     */
    atom = XInternAtom(dpy, "DISPLAYSWITCH_DAEMON", False);
    if (!atom) {
    if (verbose)
        fprintf(stderr, "cannot create Atom\n");
    }
    else {
    if (XGetSelectionOwner (dpy, atom)) {
        if (verbose)
        fprintf(stderr, "dispswitch daemon is already running, quit\n");
        exit (1);
    }
    win = XCreateSimpleWindow(dpy, root, 0, 0, 10, 10, 0, 10, 0);
    if (!win) {
        if (verbose)
        fprintf(stderr, "cannot create window\n");
    }
    else {
        XSetSelectionOwner(dpy, atom, win, CurrentTime);
        if (XGetSelectionOwner(dpy, atom) != win) {
        if (verbose)
            fprintf(stderr, "set selection owner failed\n");
        } else
        XSelectInput(dpy, win, KeyPressMask);
    }
    }

    /* set default key and modifier if not given in command */
    if (!key_given)
    keysym  = XStringToKeysym ("F5");
    if (!mod_given)
    modifier = ShiftMask;

    if (!listen)
    cur_keycode = grab_key (dpy, keysym, modifier, root);

    XRRGetScreenSizeRange (dpy, root, &minWidth, &minHeight,
                           &maxWidth, &maxHeight);

    fb_width_mm = DisplayWidthMM (dpy, screen);
    fb_height_mm = DisplayHeightMM (dpy, screen);
    dpi = (25.4 * DisplayHeight (dpy, screen)) / DisplayHeightMM(dpy, screen);

    res = XRRGetScreenResources (dpy, root);
    if (!res)
    fatal ("could not get screen resources\n");
    if (res->ncrtc < 2)
    fatal ("too few crtcs: %d\n", res->ncrtc);

    do_init();

    X_GETTIMEOFDAY(&time_val);

    for(;;)
    {
    need_off_deferred = False;

    if (testrun) {
        usleep(4000000);
        fprintf(stderr, "\n");
    } else
        XNextEvent(dpy, &ev);

    if (!listen && !testrun && (ev.type == MappingNotify) &&
        ((ev.xmapping.request == MappingKeyboard) ||
        (ev.xmapping.request == MappingModifier))) {
        /* keyboard/modifier mapping changed */
        if (verbose)
        fprintf(stderr, "\nkeyboard/modifier mapping changed ...\n");

        XUngrabKey(dpy, cur_keycode, modifier, root);
        cur_keycode = grab_key (dpy, keysym, modifier, root);
    }

    if (testrun || (ev.type == KeyPress)) {
        if (verbose)
        fprintf(stderr, "\na key press event was grabbed ...\n");

        do_not_switch = False;

        if (testrun || need_probe()) {
        /* Too long since last switch, need to check output changes */
        if (probe_and_check_output_changes ()) {
            output_t    *output, *next;

            output = outputs;
            while (output) {
            if (output->output_info)
                XRRFreeOutputInfo (output->output_info);
            if (output->crtc_info && output->crtc_info->outputs) {
                free(output->crtc_info->outputs);
                output->crtc_info->outputs = NULL;
            }
            next = output->next;
            free(output);
            output = next;
            }
            outputs = NULL;
            outputs_tail = &outputs;
            for (i = 0; i < ncon; i++) {
            con_outputs[i].output = NULL;
            con_outputs[i].on = False;
            if (con_outputs[i].smodes) {
                free(con_outputs[i].smodes);
                con_outputs[i].smodes = NULL;
            }
            con_outputs[i].nsmodes = 0;
            }

            do_init();
        } else if (ncon == 1)
            do_not_switch = True;
        } else if (ncon == 1)
        do_not_switch = True;

            if (!do_not_switch) {
        if ((ncon == 2) && (start == 1))
            /*
             * Workaround for intel based graphics: in switching from
             * LVDS to VGA, off on LVDS needs to be deferred.
             */
            need_off_deferred = True;
            if (!do_switch()) {
            if ((ncon == 2) && (start == 4)) {
            start = 5;
            if (verbose)
                fprintf(stderr, "too small screen, skipping side view\n");
            (void) do_switch();
            }
        }
        }

        X_GETTIMEOFDAY(&time_val);
    }
    }
}