/* 

 * 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);