mirror of
https://github.com/brl/mutter.git
synced 2024-11-30 20:01:00 -05:00
29e5c6c363
In randr events, configTimestamp can be considered the hotplug time, i.e. whenever the server notices hardware changes, this value will be updated. Having that in mind, we can re-work the logic to make it clearer. There are no semantic changes.
1090 lines
33 KiB
C
1090 lines
33 KiB
C
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
|
|
|
|
/*
|
|
* Copyright (C) 2001, 2002 Havoc Pennington
|
|
* Copyright (C) 2002, 2003 Red Hat Inc.
|
|
* Some ICCCM manager selection code derived from fvwm2,
|
|
* Copyright (C) 2001 Dominik Vogt, Matthias Clasen, and fvwm2 team
|
|
* Copyright (C) 2003 Rob Adams
|
|
* Copyright (C) 2004-2006 Elijah Newren
|
|
* Copyright (C) 2013 Red Hat Inc.
|
|
*
|
|
* 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, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "meta-monitor-manager-xrandr.h"
|
|
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <math.h>
|
|
#include <clutter/clutter.h>
|
|
|
|
#include <X11/Xatom.h>
|
|
#include <X11/extensions/Xrandr.h>
|
|
#include <X11/extensions/dpms.h>
|
|
#include <X11/Xlib-xcb.h>
|
|
#include <xcb/randr.h>
|
|
|
|
#include "meta-backend-x11.h"
|
|
#include <meta/main.h>
|
|
#include <meta/errors.h>
|
|
#include "edid.h"
|
|
#include "meta-monitor-config.h"
|
|
|
|
#define ALL_TRANSFORMS ((1 << (META_MONITOR_TRANSFORM_FLIPPED_270 + 1)) - 1)
|
|
|
|
/* Look for DPI_FALLBACK in:
|
|
* http://git.gnome.org/browse/gnome-settings-daemon/tree/plugins/xsettings/gsd-xsettings-manager.c
|
|
* for the reasoning */
|
|
#define DPI_FALLBACK 96.0
|
|
|
|
struct _MetaMonitorManagerXrandr
|
|
{
|
|
MetaMonitorManager parent_instance;
|
|
|
|
Display *xdisplay;
|
|
XRRScreenResources *resources;
|
|
int time;
|
|
int rr_event_base;
|
|
int rr_error_base;
|
|
};
|
|
|
|
struct _MetaMonitorManagerXrandrClass
|
|
{
|
|
MetaMonitorManagerClass parent_class;
|
|
};
|
|
|
|
G_DEFINE_TYPE (MetaMonitorManagerXrandr, meta_monitor_manager_xrandr, META_TYPE_MONITOR_MANAGER);
|
|
|
|
static MetaMonitorTransform
|
|
meta_monitor_transform_from_xrandr (Rotation rotation)
|
|
{
|
|
static const MetaMonitorTransform y_reflected_map[4] = {
|
|
META_MONITOR_TRANSFORM_FLIPPED_180,
|
|
META_MONITOR_TRANSFORM_FLIPPED_90,
|
|
META_MONITOR_TRANSFORM_FLIPPED,
|
|
META_MONITOR_TRANSFORM_FLIPPED_270
|
|
};
|
|
MetaMonitorTransform ret;
|
|
|
|
switch (rotation & 0x7F)
|
|
{
|
|
default:
|
|
case RR_Rotate_0:
|
|
ret = META_MONITOR_TRANSFORM_NORMAL;
|
|
break;
|
|
case RR_Rotate_90:
|
|
ret = META_MONITOR_TRANSFORM_90;
|
|
break;
|
|
case RR_Rotate_180:
|
|
ret = META_MONITOR_TRANSFORM_180;
|
|
break;
|
|
case RR_Rotate_270:
|
|
ret = META_MONITOR_TRANSFORM_270;
|
|
break;
|
|
}
|
|
|
|
if (rotation & RR_Reflect_X)
|
|
return ret + 4;
|
|
else if (rotation & RR_Reflect_Y)
|
|
return y_reflected_map[ret];
|
|
else
|
|
return ret;
|
|
}
|
|
|
|
#define ALL_ROTATIONS (RR_Rotate_0 | RR_Rotate_90 | RR_Rotate_180 | RR_Rotate_270)
|
|
|
|
static MetaMonitorTransform
|
|
meta_monitor_transform_from_xrandr_all (Rotation rotation)
|
|
{
|
|
unsigned ret;
|
|
|
|
/* Handle the common cases first (none or all) */
|
|
if (rotation == 0 || rotation == RR_Rotate_0)
|
|
return (1 << META_MONITOR_TRANSFORM_NORMAL);
|
|
|
|
/* All rotations and one reflection -> all of them by composition */
|
|
if ((rotation & ALL_ROTATIONS) &&
|
|
((rotation & RR_Reflect_X) || (rotation & RR_Reflect_Y)))
|
|
return ALL_TRANSFORMS;
|
|
|
|
ret = 1 << META_MONITOR_TRANSFORM_NORMAL;
|
|
if (rotation & RR_Rotate_90)
|
|
ret |= 1 << META_MONITOR_TRANSFORM_90;
|
|
if (rotation & RR_Rotate_180)
|
|
ret |= 1 << META_MONITOR_TRANSFORM_180;
|
|
if (rotation & RR_Rotate_270)
|
|
ret |= 1 << META_MONITOR_TRANSFORM_270;
|
|
if (rotation & (RR_Rotate_0 | RR_Reflect_X))
|
|
ret |= 1 << META_MONITOR_TRANSFORM_FLIPPED;
|
|
if (rotation & (RR_Rotate_90 | RR_Reflect_X))
|
|
ret |= 1 << META_MONITOR_TRANSFORM_FLIPPED_90;
|
|
if (rotation & (RR_Rotate_180 | RR_Reflect_X))
|
|
ret |= 1 << META_MONITOR_TRANSFORM_FLIPPED_180;
|
|
if (rotation & (RR_Rotate_270 | RR_Reflect_X))
|
|
ret |= 1 << META_MONITOR_TRANSFORM_FLIPPED_270;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
output_get_boolean_property (MetaMonitorManagerXrandr *manager_xrandr,
|
|
MetaOutput *output, const char *propname)
|
|
{
|
|
gboolean value = FALSE;
|
|
Atom atom, actual_type;
|
|
int actual_format;
|
|
unsigned long nitems, bytes_after;
|
|
unsigned char *buffer;
|
|
|
|
atom = XInternAtom (manager_xrandr->xdisplay, propname, False);
|
|
XRRGetOutputProperty (manager_xrandr->xdisplay,
|
|
(XID)output->winsys_id,
|
|
atom,
|
|
0, G_MAXLONG, False, False, XA_CARDINAL,
|
|
&actual_type, &actual_format,
|
|
&nitems, &bytes_after, &buffer);
|
|
|
|
if (actual_type != XA_CARDINAL || actual_format != 32 || nitems < 1)
|
|
goto out;
|
|
|
|
value = ((int*)buffer)[0];
|
|
|
|
out:
|
|
XFree (buffer);
|
|
return value;
|
|
}
|
|
|
|
static gboolean
|
|
output_get_presentation_xrandr (MetaMonitorManagerXrandr *manager_xrandr,
|
|
MetaOutput *output)
|
|
{
|
|
return output_get_boolean_property (manager_xrandr, output, "_MUTTER_PRESENTATION_OUTPUT");
|
|
}
|
|
|
|
static int
|
|
normalize_backlight (MetaOutput *output,
|
|
int hw_value)
|
|
{
|
|
return round ((double)(hw_value - output->backlight_min) /
|
|
(output->backlight_max - output->backlight_min) * 100.0);
|
|
}
|
|
|
|
static int
|
|
output_get_backlight_xrandr (MetaMonitorManagerXrandr *manager_xrandr,
|
|
MetaOutput *output)
|
|
{
|
|
int value = -1;
|
|
Atom atom, actual_type;
|
|
int actual_format;
|
|
unsigned long nitems, bytes_after;
|
|
unsigned char *buffer;
|
|
|
|
atom = XInternAtom (manager_xrandr->xdisplay, "Backlight", False);
|
|
XRRGetOutputProperty (manager_xrandr->xdisplay,
|
|
(XID)output->winsys_id,
|
|
atom,
|
|
0, G_MAXLONG, False, False, XA_INTEGER,
|
|
&actual_type, &actual_format,
|
|
&nitems, &bytes_after, &buffer);
|
|
|
|
if (actual_type != XA_INTEGER || actual_format != 32 || nitems < 1)
|
|
goto out;
|
|
|
|
value = ((int*)buffer)[0];
|
|
|
|
out:
|
|
XFree (buffer);
|
|
if (value > 0)
|
|
return normalize_backlight (output, value);
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
static void
|
|
output_get_backlight_limits_xrandr (MetaMonitorManagerXrandr *manager_xrandr,
|
|
MetaOutput *output)
|
|
{
|
|
Atom atom;
|
|
xcb_connection_t *xcb_conn;
|
|
xcb_randr_query_output_property_reply_t *reply;
|
|
|
|
atom = XInternAtom (manager_xrandr->xdisplay, "Backlight", False);
|
|
|
|
xcb_conn = XGetXCBConnection (manager_xrandr->xdisplay);
|
|
reply = xcb_randr_query_output_property_reply (xcb_conn,
|
|
xcb_randr_query_output_property (xcb_conn,
|
|
(xcb_randr_output_t) output->winsys_id,
|
|
(xcb_atom_t) atom),
|
|
NULL);
|
|
|
|
/* This can happen on systems without backlights. */
|
|
if (reply == NULL)
|
|
return;
|
|
|
|
if (!reply->range || reply->length != 2)
|
|
{
|
|
meta_verbose ("backlight %s was not range\n", output->name);
|
|
goto out;
|
|
}
|
|
|
|
int32_t *values = xcb_randr_query_output_property_valid_values (reply);
|
|
output->backlight_min = values[0];
|
|
output->backlight_max = values[1];
|
|
|
|
out:
|
|
free (reply);
|
|
}
|
|
|
|
static int
|
|
compare_outputs (const void *one,
|
|
const void *two)
|
|
{
|
|
const MetaOutput *o_one = one, *o_two = two;
|
|
|
|
return strcmp (o_one->name, o_two->name);
|
|
}
|
|
|
|
static guint8 *
|
|
get_edid_property (Display *dpy,
|
|
RROutput output,
|
|
Atom atom,
|
|
gsize *len)
|
|
{
|
|
unsigned char *prop;
|
|
int actual_format;
|
|
unsigned long nitems, bytes_after;
|
|
Atom actual_type;
|
|
guint8 *result;
|
|
|
|
XRRGetOutputProperty (dpy, output, atom,
|
|
0, 100, False, False,
|
|
AnyPropertyType,
|
|
&actual_type, &actual_format,
|
|
&nitems, &bytes_after, &prop);
|
|
|
|
if (actual_type == XA_INTEGER && actual_format == 8)
|
|
{
|
|
result = g_memdup (prop, nitems);
|
|
if (len)
|
|
*len = nitems;
|
|
}
|
|
else
|
|
{
|
|
result = NULL;
|
|
}
|
|
|
|
XFree (prop);
|
|
|
|
return result;
|
|
}
|
|
|
|
static GBytes *
|
|
read_output_edid (MetaMonitorManagerXrandr *manager_xrandr,
|
|
XID winsys_id)
|
|
{
|
|
Atom edid_atom;
|
|
guint8 *result;
|
|
gsize len;
|
|
|
|
edid_atom = XInternAtom (manager_xrandr->xdisplay, "EDID", FALSE);
|
|
result = get_edid_property (manager_xrandr->xdisplay, winsys_id, edid_atom, &len);
|
|
|
|
if (!result)
|
|
{
|
|
edid_atom = XInternAtom (manager_xrandr->xdisplay, "EDID_DATA", FALSE);
|
|
result = get_edid_property (manager_xrandr->xdisplay, winsys_id, edid_atom, &len);
|
|
}
|
|
|
|
if (!result)
|
|
{
|
|
edid_atom = XInternAtom (manager_xrandr->xdisplay, "XFree86_DDC_EDID1_RAWDATA", FALSE);
|
|
result = get_edid_property (manager_xrandr->xdisplay, winsys_id, edid_atom, &len);
|
|
}
|
|
|
|
if (result)
|
|
{
|
|
if (len > 0 && len % 128 == 0)
|
|
return g_bytes_new_take (result, len);
|
|
else
|
|
g_free (result);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static gboolean
|
|
output_get_hotplug_mode_update (MetaMonitorManagerXrandr *manager_xrandr,
|
|
MetaOutput *output)
|
|
{
|
|
return output_get_boolean_property (manager_xrandr, output, "hotplug_mode_update");
|
|
}
|
|
|
|
static char *
|
|
get_xmode_name (XRRModeInfo *xmode)
|
|
{
|
|
int width = xmode->width;
|
|
int height = xmode->height;
|
|
|
|
if (xmode->hSkew != 0)
|
|
{
|
|
width += 2 * (xmode->hSkew >> 8);
|
|
height += 2 * (xmode->hSkew & 0xff);
|
|
}
|
|
|
|
return g_strdup_printf ("%dx%d", width, height);
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
|
|
XRRScreenResources *resources;
|
|
RROutput primary_output;
|
|
unsigned int i, j, k;
|
|
unsigned int n_actual_outputs;
|
|
int min_width, min_height;
|
|
Screen *screen;
|
|
BOOL dpms_capable, dpms_enabled;
|
|
CARD16 dpms_state;
|
|
|
|
if (manager_xrandr->resources)
|
|
XRRFreeScreenResources (manager_xrandr->resources);
|
|
manager_xrandr->resources = NULL;
|
|
|
|
dpms_capable = DPMSCapable (manager_xrandr->xdisplay);
|
|
|
|
if (dpms_capable &&
|
|
DPMSInfo (manager_xrandr->xdisplay, &dpms_state, &dpms_enabled) &&
|
|
dpms_enabled)
|
|
{
|
|
switch (dpms_state)
|
|
{
|
|
case DPMSModeOn:
|
|
manager->power_save_mode = META_POWER_SAVE_ON;
|
|
break;
|
|
case DPMSModeStandby:
|
|
manager->power_save_mode = META_POWER_SAVE_STANDBY;
|
|
break;
|
|
case DPMSModeSuspend:
|
|
manager->power_save_mode = META_POWER_SAVE_SUSPEND;
|
|
break;
|
|
case DPMSModeOff:
|
|
manager->power_save_mode = META_POWER_SAVE_OFF;
|
|
break;
|
|
default:
|
|
manager->power_save_mode = META_POWER_SAVE_UNSUPPORTED;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
manager->power_save_mode = META_POWER_SAVE_UNSUPPORTED;
|
|
}
|
|
|
|
XRRGetScreenSizeRange (manager_xrandr->xdisplay, DefaultRootWindow (manager_xrandr->xdisplay),
|
|
&min_width,
|
|
&min_height,
|
|
&manager->max_screen_width,
|
|
&manager->max_screen_height);
|
|
|
|
screen = ScreenOfDisplay (manager_xrandr->xdisplay,
|
|
DefaultScreen (manager_xrandr->xdisplay));
|
|
/* This is updated because we called RRUpdateConfiguration below */
|
|
manager->screen_width = WidthOfScreen (screen);
|
|
manager->screen_height = HeightOfScreen (screen);
|
|
|
|
resources = XRRGetScreenResourcesCurrent (manager_xrandr->xdisplay,
|
|
DefaultRootWindow (manager_xrandr->xdisplay));
|
|
if (!resources)
|
|
return;
|
|
|
|
manager_xrandr->resources = resources;
|
|
manager_xrandr->time = resources->configTimestamp;
|
|
manager->n_outputs = resources->noutput;
|
|
manager->n_crtcs = resources->ncrtc;
|
|
manager->n_modes = resources->nmode;
|
|
manager->outputs = g_new0 (MetaOutput, manager->n_outputs);
|
|
manager->modes = g_new0 (MetaMonitorMode, manager->n_modes);
|
|
manager->crtcs = g_new0 (MetaCRTC, manager->n_crtcs);
|
|
|
|
for (i = 0; i < (unsigned)resources->nmode; i++)
|
|
{
|
|
XRRModeInfo *xmode = &resources->modes[i];
|
|
MetaMonitorMode *mode;
|
|
|
|
mode = &manager->modes[i];
|
|
|
|
mode->mode_id = xmode->id;
|
|
mode->width = xmode->width;
|
|
mode->height = xmode->height;
|
|
mode->refresh_rate = (xmode->dotClock /
|
|
((float)xmode->hTotal * xmode->vTotal));
|
|
mode->name = get_xmode_name (xmode);
|
|
}
|
|
|
|
for (i = 0; i < (unsigned)resources->ncrtc; i++)
|
|
{
|
|
XRRCrtcInfo *crtc;
|
|
MetaCRTC *meta_crtc;
|
|
|
|
crtc = XRRGetCrtcInfo (manager_xrandr->xdisplay, resources, resources->crtcs[i]);
|
|
|
|
meta_crtc = &manager->crtcs[i];
|
|
|
|
meta_crtc->crtc_id = resources->crtcs[i];
|
|
meta_crtc->rect.x = crtc->x;
|
|
meta_crtc->rect.y = crtc->y;
|
|
meta_crtc->rect.width = crtc->width;
|
|
meta_crtc->rect.height = crtc->height;
|
|
meta_crtc->is_dirty = FALSE;
|
|
meta_crtc->transform = meta_monitor_transform_from_xrandr (crtc->rotation);
|
|
meta_crtc->all_transforms = meta_monitor_transform_from_xrandr_all (crtc->rotations);
|
|
|
|
for (j = 0; j < (unsigned)resources->nmode; j++)
|
|
{
|
|
if (resources->modes[j].id == crtc->mode)
|
|
{
|
|
meta_crtc->current_mode = &manager->modes[j];
|
|
break;
|
|
}
|
|
}
|
|
|
|
XRRFreeCrtcInfo (crtc);
|
|
}
|
|
|
|
primary_output = XRRGetOutputPrimary (manager_xrandr->xdisplay,
|
|
DefaultRootWindow (manager_xrandr->xdisplay));
|
|
|
|
n_actual_outputs = 0;
|
|
for (i = 0; i < (unsigned)resources->noutput; i++)
|
|
{
|
|
XRROutputInfo *output;
|
|
MetaOutput *meta_output;
|
|
|
|
output = XRRGetOutputInfo (manager_xrandr->xdisplay, resources, resources->outputs[i]);
|
|
|
|
meta_output = &manager->outputs[n_actual_outputs];
|
|
|
|
if (output->connection != RR_Disconnected)
|
|
{
|
|
GBytes *edid;
|
|
MonitorInfo *parsed_edid;
|
|
|
|
meta_output->winsys_id = resources->outputs[i];
|
|
meta_output->name = g_strdup (output->name);
|
|
|
|
edid = read_output_edid (manager_xrandr, meta_output->winsys_id);
|
|
if (edid)
|
|
{
|
|
gsize len;
|
|
|
|
parsed_edid = decode_edid (g_bytes_get_data (edid, &len));
|
|
if (parsed_edid)
|
|
{
|
|
meta_output->vendor = g_strndup (parsed_edid->manufacturer_code, 4);
|
|
if (parsed_edid->dsc_product_name[0])
|
|
meta_output->product = g_strndup (parsed_edid->dsc_product_name, 14);
|
|
else
|
|
meta_output->product = g_strdup_printf ("0x%04x", (unsigned)parsed_edid->product_code);
|
|
if (parsed_edid->dsc_serial_number[0])
|
|
meta_output->serial = g_strndup (parsed_edid->dsc_serial_number, 14);
|
|
else
|
|
meta_output->serial = g_strdup_printf ("0x%08x", parsed_edid->serial_number);
|
|
|
|
g_free (parsed_edid);
|
|
}
|
|
|
|
g_bytes_unref (edid);
|
|
}
|
|
|
|
if (!meta_output->vendor)
|
|
{
|
|
meta_output->vendor = g_strdup ("unknown");
|
|
meta_output->product = g_strdup ("unknown");
|
|
meta_output->serial = g_strdup ("unknown");
|
|
}
|
|
meta_output->width_mm = output->mm_width;
|
|
meta_output->height_mm = output->mm_height;
|
|
meta_output->subpixel_order = COGL_SUBPIXEL_ORDER_UNKNOWN;
|
|
meta_output->hotplug_mode_update = output_get_hotplug_mode_update (manager_xrandr, meta_output);
|
|
|
|
meta_output->n_modes = output->nmode;
|
|
meta_output->modes = g_new0 (MetaMonitorMode *, meta_output->n_modes);
|
|
for (j = 0; j < meta_output->n_modes; j++)
|
|
{
|
|
for (k = 0; k < manager->n_modes; k++)
|
|
{
|
|
if (output->modes[j] == (XID)manager->modes[k].mode_id)
|
|
{
|
|
meta_output->modes[j] = &manager->modes[k];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
meta_output->preferred_mode = meta_output->modes[0];
|
|
|
|
meta_output->n_possible_crtcs = output->ncrtc;
|
|
meta_output->possible_crtcs = g_new0 (MetaCRTC *, meta_output->n_possible_crtcs);
|
|
for (j = 0; j < (unsigned)output->ncrtc; j++)
|
|
{
|
|
for (k = 0; k < manager->n_crtcs; k++)
|
|
{
|
|
if ((XID)manager->crtcs[k].crtc_id == output->crtcs[j])
|
|
{
|
|
meta_output->possible_crtcs[j] = &manager->crtcs[k];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
meta_output->crtc = NULL;
|
|
for (j = 0; j < manager->n_crtcs; j++)
|
|
{
|
|
if ((XID)manager->crtcs[j].crtc_id == output->crtc)
|
|
{
|
|
meta_output->crtc = &manager->crtcs[j];
|
|
break;
|
|
}
|
|
}
|
|
|
|
meta_output->n_possible_clones = output->nclone;
|
|
meta_output->possible_clones = g_new0 (MetaOutput *, meta_output->n_possible_clones);
|
|
/* We can build the list of clones now, because we don't have the list of outputs
|
|
yet, so temporarily set the pointers to the bare XIDs, and then we'll fix them
|
|
in a second pass
|
|
*/
|
|
for (j = 0; j < (unsigned)output->nclone; j++)
|
|
{
|
|
meta_output->possible_clones[j] = GINT_TO_POINTER (output->clones[j]);
|
|
}
|
|
|
|
meta_output->is_primary = ((XID)meta_output->winsys_id == primary_output);
|
|
meta_output->is_presentation = output_get_presentation_xrandr (manager_xrandr, meta_output);
|
|
output_get_backlight_limits_xrandr (manager_xrandr, meta_output);
|
|
|
|
if (!(meta_output->backlight_min == 0 && meta_output->backlight_max == 0))
|
|
meta_output->backlight = output_get_backlight_xrandr (manager_xrandr, meta_output);
|
|
else
|
|
meta_output->backlight = -1;
|
|
|
|
n_actual_outputs++;
|
|
}
|
|
|
|
XRRFreeOutputInfo (output);
|
|
}
|
|
|
|
manager->n_outputs = n_actual_outputs;
|
|
|
|
/* Sort the outputs for easier handling in MetaMonitorConfig */
|
|
qsort (manager->outputs, manager->n_outputs, sizeof (MetaOutput), compare_outputs);
|
|
|
|
/* Now fix the clones */
|
|
for (i = 0; i < manager->n_outputs; i++)
|
|
{
|
|
MetaOutput *meta_output;
|
|
|
|
meta_output = &manager->outputs[i];
|
|
|
|
for (j = 0; j < meta_output->n_possible_clones; j++)
|
|
{
|
|
RROutput clone = GPOINTER_TO_INT (meta_output->possible_clones[j]);
|
|
|
|
for (k = 0; k < manager->n_outputs; k++)
|
|
{
|
|
if (clone == (XID)manager->outputs[k].winsys_id)
|
|
{
|
|
meta_output->possible_clones[j] = &manager->outputs[k];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static GBytes *
|
|
meta_monitor_manager_xrandr_read_edid (MetaMonitorManager *manager,
|
|
MetaOutput *output)
|
|
{
|
|
MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
|
|
|
|
return read_output_edid (manager_xrandr, output->winsys_id);
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_xrandr_set_power_save_mode (MetaMonitorManager *manager,
|
|
MetaPowerSave mode)
|
|
{
|
|
MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
|
|
CARD16 state;
|
|
|
|
switch (mode) {
|
|
case META_POWER_SAVE_ON:
|
|
state = DPMSModeOn;
|
|
break;
|
|
case META_POWER_SAVE_STANDBY:
|
|
state = DPMSModeStandby;
|
|
break;
|
|
case META_POWER_SAVE_SUSPEND:
|
|
state = DPMSModeSuspend;
|
|
break;
|
|
case META_POWER_SAVE_OFF:
|
|
state = DPMSModeOff;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
DPMSForceLevel (manager_xrandr->xdisplay, state);
|
|
DPMSSetTimeouts (manager_xrandr->xdisplay, 0, 0, 0);
|
|
}
|
|
|
|
static Rotation
|
|
meta_monitor_transform_to_xrandr (MetaMonitorTransform transform)
|
|
{
|
|
switch (transform)
|
|
{
|
|
case META_MONITOR_TRANSFORM_NORMAL:
|
|
return RR_Rotate_0;
|
|
case META_MONITOR_TRANSFORM_90:
|
|
return RR_Rotate_90;
|
|
case META_MONITOR_TRANSFORM_180:
|
|
return RR_Rotate_180;
|
|
case META_MONITOR_TRANSFORM_270:
|
|
return RR_Rotate_270;
|
|
case META_MONITOR_TRANSFORM_FLIPPED:
|
|
return RR_Reflect_X | RR_Rotate_0;
|
|
case META_MONITOR_TRANSFORM_FLIPPED_90:
|
|
return RR_Reflect_X | RR_Rotate_90;
|
|
case META_MONITOR_TRANSFORM_FLIPPED_180:
|
|
return RR_Reflect_X | RR_Rotate_180;
|
|
case META_MONITOR_TRANSFORM_FLIPPED_270:
|
|
return RR_Reflect_X | RR_Rotate_270;
|
|
}
|
|
|
|
g_assert_not_reached ();
|
|
}
|
|
|
|
static void
|
|
output_set_presentation_xrandr (MetaMonitorManagerXrandr *manager_xrandr,
|
|
MetaOutput *output,
|
|
gboolean presentation)
|
|
{
|
|
Atom atom;
|
|
int value = presentation;
|
|
|
|
atom = XInternAtom (manager_xrandr->xdisplay, "_MUTTER_PRESENTATION_OUTPUT", False);
|
|
XRRChangeOutputProperty (manager_xrandr->xdisplay,
|
|
(XID)output->winsys_id,
|
|
atom,
|
|
XA_CARDINAL, 32, PropModeReplace,
|
|
(unsigned char*) &value, 1);
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
|
|
MetaCRTCInfo **crtcs,
|
|
unsigned int n_crtcs,
|
|
MetaOutputInfo **outputs,
|
|
unsigned int n_outputs)
|
|
{
|
|
MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
|
|
unsigned i;
|
|
int width, height, width_mm, height_mm;
|
|
|
|
XGrabServer (manager_xrandr->xdisplay);
|
|
|
|
/* First compute the new size of the screen (framebuffer) */
|
|
width = 0; height = 0;
|
|
for (i = 0; i < n_crtcs; i++)
|
|
{
|
|
MetaCRTCInfo *crtc_info = crtcs[i];
|
|
MetaCRTC *crtc = crtc_info->crtc;
|
|
crtc->is_dirty = TRUE;
|
|
|
|
if (crtc_info->mode == NULL)
|
|
continue;
|
|
|
|
if (meta_monitor_transform_is_rotated (crtc_info->transform))
|
|
{
|
|
width = MAX (width, crtc_info->x + crtc_info->mode->height);
|
|
height = MAX (height, crtc_info->y + crtc_info->mode->width);
|
|
}
|
|
else
|
|
{
|
|
width = MAX (width, crtc_info->x + crtc_info->mode->width);
|
|
height = MAX (height, crtc_info->y + crtc_info->mode->height);
|
|
}
|
|
}
|
|
|
|
/* Second disable all newly disabled CRTCs, or CRTCs that in the previous
|
|
configuration would be outside the new framebuffer (otherwise X complains
|
|
loudly when resizing)
|
|
CRTC will be enabled again after resizing the FB
|
|
*/
|
|
for (i = 0; i < n_crtcs; i++)
|
|
{
|
|
MetaCRTCInfo *crtc_info = crtcs[i];
|
|
MetaCRTC *crtc = crtc_info->crtc;
|
|
|
|
if (crtc_info->mode == NULL ||
|
|
crtc->rect.x + crtc->rect.width > width ||
|
|
crtc->rect.y + crtc->rect.height > height)
|
|
{
|
|
XRRSetCrtcConfig (manager_xrandr->xdisplay,
|
|
manager_xrandr->resources,
|
|
(XID)crtc->crtc_id,
|
|
manager_xrandr->time,
|
|
0, 0,
|
|
None,
|
|
RR_Rotate_0,
|
|
NULL, 0);
|
|
|
|
crtc->rect.x = 0;
|
|
crtc->rect.y = 0;
|
|
crtc->rect.width = 0;
|
|
crtc->rect.height = 0;
|
|
crtc->current_mode = NULL;
|
|
}
|
|
}
|
|
|
|
/* Disable CRTCs not mentioned in the list */
|
|
for (i = 0; i < manager->n_crtcs; i++)
|
|
{
|
|
MetaCRTC *crtc = &manager->crtcs[i];
|
|
|
|
if (crtc->is_dirty)
|
|
{
|
|
crtc->is_dirty = FALSE;
|
|
continue;
|
|
}
|
|
if (crtc->current_mode == NULL)
|
|
continue;
|
|
|
|
XRRSetCrtcConfig (manager_xrandr->xdisplay,
|
|
manager_xrandr->resources,
|
|
(XID)crtc->crtc_id,
|
|
manager_xrandr->time,
|
|
0, 0,
|
|
None,
|
|
RR_Rotate_0,
|
|
NULL, 0);
|
|
|
|
crtc->rect.x = 0;
|
|
crtc->rect.y = 0;
|
|
crtc->rect.width = 0;
|
|
crtc->rect.height = 0;
|
|
crtc->current_mode = NULL;
|
|
}
|
|
|
|
g_assert (width > 0 && height > 0);
|
|
/* The 'physical size' of an X screen is meaningless if that screen
|
|
* can consist of many monitors. So just pick a size that make the
|
|
* dpi 96.
|
|
*
|
|
* Firefox and Evince apparently believe what X tells them.
|
|
*/
|
|
width_mm = (width / DPI_FALLBACK) * 25.4 + 0.5;
|
|
height_mm = (height / DPI_FALLBACK) * 25.4 + 0.5;
|
|
XRRSetScreenSize (manager_xrandr->xdisplay, DefaultRootWindow (manager_xrandr->xdisplay),
|
|
width, height, width_mm, height_mm);
|
|
|
|
for (i = 0; i < n_crtcs; i++)
|
|
{
|
|
MetaCRTCInfo *crtc_info = crtcs[i];
|
|
MetaCRTC *crtc = crtc_info->crtc;
|
|
|
|
if (crtc_info->mode != NULL)
|
|
{
|
|
MetaMonitorMode *mode;
|
|
XID *outputs;
|
|
unsigned int j, n_outputs;
|
|
int width, height;
|
|
Status ok;
|
|
unsigned long old_controlled_mask;
|
|
unsigned long new_controlled_mask;
|
|
|
|
mode = crtc_info->mode;
|
|
|
|
n_outputs = crtc_info->outputs->len;
|
|
outputs = g_new (XID, n_outputs);
|
|
|
|
old_controlled_mask = 0;
|
|
for (j = 0; j < manager->n_outputs; j++)
|
|
{
|
|
MetaOutput *output;
|
|
|
|
output = &manager->outputs[j];
|
|
|
|
if (output->crtc == crtc)
|
|
old_controlled_mask |= 1UL << j;
|
|
}
|
|
|
|
new_controlled_mask = 0;
|
|
for (j = 0; j < n_outputs; j++)
|
|
{
|
|
MetaOutput *output;
|
|
|
|
output = ((MetaOutput**)crtc_info->outputs->pdata)[j];
|
|
|
|
output->is_dirty = TRUE;
|
|
output->crtc = crtc;
|
|
new_controlled_mask |= 1UL << j;
|
|
|
|
outputs[j] = output->winsys_id;
|
|
}
|
|
|
|
if (crtc->current_mode == mode &&
|
|
crtc->rect.x == crtc_info->x &&
|
|
crtc->rect.y == crtc_info->y &&
|
|
crtc->transform == crtc_info->transform &&
|
|
old_controlled_mask == new_controlled_mask)
|
|
{
|
|
/* No change */
|
|
goto next;
|
|
}
|
|
|
|
ok = XRRSetCrtcConfig (manager_xrandr->xdisplay,
|
|
manager_xrandr->resources,
|
|
(XID)crtc->crtc_id,
|
|
manager_xrandr->time,
|
|
crtc_info->x, crtc_info->y,
|
|
(XID)mode->mode_id,
|
|
meta_monitor_transform_to_xrandr (crtc_info->transform),
|
|
outputs, n_outputs);
|
|
|
|
if (ok != Success)
|
|
{
|
|
meta_warning ("Configuring CRTC %d with mode %d (%d x %d @ %f) at position %d, %d and transfrom %u failed\n",
|
|
(unsigned)(crtc->crtc_id), (unsigned)(mode->mode_id),
|
|
mode->width, mode->height, (float)mode->refresh_rate,
|
|
crtc_info->x, crtc_info->y, crtc_info->transform);
|
|
goto next;
|
|
}
|
|
|
|
if (meta_monitor_transform_is_rotated (crtc_info->transform))
|
|
{
|
|
width = mode->height;
|
|
height = mode->width;
|
|
}
|
|
else
|
|
{
|
|
width = mode->width;
|
|
height = mode->height;
|
|
}
|
|
|
|
crtc->rect.x = crtc_info->x;
|
|
crtc->rect.y = crtc_info->y;
|
|
crtc->rect.width = width;
|
|
crtc->rect.height = height;
|
|
crtc->current_mode = mode;
|
|
crtc->transform = crtc_info->transform;
|
|
|
|
next:
|
|
g_free (outputs);
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < n_outputs; i++)
|
|
{
|
|
MetaOutputInfo *output_info = outputs[i];
|
|
MetaOutput *output = output_info->output;
|
|
|
|
if (output_info->is_primary)
|
|
{
|
|
XRRSetOutputPrimary (manager_xrandr->xdisplay,
|
|
DefaultRootWindow (manager_xrandr->xdisplay),
|
|
(XID)output_info->output->winsys_id);
|
|
}
|
|
|
|
output_set_presentation_xrandr (manager_xrandr,
|
|
output_info->output,
|
|
output_info->is_presentation);
|
|
|
|
output->is_primary = output_info->is_primary;
|
|
output->is_presentation = output_info->is_presentation;
|
|
}
|
|
|
|
/* Disable outputs not mentioned in the list */
|
|
for (i = 0; i < manager->n_outputs; i++)
|
|
{
|
|
MetaOutput *output = &manager->outputs[i];
|
|
|
|
if (output->is_dirty)
|
|
{
|
|
output->is_dirty = FALSE;
|
|
continue;
|
|
}
|
|
|
|
output->crtc = NULL;
|
|
output->is_primary = FALSE;
|
|
}
|
|
|
|
XUngrabServer (manager_xrandr->xdisplay);
|
|
XFlush (manager_xrandr->xdisplay);
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_xrandr_change_backlight (MetaMonitorManager *manager,
|
|
MetaOutput *output,
|
|
gint value)
|
|
{
|
|
MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
|
|
Atom atom;
|
|
int hw_value;
|
|
|
|
hw_value = round ((double)value / 100.0 * output->backlight_max + output->backlight_min);
|
|
|
|
atom = XInternAtom (manager_xrandr->xdisplay, "Backlight", False);
|
|
XRRChangeOutputProperty (manager_xrandr->xdisplay,
|
|
(XID)output->winsys_id,
|
|
atom,
|
|
XA_INTEGER, 32, PropModeReplace,
|
|
(unsigned char *) &hw_value, 1);
|
|
|
|
/* We're not selecting for property notifies, so update the value immediately */
|
|
output->backlight = normalize_backlight (output, hw_value);
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_xrandr_get_crtc_gamma (MetaMonitorManager *manager,
|
|
MetaCRTC *crtc,
|
|
gsize *size,
|
|
unsigned short **red,
|
|
unsigned short **green,
|
|
unsigned short **blue)
|
|
{
|
|
MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
|
|
XRRCrtcGamma *gamma;
|
|
|
|
gamma = XRRGetCrtcGamma (manager_xrandr->xdisplay, (XID)crtc->crtc_id);
|
|
|
|
*size = gamma->size;
|
|
*red = g_memdup (gamma->red, sizeof (unsigned short) * gamma->size);
|
|
*green = g_memdup (gamma->green, sizeof (unsigned short) * gamma->size);
|
|
*blue = g_memdup (gamma->blue, sizeof (unsigned short) * gamma->size);
|
|
|
|
XRRFreeGamma (gamma);
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_xrandr_set_crtc_gamma (MetaMonitorManager *manager,
|
|
MetaCRTC *crtc,
|
|
gsize size,
|
|
unsigned short *red,
|
|
unsigned short *green,
|
|
unsigned short *blue)
|
|
{
|
|
MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
|
|
XRRCrtcGamma *gamma;
|
|
|
|
gamma = XRRAllocGamma (size);
|
|
memcpy (gamma->red, red, sizeof (unsigned short) * size);
|
|
memcpy (gamma->green, green, sizeof (unsigned short) * size);
|
|
memcpy (gamma->blue, blue, sizeof (unsigned short) * size);
|
|
|
|
XRRSetCrtcGamma (manager_xrandr->xdisplay, (XID)crtc->crtc_id, gamma);
|
|
|
|
XRRFreeGamma (gamma);
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_xrandr_init (MetaMonitorManagerXrandr *manager_xrandr)
|
|
{
|
|
MetaBackendX11 *backend = META_BACKEND_X11 (meta_get_backend ());
|
|
|
|
manager_xrandr->xdisplay = meta_backend_x11_get_xdisplay (backend);
|
|
|
|
if (!XRRQueryExtension (manager_xrandr->xdisplay,
|
|
&manager_xrandr->rr_event_base,
|
|
&manager_xrandr->rr_error_base))
|
|
{
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
/* We only use ScreenChangeNotify, but GDK uses the others,
|
|
and we don't want to step on its toes */
|
|
XRRSelectInput (manager_xrandr->xdisplay,
|
|
DefaultRootWindow (manager_xrandr->xdisplay),
|
|
RRScreenChangeNotifyMask
|
|
| RRCrtcChangeNotifyMask
|
|
| RROutputPropertyNotifyMask);
|
|
}
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_xrandr_finalize (GObject *object)
|
|
{
|
|
MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (object);
|
|
|
|
if (manager_xrandr->resources)
|
|
XRRFreeScreenResources (manager_xrandr->resources);
|
|
manager_xrandr->resources = NULL;
|
|
|
|
G_OBJECT_CLASS (meta_monitor_manager_xrandr_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_xrandr_class_init (MetaMonitorManagerXrandrClass *klass)
|
|
{
|
|
MetaMonitorManagerClass *manager_class = META_MONITOR_MANAGER_CLASS (klass);
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
object_class->finalize = meta_monitor_manager_xrandr_finalize;
|
|
|
|
manager_class->read_current = meta_monitor_manager_xrandr_read_current;
|
|
manager_class->read_edid = meta_monitor_manager_xrandr_read_edid;
|
|
manager_class->apply_configuration = meta_monitor_manager_xrandr_apply_configuration;
|
|
manager_class->set_power_save_mode = meta_monitor_manager_xrandr_set_power_save_mode;
|
|
manager_class->change_backlight = meta_monitor_manager_xrandr_change_backlight;
|
|
manager_class->get_crtc_gamma = meta_monitor_manager_xrandr_get_crtc_gamma;
|
|
manager_class->set_crtc_gamma = meta_monitor_manager_xrandr_set_crtc_gamma;
|
|
}
|
|
|
|
gboolean
|
|
meta_monitor_manager_xrandr_handle_xevent (MetaMonitorManagerXrandr *manager_xrandr,
|
|
XEvent *event)
|
|
{
|
|
MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_xrandr);
|
|
gboolean hotplug;
|
|
|
|
if ((event->type - manager_xrandr->rr_event_base) != RRScreenChangeNotify)
|
|
return FALSE;
|
|
|
|
XRRUpdateConfiguration (event);
|
|
|
|
meta_monitor_manager_read_current_config (manager);
|
|
|
|
/* If this config matches our existing one, don't bother doing anything. */
|
|
if (meta_monitor_config_match_current (manager->config, manager))
|
|
return TRUE;
|
|
|
|
hotplug = manager_xrandr->resources->timestamp < manager_xrandr->resources->configTimestamp;
|
|
if (hotplug)
|
|
{
|
|
/* This is a hotplug event, so go ahead and build a new configuration. */
|
|
meta_monitor_manager_on_hotplug (manager);
|
|
}
|
|
else
|
|
{
|
|
/* Something else changed -- tell the world about it. */
|
|
meta_monitor_manager_rebuild_derived (manager);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|