diff options
Diffstat (limited to 'panels/display')
27 files changed, 9283 insertions, 0 deletions
diff --git a/panels/display/TODO b/panels/display/TODO new file mode 100644 index 0000000..f09425c --- /dev/null +++ b/panels/display/TODO @@ -0,0 +1,837 @@ +Highlevel overview: + +Tablet rotation things +only when there is a tablet attached. + +Here is the OS X Display menu: + + Detect Displays + Turn on mirroring + -------------------------- + SyncMaster + - 1280 x 1024, 60 Hz, Millions + - 1344 x ... + -------------------------------- + Color LCD + - 1024 x 1024 ... + -------------------------- + Displays Preferences + + Color LCD means "laptop panel". + +- GTK+ work. + + Allow applications to be notified whenever monitors are added + or removed. Allow applications to get more detailed + information about the connected monitors. + + The main complication is that XRRGetScreenResources() is very + slow. We could call it only when the X server sends an event, + but it's not desirable to have every application freeze for + half a second. And certainly not desirable to have the X + server block for n * 0.5 seconds. + + With the X server work below we should be fine just calling + XRRGetScreenResources on startup and in response to events. + +- X server work: + + X server needs to poll for whether a monitor is plugged + in. Whenever it detects a change, it should do an EDID query, + and cache the resulting information. That way XRRGetScreenResources() + can be the speed of a normal roundtrip. It's desirable that + normal client requests can still be processed during the EDID + querying, but only a nice-to-have. + + Drivers need to work reliably. There could be substantial work + here. For F9, possibly only the Intel driver can be made to + work. + + Interrupts and events must be generated whenever something changes + about the outputs, if necessary by polling. + + Events must be emitted whenever something changes, including when + the reason for the change is a manual change. + + The maximum framebuffer must be dynamically changable. + +- Control panel work: + Capplet needs to be written. The main complications: + + - It needs to pay attention to events from the X server + and update itself, ie., add show new monitors if they become + available when the applet is shown. + + - It needs to store information under a key computed + from a monitor identifier. The complication here is that + it's not completely clear how to do this in GConf. + + - Would probably be worthwhile to drop libgnome/libgnomeui from + the craplets. + +- Metacity work: + - Metacity is already Xinerama aware, but it needs to update itself + when monitors come and go. + +- GNOME panel work: + - Is already Xinerama aware, but needs to listen and update itself + when monitors change. + +- Evince work: + - Make sure it deals sensibly with multiple monitors + +- OpenOffice work: + - Make sure it deals sensibly with multiple monitors + +- An Xlib call to just return all the available information would be + useful. At the moment we have to do a bunch of roundtrips to + get the information. This is a would-be-nice though. + +- A dbus service could be written that pops up the applet whenever a + monitor. It should only pop up if the new monitor is unknown. This + is at best a nice-to-have, and low priority in my opinion. + + +******************* Metacity + +Havoc: + +> I was just talking to bryan about this and "helping" him design it ;-) + +> But I wanted to be sure and lobby for a fix window managers +> need. Basically right now the WM can't tell "physical" from +> "logical" monitors. + +> A "logical" monitor is a desktop; it has its own panel, windows +> maximize to it, etc. + +> A "physical" monitor is a piece of hardware. + +> Sometimes people want to combine physical monitors into a video wall +> or just two monitors treated as one. Or at least a couple of noisy +> people in bugzilla want to do this. + +> When people talk about a "Xinerama aware" app or WM they usually +> mean that all physical monitors are treated as logical monitors, +> while lack of Xinerama-aware means treating the entire X screen (all +> physical monitors) as one logical monitor. + +> The problem is that the setting for "ignore Xinerama" or "don't be +> Xinerama aware" should be global to the desktop (GTK, all apps, WM) +> and should not be a window manager setting. + +> Bryan thought people who wanted non-Xinerama-aware should just use +> fvwm, which may be right, but what I'd say is that if there is any +> setting for this, it should be desktop-global and in this monitor +> config dialog. + +> It should not be a metacity or Compiz option, but in some way an X +> option in short. The implementation could be either an X server +> feature or an EWMH hint or whatever, but it should be controlled by +> the monitor config dialog and used by apps, GTK, etc. in addition to +> used by the WM. + +> People tend to insist this should be a WM option, but that's just +> busted, since GTK and apps also have Xinerama-awareness features. + + +******************* EDID + +edid-decode enhancements: + +- Rejects years <= 0x0f for all versions, but this should only be done + for monitors claiming conformance to 1.4 (since 1.4 was released in + 2006). A monitor produced in 2005 should have 0x0f - it's the only + reasonable thing to do. + +- Uses 0x80 as the conformance mask for 1.4, should be 0 + +- Should read from stdin + +- Should parse xrandr -verbose output more robustly + +- Color depth computation is wrong. It uses the formula + + (edid[0x14] >> 3) + 2 + + The correct formula to use is + + (edid[0x14] & 0x70) >> 3 + 4 + +- + +-=-=-=- +Computing a display name from EDID information: + + vendor = lookup_vendor (code); + + if (dsc_product && !is_gobbledigook (dsc_product)) + { + if (vendor && !fuzzy_string_search (vendor, dsc_product)) + prepend (vendor); + } + else + { + if (vendor) + append (vendor); + else + append ("Unknown"); + } + + if (has size) + { + convert_to_inches() + + append (" %d\"", inches) + } + +(Does this internationalize at all)? + +We also need the ability to get laptop names. The laptop panel may report +a manufacturer that has nothing to do with the laptop manufacturer. + +Needed XRandr output properties: + +- Modes that the monitor supports, or enough information that the + client can go throught the list of modes for the relevant + CRTC/Outputs and filter those out that the monitor can't support. + +- The preferred mode, if any. Also useful if we could get a "strongly + preferred" indication if it's an LCD with a fixed resolution. + +- Sufficient information that a fairly specific identifier can be + computed. The algorithm the client should use is: + + 1 Have we seen exactly this monitor before? If yes, use + settings for that. + + 2 Have we seen a monitor with similar specs before? If yes, + use settings for that. (But don't save, unless the user + changes the settings). + + 3 Otherwise, use some reasonable default for the monitor and + save it. + + A setting should only be used if the CRTC/Output allows it. Ie,. if + a user has installed a new video card, then previously-used settings + may no longer apply, so this must be checked every time. + + (1) Implies that we really need a globally unique identifier for + monitors. (2) is useful in an enterprise setting, but not absolutely + critical, since (3) would still handle the majority of cases. + + There is a question here: Where are machine specific preferences + stored? Havoc mentions three possibilities here: + + http://mail.gnome.org/archives/gnomecc-list/2001-October/msg00023.html + + I'm not sure if any of them are implementable at this point. Also + (1) may mostly take care of the problem. + + + Usecases: + + 1. Fixed setup with some number of monitors. + - They should be set to the correct mode on login. + Note that this involves setting the right position in the + framebuffer too. + + What if someone swaps two monitors? Users are going to expect + that the images will switch position. + + 2. Laptop being moved between home and work + - Setups should be detected and the correct mode set, at least on + login, but ideally when you put the laptop into the docking + station. + + 3. Laptop gets projector plugged in. + + Note the same model monitor can be used in two different ways. Ie., + at home, it's being used at one resolution, at work the same type of + monitor is used at a different resolution. + + Simple solution: + + - The on-disk database is just a list of monitors. Each monitor has an + associated mode. This has these problems: + - If someone uses the same monitor model in two different ways. + - If someone swaps the monitors around + + Better solution + + - The on-disk database is a list of configurations, where a + configuration is a list of monitors and what outputs they are + connected to, and the position in the framebuffer. + + - Picking a default configuration is then a matter of selecting the + closest existing configuration from the database. + + - If the stored configuration is a subset of the existing, + then use that - then pick the best mode available for the + rest of the monitors + + - If the stored configuration is a superset of the existing, + then use the projection of the configuration onto the monitors. + + - Pick the configuration with the most overlap in monitors. + Although, if a configuration differs only in what outputs + they are connected to, then those outputs should probably + get their original modes set. + + - Or maybe simply: + + - If there is an exact match, use it, if not, pick a default. + + - Picking a new default must never change the mode of any existing + output. + +******************* Capplet + +Somehow the applet will find out that a new monitor is plugged in +(either through notification, or through a refresh button). When this +happens, this monitor is looked up in a database and if it is found, +some suitable mode is set. + +Restrictions on the modes: + +- Monitors that are already plugged in should not get their mode + changed just because a new monitor is plugged in. + +- If the exact configuration of monitors is known, and all the old + monitors have the same mode as the known configuration, then just use + the known configuration. Also do this, if the configuration is a + subset of something known. + +- Otherwise, if the configuration is a subset of a known configuration + where the only difference is that existing monitors have different + modes, then try and convert that mode to something we can know + about. Maybe configurations should be stored in terms of edges that + line up. + +- Otherwise, just pick some good default for the mode, probably based + on the EDID prferred mode if possible. By default cloning is + probably best. + +- How do virtual desktops interact with this? + + +g-s-d: + +- On startup + + - It reads the configuration file into memory + + capplet --configure + + - It gathers the existing configuration from randr + + - If the existing config is in the file, set that mode + +- On changes, including changes to the config file [this is crack] + + - Reread configuration file + + - Compare new configuration to database, if it is there, set the + mode as appropriate + + - If a monitor was added, pop up a bubble + + capplet --show-bubble + + capplet --set-mode + +capplet + +- On changes + + - Update GUI + +- When user changes something, + + - Write configuration to file + + - Signal gsd somehow + +Schemes: + - configuration file changes + - randr code will have to be shared between gcc and gsd + + - binary installed by gcc + - something will still have to listen for changes to pop + up the notification bubble. + +Structure of capplet: + +- There is a database on disk with monitors and their corresponding + settings. + +- On startup, this database is read into memory. When the user accepts + new settings, it is written back to disk. + +- When something changes about the settings + + - If new configuration is in the database, use that mode + + - Else, find all outputs that are now connected but weren't before, + and set a default mode for them. + + - If GUI is running, update graphics. + + + - Notification thing: + - if + + - if the new configuration is found in the database, use it + + and added if they are not already there. Initial settings are + 1 what the output is already doing, if anything + 2 based on an existing sufficiently similar monitor, if possible + 3 some reasonable default. + +- When the user changes settings in the GUI, the corresponding monitor + in the database is updated. + +- Whenever the GUI settings change, for all displayed monitors the + possible modes are recomputed. + +- Whenever a new monitor is selected in the GUI, it first gets all its + possible modes computed based on the selections on other + outputs. Then, if the possible modes include the existing choice of + resolution, that is selected. + + Actually, + + - initially, the settings are copied from the current settings + + - whenever a gui setting changes for a monitor, all the other + monitors get their list of choices set to whatever is possible + given the chocie for the current monitor. A 'desired mode' is + maintained, and the closest choice to that is displayed. Whenever + the user actively selects something, that becomes the desired mode + for that monitor. + +- Required + + - Generate all outputs that are newly connected + + foreach_newly_connected (Configuration *before, Configuration *after, + OutputFunc); + + - A way to generate the best mode for a connected output + + existing best_mode() can probably be used + + - Given a list of modes, pick the one closest to a given mode. + + (a possibility here is: pick an exact match, if that's + impossible, then pick the best one with the same + width/height, if that's impossible, then just pick the + best mode on the list). + + - For a configuation, fix the mode for a subset of the outputs, then + list the combinations for the rest of the outputs. + + An obvious possibility here is to simply list all possibilities, + then weed out those that don't work. Is this too expensive? + It might be. + +Structure of login time program: + +- The configuration database is read + +- The current hardware configuration is generated + +- If the current configuration is found in the database, that mode is set. + +- If it isn't found, then nothing changes. + + This could just be gnome-screen-resolution-capplet --reset + +******************* Things that need to be done to the xrandr.patch: + +=== + +XRRGetScreenResources() is a roundtrip and very slow (~0.5 s). GTK+ +needs to keep information up-to-date by tracking events rather than +calling this function. In fact we probably can't call it at all unless +its performance improves significantly. + +If EDID processing really has to be this slow, and we can't get +interrupts when monitors are plugged in, then we have a problem, +because we can't do anything this expensive once per second. + + +Detailed notes (but most of the patch should be rewritten): + + +=== FIXME in gdkscreen-x11.c in get_width_mm() + +/* monitor pixel width / screen pixel width * screen_physical width */ + + + +=== Check for 1.2 library + +The patch should check that the 1.2 version of the XRandR library is +available before using the functions. A possibility is to not use any +RandR unless 1.2 is available, another is to conditionalize the code. + +The most sane thing is probably to just require 1.2. + +On the other hand, installing a newer gtk+ on a system with older X is +probably not that unusual, so maybe it's better to do the full 1.0, +vs. 1.1 vs 1.2 check. + +For now it just requires 1.2. + +Actually, this might be fine because the only place where we make use +of a 1.1 library is in the _gdk_x11_screen_size_changed() function, +but there we have a fallback that just updates the variables in the +Screen struct itself. + +So, only defining HAVE_RANDR if we detect 1.2 should be ok. + +=== Monitor information available + +- Subpixel information. This should be set automatically for the fonts and + store under the name of the monitor. If the user changes the font + configuration, that change should also be stored under the monitor name. + +- When a monitor we don't know about is plugged in, a configuration should + be generated: + + - Screen size, computed based on the location of the screens + + - RGBA information + + - Whether the screen has a panel on it + + - If there is a conflict between stored information and EDID, + the stored information wins + + + +New API so far: + +(* monitors_changed) signal +gdk_screen_get_monitor_width_mm() +gdk_screen_get_monitor_height_mm() +gdk_screen_get_monitor_name() => Note this is the output (eg. "DVI-0") + +We should probably also have +get_manufacturer() +get_serial() +get_resolutions() + +etc. + +Should there be a GdkMonitor object that would correspond to an +output? Or maybe GdkOutput? + +screen_list_monitors() + + +*************************** Issues XRandR/Xserver + +- We need polling in the X server, whenever something changes, X must + recompute the information and cache it, then send an event. Note the + situation where the user disconnects and reconnects a monitor within + the polling interval. The event could missed in that case since the polling + cannot do a full EDID query. Difficult to see a way around this. + + Actually, DDC allows random access, so it should be possible to just + read theq vendor id and manufacturer codes. This can be done once a + second without a problem. The polling should be turned off in power + saving mode anyway. + + - Driver work: + + - Intel driver: + + - EDID information is not reported for VGA when the output is not + turned on (i945 laptop). + + - Screen size must be dynamically changable. (No xorg.conf changes + should be required). + + - Make use of ACPI information when possible. + + Adam has code on his freedesktop page. + + - i830 laptop can be put in a state where XRandr reports that no + outputs are connected to a CRTC, but the panel is on. + + - Plug in VGA + - xrandr --auto + - xrandr --output VGA --off + - run chk + - xrandr --verbose will now not report any outputs as turned on + - run chk again - all screens will be turned off + + - Small Sun monitor - an 1152x921 mode is generated, but the + monitor doesn't handle that. The monitor itself only claims to + handle 1152x920. It doesn't look to me like there is anything + in the EDID information that would indicate that it could handle + 1152x921. + + This happens with a radeon as wellso it may be a bug in the + generic X server EDID parsing. The X server apparently + interpretes the standard timing 1152x920 as 1152x921. + + This happens because the X server uses + + hsize * 4 / 5 + + which gives 921 for 1152. By using + + (hsize / 5) * 4 + + you get 920. The 66 Hz version can bet set, the 76 Hz mode gets + sync out of range. (Would be interesting to find out whether the + 1152x920 ModeLine would allow the 76 Hz version to be set). + + This is for the ATI driver as shipped in F8: + + - XRRGetScreenResources() takes half a second. + + - Adam has now removed a workaround that caused some of the slowdown. + + - If a DVI monitor is disconnected, you get "Unknown" for connection + status. + + - If a VGA monitor is plugged in, then EDID information is not + available, even after running xrandr --verbose. The monitor has + to be plugged in at driver startup time, apparently. + + - Logging out and logging back in often results in some random mode being + set. We need mode selection to not be completely screwed up. + Currently it is. + + - The set up at server startup needs to be fixed. *If* randr actually works, + then we might be able to do something sensible. + + - We need to revisit the idea that many monitors have broken EDID data. + This may be less widespread than previously believed. + +- It may be useful to return the connector names as identifiers instead + of relying on UTF-8 strings. Ie., have an enum + + { UNKNOWN, OTHER, DVI, VGA, HDMI, ..., } + + in addition to the string. The difference between UNKNOWN and OTHER is that + UNKNOWN means the driver doesn't know, whereas OTHER means it is something + not listed in the enum (which could be listed in a later version). + +- Mouse cursor should be confined to the visible area. (It is already, I think) + +- It looks like EDID information is only available for one output + even though it is actually read according to the log file. + (nv, intel drivers) + + +********************************* + + + +DONE: + +Server work: + + - i830 laptop incorrectly reports BadMatch when you configure the + CRTC to drive both VGA and LVDS with the 1024x768 mode that both + outputs can handle. (It should return 'failed' if it can't do + that). Same for i945 laptop. It seems as if the same CRTC can't + drive more than one output at the same time on Intel. + + This was a client bug, but the documentation for SetCrtcConfig + should say that BadMatch will be returned if the outputs aren't + clones. + +GTK+ patch is in now. + +=== Add helper function + + ++ if (screen_x11->randr12) ++ { ++ XRRScreenResources *sr; ++ XRROutputInfo *output; ++ gchar *retval; ++ ++ sr = XRRGetScreenResources ( screen_x11->xdisplay, ++ screen_x11->xroot_window ); ++ ++ output = XRRGetOutputInfo ( screen_x11->xdisplay, ++ sr, ++ (RROutput)screen_x11->act_outputs[monitor_num] +); + + Might be worthwhile to factor this out into a + gdk_screen_get_output_info (screen, monitor_num) + helper function ? + +Instead of cutting and pasting all over creation + +* Calling XRRGetScreenResources all the time is not going to fly. It + takes hundreds of milliseconds ... Even if it didn't, it wouldn't + be acceptable to do all those roundtrips. + + +=== Some g_prints left + + +=== Version check + +Should be (maj > 1) || (maj == 1 && min >= 2) + + +=== Grep for TODO + + +=== Setup XRRSelectInput() + + You should call XRRSelectInput() at the same place where you are + calling XSelectInput() right now. The right place to handle the + XRandr events is the huge switch in gdkevents-x11.c:gdk_event_translate + Check out how other extension events are handled there, like + XKB, or XFixes. + + +=== Lots of variable naming issues, such as act_output and noutput + +=== Needs to select the input, and hook it up to the signal + +=== Add version markers to API + +=== API to turn monitors on and off? + +- DPMS not exposed through randr, maybe should be + + - DPMS is presumably a property of either an + output or a CRTC. Logically it's an output. + +- Need events when DPMS happens. Exposing the "screen saving on" on + dbus may not be good enough. + +=== Why does init_multihead_support() start by freeing monitors and +outputs? + +=== Do we disable Xinerama support entirely when 1.2 is in use? + +=== We should expose information about what parts of the screen monitors +are viewing. + +=== Make use of the EDID information? + + +-- details for X server -- + +In nv driver SorSetOutputProperty should return TRUE for unknown +properties. (Like the Intel driver does). + +Detecting plugged in + +- Periodically poll + - + + - One ddc probe takes 5 ms, according to a comment in the intel + driver. Running this twice a second would mean spending 1% of + overall time doing ddc polling, which is almost certainly not + acceptable. + + 1) Async I2C: + + void I2CProbeAsync(..., callback, data); + Bool I2CPending() + void I2CUpdate() + + In Dispatch, call I2CUpdate() + Before going idle, do + + while (I2CPending()) + I2CUpdate() + + Would need + RegisterDispatchFunction() (Is this called Wakeup?) + RegisterIdleFunction() + + Note the idle function should have the option of saying: + "check if something else happened; if not, call me again" and + "ok, I'm done - go idle". Otherwise, we would be blocking for + 5 ms whenever the X server went idle. So actually the idle + function should be + + if (I2CPending()) + { + I2CUpdate(); + return TRUE; /* call me again */ + } + else + { + return FALSE; /* I'm done */ + } + + What happens if another I2C requests come in while an async one + is pending? Most likely we simply finish whatever is going on, + then process the new request. + + What happens if an X request takes so long that we get timeouts on + the i2c bus? Good question. Need to read the VESA ddc spec. + + 2) Run the polling in a separate thread. + + Probably crack. + + 3) Run the polling less, maybe once every three seconds. + +-- details for control panel -- +Screen changes + - Currently it is polling via rw_screen_refresh(), which will always emit + a screen-changed event. In reponse to this event the capplet currently + checks whether anything changed physically about the setup. This means + the capplet can't react to external changes to modes. On the other hand + if it didn't +Disallow combinations that would exceed the screen ranges. + - Note rotations + +Give rw objects stable positions in memory so that they can be cached +across screen_changed events. + +Add Clone Mode + +Drag and drop for the monitors + - 2 dimensional layout + +Store make and model in monitors.xml, then if serial numbers don't +match, fall back to a make and model match. Users with an nfs mounted +home directory should not have to reconfigure for each new system they +log in to. + +Make sure text is scaled correctly + +Need to sanitize naming + RWOutput vs Output - should probably be OutputInfo + rate vs. freq - decide on one + +Should probably reconsider the use of null terminated arrays. +Maybe lists would be better. + +Pick a fixed scale, so that two 1024x768 don't look like two 6x4. + - An alternative would be to draw a checkerboard pattern + below the monitors. + + + +done: + +Add rotation + +Disable panel checkbox for now + +Patch into gnome-desktop + +Find out how to share code between gcc and gsd + +Make it assign coordinates correctly + - including computing correct screen size + diff --git a/panels/display/cc-display-arrangement.c b/panels/display/cc-display-arrangement.c new file mode 100644 index 0000000..ae3541e --- /dev/null +++ b/panels/display/cc-display-arrangement.c @@ -0,0 +1,978 @@ +/* cc-display-arrangement.c + * + * Copyright (C) 2007, 2008, 2017 Red Hat, Inc. + * Copyright (C) 2013 Intel, Inc. + * + * Written by: Benjamin Berg <bberg@redhat.com> + * + * 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, 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 <math.h> +#include "cc-display-arrangement.h" +#include "cc-display-config.h" + +struct _CcDisplayArrangement +{ + GtkDrawingArea object; + + CcDisplayConfig *config; + + cairo_matrix_t to_widget; + cairo_matrix_t to_actual; + + gboolean drag_active; + CcDisplayMonitor *selected_output; + CcDisplayMonitor *prelit_output; + /* Starting position of cursor inside the monitor. */ + gdouble drag_anchor_x; + gdouble drag_anchor_y; + + guint major_snap_distance; +}; + +typedef struct _CcDisplayArrangement CcDisplayArrangement; + +enum { + PROP_0, + PROP_CONFIG, + PROP_SELECTED_OUTPUT, + PROP_LAST +}; + +typedef enum { + SNAP_DIR_NONE = 0, + SNAP_DIR_X = 1 << 0, + SNAP_DIR_Y = 1 << 1, + SNAP_DIR_BOTH = (SNAP_DIR_X | SNAP_DIR_Y), +} SnapDirection; + +typedef struct { + cairo_matrix_t to_widget; + guint major_snap_distance; + gdouble dist_x; + gdouble dist_y; + gint mon_x; + gint mon_y; + SnapDirection snapped; +} SnapData; + +#define MARGIN_PX 0 +#define MARGIN_MON 0.66 +#define MAJOR_SNAP_DISTANCE 25 +#define MINOR_SNAP_DISTANCE 5 +#define MIN_OVERLAP 25 + +G_DEFINE_TYPE (CcDisplayArrangement, cc_display_arrangement, GTK_TYPE_DRAWING_AREA) + +static GParamSpec *props[PROP_LAST]; + +static void +apply_rotation_to_geometry (CcDisplayMonitor *output, + int *w, + int *h) +{ + CcDisplayRotation rotation; + + rotation = cc_display_monitor_get_rotation (output); + if ((rotation == CC_DISPLAY_ROTATION_90) || (rotation == CC_DISPLAY_ROTATION_270)) + { + int tmp; + tmp = *h; + *h = *w; + *w = tmp; + } +} + +/* get_geometry */ +static void +get_scaled_geometry (CcDisplayConfig *config, + CcDisplayMonitor *output, + int *x, + int *y, + int *w, + int *h) +{ + if (cc_display_monitor_is_active (output)) + { + cc_display_monitor_get_geometry (output, x, y, w, h); + } + else + { + cc_display_monitor_get_geometry (output, x, y, NULL, NULL); + cc_display_mode_get_resolution (cc_display_monitor_get_preferred_mode (output), w, h); + } + + if (cc_display_config_is_layout_logical (config)) + { + double scale = cc_display_monitor_get_scale (output); + *w = round (*w / scale); + *h = round (*h / scale); + } + + apply_rotation_to_geometry (output, w, h); +} + +static void +get_bounding_box (CcDisplayConfig *config, + gint *x1, + gint *y1, + gint *x2, + gint *y2, + gint *max_w, + gint *max_h) +{ + GList *outputs, *l; + + g_assert (x1 && y1 && x2 && y2); + + *x1 = *y1 = G_MAXINT; + *x2 = *y2 = G_MININT; + *max_w = 0; + *max_h = 0; + + outputs = cc_display_config_get_monitors (config); + for (l = outputs; l; l = l->next) + { + CcDisplayMonitor *output = l->data; + int x, y, w, h; + + if (!cc_display_monitor_is_useful (output)) + continue; + + get_scaled_geometry (config, output, &x, &y, &w, &h); + + *x1 = MIN (*x1, x); + *y1 = MIN (*y1, y); + *x2 = MAX (*x2, x + w); + *y2 = MAX (*y2, y + h); + *max_w = MAX (*max_w, w); + *max_h = MAX (*max_h, h); + } +} + +static void +monitor_get_drawing_rect (CcDisplayArrangement *self, + CcDisplayMonitor *output, + gint *x1, + gint *y1, + gint *x2, + gint *y2) +{ + gdouble x, y; + + get_scaled_geometry (self->config, output, x1, y1, x2, y2); + + /* get_scaled_geometry returns the width and height */ + *x2 = *x1 + *x2; + *y2 = *y1 + *y2; + + x = *x1; y = *y1; + cairo_matrix_transform_point (&self->to_widget, &x, &y); + *x1 = round (x); + *y1 = round (y); + + x = *x2; y = *y2; + cairo_matrix_transform_point (&self->to_widget, &x, &y); + *x2 = round (x); + *y2 = round (y); +} + + +static void +get_snap_distance (SnapData *snap_data, + gint mon_x, + gint mon_y, + gint new_x, + gint new_y, + gdouble *dist_x, + gdouble *dist_y) +{ + gdouble local_dist_x, local_dist_y; + + local_dist_x = ABS (mon_x - new_x); + local_dist_y = ABS (mon_y - new_y); + + cairo_matrix_transform_distance (&snap_data->to_widget, &local_dist_x, &local_dist_y); + + if (dist_x) + *dist_x = local_dist_x; + if (dist_y) + *dist_y = local_dist_y; +} + +static void +maybe_update_snap (SnapData *snap_data, + gint mon_x, + gint mon_y, + gint new_x, + gint new_y, + SnapDirection snapped, + SnapDirection major_axis, + gint minor_unlimited) +{ + SnapDirection update_snap = SNAP_DIR_NONE; + gdouble dist_x, dist_y; + gdouble dist; + + get_snap_distance (snap_data, mon_x, mon_y, new_x, new_y, &dist_x, &dist_y); + dist = MAX (dist_x, dist_y); + + /* Snap by the variable max snap distance on the major axis, ensure the + * minor axis is below the minimum snapping distance (often just zero). */ + switch (major_axis) + { + case SNAP_DIR_X: + if (dist_x > snap_data->major_snap_distance) + return; + if (dist_y > MINOR_SNAP_DISTANCE) + { + if (new_y > mon_y && minor_unlimited <= 0) + return; + if (new_y < mon_y && minor_unlimited >= 0) + return; + } + break; + + case SNAP_DIR_Y: + if (dist_y > snap_data->major_snap_distance) + return; + if (dist_x > MINOR_SNAP_DISTANCE) + { + if (new_x > mon_x && minor_unlimited <= 0) + return; + if (new_x < mon_x && minor_unlimited >= 0) + return; + } + break; + + default: + g_assert_not_reached(); + } + + if (snapped == SNAP_DIR_BOTH) + { + if (snap_data->snapped == SNAP_DIR_NONE) + update_snap = SNAP_DIR_BOTH; + + /* Update, if this is closer on the main axis. */ + if (((major_axis == SNAP_DIR_X) && (dist_x < snap_data->dist_x)) || + ((major_axis == SNAP_DIR_Y) && (dist_y < snap_data->dist_y))) + { + update_snap = SNAP_DIR_BOTH; + } + + /* Also update if we were only snapping in one direction earlier and it + * is better or equally good. */ + if ((snap_data->snapped == SNAP_DIR_X && (dist <= snap_data->dist_x)) || + (snap_data->snapped == SNAP_DIR_Y && (dist <= snap_data->dist_y))) + { + update_snap = SNAP_DIR_BOTH; + } + + /* Also allow a minor axis to be added if the first axis remains identical. */ + if (((snap_data->snapped == SNAP_DIR_X) && (major_axis == SNAP_DIR_X) && (new_x == snap_data->mon_x)) || + ((snap_data->snapped == SNAP_DIR_Y) && (major_axis == SNAP_DIR_Y) && (new_y == snap_data->mon_y))) + { + update_snap = SNAP_DIR_BOTH; + } + } + else if (snapped == SNAP_DIR_X) + { + if (dist_x < snap_data->dist_x || (snap_data->snapped & SNAP_DIR_X) == SNAP_DIR_NONE) + update_snap = SNAP_DIR_X; + } + else if (snapped == SNAP_DIR_Y) + { + if (dist_y < snap_data->dist_y || (snap_data->snapped & SNAP_DIR_Y) == SNAP_DIR_NONE) + update_snap = SNAP_DIR_Y; + } + else + { + g_assert_not_reached (); + } + + if (update_snap & SNAP_DIR_X) + { + snap_data->dist_x = dist_x; + snap_data->mon_x = new_x; + snap_data->snapped = snap_data->snapped | SNAP_DIR_X; + } + if (update_snap & SNAP_DIR_Y) + { + snap_data->dist_y = dist_y; + snap_data->mon_y = new_y; + snap_data->snapped = snap_data->snapped | SNAP_DIR_Y; + } +} + +static void +find_best_snapping (CcDisplayConfig *config, + CcDisplayMonitor *snap_output, + SnapData *snap_data) +{ + GList *outputs, *l; + gint x1, y1, x2, y2; + gint w, h; + + g_assert (snap_data != NULL); + + get_scaled_geometry (config, snap_output, &x1, &y1, &w, &h); + x2 = x1 + w; + y2 = y1 + h; + +#define OVERLAP(_s1, _s2, _t1, _t2) ((_s1) <= (_t2) && (_t1) <= (_s2)) + + outputs = cc_display_config_get_monitors (config); + for (l = outputs; l; l = l->next) + { + CcDisplayMonitor *output = l->data; + gint _x1, _y1, _x2, _y2, _h, _w; + gint bottom_snap_pos; + gint top_snap_pos; + gint left_snap_pos; + gint right_snap_pos; + gdouble dist_x, dist_y; + gdouble tmp; + + if (output == snap_output) + continue; + + if (!cc_display_monitor_is_useful (output)) + continue; + + get_scaled_geometry (config, output, &_x1, &_y1, &_w, &_h); + _x2 = _x1 + _w; + _y2 = _y1 + _h; + + top_snap_pos = _y1 - h; + bottom_snap_pos = _y2; + left_snap_pos = _x1 - w; + right_snap_pos = _x2; + + dist_y = 9999; + /* overlap on the X axis */ + if (OVERLAP (x1, x2, _x1, _x2)) + { + get_snap_distance (snap_data, x1, y1, x1, top_snap_pos, NULL, &dist_y); + get_snap_distance (snap_data, x1, y1, x1, bottom_snap_pos, NULL, &tmp); + dist_y = MIN(dist_y, tmp); + } + + dist_x = 9999; + /* overlap on the Y axis */ + if (OVERLAP (y1, y2, _y1, _y2)) + { + get_snap_distance (snap_data, x1, y1, left_snap_pos, y1, &dist_x, NULL); + get_snap_distance (snap_data, x1, y1, right_snap_pos, y1, &tmp, NULL); + dist_x = MIN(dist_x, tmp); + } + + /* We only snap horizontally or vertically to an edge of the same monitor */ + if (dist_y < dist_x) + { + maybe_update_snap (snap_data, x1, y1, x1, top_snap_pos, SNAP_DIR_Y, SNAP_DIR_Y, 0); + maybe_update_snap (snap_data, x1, y1, x1, bottom_snap_pos, SNAP_DIR_Y, SNAP_DIR_Y, 0); + } + else if (dist_x < 9999) + { + maybe_update_snap (snap_data, x1, y1, left_snap_pos, y1, SNAP_DIR_X, SNAP_DIR_X, 0); + maybe_update_snap (snap_data, x1, y1, right_snap_pos, y1, SNAP_DIR_X, SNAP_DIR_X, 0); + } + + /* Left/right edge identical on the top */ + maybe_update_snap (snap_data, x1, y1, _x1, top_snap_pos, SNAP_DIR_BOTH, SNAP_DIR_Y, 0); + maybe_update_snap (snap_data, x1, y1, _x2 - w, top_snap_pos, SNAP_DIR_BOTH, SNAP_DIR_Y, 0); + + /* Left/right edge identical on the bottom */ + maybe_update_snap (snap_data, x1, y1, _x1, bottom_snap_pos, SNAP_DIR_BOTH, SNAP_DIR_Y, 0); + maybe_update_snap (snap_data, x1, y1, _x2 - w, bottom_snap_pos, SNAP_DIR_BOTH, SNAP_DIR_Y, 0); + + /* Top/bottom edge identical on the left */ + maybe_update_snap (snap_data, x1, y1, left_snap_pos, _y1, SNAP_DIR_BOTH, SNAP_DIR_X, 0); + maybe_update_snap (snap_data, x1, y1, left_snap_pos, _y2 - h, SNAP_DIR_BOTH, SNAP_DIR_X, 0); + + /* Top/bottom edge identical on the right */ + maybe_update_snap (snap_data, x1, y1, right_snap_pos, _y1, SNAP_DIR_BOTH, SNAP_DIR_X, 0); + maybe_update_snap (snap_data, x1, y1, right_snap_pos, _y2 - h, SNAP_DIR_BOTH, SNAP_DIR_X, 0); + + /* If snapping is infinite, then add snapping points with minimal overlap + * to prevent detachment. + * This is similar to the above but simply re-defines the snapping pos + * to have only minimal overlap */ + if (snap_data->major_snap_distance == G_MAXUINT) + { + /* Hanging over the left/right edge on the top */ + maybe_update_snap (snap_data, x1, y1, _x1 - w + MIN_OVERLAP, top_snap_pos, SNAP_DIR_BOTH, SNAP_DIR_Y, 1); + maybe_update_snap (snap_data, x1, y1, _x2 - MIN_OVERLAP, top_snap_pos, SNAP_DIR_BOTH, SNAP_DIR_Y, -1); + + /* Left/right edge identical on the bottom */ + maybe_update_snap (snap_data, x1, y1, _x1 - w + MIN_OVERLAP, bottom_snap_pos, SNAP_DIR_BOTH, SNAP_DIR_Y, 1); + maybe_update_snap (snap_data, x1, y1, _x2 - MIN_OVERLAP, bottom_snap_pos, SNAP_DIR_BOTH, SNAP_DIR_Y, -1); + + /* Top/bottom edge identical on the left */ + maybe_update_snap (snap_data, x1, y1, left_snap_pos, _y1 - h + MIN_OVERLAP, SNAP_DIR_BOTH, SNAP_DIR_X, 1); + maybe_update_snap (snap_data, x1, y1, left_snap_pos, _y2 - MIN_OVERLAP, SNAP_DIR_BOTH, SNAP_DIR_X, -1); + + /* Top/bottom edge identical on the right */ + maybe_update_snap (snap_data, x1, y1, right_snap_pos, _y1 - h + MIN_OVERLAP, SNAP_DIR_BOTH, SNAP_DIR_X, 1); + maybe_update_snap (snap_data, x1, y1, right_snap_pos, _y2 - MIN_OVERLAP, SNAP_DIR_BOTH, SNAP_DIR_X, -1); + } + } + +#undef OVERLAP +} + +static void +cc_display_arrangement_update_matrices (CcDisplayArrangement *self) +{ + GtkAllocation allocation; + gdouble scale, scale_h, scale_w; + gint x1, y1, x2, y2, max_w, max_h; + + g_assert (self->config); + + /* Do not update the matrices while the user is dragging things around. */ + if (self->drag_active) + return; + + get_bounding_box (self->config, &x1, &y1, &x2, &y2, &max_w, &max_h); + gtk_widget_get_allocation (GTK_WIDGET (self), &allocation); + + scale_h = (gdouble) (allocation.width - 2 * MARGIN_PX) / (x2 - x1 + max_w * 2 * MARGIN_MON); + scale_w = (gdouble) (allocation.height - 2 * MARGIN_PX) / (y2 - y1 + max_h * 2 * MARGIN_MON); + + scale = MIN (scale_h, scale_w); + + cairo_matrix_init_identity (&self->to_widget); + cairo_matrix_translate (&self->to_widget, allocation.width / 2.0, allocation.height / 2.0); + cairo_matrix_scale (&self->to_widget, scale, scale); + cairo_matrix_translate (&self->to_widget, - (x1 + x2) / 2.0, - (y1 + y2) / 2.0); + + self->to_actual = self->to_widget; + cairo_matrix_invert (&self->to_actual); +} + +static CcDisplayMonitor* +cc_display_arrangement_find_monitor_at (CcDisplayArrangement *self, + gint x, + gint y) +{ + g_autoptr(GList) outputs = NULL; + GList *l; + + outputs = g_list_copy (cc_display_config_get_monitors (self->config)); + + if (self->selected_output) + outputs = g_list_prepend (outputs, self->selected_output); + + for (l = outputs; l; l = l->next) + { + CcDisplayMonitor *output = l->data; + gint x1, y1, x2, y2; + + if (!cc_display_monitor_is_useful (output)) + continue; + + monitor_get_drawing_rect (self, output, &x1, &y1, &x2, &y2); + + if (x >= x1 && x <= x2 && y >= y1 && y <= y2) + return output; + } + + return NULL; +} + +static void +on_output_changed_cb (CcDisplayArrangement *self, + CcDisplayMonitor *output) +{ + if (cc_display_config_count_useful_monitors (self->config) > 2) + self->major_snap_distance = MAJOR_SNAP_DISTANCE; + else + self->major_snap_distance = G_MAXUINT; + + gtk_widget_queue_draw (GTK_WIDGET (self)); +} + +static void +cc_display_arrangement_draw (GtkDrawingArea *drawing_area, + cairo_t *cr, + gint width, + gint height, + gpointer user_data) +{ + CcDisplayArrangement *self = CC_DISPLAY_ARRANGEMENT (drawing_area); + GtkStyleContext *context = gtk_widget_get_style_context (GTK_WIDGET (self)); + g_autoptr(GList) outputs = NULL; + GList *l; + + if (!self->config) + return; + + cc_display_arrangement_update_matrices (self); + + /* Draw in reverse order so that hit detection matches visual. Also pull + * the selected output to the back. */ + outputs = g_list_copy (cc_display_config_get_monitors (self->config)); + outputs = g_list_remove (outputs, self->selected_output); + if (self->selected_output != NULL) + outputs = g_list_prepend (outputs, self->selected_output); + outputs = g_list_reverse (outputs); + + for (l = outputs; l; l = l->next) + { + CcDisplayMonitor *output = l->data; + GtkStateFlags state = GTK_STATE_FLAG_NORMAL; + GtkBorder border, padding, margin; + gint x1, y1, x2, y2; + gint w, h; + gint num; + + if (!cc_display_monitor_is_useful (output)) + continue; + + gtk_style_context_save (context); + cairo_save (cr); + + gtk_style_context_add_class (context, "monitor"); + + if (output == self->selected_output) + state |= GTK_STATE_FLAG_SELECTED; + if (output == self->prelit_output) + state |= GTK_STATE_FLAG_PRELIGHT; + + gtk_style_context_set_state (context, state); + if (cc_display_monitor_is_primary (output) || cc_display_config_is_cloning (self->config)) + gtk_style_context_add_class (context, "primary"); + + /* Set in cc-display-panel.c */ + num = cc_display_monitor_get_ui_number (output); + + monitor_get_drawing_rect (self, output, &x1, &y1, &x2, &y2); + w = x2 - x1; + h = y2 - y1; + + cairo_translate (cr, x1, y1); + + gtk_style_context_get_margin (context, &margin); + + cairo_translate (cr, margin.left, margin.top); + + w -= margin.left + margin.right; + h -= margin.top + margin.bottom; + + gtk_render_background (context, cr, 0, 0, w, h); + gtk_render_frame (context, cr, 0, 0, w, h); + + gtk_style_context_get_border (context, &border); + gtk_style_context_get_padding (context, &padding); + + w -= border.left + border.right + padding.left + padding.right; + h -= border.top + border.bottom + padding.top + padding.bottom; + + cairo_translate (cr, border.left + padding.left, border.top + padding.top); + + if (num > 0) + { + PangoLayout *layout; + g_autofree gchar *number_str = NULL; + PangoRectangle extents; + GdkRGBA color; + gdouble text_width, text_padding; + + gtk_style_context_add_class (context, "monitor-label"); + gtk_style_context_remove_class (context, "monitor"); + + gtk_style_context_get_border (context, &border); + gtk_style_context_get_padding (context, &padding); + + cairo_translate (cr, w / 2, h / 2); + + number_str = g_strdup_printf ("%d", num); + layout = gtk_widget_create_pango_layout (GTK_WIDGET (self), number_str); + pango_layout_get_extents (layout, NULL, &extents); + + h = (extents.height - extents.y) / PANGO_SCALE; + text_width = (extents.width - extents.x) / PANGO_SCALE; + w = MAX (text_width, h - padding.left - padding.right); + text_padding = w - text_width; + + w += border.left + border.right + padding.left + padding.right; + h += border.top + border.bottom + padding.top + padding.bottom; + + /* Enforce evenness */ + if ((w % 2) != 0) + w++; + if ((h % 2) != 0) + h++; + + cairo_translate (cr, - w / 2, - h / 2); + + gtk_render_background (context, cr, 0, 0, w, h); + gtk_render_frame (context, cr, 0, 0, w, h); + + cairo_translate (cr, border.left + padding.left, border.top + padding.top); + cairo_translate (cr, extents.x + text_padding / 2, 0); + + gtk_style_context_get_color (context, &color); + gdk_cairo_set_source_rgba (cr, &color); + + gtk_render_layout (context, cr, 0, 0, layout); + g_object_unref (layout); + } + + gtk_style_context_restore (context); + cairo_restore (cr); + } +} + +static gboolean +on_click_gesture_pressed_cb (GtkGestureClick *click_gesture, + gint n_press, + gdouble x, + gdouble y, + CcDisplayArrangement *self) +{ + CcDisplayMonitor *output; + gdouble event_x, event_y; + gint mon_x, mon_y; + + if (!self->config) + return FALSE; + + g_return_val_if_fail (self->drag_active == FALSE, FALSE); + + output = cc_display_arrangement_find_monitor_at (self, x, y); + if (!output) + return FALSE; + + event_x = x; + event_y = y; + + cairo_matrix_transform_point (&self->to_actual, &event_x, &event_y); + cc_display_monitor_get_geometry (output, &mon_x, &mon_y, NULL, NULL); + + cc_display_arrangement_set_selected_output (self, output); + + if (cc_display_config_count_useful_monitors (self->config) > 1) + { + self->drag_active = TRUE; + self->drag_anchor_x = event_x - mon_x; + self->drag_anchor_y = event_y - mon_y; + } + + return TRUE; +} + +static gboolean +on_click_gesture_released_cb (GtkGestureClick *click_gesture, + gint n_press, + gdouble x, + gdouble y, + CcDisplayArrangement *self) +{ + CcDisplayMonitor *output; + + if (!self->config) + return FALSE; + + if (!self->drag_active) + return FALSE; + + self->drag_active = FALSE; + + output = cc_display_arrangement_find_monitor_at (self, x, y); + gtk_widget_set_cursor_from_name (GTK_WIDGET (self), + output != NULL ? "fleur" : NULL); + + /* And queue a redraw to recenter everything */ + gtk_widget_queue_draw (GTK_WIDGET (self)); + + g_signal_emit_by_name (G_OBJECT (self), "updated"); + + return TRUE; +} + +static gboolean +on_motion_controller_motion_cb (GtkEventControllerMotion *motion_controller, + gdouble x, + gdouble y, + CcDisplayArrangement *self) +{ + gdouble event_x, event_y; + gint mon_x, mon_y; + SnapData snap_data; + + if (!self->config) + return FALSE; + + if (cc_display_config_count_useful_monitors (self->config) <= 1) + return FALSE; + + if (!self->drag_active) + { + CcDisplayMonitor *output; + output = cc_display_arrangement_find_monitor_at (self, x, y); + + gtk_widget_set_cursor_from_name (GTK_WIDGET (self), + output != NULL ? "fleur" : NULL); + if (self->prelit_output != output) + gtk_widget_queue_draw (GTK_WIDGET (self)); + + self->prelit_output = output; + + return FALSE; + } + + g_assert (self->selected_output); + + event_x = x; + event_y = y; + + cairo_matrix_transform_point (&self->to_actual, &event_x, &event_y); + + mon_x = round (event_x - self->drag_anchor_x); + mon_y = round (event_y - self->drag_anchor_y); + + /* The monitor is now at the location as if there was no snapping whatsoever. */ + snap_data.snapped = SNAP_DIR_NONE; + snap_data.mon_x = mon_x; + snap_data.mon_y = mon_y; + snap_data.dist_x = 0; + snap_data.dist_y = 0; + snap_data.to_widget = self->to_widget; + snap_data.major_snap_distance = self->major_snap_distance; + + cc_display_monitor_set_position (self->selected_output, mon_x, mon_y); + + find_best_snapping (self->config, self->selected_output, &snap_data); + + cc_display_monitor_set_position (self->selected_output, snap_data.mon_x, snap_data.mon_y); + + return TRUE; +} + +static void +cc_display_arrangement_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + CcDisplayArrangement *self = CC_DISPLAY_ARRANGEMENT (object); + + switch (prop_id) + { + case PROP_CONFIG: + g_value_set_object (value, self->config); + break; + + case PROP_SELECTED_OUTPUT: + g_value_set_object (value, self->selected_output); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +cc_display_arrangement_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + CcDisplayArrangement *obj = CC_DISPLAY_ARRANGEMENT (object); + + switch (prop_id) + { + case PROP_CONFIG: + cc_display_arrangement_set_config (obj, g_value_get_object (value)); + break; + + case PROP_SELECTED_OUTPUT: + cc_display_arrangement_set_selected_output (obj, g_value_get_object (value)); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +cc_display_arrangement_finalize (GObject *object) +{ + CcDisplayArrangement *self = CC_DISPLAY_ARRANGEMENT (object); + + g_clear_object (&self->config); + + G_OBJECT_CLASS (cc_display_arrangement_parent_class)->finalize (object); +} + +static void +cc_display_arrangement_class_init (CcDisplayArrangementClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->finalize = cc_display_arrangement_finalize; + gobject_class->get_property = cc_display_arrangement_get_property; + gobject_class->set_property = cc_display_arrangement_set_property; + + props[PROP_CONFIG] = g_param_spec_object ("config", "Display Config", + "The display configuration to work with", + CC_TYPE_DISPLAY_CONFIG, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + + props[PROP_SELECTED_OUTPUT] = g_param_spec_object ("selected-output", "Selected Output", + "The output that is currently selected on the configuration", + CC_TYPE_DISPLAY_MONITOR, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties (gobject_class, + PROP_LAST, + props); + + g_signal_new ("updated", + CC_TYPE_DISPLAY_ARRANGEMENT, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); + + gtk_widget_class_set_css_name (GTK_WIDGET_CLASS (klass), "display-arrangement"); +} + +static void +cc_display_arrangement_init (CcDisplayArrangement *self) +{ + GtkEventController *motion_controller; + GtkGesture *click_gesture; + + click_gesture = gtk_gesture_click_new (); + g_signal_connect (click_gesture, "pressed", G_CALLBACK (on_click_gesture_pressed_cb), self); + g_signal_connect (click_gesture, "released", G_CALLBACK (on_click_gesture_released_cb), self); + gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (click_gesture)); + + motion_controller = gtk_event_controller_motion_new (); + g_signal_connect (motion_controller, "motion", G_CALLBACK (on_motion_controller_motion_cb), self); + gtk_widget_add_controller (GTK_WIDGET (self), motion_controller); + + gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (self), + cc_display_arrangement_draw, + self, + NULL); + + self->major_snap_distance = MAJOR_SNAP_DISTANCE; +} + +CcDisplayArrangement* +cc_display_arrangement_new (CcDisplayConfig *config) +{ + return g_object_new (CC_TYPE_DISPLAY_ARRANGEMENT, "config", config, NULL); +} + +CcDisplayConfig* +cc_display_arrangement_get_config (CcDisplayArrangement *self) +{ + return self->config; +} + +void +cc_display_arrangement_set_config (CcDisplayArrangement *self, + CcDisplayConfig *config) +{ + const gchar *signals[] = { "rotation", "mode", "primary", "active", "scale", "position-changed", "is-usable" }; + GList *outputs, *l; + guint i; + + if (self->config) + { + outputs = cc_display_config_get_monitors (self->config); + for (l = outputs; l; l = l->next) + { + CcDisplayMonitor *output = l->data; + + g_signal_handlers_disconnect_by_data (output, self); + } + } + g_clear_object (&self->config); + + self->drag_active = FALSE; + + /* Listen to all the signals */ + if (config) + { + self->config = g_object_ref (config); + + outputs = cc_display_config_get_monitors (self->config); + for (l = outputs; l; l = l->next) + { + CcDisplayMonitor *output = l->data; + + for (i = 0; i < G_N_ELEMENTS (signals); ++i) + g_signal_connect_object (output, signals[i], G_CALLBACK (on_output_changed_cb), self, G_CONNECT_SWAPPED); + } + } + + cc_display_arrangement_set_selected_output (self, NULL); + + g_object_notify_by_pspec (G_OBJECT (self), props[PROP_CONFIG]); +} + +CcDisplayMonitor* +cc_display_arrangement_get_selected_output (CcDisplayArrangement *self) +{ + return self->selected_output; +} + +void +cc_display_arrangement_set_selected_output (CcDisplayArrangement *self, + CcDisplayMonitor *output) +{ + g_return_if_fail (self->drag_active == FALSE); + + /* XXX: Could check that it actually belongs to the right config object. */ + self->selected_output = output; + + gtk_widget_queue_draw (GTK_WIDGET (self)); + + g_object_notify_by_pspec (G_OBJECT (self), props[PROP_SELECTED_OUTPUT]); +} + +void +cc_display_config_snap_output (CcDisplayConfig *config, + CcDisplayMonitor *output) +{ + SnapData snap_data; + gint x, y, w, h; + + if (!cc_display_monitor_is_useful (output)) + return; + + if (cc_display_config_count_useful_monitors (config) <= 1) + return; + + get_scaled_geometry (config, output, &x, &y, &w, &h); + + snap_data.snapped = SNAP_DIR_NONE; + snap_data.mon_x = x; + snap_data.mon_y = y; + snap_data.dist_x = 0; + snap_data.dist_y = 0; + cairo_matrix_init_identity (&snap_data.to_widget); + snap_data.major_snap_distance = G_MAXUINT; + + find_best_snapping (config, output, &snap_data); + + cc_display_monitor_set_position (output, snap_data.mon_x, snap_data.mon_y); +} diff --git a/panels/display/cc-display-arrangement.h b/panels/display/cc-display-arrangement.h new file mode 100644 index 0000000..9494c48 --- /dev/null +++ b/panels/display/cc-display-arrangement.h @@ -0,0 +1,47 @@ +/* -*- mode: c; style: linux -*- + * + * Copyright (C) 2017 Red Hat, Inc. + * + * Written by: Benjamin Berg <bberg@redhat.com> + * + * 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, 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/>. + */ + +#pragma once + +#include <gtk/gtk.h> +#include "cc-display-config.h" + +G_BEGIN_DECLS + +#define CC_TYPE_DISPLAY_ARRANGEMENT cc_display_arrangement_get_type () +G_DECLARE_FINAL_TYPE (CcDisplayArrangement, cc_display_arrangement, CC, DISPLAY_ARRANGEMENT, GtkDrawingArea); + +CcDisplayArrangement* cc_display_arrangement_new (CcDisplayConfig *config); + +CcDisplayConfig* cc_display_arrangement_get_config (CcDisplayArrangement *self); +void cc_display_arrangement_set_config (CcDisplayArrangement *self, + CcDisplayConfig *config); + +CcDisplayMonitor* cc_display_arrangement_get_selected_output (CcDisplayArrangement *arr); +void cc_display_arrangement_set_selected_output (CcDisplayArrangement *arr, + CcDisplayMonitor *output); + +/* This is a bit of an odd-ball, but it currently makes sense to have it with + * the arrangement widget where the snapping code lives. */ +void cc_display_config_snap_output (CcDisplayConfig *config, + CcDisplayMonitor *output); + +G_END_DECLS + diff --git a/panels/display/cc-display-config-dbus.c b/panels/display/cc-display-config-dbus.c new file mode 100644 index 0000000..c3b269d --- /dev/null +++ b/panels/display/cc-display-config-dbus.c @@ -0,0 +1,2116 @@ +/* + * Copyright (C) 2017 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, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + */ + +#include <float.h> +#include <math.h> +#include <gio/gio.h> + +#include "cc-display-config-dbus.h" + +#define MODE_BASE_FORMAT "siiddad" +#define MODE_FORMAT "(" MODE_BASE_FORMAT "a{sv})" +#define MODES_FORMAT "a" MODE_FORMAT +#define MONITOR_SPEC_FORMAT "(ssss)" +#define MONITOR_FORMAT "(" MONITOR_SPEC_FORMAT MODES_FORMAT "a{sv})" +#define MONITORS_FORMAT "a" MONITOR_FORMAT + +#define LOGICAL_MONITOR_MONITORS_FORMAT "a" MONITOR_SPEC_FORMAT +#define LOGICAL_MONITOR_FORMAT "(iidub" LOGICAL_MONITOR_MONITORS_FORMAT "a{sv})" +#define LOGICAL_MONITORS_FORMAT "a" LOGICAL_MONITOR_FORMAT + +#define CURRENT_STATE_FORMAT "(u" MONITORS_FORMAT LOGICAL_MONITORS_FORMAT "a{sv})" + +typedef enum _CcDisplayModeFlags +{ + MODE_PREFERRED = 1 << 0, + MODE_CURRENT = 1 << 1, + MODE_INTERLACED = 1 << 2, +} CcDisplayModeFlags; + +struct _CcDisplayModeDBus +{ + CcDisplayMode parent_instance; + CcDisplayMonitorDBus *monitor; + + char *id; + int width; + int height; + double refresh_rate; + double preferred_scale; + GArray *supported_scales; + guint32 flags; +}; + +G_DEFINE_TYPE (CcDisplayModeDBus, + cc_display_mode_dbus, + CC_TYPE_DISPLAY_MODE) + +static gboolean +cc_display_mode_dbus_equal (const CcDisplayModeDBus *m1, + const CcDisplayModeDBus *m2) +{ + if (!m1 && !m2) + return TRUE; + else if (!m1 || !m2) + return FALSE; + + return m1->width == m2->width && + m1->height == m2->height && + m1->refresh_rate == m2->refresh_rate && + (m1->flags & MODE_INTERLACED) == (m2->flags & MODE_INTERLACED); +} + +static gboolean +cc_display_mode_dbus_is_clone_mode (CcDisplayMode *pself) +{ + CcDisplayModeDBus *self = CC_DISPLAY_MODE_DBUS (pself); + + return !self->id; +} + +static void +cc_display_mode_dbus_get_resolution (CcDisplayMode *pself, + int *w, int *h) +{ + CcDisplayModeDBus *self = CC_DISPLAY_MODE_DBUS (pself); + + if (w) + *w = self->width; + if (h) + *h = self->height; +} + +static GArray * cc_display_mode_dbus_get_supported_scales (CcDisplayMode *pself); + +static double +cc_display_mode_dbus_get_preferred_scale (CcDisplayMode *pself) +{ + CcDisplayModeDBus *self = CC_DISPLAY_MODE_DBUS (pself); + + return self->preferred_scale; +} + +static gboolean +cc_display_mode_dbus_is_supported_scale (CcDisplayMode *pself, + double scale) +{ + CcDisplayModeDBus *self = CC_DISPLAY_MODE_DBUS (pself); + + guint i; + for (i = 0; i < self->supported_scales->len; i++) + { + double v = g_array_index (self->supported_scales, double, i); + + if (G_APPROX_VALUE (v, scale, DBL_EPSILON)) + return TRUE; + } + return FALSE; +} + + +static gboolean +cc_display_mode_dbus_is_interlaced (CcDisplayMode *pself) +{ + CcDisplayModeDBus *self = CC_DISPLAY_MODE_DBUS (pself); + + return !!(self->flags & MODE_INTERLACED); +} + +static gboolean +cc_display_mode_dbus_is_preferred (CcDisplayMode *pself) +{ + CcDisplayModeDBus *self = CC_DISPLAY_MODE_DBUS (pself); + + return !!(self->flags & MODE_PREFERRED); +} + +static int +cc_display_mode_dbus_get_freq (CcDisplayMode *pself) +{ + CcDisplayModeDBus *self = CC_DISPLAY_MODE_DBUS (pself); + + return self->refresh_rate; +} + +static double +cc_display_mode_dbus_get_freq_f (CcDisplayMode *pself) +{ + CcDisplayModeDBus *self = CC_DISPLAY_MODE_DBUS (pself); + + return self->refresh_rate; +} + +static void +cc_display_mode_dbus_init (CcDisplayModeDBus *self) +{ + self->supported_scales = g_array_new (FALSE, FALSE, sizeof (double)); +} + +static void +cc_display_mode_dbus_finalize (GObject *object) +{ + CcDisplayModeDBus *self = CC_DISPLAY_MODE_DBUS (object); + + g_free (self->id); + g_array_free (self->supported_scales, TRUE); + + G_OBJECT_CLASS (cc_display_mode_dbus_parent_class)->finalize (object); +} + +static void +cc_display_mode_dbus_class_init (CcDisplayModeDBusClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + CcDisplayModeClass *parent_class = CC_DISPLAY_MODE_CLASS (klass); + + gobject_class->finalize = cc_display_mode_dbus_finalize; + + parent_class->is_clone_mode = cc_display_mode_dbus_is_clone_mode; + parent_class->get_resolution = cc_display_mode_dbus_get_resolution; + parent_class->get_supported_scales = cc_display_mode_dbus_get_supported_scales; + parent_class->get_preferred_scale = cc_display_mode_dbus_get_preferred_scale; + parent_class->is_interlaced = cc_display_mode_dbus_is_interlaced; + parent_class->is_preferred = cc_display_mode_dbus_is_preferred; + parent_class->get_freq = cc_display_mode_dbus_get_freq; + parent_class->get_freq_f = cc_display_mode_dbus_get_freq_f; +} + +static CcDisplayModeDBus * +cc_display_mode_dbus_new_virtual (int width, + int height, + double preferred_scale, + GArray *supported_scales) +{ + g_autoptr(GVariant) properties_variant = NULL; + CcDisplayModeDBus *self; + + self = g_object_new (CC_TYPE_DISPLAY_MODE_DBUS, NULL); + + self->width = width; + self->height = height; + self->preferred_scale = preferred_scale; + self->supported_scales = g_array_ref (supported_scales); + + return self; +} + +static CcDisplayModeDBus * +cc_display_mode_dbus_new (CcDisplayMonitorDBus *monitor, + GVariant *variant) +{ + double d; + g_autoptr(GVariantIter) scales_iter = NULL; + g_autoptr(GVariant) properties_variant = NULL; + gboolean is_current; + gboolean is_preferred; + gboolean is_interlaced; + CcDisplayModeDBus *self = g_object_new (CC_TYPE_DISPLAY_MODE_DBUS, NULL); + + self->monitor = monitor; + + g_variant_get (variant, "(" MODE_BASE_FORMAT "@a{sv})", + &self->id, + &self->width, + &self->height, + &self->refresh_rate, + &self->preferred_scale, + &scales_iter, + &properties_variant); + + while (g_variant_iter_next (scales_iter, "d", &d)) + g_array_append_val (self->supported_scales, d); + + if (!g_variant_lookup (properties_variant, "is-current", "b", &is_current)) + is_current = FALSE; + if (!g_variant_lookup (properties_variant, "is-preferred", "b", &is_preferred)) + is_preferred = FALSE; + if (!g_variant_lookup (properties_variant, "is-interlaced", "b", &is_interlaced)) + is_interlaced = FALSE; + + if (is_current) + self->flags |= MODE_CURRENT; + if (is_preferred) + self->flags |= MODE_PREFERRED; + if (is_interlaced) + self->flags |= MODE_INTERLACED; + + return self; +} + + +#define CC_TYPE_DISPLAY_LOGICAL_MONITOR (cc_display_logical_monitor_get_type ()) +G_DECLARE_FINAL_TYPE (CcDisplayLogicalMonitor, cc_display_logical_monitor, + CC, DISPLAY_LOGICAL_MONITOR, GObject) + +struct _CcDisplayLogicalMonitor +{ + GObject parent_instance; + + int x; + int y; + double scale; + CcDisplayRotation rotation; + gboolean primary; + + GHashTable *monitors; +}; + +G_DEFINE_TYPE (CcDisplayLogicalMonitor, + cc_display_logical_monitor, + G_TYPE_OBJECT) + +static gboolean +cc_display_logical_monitor_equal (const CcDisplayLogicalMonitor *m1, + const CcDisplayLogicalMonitor *m2) +{ + if (!m1 && !m2) + return TRUE; + else if (!m1 || !m2) + return FALSE; + + return m1->x == m2->x && + m1->y == m2->y && + G_APPROX_VALUE (m1->scale, m2->scale, DBL_EPSILON) && + m1->rotation == m2->rotation && + m1->primary == m2->primary; +} + +static void +cc_display_logical_monitor_init (CcDisplayLogicalMonitor *self) +{ + self->scale = 1.0; + self->monitors = g_hash_table_new (NULL, NULL); +} + +static void +cc_display_logical_monitor_finalize (GObject *object) +{ + CcDisplayLogicalMonitor *self = CC_DISPLAY_LOGICAL_MONITOR (object); + + g_warn_if_fail (g_hash_table_size (self->monitors) == 0); + g_clear_pointer (&self->monitors, g_hash_table_destroy); + + G_OBJECT_CLASS (cc_display_logical_monitor_parent_class)->finalize (object); +} + +static void +cc_display_logical_monitor_class_init (CcDisplayLogicalMonitorClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->finalize = cc_display_logical_monitor_finalize; +} + + +typedef enum _CcDisplayMonitorUnderscanning +{ + UNDERSCANNING_UNSUPPORTED = 0, + UNDERSCANNING_DISABLED, + UNDERSCANNING_ENABLED +} CcDisplayMonitorUnderscanning; + +struct _CcDisplayMonitorDBus +{ + CcDisplayMonitor parent_instance; + CcDisplayConfigDBus *config; + + gchar *connector_name; + gchar *vendor_name; + gchar *product_name; + gchar *product_serial; + gchar *display_name; + + int width_mm; + int height_mm; + gboolean builtin; + CcDisplayMonitorUnderscanning underscanning; + CcDisplayMonitorPrivacy privacy_screen; + int max_width; + int max_height; + + GList *modes; + CcDisplayMode *current_mode; + CcDisplayMode *preferred_mode; + + CcDisplayLogicalMonitor *logical_monitor; +}; + +G_DEFINE_TYPE (CcDisplayMonitorDBus, + cc_display_monitor_dbus, + CC_TYPE_DISPLAY_MONITOR) + +static void +register_logical_monitor (CcDisplayConfigDBus *self, + CcDisplayLogicalMonitor *logical_monitor); +static void +cc_display_config_dbus_set_primary (CcDisplayConfigDBus *self, + CcDisplayMonitorDBus *new_primary); +static void +cc_display_config_dbus_unset_primary (CcDisplayConfigDBus *self, + CcDisplayMonitorDBus *old_primary); +static void +cc_display_config_dbus_ensure_non_offset_coords (CcDisplayConfigDBus *self); +static void +cc_display_config_dbus_append_right (CcDisplayConfigDBus *self, + CcDisplayLogicalMonitor *monitor); +static void +cc_display_config_dbus_make_linear (CcDisplayConfigDBus *self); + + +static const char * +cc_display_monitor_dbus_get_display_name (CcDisplayMonitor *pself) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + if (self->display_name) + return self->display_name; + + return self->connector_name; +} + +static const char * +cc_display_monitor_dbus_get_connector_name (CcDisplayMonitor *pself) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + return self->connector_name; +} + +static gboolean +cc_display_monitor_dbus_is_builtin (CcDisplayMonitor *pself) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + return self->builtin; +} + +static gboolean +cc_display_monitor_dbus_is_primary (CcDisplayMonitor *pself) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + if (self->logical_monitor) + return self->logical_monitor->primary; + + return FALSE; +} + +static void +cc_display_monitor_dbus_set_primary (CcDisplayMonitor *pself, + gboolean primary) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + if (primary) + cc_display_config_dbus_set_primary (self->config, self); + else + cc_display_config_dbus_unset_primary (self->config, self); +} + +static gboolean +cc_display_monitor_dbus_is_active (CcDisplayMonitor *pself) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + return self->logical_monitor != NULL; +} + +static void +cc_display_monitor_dbus_set_logical_monitor (CcDisplayMonitorDBus *self, + CcDisplayLogicalMonitor *logical_monitor) +{ + gboolean was_primary = FALSE; + + if (self->logical_monitor) + { + was_primary = self->logical_monitor->primary; + if (was_primary) + cc_display_config_dbus_unset_primary (self->config, self); + g_hash_table_remove (self->logical_monitor->monitors, self); + g_object_unref (self->logical_monitor); + } + + self->logical_monitor = logical_monitor; + + if (self->logical_monitor) + { + g_hash_table_add (self->logical_monitor->monitors, self); + g_object_ref (self->logical_monitor); + /* unset primary with NULL will select this monitor if it is the only one.*/ + if (was_primary) + cc_display_config_dbus_set_primary (self->config, self); + else + cc_display_config_dbus_unset_primary (self->config, NULL); + } +} + +static void +cc_display_monitor_dbus_set_active (CcDisplayMonitor *pself, + gboolean active) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + if (!self->current_mode && active) + { + if (self->preferred_mode) + self->current_mode = self->preferred_mode; + else if (self->modes) + self->current_mode = (CcDisplayMode *) self->modes->data; + else + g_warning ("Couldn't find a mode to activate monitor at %s", self->connector_name); + } + + if (!self->logical_monitor && active) + { + CcDisplayLogicalMonitor *logical_monitor; + logical_monitor = g_object_new (CC_TYPE_DISPLAY_LOGICAL_MONITOR, NULL); + cc_display_monitor_dbus_set_logical_monitor (self, logical_monitor); + cc_display_config_dbus_append_right (self->config, logical_monitor); + register_logical_monitor (self->config, logical_monitor); + } + else if (self->logical_monitor && !active) + { + cc_display_monitor_dbus_set_logical_monitor (self, NULL); + } + + g_signal_emit_by_name (self, "active"); +} + +static CcDisplayRotation +cc_display_monitor_dbus_get_rotation (CcDisplayMonitor *pself) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + if (self->logical_monitor) + return self->logical_monitor->rotation; + + return CC_DISPLAY_ROTATION_NONE; +} + +static void +cc_display_monitor_dbus_set_rotation (CcDisplayMonitor *pself, + CcDisplayRotation rotation) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + if (!self->logical_monitor) + return; + + if (self->logical_monitor->rotation != rotation) + { + self->logical_monitor->rotation = rotation; + + g_signal_emit_by_name (self, "rotation"); + } +} + +static gboolean +cc_display_monitor_dbus_supports_rotation (CcDisplayMonitor *pself, + CcDisplayRotation rotation) +{ + return TRUE; +} + +static void +cc_display_monitor_dbus_get_physical_size (CcDisplayMonitor *pself, + int *w, int *h) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + if (w) + *w = self->width_mm; + if (h) + *h = self->height_mm; +} + +static void +cc_display_monitor_dbus_get_geometry (CcDisplayMonitor *pself, + int *x, int *y, int *w, int *h) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + CcDisplayMode *mode = NULL; + + if (self->logical_monitor) + { + if (x) + *x = self->logical_monitor->x; + if (y) + *y = self->logical_monitor->y; + } + else + { + if (x) + *x = -1; + if (y) + *y = -1; + } + + if (self->current_mode) + mode = self->current_mode; + else if (self->preferred_mode) + mode = self->preferred_mode; + else if (self->modes) + mode = CC_DISPLAY_MODE (self->modes->data); + + if (mode) + cc_display_mode_get_resolution (mode, w, h); + else + { + g_warning ("Monitor at %s has no modes?", self->connector_name); + if (w) + *w = -1; + if (h) + *h = -1; + } +} + +static CcDisplayMode * +cc_display_monitor_dbus_get_mode (CcDisplayMonitor *pself) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + return self->current_mode; +} + +static CcDisplayMode * +cc_display_monitor_dbus_get_preferred_mode (CcDisplayMonitor *pself) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + return self->preferred_mode; +} + +static guint32 +cc_display_monitor_dbus_get_id (CcDisplayMonitor *pself) +{ + return 0; +} + +static GList * +cc_display_monitor_dbus_get_modes (CcDisplayMonitor *pself) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + return self->modes; +} + +static gboolean +cc_display_monitor_dbus_supports_underscanning (CcDisplayMonitor *pself) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + return self->underscanning != UNDERSCANNING_UNSUPPORTED; +} + +static gboolean +cc_display_monitor_dbus_get_underscanning (CcDisplayMonitor *pself) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + return self->underscanning == UNDERSCANNING_ENABLED; +} + +static CcDisplayMonitorPrivacy +cc_display_monitor_dbus_get_privacy (CcDisplayMonitor *pself) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + return self->privacy_screen; +} + +static void +cc_display_monitor_dbus_set_underscanning (CcDisplayMonitor *pself, + gboolean underscanning) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + if (self->underscanning == UNDERSCANNING_UNSUPPORTED) + return; + + if (underscanning) + self->underscanning = UNDERSCANNING_ENABLED; + else + self->underscanning = UNDERSCANNING_DISABLED; +} + +static CcDisplayMode * +cc_display_monitor_dbus_get_closest_mode (CcDisplayMonitorDBus *self, + CcDisplayModeDBus *mode) +{ + CcDisplayModeDBus *best = NULL; + GList *l; + + for (l = self->modes; l != NULL; l = l->next) + { + CcDisplayModeDBus *similar = l->data; + + if (similar->width != mode->width || + similar->height != mode->height) + continue; + + if (similar->refresh_rate == mode->refresh_rate && + (similar->flags & MODE_INTERLACED) == (mode->flags & MODE_INTERLACED)) + { + best = similar; + break; + } + + /* There might be a better heuristic. */ + if (!best || best->refresh_rate < similar->refresh_rate) + { + best = similar; + continue; + } + } + + return CC_DISPLAY_MODE (best); +} + +static void +cc_display_monitor_dbus_set_mode (CcDisplayMonitor *pself, + CcDisplayMode *new_mode) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + CcDisplayMode *mode; + + g_return_if_fail (new_mode != NULL); + + mode = cc_display_monitor_dbus_get_closest_mode (self, CC_DISPLAY_MODE_DBUS (new_mode)); + + self->current_mode = mode; + + if (!cc_display_mode_dbus_is_supported_scale (mode, cc_display_monitor_get_scale (pself))) + cc_display_monitor_set_scale (pself, cc_display_mode_get_preferred_scale (mode)); + + g_signal_emit_by_name (self, "mode"); +} + +static void +cc_display_monitor_dbus_set_compatible_clone_mode (CcDisplayMonitor *pself, + CcDisplayMode *clone_mode) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + GList *l; + CcDisplayMode *best_mode = NULL; + int clone_width, clone_height; + + g_return_if_fail (cc_display_mode_is_clone_mode (clone_mode)); + + cc_display_mode_get_resolution (clone_mode, &clone_width, &clone_height); + + for (l = self->modes; l; l = l->next) + { + CcDisplayMode *mode = l->data; + int width, height; + + cc_display_mode_get_resolution (mode, &width, &height); + if (width != clone_width || height != clone_height) + continue; + + if (!best_mode) + { + best_mode = mode; + continue; + } + + if (cc_display_mode_get_freq_f (mode) > + cc_display_mode_get_freq_f (best_mode)) + best_mode = mode; + } + + g_return_if_fail (best_mode); + + cc_display_monitor_set_mode (CC_DISPLAY_MONITOR (self), best_mode); +} + +static void +cc_display_monitor_dbus_set_position (CcDisplayMonitor *pself, + int x, int y) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + if (self->logical_monitor) + { + gboolean notify = FALSE; + + if (self->logical_monitor->x != x || self->logical_monitor->y != y) + notify = TRUE; + + self->logical_monitor->x = x; + self->logical_monitor->y = y; + + if (notify) + g_signal_emit_by_name (self, "position-changed"); + } + +} + +static double +cc_display_monitor_dbus_get_scale (CcDisplayMonitor *pself) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + if (self->logical_monitor) + return self->logical_monitor->scale; + + return 1.0; +} + +static void +cc_display_monitor_dbus_set_scale (CcDisplayMonitor *pself, + double scale) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (pself); + + if (!self->current_mode) + return; + + if (!cc_display_mode_dbus_is_supported_scale (self->current_mode, scale)) + return; + + if (!self->logical_monitor) + return; + + if (!G_APPROX_VALUE (self->logical_monitor->scale, scale, DBL_EPSILON)) + { + self->logical_monitor->scale = scale; + + g_signal_emit_by_name (self, "scale"); + } +} + +static void +cc_display_monitor_dbus_init (CcDisplayMonitorDBus *self) +{ + self->underscanning = UNDERSCANNING_UNSUPPORTED; + self->max_width = G_MAXINT; + self->max_height = G_MAXINT; +} + +static void +cc_display_monitor_dbus_finalize (GObject *object) +{ + CcDisplayMonitorDBus *self = CC_DISPLAY_MONITOR_DBUS (object); + + g_free (self->connector_name); + g_free (self->vendor_name); + g_free (self->product_name); + g_free (self->product_serial); + g_free (self->display_name); + + g_list_free_full (self->modes, g_object_unref); + + if (self->logical_monitor) + { + g_hash_table_remove (self->logical_monitor->monitors, self); + g_object_unref (self->logical_monitor); + } + + G_OBJECT_CLASS (cc_display_monitor_dbus_parent_class)->finalize (object); +} + +static void +cc_display_monitor_dbus_class_init (CcDisplayMonitorDBusClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + CcDisplayMonitorClass *parent_class = CC_DISPLAY_MONITOR_CLASS (klass); + + gobject_class->finalize = cc_display_monitor_dbus_finalize; + + parent_class->get_display_name = cc_display_monitor_dbus_get_display_name; + parent_class->get_connector_name = cc_display_monitor_dbus_get_connector_name; + parent_class->is_builtin = cc_display_monitor_dbus_is_builtin; + parent_class->is_primary = cc_display_monitor_dbus_is_primary; + parent_class->set_primary = cc_display_monitor_dbus_set_primary; + parent_class->is_active = cc_display_monitor_dbus_is_active; + parent_class->set_active = cc_display_monitor_dbus_set_active; + parent_class->get_rotation = cc_display_monitor_dbus_get_rotation; + parent_class->set_rotation = cc_display_monitor_dbus_set_rotation; + parent_class->supports_rotation = cc_display_monitor_dbus_supports_rotation; + parent_class->get_physical_size = cc_display_monitor_dbus_get_physical_size; + parent_class->get_geometry = cc_display_monitor_dbus_get_geometry; + parent_class->get_mode = cc_display_monitor_dbus_get_mode; + parent_class->get_preferred_mode = cc_display_monitor_dbus_get_preferred_mode; + parent_class->get_id = cc_display_monitor_dbus_get_id; + parent_class->get_modes = cc_display_monitor_dbus_get_modes; + parent_class->supports_underscanning = cc_display_monitor_dbus_supports_underscanning; + parent_class->get_underscanning = cc_display_monitor_dbus_get_underscanning; + parent_class->set_underscanning = cc_display_monitor_dbus_set_underscanning; + parent_class->get_privacy = cc_display_monitor_dbus_get_privacy; + parent_class->set_mode = cc_display_monitor_dbus_set_mode; + parent_class->set_compatible_clone_mode = cc_display_monitor_dbus_set_compatible_clone_mode; + parent_class->set_position = cc_display_monitor_dbus_set_position; + parent_class->get_scale = cc_display_monitor_dbus_get_scale; + parent_class->set_scale = cc_display_monitor_dbus_set_scale; +} + +static void +construct_modes (CcDisplayMonitorDBus *self, + GVariantIter *modes) +{ + CcDisplayModeDBus *mode; + + while (TRUE) + { + g_autoptr(GVariant) variant = NULL; + + if (!g_variant_iter_next (modes, "@"MODE_FORMAT, &variant)) + break; + + mode = cc_display_mode_dbus_new (self, variant); + self->modes = g_list_prepend (self->modes, mode); + + if (mode->flags & MODE_PREFERRED) + self->preferred_mode = CC_DISPLAY_MODE (mode); + if (mode->flags & MODE_CURRENT) + self->current_mode = CC_DISPLAY_MODE (mode); + } + + self->modes = g_list_reverse (self->modes); +} + +static CcDisplayMonitorDBus * +cc_display_monitor_dbus_new (GVariant *variant, + CcDisplayConfigDBus *config) +{ + CcDisplayMonitorDBus *self = g_object_new (CC_TYPE_DISPLAY_MONITOR_DBUS, NULL); + gchar *s1, *s2, *s3, *s4; + g_autoptr(GVariantIter) modes = NULL; + g_autoptr(GVariantIter) props = NULL; + + self->config = config; + + g_variant_get (variant, MONITOR_FORMAT, + &s1, &s2, &s3, &s4, &modes, &props); + self->connector_name = s1; + self->vendor_name = s2; + self->product_name = s3; + self->product_serial = s4; + + construct_modes (self, modes); + + while (TRUE) + { + const char *s; + g_autoptr(GVariant) v = NULL; + + if (!g_variant_iter_next (props, "{&sv}", &s, &v)) + break; + + if (g_str_equal (s, "width-mm")) + { + g_variant_get (v, "i", &self->width_mm); + } + else if (g_str_equal (s, "height-mm")) + { + g_variant_get (v, "i", &self->height_mm); + } + else if (g_str_equal (s, "is-underscanning")) + { + gboolean underscanning = FALSE; + g_variant_get (v, "b", &underscanning); + if (underscanning) + self->underscanning = UNDERSCANNING_ENABLED; + else + self->underscanning = UNDERSCANNING_DISABLED; + } + else if (g_str_equal (s, "max-screen-size")) + { + g_variant_get (v, "ii", &self->max_width, &self->max_height); + } + else if (g_str_equal (s, "is-builtin")) + { + g_variant_get (v, "b", &self->builtin); + } + else if (g_str_equal (s, "display-name")) + { + g_variant_get (v, "s", &self->display_name); + } + else if (g_str_equal (s, "privacy-screen-state")) + { + gboolean enabled; + gboolean locked; + g_variant_get (v, "(bb)", &enabled, &locked); + + if (enabled) + self->privacy_screen = CC_DISPLAY_MONITOR_PRIVACY_ENABLED; + else + self->privacy_screen = CC_DISPLAY_MONITOR_PRIVACY_DISABLED; + + if (locked) + self->privacy_screen |= CC_DISPLAY_MONITOR_PRIVACY_LOCKED; + } + } + + return self; +} + + +typedef enum _CcDisplayLayoutMode +{ + CC_DISPLAY_LAYOUT_MODE_LOGICAL = 1, + CC_DISPLAY_LAYOUT_MODE_PHYSICAL = 2 +} CcDisplayLayoutMode; + +typedef enum _CcDisplayConfigMethod +{ + CC_DISPLAY_CONFIG_METHOD_VERIFY = 0, + CC_DISPLAY_CONFIG_METHOD_TEMPORARY = 1, + CC_DISPLAY_CONFIG_METHOD_PERSISTENT = 2 +} CcDisplayConfigMethod; + +struct _CcDisplayConfigDBus +{ + CcDisplayConfig parent_instance; + + GVariant *state; + GDBusConnection *connection; + GDBusProxy *proxy; + + int min_width; + int min_height; + + guint panel_orientation_managed; + + guint32 serial; + gboolean supports_mirroring; + gboolean supports_changing_layout_mode; + gboolean global_scale_required; + CcDisplayLayoutMode layout_mode; + + GList *monitors; + CcDisplayMonitorDBus *primary; + + GHashTable *logical_monitors; +}; + +G_DEFINE_TYPE (CcDisplayConfigDBus, + cc_display_config_dbus, + CC_TYPE_DISPLAY_CONFIG) + +enum +{ + PROP_0, + PROP_STATE, + PROP_CONNECTION, +}; + +static GList * +cc_display_config_dbus_get_monitors (CcDisplayConfig *pself) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (pself); + + return self->monitors; +} + +static GVariant * +build_monitors_variant (GHashTable *monitors) +{ + GVariantBuilder builder; + GHashTableIter iter; + CcDisplayMonitorDBus *monitor; + + g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); + g_hash_table_iter_init (&iter, monitors); + + while (g_hash_table_iter_next (&iter, (void **) &monitor, NULL)) + { + GVariantBuilder props_builder; + CcDisplayModeDBus *mode_dbus; + + if (!monitor->current_mode) + continue; + + g_variant_builder_init (&props_builder, G_VARIANT_TYPE ("a{sv}")); + g_variant_builder_add (&props_builder, "{sv}", + "underscanning", + g_variant_new_boolean (monitor->underscanning == UNDERSCANNING_ENABLED)); + + mode_dbus = CC_DISPLAY_MODE_DBUS (monitor->current_mode); + g_variant_builder_add (&builder, "(ss@*)", + monitor->connector_name, + mode_dbus->id, + g_variant_builder_end (&props_builder)); + } + + return g_variant_builder_end (&builder); +} + +static GVariant * +build_logical_monitors_parameter (CcDisplayConfigDBus *self) +{ + GVariantBuilder builder; + GHashTableIter iter; + CcDisplayLogicalMonitor *logical_monitor; + + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a(iiduba(ssa{sv}))")); + g_hash_table_iter_init (&iter, self->logical_monitors); + + while (g_hash_table_iter_next (&iter, (void **) &logical_monitor, NULL)) + g_variant_builder_add (&builder, "(iidub@*)", + logical_monitor->x, + logical_monitor->y, + logical_monitor->scale, + logical_monitor->rotation, + logical_monitor->primary, + build_monitors_variant (logical_monitor->monitors)); + + return g_variant_builder_end (&builder); +} + +static GVariant * +build_apply_parameters (CcDisplayConfigDBus *self, + CcDisplayConfigMethod method) +{ + GVariantBuilder props_builder; + g_variant_builder_init (&props_builder, G_VARIANT_TYPE ("a{sv}")); + + if (self->supports_changing_layout_mode) + g_variant_builder_add (&props_builder, "{sv}", + "layout-mode", g_variant_new_uint32 (self->layout_mode)); + + return g_variant_new ("(uu@*@*)", + self->serial, + method, + build_logical_monitors_parameter (self), + g_variant_builder_end (&props_builder)); +} + +static gboolean +config_apply (CcDisplayConfigDBus *self, + CcDisplayConfigMethod method, + GError **error) +{ + g_autoptr(GVariant) retval = NULL; + + cc_display_config_dbus_ensure_non_offset_coords (self); + + retval = g_dbus_proxy_call_sync (self->proxy, + "ApplyMonitorsConfig", + build_apply_parameters (self, method), + G_DBUS_CALL_FLAGS_NO_AUTO_START, + -1, + NULL, + error); + return retval != NULL; +} + +static gboolean +cc_display_config_dbus_is_applicable (CcDisplayConfig *pself) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (pself); + g_autoptr(GError) error = NULL; + + if (!config_apply (self, CC_DISPLAY_CONFIG_METHOD_VERIFY, &error)) + { + g_warning ("Config not applicable: %s", error->message); + return FALSE; + } + else + { + return TRUE; + } +} + +static CcDisplayMonitorDBus * +monitor_from_spec (CcDisplayConfigDBus *self, + const gchar *connector, + const gchar *vendor, + const gchar *product, + const gchar *serial) +{ + GList *l; + for (l = self->monitors; l != NULL; l = l->next) + { + CcDisplayMonitorDBus *m = l->data; + if (g_str_equal (m->connector_name, connector) && + g_str_equal (m->vendor_name, vendor) && + g_str_equal (m->product_name, product) && + g_str_equal (m->product_serial, serial)) + return m; + } + return NULL; +} + +static gboolean +cc_display_config_dbus_equal (CcDisplayConfig *pself, + CcDisplayConfig *pother) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (pself); + CcDisplayConfigDBus *other = CC_DISPLAY_CONFIG_DBUS (pother); + GList *l; + + g_return_val_if_fail (pself, FALSE); + g_return_val_if_fail (pother, FALSE); + + cc_display_config_dbus_ensure_non_offset_coords (self); + cc_display_config_dbus_ensure_non_offset_coords (other); + + for (l = self->monitors; l != NULL; l = l->next) + { + CcDisplayMonitorDBus *m1 = l->data; + CcDisplayMonitorDBus *m2 = monitor_from_spec (other, + m1->connector_name, + m1->vendor_name, + m1->product_name, + m1->product_serial); + if (!m2) + return FALSE; + + if (m1->underscanning != m2->underscanning) + return FALSE; + + if (!cc_display_logical_monitor_equal (m1->logical_monitor, m2->logical_monitor)) + return FALSE; + + /* Modes should not be compared if both monitors have no logical monitor. */ + if (m1->logical_monitor == NULL && m2->logical_monitor == NULL) + continue; + + if (!cc_display_mode_dbus_equal (CC_DISPLAY_MODE_DBUS (m1->current_mode), + CC_DISPLAY_MODE_DBUS (m2->current_mode))) + return FALSE; + } + + return TRUE; +} + +static void +cc_display_config_dbus_set_primary (CcDisplayConfigDBus *self, + CcDisplayMonitorDBus *new_primary) +{ + if (self->primary == new_primary) + return; + + if (!new_primary->logical_monitor) + return; + + if (self->primary && self->primary->logical_monitor) + { + self->primary->logical_monitor->primary = FALSE; + g_signal_emit_by_name (self->primary, "primary"); + } + + self->primary = new_primary; + self->primary->logical_monitor->primary = TRUE; + + g_signal_emit_by_name (self->primary, "primary"); + g_signal_emit_by_name (self, "primary"); +} + +static void +cc_display_config_dbus_unset_primary (CcDisplayConfigDBus *self, + CcDisplayMonitorDBus *old_primary) +{ + GList *l; + + if (self->primary != old_primary) + return; + + for (l = self->monitors; l != NULL; l = l->next) + { + CcDisplayMonitorDBus *monitor = l->data; + if (monitor->logical_monitor && + monitor != old_primary) + { + cc_display_config_dbus_set_primary (self, monitor); + break; + } + } + + if (self->primary == old_primary) + self->primary = NULL; +} + +static gboolean +cc_display_config_dbus_is_cloning (CcDisplayConfig *pself) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (pself); + guint n_active_monitors = 0; + GList *l; + + for (l = self->monitors; l != NULL; l = l->next) + if (cc_display_monitor_is_active (CC_DISPLAY_MONITOR (l->data))) + n_active_monitors += 1; + + return n_active_monitors > 1 && g_hash_table_size (self->logical_monitors) == 1; +} + +static void +cc_display_config_dbus_set_cloning (CcDisplayConfig *pself, + gboolean clone) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (pself); + gboolean is_cloning = cc_display_config_is_cloning (pself); + CcDisplayLogicalMonitor *logical_monitor; + GList *l; + + if (clone && !is_cloning) + { + logical_monitor = g_object_new (CC_TYPE_DISPLAY_LOGICAL_MONITOR, NULL); + for (l = self->monitors; l != NULL; l = l->next) + cc_display_monitor_dbus_set_logical_monitor (CC_DISPLAY_MONITOR_DBUS (l->data), + logical_monitor); + register_logical_monitor (self, logical_monitor); + } + else if (!clone && is_cloning) + { + for (l = self->monitors; l != NULL; l = l->next) + { + logical_monitor = g_object_new (CC_TYPE_DISPLAY_LOGICAL_MONITOR, NULL); + cc_display_monitor_dbus_set_logical_monitor (CC_DISPLAY_MONITOR_DBUS (l->data), + logical_monitor); + register_logical_monitor (self, logical_monitor); + } + cc_display_config_dbus_make_linear (self); + } +} + +static gboolean +mode_supports_scale (CcDisplayMode *mode, + double scale) +{ + g_autoptr(GArray) scales = NULL; + int i; + + scales = cc_display_mode_get_supported_scales (mode); + for (i = 0; i < scales->len; i++) + { + if (G_APPROX_VALUE (scale, g_array_index (scales, double, i), + DBL_EPSILON)) + return TRUE; + } + + return FALSE; +} + +static void +remove_unsupported_scales (CcDisplayMode *mode, + GArray *supported_scales) +{ + g_autoptr(GArray) mode_scales = NULL; + int i; + + mode_scales = cc_display_mode_get_supported_scales (mode); + i = 0; + while (i < supported_scales->len) + { + double scale; + + if (i == supported_scales->len) + break; + + scale = g_array_index (supported_scales, double, i); + + if (mode_supports_scale (mode, scale)) + { + i++; + continue; + } + + g_array_remove_range (supported_scales, i, 1); + } +} + +static gboolean +monitor_has_compatible_clone_mode (CcDisplayMonitorDBus *monitor, + CcDisplayModeDBus *mode, + GArray *supported_scales) +{ + GList *l; + + for (l = monitor->modes; l; l = l->next) + { + CcDisplayModeDBus *other_mode = l->data; + + if (other_mode->width != mode->width || + other_mode->height != mode->height) + continue; + + if ((other_mode->flags & MODE_INTERLACED) != + (mode->flags & MODE_INTERLACED)) + continue; + + remove_unsupported_scales (CC_DISPLAY_MODE (other_mode), supported_scales); + + return TRUE; + } + + return FALSE; +} + +static gboolean +monitors_has_compatible_clone_mode (CcDisplayConfigDBus *self, + CcDisplayModeDBus *mode, + GArray *supported_scales) +{ + GList *l; + + for (l = self->monitors; l; l = l->next) + { + CcDisplayMonitorDBus *monitor = l->data; + + if (!monitor_has_compatible_clone_mode (monitor, mode, supported_scales)) + return FALSE; + } + + return TRUE; +} + +static gboolean +is_mode_better (CcDisplayModeDBus *mode, + CcDisplayModeDBus *other_mode) +{ + if (mode->width * mode->height > other_mode->width * other_mode->height) + return TRUE; + else if (mode->width * mode->height < other_mode->width * other_mode->height) + return FALSE; + + if (!(mode->flags & MODE_INTERLACED) && + (other_mode->flags & MODE_INTERLACED)) + return TRUE; + + return FALSE; +} + +static GList * +cc_display_config_dbus_generate_cloning_modes (CcDisplayConfig *pself) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (pself); + CcDisplayMonitorDBus *base_monitor = NULL; + GList *l; + GList *clone_modes = NULL; + CcDisplayModeDBus *best_mode = NULL; + + for (l = self->monitors; l; l = l->next) + { + CcDisplayMonitor *monitor = l->data; + + if (cc_display_monitor_is_active (monitor)) + { + base_monitor = CC_DISPLAY_MONITOR_DBUS (monitor); + break; + } + } + + if (!base_monitor) + return NULL; + + for (l = base_monitor->modes; l; l = l->next) + { + CcDisplayModeDBus *mode = l->data; + CcDisplayModeDBus *virtual_mode; + g_autoptr (GArray) supported_scales = NULL; + + supported_scales = + cc_display_mode_get_supported_scales (CC_DISPLAY_MODE (mode)); + + if (!monitors_has_compatible_clone_mode (self, mode, supported_scales)) + continue; + + virtual_mode = cc_display_mode_dbus_new_virtual (mode->width, + mode->height, + mode->preferred_scale, + supported_scales); + clone_modes = g_list_append (clone_modes, virtual_mode); + + if (!best_mode || is_mode_better (virtual_mode, best_mode)) + best_mode = virtual_mode; + } + + best_mode->flags |= MODE_PREFERRED; + + return clone_modes; +} + +static gboolean +cc_display_config_dbus_apply (CcDisplayConfig *pself, + GError **error) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (pself); + + return config_apply (self, CC_DISPLAY_CONFIG_METHOD_PERSISTENT, error); +} + +static gboolean +cc_display_config_dbus_is_layout_logical (CcDisplayConfig *pself) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (pself); + + return self->layout_mode == CC_DISPLAY_LAYOUT_MODE_LOGICAL; +} + +static gboolean +is_scale_allowed_by_active_monitors (CcDisplayConfigDBus *self, + CcDisplayMode *mode, + double scale); + +static gboolean +is_scaled_mode_allowed (CcDisplayConfigDBus *self, + CcDisplayModeDBus *mode, + double scale) +{ + gint width, height; + + /* Do the math as if the monitor is always in landscape mode. */ + width = round (mode->width / scale); + height = round (mode->height / scale); + + if (MAX (width, height) < self->min_width || + MIN (width, height) < self->min_height) + return FALSE; + + if (!self->global_scale_required) + return TRUE; + + return is_scale_allowed_by_active_monitors (self, CC_DISPLAY_MODE (mode), scale); +} + +static gboolean +is_scale_allowed_by_active_monitors (CcDisplayConfigDBus *self, + CcDisplayMode *mode, + double scale) +{ + GList *l; + + for (l = self->monitors; l != NULL; l = l->next) + { + CcDisplayMonitorDBus *m = CC_DISPLAY_MONITOR_DBUS (l->data); + + if (!cc_display_monitor_is_active (CC_DISPLAY_MONITOR (m))) + continue; + + if (!cc_display_mode_dbus_is_supported_scale (mode, scale)) + return FALSE; + } + + return TRUE; +} + +static GArray * +cc_display_mode_dbus_get_supported_scales (CcDisplayMode *pself) +{ + CcDisplayModeDBus *self = CC_DISPLAY_MODE_DBUS (pself); + CcDisplayConfig *config = CC_DISPLAY_CONFIG (self->monitor->config); + + if (cc_display_config_is_cloning (config)) + { + GArray *scales = g_array_copy (self->supported_scales); + int i; + + for (i = scales->len - 1; i >= 0; i--) + { + double scale = g_array_index (scales, double, i); + + if (!is_scale_allowed_by_active_monitors (self->monitor->config, + pself, scale)) + g_array_remove_index (scales, i); + } + + return g_steal_pointer (&scales); + } + + return g_array_ref (self->supported_scales); +} + +static void +filter_out_invalid_scaled_modes (CcDisplayConfigDBus *self) +{ + GList *l; + + for (l = self->monitors; l; l = l->next) + { + CcDisplayMonitorDBus *monitor = l->data; + GList *ll = monitor->modes; + + while (ll != NULL) + { + CcDisplayModeDBus *mode = ll->data; + GList *current = ll; + double current_scale = -1; + int i; + + ll = ll->next; + + if (monitor->current_mode != CC_DISPLAY_MODE (mode) && + monitor->preferred_mode != CC_DISPLAY_MODE (mode) && + !is_scaled_mode_allowed (self, mode, 1.0)) + { + g_clear_object (&mode); + monitor->modes = g_list_delete_link (monitor->modes, current); + continue; + } + + if (monitor->current_mode == CC_DISPLAY_MODE (mode)) + current_scale = cc_display_monitor_dbus_get_scale (CC_DISPLAY_MONITOR (monitor)); + + for (i = mode->supported_scales->len - 1; i >= 0; i--) + { + float scale = g_array_index (mode->supported_scales, double, i); + + if (!G_APPROX_VALUE (scale, current_scale, DBL_EPSILON) && + !G_APPROX_VALUE (scale, mode->preferred_scale, DBL_EPSILON) && + !is_scaled_mode_allowed (self, mode, scale)) + { + g_array_remove_index (mode->supported_scales, i); + } + } + } + } +} + +static void +cc_display_config_dbus_set_minimum_size (CcDisplayConfig *pself, + int width, + int height) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (pself); + + g_assert (width >= 0 && height >= 0); + g_assert (((self->min_width == 0 && self->min_height == 0) || + (self->min_width >= width && self->min_height >= height)) && + "Minimum size can't be set again to higher values"); + + self->min_width = width; + self->min_height = height; + + filter_out_invalid_scaled_modes (self); +} + +static gboolean +cc_display_config_dbus_is_scaled_mode_valid (CcDisplayConfig *pself, + CcDisplayMode *mode, + double scale) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (pself); + + if (cc_display_config_is_cloning (pself)) + return is_scale_allowed_by_active_monitors (self, mode, scale); + + return cc_display_mode_dbus_is_supported_scale (mode, scale); +} + +static gboolean +cc_display_config_dbus_get_panel_orientation_managed (CcDisplayConfig *pself) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (pself); + + return self->panel_orientation_managed; +} + +static void +cc_display_config_dbus_init (CcDisplayConfigDBus *self) +{ + self->serial = 0; + self->supports_mirroring = TRUE; + self->supports_changing_layout_mode = FALSE; + self->global_scale_required = FALSE; + self->layout_mode = CC_DISPLAY_LAYOUT_MODE_LOGICAL; + self->logical_monitors = g_hash_table_new (NULL, NULL); +} + +static void +remove_logical_monitor (gpointer data, + GObject *object) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (data); + + g_hash_table_remove (self->logical_monitors, object); +} + +static void +register_logical_monitor (CcDisplayConfigDBus *self, + CcDisplayLogicalMonitor *logical_monitor) +{ + g_hash_table_add (self->logical_monitors, logical_monitor); + g_object_weak_ref (G_OBJECT (logical_monitor), remove_logical_monitor, self); + g_object_unref (logical_monitor); +} + +static void +apply_global_scale_requirement (CcDisplayConfigDBus *self, + CcDisplayMonitor *monitor) +{ + GList *l; + double scale = cc_display_monitor_get_scale (monitor); + + for (l = self->monitors; l != NULL; l = l->next) + { + CcDisplayMonitor *m = l->data; + if (m != monitor) + cc_display_monitor_set_scale (m, scale); + } +} + +static void +construct_monitors (CcDisplayConfigDBus *self, + GVariantIter *monitors, + GVariantIter *logical_monitors) +{ + while (TRUE) + { + CcDisplayMonitorDBus *monitor; + g_autoptr(GVariant) variant = NULL; + + if (!g_variant_iter_next (monitors, "@"MONITOR_FORMAT, &variant)) + break; + + monitor = cc_display_monitor_dbus_new (variant, self); + self->monitors = g_list_prepend (self->monitors, monitor); + + if (self->global_scale_required) + g_signal_connect_object (monitor, "scale", + G_CALLBACK (apply_global_scale_requirement), + self, G_CONNECT_SWAPPED); + } + + self->monitors = g_list_reverse (self->monitors); + + while (TRUE) + { + g_autoptr(GVariant) variant = NULL; + CcDisplayLogicalMonitor *logical_monitor; + g_autoptr(GVariantIter) monitor_specs = NULL; + const gchar *s1, *s2, *s3, *s4; + gboolean primary; + + if (!g_variant_iter_next (logical_monitors, "@"LOGICAL_MONITOR_FORMAT, &variant)) + break; + + logical_monitor = g_object_new (CC_TYPE_DISPLAY_LOGICAL_MONITOR, NULL); + g_variant_get (variant, LOGICAL_MONITOR_FORMAT, + &logical_monitor->x, + &logical_monitor->y, + &logical_monitor->scale, + &logical_monitor->rotation, + &primary, + &monitor_specs, + NULL); + + while (g_variant_iter_next (monitor_specs, "(&s&s&s&s)", &s1, &s2, &s3, &s4)) + { + CcDisplayMonitorDBus *m = monitor_from_spec (self, s1, s2, s3, s4); + if (!m) + { + g_warning ("Couldn't find monitor given spec: %s, %s, %s, %s", + s1, s2, s3, s4); + continue; + } + + cc_display_monitor_dbus_set_logical_monitor (m, logical_monitor); + } + + if (g_hash_table_size (logical_monitor->monitors) > 0) + { + if (primary) + { + CcDisplayMonitorDBus *m = NULL; + GHashTableIter iter; + g_hash_table_iter_init (&iter, logical_monitor->monitors); + g_hash_table_iter_next (&iter, (void **) &m, NULL); + + cc_display_config_dbus_set_primary (self, m); + } + } + else + { + g_warning ("Got an empty logical monitor, ignoring"); + } + + register_logical_monitor (self, logical_monitor); + } +} + +static void +update_panel_orientation_managed (CcDisplayConfigDBus *self) +{ + g_autoptr(GVariant) v = NULL; + gboolean panel_orientation_managed = FALSE; + + if (self->proxy != NULL) + { + v = g_dbus_proxy_get_cached_property (self->proxy, "PanelOrientationManaged"); + if (v) + { + panel_orientation_managed = g_variant_get_boolean (v); + } + } + + if (panel_orientation_managed == self->panel_orientation_managed) + return; + + self->panel_orientation_managed = panel_orientation_managed; + g_signal_emit_by_name (self, "panel-orientation-managed", self->panel_orientation_managed); +} + +static void +proxy_properties_changed_cb (GDBusProxy *proxy, + GVariant *changed_properties, + GStrv invalidated_properties, + CcDisplayConfigDBus *self) +{ + GVariantDict dict; + + g_variant_dict_init (&dict, changed_properties); + + if (g_variant_dict_contains (&dict, "PanelOrientationManaged")) + update_panel_orientation_managed (self); +} + +static void +cc_display_config_dbus_constructed (GObject *object) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (object); + g_autoptr(GVariantIter) monitors = NULL; + g_autoptr(GVariantIter) logical_monitors = NULL; + g_autoptr(GVariantIter) props = NULL; + g_autoptr(GError) error = NULL; + + g_variant_get (self->state, + CURRENT_STATE_FORMAT, + &self->serial, + &monitors, + &logical_monitors, + &props); + + while (TRUE) + { + const char *s; + g_autoptr(GVariant) v = NULL; + + if (!g_variant_iter_next (props, "{&sv}", &s, &v)) + break; + + if (g_str_equal (s, "supports-mirroring")) + { + g_variant_get (v, "b", &self->supports_mirroring); + } + else if (g_str_equal (s, "supports-changing-layout-mode")) + { + g_variant_get (v, "b", &self->supports_changing_layout_mode); + } + else if (g_str_equal (s, "global-scale-required")) + { + g_variant_get (v, "b", &self->global_scale_required); + } + else if (g_str_equal (s, "layout-mode")) + { + guint32 u = 0; + g_variant_get (v, "u", &u); + if (u >= CC_DISPLAY_LAYOUT_MODE_LOGICAL && + u <= CC_DISPLAY_LAYOUT_MODE_PHYSICAL) + self->layout_mode = u; + } + } + + construct_monitors (self, monitors, logical_monitors); + filter_out_invalid_scaled_modes (self); + + self->proxy = g_dbus_proxy_new_sync (self->connection, + G_DBUS_PROXY_FLAGS_NONE, + NULL, + "org.gnome.Mutter.DisplayConfig", + "/org/gnome/Mutter/DisplayConfig", + "org.gnome.Mutter.DisplayConfig", + NULL, + &error); + if (error) + g_warning ("Could not create DisplayConfig proxy: %s", error->message); + + g_signal_connect (self->proxy, "g-properties-changed", + G_CALLBACK (proxy_properties_changed_cb), self); + update_panel_orientation_managed (self); + + G_OBJECT_CLASS (cc_display_config_dbus_parent_class)->constructed (object); +} + +static void +cc_display_config_dbus_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (object); + + switch (prop_id) + { + case PROP_STATE: + self->state = g_value_dup_variant (value); + break; + case PROP_CONNECTION: + self->connection = g_value_dup_object (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +cc_display_config_dbus_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (object); + + switch (prop_id) + { + case PROP_STATE: + g_value_set_variant (value, self->state); + break; + case PROP_CONNECTION: + g_value_set_object (value, self->connection); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +cc_display_config_dbus_dispose (GObject *object) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (object); + + if (self->logical_monitors) + { + GHashTableIter iter; + gpointer monitor; + + g_hash_table_iter_init (&iter, self->logical_monitors); + + while (g_hash_table_iter_next (&iter, &monitor, NULL)) + g_object_weak_unref (G_OBJECT (monitor), remove_logical_monitor, self); + } + + G_OBJECT_CLASS (cc_display_config_dbus_parent_class)->dispose (object); +} + +static void +cc_display_config_dbus_finalize (GObject *object) +{ + CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (object); + + g_clear_pointer (&self->state, g_variant_unref); + g_clear_object (&self->connection); + g_clear_object (&self->proxy); + + g_clear_list (&self->monitors, g_object_unref); + g_clear_pointer (&self->logical_monitors, g_hash_table_destroy); + + G_OBJECT_CLASS (cc_display_config_dbus_parent_class)->finalize (object); +} + +static void +cc_display_config_dbus_class_init (CcDisplayConfigDBusClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + CcDisplayConfigClass *parent_class = CC_DISPLAY_CONFIG_CLASS (klass); + GParamSpec *pspec; + + gobject_class->constructed = cc_display_config_dbus_constructed; + gobject_class->set_property = cc_display_config_dbus_set_property; + gobject_class->get_property = cc_display_config_dbus_get_property; + gobject_class->dispose = cc_display_config_dbus_dispose; + gobject_class->finalize = cc_display_config_dbus_finalize; + + parent_class->get_monitors = cc_display_config_dbus_get_monitors; + parent_class->is_applicable = cc_display_config_dbus_is_applicable; + parent_class->equal = cc_display_config_dbus_equal; + parent_class->apply = cc_display_config_dbus_apply; + parent_class->is_cloning = cc_display_config_dbus_is_cloning; + parent_class->set_cloning = cc_display_config_dbus_set_cloning; + parent_class->generate_cloning_modes = cc_display_config_dbus_generate_cloning_modes; + parent_class->is_layout_logical = cc_display_config_dbus_is_layout_logical; + parent_class->is_scaled_mode_valid = cc_display_config_dbus_is_scaled_mode_valid; + parent_class->set_minimum_size = cc_display_config_dbus_set_minimum_size; + parent_class->get_panel_orientation_managed = + cc_display_config_dbus_get_panel_orientation_managed; + + pspec = g_param_spec_variant ("state", + "GVariant", + "GVariant", + G_VARIANT_TYPE (CURRENT_STATE_FORMAT), + NULL, + G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS | + G_PARAM_CONSTRUCT_ONLY); + g_object_class_install_property (gobject_class, PROP_STATE, pspec); + + pspec = g_param_spec_object ("connection", + "GDBusConnection", + "GDBusConnection", + G_TYPE_DBUS_CONNECTION, + G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS | + G_PARAM_CONSTRUCT_ONLY); + g_object_class_install_property (gobject_class, PROP_CONNECTION, pspec); +} + +static gint +sort_x_axis (gconstpointer a, gconstpointer b) +{ + const CcDisplayLogicalMonitor *ma = a; + const CcDisplayLogicalMonitor *mb = b; + return ma->x - mb->x; +} + +static gint +sort_y_axis (gconstpointer a, gconstpointer b) +{ + const CcDisplayLogicalMonitor *ma = a; + const CcDisplayLogicalMonitor *mb = b; + return ma->y - mb->y; +} + +static void +add_x_delta (gpointer d1, gpointer d2) +{ + CcDisplayLogicalMonitor *m = d1; + int delta = GPOINTER_TO_INT (d2); + m->x += delta; +} + +static gboolean +logical_monitor_is_rotated (CcDisplayLogicalMonitor *lm) +{ + switch (lm->rotation) + { + case CC_DISPLAY_ROTATION_90: + case CC_DISPLAY_ROTATION_270: + case CC_DISPLAY_ROTATION_90_FLIPPED: + case CC_DISPLAY_ROTATION_270_FLIPPED: + return TRUE; + default: + return FALSE; + } +} + +static int +logical_monitor_width (CcDisplayLogicalMonitor *lm) +{ + CcDisplayMonitorDBus *monitor; + CcDisplayModeDBus *mode; + GHashTableIter iter; + int width; + + g_hash_table_iter_init (&iter, lm->monitors); + g_hash_table_iter_next (&iter, (void **) &monitor, NULL); + mode = CC_DISPLAY_MODE_DBUS (monitor->current_mode); + if (logical_monitor_is_rotated (lm)) + width = mode ? mode->height : 0; + else + width = mode ? mode->width : 0; + + if (monitor->config->layout_mode == CC_DISPLAY_LAYOUT_MODE_LOGICAL) + return round (width / lm->scale); + else + return width; +} + +static void +add_y_delta (gpointer d1, gpointer d2) +{ + CcDisplayLogicalMonitor *m = d1; + int delta = GPOINTER_TO_INT (d2); + m->y += delta; +} + +static void +cc_display_config_dbus_ensure_non_offset_coords (CcDisplayConfigDBus *self) +{ + GList *x_axis, *y_axis; + CcDisplayLogicalMonitor *m; + + if (g_hash_table_size (self->logical_monitors) == 0) + return; + + x_axis = g_hash_table_get_keys (self->logical_monitors); + x_axis = g_list_sort (x_axis, sort_x_axis); + y_axis = g_hash_table_get_keys (self->logical_monitors); + y_axis = g_list_sort (y_axis, sort_y_axis); + + m = x_axis->data; + if (m->x != 0) + g_list_foreach (x_axis, add_x_delta, GINT_TO_POINTER (- m->x)); + + m = y_axis->data; + if (m->y != 0) + g_list_foreach (y_axis, add_y_delta, GINT_TO_POINTER (- m->y)); + + g_list_free (x_axis); + g_list_free (y_axis); +} + +static void +cc_display_config_dbus_append_right (CcDisplayConfigDBus *self, + CcDisplayLogicalMonitor *monitor) +{ + GList *x_axis; + CcDisplayLogicalMonitor *last; + + if (g_hash_table_size (self->logical_monitors) == 0) + { + monitor->x = 0; + monitor->y = 0; + return; + } + + x_axis = g_hash_table_get_keys (self->logical_monitors); + x_axis = g_list_sort (x_axis, sort_x_axis); + last = g_list_last (x_axis)->data; + monitor->x = last->x + logical_monitor_width (last); + monitor->y = last->y; + + g_list_free (x_axis); +} + +static void +cc_display_config_dbus_make_linear (CcDisplayConfigDBus *self) +{ + CcDisplayLogicalMonitor *primary; + GList *logical_monitors, *l; + int x; + + if (self->primary && self->primary->logical_monitor) + { + primary = self->primary->logical_monitor; + primary->x = primary->y = 0; + x = logical_monitor_width (primary); + } + else + { + primary = NULL; + x = 0; + } + + logical_monitors = g_hash_table_get_keys (self->logical_monitors); + for (l = logical_monitors; l != NULL; l = l->next) + { + CcDisplayLogicalMonitor *m = l->data; + + if (m == primary) + continue; + + m->x = x; + m->y = 0; + x += logical_monitor_width (m); + } + + g_list_free (logical_monitors); +} diff --git a/panels/display/cc-display-config-dbus.h b/panels/display/cc-display-config-dbus.h new file mode 100644 index 0000000..8609087 --- /dev/null +++ b/panels/display/cc-display-config-dbus.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2017 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, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + */ + +#pragma once + +#include <glib-object.h> + +#include "cc-display-config.h" + +G_BEGIN_DECLS + +#define CC_TYPE_DISPLAY_MODE_DBUS (cc_display_mode_dbus_get_type ()) +G_DECLARE_FINAL_TYPE (CcDisplayModeDBus, cc_display_mode_dbus, + CC, DISPLAY_MODE_DBUS, CcDisplayMode) + +#define CC_TYPE_DISPLAY_MONITOR_DBUS (cc_display_monitor_dbus_get_type ()) +G_DECLARE_FINAL_TYPE (CcDisplayMonitorDBus, cc_display_monitor_dbus, + CC, DISPLAY_MONITOR_DBUS, CcDisplayMonitor) + +#define CC_TYPE_DISPLAY_CONFIG_DBUS (cc_display_config_dbus_get_type ()) +G_DECLARE_FINAL_TYPE (CcDisplayConfigDBus, cc_display_config_dbus, + CC, DISPLAY_CONFIG_DBUS, CcDisplayConfig) + +G_END_DECLS diff --git a/panels/display/cc-display-config-manager-dbus.c b/panels/display/cc-display-config-manager-dbus.c new file mode 100644 index 0000000..678b696 --- /dev/null +++ b/panels/display/cc-display-config-manager-dbus.c @@ -0,0 +1,241 @@ +/* + * Copyright (C) 2017 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, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + */ + +#include "cc-display-config-dbus.h" +#include "cc-display-config-manager-dbus.h" + +#include <gio/gio.h> + +struct _CcDisplayConfigManagerDBus +{ + CcDisplayConfigManager parent_instance; + + GCancellable *cancellable; + GDBusConnection *connection; + guint monitors_changed_id; + + GVariant *current_state; + + gboolean apply_allowed; + gboolean night_light_supported; +}; + +G_DEFINE_TYPE (CcDisplayConfigManagerDBus, + cc_display_config_manager_dbus, + CC_TYPE_DISPLAY_CONFIG_MANAGER) + +static CcDisplayConfig * +cc_display_config_manager_dbus_get_current (CcDisplayConfigManager *pself) +{ + CcDisplayConfigManagerDBus *self = CC_DISPLAY_CONFIG_MANAGER_DBUS (pself); + + if (!self->current_state) + return NULL; + + return g_object_new (CC_TYPE_DISPLAY_CONFIG_DBUS, + "state", self->current_state, + "connection", self->connection, NULL); +} + +static void +got_current_state (GObject *object, + GAsyncResult *result, + gpointer data) +{ + CcDisplayConfigManagerDBus *self; + GVariant *variant; + g_autoptr(GError) error = NULL; + + variant = g_dbus_connection_call_finish (G_DBUS_CONNECTION (object), + result, &error); + if (!variant) + { + if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + { + self = CC_DISPLAY_CONFIG_MANAGER_DBUS (data); + g_clear_pointer (&self->current_state, g_variant_unref); + _cc_display_config_manager_emit_changed (CC_DISPLAY_CONFIG_MANAGER (data)); + g_warning ("Error calling GetCurrentState: %s", error->message); + } + return; + } + + self = CC_DISPLAY_CONFIG_MANAGER_DBUS (data); + g_clear_pointer (&self->current_state, g_variant_unref); + self->current_state = variant; + + _cc_display_config_manager_emit_changed (CC_DISPLAY_CONFIG_MANAGER (self)); +} + +static void +get_current_state (CcDisplayConfigManagerDBus *self) +{ + g_dbus_connection_call (self->connection, + "org.gnome.Mutter.DisplayConfig", + "/org/gnome/Mutter/DisplayConfig", + "org.gnome.Mutter.DisplayConfig", + "GetCurrentState", + NULL, + NULL, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + -1, + self->cancellable, + got_current_state, + self); +} + +static void +monitors_changed (GDBusConnection *connection, + const gchar *sender_name, + const gchar *object_path, + const gchar *interface_name, + const gchar *signal_name, + GVariant *parameters, + gpointer data) +{ + CcDisplayConfigManagerDBus *self = CC_DISPLAY_CONFIG_MANAGER_DBUS (data); + get_current_state (self); +} + +static void +bus_gotten (GObject *object, + GAsyncResult *result, + gpointer data) +{ + CcDisplayConfigManagerDBus *self; + GDBusConnection *connection; + g_autoptr(GError) error = NULL; + g_autoptr(GDBusProxy) proxy = NULL; + g_autoptr(GVariant) variant = NULL; + + connection = g_bus_get_finish (result, &error); + if (!connection) + { + if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + { + _cc_display_config_manager_emit_changed (CC_DISPLAY_CONFIG_MANAGER (data)); + g_warning ("Error obtaining DBus connection: %s", error->message); + } + return; + } + + self = CC_DISPLAY_CONFIG_MANAGER_DBUS (data); + self->connection = connection; + self->monitors_changed_id = + g_dbus_connection_signal_subscribe (self->connection, + "org.gnome.Mutter.DisplayConfig", + "org.gnome.Mutter.DisplayConfig", + "MonitorsChanged", + "/org/gnome/Mutter/DisplayConfig", + NULL, + G_DBUS_SIGNAL_FLAGS_NONE, + monitors_changed, + self, + NULL); + + proxy = g_dbus_proxy_new_sync (self->connection, + G_DBUS_PROXY_FLAGS_NONE, + NULL, + "org.gnome.Mutter.DisplayConfig", + "/org/gnome/Mutter/DisplayConfig", + "org.gnome.Mutter.DisplayConfig", + NULL, + &error); + if (!proxy) + { + g_warning ("Failed to create D-Bus proxy to \"org.gnome.Mutter.DisplayConfig\": %s", + error->message); + return; + } + + variant = g_dbus_proxy_get_cached_property (proxy, "ApplyMonitorsConfigAllowed"); + if (variant) + self->apply_allowed = g_variant_get_boolean (variant); + else + g_warning ("Missing property 'ApplyMonitorsConfigAllowed' on DisplayConfig API"); + + variant = g_dbus_proxy_get_cached_property (proxy, "NightLightSupported"); + if (variant) + self->night_light_supported = g_variant_get_boolean (variant); + else + g_warning ("Missing property 'NightLightSupported' on DisplayConfig API"); + + get_current_state (self); +} + +static void +cc_display_config_manager_dbus_init (CcDisplayConfigManagerDBus *self) +{ + self->apply_allowed = TRUE; + self->night_light_supported = TRUE; + self->cancellable = g_cancellable_new (); + g_bus_get (G_BUS_TYPE_SESSION, self->cancellable, bus_gotten, self); +} + +static void +cc_display_config_manager_dbus_finalize (GObject *object) +{ + CcDisplayConfigManagerDBus *self = CC_DISPLAY_CONFIG_MANAGER_DBUS (object); + + g_cancellable_cancel (self->cancellable); + g_clear_object (&self->cancellable); + + if (self->monitors_changed_id && self->connection) + g_dbus_connection_signal_unsubscribe (self->connection, + self->monitors_changed_id); + g_clear_object (&self->connection); + g_clear_pointer (&self->current_state, g_variant_unref); + + G_OBJECT_CLASS (cc_display_config_manager_dbus_parent_class)->finalize (object); +} + +static gboolean +cc_display_config_manager_dbus_get_apply_allowed (CcDisplayConfigManager *pself) +{ + CcDisplayConfigManagerDBus *self = CC_DISPLAY_CONFIG_MANAGER_DBUS (pself); + + return self->apply_allowed; +} + +static gboolean +cc_display_config_manager_dbus_get_night_light_supported (CcDisplayConfigManager *pself) +{ + CcDisplayConfigManagerDBus *self = CC_DISPLAY_CONFIG_MANAGER_DBUS (pself); + + return self->night_light_supported; +} + +static void +cc_display_config_manager_dbus_class_init (CcDisplayConfigManagerDBusClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + CcDisplayConfigManagerClass *parent_class = CC_DISPLAY_CONFIG_MANAGER_CLASS (klass); + + gobject_class->finalize = cc_display_config_manager_dbus_finalize; + + parent_class->get_current = cc_display_config_manager_dbus_get_current; + parent_class->get_apply_allowed = cc_display_config_manager_dbus_get_apply_allowed; + parent_class->get_night_light_supported = cc_display_config_manager_dbus_get_night_light_supported; +} + +CcDisplayConfigManager * +cc_display_config_manager_dbus_new (void) +{ + return g_object_new (CC_TYPE_DISPLAY_CONFIG_MANAGER_DBUS, NULL); +} diff --git a/panels/display/cc-display-config-manager-dbus.h b/panels/display/cc-display-config-manager-dbus.h new file mode 100644 index 0000000..a099598 --- /dev/null +++ b/panels/display/cc-display-config-manager-dbus.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2017 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, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + */ + +#pragma once + +#include <glib-object.h> + +#include "cc-display-config-manager.h" + +G_BEGIN_DECLS + +#define CC_TYPE_DISPLAY_CONFIG_MANAGER_DBUS (cc_display_config_manager_dbus_get_type ()) +G_DECLARE_FINAL_TYPE (CcDisplayConfigManagerDBus, cc_display_config_manager_dbus, + CC, DISPLAY_CONFIG_MANAGER_DBUS, CcDisplayConfigManager) + +CcDisplayConfigManager * cc_display_config_manager_dbus_new (void); + +G_END_DECLS diff --git a/panels/display/cc-display-config-manager.c b/panels/display/cc-display-config-manager.c new file mode 100644 index 0000000..f231edd --- /dev/null +++ b/panels/display/cc-display-config-manager.c @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2016 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, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + */ + +#include "cc-display-config-manager.h" + +G_DEFINE_TYPE (CcDisplayConfigManager, + cc_display_config_manager, + G_TYPE_OBJECT) + +enum +{ + CONFIG_MANAGER_CHANGED, + N_CONFIG_MANAGER_SIGNALS, +}; + +static guint config_manager_signals[N_CONFIG_MANAGER_SIGNALS] = { 0 }; + +static void +cc_display_config_manager_init (CcDisplayConfigManager *self) +{ +} + +static void +cc_display_config_manager_class_init (CcDisplayConfigManagerClass *klass) +{ + config_manager_signals[CONFIG_MANAGER_CHANGED] = + g_signal_new ("changed", + CC_TYPE_DISPLAY_CONFIG_MANAGER, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); +} + +void +_cc_display_config_manager_emit_changed (CcDisplayConfigManager *self) +{ + g_signal_emit (self, config_manager_signals[CONFIG_MANAGER_CHANGED], 0); +} + +CcDisplayConfig * +cc_display_config_manager_get_current (CcDisplayConfigManager *self) +{ + return CC_DISPLAY_CONFIG_MANAGER_GET_CLASS (self)->get_current (self); +} + +gboolean +cc_display_config_manager_get_apply_allowed (CcDisplayConfigManager *self) +{ + return CC_DISPLAY_CONFIG_MANAGER_GET_CLASS (self)->get_apply_allowed (self); +} + +gboolean +cc_display_config_manager_get_night_light_supported (CcDisplayConfigManager *self) +{ + return CC_DISPLAY_CONFIG_MANAGER_GET_CLASS (self)->get_night_light_supported (self); +} diff --git a/panels/display/cc-display-config-manager.h b/panels/display/cc-display-config-manager.h new file mode 100644 index 0000000..ab1e84f --- /dev/null +++ b/panels/display/cc-display-config-manager.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2016 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, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + */ + +#pragma once + +#include <glib-object.h> + +#include "cc-display-config.h" + +G_BEGIN_DECLS + +#define CC_TYPE_DISPLAY_CONFIG_MANAGER (cc_display_config_manager_get_type ()) +G_DECLARE_DERIVABLE_TYPE (CcDisplayConfigManager, cc_display_config_manager, + CC, DISPLAY_CONFIG_MANAGER, GObject) + +struct _CcDisplayConfigManagerClass +{ + GObjectClass parent_class; + + CcDisplayConfig * (*get_current) (CcDisplayConfigManager *self); + gboolean (* get_apply_allowed) (CcDisplayConfigManager *self); + gboolean (* get_night_light_supported) (CcDisplayConfigManager *self); +}; + +CcDisplayConfig * cc_display_config_manager_get_current (CcDisplayConfigManager *self); + +gboolean cc_display_config_manager_get_apply_allowed (CcDisplayConfigManager *self); + +gboolean cc_display_config_manager_get_night_light_supported (CcDisplayConfigManager *self); + +void _cc_display_config_manager_emit_changed (CcDisplayConfigManager *self); + +G_END_DECLS diff --git a/panels/display/cc-display-config.c b/panels/display/cc-display-config.c new file mode 100644 index 0000000..b7532f9 --- /dev/null +++ b/panels/display/cc-display-config.c @@ -0,0 +1,665 @@ +/* + * Copyright (C) 2016 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, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + */ + +#include <gio/gio.h> +#include <math.h> +#include "cc-display-config.h" + +static const double known_diagonals[] = { + 12.1, + 13.3, + 15.6 +}; + +static char * +diagonal_to_str (double d) +{ + int i; + + for (i = 0; i < G_N_ELEMENTS (known_diagonals); i++) + { + double delta; + + delta = fabs(known_diagonals[i] - d); + if (delta < 0.1) + return g_strdup_printf ("%0.1lf\"", known_diagonals[i]); + } + + return g_strdup_printf ("%d\"", (int) (d + 0.5)); +} + +static char * +make_display_size_string (int width_mm, + int height_mm) +{ + char *inches = NULL; + + if (width_mm > 0 && height_mm > 0) + { + double d = sqrt (width_mm * width_mm + height_mm * height_mm); + + inches = diagonal_to_str (d / 25.4); + } + + return inches; +} + +static char * +make_output_ui_name (CcDisplayMonitor *output) +{ + int width_mm, height_mm; + g_autofree char *size = NULL; + + cc_display_monitor_get_physical_size (output, &width_mm, &height_mm); + size = make_display_size_string (width_mm, height_mm); + if (size) + return g_strdup_printf ("%s (%s)", cc_display_monitor_get_display_name (output), size); + else + return g_strdup_printf ("%s", cc_display_monitor_get_display_name (output)); +} + + + +G_DEFINE_TYPE (CcDisplayMode, + cc_display_mode, + G_TYPE_OBJECT) + +static void +cc_display_mode_init (CcDisplayMode *self) +{ +} + +static void +cc_display_mode_class_init (CcDisplayModeClass *klass) +{ +} + +gboolean +cc_display_mode_is_clone_mode (CcDisplayMode *self) +{ + return CC_DISPLAY_MODE_GET_CLASS (self)->is_clone_mode (self); +} + +void +cc_display_mode_get_resolution (CcDisplayMode *self, int *w, int *h) +{ + return CC_DISPLAY_MODE_GET_CLASS (self)->get_resolution (self, w, h); +} + +GArray * +cc_display_mode_get_supported_scales (CcDisplayMode *self) +{ + return CC_DISPLAY_MODE_GET_CLASS (self)->get_supported_scales (self); +} + +double +cc_display_mode_get_preferred_scale (CcDisplayMode *self) +{ + return CC_DISPLAY_MODE_GET_CLASS (self)->get_preferred_scale (self); +} + +gboolean +cc_display_mode_is_interlaced (CcDisplayMode *self) +{ + return CC_DISPLAY_MODE_GET_CLASS (self)->is_interlaced (self); +} + +gboolean +cc_display_mode_is_preferred (CcDisplayMode *self) +{ + return CC_DISPLAY_MODE_GET_CLASS (self)->is_preferred (self); +} + +int +cc_display_mode_get_freq (CcDisplayMode *self) +{ + return CC_DISPLAY_MODE_GET_CLASS (self)->get_freq (self); +} + +double +cc_display_mode_get_freq_f (CcDisplayMode *self) +{ + return CC_DISPLAY_MODE_GET_CLASS (self)->get_freq_f (self); +} + + +struct _CcDisplayMonitorPrivate { + int ui_number; + gchar *ui_name; + gchar *ui_number_name; + gboolean is_usable; +}; +typedef struct _CcDisplayMonitorPrivate CcDisplayMonitorPrivate; + +G_DEFINE_TYPE_WITH_PRIVATE (CcDisplayMonitor, + cc_display_monitor, + G_TYPE_OBJECT) + +static void +cc_display_monitor_init (CcDisplayMonitor *self) +{ + CcDisplayMonitorPrivate *priv = cc_display_monitor_get_instance_private (self); + + priv->ui_number = 0; + priv->ui_name = NULL; + priv->ui_number_name = NULL; + priv->is_usable = TRUE; +} + +static void +cc_display_monitor_finalize (GObject *object) +{ + CcDisplayMonitor *self = CC_DISPLAY_MONITOR (object); + CcDisplayMonitorPrivate *priv = cc_display_monitor_get_instance_private (self); + + g_clear_pointer (&priv->ui_name, g_free); + g_clear_pointer (&priv->ui_number_name, g_free); + + G_OBJECT_CLASS (cc_display_monitor_parent_class)->finalize (object); +} + +static void +cc_display_monitor_class_init (CcDisplayMonitorClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->finalize = cc_display_monitor_finalize; + + g_signal_new ("rotation", + CC_TYPE_DISPLAY_MONITOR, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); + g_signal_new ("mode", + CC_TYPE_DISPLAY_MONITOR, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); + g_signal_new ("primary", + CC_TYPE_DISPLAY_MONITOR, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); + g_signal_new ("active", + CC_TYPE_DISPLAY_MONITOR, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); + g_signal_new ("scale", + CC_TYPE_DISPLAY_MONITOR, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); + g_signal_new ("position-changed", + CC_TYPE_DISPLAY_MONITOR, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); + g_signal_new ("is-usable", + CC_TYPE_DISPLAY_MONITOR, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); +} + +const char * +cc_display_monitor_get_display_name (CcDisplayMonitor *self) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->get_display_name (self); +} + +const char * +cc_display_monitor_get_connector_name (CcDisplayMonitor *self) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->get_connector_name (self); +} + +gboolean +cc_display_monitor_is_builtin (CcDisplayMonitor *self) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->is_builtin (self); +} + +gboolean +cc_display_monitor_is_primary (CcDisplayMonitor *self) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->is_primary (self); +} + +void +cc_display_monitor_set_primary (CcDisplayMonitor *self, gboolean primary) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->set_primary (self, primary); +} + +gboolean +cc_display_monitor_is_active (CcDisplayMonitor *self) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->is_active (self); +} + +void +cc_display_monitor_set_active (CcDisplayMonitor *self, gboolean active) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->set_active (self, active); +} + +CcDisplayRotation +cc_display_monitor_get_rotation (CcDisplayMonitor *self) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->get_rotation (self); +} + +void +cc_display_monitor_set_rotation (CcDisplayMonitor *self, + CcDisplayRotation rotation) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->set_rotation (self, rotation); +} + +gboolean +cc_display_monitor_supports_rotation (CcDisplayMonitor *self, CcDisplayRotation r) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->supports_rotation (self, r); +} + +void +cc_display_monitor_get_physical_size (CcDisplayMonitor *self, int *w, int *h) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->get_physical_size (self, w, h); +} + +void +cc_display_monitor_get_geometry (CcDisplayMonitor *self, int *x, int *y, int *w, int *h) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->get_geometry (self, x, y, w, h); +} + +CcDisplayMode * +cc_display_monitor_get_mode (CcDisplayMonitor *self) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->get_mode (self); +} + +CcDisplayMode * +cc_display_monitor_get_preferred_mode (CcDisplayMonitor *self) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->get_preferred_mode (self); +} + +guint32 +cc_display_monitor_get_id (CcDisplayMonitor *self) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->get_id (self); +} + +GList * +cc_display_monitor_get_modes (CcDisplayMonitor *self) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->get_modes (self); +} + +gboolean +cc_display_monitor_supports_underscanning (CcDisplayMonitor *self) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->supports_underscanning (self); +} + +gboolean +cc_display_monitor_get_underscanning (CcDisplayMonitor *self) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->get_underscanning (self); +} + +void +cc_display_monitor_set_underscanning (CcDisplayMonitor *self, + gboolean underscanning) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->set_underscanning (self, underscanning); +} + +CcDisplayMonitorPrivacy +cc_display_monitor_get_privacy (CcDisplayMonitor *self) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->get_privacy (self); +} + +void +cc_display_monitor_set_mode (CcDisplayMonitor *self, CcDisplayMode *m) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->set_mode (self, m); +} + +void +cc_display_monitor_set_compatible_clone_mode (CcDisplayMonitor *self, CcDisplayMode *m) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->set_mode (self, m); +} + +void +cc_display_monitor_set_position (CcDisplayMonitor *self, int x, int y) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->set_position (self, x, y); +} + +double +cc_display_monitor_get_scale (CcDisplayMonitor *self) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->get_scale (self); +} + +void +cc_display_monitor_set_scale (CcDisplayMonitor *self, double s) +{ + return CC_DISPLAY_MONITOR_GET_CLASS (self)->set_scale (self, s); +} + +gboolean +cc_display_monitor_is_useful (CcDisplayMonitor *self) +{ + CcDisplayMonitorPrivate *priv = cc_display_monitor_get_instance_private (self); + + return priv->is_usable && + cc_display_monitor_is_active (self); +} + +gboolean +cc_display_monitor_is_usable (CcDisplayMonitor *self) +{ + CcDisplayMonitorPrivate *priv = cc_display_monitor_get_instance_private (self); + + return priv->is_usable; +} + +void +cc_display_monitor_set_usable (CcDisplayMonitor *self, gboolean is_usable) +{ + CcDisplayMonitorPrivate *priv = cc_display_monitor_get_instance_private (self); + + priv->is_usable = is_usable; + + g_signal_emit_by_name (self, "is-usable"); +} + +gint +cc_display_monitor_get_ui_number (CcDisplayMonitor *self) +{ + CcDisplayMonitorPrivate *priv = cc_display_monitor_get_instance_private (self); + + return priv->ui_number; +} + +const char * +cc_display_monitor_get_ui_name (CcDisplayMonitor *self) +{ + CcDisplayMonitorPrivate *priv = cc_display_monitor_get_instance_private (self); + + return priv->ui_name; +} + +const char * +cc_display_monitor_get_ui_number_name (CcDisplayMonitor *self) +{ + CcDisplayMonitorPrivate *priv = cc_display_monitor_get_instance_private (self); + + return priv->ui_number_name; +} + +char * +cc_display_monitor_dup_ui_number_name (CcDisplayMonitor *self) +{ + CcDisplayMonitorPrivate *priv = cc_display_monitor_get_instance_private (self); + + return g_strdup (priv->ui_number_name); +} + +static void +cc_display_monitor_set_ui_info (CcDisplayMonitor *self, gint ui_number, gchar *ui_name) +{ + + CcDisplayMonitorPrivate *priv = cc_display_monitor_get_instance_private (self); + + priv->ui_number = ui_number; + g_free (priv->ui_name); + priv->ui_name = ui_name; + priv->ui_number_name = g_strdup_printf ("%d\u2003%s", ui_number, ui_name); +} + +struct _CcDisplayConfigPrivate { + GList *ui_sorted_monitors; +}; +typedef struct _CcDisplayConfigPrivate CcDisplayConfigPrivate; + +G_DEFINE_TYPE_WITH_PRIVATE (CcDisplayConfig, + cc_display_config, + G_TYPE_OBJECT) + +static void +cc_display_config_init (CcDisplayConfig *self) +{ + CcDisplayConfigPrivate *priv = cc_display_config_get_instance_private (self); + + priv->ui_sorted_monitors = NULL; +} + +static void +cc_display_config_constructed (GObject *object) +{ + CcDisplayConfig *self = CC_DISPLAY_CONFIG (object); + CcDisplayConfigPrivate *priv = cc_display_config_get_instance_private (self); + GList *monitors = cc_display_config_get_monitors (self); + GList *item; + gint ui_number = 1; + + for (item = monitors; item != NULL; item = item->next) + { + CcDisplayMonitor *monitor = item->data; + + if (cc_display_monitor_is_builtin (monitor)) + priv->ui_sorted_monitors = g_list_prepend (priv->ui_sorted_monitors, monitor); + else + priv->ui_sorted_monitors = g_list_append (priv->ui_sorted_monitors, monitor); + } + + for (item = priv->ui_sorted_monitors; item != NULL; item = item->next) + { + CcDisplayMonitor *monitor = item->data; + char *ui_name; + ui_name = make_output_ui_name (monitor); + + cc_display_monitor_set_ui_info (monitor, ui_number, ui_name); + + ui_number += 1; + } +} + +static void +cc_display_config_finalize (GObject *object) +{ + CcDisplayConfig *self = CC_DISPLAY_CONFIG (object); + CcDisplayConfigPrivate *priv = cc_display_config_get_instance_private (self); + + g_list_free (priv->ui_sorted_monitors); + + G_OBJECT_CLASS (cc_display_config_parent_class)->finalize (object); +} + +static void +cc_display_config_class_init (CcDisplayConfigClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + g_signal_new ("primary", + CC_TYPE_DISPLAY_CONFIG, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); + g_signal_new ("panel-orientation-managed", + CC_TYPE_DISPLAY_CONFIG, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 1, G_TYPE_BOOLEAN); + + gobject_class->constructed = cc_display_config_constructed; + gobject_class->finalize = cc_display_config_finalize; +} + +GList * +cc_display_config_get_monitors (CcDisplayConfig *self) +{ + g_return_val_if_fail (CC_IS_DISPLAY_CONFIG (self), NULL); + return CC_DISPLAY_CONFIG_GET_CLASS (self)->get_monitors (self); +} + +GList * +cc_display_config_get_ui_sorted_monitors (CcDisplayConfig *self) +{ + CcDisplayConfigPrivate *priv = cc_display_config_get_instance_private (self); + + g_return_val_if_fail (CC_IS_DISPLAY_CONFIG (self), NULL); + return priv->ui_sorted_monitors; +} + +int +cc_display_config_count_useful_monitors (CcDisplayConfig *self) +{ + CcDisplayConfigPrivate *priv = cc_display_config_get_instance_private (self); + GList *outputs, *l; + guint count = 0; + + g_return_val_if_fail (CC_IS_DISPLAY_CONFIG (self), 0); + + outputs = priv->ui_sorted_monitors; + for (l = outputs; l != NULL; l = l->next) + { + CcDisplayMonitor *output = l->data; + if (!cc_display_monitor_is_useful (output)) + continue; + else + count++; + } + return count; + +} + +gboolean +cc_display_config_is_applicable (CcDisplayConfig *self) +{ + g_return_val_if_fail (CC_IS_DISPLAY_CONFIG (self), FALSE); + return CC_DISPLAY_CONFIG_GET_CLASS (self)->is_applicable (self); +} + +void +cc_display_config_set_mode_on_all_outputs (CcDisplayConfig *config, + CcDisplayMode *clone_mode) +{ + GList *outputs, *l; + + g_return_if_fail (CC_IS_DISPLAY_CONFIG (config)); + g_return_if_fail (cc_display_mode_is_clone_mode (clone_mode)); + + outputs = cc_display_config_get_monitors (config); + for (l = outputs; l; l = l->next) + { + CcDisplayMonitor *output = l->data; + cc_display_monitor_set_compatible_clone_mode (output, clone_mode); + cc_display_monitor_set_position (output, 0, 0); + } +} + +gboolean +cc_display_config_equal (CcDisplayConfig *self, + CcDisplayConfig *other) +{ + g_return_val_if_fail (CC_IS_DISPLAY_CONFIG (self), FALSE); + g_return_val_if_fail (CC_IS_DISPLAY_CONFIG (other), FALSE); + + return CC_DISPLAY_CONFIG_GET_CLASS (self)->equal (self, other); +} + +gboolean +cc_display_config_apply (CcDisplayConfig *self, + GError **error) +{ + if (!CC_IS_DISPLAY_CONFIG (self)) + { + g_warning ("Cannot apply invalid configuration"); + g_set_error (error, + G_IO_ERROR, + G_IO_ERROR_FAILED, + "Cannot apply invalid configuration"); + return FALSE; + } + + return CC_DISPLAY_CONFIG_GET_CLASS (self)->apply (self, error); +} + +gboolean +cc_display_config_is_cloning (CcDisplayConfig *self) +{ + g_return_val_if_fail (CC_IS_DISPLAY_CONFIG (self), FALSE); + return CC_DISPLAY_CONFIG_GET_CLASS (self)->is_cloning (self); +} + +void +cc_display_config_set_cloning (CcDisplayConfig *self, + gboolean clone) +{ + g_return_if_fail (CC_IS_DISPLAY_CONFIG (self)); + return CC_DISPLAY_CONFIG_GET_CLASS (self)->set_cloning (self, clone); +} + +GList * +cc_display_config_generate_cloning_modes (CcDisplayConfig *self) +{ + g_return_val_if_fail (CC_IS_DISPLAY_CONFIG (self), NULL); + return CC_DISPLAY_CONFIG_GET_CLASS (self)->generate_cloning_modes (self); +} + +gboolean +cc_display_config_is_layout_logical (CcDisplayConfig *self) +{ + g_return_val_if_fail (CC_IS_DISPLAY_CONFIG (self), FALSE); + return CC_DISPLAY_CONFIG_GET_CLASS (self)->is_layout_logical (self); +} + +void +cc_display_config_set_minimum_size (CcDisplayConfig *self, + int width, + int height) +{ + g_return_if_fail (CC_IS_DISPLAY_CONFIG (self)); + CC_DISPLAY_CONFIG_GET_CLASS (self)->set_minimum_size (self, width, height); +} + +gboolean +cc_display_config_is_scaled_mode_valid (CcDisplayConfig *self, + CcDisplayMode *mode, + double scale) +{ + g_return_val_if_fail (CC_IS_DISPLAY_CONFIG (self), FALSE); + g_return_val_if_fail (CC_IS_DISPLAY_MODE (mode), FALSE); + return CC_DISPLAY_CONFIG_GET_CLASS (self)->is_scaled_mode_valid (self, mode, scale); +} + +gboolean +cc_display_config_get_panel_orientation_managed (CcDisplayConfig *self) +{ + return CC_DISPLAY_CONFIG_GET_CLASS (self)->get_panel_orientation_managed (self); +} diff --git a/panels/display/cc-display-config.h b/panels/display/cc-display-config.h new file mode 100644 index 0000000..1241adc --- /dev/null +++ b/panels/display/cc-display-config.h @@ -0,0 +1,272 @@ +/* + * Copyright (C) 2016 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, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + */ + +#pragma once + +#include <glib-object.h> + +G_BEGIN_DECLS + +/* + * GNOME Control Center display configuration system: + * + * The display configuration system consists of multiple concepts: + * + * CcDisplayConfig: + * + * Configuration instance, read from mutter using the + * org.gnome.Mutter.DisplayConfig D-Bus API. Contains information about the + * current configuration. Can be copied, to create a representation of a + * configuration at a given time, and applied, applying any changes that has + * been made to the objects associated with the configuration. + * + * CcDisplayConfig provides a list of all known "monitors" known to the + * compositor. It does not know about ports without any monitors connected, + * nor low level details about monitors, such as tiling etc. + * + * CcDisplayMonitor: + * + * A high level representation of a connected monitor. A monitor have details + * associated with it, some which can be altered. Each CcDisplayMonitor + * instance is associated with a single CcDisplayConfig instance. All + * alteration to a monitor is cached and not applied until + * cc_display_config_apply() is called on the corresponding CcDisplayConfig + * object. + * + * CcDisplayMode: + * + * A monitor mode, including resolution, refresh rate, and scale. Each monitor + * will have a list of possible modes. + * + */ + +typedef enum _CcDisplayRotation +{ + CC_DISPLAY_ROTATION_NONE, + CC_DISPLAY_ROTATION_90, + CC_DISPLAY_ROTATION_180, + CC_DISPLAY_ROTATION_270, + CC_DISPLAY_ROTATION_FLIPPED, + CC_DISPLAY_ROTATION_90_FLIPPED, + CC_DISPLAY_ROTATION_180_FLIPPED, + CC_DISPLAY_ROTATION_270_FLIPPED, +} CcDisplayRotation; + +typedef enum _CcDisplayMonitorPrivacy +{ + CC_DISPLAY_MONITOR_PRIVACY_UNSUPPORTED = 0, + CC_DISPLAY_MONITOR_PRIVACY_DISABLED = 1 << 0, + CC_DISPLAY_MONITOR_PRIVACY_ENABLED = 1 << 1, + CC_DISPLAY_MONITOR_PRIVACY_LOCKED = 1 << 2, +} CcDisplayMonitorPrivacy; + + +#define CC_TYPE_DISPLAY_MODE (cc_display_mode_get_type ()) +G_DECLARE_DERIVABLE_TYPE (CcDisplayMode, cc_display_mode, + CC, DISPLAY_MODE, GObject) + +struct _CcDisplayModeClass +{ + GObjectClass parent_class; + + gboolean (*is_clone_mode) (CcDisplayMode *self); + void (*get_resolution) (CcDisplayMode *self, int *w, int *h); + GArray* (*get_supported_scales) (CcDisplayMode *self); + double (*get_preferred_scale) (CcDisplayMode *self); + gboolean (*is_interlaced) (CcDisplayMode *self); + gboolean (*is_preferred) (CcDisplayMode *self); + int (*get_freq) (CcDisplayMode *self); + double (*get_freq_f) (CcDisplayMode *self); +}; + + +#define CC_TYPE_DISPLAY_MONITOR (cc_display_monitor_get_type ()) +G_DECLARE_DERIVABLE_TYPE (CcDisplayMonitor, cc_display_monitor, + CC, DISPLAY_MONITOR, GObject) + +struct _CcDisplayMonitorClass +{ + GObjectClass parent_class; + + guint32 (*get_id) (CcDisplayMonitor *self); + const char* (*get_display_name) (CcDisplayMonitor *self); + const char* (*get_connector_name) (CcDisplayMonitor *self); + gboolean (*is_builtin) (CcDisplayMonitor *self); + gboolean (*is_primary) (CcDisplayMonitor *self); + void (*set_primary) (CcDisplayMonitor *self, + gboolean primary); + gboolean (*is_active) (CcDisplayMonitor *self); + void (*set_active) (CcDisplayMonitor *self, + gboolean a); + CcDisplayRotation (*get_rotation) (CcDisplayMonitor *self); + void (*set_rotation) (CcDisplayMonitor *self, + CcDisplayRotation r); + gboolean (*supports_rotation) (CcDisplayMonitor *self, + CcDisplayRotation r); + void (*get_physical_size) (CcDisplayMonitor *self, + int *w, + int *h); + void (*get_geometry) (CcDisplayMonitor *self, + int *x, + int *y, + int *w, + int *h); + gboolean (*supports_underscanning) (CcDisplayMonitor *self); + gboolean (*get_underscanning) (CcDisplayMonitor *self); + void (*set_underscanning) (CcDisplayMonitor *self, + gboolean u); + CcDisplayMonitorPrivacy (*get_privacy) (CcDisplayMonitor *self); + CcDisplayMode* (*get_mode) (CcDisplayMonitor *self); + CcDisplayMode* (*get_preferred_mode) (CcDisplayMonitor *self); + GList* (*get_modes) (CcDisplayMonitor *self); + void (*set_compatible_clone_mode) (CcDisplayMonitor *self, + CcDisplayMode *m); + void (*set_mode) (CcDisplayMonitor *self, + CcDisplayMode *m); + void (*set_position) (CcDisplayMonitor *self, + int x, + int y); + double (*get_scale) (CcDisplayMonitor *self); + void (*set_scale) (CcDisplayMonitor *self, + double s); +}; + + +#define CC_TYPE_DISPLAY_CONFIG (cc_display_config_get_type ()) +G_DECLARE_DERIVABLE_TYPE (CcDisplayConfig, cc_display_config, + CC, DISPLAY_CONFIG, GObject) + +struct _CcDisplayConfigClass +{ + GObjectClass parent_class; + + GList* (*get_monitors) (CcDisplayConfig *self); + gboolean (*is_applicable) (CcDisplayConfig *self); + gboolean (*equal) (CcDisplayConfig *self, + CcDisplayConfig *other); + gboolean (*apply) (CcDisplayConfig *self, + GError **error); + gboolean (*is_cloning) (CcDisplayConfig *self); + void (*set_cloning) (CcDisplayConfig *self, + gboolean clone); + GList* (*generate_cloning_modes) (CcDisplayConfig *self); + gboolean (*is_layout_logical) (CcDisplayConfig *self); + void (*set_minimum_size) (CcDisplayConfig *self, + int width, + int height); + gboolean (*is_scaled_mode_valid) (CcDisplayConfig *self, + CcDisplayMode *mode, + double scale); + gboolean (* get_panel_orientation_managed) (CcDisplayConfig *self); +}; + + +GList* cc_display_config_get_monitors (CcDisplayConfig *config); +GList* cc_display_config_get_ui_sorted_monitors (CcDisplayConfig *config); +int cc_display_config_count_useful_monitors (CcDisplayConfig *config); +gboolean cc_display_config_is_applicable (CcDisplayConfig *config); +gboolean cc_display_config_equal (CcDisplayConfig *config, + CcDisplayConfig *other); +gboolean cc_display_config_apply (CcDisplayConfig *config, + GError **error); +gboolean cc_display_config_is_cloning (CcDisplayConfig *config); +void cc_display_config_set_cloning (CcDisplayConfig *config, + gboolean clone); +GList* cc_display_config_generate_cloning_modes (CcDisplayConfig *config); + +void cc_display_config_set_mode_on_all_outputs (CcDisplayConfig *config, + CcDisplayMode *mode); + +gboolean cc_display_config_is_layout_logical (CcDisplayConfig *self); +void cc_display_config_set_minimum_size (CcDisplayConfig *self, + int width, + int height); +gboolean cc_display_config_is_scaled_mode_valid (CcDisplayConfig *self, + CcDisplayMode *mode, + double scale); +gboolean cc_display_config_get_panel_orientation_managed + (CcDisplayConfig *self); + +const char* cc_display_monitor_get_display_name (CcDisplayMonitor *monitor); +gboolean cc_display_monitor_is_active (CcDisplayMonitor *monitor); +void cc_display_monitor_set_active (CcDisplayMonitor *monitor, + gboolean active); +const char* cc_display_monitor_get_connector_name (CcDisplayMonitor *monitor); +CcDisplayRotation cc_display_monitor_get_rotation (CcDisplayMonitor *monitor); +void cc_display_monitor_set_rotation (CcDisplayMonitor *monitor, + CcDisplayRotation r); +gboolean cc_display_monitor_supports_rotation (CcDisplayMonitor *monitor, + CcDisplayRotation rotation); +void cc_display_monitor_get_physical_size (CcDisplayMonitor *monitor, + int *w, + int *h); +gboolean cc_display_monitor_is_builtin (CcDisplayMonitor *monitor); +gboolean cc_display_monitor_is_primary (CcDisplayMonitor *monitor); +void cc_display_monitor_set_primary (CcDisplayMonitor *monitor, + gboolean primary); +guint32 cc_display_monitor_get_id (CcDisplayMonitor *monitor); + +gboolean cc_display_monitor_supports_underscanning (CcDisplayMonitor *monitor); +gboolean cc_display_monitor_get_underscanning (CcDisplayMonitor *monitor); +void cc_display_monitor_set_underscanning (CcDisplayMonitor *monitor, + gboolean underscanning); + +CcDisplayMonitorPrivacy cc_display_monitor_get_privacy (CcDisplayMonitor *self); + +CcDisplayMode* cc_display_monitor_get_mode (CcDisplayMonitor *monitor); +void cc_display_monitor_get_geometry (CcDisplayMonitor *monitor, + int *x, + int *y, + int *width, + int *height); +GList* cc_display_monitor_get_modes (CcDisplayMonitor *monitor); +CcDisplayMode* cc_display_monitor_get_preferred_mode (CcDisplayMonitor *monitor); +double cc_display_monitor_get_scale (CcDisplayMonitor *monitor); +void cc_display_monitor_set_scale (CcDisplayMonitor *monitor, + double s); + +void cc_display_monitor_set_compatible_clone_mode (CcDisplayMonitor *monitor, + CcDisplayMode *mode); +void cc_display_monitor_set_mode (CcDisplayMonitor *monitor, + CcDisplayMode *mode); +void cc_display_monitor_set_position (CcDisplayMonitor *monitor, + int x, + int y); + +gboolean cc_display_monitor_is_useful (CcDisplayMonitor *monitor); +gboolean cc_display_monitor_is_usable (CcDisplayMonitor *monitor); +void cc_display_monitor_set_usable (CcDisplayMonitor *monitor, + gboolean is_usable); +int cc_display_monitor_get_ui_number (CcDisplayMonitor *monitor); +const char* cc_display_monitor_get_ui_name (CcDisplayMonitor *monitor); +const char* cc_display_monitor_get_ui_number_name (CcDisplayMonitor *monitor); +char* cc_display_monitor_dup_ui_number_name (CcDisplayMonitor *monitor); + +gboolean cc_display_mode_is_clone_mode (CcDisplayMode *mode); +void cc_display_mode_get_resolution (CcDisplayMode *mode, + int *width, + int *height); +GArray* cc_display_mode_get_supported_scales (CcDisplayMode *self); +double cc_display_mode_get_preferred_scale (CcDisplayMode *self); +gboolean cc_display_mode_is_interlaced (CcDisplayMode *mode); +gboolean cc_display_mode_is_preferred (CcDisplayMode *mode); +int cc_display_mode_get_freq (CcDisplayMode *mode); +double cc_display_mode_get_freq_f (CcDisplayMode *mode); + +G_END_DECLS diff --git a/panels/display/cc-display-panel.c b/panels/display/cc-display-panel.c new file mode 100644 index 0000000..6958e19 --- /dev/null +++ b/panels/display/cc-display-panel.c @@ -0,0 +1,1140 @@ +/* + * Copyright (C) 2007, 2008 Red Hat, Inc. + * Copyright (C) 2013 Intel, 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, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + */ + +#include "cc-display-panel.h" + +#include <gtk/gtk.h> +#include <glib/gi18n.h> +#include <stdlib.h> +#include <gdesktop-enums.h> +#include <math.h> + +#include "shell/cc-object-storage.h" +#include <libupower-glib/upower.h> + +#include "cc-display-config-manager-dbus.h" +#include "cc-display-config.h" +#include "cc-display-arrangement.h" +#include "cc-night-light-page.h" +#include "cc-display-resources.h" +#include "cc-display-settings.h" + +/* The minimum supported size for the panel + * Note that WIDTH is assumed to be the larger size and we accept portrait + * mode too effectively (in principle we should probably restrict the rotation + * setting in that case). */ +#define MINIMUM_WIDTH 720 +#define MINIMUM_HEIGHT 360 + +#define PANEL_PADDING 32 +#define SECTION_PADDING 32 +#define HEADING_PADDING 12 + +#define DISPLAY_SCHEMA "org.gnome.settings-daemon.plugins.color" + +typedef enum { + CC_DISPLAY_CONFIG_JOIN, + CC_DISPLAY_CONFIG_CLONE, + + CC_DISPLAY_CONFIG_INVALID_NONE, +} CcDisplayConfigType; + +#define CC_DISPLAY_CONFIG_LAST_VALID CC_DISPLAY_CONFIG_CLONE + +struct _CcDisplayPanel +{ + CcPanel parent_instance; + + CcDisplayConfigManager *manager; + CcDisplayConfig *current_config; + CcDisplayMonitor *current_output; + + gint rebuilding_counter; + + CcDisplayArrangement *arrangement; + CcDisplaySettings *settings; + + guint focus_id; + + CcNightLightPage *night_light_page; + GtkLabel *night_light_state_label; + + UpClient *up_client; + gboolean lid_is_closed; + + GDBusProxy *shell_proxy; + + GtkWidget *apply_titlebar; + GtkWidget *apply_button; + GtkWidget *cancel_button; + AdwWindowTitle *apply_titlebar_title_widget; + + GListStore *primary_display_list; + GList *monitor_rows; + + GtkWidget *display_settings_disabled_group; + + GtkWidget *arrangement_row; + AdwBin *arrangement_bin; + GtkToggleButton *config_type_join; + GtkToggleButton *config_type_mirror; + GtkWidget *display_multiple_displays; + AdwBin *display_settings_bin; + GtkWidget *display_settings_group; + AdwWindowTitle *display_settings_title_widget; + AdwLeaflet *leaflet; + AdwComboRow *primary_display_row; + AdwPreferencesGroup *single_display_settings_group; + + GtkShortcutController *toplevel_shortcuts; + GtkShortcut *escape_shortcut; + + GSettings *display_settings; +}; + +CC_PANEL_REGISTER (CcDisplayPanel, cc_display_panel) + +static void +update_apply_button (CcDisplayPanel *panel); +static void +apply_current_configuration (CcDisplayPanel *self); +static void +reset_current_config (CcDisplayPanel *panel); +static void +rebuild_ui (CcDisplayPanel *panel); +static void +set_current_output (CcDisplayPanel *panel, + CcDisplayMonitor *output, + gboolean force); +static void +on_screen_changed (CcDisplayPanel *panel); + + +static CcDisplayConfigType +config_get_current_type (CcDisplayPanel *panel) +{ + guint n_active_outputs; + GList *outputs, *l; + + outputs = cc_display_config_get_ui_sorted_monitors (panel->current_config); + n_active_outputs = 0; + for (l = outputs; l; l = l->next) + { + CcDisplayMonitor *output = l->data; + + if (cc_display_monitor_is_useful (output)) + n_active_outputs += 1; + } + + if (n_active_outputs == 0) + return CC_DISPLAY_CONFIG_INVALID_NONE; + + if (cc_display_config_is_cloning (panel->current_config)) + return CC_DISPLAY_CONFIG_CLONE; + + return CC_DISPLAY_CONFIG_JOIN; +} + +static CcDisplayConfigType +cc_panel_get_selected_type (CcDisplayPanel *panel) +{ + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (panel->config_type_join))) + return CC_DISPLAY_CONFIG_JOIN; + else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (panel->config_type_mirror))) + return CC_DISPLAY_CONFIG_CLONE; + else + g_assert_not_reached (); +} + +static CcDisplayMode * +find_preferred_mode (GList *modes) +{ + GList *l; + + for (l = modes; l; l = l->next) + { + CcDisplayMode *mode = l->data; + + if (cc_display_mode_is_preferred (mode)) + return mode; + } + + return NULL; +} + +static void +config_ensure_of_type (CcDisplayPanel *panel, CcDisplayConfigType type) +{ + CcDisplayConfigType current_type = config_get_current_type (panel); + GList *outputs, *l; + CcDisplayMonitor *current_primary = NULL; + gdouble old_primary_scale = -1; + + /* Do not do anything if the current detected configuration type is + * identitcal to what we expect. */ + if (type == current_type) + return; + + reset_current_config (panel); + + outputs = cc_display_config_get_ui_sorted_monitors (panel->current_config); + for (l = outputs; l; l = l->next) + { + CcDisplayMonitor *output = l->data; + + if (cc_display_monitor_is_primary (output)) + { + current_primary = output; + old_primary_scale = cc_display_monitor_get_scale (current_primary); + break; + } + } + + switch (type) + { + case CC_DISPLAY_CONFIG_JOIN: + g_debug ("Creating new join config"); + /* Enable all usable outputs + * Note that this might result in invalid configurations as we + * we might not be able to drive all attached monitors. */ + cc_display_config_set_cloning (panel->current_config, FALSE); + for (l = outputs; l; l = l->next) + { + CcDisplayMonitor *output = l->data; + gdouble scale; + CcDisplayMode *mode; + + mode = cc_display_monitor_get_preferred_mode (output); + /* If the monitor was active, try using the current scale, otherwise + * try picking the preferred scale. */ + if (cc_display_monitor_is_active (output)) + scale = cc_display_monitor_get_scale (output); + else + scale = cc_display_mode_get_preferred_scale (mode); + + /* If we cannot use the current/preferred scale, try to fall back to + * the previously scale of the primary monitor instead. + * This is not guaranteed to result in a valid configuration! */ + if (!cc_display_config_is_scaled_mode_valid (panel->current_config, + mode, + scale)) + { + if (current_primary && + cc_display_config_is_scaled_mode_valid (panel->current_config, + mode, + old_primary_scale)) + scale = old_primary_scale; + } + + cc_display_monitor_set_active (output, cc_display_monitor_is_usable (output)); + cc_display_monitor_set_mode (output, mode); + cc_display_monitor_set_scale (output, scale); + } + break; + + case CC_DISPLAY_CONFIG_CLONE: + { + g_debug ("Creating new clone config"); + gdouble scale; + g_autolist(CcDisplayMode) modes = NULL; + CcDisplayMode *clone_mode; + + /* Turn on cloning and select the best mode we can find by default */ + cc_display_config_set_cloning (panel->current_config, TRUE); + + modes = cc_display_config_generate_cloning_modes (panel->current_config); + clone_mode = find_preferred_mode (modes); + g_return_if_fail (clone_mode); + + /* Take the preferred scale by default, */ + scale = cc_display_mode_get_preferred_scale (clone_mode); + /* but prefer the old primary scale if that is valid. */ + if (current_primary && + cc_display_config_is_scaled_mode_valid (panel->current_config, + clone_mode, + old_primary_scale)) + scale = old_primary_scale; + + for (l = outputs; l; l = l->next) + { + CcDisplayMonitor *output = l->data; + + cc_display_monitor_set_compatible_clone_mode (output, clone_mode); + cc_display_monitor_set_scale (output, scale); + } + } + break; + + default: + g_assert_not_reached (); + } + + if (!panel->rebuilding_counter) + rebuild_ui (panel); +} + +static void +cc_panel_set_selected_type (CcDisplayPanel *panel, CcDisplayConfigType type) +{ + switch (type) + { + case CC_DISPLAY_CONFIG_JOIN: + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (panel->config_type_join), TRUE); + break; + case CC_DISPLAY_CONFIG_CLONE: + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (panel->config_type_mirror), TRUE); + break; + default: + g_assert_not_reached (); + } + + config_ensure_of_type (panel, type); +} + +static void +monitor_labeler_hide (CcDisplayPanel *self) +{ + if (!self->shell_proxy) + return; + + g_dbus_proxy_call (self->shell_proxy, + "HideMonitorLabels", + NULL, G_DBUS_CALL_FLAGS_NONE, + -1, NULL, NULL, NULL); +} + +static void +monitor_labeler_show (CcDisplayPanel *self) +{ + GList *outputs, *l; + GVariantBuilder builder; + gint number = 0; + + if (!self->shell_proxy || !self->current_config) + return; + + outputs = cc_display_config_get_ui_sorted_monitors (self->current_config); + if (!outputs) + return; + + if (cc_display_config_is_cloning (self->current_config)) + return monitor_labeler_hide (self); + + g_variant_builder_init (&builder, G_VARIANT_TYPE_TUPLE); + g_variant_builder_open (&builder, G_VARIANT_TYPE_ARRAY); + + for (l = outputs; l != NULL; l = l->next) + { + CcDisplayMonitor *output = l->data; + + number = cc_display_monitor_get_ui_number (output); + if (number == 0) + continue; + + g_variant_builder_add (&builder, "{sv}", + cc_display_monitor_get_connector_name (output), + g_variant_new_int32 (number)); + } + + g_variant_builder_close (&builder); + + if (number < 2) + { + g_variant_builder_clear (&builder); + return monitor_labeler_hide (self); + } + + g_dbus_proxy_call (self->shell_proxy, + "ShowMonitorLabels", + g_variant_builder_end (&builder), + G_DBUS_CALL_FLAGS_NONE, + -1, NULL, NULL, NULL); +} + +static void +ensure_monitor_labels (CcDisplayPanel *self) +{ + g_autoptr(GList) windows = NULL; + GList *w; + + windows = gtk_window_list_toplevels (); + + for (w = windows; w; w = w->next) + { + if (gtk_window_is_active (GTK_WINDOW (w->data))) + { + monitor_labeler_show (self); + break; + } + } + + if (!w) + monitor_labeler_hide (self); +} + +static void +dialog_toplevel_is_active_changed (CcDisplayPanel *self) +{ + ensure_monitor_labels (self); +} + +static void +reset_titlebar (CcDisplayPanel *self) +{ + gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (self->toplevel_shortcuts), + GTK_PHASE_NONE); + gtk_widget_hide (self->apply_titlebar); +} + +static void +active_panel_changed (CcPanel *self) +{ + CcShell *shell; + g_autoptr(CcPanel) panel = NULL; + + shell = cc_panel_get_shell (CC_PANEL (self)); + g_object_get (shell, "active-panel", &panel, NULL); + if (panel != self) + reset_titlebar (CC_DISPLAY_PANEL (self)); +} + +static void +cc_display_panel_dispose (GObject *object) +{ + CcDisplayPanel *self = CC_DISPLAY_PANEL (object); + GtkWidget *toplevel = cc_shell_get_toplevel (cc_panel_get_shell (CC_PANEL (self))); + + reset_titlebar (CC_DISPLAY_PANEL (object)); + + if (self->focus_id) + { + self->focus_id = 0; + monitor_labeler_hide (CC_DISPLAY_PANEL (object)); + } + + g_clear_pointer (&self->monitor_rows, g_list_free); + g_clear_object (&self->manager); + g_clear_object (&self->current_config); + g_clear_object (&self->up_client); + + g_clear_object (&self->shell_proxy); + + g_signal_handlers_disconnect_by_data (toplevel, self); + + G_OBJECT_CLASS (cc_display_panel_parent_class)->dispose (object); +} + +static void +on_arrangement_selected_ouptut_changed_cb (CcDisplayPanel *panel) +{ + set_current_output (panel, cc_display_arrangement_get_selected_output (panel->arrangement), FALSE); +} + +static void +on_monitor_settings_updated_cb (CcDisplayPanel *panel, + CcDisplayMonitor *monitor, + CcDisplaySettings *settings) +{ + if (monitor) + cc_display_config_snap_output (panel->current_config, monitor); + update_apply_button (panel); +} + +static void +on_back_button_clicked_cb (GtkButton *button, + CcDisplayPanel *self) +{ + adw_leaflet_set_visible_child_name (self->leaflet, "displays"); +} + +static void +on_config_type_toggled_cb (CcDisplayPanel *panel, + GtkCheckButton *btn) +{ + CcDisplayConfigType type; + + if (panel->rebuilding_counter > 0) + return; + + if (!panel->current_config) + return; + + if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (btn))) + return; + + type = cc_panel_get_selected_type (panel); + config_ensure_of_type (panel, type); +} + +static void +on_night_light_enabled_changed_cb (GSettings *settings, + const gchar *key, + CcDisplayPanel *self) +{ + if (g_settings_get_boolean (self->display_settings, "night-light-enabled")) + gtk_label_set_label (self->night_light_state_label, _("On")); + else + gtk_label_set_label (self->night_light_state_label, _("Off")); +} + +static void +on_night_light_row_activated_cb (GtkListBoxRow *row, + CcDisplayPanel *self) +{ + adw_leaflet_set_visible_child_name (self->leaflet, "night-light"); +} + +static void +on_primary_display_selected_item_changed_cb (CcDisplayPanel *panel) +{ + gint idx = adw_combo_row_get_selected (panel->primary_display_row); + g_autoptr(CcDisplayMonitor) output = NULL; + + if (idx < 0 || panel->rebuilding_counter > 0) + return; + + output = g_list_model_get_item (G_LIST_MODEL (panel->primary_display_list), idx); + + if (cc_display_monitor_is_primary (output)) + return; + + cc_display_monitor_set_primary (output, TRUE); + update_apply_button (panel); +} + +static void +on_toplevel_folded (CcDisplayPanel *panel, GParamSpec *pspec, GtkWidget *toplevel) +{ + gboolean folded; + + g_object_get (toplevel, "folded", &folded, NULL); + cc_display_settings_refresh_layout (panel->settings, folded); +} + +static gboolean +on_toplevel_escape_pressed_cb (GtkWidget *widget, + GVariant *args, + CcDisplayPanel *self) +{ + if (gtk_widget_get_visible (self->apply_titlebar)) + { + gtk_widget_activate (self->cancel_button); + return GDK_EVENT_STOP; + } + + return GDK_EVENT_PROPAGATE; +} + +static void +cc_display_panel_constructed (GObject *object) +{ + CcShell *shell = cc_panel_get_shell (CC_PANEL (object)); + GtkWidget *toplevel = cc_shell_get_toplevel (shell); + + g_signal_connect_object (cc_panel_get_shell (CC_PANEL (object)), "notify::active-panel", + G_CALLBACK (active_panel_changed), object, G_CONNECT_SWAPPED); + + g_signal_connect_swapped (toplevel, "notify::folded", G_CALLBACK (on_toplevel_folded), object); + on_toplevel_folded (CC_DISPLAY_PANEL (object), NULL, toplevel); + + G_OBJECT_CLASS (cc_display_panel_parent_class)->constructed (object); +} + +static const char * +cc_display_panel_get_help_uri (CcPanel *panel) +{ + return "help:gnome-help/prefs-display"; +} + +static void +cc_display_panel_class_init (CcDisplayPanelClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + CcPanelClass *panel_class = CC_PANEL_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + g_type_ensure (CC_TYPE_NIGHT_LIGHT_PAGE); + + panel_class->get_help_uri = cc_display_panel_get_help_uri; + + object_class->constructed = cc_display_panel_constructed; + object_class->dispose = cc_display_panel_dispose; + + gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/display/cc-display-panel.ui"); + + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, apply_button); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, apply_titlebar); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, apply_titlebar_title_widget); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, display_settings_disabled_group); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, arrangement_bin); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, arrangement_row); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, cancel_button); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, display_multiple_displays); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, config_type_join); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, config_type_mirror); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, display_settings_bin); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, display_settings_group); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, display_settings_title_widget); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, escape_shortcut); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, leaflet); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, night_light_page); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, night_light_state_label); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, primary_display_row); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, single_display_settings_group); + gtk_widget_class_bind_template_child (widget_class, CcDisplayPanel, toplevel_shortcuts); + + gtk_widget_class_bind_template_callback (widget_class, apply_current_configuration); + gtk_widget_class_bind_template_callback (widget_class, on_back_button_clicked_cb); + gtk_widget_class_bind_template_callback (widget_class, on_config_type_toggled_cb); + gtk_widget_class_bind_template_callback (widget_class, on_night_light_row_activated_cb); + gtk_widget_class_bind_template_callback (widget_class, on_primary_display_selected_item_changed_cb); + gtk_widget_class_bind_template_callback (widget_class, on_screen_changed); + gtk_widget_class_bind_template_callback (widget_class, on_toplevel_escape_pressed_cb); +} + +static void +set_current_output (CcDisplayPanel *panel, + CcDisplayMonitor *output, + gboolean force) +{ + gboolean changed; + + /* Note, this function is also called if the internal UI needs updating after a rebuild. */ + changed = (output != panel->current_output); + + if (!changed && !force) + return; + + panel->rebuilding_counter++; + + panel->current_output = output; + + if (changed) + { + cc_display_settings_set_selected_output (panel->settings, panel->current_output); + cc_display_arrangement_set_selected_output (panel->arrangement, panel->current_output); + + adw_window_title_set_title (panel->display_settings_title_widget, + output ? cc_display_monitor_get_ui_name (output) : ""); + } + + panel->rebuilding_counter--; +} + +static void +on_monitor_row_activated_cb (GtkListBoxRow *row, + CcDisplayPanel *self) +{ + CcDisplayMonitor *monitor; + + monitor = g_object_get_data (G_OBJECT (row), "monitor"); + set_current_output (self, monitor, FALSE); + + adw_leaflet_set_visible_child_name (self->leaflet, "display-settings"); +} + +static void +add_display_row (CcDisplayPanel *self, + CcDisplayMonitor *monitor) +{ + g_autofree gchar *number_string = NULL; + GtkWidget *number_label; + GtkWidget *icon; + GtkWidget *row; + + row = adw_action_row_new (); + g_object_set_data (G_OBJECT (row), "monitor", monitor); + adw_preferences_row_set_title (ADW_PREFERENCES_ROW (row), + cc_display_monitor_get_ui_name (monitor)); + + number_string = g_strdup_printf ("%d", cc_display_monitor_get_ui_number (monitor)); + number_label = gtk_label_new (number_string); + gtk_widget_set_valign (number_label, GTK_ALIGN_CENTER); + gtk_widget_set_halign (number_label, GTK_ALIGN_CENTER); + gtk_widget_add_css_class (number_label, "monitor-label"); + adw_action_row_add_prefix (ADW_ACTION_ROW (row), number_label); + + icon = gtk_image_new_from_icon_name ("go-next-symbolic"); + adw_action_row_add_suffix (ADW_ACTION_ROW (row), icon); + adw_action_row_set_activatable_widget (ADW_ACTION_ROW (row), icon); + + adw_preferences_group_add (ADW_PREFERENCES_GROUP (self->display_settings_group), row); + + g_signal_connect (row, "activated", G_CALLBACK (on_monitor_row_activated_cb), self); + + self->monitor_rows = g_list_prepend (self->monitor_rows, row); +} + +static void +move_display_settings_to_main_page (CcDisplayPanel *self) +{ + GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (self->settings)); + + if (parent != GTK_WIDGET (self->display_settings_bin)) + return; + + g_object_ref (self->settings); + adw_bin_set_child (self->display_settings_bin, NULL); + adw_preferences_group_add (self->single_display_settings_group, + GTK_WIDGET (self->settings)); + g_object_unref (self->settings); + + gtk_widget_show (GTK_WIDGET (self->single_display_settings_group)); +} + +static void +move_display_settings_to_separate_page (CcDisplayPanel *self) +{ + GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (self->settings)); + + if (parent == GTK_WIDGET (self->display_settings_bin)) + return; + + g_object_ref (self->settings); + adw_preferences_group_remove (self->single_display_settings_group, + GTK_WIDGET (self->settings)); + adw_bin_set_child (self->display_settings_bin, + GTK_WIDGET (self->settings)); + g_object_unref (self->settings); + + gtk_widget_hide (GTK_WIDGET (self->single_display_settings_group)); +} + +static void +rebuild_ui (CcDisplayPanel *panel) +{ + guint n_outputs, n_active_outputs, n_usable_outputs; + GList *outputs, *l; + CcDisplayConfigType type; + + if (!cc_display_config_manager_get_apply_allowed (panel->manager)) + { + gtk_widget_set_visible (panel->display_settings_disabled_group, TRUE); + gtk_widget_set_visible (panel->display_settings_group, FALSE); + gtk_widget_set_visible (panel->arrangement_row, FALSE); + return; + } + + panel->rebuilding_counter++; + + g_list_store_remove_all (panel->primary_display_list); + + /* Remove all monitor rows */ + while (panel->monitor_rows) + { + adw_preferences_group_remove (ADW_PREFERENCES_GROUP (panel->display_settings_group), + panel->monitor_rows->data); + panel->monitor_rows = g_list_remove_link (panel->monitor_rows, panel->monitor_rows); + } + + if (!panel->current_config) + { + panel->rebuilding_counter--; + return; + } + + gtk_widget_set_visible (panel->display_settings_disabled_group, FALSE); + + n_active_outputs = 0; + n_usable_outputs = 0; + outputs = cc_display_config_get_ui_sorted_monitors (panel->current_config); + for (l = outputs; l; l = l->next) + { + CcDisplayMonitor *output = l->data; + + if (!cc_display_monitor_is_usable (output)) + continue; + + n_usable_outputs += 1; + + if (cc_display_monitor_is_active (output)) + { + n_active_outputs += 1; + + g_list_store_append (panel->primary_display_list, output); + if (cc_display_monitor_is_primary (output)) + adw_combo_row_set_selected (panel->primary_display_row, + g_list_model_get_n_items (G_LIST_MODEL (panel->primary_display_list)) - 1); + + /* Ensure that an output is selected; note that this doesn't ensure + * the selected output is any useful (i.e. when switching types). + */ + if (!panel->current_output) + set_current_output (panel, output, FALSE); + } + + add_display_row (panel, l->data); + } + + /* Sync the rebuild lists/buttons */ + set_current_output (panel, panel->current_output, TRUE); + + n_outputs = g_list_length (outputs); + type = config_get_current_type (panel); + + if (n_outputs == 2 && n_usable_outputs == 2) + { + /* We only show the top chooser with two monitors that are + * both usable (i.e. two monitors incl. internal and lid not closed). + * In this case, the arrangement widget is shown if we are in JOIN mode. + */ + if (type > CC_DISPLAY_CONFIG_LAST_VALID) + type = CC_DISPLAY_CONFIG_JOIN; + + gtk_widget_set_visible (panel->display_settings_group, type == CC_DISPLAY_CONFIG_JOIN); + gtk_widget_set_visible (panel->display_multiple_displays, TRUE); + gtk_widget_set_visible (panel->arrangement_row, type == CC_DISPLAY_CONFIG_JOIN); + + if (type == CC_DISPLAY_CONFIG_CLONE) + move_display_settings_to_main_page (panel); + else + move_display_settings_to_separate_page (panel); + } + else if (n_usable_outputs > 1) + { + /* We have more than one usable monitor. In this case there is no chooser, + * and we always show the arrangement widget. + */ + gtk_widget_set_visible (panel->display_settings_group, TRUE); + gtk_widget_set_visible (panel->display_multiple_displays, FALSE); + gtk_widget_set_visible (panel->arrangement_row, TRUE); + + /* Mirror is also invalid as it cannot be configured using this UI. */ + if (type == CC_DISPLAY_CONFIG_CLONE || type > CC_DISPLAY_CONFIG_LAST_VALID) + type = CC_DISPLAY_CONFIG_JOIN; + + move_display_settings_to_separate_page (panel); + } + else + { + type = CC_DISPLAY_CONFIG_JOIN; + + gtk_widget_set_visible (panel->display_settings_group, FALSE); + gtk_widget_set_visible (panel->display_multiple_displays, FALSE); + gtk_widget_set_visible (panel->arrangement_row, FALSE); + + move_display_settings_to_main_page (panel); + } + + cc_display_settings_set_multimonitor (panel->settings, + n_outputs > 1 && + type != CC_DISPLAY_CONFIG_CLONE); + + cc_panel_set_selected_type (panel, type); + + panel->rebuilding_counter--; + update_apply_button (panel); +} + +static void +update_panel_orientation_managed (CcDisplayPanel *panel, + gboolean managed) +{ + cc_display_settings_set_has_accelerometer (panel->settings, managed); +} + +static void +reset_current_config (CcDisplayPanel *panel) +{ + CcDisplayConfig *current; + CcDisplayConfig *old; + GList *outputs, *l; + + g_debug ("Resetting current config!"); + + /* We need to hold on to the config until all display references are dropped. */ + old = panel->current_config; + panel->current_output = NULL; + + current = cc_display_config_manager_get_current (panel->manager); + + if (!current) + return; + + cc_display_config_set_minimum_size (current, MINIMUM_WIDTH, MINIMUM_HEIGHT); + panel->current_config = current; + + g_signal_connect_object (current, "panel-orientation-managed", + G_CALLBACK (update_panel_orientation_managed), panel, + G_CONNECT_SWAPPED); + update_panel_orientation_managed (panel, + cc_display_config_get_panel_orientation_managed (current)); + + g_list_store_remove_all (panel->primary_display_list); + + if (panel->current_config) + { + outputs = cc_display_config_get_ui_sorted_monitors (panel->current_config); + for (l = outputs; l; l = l->next) + { + CcDisplayMonitor *output = l->data; + + /* Mark any builtin monitor as unusable if the lid is closed. */ + if (cc_display_monitor_is_builtin (output) && panel->lid_is_closed) + cc_display_monitor_set_usable (output, FALSE); + } + } + + cc_display_arrangement_set_config (panel->arrangement, panel->current_config); + cc_display_settings_set_config (panel->settings, panel->current_config); + set_current_output (panel, NULL, FALSE); + + g_clear_object (&old); + + update_apply_button (panel); +} + +static void +on_screen_changed (CcDisplayPanel *panel) +{ + if (!panel->manager) + return; + + reset_titlebar (panel); + + reset_current_config (panel); + rebuild_ui (panel); + + if (!panel->current_config) + return; + + ensure_monitor_labels (panel); +} + +static void +show_apply_titlebar (CcDisplayPanel *panel, gboolean is_applicable) +{ + gtk_widget_show (panel->apply_titlebar); + gtk_widget_set_sensitive (panel->apply_button, is_applicable); + + if (is_applicable) + { + adw_window_title_set_title (panel->apply_titlebar_title_widget, + _("Apply Changes?")); + } + else + { + adw_window_title_set_title (panel->apply_titlebar_title_widget, + _("Changes Cannot be Applied")); + adw_window_title_set_subtitle (panel->apply_titlebar_title_widget, + _("This could be due to hardware limitations.")); + } + + gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (panel->toplevel_shortcuts), + GTK_PHASE_BUBBLE); +} + +static void +update_apply_button (CcDisplayPanel *panel) +{ + gboolean config_equal; + g_autoptr(CcDisplayConfig) applied_config = NULL; + + if (!panel->current_config) + { + reset_titlebar (panel); + return; + } + + applied_config = cc_display_config_manager_get_current (panel->manager); + + config_equal = cc_display_config_equal (panel->current_config, + applied_config); + + if (config_equal) + reset_titlebar (panel); + else + show_apply_titlebar (panel, cc_display_config_is_applicable (panel->current_config)); +} + +static void +apply_current_configuration (CcDisplayPanel *self) +{ + g_autoptr(GError) error = NULL; + + cc_display_config_apply (self->current_config, &error); + + /* re-read the configuration */ + on_screen_changed (self); + + if (error) + g_warning ("Error applying configuration: %s", error->message); + + adw_leaflet_set_visible_child_name (self->leaflet, "displays"); +} + +static void +mapped_cb (CcDisplayPanel *panel) +{ + CcShell *shell; + GtkWidget *toplevel; + + shell = cc_panel_get_shell (CC_PANEL (panel)); + toplevel = cc_shell_get_toplevel (shell); + if (toplevel && !panel->focus_id) + panel->focus_id = g_signal_connect_object (toplevel, "notify::is-active", + G_CALLBACK (dialog_toplevel_is_active_changed), panel, G_CONNECT_SWAPPED); +} + +static void +cc_display_panel_up_client_changed (CcDisplayPanel *self) +{ + gboolean lid_is_closed; + + lid_is_closed = up_client_get_lid_is_closed (self->up_client); + + if (lid_is_closed != self->lid_is_closed) + { + self->lid_is_closed = lid_is_closed; + + on_screen_changed (self); + } +} + +static void +shell_proxy_ready (GObject *source, + GAsyncResult *res, + CcDisplayPanel *self) +{ + GDBusProxy *proxy; + g_autoptr(GError) error = NULL; + + proxy = cc_object_storage_create_dbus_proxy_finish (res, &error); + if (!proxy) + { + if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + g_warning ("Failed to contact gnome-shell: %s", error->message); + return; + } + + self->shell_proxy = proxy; + + ensure_monitor_labels (self); +} + +static void +session_bus_ready (GObject *source, + GAsyncResult *res, + CcDisplayPanel *self) +{ + GDBusConnection *bus; + g_autoptr(GError) error = NULL; + + bus = g_bus_get_finish (res, &error); + if (!bus) + { + if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + { + g_warning ("Failed to get session bus: %s", error->message); + } + return; + } + + self->manager = cc_display_config_manager_dbus_new (); + g_signal_connect_object (self->manager, "changed", + G_CALLBACK (on_screen_changed), + self, + G_CONNECT_SWAPPED); +} + +static void +cc_display_panel_init (CcDisplayPanel *self) +{ + g_autoptr(GtkCssProvider) provider = NULL; + GtkExpression *expression; + + g_resources_register (cc_display_get_resource ()); + + gtk_widget_init_template (GTK_WIDGET (self)); + + self->arrangement = cc_display_arrangement_new (NULL); + gtk_widget_set_size_request (GTK_WIDGET (self->arrangement), 375, 175); + adw_bin_set_child (self->arrangement_bin, GTK_WIDGET (self->arrangement)); + + g_signal_connect_object (self->arrangement, "updated", + G_CALLBACK (update_apply_button), self, + G_CONNECT_SWAPPED); + g_signal_connect_object (self->arrangement, "notify::selected-output", + G_CALLBACK (on_arrangement_selected_ouptut_changed_cb), self, + G_CONNECT_SWAPPED); + + self->settings = cc_display_settings_new (); + adw_bin_set_child (self->display_settings_bin, GTK_WIDGET (self->settings)); + g_signal_connect_object (self->settings, "updated", + G_CALLBACK (on_monitor_settings_updated_cb), self, + G_CONNECT_SWAPPED); + + self->primary_display_list = g_list_store_new (CC_TYPE_DISPLAY_MONITOR); + + expression = gtk_cclosure_expression_new (G_TYPE_STRING, + NULL, 0, NULL, + G_CALLBACK (cc_display_monitor_dup_ui_number_name), + self, NULL); + adw_combo_row_set_expression (self->primary_display_row, expression); + adw_combo_row_set_model (self->primary_display_row, + G_LIST_MODEL (self->primary_display_list)); + + self->up_client = up_client_new (); + if (up_client_get_lid_is_present (self->up_client)) + { + g_signal_connect_object (self->up_client, "notify::lid-is-closed", + G_CALLBACK (cc_display_panel_up_client_changed), self, G_CONNECT_SWAPPED); + cc_display_panel_up_client_changed (self); + } + else + g_clear_object (&self->up_client); + + g_signal_connect (self, "map", G_CALLBACK (mapped_cb), NULL); + + cc_object_storage_create_dbus_proxy (G_BUS_TYPE_SESSION, + G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | + G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS | + G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START, + "org.gnome.Shell", + "/org/gnome/Shell", + "org.gnome.Shell", + cc_panel_get_cancellable (CC_PANEL (self)), + (GAsyncReadyCallback) shell_proxy_ready, + self); + + g_bus_get (G_BUS_TYPE_SESSION, + cc_panel_get_cancellable (CC_PANEL (self)), + (GAsyncReadyCallback) session_bus_ready, + self); + + provider = gtk_css_provider_new (); + gtk_css_provider_load_from_resource (provider, "/org/gnome/control-center/display/display-arrangement.css"); + gtk_style_context_add_provider_for_display (gdk_display_get_default (), + GTK_STYLE_PROVIDER (provider), + GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); + + gtk_shortcut_set_action (self->escape_shortcut, + gtk_callback_action_new ((GtkShortcutFunc) on_toplevel_escape_pressed_cb, + self, + NULL)); + + self->display_settings = g_settings_new (DISPLAY_SCHEMA); + g_signal_connect_object (self->display_settings, + "changed::night-light-enabled", + G_CALLBACK (on_night_light_enabled_changed_cb), + self, + 0); + on_night_light_enabled_changed_cb (NULL, NULL, self); +} diff --git a/panels/display/cc-display-panel.h b/panels/display/cc-display-panel.h new file mode 100644 index 0000000..a7ade28 --- /dev/null +++ b/panels/display/cc-display-panel.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2010 Intel, 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/>. + * + * Author: Thomas Wood <thomas.wood@intel.com> + * + */ + +#pragma once + +#include <shell/cc-panel.h> + +G_BEGIN_DECLS + +#define CC_TYPE_DISPLAY_PANEL (cc_display_panel_get_type ()) +G_DECLARE_FINAL_TYPE (CcDisplayPanel, cc_display_panel, CC, DISPLAY_PANEL, CcPanel) + +G_END_DECLS diff --git a/panels/display/cc-display-panel.ui b/panels/display/cc-display-panel.ui new file mode 100644 index 0000000..9337b18 --- /dev/null +++ b/panels/display/cc-display-panel.ui @@ -0,0 +1,316 @@ +<?xml version="1.0" encoding="UTF-8"?> +<interface> + <template class="CcDisplayPanel" parent="CcPanel"> + + <child> + <object class="GtkShortcutController" id="toplevel_shortcuts"> + <property name="scope">global</property> + <property name="name">Display Panel Globals Shortcuts</property> + <child> + <object class="GtkShortcut" id="escape_shortcut"> + <property name="trigger">Escape</property> + <property name="action">callback(on_toplevel_escape_pressed_cb)</property> + </object> + </child> + </object> + </child> + + <child> + <object class="GtkOverlay"> + + <child type="overlay"> + <object class="AdwHeaderBar" id="apply_titlebar"> + <property name="visible">False</property> + <property name="valign">start</property> + <property name="show-start-title-buttons">False</property> + <property name="show-end-title-buttons">False</property> + + <child type="start"> + <object class="GtkButton" id="cancel_button"> + <property name="use-underline">True</property> + <property name="label" translatable="yes">_Cancel</property> + <signal name="clicked" handler="on_screen_changed" object="CcDisplayPanel" swapped="yes" /> + </object> + </child> + + <property name="title-widget"> + <object class="AdwWindowTitle" id="apply_titlebar_title_widget" /> + </property> + + <child type="end"> + <object class="GtkButton" id="apply_button"> + <property name="use-underline">True</property> + <property name="label" translatable="yes">_Apply</property> + <signal name="clicked" handler="apply_current_configuration" object="CcDisplayPanel" swapped="yes" /> + <style> + <class name="suggested-action" /> + </style> + </object> + </child> + + </object> + </child> + + <child> + <object class="AdwLeaflet" id="leaflet"> + <property name="can-unfold">False</property> + + <!-- Displays page --> + <child> + <object class="AdwLeafletPage"> + <property name="name">displays</property> + <property name="child"> + <object class="GtkBox"> + <property name="orientation">vertical</property> + + <!-- Displays page titlebar --> + <child> + <object class="AdwHeaderBar" id="displays_titlebar"> + <property name="show-end-title-buttons">True</property> + <property name="show-start-title-buttons" bind-source="CcDisplayPanel" bind-property="folded" bind-flags="default|sync-create" /> + <child type="start"> + <object class="GtkButton"> + <property name="visible" bind-source="CcDisplayPanel" bind-property="folded" bind-flags="default|sync-create" /> + <property name="icon-name">go-previous-symbolic</property> + <property name="action-name">window.navigate</property> + <property name="action-target">0</property> <!-- 0: ADW_NAVIGATION_DIRECTION_BACK --> + <accessibility> + <property name="label" translatable="yes">Back</property> + </accessibility> + </object> + </child> + <property name="title-widget"> + <object class="AdwWindowTitle"> + <property name="title" bind-source="CcDisplayPanel" bind-property="title" bind-flags="default|sync-create" /> + </object> + </property> + </object> + </child> + + <child> + <object class="AdwPreferencesPage"> + + <child> + <object class="AdwPreferencesGroup" id="display_settings_disabled_group"> + <property name="visible">False</property> + <child> + <object class="AdwStatusPage"> + <property name="vexpand">True</property> + <property name="icon-name">computer-symbolic</property> + <property name="title" translatable="yes">Display Settings Disabled</property> + </object> + </child> + </object> + </child> + + <child> + <object class="AdwPreferencesGroup" id="display_multiple_displays"> + <!-- Config Type --> + <child> + <object class="AdwActionRow" id="config_type_switcher_row"> + <property name="title" translatable="yes">Multiple Displays</property> + <child type="suffix"> + <object class="GtkBox"> + <property name="valign">center</property> + <style> + <class name="linked" /> + </style> + <child> + <object class="GtkToggleButton" id="config_type_join"> + <property name="label" translatable="yes" comments="'Join' as in 'Join displays'">Join</property> + <property name="active">True</property> + <signal name="toggled" handler="on_config_type_toggled_cb" swapped="yes"/> + </object> + </child> + <child> + <object class="GtkToggleButton" id="config_type_mirror"> + <property name="label" translatable="yes">Mirror</property> + <property name="group">config_type_join</property> + <signal name="toggled" handler="on_config_type_toggled_cb" swapped="yes"/> + </object> + </child> + </object> + </child> + </object> + </child> + </object> + </child> + + <child> + <object class="AdwPreferencesGroup" id="display_settings_group"> + <!-- Display Arrangement --> + <child> + <object class="AdwPreferencesRow" id="arrangement_row"> + <property name="activatable">False</property> + <child> + <object class="AdwBin" id="arrangement_bin"> + </object> + </child> + </object> + </child> + + <!-- Primary Display --> + <child> + <object class="AdwComboRow" id="primary_display_row"> + <property name="subtitle" translatable="yes">Contains top bar and Activities</property> + <property name="title" translatable="yes">Primary Display</property> + <signal name="notify::selected-item" handler="on_primary_display_selected_item_changed_cb" swapped="yes"/> + </object> + </child> + </object> + + </child> + + <!-- Single Display Settings --> + <child> + <object class="AdwPreferencesGroup" id="single_display_settings_group"> + <property name="visible">False</property> + </object> + </child> + + <!-- Night Light --> + <child> + <object class="AdwPreferencesGroup"> + <child> + <object class="AdwActionRow"> + <property name="activatable">True</property> + <property name="title" translatable="yes" comments="This is the redshift functionality where we suppress blue light when the sun has gone down">Night Light</property> + <signal name="activated" handler="on_night_light_row_activated_cb" object="CcDisplayPanel" swapped="no" /> + + <child type="suffix"> + <object class="GtkLabel" id="night_light_state_label"> + <property name="label">On</property> + </object> + </child> + + <child type="suffix"> + <object class="GtkImage"> + <property name="icon-name">go-next-symbolic</property> + </object> + </child> + + </object> + </child> + </object> + </child> + + </object> + </child> + </object> + </property> + </object> + </child> + + <!-- Night Light page --> + <child> + <object class="AdwLeafletPage"> + <property name="name">night-light</property> + <property name="child"> + <object class="GtkBox"> + <property name="orientation">vertical</property> + + <!-- Night Light titlebar --> + <child> + <object class="AdwHeaderBar" id="night_light_titlebar"> + <property name="show-start-title-buttons">True</property> + <property name="show-end-title-buttons">True</property> + <child type="start"> + <object class="GtkButton"> + <property name="icon-name">go-previous-symbolic</property> + <accessibility> + <property name="label" translatable="yes">Back</property> + </accessibility> + <signal name="clicked" handler="on_back_button_clicked_cb" object="CcDisplayPanel" swapped="no" /> + </object> + </child> + <property name="title-widget"> + <object class="AdwWindowTitle"> + <property name="title" translatable="yes">Night Light</property> + </object> + </property> + </object> + </child> + + <!-- Night Light --> + <child> + <object class="CcNightLightPage" id="night_light_page" /> + </child> + + </object> + </property> + </object> + </child> + + <!-- Display Settings page --> + <child> + <object class="AdwLeafletPage"> + <property name="name">display-settings</property> + <property name="child"><object class="GtkBox"> + <property name="orientation">vertical</property> + + <!-- Display Settings titlebar --> + <child> + <object class="AdwHeaderBar" id="display_settings_titlebar"> + <property name="show-start-title-buttons">True</property> + <property name="show-end-title-buttons">True</property> + <child type="start"> + <object class="GtkButton"> + <property name="icon-name">go-previous-symbolic</property> + <accessibility> + <property name="label" translatable="yes">Back</property> + </accessibility> + <signal name="clicked" handler="on_back_button_clicked_cb" object="CcDisplayPanel" swapped="no" /> + </object> + </child> + <property name="title-widget"> + <object class="AdwWindowTitle" id="display_settings_title_widget" /> + </property> + </object> + </child> + + <!-- Display Settings --> + <child> + <object class="AdwPreferencesPage"> + <child> + <object class="AdwPreferencesGroup"> + <child> + <object class="AdwBin" id="display_settings_bin" /> + </child> + </object> + </child> + </object> + </child> + + </object> + </property> + </object> + </child> + + </object> + </child> + + </object> + </child> + + </template> + + <object class="GtkSizeGroup"> + <property name="mode">horizontal</property> + <widgets> + <widget name="apply_button" /> + <widget name="cancel_button" /> + </widgets> + </object> + + <object class="GtkSizeGroup"> + <property name="mode">vertical</property> + <widgets> + <widget name="apply_titlebar" /> + <widget name="displays_titlebar" /> + <widget name="display_settings_titlebar" /> + <widget name="night_light_titlebar" /> + </widgets> + </object> + +</interface> + diff --git a/panels/display/cc-display-settings.c b/panels/display/cc-display-settings.c new file mode 100644 index 0000000..8fec65b --- /dev/null +++ b/panels/display/cc-display-settings.c @@ -0,0 +1,919 @@ +/* cc-display-settings.c + * + * Copyright (C) 2007, 2008, 2018, 2019 Red Hat, Inc. + * Copyright (C) 2013 Intel, Inc. + * + * Written by: Benjamin Berg <bberg@redhat.com> + * + * 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, 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 <float.h> +#include <glib/gi18n.h> +#include <float.h> +#include <math.h> +#include "cc-display-settings.h" +#include "cc-display-config.h" + +#define MAX_SCALE_BUTTONS 5 + +struct _CcDisplaySettings +{ + GtkBox object; + + gboolean updating; + gboolean num_scales; + gboolean folded; + guint idle_udpate_id; + + gboolean has_accelerometer; + CcDisplayConfig *config; + CcDisplayMonitor *selected_output; + + GListModel *orientation_list; + GListStore *refresh_rate_list; + GListStore *resolution_list; + GListModel *scale_list; + + GtkWidget *enabled_listbox; + AdwActionRow *enabled_row; + GtkSwitch *enabled_switch; + GtkWidget *orientation_row; + GtkWidget *refresh_rate_row; + GtkWidget *resolution_row; + GtkWidget *scale_bbox; + GtkWidget *scale_buttons_row; + GtkWidget *scale_combo_row; + GtkWidget *underscanning_row; + GtkWidget *underscanning_switch; +}; + +typedef struct _CcDisplaySettings CcDisplaySettings; + +enum { + PROP_0, + PROP_HAS_ACCELEROMETER, + PROP_CONFIG, + PROP_SELECTED_OUTPUT, + PROP_LAST +}; + +G_DEFINE_TYPE (CcDisplaySettings, cc_display_settings, GTK_TYPE_BOX) + +static GParamSpec *props[PROP_LAST]; + +static void on_scale_btn_active_changed_cb (GtkWidget *widget, + GParamSpec *pspec, + CcDisplaySettings *self); + + +static gboolean +should_show_rotation (CcDisplaySettings *self) +{ + gboolean supports_rotation; + + supports_rotation = cc_display_monitor_supports_rotation (self->selected_output, + CC_DISPLAY_ROTATION_90 | + CC_DISPLAY_ROTATION_180 | + CC_DISPLAY_ROTATION_270); + + /* Doesn't support rotation at all */ + if (!supports_rotation) + return FALSE; + + /* We can always rotate displays that aren't builtin */ + if (!cc_display_monitor_is_builtin (self->selected_output)) + return TRUE; + + /* Only offer rotation if there's no accelerometer */ + return !self->has_accelerometer; +} + +static const gchar * +string_for_rotation (CcDisplayRotation rotation) +{ + switch (rotation) + { + case CC_DISPLAY_ROTATION_NONE: + case CC_DISPLAY_ROTATION_180_FLIPPED: + return C_("Display rotation", "Landscape"); + case CC_DISPLAY_ROTATION_90: + case CC_DISPLAY_ROTATION_270_FLIPPED: + return C_("Display rotation", "Portrait Right"); + case CC_DISPLAY_ROTATION_270: + case CC_DISPLAY_ROTATION_90_FLIPPED: + return C_("Display rotation", "Portrait Left"); + case CC_DISPLAY_ROTATION_180: + case CC_DISPLAY_ROTATION_FLIPPED: + return C_("Display rotation", "Landscape (flipped)"); + } + return ""; +} + +static const gchar * +make_aspect_string (gint width, + gint height) +{ + int ratio; + const gchar *aspect = NULL; + + /* We use a number of Unicode characters below: + * ∶ is U+2236 RATIO + *   is U+2009 THIN SPACE, + * × is U+00D7 MULTIPLICATION SIGN + */ + if (width && height) { + if (width > height) + ratio = width * 10 / height; + else + ratio = height * 10 / width; + + switch (ratio) { + case 13: + aspect = "4∶3"; + break; + case 16: + aspect = "16∶10"; + break; + case 17: + aspect = "16∶9"; + break; + case 23: + aspect = "21∶9"; + break; + case 35: + aspect = "32∶9"; + break; + case 12: + aspect = "5∶4"; + break; + /* This catches 1.5625 as well (1600x1024) when maybe it shouldn't. */ + case 15: + aspect = "3∶2"; + break; + case 18: + aspect = "9∶5"; + break; + case 10: + aspect = "1∶1"; + break; + } + } + + return aspect; +} + +static gchar * +make_refresh_rate_string (CcDisplayMode *mode) +{ + return g_strdup_printf (_("%.2lf Hz"), cc_display_mode_get_freq_f (mode)); +} + +static gchar * +make_resolution_string (CcDisplayMode *mode) +{ + const char *interlaced; + const char *aspect; + int width, height; + + cc_display_mode_get_resolution (mode, &width, &height); + aspect = make_aspect_string (width, height); + interlaced = cc_display_mode_is_interlaced (mode) ? "i" : ""; + + if (aspect != NULL) + return g_strdup_printf ("%d × %d%s (%s)", width, height, interlaced, aspect); + else + return g_strdup_printf ("%d × %d%s", width, height, interlaced); +} + +static double +round_scale_for_ui (double scale) +{ + /* Keep in sync with mutter */ + return round (scale*4)/4; +} + +static gchar * +make_scale_string (gdouble scale) +{ + return g_strdup_printf ("%d %%", (int) (round_scale_for_ui (scale)*100)); +} + +static gint +sort_modes_by_area_desc (CcDisplayMode *a, CcDisplayMode *b) +{ + gint wa, ha, wb, hb; + gint res; + + cc_display_mode_get_resolution (a, &wa, &ha); + cc_display_mode_get_resolution (b, &wb, &hb); + + /* Sort first by width, then height. + * We used to sort by area, but that can be confusing. */ + res = wb - wa; + if (res) + return res; + return hb - ha; +} + +static gint +sort_modes_by_freq_desc (CcDisplayMode *a, CcDisplayMode *b) +{ + double delta = (cc_display_mode_get_freq_f (b) - cc_display_mode_get_freq_f (a))*1000.; + return delta; +} + +static gboolean +cc_display_settings_rebuild_ui (CcDisplaySettings *self) +{ + GtkWidget *child; + g_autolist(CcDisplayMode) clone_modes = NULL; + GList *modes; + GList *item; + gint width, height; + CcDisplayMode *current_mode; + GtkToggleButton *group = NULL; + g_autoptr(GArray) scales = NULL; + gint i; + + self->idle_udpate_id = 0; + + if (!self->config || !self->selected_output) + { + gtk_widget_set_visible (self->enabled_listbox, FALSE); + gtk_widget_set_visible (self->orientation_row, FALSE); + gtk_widget_set_visible (self->refresh_rate_row, FALSE); + gtk_widget_set_visible (self->resolution_row, FALSE); + gtk_widget_set_visible (self->scale_combo_row, FALSE); + gtk_widget_set_visible (self->scale_buttons_row, FALSE); + gtk_widget_set_visible (self->underscanning_row, FALSE); + + return G_SOURCE_REMOVE; + } + + g_object_freeze_notify ((GObject*) self->enabled_switch); + g_object_freeze_notify ((GObject*) self->orientation_row); + g_object_freeze_notify ((GObject*) self->refresh_rate_row); + g_object_freeze_notify ((GObject*) self->resolution_row); + g_object_freeze_notify ((GObject*) self->scale_combo_row); + g_object_freeze_notify ((GObject*) self->underscanning_switch); + + cc_display_monitor_get_geometry (self->selected_output, NULL, NULL, &width, &height); + + /* Selecte the first mode we can find if the monitor is disabled. */ + current_mode = cc_display_monitor_get_mode (self->selected_output); + if (current_mode == NULL) + current_mode = cc_display_monitor_get_preferred_mode (self->selected_output); + if (current_mode == NULL) { + modes = cc_display_monitor_get_modes (self->selected_output); + /* Lets assume that a monitor always has at least one mode. */ + g_assert (modes); + current_mode = CC_DISPLAY_MODE (modes->data); + } + + /* Enabled Switch */ + adw_preferences_row_set_title (ADW_PREFERENCES_ROW (self->enabled_row), + cc_display_monitor_get_ui_name (self->selected_output)); + gtk_switch_set_active (GTK_SWITCH (self->enabled_switch), + cc_display_monitor_is_active (self->selected_output)); + + if (should_show_rotation (self)) + { + guint i; + CcDisplayRotation rotations[] = { CC_DISPLAY_ROTATION_NONE, + CC_DISPLAY_ROTATION_90, + CC_DISPLAY_ROTATION_270, + CC_DISPLAY_ROTATION_180 }; + + gtk_widget_set_visible (self->orientation_row, TRUE); + + gtk_string_list_splice (GTK_STRING_LIST (self->orientation_list), + 0, + g_list_model_get_n_items (self->orientation_list), + NULL); + for (i = 0; i < G_N_ELEMENTS (rotations); i++) + { + g_autoptr(GObject) obj = NULL; + + if (!cc_display_monitor_supports_rotation (self->selected_output, rotations[i])) + continue; + + gtk_string_list_append (GTK_STRING_LIST (self->orientation_list), + string_for_rotation (rotations[i])); + obj = g_list_model_get_item (self->orientation_list, i); + g_object_set_data (G_OBJECT (obj), "rotation-value", GINT_TO_POINTER (rotations[i])); + + if (cc_display_monitor_get_rotation (self->selected_output) == rotations[i]) + adw_combo_row_set_selected (ADW_COMBO_ROW (self->orientation_row), + g_list_model_get_n_items (G_LIST_MODEL (self->orientation_list)) - 1); + } + } + else + { + gtk_widget_set_visible (self->orientation_row, FALSE); + } + + /* Only show refresh rate if we are not in cloning mode. */ + if (!cc_display_config_is_cloning (self->config)) + { + GList *item; + gdouble freq; + + freq = cc_display_mode_get_freq_f (current_mode); + + modes = cc_display_monitor_get_modes (self->selected_output); + + g_list_store_remove_all (self->refresh_rate_list); + + for (item = modes; item != NULL; item = item->next) + { + gint w, h; + guint new; + CcDisplayMode *mode = CC_DISPLAY_MODE (item->data); + + cc_display_mode_get_resolution (mode, &w, &h); + if (w != width || h != height) + continue; + + /* At some point we used to filter very close resolutions, + * but we don't anymore these days. + */ + new = g_list_store_insert_sorted (self->refresh_rate_list, + mode, + (GCompareDataFunc) sort_modes_by_freq_desc, + NULL); + if (freq == cc_display_mode_get_freq_f (mode)) + adw_combo_row_set_selected (ADW_COMBO_ROW (self->refresh_rate_row), new); + } + + gtk_widget_set_visible (self->refresh_rate_row, TRUE); + } + else + { + gtk_widget_set_visible (self->refresh_rate_row, FALSE); + } + + + /* Resolutions are always shown. */ + gtk_widget_set_visible (self->resolution_row, TRUE); + if (cc_display_config_is_cloning (self->config)) + { + clone_modes = cc_display_config_generate_cloning_modes (self->config); + modes = clone_modes; + } + else + { + modes = cc_display_monitor_get_modes (self->selected_output); + } + + g_list_store_remove_all (self->resolution_list); + g_list_store_append (self->resolution_list, current_mode); + adw_combo_row_set_selected (ADW_COMBO_ROW (self->resolution_row), 0); + for (item = modes; item != NULL; item = item->next) + { + gint ins; + gint w, h; + CcDisplayMode *mode = CC_DISPLAY_MODE (item->data); + + cc_display_mode_get_resolution (mode, &w, &h); + + /* Find the appropriate insertion point. */ + for (ins = 0; ins < g_list_model_get_n_items (G_LIST_MODEL (self->resolution_list)); ins++) + { + g_autoptr(CcDisplayMode) m = NULL; + gint cmp; + + m = g_list_model_get_item (G_LIST_MODEL (self->resolution_list), ins); + + cmp = sort_modes_by_area_desc (mode, m); + /* Next item is smaller, insert at this point. */ + if (cmp < 0) + break; + + /* Don't insert if it is already in the list */ + if (cmp == 0) + { + ins = -1; + break; + } + } + + if (ins >= 0) + g_list_store_insert (self->resolution_list, ins, mode); + } + + + /* Scale row is usually shown. */ + while ((child = gtk_widget_get_first_child (self->scale_bbox)) != NULL) + gtk_box_remove (GTK_BOX (self->scale_bbox), child); + + gtk_string_list_splice (GTK_STRING_LIST (self->scale_list), + 0, + g_list_model_get_n_items (self->scale_list), + NULL); + scales = cc_display_mode_get_supported_scales (current_mode); + self->num_scales = scales->len; + for (i = 0; i < scales->len; i++) + { + g_autofree gchar *scale_str = NULL; + g_autoptr(GObject) value_object = NULL; + double scale = g_array_index (scales, double, i); + GtkWidget *scale_btn; + gboolean is_selected; + + /* ComboRow */ + scale_str = make_scale_string (scale); + is_selected = G_APPROX_VALUE (cc_display_monitor_get_scale (self->selected_output), + scale, DBL_EPSILON); + + gtk_string_list_append (GTK_STRING_LIST (self->scale_list), scale_str); + value_object = g_list_model_get_item (self->scale_list, i); + g_object_set_data_full (G_OBJECT (value_object), "scale", + g_memdup2 (&scale, sizeof (double)), g_free); + if (is_selected) + adw_combo_row_set_selected (ADW_COMBO_ROW (self->scale_combo_row), + g_list_model_get_n_items (G_LIST_MODEL (self->scale_list)) - 1); + + /* ButtonBox */ + scale_btn = gtk_toggle_button_new_with_label (scale_str); + gtk_toggle_button_set_group (GTK_TOGGLE_BUTTON (scale_btn), group); + g_object_set_data_full (G_OBJECT (scale_btn), "scale", + g_memdup2 (&scale, sizeof (double)), g_free); + + if (!group) + group = GTK_TOGGLE_BUTTON (scale_btn); + gtk_box_append (GTK_BOX (self->scale_bbox), scale_btn); + /* Set active before connecting the signal */ + if (is_selected) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (scale_btn), TRUE); + + g_signal_connect_object (scale_btn, + "notify::active", + G_CALLBACK (on_scale_btn_active_changed_cb), + self, 0); + } + cc_display_settings_refresh_layout (self, self->folded); + + gtk_widget_set_visible (self->underscanning_row, + cc_display_monitor_supports_underscanning (self->selected_output) && + !cc_display_config_is_cloning (self->config)); + gtk_switch_set_active (GTK_SWITCH (self->underscanning_switch), + cc_display_monitor_get_underscanning (self->selected_output)); + + self->updating = TRUE; + g_object_thaw_notify ((GObject*) self->enabled_switch); + g_object_thaw_notify ((GObject*) self->orientation_row); + g_object_thaw_notify ((GObject*) self->refresh_rate_row); + g_object_thaw_notify ((GObject*) self->resolution_row); + g_object_thaw_notify ((GObject*) self->scale_combo_row); + g_object_thaw_notify ((GObject*) self->underscanning_switch); + self->updating = FALSE; + + return G_SOURCE_REMOVE; +} + +static void +on_output_changed_cb (CcDisplaySettings *self, + GParamSpec *pspec, + CcDisplayMonitor *output) +{ + /* Do this frmo an idle handler, because otherwise we may create an + * infinite loop triggering the notify::selected-index from the + * combo rows. */ + if (self->idle_udpate_id) + return; + + self->idle_udpate_id = g_idle_add ((GSourceFunc) cc_display_settings_rebuild_ui, self); +} + +static void +on_enabled_switch_active_changed_cb (GtkWidget *widget, + GParamSpec *pspec, + CcDisplaySettings *self) +{ + if (self->updating) + return; + + cc_display_monitor_set_active (self->selected_output, + gtk_switch_get_active (self->enabled_switch)); + + g_signal_emit_by_name (G_OBJECT (self), "updated", self->selected_output); +} + +static void +on_orientation_selection_changed_cb (GtkWidget *widget, + GParamSpec *pspec, + CcDisplaySettings *self) +{ + gint idx; + g_autoptr(GObject) obj = NULL; + + if (self->updating) + return; + + idx = adw_combo_row_get_selected (ADW_COMBO_ROW (self->orientation_row)); + obj = g_list_model_get_item (G_LIST_MODEL (self->orientation_list), idx); + + if (!obj) + return; + + cc_display_monitor_set_rotation (self->selected_output, + GPOINTER_TO_INT (g_object_get_data (G_OBJECT (obj), "rotation-value"))); + + g_signal_emit_by_name (G_OBJECT (self), "updated", self->selected_output); +} + +static void +on_refresh_rate_selection_changed_cb (GtkWidget *widget, + GParamSpec *pspec, + CcDisplaySettings *self) +{ + gint idx; + g_autoptr(CcDisplayMode) mode = NULL; + + if (self->updating) + return; + + idx = adw_combo_row_get_selected (ADW_COMBO_ROW (self->refresh_rate_row)); + mode = g_list_model_get_item (G_LIST_MODEL (self->refresh_rate_list), idx); + + if (!mode) + return; + + cc_display_monitor_set_mode (self->selected_output, mode); + + g_signal_emit_by_name (G_OBJECT (self), "updated", self->selected_output); +} + +static void +on_resolution_selection_changed_cb (GtkWidget *widget, + GParamSpec *pspec, + CcDisplaySettings *self) +{ + gint idx; + g_autoptr(CcDisplayMode) mode = NULL; + + if (self->updating) + return; + + idx = adw_combo_row_get_selected (ADW_COMBO_ROW (self->resolution_row)); + mode = g_list_model_get_item (G_LIST_MODEL (self->resolution_list), idx); + + if (!mode) + return; + + /* This is the only row that can be changed when in cloning mode. */ + if (!cc_display_config_is_cloning (self->config)) + cc_display_monitor_set_mode (self->selected_output, mode); + else + cc_display_config_set_mode_on_all_outputs (self->config, mode); + + g_signal_emit_by_name (G_OBJECT (self), "updated", self->selected_output); +} + +static void +on_scale_btn_active_changed_cb (GtkWidget *widget, + GParamSpec *pspec, + CcDisplaySettings *self) +{ + gdouble scale; + if (self->updating) + return; + + if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) + return; + + scale = *(gdouble*) g_object_get_data (G_OBJECT (widget), "scale"); + cc_display_monitor_set_scale (self->selected_output, + scale); + + g_signal_emit_by_name (G_OBJECT (self), "updated", self->selected_output); +} + +static void +on_scale_selection_changed_cb (GtkWidget *widget, + GParamSpec *pspec, + CcDisplaySettings *self) +{ + int idx; + double scale; + g_autoptr(GObject) obj = NULL; + + if (self->updating) + return; + + idx = adw_combo_row_get_selected (ADW_COMBO_ROW (self->scale_combo_row)); + obj = g_list_model_get_item (G_LIST_MODEL (self->scale_list), idx); + if (!obj) + return; + scale = *(gdouble*) g_object_get_data (G_OBJECT (obj), "scale"); + + cc_display_monitor_set_scale (self->selected_output, scale); + + g_signal_emit_by_name (G_OBJECT (self), "updated", self->selected_output); +} + +static void +on_underscanning_switch_active_changed_cb (GtkWidget *widget, + GParamSpec *pspec, + CcDisplaySettings *self) +{ + if (self->updating) + return; + + cc_display_monitor_set_underscanning (self->selected_output, + gtk_switch_get_active (GTK_SWITCH (self->underscanning_switch))); + + g_signal_emit_by_name (G_OBJECT (self), "updated", self->selected_output); +} + +static void +cc_display_settings_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + CcDisplaySettings *self = CC_DISPLAY_SETTINGS (object); + + switch (prop_id) + { + case PROP_HAS_ACCELEROMETER: + g_value_set_boolean (value, cc_display_settings_get_has_accelerometer (self)); + break; + + case PROP_CONFIG: + g_value_set_object (value, self->config); + break; + + case PROP_SELECTED_OUTPUT: + g_value_set_object (value, self->selected_output); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +cc_display_settings_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + CcDisplaySettings *self = CC_DISPLAY_SETTINGS (object); + + switch (prop_id) + { + case PROP_HAS_ACCELEROMETER: + cc_display_settings_set_has_accelerometer (self, g_value_get_boolean (value)); + break; + + case PROP_CONFIG: + cc_display_settings_set_config (self, g_value_get_object (value)); + break; + + case PROP_SELECTED_OUTPUT: + cc_display_settings_set_selected_output (self, g_value_get_object (value)); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +cc_display_settings_finalize (GObject *object) +{ + CcDisplaySettings *self = CC_DISPLAY_SETTINGS (object); + + g_clear_object (&self->config); + + g_clear_object (&self->orientation_list); + g_clear_object (&self->refresh_rate_list); + g_clear_object (&self->resolution_list); + g_clear_object (&self->scale_list); + + if (self->idle_udpate_id) + g_source_remove (self->idle_udpate_id); + self->idle_udpate_id = 0; + + G_OBJECT_CLASS (cc_display_settings_parent_class)->finalize (object); +} + +static void +cc_display_settings_class_init (CcDisplaySettingsClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + gobject_class->finalize = cc_display_settings_finalize; + gobject_class->get_property = cc_display_settings_get_property; + gobject_class->set_property = cc_display_settings_set_property; + + gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/display/cc-display-settings.ui"); + + props[PROP_HAS_ACCELEROMETER] = + g_param_spec_boolean ("has-accelerometer", "Has Accelerometer", + "If an accelerometre is available for the builtin display", + FALSE, + G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); + + props[PROP_CONFIG] = + g_param_spec_object ("config", "Display Config", + "The display configuration to work with", + CC_TYPE_DISPLAY_CONFIG, + G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); + + props[PROP_SELECTED_OUTPUT] = + g_param_spec_object ("selected-output", "Selected Output", + "The output that is currently selected on the configuration", + CC_TYPE_DISPLAY_MONITOR, + G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties (gobject_class, + PROP_LAST, + props); + + g_signal_new ("updated", + CC_TYPE_DISPLAY_SETTINGS, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 1, CC_TYPE_DISPLAY_MONITOR); + + gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, enabled_listbox); + gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, enabled_row); + gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, enabled_switch); + gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, orientation_row); + gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, refresh_rate_row); + gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, resolution_row); + gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, scale_bbox); + gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, scale_buttons_row); + gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, scale_combo_row); + gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, underscanning_row); + gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, underscanning_switch); + + gtk_widget_class_bind_template_callback (widget_class, on_enabled_switch_active_changed_cb); + gtk_widget_class_bind_template_callback (widget_class, on_orientation_selection_changed_cb); + gtk_widget_class_bind_template_callback (widget_class, on_refresh_rate_selection_changed_cb); + gtk_widget_class_bind_template_callback (widget_class, on_resolution_selection_changed_cb); + gtk_widget_class_bind_template_callback (widget_class, on_scale_selection_changed_cb); + gtk_widget_class_bind_template_callback (widget_class, on_underscanning_switch_active_changed_cb); +} + +static void +cc_display_settings_init (CcDisplaySettings *self) +{ + GtkExpression *expression; + + gtk_widget_init_template (GTK_WIDGET (self)); + + self->orientation_list = G_LIST_MODEL (gtk_string_list_new (NULL)); + self->refresh_rate_list = g_list_store_new (CC_TYPE_DISPLAY_MODE); + self->resolution_list = g_list_store_new (CC_TYPE_DISPLAY_MODE); + self->scale_list = G_LIST_MODEL (gtk_string_list_new (NULL)); + + self->updating = TRUE; + + adw_combo_row_set_model (ADW_COMBO_ROW (self->orientation_row), + G_LIST_MODEL (self->orientation_list)); + adw_combo_row_set_model (ADW_COMBO_ROW (self->scale_combo_row), + G_LIST_MODEL (self->scale_list)); + + expression = gtk_cclosure_expression_new (G_TYPE_STRING, + NULL, 0, NULL, + G_CALLBACK (make_refresh_rate_string), + self, NULL); + adw_combo_row_set_expression (ADW_COMBO_ROW (self->refresh_rate_row), expression); + adw_combo_row_set_model (ADW_COMBO_ROW (self->refresh_rate_row), + G_LIST_MODEL (self->refresh_rate_list)); + + expression = gtk_cclosure_expression_new (G_TYPE_STRING, + NULL, 0, NULL, + G_CALLBACK (make_resolution_string), + self, NULL); + adw_combo_row_set_expression (ADW_COMBO_ROW (self->resolution_row), expression); + adw_combo_row_set_model (ADW_COMBO_ROW (self->resolution_row), + G_LIST_MODEL (self->resolution_list)); + + self->updating = FALSE; +} + +CcDisplaySettings* +cc_display_settings_new (void) +{ + return g_object_new (CC_TYPE_DISPLAY_SETTINGS, + NULL); +} + +gboolean +cc_display_settings_get_has_accelerometer (CcDisplaySettings *settings) +{ + return settings->has_accelerometer; +} + +void +cc_display_settings_set_has_accelerometer (CcDisplaySettings *self, + gboolean has_accelerometer) +{ + self->has_accelerometer = has_accelerometer; + + cc_display_settings_rebuild_ui (self); + g_object_notify_by_pspec (G_OBJECT (self), props[PROP_CONFIG]); +} + +CcDisplayConfig* +cc_display_settings_get_config (CcDisplaySettings *self) +{ + return self->config; +} + +void +cc_display_settings_set_config (CcDisplaySettings *self, + CcDisplayConfig *config) +{ + const gchar *signals[] = { "rotation", "mode", "scale", "is-usable", "active" }; + GList *outputs, *l; + guint i; + + if (self->config) + { + outputs = cc_display_config_get_monitors (self->config); + for (l = outputs; l; l = l->next) + { + CcDisplayMonitor *output = l->data; + + g_signal_handlers_disconnect_by_data (output, self); + } + } + g_clear_object (&self->config); + + self->config = g_object_ref (config); + + /* Listen to all the signals */ + if (self->config) + { + outputs = cc_display_config_get_monitors (self->config); + for (l = outputs; l; l = l->next) + { + CcDisplayMonitor *output = l->data; + + for (i = 0; i < G_N_ELEMENTS (signals); ++i) + g_signal_connect_object (output, signals[i], G_CALLBACK (on_output_changed_cb), self, G_CONNECT_SWAPPED); + } + } + + cc_display_settings_set_selected_output (self, NULL); + + g_object_notify_by_pspec (G_OBJECT (self), props[PROP_CONFIG]); +} + +CcDisplayMonitor* +cc_display_settings_get_selected_output (CcDisplaySettings *self) +{ + return self->selected_output; +} + +void +cc_display_settings_set_selected_output (CcDisplaySettings *self, + CcDisplayMonitor *output) +{ + self->selected_output = output; + + cc_display_settings_rebuild_ui (self); + + g_object_notify_by_pspec (G_OBJECT (self), props[PROP_SELECTED_OUTPUT]); +} + +void +cc_display_settings_refresh_layout (CcDisplaySettings *self, + gboolean folded) +{ + gboolean use_combo; + + self->folded = folded; + use_combo = self->num_scales > MAX_SCALE_BUTTONS || (self->num_scales > 2 && folded); + + gtk_widget_set_visible (self->scale_combo_row, use_combo); + gtk_widget_set_visible (self->scale_buttons_row, self->num_scales > 1 && !use_combo); +} + +void +cc_display_settings_set_multimonitor (CcDisplaySettings *self, + gboolean multimonitor) +{ + gtk_widget_set_visible (self->enabled_listbox, multimonitor); + + if (!multimonitor) + gtk_switch_set_active (GTK_SWITCH (self->enabled_switch), TRUE); +} diff --git a/panels/display/cc-display-settings.h b/panels/display/cc-display-settings.h new file mode 100644 index 0000000..4794414 --- /dev/null +++ b/panels/display/cc-display-settings.h @@ -0,0 +1,48 @@ +/* -*- mode: c; style: linux -*- + * + * Copyright (C) 2019 Red Hat, Inc. + * + * Written by: Benjamin Berg <bberg@redhat.com> + * + * 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, 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/>. + */ + +#pragma once + +#include <adwaita.h> +#include "cc-display-config.h" + +G_BEGIN_DECLS + +#define CC_TYPE_DISPLAY_SETTINGS cc_display_settings_get_type () +G_DECLARE_FINAL_TYPE (CcDisplaySettings, cc_display_settings, CC, DISPLAY_SETTINGS, GtkBox); + +CcDisplaySettings* cc_display_settings_new (void); + +gboolean cc_display_settings_get_has_accelerometer (CcDisplaySettings *settings); +void cc_display_settings_set_has_accelerometer (CcDisplaySettings *settings, + gboolean has_accelerometer); +CcDisplayConfig* cc_display_settings_get_config (CcDisplaySettings *settings); +void cc_display_settings_set_config (CcDisplaySettings *settings, + CcDisplayConfig *config); +CcDisplayMonitor* cc_display_settings_get_selected_output (CcDisplaySettings *settings); +void cc_display_settings_set_selected_output (CcDisplaySettings *settings, + CcDisplayMonitor *output); +void cc_display_settings_refresh_layout (CcDisplaySettings *settings, + gboolean folded); +void cc_display_settings_set_multimonitor (CcDisplaySettings *self, + gboolean multimonitor); + +G_END_DECLS + diff --git a/panels/display/cc-display-settings.ui b/panels/display/cc-display-settings.ui new file mode 100644 index 0000000..64c44d1 --- /dev/null +++ b/panels/display/cc-display-settings.ui @@ -0,0 +1,101 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- Generated with glade 3.22.0 --> +<interface> + <template class="CcDisplaySettings" parent="GtkBox"> + <property name="spacing">18</property> + <property name="orientation">vertical</property> + + <child> + <object class="GtkListBox" id="enabled_listbox"> + <property name="hexpand">True</property> + <property name="selection_mode">none</property> + <style> + <class name="boxed-list" /> + </style> + <child> + <object class="AdwActionRow" id="enabled_row"> + <property name="activatable-widget">enabled_switch</property> + <child> + <object class="GtkSwitch" id="enabled_switch"> + <property name="halign">end</property> + <property name="valign">center</property> + <accessibility> + <property name="label" translatable="yes">Enabled</property> + </accessibility> + <signal name="notify::active" handler="on_enabled_switch_active_changed_cb" swapped="no"/> + </object> + </child> + </object> + </child> + </object> + </child> + + <child> + <object class="GtkListBox" id="listbox"> + <property name="hexpand">True</property> + <property name="selection_mode">none</property> + <style> + <class name="boxed-list" /> + </style> + <child> + <object class="AdwComboRow" id="orientation_row"> + <property name="width_request">100</property> + <property name="title" translatable="yes" context="display setting">Orientation</property> + <signal name="notify::selected-item" handler="on_orientation_selection_changed_cb" swapped="no"/> + </object> + </child> + <child> + <object class="AdwComboRow" id="resolution_row"> + <property name="width_request">100</property> + <property name="title" translatable="yes" context="display setting">Resolution</property> + <signal name="notify::selected-item" handler="on_resolution_selection_changed_cb" swapped="no"/> + </object> + </child> + <child> + <object class="AdwComboRow" id="refresh_rate_row"> + <property name="width_request">100</property> + <property name="title" translatable="yes">Refresh Rate</property> + <signal name="notify::selected-item" handler="on_refresh_rate_selection_changed_cb" swapped="no"/> + </object> + </child> + <child> + <object class="AdwActionRow" id="underscanning_row"> + <property name="width_request">100</property> + <property name="title" translatable="yes">Adjust for TV</property> + <property name="activatable-widget">underscanning_switch</property> + <child> + <object class="GtkSwitch" id="underscanning_switch"> + <property name="can_focus">False</property> + <property name="halign">end</property> + <property name="valign">center</property> + <signal name="notify::active" handler="on_underscanning_switch_active_changed_cb" swapped="no"/> + </object> + </child> + </object> + </child> + <child> + <object class="AdwActionRow" id="scale_buttons_row"> + <property name="width_request">100</property> + <property name="title" translatable="yes" context="display setting">Scale</property> + <child> + <object class="GtkBox" id="scale_bbox"> + <property name="halign">end</property> + <property name="valign">center</property> + <style> + <class name="linked" /> + </style> + </object> + </child> + </object> + </child> + <child> + <object class="AdwComboRow" id="scale_combo_row"> + <property name="width_request">100</property> + <property name="title" translatable="yes" context="display setting">Scale</property> + <signal name="notify::selected-item" handler="on_scale_selection_changed_cb" swapped="no"/> + </object> + </child> + </object> + </child> + </template> +</interface> diff --git a/panels/display/cc-night-light-page.c b/panels/display/cc-night-light-page.c new file mode 100644 index 0000000..4b7b112 --- /dev/null +++ b/panels/display/cc-night-light-page.c @@ -0,0 +1,746 @@ +/* + * Copyright (C) 2017 Richard Hughes <richard@hughsie.com> + * + * Licensed under the GNU General Public License Version 2 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" + +#include <gdesktop-enums.h> +#include <gtk/gtk.h> +#include <glib/gi18n.h> +#include <math.h> + +#include "cc-night-light-page.h" + +#include "shell/cc-object-storage.h" +#include "cc-display-config-manager-dbus.h" + +struct _CcNightLightPage { + AdwBin parent; + + GtkWidget *night_light_settings; + GtkWidget *box_manual; + GtkButton *button_from_am; + GtkButton *button_from_pm; + GtkButton *button_to_am; + GtkButton *button_to_pm; + GtkWidget *infobar_unsupported; + GtkWidget *infobar_disabled; + GtkListBox *listbox; + GtkWidget *scale_color_temperature; + GtkWidget *night_light_toggle_switch; + GtkComboBox *schedule_type_combo; + GtkWidget *from_spinbuttons_box; + GtkWidget *spinbutton_from_hours; + GtkWidget *spinbutton_from_minutes; + GtkWidget *to_spinbuttons_box; + GtkWidget *spinbutton_to_hours; + GtkWidget *spinbutton_to_minutes; + GtkStack *stack_from; + GtkStack *stack_to; + + GtkAdjustment *adjustment_from_hours; + GtkAdjustment *adjustment_from_minutes; + GtkAdjustment *adjustment_to_hours; + GtkAdjustment *adjustment_to_minutes; + GtkAdjustment *adjustment_color_temperature; + + GSettings *settings_display; + GSettings *settings_clock; + GDBusProxy *proxy_color; + GDBusProxy *proxy_color_props; + GCancellable *cancellable; + gboolean ignore_value_changed; + guint timer_id; + GDesktopClockFormat clock_format; + + CcDisplayConfigManager *config_manager; +}; + +G_DEFINE_TYPE (CcNightLightPage, cc_night_light_page, ADW_TYPE_BIN); + +#define CLOCK_SCHEMA "org.gnome.desktop.interface" +#define DISPLAY_SCHEMA "org.gnome.settings-daemon.plugins.color" +#define CLOCK_FORMAT_KEY "clock-format" +#define NIGHT_LIGHT_PREVIEW_TIMEOUT_SECONDS 5 + +static void +dialog_adjustments_set_frac_hours (CcNightLightPage *self, + gdouble value, + GtkAdjustment *adj_hours, + GtkAdjustment *adj_mins, + GtkStack *stack, + GtkButton *button_am, + GtkButton *button_pm) +{ + gdouble hours; + gdouble mins = 0.f; + gboolean is_pm = FALSE; + gboolean is_24h; + + /* display the right thing for AM/PM */ + is_24h = self->clock_format == G_DESKTOP_CLOCK_FORMAT_24H; + mins = modf (value, &hours) * 60.f; + if (!is_24h) + { + if (hours > 12) + { + hours -= 12; + is_pm = TRUE; + } + else if (hours < 1.0) + { + hours += 12; + is_pm = FALSE; + } + else if (hours == 12.f) + { + is_pm = TRUE; + } + } + + g_debug ("setting adjustment %.3f to %.0f:%02.0f", value, hours, mins); + + self->ignore_value_changed = TRUE; + gtk_adjustment_set_value (GTK_ADJUSTMENT (adj_hours), hours); + gtk_adjustment_set_value (GTK_ADJUSTMENT (adj_mins), mins); + self->ignore_value_changed = FALSE; + + gtk_widget_set_visible (GTK_WIDGET (stack), !is_24h); + gtk_stack_set_visible_child (stack, is_pm ? GTK_WIDGET (button_pm) : GTK_WIDGET (button_am)); +} + +static void +dialog_update_state (CcNightLightPage *self) +{ + if (cc_display_config_manager_get_night_light_supported (self->config_manager)) + { + gboolean automatic; + gboolean disabled_until_tomorrow = FALSE; + gboolean enabled; + gdouble value = 0.f; + + /* only show the infobar if we are disabled */ + if (self->proxy_color != NULL) + { + g_autoptr(GVariant) disabled = NULL; + disabled = g_dbus_proxy_get_cached_property (self->proxy_color, + "DisabledUntilTomorrow"); + if (disabled != NULL) + disabled_until_tomorrow = g_variant_get_boolean (disabled); + } + gtk_widget_set_visible (self->infobar_disabled, disabled_until_tomorrow); + + /* make things insensitive if the switch is disabled */ + enabled = g_settings_get_boolean (self->settings_display, "night-light-enabled"); + automatic = g_settings_get_boolean (self->settings_display, "night-light-schedule-automatic"); + + gtk_widget_set_sensitive (self->box_manual, enabled && !automatic); + + gtk_combo_box_set_active_id (self->schedule_type_combo, automatic ? "automatic" : "manual"); + + /* set from */ + if (automatic && self->proxy_color != NULL) + { + g_autoptr(GVariant) sunset = NULL; + sunset = g_dbus_proxy_get_cached_property (self->proxy_color, "Sunset"); + if (sunset != NULL) + { + value = g_variant_get_double (sunset); + } + else + { + value = 16.0f; + g_warning ("no sunset data, using %02.2f", value); + } + } + else + { + value = g_settings_get_double (self->settings_display, "night-light-schedule-from"); + value = fmod (value, 24.f); + } + dialog_adjustments_set_frac_hours (self, value, + self->adjustment_from_hours, + self->adjustment_from_minutes, + self->stack_from, + self->button_from_am, + self->button_from_pm); + + /* set to */ + if (automatic && self->proxy_color != NULL) + { + g_autoptr(GVariant) sunset = NULL; + sunset = g_dbus_proxy_get_cached_property (self->proxy_color, "Sunrise"); + if (sunset != NULL) + { + value = g_variant_get_double (sunset); + } + else + { + value = 8.0f; + g_warning ("no sunrise data, using %02.2f", value); + } + } + else + { + value = g_settings_get_double (self->settings_display, "night-light-schedule-to"); + value = fmod (value, 24.f); + } + dialog_adjustments_set_frac_hours (self, value, + self->adjustment_to_hours, + self->adjustment_to_minutes, + self->stack_to, + self->button_to_am, + self->button_to_pm); + + self->ignore_value_changed = TRUE; + value = (gdouble) g_settings_get_uint (self->settings_display, "night-light-temperature"); + gtk_adjustment_set_value (self->adjustment_color_temperature, value); + self->ignore_value_changed = FALSE; + } + else + { + gtk_widget_set_visible (self->infobar_unsupported, TRUE); + gtk_widget_set_visible (self->infobar_disabled, FALSE); + gtk_widget_set_sensitive (self->night_light_settings, FALSE); + } +} + +static void +build_schedule_combo_row (CcNightLightPage *self) +{ + gboolean automatic; + gboolean enabled; + + self->ignore_value_changed = TRUE; + + + enabled = g_settings_get_boolean (self->settings_display, "night-light-enabled"); + automatic = g_settings_get_boolean (self->settings_display, "night-light-schedule-automatic"); + + gtk_widget_set_sensitive (self->box_manual, enabled && !automatic); + + gtk_combo_box_set_active_id (self->schedule_type_combo, automatic ? "automatic" : "manual"); + + self->ignore_value_changed = FALSE; +} + +static void +on_schedule_type_combo_active_changed_cb (GtkComboBox *combo_box, + GParamSpec *pspec, + CcNightLightPage *self) +{ + const gchar *active_id; + gboolean automatic; + + if (self->ignore_value_changed) + return; + + active_id = gtk_combo_box_get_active_id (combo_box); + automatic = g_str_equal (active_id, "automatic"); + + g_settings_set_boolean (self->settings_display, "night-light-schedule-automatic", automatic); +} + +static gboolean +dialog_tick_cb (gpointer user_data) +{ + CcNightLightPage *self = (CcNightLightPage *) user_data; + dialog_update_state (self); + return G_SOURCE_CONTINUE; +} + +static void +dialog_enabled_notify_cb (GtkSwitch *sw, + GParamSpec *pspec, + CcNightLightPage *self) +{ + g_settings_set_boolean (self->settings_display, "night-light-enabled", + gtk_switch_get_active (sw)); +} + +static void +dialog_undisable_call_cb (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + g_autoptr(GVariant) val = NULL; + g_autoptr(GError) error = NULL; + + val = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), + res, &error); + if (val == NULL) + { + g_warning ("failed to undisable: %s", error->message); + return; + } +} + +static void +dialog_undisable_clicked_cb (GtkButton *button, + CcNightLightPage *self) +{ + g_dbus_proxy_call (self->proxy_color_props, + "Set", + g_variant_new ("(ssv)", + "org.gnome.SettingsDaemon.Color", + "DisabledUntilTomorrow", + g_variant_new_boolean (FALSE)), + G_DBUS_CALL_FLAGS_NONE, + 5000, + self->cancellable, + dialog_undisable_call_cb, + self); +} + +static gdouble +dialog_adjustments_get_frac_hours (CcNightLightPage *self, + GtkAdjustment *adj_hours, + GtkAdjustment *adj_mins, + GtkStack *stack) +{ + gdouble value; + + value = gtk_adjustment_get_value (adj_hours); + value += gtk_adjustment_get_value (adj_mins) / 60.0f; + + if (g_strcmp0 (gtk_stack_get_visible_child_name (stack), "pm") == 0) + value += 12.f; + + return value; +} + +static void +dialog_time_from_value_changed_cb (GtkAdjustment *adjustment, + CcNightLightPage *self) +{ + gdouble value; + + if (self->ignore_value_changed) + return; + + value = dialog_adjustments_get_frac_hours (self, + self->adjustment_from_hours, + self->adjustment_from_minutes, + self->stack_from); + + if (value >= 24.f) + value = fmod (value, 24); + + g_debug ("new value = %.3f", value); + + g_settings_set_double (self->settings_display, "night-light-schedule-from", value); +} + +static void +dialog_time_to_value_changed_cb (GtkAdjustment *adjustment, + CcNightLightPage *self) +{ + gdouble value; + + if (self->ignore_value_changed) + return; + + value = dialog_adjustments_get_frac_hours (self, + self->adjustment_to_hours, + self->adjustment_to_minutes, + self->stack_to); + if (value >= 24.f) + value = fmod (value, 24); + + g_debug ("new value = %.3f", value); + + g_settings_set_double (self->settings_display, "night-light-schedule-to", value); +} + +static void +dialog_color_temperature_value_changed_cb (GtkAdjustment *adjustment, + CcNightLightPage *self) +{ + gdouble value; + + if (self->ignore_value_changed) + return; + + value = gtk_adjustment_get_value (adjustment); + + g_debug ("new value = %.0f", value); + + if (self->proxy_color != NULL) + g_dbus_proxy_call (self->proxy_color, + "NightLightPreview", + g_variant_new ("(u)", NIGHT_LIGHT_PREVIEW_TIMEOUT_SECONDS), + G_DBUS_CALL_FLAGS_NONE, + 5000, + NULL, + NULL, + NULL); + + g_settings_set_uint (self->settings_display, "night-light-temperature", (guint) value); +} + +static void +dialog_color_properties_changed_cb (CcNightLightPage *self) +{ + dialog_update_state (self); +} + +static void +dialog_got_proxy_cb (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + CcNightLightPage *self = (CcNightLightPage *) user_data; + GDBusProxy *proxy; + g_autoptr(GError) error = NULL; + + proxy = cc_object_storage_create_dbus_proxy_finish (res, &error); + if (proxy == NULL) + { + if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + g_warning ("failed to connect to g-s-d: %s", error->message); + return; + } + + self->proxy_color = proxy; + + g_signal_connect_object (self->proxy_color, "g-properties-changed", + G_CALLBACK (dialog_color_properties_changed_cb), self, G_CONNECT_SWAPPED); + dialog_update_state (self); + self->timer_id = g_timeout_add_seconds (10, dialog_tick_cb, self); +} + +static void +dialog_got_proxy_props_cb (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + CcNightLightPage *self = (CcNightLightPage *) user_data; + GDBusProxy *proxy; + g_autoptr(GError) error = NULL; + + proxy = cc_object_storage_create_dbus_proxy_finish (res, &error); + if (proxy == NULL) + { + if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + g_warning ("failed to connect to g-s-d: %s", error->message); + return; + } + + self->proxy_color_props = proxy; +} + +static gboolean +dialog_format_minutes_combobox (GtkSpinButton *spin, + CcNightLightPage *self) +{ + GtkAdjustment *adjustment; + g_autofree gchar *text = NULL; + adjustment = gtk_spin_button_get_adjustment (spin); + text = g_strdup_printf ("%02.0f", gtk_adjustment_get_value (adjustment)); + gtk_editable_set_text (GTK_EDITABLE (spin), text); + return TRUE; +} + +static gboolean +dialog_format_hours_combobox (GtkSpinButton *spin, + CcNightLightPage *self) +{ + GtkAdjustment *adjustment; + g_autofree gchar *text = NULL; + adjustment = gtk_spin_button_get_adjustment (spin); + if (self->clock_format == G_DESKTOP_CLOCK_FORMAT_12H) + text = g_strdup_printf ("%.0f", gtk_adjustment_get_value (adjustment)); + else + text = g_strdup_printf ("%02.0f", gtk_adjustment_get_value (adjustment)); + gtk_editable_set_text (GTK_EDITABLE (spin), text); + return TRUE; +} + +static void +dialog_update_adjustments (CcNightLightPage *self) +{ + /* from */ + if (self->clock_format == G_DESKTOP_CLOCK_FORMAT_24H) + { + gtk_adjustment_set_lower (self->adjustment_from_hours, 0); + gtk_adjustment_set_upper (self->adjustment_from_hours, 23); + } + else + { + if (gtk_adjustment_get_value (self->adjustment_from_hours) > 12) + gtk_stack_set_visible_child (self->stack_from, GTK_WIDGET (self->button_from_pm)); + + gtk_adjustment_set_lower (self->adjustment_from_hours, 1); + gtk_adjustment_set_upper (self->adjustment_from_hours, 12); + } + + /* to */ + if (self->clock_format == G_DESKTOP_CLOCK_FORMAT_24H) + { + gtk_adjustment_set_lower (self->adjustment_to_hours, 0); + gtk_adjustment_set_upper (self->adjustment_to_hours, 23); + } + else + { + if (gtk_adjustment_get_value (self->adjustment_to_hours) > 12) + gtk_stack_set_visible_child (self->stack_to, GTK_WIDGET (self->button_to_pm)); + + gtk_adjustment_set_lower (self->adjustment_to_hours, 1); + gtk_adjustment_set_upper (self->adjustment_to_hours, 12); + } +} + +static void +dialog_settings_changed_cb (CcNightLightPage *self) +{ + dialog_update_state (self); +} + +static void +dialog_clock_settings_changed_cb (CcNightLightPage *self) +{ + self->clock_format = g_settings_get_enum (self->settings_clock, CLOCK_FORMAT_KEY); + + /* uncontionally widen this to avoid truncation */ + gtk_adjustment_set_lower (self->adjustment_from_hours, 0); + gtk_adjustment_set_upper (self->adjustment_from_hours, 23); + gtk_adjustment_set_lower (self->adjustment_to_hours, 0); + gtk_adjustment_set_upper (self->adjustment_to_hours, 23); + + /* update spinbuttons */ + gtk_spin_button_update (GTK_SPIN_BUTTON (self->spinbutton_from_hours)); + gtk_spin_button_update (GTK_SPIN_BUTTON (self->spinbutton_to_hours)); + + /* update UI */ + dialog_update_state (self); + dialog_update_adjustments (self); +} + +static void +dialog_am_pm_from_button_clicked_cb (GtkButton *button, + CcNightLightPage *self) +{ + gdouble value; + value = g_settings_get_double (self->settings_display, "night-light-schedule-from"); + if (value > 12.f) + value -= 12.f; + else + value += 12.f; + if (value >= 24.f) + value = fmod (value, 24); + g_settings_set_double (self->settings_display, "night-light-schedule-from", value); + g_debug ("new value = %.3f", value); +} + +static void +dialog_am_pm_to_button_clicked_cb (GtkButton *button, + CcNightLightPage *self) +{ + gdouble value; + value = g_settings_get_double (self->settings_display, "night-light-schedule-to"); + if (value > 12.f) + value -= 12.f; + else + value += 12.f; + if (value >= 24.f) + value = fmod (value, 24); + g_settings_set_double (self->settings_display, "night-light-schedule-to", value); + g_debug ("new value = %.3f", value); +} + +static void +config_manager_changed_cb (CcDisplayConfigManager *config_manager, + CcNightLightPage *self) +{ + dialog_update_state (self); +} + +/* GObject overrides */ +static void +cc_night_light_page_finalize (GObject *object) +{ + CcNightLightPage *self = CC_NIGHT_LIGHT_PAGE (object); + + g_cancellable_cancel (self->cancellable); + + g_clear_object (&self->cancellable); + g_clear_object (&self->proxy_color); + g_clear_object (&self->proxy_color_props); + g_clear_object (&self->settings_display); + g_clear_object (&self->settings_clock); + if (self->timer_id > 0) + g_source_remove (self->timer_id); + + G_OBJECT_CLASS (cc_night_light_page_parent_class)->finalize (object); +} + +static void +cc_night_light_page_class_init (CcNightLightPageClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + object_class->finalize = cc_night_light_page_finalize; + + gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/display/cc-night-light-page.ui"); + + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, adjustment_from_hours); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, adjustment_from_minutes); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, adjustment_to_hours); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, adjustment_to_minutes); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, adjustment_color_temperature); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, night_light_settings); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, box_manual); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, button_from_am); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, button_from_pm); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, button_to_am); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, button_to_pm); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, infobar_unsupported); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, infobar_disabled); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, listbox); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, night_light_toggle_switch); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, schedule_type_combo); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, scale_color_temperature); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, from_spinbuttons_box); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, spinbutton_from_hours); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, spinbutton_from_minutes); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, to_spinbuttons_box); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, spinbutton_to_hours); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, spinbutton_to_minutes); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, stack_from); + gtk_widget_class_bind_template_child (widget_class, CcNightLightPage, stack_to); + + gtk_widget_class_bind_template_callback (widget_class, dialog_am_pm_from_button_clicked_cb); + gtk_widget_class_bind_template_callback (widget_class, dialog_am_pm_to_button_clicked_cb); + gtk_widget_class_bind_template_callback (widget_class, dialog_enabled_notify_cb); + gtk_widget_class_bind_template_callback (widget_class, dialog_format_hours_combobox); + gtk_widget_class_bind_template_callback (widget_class, dialog_format_minutes_combobox); + gtk_widget_class_bind_template_callback (widget_class, dialog_time_from_value_changed_cb); + gtk_widget_class_bind_template_callback (widget_class, dialog_time_to_value_changed_cb); + gtk_widget_class_bind_template_callback (widget_class, dialog_color_temperature_value_changed_cb); + gtk_widget_class_bind_template_callback (widget_class, dialog_undisable_clicked_cb); + gtk_widget_class_bind_template_callback (widget_class, on_schedule_type_combo_active_changed_cb); + +} + +static void +cc_night_light_page_init (CcNightLightPage *self) +{ + g_autoptr(GtkCssProvider) provider = NULL; + + gtk_widget_init_template (GTK_WIDGET (self)); + + gtk_scale_add_mark (GTK_SCALE (self->scale_color_temperature), + 1700, GTK_POS_BOTTOM, + NULL); + + gtk_scale_add_mark (GTK_SCALE (self->scale_color_temperature), + 2700, GTK_POS_BOTTOM, + NULL); + + gtk_scale_add_mark (GTK_SCALE (self->scale_color_temperature), + 3700, GTK_POS_BOTTOM, + NULL); + + gtk_scale_add_mark (GTK_SCALE (self->scale_color_temperature), + 4700, GTK_POS_BOTTOM, + NULL); + + self->cancellable = g_cancellable_new (); + self->settings_display = g_settings_new (DISPLAY_SCHEMA); + + g_signal_connect_object (self->settings_display, "changed", G_CALLBACK (dialog_settings_changed_cb), self, G_CONNECT_SWAPPED); + + build_schedule_combo_row (self); + + g_settings_bind (self->settings_display, "night-light-enabled", + self->night_light_toggle_switch, "active", + G_SETTINGS_BIND_DEFAULT); + + g_settings_bind_writable (self->settings_display, "night-light-enabled", + self->night_light_toggle_switch, "sensitive", + FALSE); + + g_settings_bind_writable (self->settings_display, "night-light-schedule-from", + self->spinbutton_from_hours, "sensitive", + FALSE); + g_settings_bind_writable (self->settings_display, "night-light-schedule-from", + self->spinbutton_from_minutes, "sensitive", + FALSE); + g_settings_bind_writable (self->settings_display, "night-light-schedule-to", + self->spinbutton_to_minutes, "sensitive", + FALSE); + g_settings_bind_writable (self->settings_display, "night-light-schedule-to", + self->spinbutton_to_minutes, "sensitive", + FALSE); + + /* use custom CSS */ + provider = gtk_css_provider_new (); + gtk_css_provider_load_from_resource (provider, "/org/gnome/control-center/display/night-light.css"); + gtk_style_context_add_provider_for_display (gdk_display_get_default (), + GTK_STYLE_PROVIDER (provider), + GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); + + cc_object_storage_create_dbus_proxy (G_BUS_TYPE_SESSION, + G_DBUS_PROXY_FLAGS_NONE, + "org.gnome.SettingsDaemon.Color", + "/org/gnome/SettingsDaemon/Color", + "org.gnome.SettingsDaemon.Color", + self->cancellable, + dialog_got_proxy_cb, + self); + + cc_object_storage_create_dbus_proxy (G_BUS_TYPE_SESSION, + G_DBUS_PROXY_FLAGS_NONE, + "org.gnome.SettingsDaemon.Color", + "/org/gnome/SettingsDaemon/Color", + "org.freedesktop.DBus.Properties", + self->cancellable, + dialog_got_proxy_props_cb, + self); + + /* clock settings_display */ + self->settings_clock = g_settings_new (CLOCK_SCHEMA); + self->clock_format = g_settings_get_enum (self->settings_clock, CLOCK_FORMAT_KEY); + dialog_update_adjustments (self); + g_signal_connect_object (self->settings_clock, + "changed::" CLOCK_FORMAT_KEY, + G_CALLBACK (dialog_clock_settings_changed_cb), + self, G_CONNECT_SWAPPED); + + if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL) + { + gtk_widget_set_direction (self->to_spinbuttons_box, GTK_TEXT_DIR_LTR); + gtk_widget_set_direction (self->from_spinbuttons_box, GTK_TEXT_DIR_LTR); + } + + self->config_manager = cc_display_config_manager_dbus_new (); + g_signal_connect (self->config_manager, "changed", + G_CALLBACK (config_manager_changed_cb), self); + + dialog_update_state (self); +} + +CcNightLightPage * +cc_night_light_page_new (void) +{ + return g_object_new (CC_TYPE_NIGHT_LIGHT_PAGE, + NULL); +} + diff --git a/panels/display/cc-night-light-page.h b/panels/display/cc-night-light-page.h new file mode 100644 index 0000000..7e7be4b --- /dev/null +++ b/panels/display/cc-night-light-page.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2017 Richard Hughes <richard@hughsie.com> + * + * Licensed under the GNU General Public License Version 2 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#pragma once + +#include <adwaita.h> + +G_BEGIN_DECLS + +#define CC_TYPE_NIGHT_LIGHT_PAGE (cc_night_light_page_get_type ()) +G_DECLARE_FINAL_TYPE (CcNightLightPage, cc_night_light_page, CC, NIGHT_LIGHT_PAGE, AdwBin) + +CcNightLightPage* cc_night_light_page_new (void); + +G_END_DECLS diff --git a/panels/display/cc-night-light-page.ui b/panels/display/cc-night-light-page.ui new file mode 100644 index 0000000..6e5b12b --- /dev/null +++ b/panels/display/cc-night-light-page.ui @@ -0,0 +1,438 @@ +<?xml version="1.0" encoding="UTF-8"?> +<interface> + <template class="CcNightLightPage" parent="AdwBin"> + <child> + <object class="GtkBox"> + <property name="orientation">vertical</property> + <child> + <object class="GtkInfoBar" id="infobar_unsupported"> + <property name="visible">False</property> + <property name="name">infobar_unsupported</property> + <property name="message-type">warning</property> + <child> + <object class="GtkBox"> + <property name="orientation">vertical</property> + <property name="hexpand">True</property> + <property name="spacing">16</property> + <child> + <object class="GtkLabel"> + <property name="halign">start</property> + <property name="margin-start">6</property> + <property name="hexpand">False</property> + <property name="label" translatable="yes">Night Light unavailable</property> + <attributes> + <attribute name="weight" value="bold"/> + </attributes> + </object> + </child> + <child> + <object class="GtkLabel"> + <property name="margin-start">6</property> + <property name="label" translatable="yes">This could be the result of the graphics driver being used, or the desktop being used remotely</property> + <property name="wrap">True</property> + <property name="xalign">0.0</property> + </object> + </child> + </object> + </child> + </object> + </child> + <child> + <object class="GtkBox" id="night_light_settings"> + <property name="halign">center</property> + <property name="valign">start</property> + <property name="orientation">vertical</property> + <child> + <object class="GtkInfoBar" id="infobar_disabled"> + <property name="name">infobar_disabled</property> + <child> + <object class="GtkBox"> + <property name="hexpand">True</property> + <property name="spacing">16</property> + <child> + <object class="GtkLabel"> + <property name="halign">start</property> + <property name="margin-start">12</property> + <property name="hexpand">False</property> + <property name="wrap">True</property> + <property name="label" translatable="yes" comments="Inhibit the redshift functionality until the next day starts">Temporarily Disabled Until Tomorrow</property> + <attributes> + <attribute name="weight" value="bold"/> + </attributes> + </object> + </child> + </object> + </child> + <child> + <object class="GtkButton" id="button_undisable"> + <property name="margin-top">12</property> + <property name="margin-bottom">12</property> + <property name="margin-start">12</property> + <property name="margin-end">12</property> + <property name="label" translatable="yes" comments="This cancels the redshift inhibit.">Restart Filter</property> + <property name="name">button_undisable</property> + <property name="can_focus">True</property> + <property name="receives_default">True</property> + <property name="valign">GTK_ALIGN_CENTER</property> + <signal name="clicked" handler="dialog_undisable_clicked_cb" object="CcNightLightPage" swapped="no" /> + </object> + </child> + </object> + </child> + + <child> + <object class="GtkBox"> + <property name="margin_top">30</property> + <property name="margin_end">12</property> + <property name="margin_start">12</property> + <property name="margin_bottom">36</property> + <property name="orientation">vertical</property> + <property name="spacing">26</property> + <child> + <object class="GtkLabel"> + <property name="halign">start</property> + <property name="valign">start</property> + <property name="label" translatable="yes">Night light makes the screen color warmer. This can help to prevent eye strain and sleeplessness.</property> + <property name="wrap">True</property> + <property name="max_width_chars">60</property> + <property name="xalign">0</property> + <style> + <class name="dim-label"/> + </style> + </object> + </child> + <child> + <object class="GtkListBox" id="listbox"> + <property name="selection-mode">none</property> + + <style> + <class name="boxed-list" /> + </style> + + <!-- Night Light --> + <child> + <object class="AdwActionRow"> + <property name="title" translatable="yes">Night Light</property> + <property name="activatable-widget">night_light_toggle_switch</property> + + <child> + <object class="GtkSwitch" id="night_light_toggle_switch"> + <property name="valign">center</property> + <accessibility> + <property name="label" translatable="yes">Enable</property> + </accessibility> + </object> + </child> + </object> + </child> + + <!-- Schedule --> + <child> + <object class="AdwActionRow" id="schedule_row"> + <property name="title" translatable="yes">Schedule</property> + <property name="sensitive" bind-source="night_light_toggle_switch" bind-property="active" bind-flags="default|sync-create" /> + + <child> + <object class="GtkComboBoxText" id="schedule_type_combo"> + <property name="valign">center</property> + <signal name="notify::active" handler="on_schedule_type_combo_active_changed_cb" object="CcNightLightPage" swapped="no" /> + <items> + <item translatable="yes" id="automatic">Sunset to Sunrise</item> + <item translatable="yes" id="manual">Manual Schedule</item> + </items> + <accessibility> + <relation name="labelled-by">schedule_row</relation> + </accessibility> + </object> + </child> + </object> + </child> + + <!-- Time --> + <child> + <object class="AdwActionRow"> + <property name="title" translatable="yes">Times</property> + <property name="sensitive" bind-source="night_light_toggle_switch" bind-property="active" bind-flags="default|sync-create" /> + + <child> + <object class="GtkBox" id="box_manual"> + <property name="spacing">6</property> + <property name="margin-top">12</property> + <property name="margin-bottom">12</property> + <style> + <class name="time-widget" /> + </style> + <child> + <object class="GtkLabel"> + <property name="label" translatable="yes">From</property> + <property name="mnemonic_widget">spinbutton_from_hours</property> + <style> + <class name="dim-label"/> + </style> + </object> + </child> + <child> + <object class="GtkBox" id="from_spinbuttons_box"> + <property name="spacing">4</property> + <child> + <object class="GtkSpinButton" id="spinbutton_from_hours"> + <property name="can_focus">True</property> + <property name="max_width_chars">2</property> + <property name="text">4</property> + <property name="orientation">vertical</property> + <property name="adjustment">adjustment_from_hours</property> + <property name="numeric">True</property> + <property name="wrap">True</property> + <property name="value">4</property> + <signal name="output" handler="dialog_format_hours_combobox" object="CcNightLightPage" swapped="no" /> + <style> + <class name="padded-spinbutton"/> + </style> + <accessibility> + <property name="description" translatable="yes">Hour</property> + </accessibility> + </object> + </child> + <child> + <object class="GtkLabel"> + <property name="label" translatable="yes">:</property> + </object> + </child> + <child> + <object class="GtkSpinButton" id="spinbutton_from_minutes"> + <property name="can_focus">True</property> + <property name="max_width_chars">2</property> + <property name="text">0</property> + <property name="orientation">vertical</property> + <property name="adjustment">adjustment_from_minutes</property> + <property name="numeric">True</property> + <property name="wrap">True</property> + <signal name="output" handler="dialog_format_minutes_combobox" object="CcNightLightPage" swapped="no" /> + <style> + <class name="padded-spinbutton"/> + </style> + <accessibility> + <property name="description" translatable="yes">Minute</property> + </accessibility> + </object> + </child> + <child> + <object class="GtkStack" id="stack_from"> + <property name="hhomogeneous">False</property> + <property name="vhomogeneous">False</property> + <child> + <object class="GtkButton" id="button_from_am"> + <property name="label" translatable="yes" comments="This is the short form for the time period in the morning">AM</property> + <property name="can_focus">True</property> + <property name="receives_default">True</property> + <property name="valign">center</property> + <signal name="clicked" handler="dialog_am_pm_from_button_clicked_cb" object="CcNightLightPage" swapped="no" /> + <style> + <class name="unpadded-button"/> + </style> + </object> + </child> + <child> + <object class="GtkButton" id="button_from_pm"> + <property name="label" translatable="yes" comments="This is the short form for the time period in the afternoon">PM</property> + <property name="can_focus">True</property> + <property name="receives_default">True</property> + <property name="valign">center</property> + <signal name="clicked" handler="dialog_am_pm_from_button_clicked_cb" object="CcNightLightPage" swapped="no" /> + <style> + <class name="unpadded-button"/> + </style> + </object> + </child> + </object> + </child> + </object> + </child> + <child> + <object class="GtkLabel"> + <property name="margin-start">6</property> + <property name="label" translatable="yes">To</property> + <property name="mnemonic_widget">spinbutton_to_hours</property> + <style> + <class name="dim-label"/> + </style> + </object> + </child> + <child> + <object class="GtkBox" id="to_spinbuttons_box"> + <property name="spacing">4</property> + <child> + <object class="GtkSpinButton" id="spinbutton_to_hours"> + <property name="can_focus">True</property> + <property name="max_width_chars">2</property> + <property name="text">4</property> + <property name="orientation">vertical</property> + <property name="adjustment">adjustment_to_hours</property> + <property name="numeric">True</property> + <property name="wrap">True</property> + <property name="value">4</property> + <signal name="output" handler="dialog_format_hours_combobox" object="CcNightLightPage" swapped="no" /> + <style> + <class name="padded-spinbutton"/> + </style> + <accessibility> + <property name="description" translatable="yes">Hour</property> + </accessibility> + </object> + </child> + <child> + <object class="GtkLabel"> + <property name="label" translatable="yes">:</property> + </object> + </child> + <child> + <object class="GtkSpinButton" id="spinbutton_to_minutes"> + <property name="can_focus">True</property> + <property name="max_width_chars">2</property> + <property name="text">0</property> + <property name="orientation">vertical</property> + <property name="adjustment">adjustment_to_minutes</property> + <property name="numeric">True</property> + <property name="wrap">True</property> + <signal name="output" handler="dialog_format_minutes_combobox" object="CcNightLightPage" swapped="no" /> + <style> + <class name="padded-spinbutton"/> + </style> + <accessibility> + <property name="description" translatable="yes">Minute</property> + </accessibility> + </object> + </child> + <child> + <object class="GtkStack" id="stack_to"> + <property name="hhomogeneous">False</property> + <property name="vhomogeneous">False</property> + <child> + <object class="GtkButton" id="button_to_am"> + <property name="label" translatable="yes">AM</property> + <property name="can_focus">True</property> + <property name="receives_default">True</property> + <property name="valign">center</property> + <signal name="clicked" handler="dialog_am_pm_to_button_clicked_cb" object="CcNightLightPage" swapped="no" /> + <style> + <class name="unpadded-button"/> + </style> + </object> + </child> + <child> + <object class="GtkButton" id="button_to_pm"> + <property name="label" translatable="yes">PM</property> + <property name="can_focus">True</property> + <property name="receives_default">True</property> + <property name="valign">center</property> + <signal name="clicked" handler="dialog_am_pm_to_button_clicked_cb" object="CcNightLightPage" swapped="no" /> + <style> + <class name="unpadded-button"/> + </style> + </object> + </child> + </object> + </child> + </object> + </child> + </object> + </child> + </object> + </child> + + <!-- Color Temperature --> + <child> + <object class="AdwPreferencesRow"> + <property name="activatable">False</property> + <property name="sensitive" bind-source="night_light_toggle_switch" bind-property="active" bind-flags="default|sync-create" /> + + <child> + <object class="GtkBox"> + <property name="margin-start">12</property> + <property name="margin-end">12</property> + <property name="margin-top">12</property> + <property name="margin-bottom">12</property> + <property name="spacing">6</property> + <property name="orientation">vertical</property> + + <child> + <object class="GtkLabel" id="title"> + <property name="label" translatable="yes">Color Temperature</property> + <property name="ellipsize">none</property> + <property name="lines">0</property> + <property name="xalign">0.0</property> + <property name="mnemonic_widget">scale_color_temperature</property> + <style> + <class name="title"/> + </style> + </object> + </child> + + <child> + <object class="GtkScale" id="scale_color_temperature"> + <property name="hexpand">True</property> + <property name="width-request">280</property> + <property name="adjustment">adjustment_color_temperature</property> + <property name="inverted">True</property> + <property name="restrict_to_fill_level">False</property> + <property name="fill_level">1</property> + <property name="digits">0</property> + <property name="draw_value">False</property> + <property name="has_origin">False</property> + <property name="value_pos">bottom</property> + <style> + <class name="night-light-temperature"/> + </style> + </object> + </child> + + </object> + </child> + + </object> + </child> + + </object> + </child> + + </object> + </child> + + </object> + </child> + </object> + </child> + </template> + + <object class="GtkAdjustment" id="adjustment_from_hours"> + <property name="upper">23</property> + <property name="step_increment">1</property> + <property name="page_increment">10</property> + <signal name="value-changed" handler="dialog_time_from_value_changed_cb" object="CcNightLightPage" swapped="no" /> + </object> + <object class="GtkAdjustment" id="adjustment_from_minutes"> + <property name="upper">59</property> + <property name="step_increment">1</property> + <property name="page_increment">10</property> + <signal name="value-changed" handler="dialog_time_from_value_changed_cb" object="CcNightLightPage" swapped="no" /> + </object> + <object class="GtkAdjustment" id="adjustment_to_hours"> + <property name="upper">23</property> + <property name="step_increment">1</property> + <property name="page_increment">10</property> + <signal name="value-changed" handler="dialog_time_to_value_changed_cb" object="CcNightLightPage" swapped="no" /> + </object> + <object class="GtkAdjustment" id="adjustment_to_minutes"> + <property name="upper">59</property> + <property name="step_increment">1</property> + <property name="page_increment">10</property> + <signal name="value-changed" handler="dialog_time_to_value_changed_cb" object="CcNightLightPage" swapped="no" /> + </object> + <object class="GtkAdjustment" id="adjustment_color_temperature"> + <property name="lower">1700</property> + <property name="upper">4700</property> + <property name="step_increment">100</property> + <property name="page_increment">500</property> + <signal name="value-changed" handler="dialog_color_temperature_value_changed_cb" object="CcNightLightPage" swapped="no" /> + </object> +</interface> diff --git a/panels/display/display-arrangement.css b/panels/display/display-arrangement.css new file mode 100644 index 0000000..a3bc80b --- /dev/null +++ b/panels/display/display-arrangement.css @@ -0,0 +1,33 @@ +display-arrangement { + font-weight: bold; + font-size: larger; +} + +display-arrangement.monitor { + border: solid 1px @borders; + margin: 0px 0px 1px 1px; + background: @theme_bg_color; + padding: 0.4em; + border-radius: 5px; +} + +display-arrangement.monitor.primary { + border-top: 0.4em solid #000000; +} + +display-arrangement.monitor-label { + border-radius: 50%; + min-width: 1.5em; + min-height: 1.5em; + color: #000; + background: #ddd; +} + +label.monitor-label { + border-radius: 50%; + font-weight: bold; + min-width: 1.5em; + min-height: 1.5em; + color: #000; + background: #ddd; +} diff --git a/panels/display/display.gresource.xml b/panels/display/display.gresource.xml new file mode 100644 index 0000000..fcac1a2 --- /dev/null +++ b/panels/display/display.gresource.xml @@ -0,0 +1,10 @@ +<?xml version="1.0" encoding="UTF-8"?> +<gresources> + <gresource prefix="/org/gnome/control-center/display"> + <file preprocess="xml-stripblanks">cc-display-panel.ui</file> + <file preprocess="xml-stripblanks">cc-display-settings.ui</file> + <file preprocess="xml-stripblanks">cc-night-light-page.ui</file> + <file>display-arrangement.css</file> + <file>night-light.css</file> + </gresource> +</gresources> diff --git a/panels/display/gnome-display-panel.desktop.in.in b/panels/display/gnome-display-panel.desktop.in.in new file mode 100644 index 0000000..61f5ee7 --- /dev/null +++ b/panels/display/gnome-display-panel.desktop.in.in @@ -0,0 +1,18 @@ +[Desktop Entry] +Name=Displays +Comment=Choose how to use connected monitors and projectors +Exec=gnome-control-center display +# Translators: Do NOT translate or transliterate this text (this is an icon file name)! +Icon=org.gnome.Settings-display-symbolic +Terminal=false +Type=Application +NoDisplay=true +StartupNotify=true +Categories=GNOME;GTK;Settings;HardwareSettings;X-GNOME-Settings-Panel;X-GNOME-DevicesSettings; +OnlyShowIn=GNOME;Unity; +X-GNOME-Bugzilla-Bugzilla=GNOME +X-GNOME-Bugzilla-Product=gnome-control-center +X-GNOME-Bugzilla-Component=Screen resolution +X-GNOME-Bugzilla-Version=@VERSION@ +# Translators: Search terms to find the Displays panel. Do NOT translate or localize the semicolons! The list MUST also end with a semicolon! +Keywords=Panel;Projector;xrandr;Screen;Resolution;Refresh;Monitor;Night;Light;Blue;redshift;color;sunset;sunrise; diff --git a/panels/display/icons/meson.build b/panels/display/icons/meson.build new file mode 100644 index 0000000..91a313d --- /dev/null +++ b/panels/display/icons/meson.build @@ -0,0 +1,4 @@ +install_data( + 'scalable/org.gnome.Settings-display-symbolic.svg', + install_dir: join_paths(control_center_icondir, 'hicolor', 'scalable', 'apps') +) diff --git a/panels/display/icons/scalable/org.gnome.Settings-display-symbolic.svg b/panels/display/icons/scalable/org.gnome.Settings-display-symbolic.svg new file mode 100644 index 0000000..04f7a3b --- /dev/null +++ b/panels/display/icons/scalable/org.gnome.Settings-display-symbolic.svg @@ -0,0 +1,4 @@ +<?xml version="1.0" encoding="UTF-8"?> +<svg height="16px" viewBox="0 0 16 16" width="16px" xmlns="http://www.w3.org/2000/svg"> + <path d="m 12 1 c 1.660156 0 3 1.339844 3 3 v 6 c 0 1.660156 -1.339844 3 -3 3 h -8 c -1.660156 0 -3 -1.339844 -3 -3 v -6 c 0 -1.660156 1.339844 -3 3 -3 z m 0 2 h -8 c -0.554688 0 -1 0.445312 -1 1 v 6 c 0 0.554688 0.445312 1 1 1 h 8 c 0.554688 0 1 -0.445312 1 -1 v -6 c 0 -0.554688 -0.445312 -1 -1 -1 z m -4 11 c -5 0 -5 1 -5 1 c 0 1 1 1 1 1 h 8 c 1 0 1 -1 1 -1 s 0 -1 -5 -1 z m 0 0" fill="#2e3436"/> +</svg> diff --git a/panels/display/meson.build b/panels/display/meson.build new file mode 100644 index 0000000..726a898 --- /dev/null +++ b/panels/display/meson.build @@ -0,0 +1,64 @@ +panels_list += cappletname +desktop = 'gnome-@0@-panel.desktop'.format(cappletname) + +desktop_in = configure_file( + input: desktop + '.in.in', + output: desktop + '.in', + configuration: desktop_conf +) + +i18n.merge_file( + type: 'desktop', + input: desktop_in, + output: desktop, + po_dir: po_dir, + install: true, + install_dir: control_center_desktopdir +) + +sources = files( + 'cc-display-panel.c', + 'cc-display-arrangement.c', + 'cc-display-config.c', + 'cc-display-config-dbus.c', + 'cc-display-config-manager-dbus.c', + 'cc-display-config-manager.c', + 'cc-display-settings.c', + 'cc-night-light-page.c', +) + +resource_data = files( + 'cc-display-panel.ui', + 'cc-display-settings.ui', + 'cc-night-light-page.ui', +) + +sources += gnome.compile_resources( + 'cc-' + cappletname + '-resources', + cappletname + '.gresource.xml', + source_dir: ['.', 'icons'], + c_name: 'cc_' + cappletname, + dependencies: resource_data, + export: true +) + +deps = common_deps + [ + colord_dep, + gnome_rr_dep, + m_dep, + upower_glib_dep +] + +cflags += [ + '-DDATADIR="@0@"'.format(control_center_datadir) +] + +panels_libs += static_library( + cappletname, + sources: sources, + include_directories: [ top_inc, common_inc ], + dependencies: deps, + c_args: cflags +) + +subdir('icons') diff --git a/panels/display/night-light.css b/panels/display/night-light.css new file mode 100644 index 0000000..02c0a09 --- /dev/null +++ b/panels/display/night-light.css @@ -0,0 +1,28 @@ +/* color selection by Daniel Foré and elementary OS */ +@define-color ORANGE_100 #ffc27d; +@define-color ORANGE_500 #f37329; +@define-color base_color white; +@define-color bg_color shade(@base_color, 0.96); + +/* Hide the marks at the beginning and the end */ +.night-light-temperature mark indicator:nth-child(even) { + color:transparent; +} + +.night-light-temperature trough { + padding-top: 2px; + padding-bottom: 2px; + background-image: linear-gradient(to right, mix(@bg_color, @ORANGE_100, 0.5), @ORANGE_500); +} + +.night-light-temperature:dir(rtl) trough { + background-image: linear-gradient(to left, mix(@bg_color, @ORANGE_100, 0.5), @ORANGE_500); +} + +.padded-spinbutton { + min-width: 40px; +} + +.unpadded-button { + padding: 6px; +} |
