pax_global_header00006660000000000000000000000064135551313410014513gustar00rootroot0000000000000052 comment=22669edadb8ff3478bdb51ddc140ef6e61e3d9ef wdisplays-0+git20191201/000077500000000000000000000000001355513134100146325ustar00rootroot00000000000000wdisplays-0+git20191201/.gitignore000066400000000000000000000000101355513134100166110ustar00rootroot00000000000000/build/ wdisplays-0+git20191201/LICENSE000066400000000000000000000020161355513134100156360ustar00rootroot00000000000000Copyright (C) 2019 cyclopsian Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. wdisplays-0+git20191201/README.md000066400000000000000000000046001355513134100161110ustar00rootroot00000000000000# wdisplays [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://spdx.org/licenses/MIT.html) wdisplays is a graphical application for configuring displays in Wayland compositors. It borrows some code from [kanshi]. It should work in any compositor that implements the wlr-output-management-unstable-v1 protocol, including [sway]. The goal of this project is to allow precise adjustment of display settings in kiosks, digital signage, and other elaborate multi-monitor setups. ![Screenshot](wdisplays.png) # Building Build requirements are: - meson - GTK+3 - epoxy - wayland-client ```sh meson build ninja -C build sudo ninja -C build install ``` Binaries are not available. Only building from source is supported, and only if you're using wlroots compiled from master. # Usage Displays can be moved around the virtual screen space by clicking and dragging them in the preview on the left panel. By default, they will snap to one another. Hold Shift while dragging to disable snapping. You can click and drag with the middle mouse button to pan. Zoom in and out either with the buttons on the top left, or by holding Ctrl and scrolling the mouse wheel. Fine tune your adjustments in the right panel, then click apply. There are some options available by clicking the menu button on the top left: - Automatically Apply Changes: Makes it so you don't have to hit apply. Disable this for making minor adjustments, but be careful, you may end up with an unusable setup. - Show Screen Contents: Shows a live preview of the screens in the left panel. Turn off to reduce energy usage. - Overlay Screen Names: Shows big names in the corner of all screens for easy identification. Disable if they get in the way. # FAQ (Fervently Anticpiated Quandaries) ### What is this? It's intended to be the Wayland equivalent of an xrandr GUI, like [ARandR]. ### Help, I get errors and/or crashes! Make sure your wlroots is at version 0.7.0 or later. ### I'm using Sway, why aren't my display settings saved when I log out? Sway, like i3, doesn't save any settings unless you put them in the config file. See man `sway-output`. If you want to have multiple configurations depending on the monitors connected, you'll need to use an external program like [kanshi]. [kanshi]: https://github.com/emersion/kanshi [sway]: https://github.com/swaywm/sway [ARandR]: https://christian.amsuess.com/tools/arandr/ wdisplays-0+git20191201/meson.build000066400000000000000000000001201355513134100167650ustar00rootroot00000000000000project('wdisplays', 'c') subdir('protocol') subdir('resources') subdir('src') wdisplays-0+git20191201/protocol/000077500000000000000000000000001355513134100164735ustar00rootroot00000000000000wdisplays-0+git20191201/protocol/meson.build000066400000000000000000000023561355513134100206430ustar00rootroot00000000000000wayland_scanner = find_program('wayland-scanner') wayland_client = dependency('wayland-client') wayland_protos = dependency('wayland-protocols', version: '>=1.17') wl_protocol_dir = wayland_protos.get_pkgconfig_variable('pkgdatadir') wayland_scanner_code = generator( wayland_scanner, output: '@BASENAME@-protocol.c', arguments: ['private-code', '@INPUT@', '@OUTPUT@'], ) wayland_scanner_client = generator( wayland_scanner, output: '@BASENAME@-client-protocol.h', arguments: ['client-header', '@INPUT@', '@OUTPUT@'], ) client_protocols = [ [wl_protocol_dir, 'unstable/xdg-output/xdg-output-unstable-v1.xml'], [wl_protocol_dir, 'stable/xdg-shell/xdg-shell.xml'], ['wlr-output-management-unstable-v1.xml'], ['wlr-screencopy-unstable-v1.xml'], ['wlr-layer-shell-unstable-v1.xml'] ] client_protos_src = [] client_protos_headers = [] foreach p : client_protocols xml = join_paths(p) client_protos_src += wayland_scanner_code.process(xml) client_protos_headers += wayland_scanner_client.process(xml) endforeach lib_client_protos = static_library( 'client_protos', client_protos_src + client_protos_headers, dependencies: [wayland_client] ) client_protos = declare_dependency( link_with: lib_client_protos, sources: client_protos_headers, ) wdisplays-0+git20191201/protocol/wlr-layer-shell-unstable-v1.xml000066400000000000000000000320711355513134100244020ustar00rootroot00000000000000 Copyright © 2017 Drew DeVault Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of the copyright holders not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. The copyright holders make no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. Clients can use this interface to assign the surface_layer role to wl_surfaces. Such surfaces are assigned to a "layer" of the output and rendered with a defined z-depth respective to each other. They may also be anchored to the edges and corners of a screen and specify input handling semantics. This interface should be suitable for the implementation of many desktop shell components, and a broad number of other applications that interact with the desktop. Create a layer surface for an existing surface. This assigns the role of layer_surface, or raises a protocol error if another role is already assigned. Creating a layer surface from a wl_surface which has a buffer attached or committed is a client error, and any attempts by a client to attach or manipulate a buffer prior to the first layer_surface.configure call must also be treated as errors. You may pass NULL for output to allow the compositor to decide which output to use. Generally this will be the one that the user most recently interacted with. Clients can specify a namespace that defines the purpose of the layer surface. These values indicate which layers a surface can be rendered in. They are ordered by z depth, bottom-most first. Traditional shell surfaces will typically be rendered between the bottom and top layers. Fullscreen shell surfaces are typically rendered at the top layer. Multiple surfaces can share a single layer, and ordering within a single layer is undefined. An interface that may be implemented by a wl_surface, for surfaces that are designed to be rendered as a layer of a stacked desktop-like environment. Layer surface state (size, anchor, exclusive zone, margin, interactivity) is double-buffered, and will be applied at the time wl_surface.commit of the corresponding wl_surface is called. Sets the size of the surface in surface-local coordinates. The compositor will display the surface centered with respect to its anchors. If you pass 0 for either value, the compositor will assign it and inform you of the assignment in the configure event. You must set your anchor to opposite edges in the dimensions you omit; not doing so is a protocol error. Both values are 0 by default. Size is double-buffered, see wl_surface.commit. Requests that the compositor anchor the surface to the specified edges and corners. If two orthoginal edges are specified (e.g. 'top' and 'left'), then the anchor point will be the intersection of the edges (e.g. the top left corner of the output); otherwise the anchor point will be centered on that edge, or in the center if none is specified. Anchor is double-buffered, see wl_surface.commit. Requests that the compositor avoids occluding an area of the surface with other surfaces. The compositor's use of this information is implementation-dependent - do not assume that this region will not actually be occluded. A positive value is only meaningful if the surface is anchored to an edge, rather than a corner. The zone is the number of surface-local coordinates from the edge that are considered exclusive. Surfaces that do not wish to have an exclusive zone may instead specify how they should interact with surfaces that do. If set to zero, the surface indicates that it would like to be moved to avoid occluding surfaces with a positive excluzive zone. If set to -1, the surface indicates that it would not like to be moved to accommodate for other surfaces, and the compositor should extend it all the way to the edges it is anchored to. For example, a panel might set its exclusive zone to 10, so that maximized shell surfaces are not shown on top of it. A notification might set its exclusive zone to 0, so that it is moved to avoid occluding the panel, but shell surfaces are shown underneath it. A wallpaper or lock screen might set their exclusive zone to -1, so that they stretch below or over the panel. The default value is 0. Exclusive zone is double-buffered, see wl_surface.commit. Requests that the surface be placed some distance away from the anchor point on the output, in surface-local coordinates. Setting this value for edges you are not anchored to has no effect. The exclusive zone includes the margin. Margin is double-buffered, see wl_surface.commit. Set to 1 to request that the seat send keyboard events to this layer surface. For layers below the shell surface layer, the seat will use normal focus semantics. For layers above the shell surface layers, the seat will always give exclusive keyboard focus to the top-most layer which has keyboard interactivity set to true. Layer surfaces receive pointer, touch, and tablet events normally. If you do not want to receive them, set the input region on your surface to an empty region. Events is double-buffered, see wl_surface.commit. This assigns an xdg_popup's parent to this layer_surface. This popup should have been created via xdg_surface::get_popup with the parent set to NULL, and this request must be invoked before committing the popup's initial state. See the documentation of xdg_popup for more details about what an xdg_popup is and how it is used. When a configure event is received, if a client commits the surface in response to the configure event, then the client must make an ack_configure request sometime before the commit request, passing along the serial of the configure event. If the client receives multiple configure events before it can respond to one, it only has to ack the last configure event. A client is not required to commit immediately after sending an ack_configure request - it may even ack_configure several times before its next surface commit. A client may send multiple ack_configure requests before committing, but only the last request sent before a commit indicates which configure event the client really is responding to. This request destroys the layer surface. The configure event asks the client to resize its surface. Clients should arrange their surface for the new states, and then send an ack_configure request with the serial sent in this configure event at some point before committing the new surface. The client is free to dismiss all but the last configure event it received. The width and height arguments specify the size of the window in surface-local coordinates. The size is a hint, in the sense that the client is free to ignore it if it doesn't resize, pick a smaller size (to satisfy aspect ratio or resize in steps of NxM pixels). If the client picks a smaller size and is anchored to two opposite anchors (e.g. 'top' and 'bottom'), the surface will be centered on this axis. If the width or height arguments are zero, it means the client should decide its own window dimension. The closed event is sent by the compositor when the surface will no longer be shown. The output may have been destroyed or the user may have asked for it to be removed. Further changes to the surface will be ignored. The client should destroy the resource after receiving this event, and create a new surface if they so choose. wdisplays-0+git20191201/protocol/wlr-output-management-unstable-v1.xml000066400000000000000000000503571355513134100256420ustar00rootroot00000000000000 Copyright © 2019 Purism SPC Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of the copyright holders not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. The copyright holders make no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. This protocol exposes interfaces to obtain and modify output device configuration. Warning! The protocol described in this file is experimental and backward incompatible changes may be made. Backward compatible changes may be added together with the corresponding interface version bump. Backward incompatible changes are done by bumping the version number in the protocol and interface names and resetting the interface version. Once the protocol is to be declared stable, the 'z' prefix and the version number in the protocol and interface names are removed and the interface version number is reset. This interface is a manager that allows reading and writing the current output device configuration. Output devices that display pixels (e.g. a physical monitor or a virtual output in a window) are represented as heads. Heads cannot be created nor destroyed by the client, but they can be enabled or disabled and their properties can be changed. Each head may have one or more available modes. Whenever a head appears (e.g. a monitor is plugged in), it will be advertised via the head event. Immediately after the output manager is bound, all current heads are advertised. Whenever a head's properties change, the relevant wlr_output_head events will be sent. Not all head properties will be sent: only properties that have changed need to. Whenever a head disappears (e.g. a monitor is unplugged), a wlr_output_head.finished event will be sent. After one or more heads appear, change or disappear, the done event will be sent. It carries a serial which can be used in a create_configuration request to update heads properties. The information obtained from this protocol should only be used for output configuration purposes. This protocol is not designed to be a generic output property advertisement protocol for regular clients. Instead, protocols such as xdg-output should be used. This event introduces a new head. This happens whenever a new head appears (e.g. a monitor is plugged in) or after the output manager is bound. This event is sent after all information has been sent after binding to the output manager object and after any subsequent changes. This applies to child head and mode objects as well. In other words, this event is sent whenever a head or mode is created or destroyed and whenever one of their properties has been changed. Not all state is re-sent each time the current configuration changes: only the actual changes are sent. This allows changes to the output configuration to be seen as atomic, even if they happen via multiple events. A serial is sent to be used in a future create_configuration request. Create a new output configuration object. This allows to update head properties. Indicates the client no longer wishes to receive events for output configuration changes. However the compositor may emit further events, until the finished event is emitted. The client must not send any more requests after this one. This event indicates that the compositor is done sending manager events. The compositor will destroy the object immediately after sending this event, so it will become invalid and the client should release any resources associated with it. A head is an output device. The difference between a wl_output object and a head is that heads are advertised even if they are turned off. A head object only advertises properties and cannot be used directly to change them. A head has some read-only properties: modes, name, description and physical_size. These cannot be changed by clients. Other properties can be updated via a wlr_output_configuration object. Properties sent via this interface are applied atomically via the wlr_output_manager.done event. No guarantees are made regarding the order in which properties are sent. This event describes the head name. The naming convention is compositor defined, but limited to alphanumeric characters and dashes (-). Each name is unique among all wlr_output_head objects, but if a wlr_output_head object is destroyed the same name may be reused later. The names will also remain consistent across sessions with the same hardware and software configuration. Examples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do not assume that the name is a reflection of an underlying DRM connector, X11 connection, etc. If the compositor implements the xdg-output protocol and this head is enabled, the xdg_output.name event must report the same name. The name event is sent after a wlr_output_head object is created. This event is only sent once per object, and the name does not change over the lifetime of the wlr_output_head object. This event describes a human-readable description of the head. The description is a UTF-8 string with no convention defined for its contents. Examples might include 'Foocorp 11" Display' or 'Virtual X11 output via :1'. However, do not assume that the name is a reflection of the make, model, serial of the underlying DRM connector or the display name of the underlying X11 connection, etc. If the compositor implements xdg-output and this head is enabled, the xdg_output.description must report the same description. The description event is sent after a wlr_output_head object is created. This event is only sent once per object, and the description does not change over the lifetime of the wlr_output_head object. This event describes the physical size of the head. This event is only sent if the head has a physical size (e.g. is not a projector or a virtual device). This event introduces a mode for this head. It is sent once per supported mode. This event describes whether the head is enabled. A disabled head is not mapped to a region of the global compositor space. When a head is disabled, some properties (current_mode, position, transform and scale) are irrelevant. This event describes the mode currently in use for this head. It is only sent if the output is enabled. This events describes the position of the head in the global compositor space. It is only sent if the output is enabled. This event describes the transformation currently applied to the head. It is only sent if the output is enabled. This events describes the scale of the head in the global compositor space. It is only sent if the output is enabled. The compositor will destroy the object immediately after sending this event, so it will become invalid and the client should release any resources associated with it. This object describes an output mode. Some heads don't support output modes, in which case modes won't be advertised. Properties sent via this interface are applied atomically via the wlr_output_manager.done event. No guarantees are made regarding the order in which properties are sent. This event describes the mode size. The size is given in physical hardware units of the output device. This is not necessarily the same as the output size in the global compositor space. For instance, the output may be scaled or transformed. This event describes the mode's fixed vertical refresh rate. It is only sent if the mode has a fixed refresh rate. This event advertises this mode as preferred. The compositor will destroy the object immediately after sending this event, so it will become invalid and the client should release any resources associated with it. This object is used by the client to describe a full output configuration. First, the client needs to setup the output configuration. Each head can be either enabled (and configured) or disabled. It is a protocol error to send two enable_head or disable_head requests with the same head. It is a protocol error to omit a head in a configuration. Then, the client can apply or test the configuration. The compositor will then reply with a succeeded, failed or cancelled event. Finally the client should destroy the configuration object. Enable a head. This request creates a head configuration object that can be used to change the head's properties. Disable a head. Apply the new output configuration. In case the configuration is successfully applied, there is no guarantee that the new output state matches completely the requested configuration. For instance, a compositor might round the scale if it doesn't support fractional scaling. After this request has been sent, the compositor must respond with an succeeded, failed or cancelled event. Sending a request that isn't the destructor is a protocol error. Test the new output configuration. The configuration won't be applied, but will only be validated. Even if the compositor succeeds to test a configuration, applying it may fail. After this request has been sent, the compositor must respond with an succeeded, failed or cancelled event. Sending a request that isn't the destructor is a protocol error. Sent after the compositor has successfully applied the changes or tested them. Upon receiving this event, the client should destroy this object. If the current configuration has changed, events to describe the changes will be sent followed by a wlr_output_manager.done event. Sent if the compositor rejects the changes or failed to apply them. The compositor should revert any changes made by the apply request that triggered this event. Upon receiving this event, the client should destroy this object. Sent if the compositor cancels the configuration because the state of an output changed and the client has outdated information (e.g. after an output has been hotplugged). The client can create a new configuration with a newer serial and try again. Upon receiving this event, the client should destroy this object. Using this request a client can tell the compositor that it is not going to use the configuration object anymore. Any changes to the outputs that have not been applied will be discarded. This request also destroys wlr_output_configuration_head objects created via this object. This object is used by the client to update a single head's configuration. It is a protocol error to set the same property twice. This request sets the head's mode. This request assigns a custom mode to the head. The size is given in physical hardware units of the output device. If set to zero, the refresh rate is unspecified. It is a protocol error to set both a mode and a custom mode. This request sets the head's position in the global compositor space. This request sets the head's transform. This request sets the head's scale. wdisplays-0+git20191201/protocol/wlr-screencopy-unstable-v1.xml000066400000000000000000000167511355513134100243420ustar00rootroot00000000000000 Copyright © 2018 Simon Ser Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. This protocol allows clients to ask the compositor to copy part of the screen content to a client buffer. Warning! The protocol described in this file is experimental and backward incompatible changes may be made. Backward compatible changes may be added together with the corresponding interface version bump. Backward incompatible changes are done by bumping the version number in the protocol and interface names and resetting the interface version. Once the protocol is to be declared stable, the 'z' prefix and the version number in the protocol and interface names are removed and the interface version number is reset. This object is a manager which offers requests to start capturing from a source. Capture the next frame of an entire output. Capture the next frame of an output's region. The region is given in output logical coordinates, see xdg_output.logical_size. The region will be clipped to the output's extents. All objects created by the manager will still remain valid, until their appropriate destroy request has been called. This object represents a single frame. When created, a "buffer" event will be sent. The client will then be able to send a "copy" request. If the capture is successful, the compositor will send a "flags" followed by a "ready" event. If the capture failed, the "failed" event is sent. This can happen anytime before the "ready" event. Once either a "ready" or a "failed" event is received, the client should destroy the frame. Provides information about the frame's buffer. This event is sent once as soon as the frame is created. The client should then create a buffer with the provided attributes, and send a "copy" request. Copy the frame to the supplied buffer. The buffer must have a the correct size, see zwlr_screencopy_frame_v1.buffer. The buffer needs to have a supported format. If the frame is successfully copied, a "flags" and a "ready" events are sent. Otherwise, a "failed" event is sent. Provides flags about the frame. This event is sent once before the "ready" event. Called as soon as the frame is copied, indicating it is available for reading. This event includes the time at which presentation happened at. The timestamp is expressed as tv_sec_hi, tv_sec_lo, tv_nsec triples, each component being an unsigned 32-bit value. Whole seconds are in tv_sec which is a 64-bit value combined from tv_sec_hi and tv_sec_lo, and the additional fractional part in tv_nsec as nanoseconds. Hence, for valid timestamps tv_nsec must be in [0, 999999999]. The seconds part may have an arbitrary offset at start. After receiving this event, the client should destroy the object. This event indicates that the attempted frame copy has failed. After receiving this event, the client should destroy the object. Destroys the frame. This request can be sent at any time by the client. wdisplays-0+git20191201/resources/000077500000000000000000000000001355513134100166445ustar00rootroot00000000000000wdisplays-0+git20191201/resources/head.ui000066400000000000000000000453341355513134100201150ustar00rootroot00000000000000 16383 1 10 False True False 10 10 10 10 vertical 16383 1 10 16383 1 10 2147483.647 1 10 0.01 99999 0.1 0.5 16383 1 10 True False 8 8 8 8 8 16 True _Enabled True True False start True True 1 0 True False True word-char end 0 1 1 True True start 9 scale_adjustment 2 1 1 3 True False DPI _Scale True scale 1 0 3 True False _Position True pos_x 1 0 4 True False Description 1 0 1 True False True word-char end 0 1 2 True False Physical Size 1 0 2 True False Si_ze True width 1 0 5 True False start 8 True True 9 number refresh_adjustment 3 True if-valid False True 0 True False Hz False True 1 1 6 True False _Refresh Rate True 1 0 6 True True True transforms 1 7 True False _Transform True 1 0 7 _Flipped True True False start True True 1 8 True False 8 True True 6 0 number pos_x_adjustment True if-valid 0 0 True True 6 0 number pos_y_adjustment True if-valid 2 0 True True 4 0 number width_adjustment True if-valid 0 1 20 True False × 1 1 True True 4 0 number height_adjustment True if-valid 2 1 True True True Select Mode Preset 8 8 modes True False view-more-symbolic 3 1 1 4 2 False rotate_button True False 10 10 10 10 vertical True True True transform.rotate_0 Don't Rotate False True 0 True True True transform.rotate_90 Rotate 90° False True 1 True True True transform.rotate_180 Rotate 180° False True 2 True True True transform.rotate_270 Rotate 270° False True 3 wdisplays-0+git20191201/resources/meson.build000066400000000000000000000002411355513134100210030ustar00rootroot00000000000000 gnome = import('gnome') resources = gnome.compile_resources( 'waydisplay-resources', 'resources.xml', source_dir : '.', c_name : 'waydisplay_resources') wdisplays-0+git20191201/resources/resources.xml000066400000000000000000000004541355513134100214030ustar00rootroot00000000000000 wdisplays.ui head.ui style.css wdisplays-0+git20191201/resources/style.css000066400000000000000000000005651355513134100205240ustar00rootroot00000000000000spinner { opacity: 0; transition: opacity 200ms ease-in-out; background-color: rgba(64, 64, 64, 0.5); } spinner.visible { opacity: 1; } .output-overlay { font-size: 96px; background-color: @theme_selected_bg_color; color: @theme_selected_fg_color; border-radius: 8px; opacity: 0.9; padding: 8px; } .output-overlay .description { font-size: 12px; } wdisplays-0+git20191201/resources/wdisplays.ui000066400000000000000000000426741355513134100212370ustar00rootroot00000000000000 1 10 1 10 False True False 10 10 10 10 vertical True True True app.auto-apply _Automatically Apply Changes False True 0 True True True app.capture-screens Show Screen Contents False True 1 True True True app.show-overlay Overlay Screen Names False True 2 False wdisplays True False True False vertical False True start error True False False 6 end False False 0 False 16 True False True 0 True True 2 True True 0 False True 0 True True 400 True True True canvas_horiz canvas_vert 400 300 True False True False vertical True False center 8 8 8 8 8 True heads_stack False True 0 True False crossfade False True 1 False False True True 1 -1 True False True True True True True False crossfade True False wdisplays False True True False expand True True True Zoom Out True False zoom-out-symbolic True True 0 True True True True Zoom Reset True True 1 True True True True Zoom In True False zoom-in-symbolic True True 2 True True True True main_menu True False open-menu-symbolic end 1 title True False True False Apply Changes? _Apply True True True True end _Cancel True True True True 1 apply 1 wdisplays-0+git20191201/src/000077500000000000000000000000001355513134100154215ustar00rootroot00000000000000wdisplays-0+git20191201/src/glviewport.c000066400000000000000000000067521355513134100200010ustar00rootroot00000000000000/* SPDX-License-Identifier: MIT */ /* Copyright (C) 2019 cyclopsian */ #include "glviewport.h" typedef struct _WdGLViewportPrivate { GtkAdjustment *hadjustment; GtkAdjustment *vadjustment; guint hscroll_policy : 1; guint vscroll_policy : 1; } WdGLViewportPrivate; enum { PROP_0, PROP_HADJUSTMENT, PROP_VADJUSTMENT, PROP_HSCROLL_POLICY, PROP_VSCROLL_POLICY }; static void wd_gl_viewport_set_property( GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec); static void wd_gl_viewport_get_property( GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); G_DEFINE_TYPE_WITH_CODE(WdGLViewport, wd_gl_viewport, GTK_TYPE_GL_AREA, G_ADD_PRIVATE(WdGLViewport) G_IMPLEMENT_INTERFACE(GTK_TYPE_SCROLLABLE, NULL)) static void wd_gl_viewport_class_init(WdGLViewportClass *class) { GObjectClass *gobject_class = G_OBJECT_CLASS(class); gobject_class->set_property = wd_gl_viewport_set_property; gobject_class->get_property = wd_gl_viewport_get_property; g_object_class_override_property(gobject_class, PROP_HADJUSTMENT, "hadjustment"); g_object_class_override_property(gobject_class, PROP_VADJUSTMENT, "vadjustment"); g_object_class_override_property(gobject_class, PROP_HSCROLL_POLICY, "hscroll-policy"); g_object_class_override_property(gobject_class, PROP_VSCROLL_POLICY, "vscroll-policy"); } static void viewport_set_adjustment(GtkAdjustment *adjustment, GtkAdjustment **store) { if (!adjustment) { adjustment = gtk_adjustment_new(0., 0., 0., 0., 0., 0.); } if (adjustment != *store) { if (*store != NULL) { g_object_unref(*store); } *store = adjustment; g_object_ref_sink(adjustment); } } static void wd_gl_viewport_set_property( GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { WdGLViewport *viewport = WD_GL_VIEWPORT(object); WdGLViewportPrivate *priv = wd_gl_viewport_get_instance_private(viewport); switch (prop_id) { case PROP_HADJUSTMENT: viewport_set_adjustment(g_value_get_object(value), &priv->hadjustment); break; case PROP_VADJUSTMENT: viewport_set_adjustment(g_value_get_object(value), &priv->vadjustment); break; case PROP_HSCROLL_POLICY: if (priv->hscroll_policy != g_value_get_enum(value)) { priv->hscroll_policy = g_value_get_enum(value); g_object_notify_by_pspec(object, pspec); } break; case PROP_VSCROLL_POLICY: if (priv->vscroll_policy != g_value_get_enum(value)) { priv->vscroll_policy = g_value_get_enum(value); g_object_notify_by_pspec (object, pspec); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } } static void wd_gl_viewport_get_property( GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { WdGLViewport *viewport = WD_GL_VIEWPORT(object); WdGLViewportPrivate *priv = wd_gl_viewport_get_instance_private(viewport); switch (prop_id) { case PROP_HADJUSTMENT: g_value_set_object(value, priv->hadjustment); break; case PROP_VADJUSTMENT: g_value_set_object(value, priv->vadjustment); break; case PROP_HSCROLL_POLICY: g_value_set_enum(value, priv->hscroll_policy); break; case PROP_VSCROLL_POLICY: g_value_set_enum(value, priv->vscroll_policy); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } } static void wd_gl_viewport_init(WdGLViewport *viewport) { } GtkWidget *wd_gl_viewport_new(void) { return gtk_widget_new(WD_TYPE_GL_VIEWPORT, NULL); } wdisplays-0+git20191201/src/glviewport.h000066400000000000000000000006631355513134100200010ustar00rootroot00000000000000/* SPDX-License-Identifier: MIT */ /* Copyright (C) 2019 cyclopsian */ #ifndef WDISPLAY_GLVIEWPORT_H #define WDISPLAY_GLVIEWPORT_H #include G_BEGIN_DECLS #define WD_TYPE_GL_VIEWPORT (wd_gl_viewport_get_type()) G_DECLARE_DERIVABLE_TYPE( WdGLViewport, wd_gl_viewport, WD, GL_VIEWPORT,GtkGLArea) struct _WdGLViewportClass { GtkGLAreaClass parent_class; }; GtkWidget *wd_gl_viewport_new(void); G_END_DECLS #endif wdisplays-0+git20191201/src/main.c000066400000000000000000001601761355513134100165240ustar00rootroot00000000000000/* SPDX-License-Identifier: MIT */ /* Copyright (C) 2019 cyclopsian */ #include #include #include "wdisplays.h" #include "glviewport.h" __attribute__((noreturn)) void wd_fatal_error(int status, const char *message) { GtkWindow *parent = gtk_application_get_active_window(GTK_APPLICATION(g_application_get_default())); GtkWidget *dialog = gtk_message_dialog_new(parent, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", message); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); exit(status); } #define DEFAULT_ZOOM 0.1 #define MIN_ZOOM (1./1000.) #define MAX_ZOOM 1000. #define CANVAS_MARGIN 40 static const char *MODE_PREFIX = "mode"; static const char *TRANSFORM_PREFIX = "transform"; static const char *APP_PREFIX = "app"; #define NUM_ROTATIONS 4 static const char *ROTATE_IDS[NUM_ROTATIONS] = { "rotate_0", "rotate_90", "rotate_180", "rotate_270" }; static int get_rotate_index(enum wl_output_transform transform) { if (transform == WL_OUTPUT_TRANSFORM_90 || transform == WL_OUTPUT_TRANSFORM_FLIPPED_90) { return 1; } else if (transform == WL_OUTPUT_TRANSFORM_180 || transform == WL_OUTPUT_TRANSFORM_FLIPPED_180) { return 2; } else if (transform == WL_OUTPUT_TRANSFORM_270 || transform == WL_OUTPUT_TRANSFORM_FLIPPED_270) { return 3; } return 0; } static bool has_changes(const struct wd_state *state) { g_autoptr(GList) forms = gtk_container_get_children(GTK_CONTAINER(state->stack)); for (GList *form_iter = forms; form_iter != NULL; form_iter = form_iter->next) { GtkBuilder *builder = GTK_BUILDER(g_object_get_data(G_OBJECT(form_iter->data), "builder")); const struct wd_head *head = g_object_get_data(G_OBJECT(form_iter->data), "head"); if (head->enabled != gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "enabled")))) { return TRUE; } double old_scale = round(head->scale * 100.) / 100.; double new_scale = round(gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "scale"))) * 100.) / 100.; if (old_scale != new_scale) { return TRUE; } if (head->x != gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "pos_x")))) { return TRUE; } if (head->y != gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "pos_y")))) { return TRUE; } int w = head->mode != NULL ? head->mode->width : head->custom_mode.width; if (w != gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "width")))) { return TRUE; } int h = head->mode != NULL ? head->mode->height : head->custom_mode.height; if (h != gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "height")))) { return TRUE; } int r = head->mode != NULL ? head->mode->refresh : head->custom_mode.refresh; if (r / 1000. != gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "refresh")))) { return TRUE; } for (int i = 0; i < NUM_ROTATIONS; i++) { GtkWidget *rotate = GTK_WIDGET(gtk_builder_get_object(builder, ROTATE_IDS[i])); gboolean selected; g_object_get(rotate, "active", &selected, NULL); if (selected) { if (i != get_rotate_index(head->transform)) { return TRUE; } break; } } bool flipped = head->transform == WL_OUTPUT_TRANSFORM_FLIPPED || head->transform == WL_OUTPUT_TRANSFORM_FLIPPED_90 || head->transform == WL_OUTPUT_TRANSFORM_FLIPPED_180 || head->transform == WL_OUTPUT_TRANSFORM_FLIPPED_270; if (flipped != gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "flipped")))) { return TRUE; } } return FALSE; } void fill_output_from_form(struct wd_head_config *output, GtkWidget *form) { GtkBuilder *builder = GTK_BUILDER(g_object_get_data(G_OBJECT(form), "builder")); output->head = g_object_get_data(G_OBJECT(form), "head"); output->enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "enabled"))); output->scale = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "scale"))); output->x = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "pos_x"))); output->y = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "pos_y"))); output->width = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "width"))); output->height = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "height"))); output->refresh = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "refresh"))) * 1000.; gboolean flipped = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "flipped"))); for (int i = 0; i < NUM_ROTATIONS; i++) { GtkWidget *rotate = GTK_WIDGET(gtk_builder_get_object(builder, ROTATE_IDS[i])); gboolean selected; g_object_get(rotate, "active", &selected, NULL); if (selected) { switch (i) { case 0: output->transform = flipped ? WL_OUTPUT_TRANSFORM_FLIPPED : WL_OUTPUT_TRANSFORM_NORMAL; break; case 1: output->transform = flipped ? WL_OUTPUT_TRANSFORM_FLIPPED_90 : WL_OUTPUT_TRANSFORM_90; break; case 2: output->transform = flipped ? WL_OUTPUT_TRANSFORM_FLIPPED_180 : WL_OUTPUT_TRANSFORM_180; break; case 3: output->transform = flipped ? WL_OUTPUT_TRANSFORM_FLIPPED_270 : WL_OUTPUT_TRANSFORM_270; break; } break; } } } static gboolean send_apply(gpointer data) { struct wd_state *state = data; state->apply_idle = -1; struct wl_list *outputs = calloc(1, sizeof(*outputs)); wl_list_init(outputs); g_autoptr(GList) forms = gtk_container_get_children(GTK_CONTAINER(state->stack)); for (GList *form_iter = forms; form_iter != NULL; form_iter = form_iter->next) { struct wd_head_config *output = calloc(1, sizeof(*output)); wl_list_insert(outputs, &output->link); fill_output_from_form(output, GTK_WIDGET(form_iter->data)); } GdkWindow *window = gtk_widget_get_window(state->stack); GdkDisplay *display = gdk_window_get_display(window); struct wl_display *wl_display = gdk_wayland_display_get_wl_display(display); wd_apply_state(state, outputs, wl_display); state->apply_pending = FALSE; return FALSE; } static void apply_state(struct wd_state *state) { gtk_stack_set_visible_child_name(GTK_STACK(state->header_stack), "title"); if (!state->autoapply) { gtk_style_context_add_class(gtk_widget_get_style_context(state->spinner), "visible"); gtk_overlay_set_overlay_pass_through(GTK_OVERLAY(state->overlay), state->spinner, FALSE); gtk_spinner_start(GTK_SPINNER(state->spinner)); gtk_widget_set_sensitive(state->stack_switcher, FALSE); gtk_widget_set_sensitive(state->stack, FALSE); gtk_widget_set_sensitive(state->zoom_in, FALSE); gtk_widget_set_sensitive(state->zoom_reset, FALSE); gtk_widget_set_sensitive(state->zoom_out, FALSE); gtk_widget_set_sensitive(state->menu_button, FALSE); } /* queue this once per iteration in order to prevent duplicate updates */ if (!state->apply_pending) { state->apply_pending = TRUE; state->apply_idle = g_idle_add_full(G_PRIORITY_DEFAULT, send_apply, state, NULL); } } static gboolean apply_done_reset(gpointer data) { struct wd_state *state = data; state->reset_idle = -1; wd_ui_reset_all(state); return FALSE; } static void update_scroll_size(struct wd_state *state) { state->render.viewport_width = gtk_widget_get_allocated_width(state->canvas); state->render.viewport_height = gtk_widget_get_allocated_height(state->canvas); GtkAdjustment *scroll_x_adj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(state->scroller)); GtkAdjustment *scroll_y_adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(state->scroller)); int scroll_x_upper = state->render.width; int scroll_y_upper = state->render.height; gtk_adjustment_set_upper(scroll_x_adj, MAX(0, scroll_x_upper)); gtk_adjustment_set_upper(scroll_y_adj, MAX(0, scroll_y_upper)); gtk_adjustment_set_page_size(scroll_x_adj, state->render.viewport_width); gtk_adjustment_set_page_size(scroll_y_adj, state->render.viewport_height); gtk_adjustment_set_page_increment(scroll_x_adj, state->render.viewport_width); gtk_adjustment_set_page_increment(scroll_y_adj, state->render.viewport_height); gtk_adjustment_set_step_increment(scroll_x_adj, state->render.viewport_width / 10); gtk_adjustment_set_step_increment(scroll_y_adj, state->render.viewport_height / 10); double x = gtk_adjustment_get_value(scroll_x_adj); double y = gtk_adjustment_get_value(scroll_y_adj); gtk_adjustment_set_value(scroll_x_adj, MIN(x, scroll_x_upper)); gtk_adjustment_set_value(scroll_y_adj, MIN(y, scroll_y_upper)); } /* * Recalculates the desired canvas size, accounting for zoom + margins. */ static void update_canvas_size(struct wd_state *state) { int xmin = 0; int xmax = 0; int ymin = 0; int ymax = 0; g_autoptr(GList) forms = gtk_container_get_children(GTK_CONTAINER(state->stack)); for (GList *form_iter = forms; form_iter != NULL; form_iter = form_iter->next) { GtkBuilder *builder = GTK_BUILDER(g_object_get_data(G_OBJECT(form_iter->data), "builder")); gboolean enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "enabled"))); if (enabled) { int x1 = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "pos_x"))); int y1 = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "pos_y"))); int w = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "width"))); int h = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "height"))); int x2 = x1 + w; int y2 = y1 + w; double scale = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "scale"))); if (scale > 0.) { w /= scale; h /= scale; } xmin = MIN(xmin, x1); xmax = MAX(xmax, x2); ymin = MIN(ymin, y1); ymax = MAX(ymax, y2); } } // update canvas sizings state->render.x_origin = floor(xmin * state->zoom) - CANVAS_MARGIN; state->render.y_origin = floor(ymin * state->zoom) - CANVAS_MARGIN; state->render.width = ceil((xmax - xmin) * state->zoom) + CANVAS_MARGIN * 2; state->render.height = ceil((ymax - ymin) * state->zoom) + CANVAS_MARGIN * 2; update_scroll_size(state); } static void cache_scroll(struct wd_state *state) { GtkAdjustment *scroll_x_adj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(state->scroller)); GtkAdjustment *scroll_y_adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(state->scroller)); state->render.scroll_x = gtk_adjustment_get_value(scroll_x_adj); state->render.scroll_y = gtk_adjustment_get_value(scroll_y_adj); } static gboolean redraw_canvas(GtkWidget *widget, GdkFrameClock *frame_clock, gpointer data); static void update_tick_callback(struct wd_state *state) { bool any_animate = FALSE; struct wd_render_head_data *render; wl_list_for_each(render, &state->render.heads, link) { if (state->render.updated_at < render->hover_begin + HOVER_USECS || state->render.updated_at < render->click_begin + HOVER_USECS) { any_animate = TRUE; break; } } if (!any_animate && !state->capture) { if (state->canvas_tick != -1) { gtk_widget_remove_tick_callback(state->canvas, state->canvas_tick); state->canvas_tick = -1; } } else if (state->canvas_tick == -1) { state->canvas_tick = gtk_widget_add_tick_callback(state->canvas, redraw_canvas, state, NULL); } gtk_gl_area_queue_render(GTK_GL_AREA(state->canvas)); gtk_gl_area_set_auto_render(GTK_GL_AREA(state->canvas), state->capture); } static void update_cursor(struct wd_state *state) { bool any_hovered = FALSE; struct wd_head *head; wl_list_for_each(head, &state->heads, link) { struct wd_render_head_data *render = head->render; if (render != NULL && render->hovered) { any_hovered = TRUE; break; } } GdkWindow *window = gtk_widget_get_window(state->canvas); if (any_hovered) { gdk_window_set_cursor(window, state->grab_cursor); } else if (state->clicked != NULL) { gdk_window_set_cursor(window, state->grabbing_cursor); } else if (state->panning) { gdk_window_set_cursor(window, state->move_cursor); } else { gdk_window_set_cursor(window, NULL); } } static inline void flip_anim(uint64_t *timer, uint64_t tick) { uint64_t animate_end = *timer + HOVER_USECS; if (tick < animate_end) { *timer = tick - (animate_end - tick); } else { *timer = tick; } } static void update_hovered(struct wd_state *state) { GdkDisplay *display = gdk_display_get_default(); GdkWindow *window = gtk_widget_get_window(state->canvas); if (!gtk_widget_get_realized(state->canvas)) { return; } GdkFrameClock *clock = gtk_widget_get_frame_clock(state->canvas); uint64_t tick = gdk_frame_clock_get_frame_time(clock); g_autoptr(GList) seats = gdk_display_list_seats(display); bool any_hovered = FALSE; struct wd_render_head_data *render; wl_list_for_each(render, &state->render.heads, link) { bool init_hovered = render->hovered; render->hovered = FALSE; if (any_hovered) { continue; } if (state->clicked == render) { render->hovered = TRUE; any_hovered = TRUE; } else if (state->clicked == NULL) { for (GList *iter = seats; iter != NULL; iter = iter->next) { double mouse_x; double mouse_y; GdkDevice *pointer = gdk_seat_get_pointer(GDK_SEAT(iter->data)); gdk_window_get_device_position_double(window, pointer, &mouse_x, &mouse_y, NULL); if (mouse_x >= render->x1 && mouse_x < render->x2 && mouse_y >= render->y1 && mouse_y < render->y2) { render->hovered = TRUE; any_hovered = TRUE; break; } } } if (init_hovered != render->hovered) { flip_anim(&render->hover_begin, tick); } } update_cursor(state); update_tick_callback(state); } static inline void color_to_float_array(GtkStyleContext *ctx, const char *color_name, float out[4]) { GdkRGBA color; gtk_style_context_lookup_color(ctx, color_name, &color); out[0] = color.red; out[1] = color.green; out[2] = color.blue; out[3] = color.alpha; } static unsigned form_get_rotation(GtkWidget *form) { GtkBuilder *builder = GTK_BUILDER(g_object_get_data(G_OBJECT(form), "builder")); unsigned rot; for (rot = 0; rot < NUM_ROTATIONS; rot++) { GtkWidget *rotate = GTK_WIDGET(gtk_builder_get_object(builder, ROTATE_IDS[rot])); gboolean selected; g_object_get(rotate, "active", &selected, NULL); if (selected) { return rot; } } return -1; } #define SWAP(_type, _a, _b) { _type _tmp = (_a); (_a) = (_b); (_b) = _tmp; } static void queue_canvas_draw(struct wd_state *state) { GtkStyleContext *style_ctx = gtk_widget_get_style_context(state->canvas); color_to_float_array(style_ctx, "theme_fg_color", state->render.fg_color); color_to_float_array(style_ctx, "theme_bg_color", state->render.bg_color); color_to_float_array(style_ctx, "borders", state->render.border_color); color_to_float_array(style_ctx, "theme_selected_bg_color", state->render.selection_color); cache_scroll(state); g_autoptr(GList) forms = gtk_container_get_children(GTK_CONTAINER(state->stack)); for (GList *form_iter = forms; form_iter != NULL; form_iter = form_iter->next) { GtkBuilder *builder = GTK_BUILDER(g_object_get_data(G_OBJECT(form_iter->data), "builder")); gboolean enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "enabled"))); if (enabled) { int x = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "pos_x"))); int y = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "pos_y"))); int w = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "width"))); int h = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "height"))); double scale = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "scale"))); if (scale <= 0.) scale = 1.; struct wd_head *head = g_object_get_data(G_OBJECT(form_iter->data), "head"); if (head->render == NULL) { head->render = calloc(1, sizeof(*head->render)); wl_list_insert(&state->render.heads, &head->render->link); } struct wd_render_head_data *render = head->render; render->queued.rotation = form_get_rotation(GTK_WIDGET(form_iter->data)); if (render->queued.rotation & 1) { SWAP(int, w, h); } render->queued.x_invert = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "flipped"))); render->x1 = floor(x * state->zoom - state->render.scroll_x - state->render.x_origin); render->y1 = floor(y * state->zoom - state->render.scroll_y - state->render.y_origin); render->x2 = floor(render->x1 + w * state->zoom / scale); render->y2 = floor(render->y1 + h * state->zoom / scale); } } gtk_gl_area_queue_render(GTK_GL_AREA(state->canvas)); } // BEGIN FORM CALLBACKS static void show_apply(struct wd_state *state) { const gchar *page = "title"; if (has_changes(state)) { if (state->autoapply) { apply_state(state); } else { page = "apply"; } } gtk_stack_set_visible_child_name(GTK_STACK(state->header_stack), page); } static void update_ui(struct wd_state *state) { show_apply(state); update_canvas_size(state); queue_canvas_draw(state); } static void update_sensitivity(GtkWidget *form) { GtkBuilder *builder = GTK_BUILDER(g_object_get_data(G_OBJECT(form), "builder")); GtkWidget *enabled = GTK_WIDGET(gtk_builder_get_object(builder, "enabled")); bool enabled_toggled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(enabled)); g_autoptr(GList) children = gtk_container_get_children(GTK_CONTAINER(form)); for (GList *child = children; child != NULL; child = child->next) { GtkWidget *widget = GTK_WIDGET(child->data); if (widget != enabled) { gtk_widget_set_sensitive(widget, enabled_toggled); } } } static void select_rotate_option(GtkWidget *form, GtkWidget *model_button) { GtkBuilder *builder = GTK_BUILDER(g_object_get_data(G_OBJECT(form), "builder")); GtkWidget *rotate_button = GTK_WIDGET(gtk_builder_get_object(builder, "rotate_button")); for (int i = 0; i < NUM_ROTATIONS; i++) { GtkWidget *rotate = GTK_WIDGET(gtk_builder_get_object(builder, ROTATE_IDS[i])); gboolean selected = model_button == rotate; g_object_set(rotate, "active", selected, NULL); if (selected) { g_autofree gchar *rotate_text = NULL; g_object_get(rotate, "text", &rotate_text, NULL); gtk_button_set_label(GTK_BUTTON(rotate_button), rotate_text); } } } static void rotate_selected(GSimpleAction *action, GVariant *param, gpointer data) { select_rotate_option(GTK_WIDGET(data), g_object_get_data(G_OBJECT(action), "widget")); const struct wd_head *head = g_object_get_data(G_OBJECT(data), "head"); update_ui(head->state); } static void select_mode_option(GtkWidget *form, int32_t w, int32_t h, int32_t r) { GtkBuilder *builder = GTK_BUILDER(g_object_get_data(G_OBJECT(form), "builder")); GtkWidget *mode_box = GTK_WIDGET(gtk_builder_get_object(builder, "mode_box")); g_autoptr(GList) children = gtk_container_get_children(GTK_CONTAINER(mode_box)); for (GList *child = children; child != NULL; child = child->next) { const struct wd_mode *mode = g_object_get_data(G_OBJECT(child->data), "mode"); g_object_set(child->data, "active", w == mode->width && h == mode->height && r == mode->refresh, NULL); } } static void update_mode_entries(GtkWidget *form, int32_t w, int32_t h, int32_t r) { GtkBuilder *builder = GTK_BUILDER(g_object_get_data(G_OBJECT(form), "builder")); GtkWidget *width = GTK_WIDGET(gtk_builder_get_object(builder, "width")); GtkWidget *height = GTK_WIDGET(gtk_builder_get_object(builder, "height")); GtkWidget *refresh = GTK_WIDGET(gtk_builder_get_object(builder, "refresh")); gtk_spin_button_set_value(GTK_SPIN_BUTTON(width), w); gtk_spin_button_set_value(GTK_SPIN_BUTTON(height), h); gtk_spin_button_set_value(GTK_SPIN_BUTTON(refresh), r / 1000.); } static void mode_selected(GSimpleAction *action, GVariant *param, gpointer data) { GtkWidget *form = data; const struct wd_head *head = g_object_get_data(G_OBJECT(form), "head"); const struct wd_mode *mode = g_object_get_data(G_OBJECT(action), "mode"); update_mode_entries(form, mode->width, mode->height, mode->refresh); select_mode_option(form, mode->width, mode->height, mode->refresh); update_ui(head->state); } // END FORM CALLBACKS static void clear_menu(GtkWidget *box, GActionMap *action_map) { g_autoptr(GList) children = gtk_container_get_children(GTK_CONTAINER(box)); for (GList *child = children; child != NULL; child = child->next) { g_action_map_remove_action(action_map, strchr(gtk_actionable_get_action_name(GTK_ACTIONABLE(child->data)), '.') + 1); gtk_container_remove(GTK_CONTAINER(box), GTK_WIDGET(child->data)); } } static void update_head_form(GtkWidget *form, unsigned int fields) { GtkBuilder *builder = GTK_BUILDER(g_object_get_data(G_OBJECT(form), "builder")); GtkWidget *description = GTK_WIDGET(gtk_builder_get_object(builder, "description")); GtkWidget *physical_size = GTK_WIDGET(gtk_builder_get_object(builder, "physical_size")); GtkWidget *enabled = GTK_WIDGET(gtk_builder_get_object(builder, "enabled")); GtkWidget *scale = GTK_WIDGET(gtk_builder_get_object(builder, "scale")); GtkWidget *pos_x = GTK_WIDGET(gtk_builder_get_object(builder, "pos_x")); GtkWidget *pos_y = GTK_WIDGET(gtk_builder_get_object(builder, "pos_y")); GtkWidget *mode_box = GTK_WIDGET(gtk_builder_get_object(builder, "mode_box")); GtkWidget *flipped = GTK_WIDGET(gtk_builder_get_object(builder, "flipped")); const struct wd_head *head = g_object_get_data(G_OBJECT(form), "head"); if (fields & WD_FIELD_NAME) { gtk_container_child_set(GTK_CONTAINER(head->state->stack), form, "title", head->name, NULL); } if (fields & WD_FIELD_DESCRIPTION) { gtk_label_set_text(GTK_LABEL(description), head->description); } if (fields & WD_FIELD_PHYSICAL_SIZE) { g_autofree gchar *physical_str = g_strdup_printf("%dmm × %dmm", head->phys_width, head->phys_height); gtk_label_set_text(GTK_LABEL(physical_size), physical_str); } if (fields & WD_FIELD_ENABLED) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enabled), head->enabled); } if (fields & WD_FIELD_SCALE) { gtk_spin_button_set_value(GTK_SPIN_BUTTON(scale), head->scale); } if (fields & WD_FIELD_POSITION) { gtk_spin_button_set_value(GTK_SPIN_BUTTON(pos_x), head->x); gtk_spin_button_set_value(GTK_SPIN_BUTTON(pos_y), head->y); } if (fields & WD_FIELD_MODE) { GActionMap *mode_actions = G_ACTION_MAP(g_object_get_data(G_OBJECT(form), "mode-group")); clear_menu(mode_box, mode_actions); struct wd_mode *mode; wl_list_for_each(mode, &head->modes, link) { g_autofree gchar *name = g_strdup_printf("%d×%d@%0.3fHz", mode->width, mode->height, mode->refresh / 1000.); GSimpleAction *action = g_simple_action_new(name, NULL); g_action_map_add_action(G_ACTION_MAP(mode_actions), G_ACTION(action)); g_signal_connect(action, "activate", G_CALLBACK(mode_selected), form); g_object_set_data(G_OBJECT(action), "mode", mode); g_object_unref(action); GtkWidget *button = gtk_model_button_new(); g_autoptr(GString) prefixed_name = g_string_new(MODE_PREFIX); g_string_append(prefixed_name, "."); g_string_append(prefixed_name, name); gtk_actionable_set_action_name(GTK_ACTIONABLE(button), prefixed_name->str); g_object_set(button, "role", GTK_BUTTON_ROLE_RADIO, "text", name, NULL); gtk_box_pack_start(GTK_BOX(mode_box), button, FALSE, FALSE, 0); g_object_set_data(G_OBJECT(button), "mode", mode); gtk_widget_show_all(button); } // Mode entries int w = head->custom_mode.width; int h = head->custom_mode.height; int r = head->custom_mode.refresh; if (head->enabled && head->mode != NULL) { w = head->mode->width; h = head->mode->height; r = head->mode->refresh; } else if (!head->enabled && w == 0 && h == 0) { struct wd_mode *mode; wl_list_for_each(mode, &head->modes, link) { if (mode->preferred) { w = mode->width; h = mode->height; r = mode->refresh; break; } } } update_mode_entries(form, w, h, r); select_mode_option(form, w, h, r); gtk_widget_show_all(mode_box); } if (fields & WD_FIELD_TRANSFORM) { int active_rotate = get_rotate_index(head->transform); select_rotate_option(form, GTK_WIDGET(gtk_builder_get_object(builder, ROTATE_IDS[active_rotate]))); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(flipped), head->transform == WL_OUTPUT_TRANSFORM_FLIPPED || head->transform == WL_OUTPUT_TRANSFORM_FLIPPED_90 || head->transform == WL_OUTPUT_TRANSFORM_FLIPPED_180 || head->transform == WL_OUTPUT_TRANSFORM_FLIPPED_270); } // Sync state if (fields & WD_FIELD_ENABLED) { update_sensitivity(form); } update_ui(head->state); } void wd_ui_reset_heads(struct wd_state *state) { if (state->stack == NULL) { return; } g_autoptr(GList) forms = gtk_container_get_children(GTK_CONTAINER(state->stack)); GList *form_iter = forms; struct wd_head *head; int i = 0; wl_list_for_each(head, &state->heads, link) { GtkBuilder *builder; GtkWidget *form; if (form_iter == NULL) { builder = gtk_builder_new_from_resource("/head.ui"); form = GTK_WIDGET(gtk_builder_get_object(builder, "form")); g_object_set_data(G_OBJECT(form), "builder", builder); g_object_set_data(G_OBJECT(form), "head", head); g_autofree gchar *page_name = g_strdup_printf("%d", i); gtk_stack_add_titled(GTK_STACK(state->stack), form, page_name, head->name); GtkWidget *mode_button = GTK_WIDGET(gtk_builder_get_object(builder, "mode_button")); GtkWidget *rotate_button = GTK_WIDGET(gtk_builder_get_object(builder, "rotate_button")); GSimpleActionGroup *mode_actions = g_simple_action_group_new(); gtk_widget_insert_action_group(mode_button, MODE_PREFIX, G_ACTION_GROUP(mode_actions)); g_object_set_data(G_OBJECT(form), "mode-group", mode_actions); g_object_unref(mode_actions); GSimpleActionGroup *transform_actions = g_simple_action_group_new(); gtk_widget_insert_action_group(rotate_button, TRANSFORM_PREFIX, G_ACTION_GROUP(transform_actions)); g_object_unref(transform_actions); for (int i = 0; i < NUM_ROTATIONS; i++) { GtkWidget *button = GTK_WIDGET(gtk_builder_get_object(builder, ROTATE_IDS[i])); g_object_set(button, "role", GTK_BUTTON_ROLE_RADIO, NULL); GSimpleAction *action = g_simple_action_new(ROTATE_IDS[i], NULL); g_action_map_add_action(G_ACTION_MAP(transform_actions), G_ACTION(action)); g_signal_connect(action, "activate", G_CALLBACK(rotate_selected), form); g_object_set_data(G_OBJECT(action), "widget", button); g_object_unref(action); } update_head_form(form, WD_FIELDS_ALL); gtk_widget_show_all(form); g_signal_connect_swapped(gtk_builder_get_object(builder, "enabled"), "toggled", G_CALLBACK(update_sensitivity), form); g_signal_connect_swapped(gtk_builder_get_object(builder, "enabled"), "toggled", G_CALLBACK(update_ui), state); g_signal_connect_swapped(gtk_builder_get_object(builder, "scale"), "value-changed", G_CALLBACK(update_ui), state); g_signal_connect_swapped(gtk_builder_get_object(builder, "pos_x"), "value-changed", G_CALLBACK(update_ui), state); g_signal_connect_swapped(gtk_builder_get_object(builder, "pos_y"), "value-changed", G_CALLBACK(update_ui), state); g_signal_connect_swapped(gtk_builder_get_object(builder, "width"), "value-changed", G_CALLBACK(update_ui), state); g_signal_connect_swapped(gtk_builder_get_object(builder, "height"), "value-changed", G_CALLBACK(update_ui), state); g_signal_connect_swapped(gtk_builder_get_object(builder, "refresh"), "value-changed", G_CALLBACK(update_ui), state); g_signal_connect_swapped(gtk_builder_get_object(builder, "flipped"), "toggled", G_CALLBACK(update_ui), state); } else { form = form_iter->data; if (head != g_object_get_data(G_OBJECT(form), "head")) { g_object_set_data(G_OBJECT(form), "head", head); update_head_form(form, WD_FIELDS_ALL); } form_iter = form_iter->next; } i++; } // remove everything else for (; form_iter != NULL; form_iter = form_iter->next) { GtkBuilder *builder = GTK_BUILDER(g_object_get_data(G_OBJECT(form_iter->data), "builder")); g_object_unref(builder); gtk_container_remove(GTK_CONTAINER(state->stack), GTK_WIDGET(form_iter->data)); } update_canvas_size(state); queue_canvas_draw(state); } void wd_ui_reset_head(const struct wd_head *head, unsigned int fields) { if (head->state->stack == NULL) { return; } g_autoptr(GList) forms = gtk_container_get_children(GTK_CONTAINER(head->state->stack)); for (GList *form_iter = forms; form_iter != NULL; form_iter = form_iter->next) { const struct wd_head *other = g_object_get_data(G_OBJECT(form_iter->data), "head"); if (head == other) { update_head_form(GTK_WIDGET(form_iter->data), fields); break; } } update_canvas_size(head->state); queue_canvas_draw(head->state); } void wd_ui_reset_all(struct wd_state *state) { wd_ui_reset_heads(state); g_autoptr(GList) forms = gtk_container_get_children(GTK_CONTAINER(state->stack)); for (GList *form_iter = forms; form_iter != NULL; form_iter = form_iter->next) { update_head_form(GTK_WIDGET(form_iter->data), WD_FIELDS_ALL); } update_canvas_size(state); queue_canvas_draw(state); } void wd_ui_apply_done(struct wd_state *state, struct wl_list *outputs) { gtk_style_context_remove_class(gtk_widget_get_style_context(state->spinner), "visible"); gtk_overlay_set_overlay_pass_through(GTK_OVERLAY(state->overlay), state->spinner, TRUE); gtk_spinner_stop(GTK_SPINNER(state->spinner)); gtk_widget_set_sensitive(state->stack_switcher, TRUE); gtk_widget_set_sensitive(state->stack, TRUE); gtk_widget_set_sensitive(state->zoom_in, TRUE); gtk_widget_set_sensitive(state->zoom_reset, TRUE); gtk_widget_set_sensitive(state->zoom_out, TRUE); gtk_widget_set_sensitive(state->menu_button, TRUE); if (!state->autoapply) { show_apply(state); } state->reset_idle = g_idle_add_full(G_PRIORITY_DEFAULT, apply_done_reset, state, NULL); } void wd_ui_show_error(struct wd_state *state, const char *message) { gtk_label_set_text(GTK_LABEL(state->info_label), message); gtk_widget_show(state->info_bar); gtk_info_bar_set_revealed(GTK_INFO_BAR(state->info_bar), TRUE); } // BEGIN GLOBAL CALLBACKS static void cleanup(GtkWidget *window, gpointer data) { struct wd_state *state = data; if (state->reset_idle != -1) g_source_remove(state->reset_idle); if (state->apply_idle != -1) g_source_remove(state->apply_idle); g_object_unref(state->grab_cursor); g_object_unref(state->grabbing_cursor); g_object_unref(state->move_cursor); wd_state_destroy(state); } static void monitor_added(GdkDisplay *display, GdkMonitor *monitor, gpointer data) { struct wl_display *wl_display = gdk_wayland_display_get_wl_display(display); wd_add_output(data, gdk_wayland_monitor_get_wl_output(monitor), wl_display); } static void monitor_removed(GdkDisplay *display, GdkMonitor *monitor, gpointer data) { struct wl_display *wl_display = gdk_wayland_display_get_wl_display(display); wd_remove_output(data, gdk_wayland_monitor_get_wl_output(monitor), wl_display); } static void canvas_realize(GtkWidget *widget, gpointer data) { gtk_gl_area_make_current(GTK_GL_AREA(widget)); if (gtk_gl_area_get_error(GTK_GL_AREA(widget)) != NULL) { return; } struct wd_state *state = data; state->gl_data = wd_gl_setup(); } static inline bool size_changed(const struct wd_render_head_data *render) { return render->x2 - render->x1 != render->tex_width || render->y2 - render->y1 != render->tex_height; } static inline void cairo_set_source_color(cairo_t *cr, float color[4]) { cairo_set_source_rgba(cr, color[0], color[1], color[2], color[3]); } static void update_zoom(struct wd_state *state) { g_autofree gchar *zoom_percent = g_strdup_printf("%.f%%", state->zoom * 100.); gtk_button_set_label(GTK_BUTTON(state->zoom_reset), zoom_percent); gtk_widget_set_sensitive(state->zoom_in, state->zoom < MAX_ZOOM); gtk_widget_set_sensitive(state->zoom_out, state->zoom > MIN_ZOOM); update_canvas_size(state); queue_canvas_draw(state); } static void zoom_to(struct wd_state *state, double zoom) { state->zoom = zoom; state->zoom = MAX(state->zoom, MIN_ZOOM); state->zoom = MIN(state->zoom, MAX_ZOOM); update_zoom(state); } static void zoom_out(struct wd_state *state) { zoom_to(state, state->zoom * 0.75); } static void zoom_reset(struct wd_state *state) { zoom_to(state, DEFAULT_ZOOM); } static void zoom_in(struct wd_state *state) { zoom_to(state, state->zoom / 0.75); } #define TEXT_MARGIN 5 static cairo_surface_t *draw_head(PangoContext *pango, struct wd_render_data *info, const char *name, unsigned width, unsigned height) { cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height); cairo_t *cr = cairo_create(surface); cairo_rectangle(cr, 0., 0., width, height); cairo_set_source_color(cr, info->border_color); cairo_fill(cr); PangoLayout *layout = pango_layout_new(pango); pango_layout_set_text(layout, name, -1); int text_width = pango_units_from_double(width - TEXT_MARGIN * 2); int text_height = pango_units_from_double(height - TEXT_MARGIN * 2); pango_layout_set_width(layout, MAX(text_width, 0)); pango_layout_set_height(layout, MAX(text_height, 0)); pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR); pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END); pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER); cairo_set_source_color(cr, info->fg_color); pango_layout_get_size(layout, &text_width, &text_height); cairo_move_to(cr, TEXT_MARGIN, (height - PANGO_PIXELS(text_height)) / 2); pango_cairo_show_layout(cr, layout); g_object_unref(layout); cairo_destroy(cr); cairo_surface_flush(surface); return surface; } static void canvas_render(GtkGLArea *area, GdkGLContext *context, gpointer data) { struct wd_state *state = data; PangoContext *pango = gtk_widget_get_pango_context(state->canvas); GdkFrameClock *clock = gtk_widget_get_frame_clock(state->canvas); uint64_t tick = gdk_frame_clock_get_frame_time(clock); wd_capture_frame(state); struct wd_head *head; wl_list_for_each(head, &state->heads, link) { struct wd_render_head_data *render = head->render; struct wd_output *output = wd_find_output(state, head); struct wd_frame *frame = NULL; if (output != NULL && !wl_list_empty(&output->frames)) { frame = wl_container_of(output->frames.prev, frame, link); } if (render != NULL) { if (state->capture && frame != NULL && frame->pixels != NULL) { if (frame->tick > render->updated_at) { render->tex_stride = frame->stride; render->tex_width = frame->width; render->tex_height = frame->height; render->pixels = frame->pixels; render->preview = TRUE; render->updated_at = tick; render->y_invert = frame->y_invert; render->swap_rgb = frame->swap_rgb; } if (render->preview) { render->active.rotation = render->queued.rotation; render->active.x_invert = render->queued.x_invert; } } else if (render->preview || render->pixels == NULL || size_changed(render)) { render->tex_width = render->x2 - render->x1; render->tex_height = render->y2 - render->y1; render->preview = FALSE; if (head->surface != NULL) { cairo_surface_destroy(head->surface); } head->surface = draw_head(pango, &state->render, head->name, render->tex_width, render->tex_height); render->pixels = cairo_image_surface_get_data(head->surface); render->tex_stride = cairo_image_surface_get_stride(head->surface); render->updated_at = tick; render->active.rotation = 0; render->active.x_invert = FALSE; render->y_invert = FALSE; render->swap_rgb = FALSE; } } } wd_gl_render(state->gl_data, &state->render, tick); state->render.updated_at = tick; } static void canvas_unrealize(GtkWidget *widget, gpointer data) { gtk_gl_area_make_current(GTK_GL_AREA(widget)); if (gtk_gl_area_get_error(GTK_GL_AREA(widget)) != NULL) { return; } struct wd_state *state = data; GdkDisplay *gdk_display = gdk_display_get_default(); struct wl_display *display = gdk_wayland_display_get_wl_display(gdk_display); wd_capture_wait(state, display); wd_gl_cleanup(state->gl_data); state->gl_data = NULL; } static void set_clicked_head(struct wd_state *state, struct wd_render_head_data *clicked) { GdkFrameClock *clock = gtk_widget_get_frame_clock(state->canvas); uint64_t tick = gdk_frame_clock_get_frame_time(clock); if (clicked != state->clicked) { if (state->clicked != NULL) { state->clicked->clicked = FALSE; flip_anim(&state->clicked->click_begin, tick); } if (clicked != NULL) { clicked->clicked = TRUE; flip_anim(&clicked->click_begin, tick); } update_tick_callback(state); } state->clicked = clicked; } static gboolean canvas_click(GtkWidget *widget, GdkEvent *event, gpointer data) { struct wd_state *state = data; if (event->button.type == GDK_BUTTON_PRESS) { if (event->button.button == 1) { struct wd_render_head_data *render; state->clicked = NULL; wl_list_for_each(render, &state->render.heads, link) { double mouse_x = event->button.x; double mouse_y = event->button.y; if (mouse_x >= render->x1 && mouse_x < render->x2 && mouse_y >= render->y1 && mouse_y < render->y2) { set_clicked_head(state, render); state->click_offset.x = event->button.x - render->x1; state->click_offset.y = event->button.y - render->y1; break; } } if (state->clicked != NULL) { wl_list_remove(&state->clicked->link); wl_list_insert(&state->render.heads, &state->clicked->link); struct wd_render_head_data *render; wl_list_for_each(render, &state->render.heads, link) { render->updated_at = 0; render->preview = TRUE; } gtk_gl_area_queue_render(GTK_GL_AREA(state->canvas)); g_autoptr(GList) forms = gtk_container_get_children(GTK_CONTAINER(state->stack)); for (GList *form_iter = forms; form_iter != NULL; form_iter = form_iter->next) { const struct wd_head *other = g_object_get_data(G_OBJECT(form_iter->data), "head"); if (state->clicked == other->render) { gtk_stack_set_visible_child(GTK_STACK(state->stack), form_iter->data); break; } } } } else if (event->button.button == 2) { state->panning = TRUE; state->pan_last.x = event->button.x; state->pan_last.y = event->button.y; } } return TRUE; } static gboolean canvas_release(GtkWidget *widget, GdkEvent *event, gpointer data) { struct wd_state *state = data; if (event->button.button == 1) { set_clicked_head(state, NULL); } if (event->button.button == 2) { state->panning = FALSE; } update_cursor(state); return TRUE; } #define SNAP_DIST 6. static gboolean canvas_motion(GtkWidget *widget, GdkEvent *event, gpointer data) { struct wd_state *state = data; if (event->motion.state & GDK_BUTTON2_MASK) { GtkAdjustment *xadj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(state->scroller)); GtkAdjustment *yadj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(state->scroller)); double delta_x = event->motion.x - state->pan_last.x; double delta_y = event->motion.y - state->pan_last.y; gtk_adjustment_set_value(xadj, gtk_adjustment_get_value(xadj) + delta_x); gtk_adjustment_set_value(yadj, gtk_adjustment_get_value(yadj) + delta_y); state->pan_last.x = event->motion.x; state->pan_last.y = event->motion.y; queue_canvas_draw(state); } if ((event->motion.state & GDK_BUTTON1_MASK) && state->clicked != NULL) { GtkWidget *form = NULL; g_autoptr(GList) forms = gtk_container_get_children(GTK_CONTAINER(state->stack)); for (GList *form_iter = forms; form_iter != NULL; form_iter = form_iter->next) { const struct wd_head *other = g_object_get_data(G_OBJECT(form_iter->data), "head"); if (state->clicked == other->render) { form = form_iter->data; break; } } if (form != NULL) { GtkBuilder *builder = GTK_BUILDER(g_object_get_data(G_OBJECT(form), "builder")); struct wd_point size = { .x = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "width"))), .y = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "height"))), }; double scale = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "scale"))); if (scale > 0.) { size.x /= scale; size.y /= scale; } unsigned rot = form_get_rotation(form); if (rot & 1) { SWAP(int, size.x, size.y); } struct wd_point tl = { .x = (event->motion.x - state->click_offset.x + state->render.x_origin + state->render.scroll_x) / state->zoom, .y = (event->motion.y - state->click_offset.y + state->render.y_origin + state->render.scroll_y) / state->zoom }; const struct wd_point br = { .x = tl.x + size.x, .y = tl.y + size.y }; struct wd_point new_pos = tl; float snap = SNAP_DIST / state->zoom; for (GList *form_iter = forms; form_iter != NULL; form_iter = form_iter->next) { const struct wd_head *other = g_object_get_data(G_OBJECT(form_iter->data), "head"); if (other->render != state->clicked && !(event->motion.state & GDK_SHIFT_MASK)) { GtkBuilder *other_builder = GTK_BUILDER(g_object_get_data(G_OBJECT(form_iter->data), "builder")); double x1 = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(other_builder, "pos_x"))); double y1 = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(other_builder, "pos_y"))); double w = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(other_builder, "width"))); double h = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(other_builder, "height"))); scale = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(other_builder, "scale"))); if (scale > 0.) { w /= scale; h /= scale; } rot = form_get_rotation(GTK_WIDGET(form_iter->data)); if (rot & 1) { SWAP(int, w, h); } double x2 = x1 + w; double y2 = y1 + h; if (fabs(br.x) <= snap) new_pos.x = -size.x; if (fabs(br.y) <= snap) new_pos.y = -size.y; if (fabs(br.x - x1) <= snap) new_pos.x = x1 - size.x; if (fabs(br.x - x2) <= snap) new_pos.x = x2 - size.x; if (fabs(br.y - y1) <= snap) new_pos.y = y1 - size.y; if (fabs(br.y - y2) <= snap) new_pos.y = y2 - size.y; if (fabs(tl.x) <= snap) new_pos.x = 0.; if (fabs(tl.y) <= snap) new_pos.y = 0.; if (fabs(tl.x - x1) <= snap) new_pos.x = x1; if (fabs(tl.x - x2) <= snap) new_pos.x = x2; if (fabs(tl.y - y1) <= snap) new_pos.y = y1; if (fabs(tl.y - y2) <= snap) new_pos.y = y2; } } GtkWidget *pos_x = GTK_WIDGET(gtk_builder_get_object(builder, "pos_x")); GtkWidget *pos_y = GTK_WIDGET(gtk_builder_get_object(builder, "pos_y")); gtk_spin_button_set_value(GTK_SPIN_BUTTON(pos_x), new_pos.x); gtk_spin_button_set_value(GTK_SPIN_BUTTON(pos_y), new_pos.y); } } update_hovered(state); return TRUE; } static gboolean canvas_enter(GtkWidget *widget, GdkEvent *event, gpointer data) { struct wd_state *state = data; if (!(event->crossing.state & GDK_BUTTON1_MASK)) { set_clicked_head(state, NULL); } if (!(event->crossing.state & GDK_BUTTON2_MASK)) { state->panning = FALSE; } update_cursor(state); return TRUE; } static gboolean canvas_leave(GtkWidget *widget, GdkEvent *event, gpointer data) { struct wd_state *state = data; struct wd_render_head_data *render; wl_list_for_each(render, &state->render.heads, link) { render->hovered = FALSE; } update_tick_callback(state); return TRUE; } static gboolean canvas_scroll(GtkWidget *widget, GdkEvent *event, gpointer data) { struct wd_state *state = data; if (event->scroll.state & GDK_CONTROL_MASK) { switch (event->scroll.direction) { case GDK_SCROLL_UP: zoom_in(state); break; case GDK_SCROLL_DOWN: zoom_out(state); break; case GDK_SCROLL_SMOOTH: if (event->scroll.delta_y) zoom_to(state, state->zoom * pow(0.75, event->scroll.delta_y)); break; default: break; } } else { GtkAdjustment *xadj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(state->scroller)); GtkAdjustment *yadj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(state->scroller)); double xstep = gtk_adjustment_get_step_increment(xadj); double ystep = gtk_adjustment_get_step_increment(yadj); switch (event->scroll.direction) { case GDK_SCROLL_UP: gtk_adjustment_set_value(yadj, gtk_adjustment_get_value(yadj) - ystep); break; case GDK_SCROLL_DOWN: gtk_adjustment_set_value(yadj, gtk_adjustment_get_value(yadj) + ystep); break; case GDK_SCROLL_LEFT: gtk_adjustment_set_value(xadj, gtk_adjustment_get_value(xadj) - xstep); break; case GDK_SCROLL_RIGHT: gtk_adjustment_set_value(xadj, gtk_adjustment_get_value(xadj) + xstep); break; case GDK_SCROLL_SMOOTH: if (event->scroll.delta_x) gtk_adjustment_set_value(xadj, gtk_adjustment_get_value(xadj) + xstep * event->scroll.delta_x); if (event->scroll.delta_y) gtk_adjustment_set_value(yadj, gtk_adjustment_get_value(yadj) + ystep * event->scroll.delta_y); break; default: break; } } return FALSE; } static void canvas_resize(GtkWidget *widget, GdkRectangle *allocation, gpointer data) { struct wd_state *state = data; update_scroll_size(state); } static void cancel_changes(GtkButton *button, gpointer data) { struct wd_state *state = data; gtk_stack_set_visible_child_name(GTK_STACK(state->header_stack), "title"); wd_ui_reset_all(state); } static void apply_changes(GtkButton *button, gpointer data) { apply_state(data); } static void info_response(GtkInfoBar *info_bar, gint response_id, gpointer data) { gtk_info_bar_set_revealed(info_bar, FALSE); } static void info_bar_animation_done(GObject *object, GParamSpec *pspec, gpointer data) { gboolean done = gtk_revealer_get_child_revealed(GTK_REVEALER(object)); if (!done) { struct wd_state *state = data; gtk_widget_set_visible(state->info_bar, gtk_revealer_get_reveal_child(GTK_REVEALER(object))); } } static void auto_apply_selected(GSimpleAction *action, GVariant *param, gpointer data) { struct wd_state *state = data; state->autoapply = !state->autoapply; g_simple_action_set_state(action, g_variant_new_boolean(state->autoapply)); } static gboolean redraw_canvas(GtkWidget *widget, GdkFrameClock *frame_clock, gpointer data) { struct wd_state *state = data; if (state->capture) { wd_capture_frame(state); } update_tick_callback(state); queue_canvas_draw(state); return G_SOURCE_CONTINUE; } static void capture_selected(GSimpleAction *action, GVariant *param, gpointer data) { struct wd_state *state = data; state->capture = !state->capture; g_simple_action_set_state(action, g_variant_new_boolean(state->capture)); update_tick_callback(state); } static void overlay_selected(GSimpleAction *action, GVariant *param, gpointer data) { struct wd_state *state = data; state->show_overlay = !state->show_overlay; g_simple_action_set_state(action, g_variant_new_boolean(state->show_overlay)); struct wd_output *output; wl_list_for_each(output, &state->outputs, link) { if (state->show_overlay) { wd_create_overlay(output); } else { wd_destroy_overlay(output); } } } static void activate(GtkApplication* app, gpointer user_data) { GdkDisplay *gdk_display = gdk_display_get_default(); if (!GDK_IS_WAYLAND_DISPLAY(gdk_display)) { wd_fatal_error(1, "This program is only usable on Wayland sessions."); } struct wd_state *state = wd_state_create(); state->zoom = DEFAULT_ZOOM; state->canvas_tick = -1; state->apply_idle = -1; state->reset_idle = -1; GtkCssProvider *css_provider = gtk_css_provider_new(); gtk_css_provider_load_from_resource(css_provider, "/style.css"); gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(css_provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); state->grab_cursor = gdk_cursor_new_from_name(gdk_display, "grab"); state->grabbing_cursor = gdk_cursor_new_from_name(gdk_display, "grabbing"); state->move_cursor = gdk_cursor_new_from_name(gdk_display, "move"); GtkBuilder *builder = gtk_builder_new_from_resource("/wdisplays.ui"); GtkWidget *window = GTK_WIDGET(gtk_builder_get_object(builder, "heads_window")); state->header_stack = GTK_WIDGET(gtk_builder_get_object(builder, "header_stack")); state->stack_switcher = GTK_WIDGET(gtk_builder_get_object(builder, "heads_stack_switcher")); state->stack = GTK_WIDGET(gtk_builder_get_object(builder, "heads_stack")); state->scroller = GTK_WIDGET(gtk_builder_get_object(builder, "heads_scroll")); state->spinner = GTK_WIDGET(gtk_builder_get_object(builder, "spinner")); state->zoom_out = GTK_WIDGET(gtk_builder_get_object(builder, "zoom_out")); state->zoom_reset = GTK_WIDGET(gtk_builder_get_object(builder, "zoom_reset")); state->zoom_in = GTK_WIDGET(gtk_builder_get_object(builder, "zoom_in")); state->overlay = GTK_WIDGET(gtk_builder_get_object(builder, "overlay")); state->info_bar = GTK_WIDGET(gtk_builder_get_object(builder, "heads_info")); state->info_label = GTK_WIDGET(gtk_builder_get_object(builder, "heads_info_label")); state->menu_button = GTK_WIDGET(gtk_builder_get_object(builder, "menu_button")); gtk_builder_add_callback_symbol(builder, "apply_changes", G_CALLBACK(apply_changes)); gtk_builder_add_callback_symbol(builder, "cancel_changes", G_CALLBACK(cancel_changes)); gtk_builder_add_callback_symbol(builder, "zoom_out", G_CALLBACK(zoom_out)); gtk_builder_add_callback_symbol(builder, "zoom_reset", G_CALLBACK(zoom_reset)); gtk_builder_add_callback_symbol(builder, "zoom_in", G_CALLBACK(zoom_in)); gtk_builder_add_callback_symbol(builder, "info_response", G_CALLBACK(info_response)); gtk_builder_add_callback_symbol(builder, "destroy", G_CALLBACK(cleanup)); gtk_builder_connect_signals(builder, state); gtk_box_set_homogeneous(GTK_BOX(gtk_builder_get_object(builder, "zoom_box")), FALSE); state->canvas = wd_gl_viewport_new(); gtk_container_add(GTK_CONTAINER(state->scroller), state->canvas); gtk_widget_add_events(state->canvas, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_SCROLL_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK); g_signal_connect(state->canvas, "realize", G_CALLBACK(canvas_realize), state); g_signal_connect(state->canvas, "render", G_CALLBACK(canvas_render), state); g_signal_connect(state->canvas, "unrealize", G_CALLBACK(canvas_unrealize), state); g_signal_connect(state->canvas, "button-press-event", G_CALLBACK(canvas_click), state); g_signal_connect(state->canvas, "button-release-event", G_CALLBACK(canvas_release), state); g_signal_connect(state->canvas, "enter-notify-event", G_CALLBACK(canvas_enter), state); g_signal_connect(state->canvas, "leave-notify-event", G_CALLBACK(canvas_leave), state); g_signal_connect(state->canvas, "motion-notify-event", G_CALLBACK(canvas_motion), state); g_signal_connect(state->canvas, "scroll-event", G_CALLBACK(canvas_scroll), state); g_signal_connect(state->canvas, "size-allocate", G_CALLBACK(canvas_resize), state); gtk_gl_area_set_use_es(GTK_GL_AREA(state->canvas), TRUE); gtk_gl_area_set_required_version(GTK_GL_AREA(state->canvas), 2, 0); gtk_gl_area_set_has_alpha(GTK_GL_AREA(state->canvas), TRUE); gtk_gl_area_set_auto_render(GTK_GL_AREA(state->canvas), state->capture); GtkAdjustment *scroll_x_adj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(state->scroller)); GtkAdjustment *scroll_y_adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(state->scroller)); g_signal_connect_swapped(scroll_x_adj, "value-changed", G_CALLBACK(queue_canvas_draw), state); g_signal_connect_swapped(scroll_y_adj, "value-changed", G_CALLBACK(queue_canvas_draw), state); update_zoom(state); GSimpleActionGroup *main_actions = g_simple_action_group_new(); gtk_widget_insert_action_group(state->menu_button, APP_PREFIX, G_ACTION_GROUP(main_actions)); g_object_unref(main_actions); GSimpleAction *autoapply_action = g_simple_action_new_stateful("auto-apply", NULL, g_variant_new_boolean(state->autoapply)); g_signal_connect(autoapply_action, "activate", G_CALLBACK(auto_apply_selected), state); g_action_map_add_action(G_ACTION_MAP(main_actions), G_ACTION(autoapply_action)); GSimpleAction *capture_action = g_simple_action_new_stateful("capture-screens", NULL, g_variant_new_boolean(state->capture)); g_signal_connect(capture_action, "activate", G_CALLBACK(capture_selected), state); g_action_map_add_action(G_ACTION_MAP(main_actions), G_ACTION(capture_action)); GSimpleAction *overlay_action = g_simple_action_new_stateful("show-overlay", NULL, g_variant_new_boolean(state->show_overlay)); g_signal_connect(overlay_action, "activate", G_CALLBACK(overlay_selected), state); g_action_map_add_action(G_ACTION_MAP(main_actions), G_ACTION(overlay_action)); /* first child of GtkInfoBar is always GtkRevealer */ g_autoptr(GList) info_children = gtk_container_get_children(GTK_CONTAINER(state->info_bar)); g_signal_connect(info_children->data, "notify::child-revealed", G_CALLBACK(info_bar_animation_done), state); struct wl_display *display = gdk_wayland_display_get_wl_display(gdk_display); wd_add_output_management_listener(state, display); if (state->output_manager == NULL) { wd_fatal_error(1, "Compositor doesn't support wlr-output-management-unstable-v1"); } if (state->xdg_output_manager == NULL) { wd_fatal_error(1, "Compositor doesn't support xdg-output-unstable-v1"); } if (state->copy_manager == NULL) { state->capture = FALSE; g_simple_action_set_state(capture_action, g_variant_new_boolean(state->capture)); g_simple_action_set_enabled(capture_action, FALSE); } if (state->layer_shell == NULL) { state->show_overlay = FALSE; g_simple_action_set_state(overlay_action, g_variant_new_boolean(state->show_overlay)); g_simple_action_set_enabled(overlay_action, FALSE); } int n_monitors = gdk_display_get_n_monitors(gdk_display); for (int i = 0; i < n_monitors; i++) { GdkMonitor *monitor = gdk_display_get_monitor(gdk_display, i); wd_add_output(state, gdk_wayland_monitor_get_wl_output(monitor), display); } g_signal_connect(gdk_display, "monitor-added", G_CALLBACK(monitor_added), state); g_signal_connect(gdk_display, "monitor-removed", G_CALLBACK(monitor_removed), state); gtk_application_add_window(app, GTK_WINDOW(window)); gtk_widget_show_all(window); g_object_unref(builder); update_tick_callback(state); } // END GLOBAL CALLBACKS int main(int argc, char *argv[]) { g_setenv("GDK_GL", "gles", FALSE); GtkApplication *app = gtk_application_new("org.swaywm.sway-outputs", G_APPLICATION_FLAGS_NONE); g_signal_connect(app, "activate", G_CALLBACK(activate), NULL); int status = g_application_run(G_APPLICATION(app), argc, argv); g_object_unref(app); return status; } wdisplays-0+git20191201/src/meson.build000066400000000000000000000011031355513134100175560ustar00rootroot00000000000000 cc = meson.get_compiler('c') m_dep = cc.find_library('m', required : false) rt_dep = cc.find_library('rt', required : false) gdk = dependency('gdk-3.0') gtk = dependency('gtk+-3.0') assert(gdk.get_pkgconfig_variable('targets').split().contains('wayland'), 'Wayland GDK backend not present') epoxy = dependency('epoxy') executable( 'wdisplays', [ 'main.c', 'outputs.c', 'render.c', 'glviewport.c', 'overlay.c', resources, ], dependencies : [ m_dep, rt_dep, wayland_client, client_protos, epoxy, gtk ], install: true ) wdisplays-0+git20191201/src/outputs.c000066400000000000000000000516321355513134100173170ustar00rootroot00000000000000/* SPDX-License-Identifier: MIT */ /* Copyright (C) 2019 cyclopsian * Copyright (C) 2017-2019 emersion */ /* * Parts of this file are taken from emersion/kanshi: * https://github.com/emersion/kanshi/blob/38d27474b686fcc8324cc5e454741a49577c0988/main.c */ #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #include #include "wdisplays.h" #include "wlr-output-management-unstable-v1-client-protocol.h" #include "xdg-output-unstable-v1-client-protocol.h" #include "wlr-screencopy-unstable-v1-client-protocol.h" #include "wlr-layer-shell-unstable-v1-client-protocol.h" static void noop() { // This space is intentionally left blank } struct wd_pending_config { struct wd_state *state; struct wl_list *outputs; }; static void destroy_pending(struct wd_pending_config *pending) { struct wd_head_config *output, *tmp; wl_list_for_each_safe(output, tmp, pending->outputs, link) { wl_list_remove(&output->link); free(output); } free(pending->outputs); free(pending); } static void config_handle_succeeded(void *data, struct zwlr_output_configuration_v1 *config) { struct wd_pending_config *pending = data; zwlr_output_configuration_v1_destroy(config); wd_ui_apply_done(pending->state, pending->outputs); destroy_pending(pending); } static void config_handle_failed(void *data, struct zwlr_output_configuration_v1 *config) { struct wd_pending_config *pending = data; zwlr_output_configuration_v1_destroy(config); wd_ui_apply_done(pending->state, NULL); wd_ui_show_error(pending->state, "The display server was not able to process your changes."); destroy_pending(pending); } static void config_handle_cancelled(void *data, struct zwlr_output_configuration_v1 *config) { struct wd_pending_config *pending = data; zwlr_output_configuration_v1_destroy(config); wd_ui_apply_done(pending->state, NULL); wd_ui_show_error(pending->state, "The display configuration was modified by the server before updates were processed. " "Please check the configuration and apply the changes again."); destroy_pending(pending); } static const struct zwlr_output_configuration_v1_listener config_listener = { .succeeded = config_handle_succeeded, .failed = config_handle_failed, .cancelled = config_handle_cancelled, }; void wd_apply_state(struct wd_state *state, struct wl_list *new_outputs, struct wl_display *display) { struct zwlr_output_configuration_v1 *config = zwlr_output_manager_v1_create_configuration(state->output_manager, state->serial); struct wd_pending_config *pending = calloc(1, sizeof(*pending)); pending->state = state; pending->outputs = new_outputs; zwlr_output_configuration_v1_add_listener(config, &config_listener, pending); ssize_t i = -1; struct wd_head_config *output; wl_list_for_each(output, new_outputs, link) { i++; struct wd_head *head = output->head; if (!output->enabled && output->enabled != head->enabled) { zwlr_output_configuration_v1_disable_head(config, head->wlr_head); continue; } struct zwlr_output_configuration_head_v1 *config_head = zwlr_output_configuration_v1_enable_head(config, head->wlr_head); const struct wd_mode *selected_mode = NULL; const struct wd_mode *mode; wl_list_for_each(mode, &head->modes, link) { if (mode->width == output->width && mode->height == output->height && mode->refresh == output->refresh) { selected_mode = mode; break; } } if (selected_mode != NULL) { if (output->enabled != head->enabled || selected_mode != head->mode) { zwlr_output_configuration_head_v1_set_mode(config_head, selected_mode->wlr_mode); } } else if (output->enabled != head->enabled || output->width != head->custom_mode.width || output->height != head->custom_mode.height || output->refresh != head->custom_mode.refresh) { zwlr_output_configuration_head_v1_set_custom_mode(config_head, output->width, output->height, output->refresh); } if (output->enabled != head->enabled || output->x != head->x || output->y != head->y) { zwlr_output_configuration_head_v1_set_position(config_head, output->x, output->y); } if (output->enabled != head->enabled || output->scale != head->scale) { zwlr_output_configuration_head_v1_set_scale(config_head, wl_fixed_from_double(output->scale)); } if (output->enabled != head->enabled || output->transform != head->transform) { zwlr_output_configuration_head_v1_set_transform(config_head, output->transform); } } zwlr_output_configuration_v1_apply(config); wl_display_roundtrip(display); } static void wd_frame_destroy(struct wd_frame *frame) { if (frame->pixels != NULL) munmap(frame->pixels, frame->height * frame->stride); if (frame->buffer != NULL) wl_buffer_destroy(frame->buffer); if (frame->pool != NULL) wl_shm_pool_destroy(frame->pool); if (frame->capture_fd != -1) close(frame->capture_fd); if (frame->wlr_frame != NULL) zwlr_screencopy_frame_v1_destroy(frame->wlr_frame); wl_list_remove(&frame->link); free(frame); } static int create_shm_file(size_t size, const char *fmt, ...) { char *shm_name = NULL; int fd = -1; va_list vl; va_start(vl, fmt); int result = vasprintf(&shm_name, fmt, vl); va_end(vl); if (result == -1) { fprintf(stderr, "asprintf: %s\n", strerror(errno)); shm_name = NULL; return -1; } fd = shm_open(shm_name, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR); if (fd == -1) { fprintf(stderr, "shm_open: %s\n", strerror(errno)); free(shm_name); return -1; } shm_unlink(shm_name); free(shm_name); if (ftruncate(fd, size) == -1) { fprintf(stderr, "ftruncate: %s\n", strerror(errno)); close(fd); return -1; } return fd; } static void capture_buffer(void *data, struct zwlr_screencopy_frame_v1 *copy_frame, uint32_t format, uint32_t width, uint32_t height, uint32_t stride) { struct wd_frame *frame = data; if (format != WL_SHM_FORMAT_ARGB8888 && format != WL_SHM_FORMAT_XRGB8888 && format != WL_SHM_FORMAT_ABGR8888 && format != WL_SHM_FORMAT_XBGR8888) { goto err; } size_t size = stride * height; frame->capture_fd = create_shm_file(size, "/wd-%s", frame->output->name); if (frame->capture_fd == -1) { goto err; } frame->pool = wl_shm_create_pool(frame->output->state->shm, frame->capture_fd, size); frame->buffer = wl_shm_pool_create_buffer(frame->pool, 0, width, height, stride, format); zwlr_screencopy_frame_v1_copy(copy_frame, frame->buffer); frame->stride = stride; frame->width = width; frame->height = height; frame->swap_rgb = format == WL_SHM_FORMAT_ABGR8888 || format == WL_SHM_FORMAT_XBGR8888; return; err: wd_frame_destroy(frame); } static void capture_flags(void *data, struct zwlr_screencopy_frame_v1 *wlr_frame, uint32_t flags) { struct wd_frame *frame = data; frame->y_invert = !!(flags & ZWLR_SCREENCOPY_FRAME_V1_FLAGS_Y_INVERT); } static void capture_ready(void *data, struct zwlr_screencopy_frame_v1 *wlr_frame, uint32_t tv_sec_hi, uint32_t tv_sec_lo, uint32_t tv_nsec) { struct wd_frame *frame = data; frame->pixels = mmap(NULL, frame->stride * frame->height, PROT_READ, MAP_SHARED, frame->capture_fd, 0); if (frame->pixels == MAP_FAILED) { frame->pixels = NULL; fprintf(stderr, "mmap: %d: %s\n", frame->capture_fd, strerror(errno)); wd_frame_destroy(frame); return; } else { uint64_t tv_sec = (uint64_t) tv_sec_hi << 32 | tv_sec_lo; frame->tick = (tv_sec * 1000000) + (tv_nsec / 1000); } zwlr_screencopy_frame_v1_destroy(frame->wlr_frame); frame->wlr_frame = NULL; struct wd_frame *frame_iter, *frame_tmp; wl_list_for_each_safe(frame_iter, frame_tmp, &frame->output->frames, link) { if (frame != frame_iter) { wd_frame_destroy(frame_iter); } } } static void capture_failed(void *data, struct zwlr_screencopy_frame_v1 *wlr_frame) { struct wd_frame *frame = data; wd_frame_destroy(frame); } struct zwlr_screencopy_frame_v1_listener capture_listener = { .buffer = capture_buffer, .flags = capture_flags, .ready = capture_ready, .failed = capture_failed }; static bool has_pending_captures(struct wd_state *state) { struct wd_output *output; wl_list_for_each(output, &state->outputs, link) { struct wd_frame *frame; wl_list_for_each(frame, &output->frames, link) { if (frame->pixels == NULL) { return true; } } } return false; } void wd_capture_frame(struct wd_state *state) { if (state->copy_manager == NULL || has_pending_captures(state) || !state->capture) { return; } struct wd_output *output; wl_list_for_each(output, &state->outputs, link) { struct wd_frame *frame = calloc(1, sizeof(*frame)); frame->output = output; frame->capture_fd = -1; frame->wlr_frame = zwlr_screencopy_manager_v1_capture_output(state->copy_manager, 1, output->wl_output); zwlr_screencopy_frame_v1_add_listener(frame->wlr_frame, &capture_listener, frame); wl_list_insert(&output->frames, &frame->link); } } static void wd_output_destroy(struct wd_output *output) { struct wd_frame *frame, *frame_tmp; wl_list_for_each_safe(frame, frame_tmp, &output->frames, link) { wd_frame_destroy(frame); } if (output->state->layer_shell != NULL) { wd_destroy_overlay(output); } zxdg_output_v1_destroy(output->xdg_output); free(output->name); free(output); } static void wd_mode_destroy(struct wd_mode* mode) { zwlr_output_mode_v1_destroy(mode->wlr_mode); free(mode); } static void wd_head_destroy(struct wd_head *head) { if (head->state->clicked == head->render) { head->state->clicked = NULL; } if (head->render != NULL) { wl_list_remove(&head->render->link); free(head->render); head->render = NULL; } struct wd_mode *mode, *mode_tmp; wl_list_for_each_safe(mode, mode_tmp, &head->modes, link) { zwlr_output_mode_v1_destroy(mode->wlr_mode); free(mode); } zwlr_output_head_v1_destroy(head->wlr_head); free(head->name); free(head->description); free(head); } static void mode_handle_size(void *data, struct zwlr_output_mode_v1 *wlr_mode, int32_t width, int32_t height) { struct wd_mode *mode = data; mode->width = width; mode->height = height; } static void mode_handle_refresh(void *data, struct zwlr_output_mode_v1 *wlr_mode, int32_t refresh) { struct wd_mode *mode = data; mode->refresh = refresh; } static void mode_handle_preferred(void *data, struct zwlr_output_mode_v1 *wlr_mode) { struct wd_mode *mode = data; mode->preferred = true; } static void mode_handle_finished(void *data, struct zwlr_output_mode_v1 *wlr_mode) { struct wd_mode *mode = data; wl_list_remove(&mode->link); wd_mode_destroy(mode); } static const struct zwlr_output_mode_v1_listener mode_listener = { .size = mode_handle_size, .refresh = mode_handle_refresh, .preferred = mode_handle_preferred, .finished = mode_handle_finished, }; static void head_handle_name(void *data, struct zwlr_output_head_v1 *wlr_head, const char *name) { struct wd_head *head = data; head->name = strdup(name); wd_ui_reset_head(head, WD_FIELD_NAME); } static void head_handle_description(void *data, struct zwlr_output_head_v1 *wlr_head, const char *description) { struct wd_head *head = data; head->description = strdup(description); wd_ui_reset_head(head, WD_FIELD_DESCRIPTION); } static void head_handle_physical_size(void *data, struct zwlr_output_head_v1 *wlr_head, int32_t width, int32_t height) { struct wd_head *head = data; head->phys_width = width; head->phys_height = height; wd_ui_reset_head(head, WD_FIELD_PHYSICAL_SIZE); } static void head_handle_mode(void *data, struct zwlr_output_head_v1 *wlr_head, struct zwlr_output_mode_v1 *wlr_mode) { struct wd_head *head = data; struct wd_mode *mode = calloc(1, sizeof(*mode)); mode->head = head; mode->wlr_mode = wlr_mode; wl_list_insert(head->modes.prev, &mode->link); zwlr_output_mode_v1_add_listener(wlr_mode, &mode_listener, mode); } static void head_handle_enabled(void *data, struct zwlr_output_head_v1 *wlr_head, int32_t enabled) { struct wd_head *head = data; head->enabled = !!enabled; if (!enabled) { head->output = NULL; } wd_ui_reset_head(head, WD_FIELD_ENABLED); } static void head_handle_current_mode(void *data, struct zwlr_output_head_v1 *wlr_head, struct zwlr_output_mode_v1 *wlr_mode) { struct wd_head *head = data; struct wd_mode *mode; wl_list_for_each(mode, &head->modes, link) { if (mode->wlr_mode == wlr_mode) { head->mode = mode; wd_ui_reset_head(head, WD_FIELD_MODE); return; } } fprintf(stderr, "received unknown current_mode\n"); head->mode = NULL; } static void head_handle_position(void *data, struct zwlr_output_head_v1 *wlr_head, int32_t x, int32_t y) { struct wd_head *head = data; head->x = x; head->y = y; wd_ui_reset_head(head, WD_FIELD_POSITION); } static void head_handle_transform(void *data, struct zwlr_output_head_v1 *wlr_head, int32_t transform) { struct wd_head *head = data; head->transform = transform; wd_ui_reset_head(head, WD_FIELD_TRANSFORM); } static void head_handle_scale(void *data, struct zwlr_output_head_v1 *wlr_head, wl_fixed_t scale) { struct wd_head *head = data; head->scale = wl_fixed_to_double(scale); wd_ui_reset_head(head, WD_FIELD_SCALE); } static void head_handle_finished(void *data, struct zwlr_output_head_v1 *wlr_head) { struct wd_head *head = data; struct wd_state *state = head->state; wl_list_remove(&head->link); wd_head_destroy(head); uint32_t counter = 0; wl_list_for_each(head, &state->heads, link) { if (head->id != counter) { head->id = counter; if (head->output != NULL) { wd_redraw_overlay(head->output); } } counter++; } } static const struct zwlr_output_head_v1_listener head_listener = { .name = head_handle_name, .description = head_handle_description, .physical_size = head_handle_physical_size, .mode = head_handle_mode, .enabled = head_handle_enabled, .current_mode = head_handle_current_mode, .position = head_handle_position, .transform = head_handle_transform, .scale = head_handle_scale, .finished = head_handle_finished, }; static void output_manager_handle_head(void *data, struct zwlr_output_manager_v1 *manager, struct zwlr_output_head_v1 *wlr_head) { struct wd_state *state = data; struct wd_head *head = calloc(1, sizeof(*head)); head->state = state; head->wlr_head = wlr_head; head->scale = 1.0; head->id = wl_list_length(&state->heads); wl_list_init(&head->modes); wl_list_insert(&state->heads, &head->link); zwlr_output_head_v1_add_listener(wlr_head, &head_listener, head); } static void output_manager_handle_done(void *data, struct zwlr_output_manager_v1 *manager, uint32_t serial) { struct wd_state *state = data; state->serial = serial; assert(wl_list_length(&state->heads) <= HEADS_MAX); struct wd_head *head = data; wl_list_for_each(head, &state->heads, link) { if (!head->enabled && head->mode == NULL && !wl_list_empty(&head->modes)) { struct wd_mode *mode = wl_container_of(head->modes.prev, mode, link); head->custom_mode.width = mode->width; head->custom_mode.height = mode->height; head->custom_mode.refresh = mode->refresh; } } wd_ui_reset_heads(state); } static const struct zwlr_output_manager_v1_listener output_manager_listener = { .head = output_manager_handle_head, .done = output_manager_handle_done, .finished = noop, }; static void registry_handle_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version) { struct wd_state *state = data; if (strcmp(interface, zwlr_output_manager_v1_interface.name) == 0) { state->output_manager = wl_registry_bind(registry, name, &zwlr_output_manager_v1_interface, version); zwlr_output_manager_v1_add_listener(state->output_manager, &output_manager_listener, state); } else if (strcmp(interface, zxdg_output_manager_v1_interface.name) == 0) { state->xdg_output_manager = wl_registry_bind(registry, name, &zxdg_output_manager_v1_interface, version); } else if(strcmp(interface, zwlr_screencopy_manager_v1_interface.name) == 0) { state->copy_manager = wl_registry_bind(registry, name, &zwlr_screencopy_manager_v1_interface, version); } else if(strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) { state->layer_shell = wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, version); } else if(strcmp(interface, wl_shm_interface.name) == 0) { state->shm = wl_registry_bind(registry, name, &wl_shm_interface, version); } } static const struct wl_registry_listener registry_listener = { .global = registry_handle_global, .global_remove = noop, }; void wd_add_output_management_listener(struct wd_state *state, struct wl_display *display) { struct wl_registry *registry = wl_display_get_registry(display); wl_registry_add_listener(registry, ®istry_listener, state); wl_display_dispatch(display); wl_display_roundtrip(display); } struct wd_head *wd_find_head(struct wd_state *state, struct wd_output *output) { struct wd_head *head; wl_list_for_each(head, &state->heads, link) { if (output->name != NULL && strcmp(output->name, head->name) == 0) { head->output = output; return head; } } return NULL; } static void output_logical_position(void *data, struct zxdg_output_v1 *zxdg_output_v1, int32_t x, int32_t y) { struct wd_output *output = data; struct wd_head *head = wd_find_head(output->state, output); if (head != NULL) { head->x = x; head->y = y; wd_ui_reset_head(head, WD_FIELD_POSITION); } } static void output_name(void *data, struct zxdg_output_v1 *zxdg_output_v1, const char *name) { struct wd_output *output = data; if (output->name != NULL) { free(output->name); } output->name = strdup(name); struct wd_head *head = wd_find_head(output->state, output); if (head != NULL) { wd_ui_reset_head(head, WD_FIELD_NAME); } } static const struct zxdg_output_v1_listener output_listener = { .logical_position = output_logical_position, .logical_size = noop, .done = noop, .name = output_name, .description = noop }; void wd_add_output(struct wd_state *state, struct wl_output *wl_output, struct wl_display *display) { struct wd_output *output = calloc(1, sizeof(*output)); output->state = state; output->wl_output = wl_output; output->xdg_output = zxdg_output_manager_v1_get_xdg_output( state->xdg_output_manager, wl_output); wl_list_init(&output->frames); zxdg_output_v1_add_listener(output->xdg_output, &output_listener, output); wl_list_insert(output->state->outputs.prev, &output->link); if (state->layer_shell != NULL && state->show_overlay) { wl_display_roundtrip(display); wd_create_overlay(output); } } void wd_remove_output(struct wd_state *state, struct wl_output *wl_output, struct wl_display *display) { struct wd_output *output, *output_tmp; wl_list_for_each_safe(output, output_tmp, &state->outputs, link) { if (output->wl_output == wl_output) { wl_list_remove(&output->link); wd_output_destroy(output); break; } } wd_capture_wait(state, display); } struct wd_output *wd_find_output(struct wd_state *state, struct wd_head *head) { if (!head->enabled) { return NULL; } if (head->output != NULL) { return head->output; } struct wd_output *output; wl_list_for_each(output, &state->outputs, link) { if (output->name != NULL && strcmp(output->name, head->name) == 0) { head->output = output; return output; } } head->output = NULL; return NULL; } struct wd_state *wd_state_create(void) { struct wd_state *state = calloc(1, sizeof(*state)); state->zoom = 1.; state->capture = true; state->show_overlay = true; wl_list_init(&state->heads); wl_list_init(&state->outputs); wl_list_init(&state->render.heads); return state; } void wd_capture_wait(struct wd_state *state, struct wl_display *display) { wl_display_flush(display); while (has_pending_captures(state)) { if (wl_display_dispatch(display) == -1) { break; } } } void wd_state_destroy(struct wd_state *state) { struct wd_head *head, *head_tmp; wl_list_for_each_safe(head, head_tmp, &state->heads, link) { wd_head_destroy(head); } struct wd_output *output, *output_tmp; wl_list_for_each_safe(output, output_tmp, &state->outputs, link) { wd_output_destroy(output); } if (state->layer_shell != NULL) { zwlr_layer_shell_v1_destroy(state->layer_shell); } if (state->copy_manager != NULL) { zwlr_screencopy_manager_v1_destroy(state->copy_manager); } zwlr_output_manager_v1_destroy(state->output_manager); zxdg_output_manager_v1_destroy(state->xdg_output_manager); wl_shm_destroy(state->shm); free(state); } wdisplays-0+git20191201/src/overlay.c000066400000000000000000000150211355513134100172450ustar00rootroot00000000000000/* SPDX-License-Identifier: MIT */ /* Copyright (C) 2019 cyclopsian */ #define _GNU_SOURCE #include #include #include #include #include #include "wdisplays.h" #include "wlr-layer-shell-unstable-v1-client-protocol.h" #define SCREEN_MARGIN_PERCENT 0.02 static void layer_surface_configure(void *data, struct zwlr_layer_surface_v1 *surface, uint32_t serial, uint32_t width, uint32_t height) { struct wd_output *output = data; gtk_widget_set_size_request(output->overlay_window, width, height); zwlr_layer_surface_v1_ack_configure(surface, serial); } static void layer_surface_closed(void *data, struct zwlr_layer_surface_v1 *surface) { } static const struct zwlr_layer_surface_v1_listener layer_surface_listener = { .configure = layer_surface_configure, .closed = layer_surface_closed, }; static inline int min(int a, int b) { return a < b ? a : b; } static PangoLayout *create_text_layout(struct wd_head *head, PangoContext *pango, GtkStyleContext *style) { GtkStyleContext *desc_style = gtk_style_context_new(); gtk_style_context_set_screen(desc_style, gtk_style_context_get_screen(style)); GtkWidgetPath *desc_path = gtk_widget_path_copy( gtk_style_context_get_path(style)); gtk_widget_path_append_type(desc_path, G_TYPE_NONE); gtk_style_context_set_path(desc_style, desc_path); gtk_style_context_add_class(desc_style, "description"); double desc_font_size = 16.; gtk_style_context_get(desc_style, GTK_STATE_FLAG_NORMAL, "font-size", &desc_font_size, NULL); g_autofree gchar *str = g_strdup_printf("%s\n%s", head->name, (int) (desc_font_size * PANGO_SCALE), head->description); PangoLayout *layout = pango_layout_new(pango); pango_layout_set_markup(layout, str, -1); return layout; } static void resize(struct wd_output *output) { struct wd_head *head = wd_find_head(output->state, output); uint32_t screen_width = head->custom_mode.width; uint32_t screen_height = head->custom_mode.height; if (head->mode != NULL) { screen_width = head->mode->width; screen_height = head->mode->height; } uint32_t margin = min(screen_width, screen_height) * SCREEN_MARGIN_PERCENT; GdkWindow *window = gtk_widget_get_window(output->overlay_window); PangoContext *pango = gtk_widget_get_pango_context(output->overlay_window); GtkStyleContext *style_ctx = gtk_widget_get_style_context( output->overlay_window); PangoLayout *layout = create_text_layout(head, pango, style_ctx); int width; int height; pango_layout_get_pixel_size(layout, &width, &height); g_object_unref(layout); GtkBorder padding; gtk_style_context_get_padding(style_ctx, GTK_STATE_FLAG_NORMAL, &padding); width = min(width, screen_width - margin * 2) + padding.left + padding.right; height = min(height, screen_height - margin * 2) + padding.top + padding.bottom; zwlr_layer_surface_v1_set_margin(output->overlay_layer_surface, margin, margin, margin, margin); zwlr_layer_surface_v1_set_size(output->overlay_layer_surface, width, height); struct wl_surface *surface = gdk_wayland_window_get_wl_surface(window); wl_surface_commit(surface); GdkDisplay *display = gdk_window_get_display(window); wl_display_roundtrip(gdk_wayland_display_get_wl_display(display)); } void wd_redraw_overlay(struct wd_output *output) { if (output->overlay_window != NULL) { resize(output); gtk_widget_queue_draw(output->overlay_window); } } void window_realize(GtkWidget *widget, gpointer data) { GdkWindow *window = gtk_widget_get_window(widget); gdk_wayland_window_set_use_custom_surface(window); } void window_map(GtkWidget *widget, gpointer data) { struct wd_output *output = data; GdkWindow *window = gtk_widget_get_window(widget); cairo_region_t *region = cairo_region_create(); gdk_window_input_shape_combine_region(window, region, 0, 0); cairo_region_destroy(region); struct wl_surface *surface = gdk_wayland_window_get_wl_surface(window); output->overlay_layer_surface = zwlr_layer_shell_v1_get_layer_surface( output->state->layer_shell, surface, output->wl_output, ZWLR_LAYER_SHELL_V1_LAYER_TOP, "output-overlay"); zwlr_layer_surface_v1_add_listener(output->overlay_layer_surface, &layer_surface_listener, output); zwlr_layer_surface_v1_set_anchor(output->overlay_layer_surface, ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT); resize(output); } void window_unmap(GtkWidget *widget, gpointer data) { struct wd_output *output = data; zwlr_layer_surface_v1_destroy(output->overlay_layer_surface); } gboolean window_draw(GtkWidget *widget, cairo_t *cr, gpointer data) { struct wd_output *output = data; struct wd_head *head = wd_find_head(output->state, output); GtkStyleContext *style_ctx = gtk_widget_get_style_context(widget); GdkRGBA fg; gtk_style_context_get_color(style_ctx, GTK_STATE_FLAG_NORMAL, &fg); int width = gtk_widget_get_allocated_width(widget); int height = gtk_widget_get_allocated_height(widget); gtk_render_background(style_ctx, cr, 0, 0, width, height); GtkBorder padding; gtk_style_context_get_padding(style_ctx, GTK_STATE_FLAG_NORMAL, &padding); PangoContext *pango = gtk_widget_get_pango_context(widget); PangoLayout *layout = create_text_layout(head, pango, style_ctx); gdk_cairo_set_source_rgba(cr, &fg); cairo_move_to(cr, padding.left, padding.top); pango_cairo_show_layout(cr, layout); g_object_unref(layout); return TRUE; } void wd_create_overlay(struct wd_output *output) { output->overlay_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_decorated(GTK_WINDOW(output->overlay_window), FALSE); gtk_window_set_resizable(GTK_WINDOW(output->overlay_window), FALSE); gtk_widget_add_events(output->overlay_window, GDK_STRUCTURE_MASK); g_signal_connect(output->overlay_window, "realize", G_CALLBACK(window_realize), output); g_signal_connect(output->overlay_window, "map", G_CALLBACK(window_map), output); g_signal_connect(output->overlay_window, "unmap", G_CALLBACK(window_unmap), output); g_signal_connect(output->overlay_window, "draw", G_CALLBACK(window_draw), output); GtkStyleContext *style_ctx = gtk_widget_get_style_context( output->overlay_window); gtk_style_context_add_class(style_ctx, "output-overlay"); gtk_widget_show(output->overlay_window); } void wd_destroy_overlay(struct wd_output *output) { if (output->overlay_window != NULL) { gtk_widget_destroy(output->overlay_window); output->overlay_window = NULL; } } wdisplays-0+git20191201/src/render.c000066400000000000000000000411361355513134100170510ustar00rootroot00000000000000/* SPDX-License-Identifier: MIT */ /* Copyright (C) 2019 cyclopsian */ #include "wdisplays.h" #include #include #include #include #include #define BT_UV_VERT_SIZE (2 + 2) #define BT_UV_QUAD_SIZE (6 * BT_UV_VERT_SIZE) #define BT_UV_MAX (BT_COLOR_QUAD_SIZE * HEADS_MAX) #define BT_COLOR_VERT_SIZE (2 + 4) #define BT_COLOR_QUAD_SIZE (6 * BT_COLOR_VERT_SIZE) #define BT_COLOR_MAX (BT_COLOR_QUAD_SIZE * HEADS_MAX) #define BT_LINE_VERT_SIZE (2 + 4) #define BT_LINE_QUAD_SIZE (8 * BT_LINE_VERT_SIZE) #define BT_LINE_EXT_SIZE (24 * BT_LINE_VERT_SIZE) #define BT_LINE_MAX (BT_LINE_EXT_SIZE * (HEADS_MAX + 1)) enum gl_buffers { TEXTURE_BUFFER, COLOR_BUFFER, LINE_BUFFER, NUM_BUFFERS }; struct wd_gl_data { GLuint color_program; GLuint color_vertex_shader; GLuint color_fragment_shader; GLuint color_position_attribute; GLuint color_color_attribute; GLuint color_screen_size_uniform; GLuint texture_program; GLuint texture_vertex_shader; GLuint texture_fragment_shader; GLuint texture_position_attribute; GLuint texture_uv_attribute; GLuint texture_screen_size_uniform; GLuint texture_texture_uniform; GLuint texture_color_transform_uniform; GLuint buffers[NUM_BUFFERS]; unsigned texture_count; GLuint textures[HEADS_MAX]; float verts[BT_LINE_MAX]; }; static const char *color_vertex_shader_src = "\ precision mediump float;\n\ attribute vec2 position;\n\ attribute vec4 color;\n\ varying vec4 color_out;\n\ uniform vec2 screen_size;\n\ void main(void) {\n\ vec2 screen_pos = (position / screen_size * 2. - 1.) * vec2(1., -1.);\n\ gl_Position = vec4(screen_pos, 0., 1.);\n\ color_out = color;\n\ }"; static const char *color_fragment_shader_src = "\ precision mediump float;\n\ varying vec4 color_out;\n\ void main(void) {\n\ gl_FragColor = color_out;\n\ }"; static const char *texture_vertex_shader_src = "\ precision mediump float;\n\ attribute vec2 position;\n\ attribute vec2 uv;\n\ varying vec2 uv_out;\n\ uniform vec2 screen_size;\n\ void main(void) {\n\ vec2 screen_pos = (position / screen_size * 2. - 1.) * vec2(1., -1.);\n\ gl_Position = vec4(screen_pos, 0., 1.);\n\ uv_out = uv;\n\ }"; static const char *texture_fragment_shader_src = "\ precision mediump float;\n\ varying vec2 uv_out;\n\ uniform sampler2D texture;\n\ uniform mat4 color_transform;\n\ void main(void) {\n\ gl_FragColor = texture2D(texture, uv_out) * color_transform;\n\ }"; static GLuint gl_make_shader(GLenum type, const char *src) { GLuint shader = glCreateShader(type); glShaderSource(shader, 1, &src, NULL); glCompileShader(shader); GLint status; glGetShaderiv(shader, GL_COMPILE_STATUS, &status); if (status == GL_FALSE) { GLsizei length; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length); GLchar *log = "Failed"; if (length > 0) { log = malloc(length); glGetShaderInfoLog(shader, length, NULL, log); } fprintf(stderr, "glCompileShader: %s\n", log); if (length > 0) { free(log); } } return shader; } static void gl_link_and_validate(GLint program) { GLint status; glLinkProgram(program); glGetProgramiv(program, GL_LINK_STATUS, &status); if (status == GL_FALSE) { GLsizei length; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length); GLchar *log = malloc(length); glGetProgramInfoLog(program, length, NULL, log); fprintf(stderr, "glLinkProgram: %s\n", log); free(log); return; } glValidateProgram(program); glGetProgramiv(program, GL_VALIDATE_STATUS, &status); if (status == GL_FALSE) { GLsizei length; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length); GLchar *log = malloc(length); glGetProgramInfoLog(program, length, NULL, log); fprintf(stderr, "glValidateProgram: %s\n", log); free(log); } } struct wd_gl_data *wd_gl_setup(void) { struct wd_gl_data *res = calloc(1, sizeof(struct wd_gl_data)); res->color_program = glCreateProgram(); res->color_vertex_shader = gl_make_shader(GL_VERTEX_SHADER, color_vertex_shader_src); glAttachShader(res->color_program, res->color_vertex_shader); res->color_fragment_shader = gl_make_shader(GL_FRAGMENT_SHADER, color_fragment_shader_src); glAttachShader(res->color_program, res->color_fragment_shader); gl_link_and_validate(res->color_program); res->color_position_attribute = glGetAttribLocation(res->color_program, "position"); res->color_color_attribute = glGetAttribLocation(res->color_program, "color"); res->color_screen_size_uniform = glGetUniformLocation(res->color_program, "screen_size"); res->texture_program = glCreateProgram(); res->texture_vertex_shader = gl_make_shader(GL_VERTEX_SHADER, texture_vertex_shader_src); glAttachShader(res->texture_program, res->texture_vertex_shader); res->texture_fragment_shader = gl_make_shader(GL_FRAGMENT_SHADER, texture_fragment_shader_src); glAttachShader(res->texture_program, res->texture_fragment_shader); gl_link_and_validate(res->texture_program); res->texture_position_attribute = glGetAttribLocation(res->texture_program, "position"); res->texture_uv_attribute = glGetAttribLocation(res->texture_program, "uv"); res->texture_screen_size_uniform = glGetUniformLocation(res->texture_program, "screen_size"); res->texture_texture_uniform = glGetUniformLocation(res->texture_program, "texture"); res->texture_color_transform_uniform = glGetUniformLocation( res->texture_program, "color_transform"); glGenBuffers(NUM_BUFFERS, res->buffers); glBindBuffer(GL_ARRAY_BUFFER, res->buffers[TEXTURE_BUFFER]); glBufferData(GL_ARRAY_BUFFER, BT_UV_MAX * sizeof(float), NULL, GL_DYNAMIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, res->buffers[COLOR_BUFFER]); glBufferData(GL_ARRAY_BUFFER, BT_COLOR_MAX * sizeof(float), NULL, GL_DYNAMIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, res->buffers[LINE_BUFFER]); glBufferData(GL_ARRAY_BUFFER, BT_LINE_MAX * sizeof(float), NULL, GL_DYNAMIC_DRAW); return res; } static const GLfloat TRANSFORM_RGB[16] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1}; static const GLfloat TRANSFORM_BGR[16] = { 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1}; #define PUSH_POINT_COLOR(_start, _a, _b, _color, _alpha) \ *((_start)++) = (_a);\ *((_start)++) = (_b);\ *((_start)++) = ((_color)[0]);\ *((_start)++) = ((_color)[1]);\ *((_start)++) = ((_color)[2]);\ *((_start)++) = (_alpha); #define PUSH_POINT_UV(_start, _a, _b, _c, _d) \ *((_start)++) = (_a);\ *((_start)++) = (_b);\ *((_start)++) = (_c);\ *((_start)++) = (_d); static inline float lerp(float x, float y, float a) { return x * (1.f - a) + y * a; } static inline void lerp_color(float out[3], float x[3], float y[3], float a) { out[0] = lerp(x[0], y[0], a); out[1] = lerp(x[1], y[1], a); out[2] = lerp(x[2], y[2], a); out[3] = lerp(x[3], y[3], a); } static inline float ease(float d) { d *= 2.f; if (d <= 1.f) { d = d * d; } else { d -= 1.f; d = d * (2.f - d) + 1.f; } d /= 2.f; return d; } void wd_gl_render(struct wd_gl_data *res, struct wd_render_data *info, uint64_t tick) { unsigned int tri_verts = 0; unsigned int head_count = wl_list_length(&info->heads); if (head_count >= HEADS_MAX) head_count = HEADS_MAX; if (head_count > res->texture_count) { glGenTextures(head_count - res->texture_count, res->textures + res->texture_count); for (int i = res->texture_count; i < head_count; i++) { glBindTexture(GL_TEXTURE_2D, res->textures[i]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); } glBindTexture(GL_TEXTURE_2D, 0); res->texture_count = head_count; } struct wd_render_head_data *head; int i = 0; wl_list_for_each_reverse(head, &info->heads, link) { float *tri_ptr = res->verts + i * BT_UV_QUAD_SIZE; float x1 = head->active.x_invert ? head->x2 : head->x1; float y1 = head->y_invert ? head->y2 : head->y1; float x2 = head->active.x_invert ? head->x1 : head->x2; float y2 = head->y_invert ? head->y1 : head->y2; float sa = 0.f; float sb = 1.f; float sc = sb; float sd = sa; float ta = 0.f; float tb = ta; float tc = 1.f; float td = tc; for (int i = 0; i < head->active.rotation; i++) { float tmp = sd; sd = sc; sc = sb; sb = sa; sa = tmp; tmp = td; td = tc; tc = tb; tb = ta; ta = tmp; } PUSH_POINT_UV(tri_ptr, x1, y1, sa, ta) PUSH_POINT_UV(tri_ptr, x2, y1, sb, tb) PUSH_POINT_UV(tri_ptr, x1, y2, sd, td) PUSH_POINT_UV(tri_ptr, x1, y2, sd, td) PUSH_POINT_UV(tri_ptr, x2, y1, sb, tb) PUSH_POINT_UV(tri_ptr, x2, y2, sc, tc) tri_verts += 6; i++; if (i >= HEADS_MAX) break; } glClearColor(info->bg_color[0], info->bg_color[1], info->bg_color[2], 1.f); glClear(GL_COLOR_BUFFER_BIT); float screen_size[2] = { info->viewport_width, info->viewport_height }; if (tri_verts > 0) { glUseProgram(res->texture_program); glBindBuffer(GL_ARRAY_BUFFER, res->buffers[TEXTURE_BUFFER]); glBufferSubData(GL_ARRAY_BUFFER, 0, tri_verts * BT_UV_VERT_SIZE * sizeof(float), res->verts); glEnableVertexAttribArray(res->texture_position_attribute); glEnableVertexAttribArray(res->texture_uv_attribute); glVertexAttribPointer(res->texture_position_attribute, 2, GL_FLOAT, GL_FALSE, BT_UV_VERT_SIZE * sizeof(float), (void *) (0 * sizeof(float))); glVertexAttribPointer(res->texture_uv_attribute, 2, GL_FLOAT, GL_FALSE, BT_UV_VERT_SIZE * sizeof(float), (void *) (2 * sizeof(float))); glUniform2fv(res->texture_screen_size_uniform, 1, screen_size); glUniform1i(res->texture_texture_uniform, 0); glActiveTexture(GL_TEXTURE0); i = 0; wl_list_for_each_reverse(head, &info->heads, link) { glBindTexture(GL_TEXTURE_2D, res->textures[i]); if (head->updated_at == tick) { glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, head->tex_stride / 4); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, head->tex_width, head->tex_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, head->pixels); glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, 0); glGenerateMipmap(GL_TEXTURE_2D); } glUniformMatrix4fv(res->texture_color_transform_uniform, 1, GL_FALSE, head->swap_rgb ? TRANSFORM_RGB : TRANSFORM_BGR); glDrawArrays(GL_TRIANGLES, i * 6, 6); i++; if (i >= HEADS_MAX) break; } } tri_verts = 0; int j = 0; i = 0; bool any_clicked = false; uint64_t click_begin = 0; wl_list_for_each_reverse(head, &info->heads, link) { any_clicked = head->clicked || any_clicked; if (head->click_begin > click_begin) click_begin = head->click_begin; if (head->hovered || tick < head->hover_begin + HOVER_USECS) { float *tri_ptr = res->verts + j++ * BT_COLOR_QUAD_SIZE; float x1 = head->x1; float y1 = head->y1; float x2 = head->x2; float y2 = head->y2; float *color = info->selection_color; float d = fminf( (tick - head->hover_begin) / (double) HOVER_USECS, 1.f); if (!head->hovered) d = 1.f - d; float alpha = color[3] * ease(d) * .5f; PUSH_POINT_COLOR(tri_ptr, x1, y1, color, alpha) PUSH_POINT_COLOR(tri_ptr, x2, y1, color, alpha) PUSH_POINT_COLOR(tri_ptr, x1, y2, color, alpha) PUSH_POINT_COLOR(tri_ptr, x1, y2, color, alpha) PUSH_POINT_COLOR(tri_ptr, x2, y1, color, alpha) PUSH_POINT_COLOR(tri_ptr, x2, y2, color, alpha) tri_verts += 6; } i++; if (i >= HEADS_MAX) break; } if (tri_verts > 0) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glUseProgram(res->color_program); glBindBuffer(GL_ARRAY_BUFFER, res->buffers[COLOR_BUFFER]); glBufferSubData(GL_ARRAY_BUFFER, 0, tri_verts * BT_COLOR_VERT_SIZE * sizeof(float), res->verts); glEnableVertexAttribArray(res->color_position_attribute); glEnableVertexAttribArray(res->color_color_attribute); glVertexAttribPointer(res->color_position_attribute, 2, GL_FLOAT, GL_FALSE, BT_COLOR_VERT_SIZE * sizeof(float), (void *) (0 * sizeof(float))); glVertexAttribPointer(res->color_color_attribute, 4, GL_FLOAT, GL_FALSE, BT_COLOR_VERT_SIZE * sizeof(float), (void *) (2 * sizeof(float))); glUniform2fv(res->color_screen_size_uniform, 1, screen_size); glDrawArrays(GL_TRIANGLES, 0, tri_verts); glDisable(GL_BLEND); } unsigned int line_verts = 0; i = 0; float *line_ptr = res->verts; if (any_clicked || (click_begin && tick < click_begin + HOVER_USECS)) { const float ox = -info->scroll_x - info->x_origin; const float oy = -info->scroll_y - info->y_origin; const float sx = screen_size[0]; const float sy = screen_size[1]; float color[4]; lerp_color(color, info->selection_color, info->fg_color, .5f); float d = fminf( (tick - click_begin) / (double) HOVER_USECS, 1.f); if (!any_clicked) d = 1.f - d; float alpha = color[3] * ease(d) * .5f; PUSH_POINT_COLOR(line_ptr, ox, oy, color, alpha) PUSH_POINT_COLOR(line_ptr, sx, oy, color, alpha) PUSH_POINT_COLOR(line_ptr, ox, oy, color, alpha) PUSH_POINT_COLOR(line_ptr, ox, sy, color, alpha) line_verts += 4; } wl_list_for_each(head, &info->heads, link) { float x1 = head->x1; float y1 = head->y1; float x2 = head->x2; float y2 = head->y2; float *color = info->fg_color; float alpha = color[3] * (head->clicked ? .5f : .25f); PUSH_POINT_COLOR(line_ptr, x1, y1, color, alpha) PUSH_POINT_COLOR(line_ptr, x2, y1, color, alpha) PUSH_POINT_COLOR(line_ptr, x2, y1, color, alpha) PUSH_POINT_COLOR(line_ptr, x2, y2, color, alpha) PUSH_POINT_COLOR(line_ptr, x2, y2, color, alpha) PUSH_POINT_COLOR(line_ptr, x1, y2, color, alpha) PUSH_POINT_COLOR(line_ptr, x1, y2, color, alpha) PUSH_POINT_COLOR(line_ptr, x1, y1, color, alpha) line_verts += 8; if (any_clicked || (click_begin && tick < click_begin + HOVER_USECS)) { float d = fminf( (tick - click_begin) / (double) HOVER_USECS, 1.f); if (!any_clicked) d = 1.f - d; alpha = color[3] * ease(d) * (head->clicked ? .15f : .075f); const float sx = screen_size[0]; const float sy = screen_size[1]; PUSH_POINT_COLOR(line_ptr, 0, y1, color, alpha) PUSH_POINT_COLOR(line_ptr, x1, y1, color, alpha) PUSH_POINT_COLOR(line_ptr, x1, 0, color, alpha) PUSH_POINT_COLOR(line_ptr, x1, y1, color, alpha) PUSH_POINT_COLOR(line_ptr, sx, y1, color, alpha) PUSH_POINT_COLOR(line_ptr, x2, y1, color, alpha) PUSH_POINT_COLOR(line_ptr, x2, 0, color, alpha) PUSH_POINT_COLOR(line_ptr, x2, y1, color, alpha) PUSH_POINT_COLOR(line_ptr, sx, y2, color, alpha) PUSH_POINT_COLOR(line_ptr, x2, y2, color, alpha) PUSH_POINT_COLOR(line_ptr, x2, sy, color, alpha) PUSH_POINT_COLOR(line_ptr, x2, y2, color, alpha) PUSH_POINT_COLOR(line_ptr, 0, y2, color, alpha) PUSH_POINT_COLOR(line_ptr, x1, y2, color, alpha) PUSH_POINT_COLOR(line_ptr, x1, sy, color, alpha) PUSH_POINT_COLOR(line_ptr, x1, y2, color, alpha) line_verts += 16; } i++; if (i >= HEADS_MAX) break; } if (line_verts > 0) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glUseProgram(res->color_program); glBindBuffer(GL_ARRAY_BUFFER, res->buffers[LINE_BUFFER]); glBufferSubData(GL_ARRAY_BUFFER, 0, line_verts * BT_LINE_VERT_SIZE * sizeof(float), res->verts); glEnableVertexAttribArray(res->color_position_attribute); glEnableVertexAttribArray(res->color_color_attribute); glVertexAttribPointer(res->color_position_attribute, 2, GL_FLOAT, GL_FALSE, BT_LINE_VERT_SIZE * sizeof(float), (void *) (0 * sizeof(float))); glVertexAttribPointer(res->color_color_attribute, 4, GL_FLOAT, GL_FALSE, BT_LINE_VERT_SIZE * sizeof(float), (void *) (2 * sizeof(float))); glUniform2fv(res->color_screen_size_uniform, 1, screen_size); glDrawArrays(GL_LINES, 0, line_verts); glDisable(GL_BLEND); } } void wd_gl_cleanup(struct wd_gl_data *res) { glDeleteBuffers(NUM_BUFFERS, res->buffers); glDeleteShader(res->texture_fragment_shader); glDeleteShader(res->texture_vertex_shader); glDeleteProgram(res->texture_program); glDeleteShader(res->color_fragment_shader); glDeleteShader(res->color_vertex_shader); glDeleteProgram(res->color_program); free(res); } wdisplays-0+git20191201/src/wdisplays.h000066400000000000000000000176001355513134100176150ustar00rootroot00000000000000/* SPDX-License-Identifier: MIT */ /* Copyright (C) 2019 cyclopsian * Copyright (C) 2017-2019 emersion */ /* * Parts of this file are taken from emersion/kanshi: * https://github.com/emersion/kanshi/blob/38d27474b686fcc8324cc5e454741a49577c0988/include/kanshi.h * https://github.com/emersion/kanshi/blob/38d27474b686fcc8324cc5e454741a49577c0988/include/config.h */ #ifndef WDISPLAY_WDISPLAY_H #define WDISPLAY_WDISPLAY_H #define HEADS_MAX 64 #define HOVER_USECS (100 * 1000) #include #include struct zxdg_output_v1; struct zxdg_output_manager_v1; struct zwlr_output_mode_v1; struct zwlr_output_head_v1; struct zwlr_output_manager_v1; struct zwlr_screencopy_manager_v1; struct zwlr_screencopy_frame_v1; struct zwlr_layer_shell_v1; struct zwlr_layer_surface_v1; struct _GtkWidget; typedef struct _GtkWidget GtkWidget; struct _GtkBuilder; typedef struct _GtkBuilder GtkBuilder; struct _GdkCursor; typedef struct _GdkCursor GdkCursor; struct _cairo_surface; typedef struct _cairo_surface cairo_surface_t; enum wd_head_fields { WD_FIELD_NAME = 1 << 0, WD_FIELD_ENABLED = 1 << 1, WD_FIELD_DESCRIPTION = 1 << 2, WD_FIELD_PHYSICAL_SIZE = 1 << 3, WD_FIELD_SCALE = 1 << 4, WD_FIELD_POSITION = 1 << 5, WD_FIELD_MODE = 1 << 6, WD_FIELD_TRANSFORM = 1 << 7, WD_FIELDS_ALL = (1 << 8) - 1 }; struct wd_output { struct wd_state *state; struct zxdg_output_v1 *xdg_output; struct wl_output *wl_output; struct wl_list link; char *name; struct wl_list frames; GtkWidget *overlay_window; struct zwlr_layer_surface_v1 *overlay_layer_surface; }; struct wd_frame { struct wd_output *output; struct zwlr_screencopy_frame_v1 *wlr_frame; struct wl_list link; int capture_fd; unsigned stride; unsigned width; unsigned height; struct wl_shm_pool *pool; struct wl_buffer *buffer; uint8_t *pixels; uint64_t tick; bool y_invert; bool swap_rgb; }; struct wd_head_config { struct wl_list link; struct wd_head *head; bool enabled; int32_t width; int32_t height; int32_t refresh; // mHz int32_t x; int32_t y; double scale; enum wl_output_transform transform; }; struct wd_mode { struct wd_head *head; struct zwlr_output_mode_v1 *wlr_mode; struct wl_list link; int32_t width, height; int32_t refresh; // mHz bool preferred; }; struct wd_head { struct wd_state *state; struct zwlr_output_head_v1 *wlr_head; struct wl_list link; struct wd_output *output; struct wd_render_head_data *render; cairo_surface_t *surface; uint32_t id; char *name, *description; int32_t phys_width, phys_height; // mm struct wl_list modes; bool enabled; struct wd_mode *mode; struct { int32_t width, height; int32_t refresh; } custom_mode; int32_t x, y; enum wl_output_transform transform; double scale; }; struct wd_gl_data; struct wd_render_head_flags { uint8_t rotation; bool x_invert; }; struct wd_render_head_data { struct wl_list link; uint64_t updated_at; uint64_t hover_begin; uint64_t click_begin; float x1; float y1; float x2; float y2; struct wd_render_head_flags queued; struct wd_render_head_flags active; uint8_t *pixels; unsigned tex_stride; unsigned tex_width; unsigned tex_height; bool preview; bool y_invert; bool swap_rgb; bool hovered; bool clicked; }; struct wd_render_data { float fg_color[4]; float bg_color[4]; float border_color[4]; float selection_color[4]; unsigned int viewport_width; unsigned int viewport_height; unsigned int width; unsigned int height; int scroll_x; int scroll_y; int x_origin; int y_origin; uint64_t updated_at; struct wl_list heads; }; struct wd_point { double x; double y; }; struct wd_state { struct zxdg_output_manager_v1 *xdg_output_manager; struct zwlr_output_manager_v1 *output_manager; struct zwlr_screencopy_manager_v1 *copy_manager; struct zwlr_layer_shell_v1 *layer_shell; struct wl_shm *shm; struct wl_list heads; struct wl_list outputs; uint32_t serial; bool apply_pending; bool autoapply; bool capture; bool show_overlay; double zoom; unsigned int apply_idle; unsigned int reset_idle; struct wd_render_head_data *clicked; /* top left, bottom right */ struct wd_point click_offset; bool panning; struct wd_point pan_last; GtkWidget *header_stack; GtkWidget *stack_switcher; GtkWidget *stack; GtkWidget *scroller; GtkWidget *canvas; GtkWidget *spinner; GtkWidget *zoom_out; GtkWidget *zoom_reset; GtkWidget *zoom_in; GtkWidget *overlay; GtkWidget *info_bar; GtkWidget *info_label; GtkWidget *menu_button; GdkCursor *grab_cursor; GdkCursor *grabbing_cursor; GdkCursor *move_cursor; unsigned int canvas_tick; struct wd_gl_data *gl_data; struct wd_render_data render; }; /* * Creates the application state structure. */ struct wd_state *wd_state_create(void); /* * Frees the application state structure. */ void wd_state_destroy(struct wd_state *state); /* * Displays an error message and then exits the program. */ void wd_fatal_error(int status, const char *message); /* * Add an output to the list of screen captured outputs. */ void wd_add_output(struct wd_state *state, struct wl_output *wl_output, struct wl_display *display); /* * Remove an output from the list of screen captured outputs. */ void wd_remove_output(struct wd_state *state, struct wl_output *wl_output, struct wl_display *display); /* * Finds the output associated with a given head. Can return NULL if the head's * output is disabled. */ struct wd_output *wd_find_output(struct wd_state *state, struct wd_head *head); /* * Finds the head associated with a given output. */ struct wd_head *wd_find_head(struct wd_state *state, struct wd_output *output); /* * Starts listening for output management events from the compositor. */ void wd_add_output_management_listener(struct wd_state *state, struct wl_display *display); /* * Sends updated display configuration back to the compositor. */ void wd_apply_state(struct wd_state *state, struct wl_list *new_outputs, struct wl_display *display); /* * Queues capture of the next frame of all screens. */ void wd_capture_frame(struct wd_state *state); /* * Blocks until all captures are finished. */ void wd_capture_wait(struct wd_state *state, struct wl_display *display); /* * Updates the UI stack of all heads. Does not update individual head forms. * Useful for when a display is plugged/unplugged and we want to add/remove * a page, but we don't want to wipe out user's changes on the other pages. */ void wd_ui_reset_heads(struct wd_state *state); /* * Updates the UI form for a single head. Useful for when the compositor * notifies us of updated configuration caused by another program. */ void wd_ui_reset_head(const struct wd_head *head, unsigned int fields); /* * Updates the stack and all forms to the last known server state. */ void wd_ui_reset_all(struct wd_state *state); /* * Reactivates the GUI after the display configuration updates. */ void wd_ui_apply_done(struct wd_state *state, struct wl_list *outputs); /* * Reactivates the GUI after the display configuration updates. */ void wd_ui_show_error(struct wd_state *state, const char *message); /* * Compiles the GL shaders. */ struct wd_gl_data *wd_gl_setup(void); /* * Renders the GL scene. */ void wd_gl_render(struct wd_gl_data *res, struct wd_render_data *info, uint64_t tick); /* * Destroys the GL shaders. */ void wd_gl_cleanup(struct wd_gl_data *res); /* * Create an overlay on the screen that contains a textual description of the * output. This is to help the user identify the outputs visually. */ void wd_create_overlay(struct wd_output *output); /* * Forces redrawing of the screen overlay on the given output. */ void wd_redraw_overlay(struct wd_output *output); /* * Destroys the screen overlay on the given output. */ void wd_destroy_overlay(struct wd_output *output); #endif wdisplays-0+git20191201/wdisplays.png000066400000000000000000001307451355513134100173710ustar00rootroot00000000000000PNG  IHDR!  IDATxyU7yΩu,}eK *A*+( Dz*rUPP6ܸ \A5 !$,L&̞^z&ef&~ꮚտ:u9B!B!B!B!B!B!B!B!B!B!B!Bl s9uc8J)DB!1f6x=`6lX<WJ4B!Yk1l󑂵cǎ6lX333K+ !B""8Z떖uuOk=nܸ\.Dj!BG APRR8N*#FMB!Ğ,d2A&`1cZ!BF"T*`k#cYkB!`fT4muqDfc?{!Ru]q5B1h( lnowR}4kyyy4{\WW7~x3[nNj*Bz P6侂6f9r$"ZkhH b-F#Glll G]!. l}Lc 3Zeee9B!G1ow6;2~}$1tm斻+c܅B1fnmhGo1hzT!߳ Ŀ#Ѹ Ίd˅B!v i!B!>:G'r"B!!٦7c-B!D?uuuTJKKǍ7ڙ|UOTʸɶnY0$*FQ"͵׷dp#Ǝ Z#&J 1Nl"!Nt?n:sy/]@g͹q[{V$B!v`pꩧ>zͷ߂?yUqӦ.W?Z;2#N/:~2o_?-ʘ:ƿ]zxm+Oh3{+n{;;`H!b@,Y{O'4Bw˞r)}/0ś[0QO/vza?r5w^>eI<[1?퇳sD<N}U_h3gQv }5b,WO<̺_z>Y~1&~!?ပB9sиIc׽ZCPXMc&V&m]؁;!voK8_ej fys7V=Ws{'Ev짟~m_Mɧ\v쇞z~䡿 $=}ֽ/sw^|ׯ>CwI`Q~{|gcq@SW?^wB`g~_UEz]B }6w=W0cwٰ~VwuwWanQm >ȱlz%SKG}Z6} Y;מw`L'_cf5?PjכS9djɟֵK+~ɭK-(9cӇ/y}I=~k=.>e=\ yIG?FH|ԁ14MYXP窅b̮C9f3gO`!QIeX [۠c>Aëw8w.w羸7~xZHHbkfw픊םW>}eGд:h;WC/םmO5jh~w2Э.ɘM;›κfqƍw_y>^~dkߓ 1wܙ?˓'|^=:aO<=h6;^Bk+o0i6lp?U\?oO !v>K Tɾ&[n7oܴqa~ɣtދ xkN>9KR_hqON<'lo] =ۋ,.~g9d0y-5&~g9urW>{_5;O~"If O/V-KHu,ͳf}~@}}%\شG Ac;;;lyilcttueO0˲9RO[=6ap$| dK^|jqpdYylyG XΒLeA#cq`fO=O&|{-bbfV( a'qOuL5n\x_^=W~n !3s?i'222k{}Lon*C~c̺uu\,EP[GDJ7~7[~>gFoѓ jC2b2pR+S??7sLԈl2ˢ| aD1Nh.!G8foXn1zP#O=h0u,nk̑-L:&G |e΍ı?{g'$3AAKx?M8sV)G1ښ`L_S|ً~⠋{l rѡ} V>*%X !v`}ɓ'sg} ; U4UIXI<Zk{W~?WwwtE~W¡o)ѫX7( w}! V.z7eɄm{oIWtY V`/1{֥>+__WqמƯn^SacP'ښzg9|3-8|L߸qUqɣ g=;-woVt.XzWN|Χ-@ٿ_}]oy+rcu]--Y,`/Y;_-Z.pU鍽_^ҺWfJM?çږͻ\glV7Fвɛ~x( ,맷>ݙ|iT}݋/xzg9U !1c+VΚuI[[[[[۬YXr*:֡|>s:zɾ03sY±5]oGlPCCC2BYw~8-_vol,؞x=z`ئ(2TM{{{CCö_|裏Qy{{TH1 }ˇ{ȡnꁧ$U !׮9zw^{44bF}u~BB`m_:~x³?>YiO!H2B!`':}ŝe\&B! 6IzB!`-B!P ֈhhY*X !b N=͎k"}_a;yDrA!%fq:;;1&ۉ1HS!b BmkDTJQMMM*gaˍ1TR2D!o4f٦׭.++ưJ.KR ܀ΡؠDniii,!B!*4 lаͻvlEDdX,` Z g˻pB1h gmv`_@&}-NfB!N:m>Lޞc !B'dB!B!`-B!n1ֵ@B!Bt0m2eU5: J;mmG-/BzK!B$X !B!Z!B B!BHB!BHB!_ii!B#fF_( Z!%t:d>1t뺉D"JkHB!vd @1ƌ?^aXk|{{y B=SJIS T@'9qX,& w!t:-b`e沲l6+$X !}i;q]WB؝ Va$cBo1bO&=B!BHB!# B!BdB!vec j>cJBkLP`;.[ݢn$,Vu:zt6yn]QvGL<<2~gSckg6W9smb"=B! roo-xyOցւ7_zۯmB\?篌ٍcu;??GRu>qk+\_vŻϽKٰcw{*M`o>s~2WnYvC_z|?y+KVQ$X !bppYg}_wscu{8s.+fAO7Cm/̺>$rO_fL׽SOTy1Y;i OࡧJf;dxzg? #%X !9{z?9s(H`:k׬Y/>ޝ:{=7wۇ7Tynso?`CaOrn_{j/#.#g;g0SYv?yg^½s_vO9aK 9@o_vOm?g7ޟȥ<7.ؖKmzbIB_-2V|8!kn8 ߺ-Ϸ7nh[~sYG`}2_J/{[Ո%M6SZ/7[sh`9uBu_*.y,rI!$X !ǬYQcO9␲ng9# 105+Wy=lSi^) >KxP_.kٺ7~ۣ @Y/Ok i'W&N Tl>zWO*}=߾d^zB'ᵯ[ݘG P,bUYwJ+͚g?Ct?v VVrtQ/x¨QJJhZȖ`-B~y㦋~w.nu?aq?㘍nYWn`?4#?WLJ]__M]_~9#eb=r,Fb1UWgOaAmo?xrqz"@LuşxDqŭ?\I_:߾ݞH7j:gM}{XuQkhٖ][cGzܸqASL^F^A`BiTVV ^~ѣۉvhl FD|uuu > B!⣓`-B!k!B!$X !Bې B!2ݠIB!B!HRkOB1C' 3I~`-B :u<9 B!ĠK$Zi{0tvv&Ii]S_G/$Įi B qJMx?['w[t5/K_}Z2Bt7f}s8\$3.3j/J^'Gd2r;:q k3\%1" HrKRFqD  dXY4%49wݘ>sDuBSaf˲s߼Mkt݌H(<\K+ !`-Dֵ:b&0p򨒀sZ6z~3Бon,\u`]}+k-[e1%#NkŤ`?0Mo[-]YV0CQgWk{-acGu,#8Q2"uT"3XB!`-nfڲa5۲/lK)eA{+5 W\`:3 :w}k3w漶N]SX]{awk sFW%KbNx/"F~C_>f_^ޞ$Y !B7vE280<81X. uy][A]a{l$X !b`)N8^e#!YHHZ&",b48[4&1[EN݂-'~9sHӉgҤ Tk7ǼJBJzժߠT9s) Қe˥t D6&l.l#AH$5^@Zu`#G+"@}/ 4eXGBZkk9T@oY66qxnZ4x,sl6kLP(ń1L4q>}jngn/οu//Ӊ'/zmHHl xce3@i< IM҇/[Dbfp<'`3ri-!Gmmm'N${.7;c^sprB `=v@w <Hp7BuB3yQ=4j%w*c^{/{OwJ}C%OhX3s/I_bk^}|N_/:F,}_RHvBdbi+GLj6f׷/^xITa&б-SJUWqMczN Du,1!lF06s̀=oChlk^)qW1uu755u|{=X~ٳj9*E`ˋ+.EW]׷rn{ oryYO~ %w\sɧ+K~ŷ}\|##Bn7R#7e^0m|9076掼(; ֲsp5XX"dd(~AeEXyyyyyyEEy2YBDI$XKkv~Xsб!454ot.V*os!SGF!e`{e67+67&ݫQc'OO=ǾiWKqcxՓ+5@UVT 4:i6wZ k'dQЙ-RkGnt!,!À"cƐRA#a~%(W2"`B8AM86 (@ƲRHy"|SZÁDbuAGAELDډ~Zk-3khKI)~=;U#b$)))!7Chώ66Fkm:. .v/c=6sL8;I&wjm.~ G&'_z!UfGEBrfOg 1. #/.V[^ۜ(lxQd"75X{*6W [Z?OӰ؈h,hnϥAϠdE$ca /`DG ZCc2'ƲFc Y|({}Ьjafp ă!"ƀVi-;-30#!32+k 0{hf$fH$;/S1"c|RDH`*\}"RJm1WeqZ"rG)y^X ^׵Br_gq:t둛o_޽j^ScK}`A}rrjgj7*ZѲ>3[]k=c%OY6Ì c5hq..U ^QqXY$˩tZԖegkoOڦEot׳A*SmFTv8u$0cY)m,u5B*)W4j`Q ` 2pjp|aw!B2 źͺRI\=exH&Gqxkk۲eˌ1ee絵D"~QG555|?qJR˹X.g3uu tZWUU >lUaFeee2Yu 73O>9w75kf̘!g`aw=֮C]bDk)0L y?jE0(&0L`3:  Z낏{~ d=8'"A+``D#F\, >Bٞ|O]S,}6|ດb*u8b1=KcǑB Ʈi,BBD(F*fc -q`lۂDviaݦ:{l2(*鰖rfBÒ a!b X &5S`8?`"6 f@|& E,Bf Ldٚp Ůe{q$ Þj;+]|5#1&L@u eqk-"^W#Z***Z[[~cZ[[˥ń{n*33oQj"۪]Y(L~>8f0 Ha8fk.#õZB@d` ^ݘafCG$"]?D'c= $\gP5jU I=ۓ? 9p3 >b*Rzc[[{{{G*笨1b8\L.Ef{aÆ@CCC㔗 !c=mB~"Drl- |m؅8 ,y"9cL` !hB1P2c, 6Ҁ[ȷgjDjHz![`}<~B-y;ot7e3~wn-wttp| 3c$XiZ>VJnB=4XS Ɗ+W#G"^J13bl,@uQ]yP;M}JFN' pQXfV"02)pD*d˥L0!!5 aEk2kRlu<=SJmJ?Ų Jk%e:vz"BLTT;#g0S,&Me"R80 {x7_mZeLJac"bB3rag ۽[z;|X%,sv!BHɔ@8-ڰ[-0ekqqDBD Ll Zk SXڰ0 16줶 *@N(v,HFNLh׻;VWVVO<3d*-++++3AGQ Yk[{nƠ##B }1 ֵz+O^4]A' =Φ !-hlI`±=ubkZDd`-B6ZdXL;" YvcׯDeK% !sPp'1rѤ)ƖvSU|Ú =*xVk4A)( !LDFs# p|?p[DJLl-F"d}k\HX7ZG َ `m+v*!b"L& |@XJUyE!k|Ϗb gZu3QZ+)j[ks\4Hўd-BHg Ф l!AD.8!@p4"`UQ4h00sK`hË#"jMJ3#*@D`, ֚5" I9L/{ս>C0lv"d=ol \Nkqߪ+(Nkol,F\ZP 52)ug'BT*%Z!`69 S e\ % 0ֲHHƚR-3 hB!vP)UQ100Px D"`pnC!2# PFyZ BVŋ̾l&$ !wDvHE0<pM% TWb氠*}_]uq  ~@sְKX 5Y"z0OZcv-㔔+#XiI")EֲRdUD|>D1@ш֎^>_T!`=PGg a1"3hcAQXo@jTF xA?d9* -X!Wc` !A9Hĥ_Haq~*Z;lk]o5y/|qقnysXM8CL|5Hxr t붵*˃ Xn3 1ufL59 +O [tM~nAD8Z) [v]Wr!S4UBp .) % Y7ZL]gQ)>tE$z݉[hĈZڇUUAhrUXaCcSsGD1Q34B!zr5|>8n!L gxl*4A޷ƂB̊P)-d 5B~1œsܲ P`%*^W-~MͪM1Nwvv֣|o*aaÆB!z!" [Ҁeò{(@` 󓣣8VI;U\JiDTND@HּC p41 St//)\!`Q5|zÚL=@)Eu |"iE*1ֲl} G*|?cDȻLx "p8'[k|0sp@)21=fppuk!BG T0^)0ka7 Kshž?BUJb؃MH n$b-"efO->Ҳc3 _YY8NcccZk0hLbŊ]@FkuA#wraêVB!$Xd]/ƓɃ9L) @]ei#830CCvL IDAT@/Γ@D\ Qʺg#x-J8d5Ac=cT*ED[Xc„vض-y/IMܐXR)"B!`c:95G֘+xR9Q J<眙%BR]A.ꪸEeEAbƺ*( (JH料9܄$>0wrg͹Ϝ !BH񕗖q]PRJ!ɡҒh4bY!Y &8!4Tbbm͈@麎iZ஬sl 9BD/^C>nEO ޣTR\\R\\uYƛ<1`}в,D, a@'D$P٦RxjD BD0!U dY~H? 0\' !ߒd!fGߥ 2:h:<`/olcq>ZkiZ_ZvjrԮ8BHopPJ:7ךl2 q\4ؚP$aX|Z \PhbdY)U V0RQCt:I{vq7lPI6o0i`4BԫWw=i¢ &$ [9pc Fc뚦VJnzƍZk֌1c.v, 4R*k@5 @LD@MހG&h"zw $xfxt [6)G-`b"Ţj)61;Ve|"#RFB冡\VmVʰmu]0*FJ)G?1GK'B mt+ыBTΨ,{=!aǻuQ ! ejm'6" Ivod)))LY_*BH?6WFHT8"vÓ( 啽E;v@EQwŠ<c1PZR*++P(Z4ݳ'ڵk@c1]M*a(s],ˣ5IC![낭~(,Չa)#QBdQ@РYXRPXd*4Q OL8v2&LIIr K!]gq`ua8F!PVrJj,R\\R8볬:uQDlӲ옝RGJNH5+mJteG{݃T-p]kx:\}ЅWU%.v?ƿSrO9qS:ýbV=ߞ#دg}W>|rI&@)>}N4hF`*Q%@CZ ԩ4)V-EiuU;S~Agg.$'%)ÈF"Rh$$Ģ宫KJKlu-- YD{F"/Lu HLL(((tЋڭIgҬg@Xpu.`ܬimrC(_ g/y{>x-g|97,r }_^eטo3'>WUf]\{ﻶojEnX+fW6Oy˩>i:u;5e}+x1;)]pْ8vm[?N2nv.0qH8>ˈly iLJSOs5 %@j!@] P$  \@aƾ4@YYiI wĄzu(Bn*Y; N,j|~SŢ1dP%"eYXưnFRRb~~BiB޷5?8JעsK?tNo]/ UWڕS~DڹLXg=-xvWd-o@6vzp˼W>ڸ3pJ!þq;4P3*3|dU0jP̪8l(@Q[הoL8eGgCɭ]㘻ܼSɦYsg~qРԪ E:ħ e@%%Հ (2eԚH jRmZZk 5 @ 82>H =~7^aarѢE'O uw;vZ(!r6mXuJ~AA]TTTTTt@pЫع3{j?֬ҡ=;rrb97f-j<=~$ꢟ~aJ ̾CG}tS}=2g0{\=d]f<:cOL9sԬ?5}ۓ|O_Cd\ĔM_⏽b?}S/}SpGS_tV{Gueɶxo]ϬlvNko7푩_:GL4;ΛzW7Akk7sK?tޤ;ķ6z{mX=CK? }/lK_mޟF^t[gÌ[l|O]я}SrڸOބfޭc҇;_Za}QYOնXn-~1h׭oX]fL_i=jiުҊ^~f|hNΌz<ؽ[6 _ ֿ XcN _ tm7UTB2W%!2 i2iHC R4,L,e4P(i43 P4PJ)R T>4LHʾ+u(,,,..?{w_96Q/t;U!QUMlL9m;GrSKL}Nοqto۫ \`q\C4q ]|.7o{G{n<:5]tE]UQ^7M~ǿ'2o5q@xl>AWWuID!"R^ۦ\يhv֦ Rl۱P;쬟#LUxk.\ئm=i?|cte`7M_RtHiidߠ dzvݪ_Ԕm|)MRU?w>1bQRGs;6lڜҔ#i!*0  )<-܄ҚD@PB`&IM %1H`a, Q';RߟJJ YBJ"J2-paais),,,,,Ovw\q/87Sҥ3ADFgYHċT釦mYَkנńcA彏?֑t ؅w[䎗?fƂmv{==uS)oMys7`JϷ|`g 27#_xkK5@UZRApjrQ?9˴{w:/|wm Cn9ZEd){Gڙ#osں'?M_>j"{ڼAfipjtvuO)R7ώVU6S$$˲ !)%Y@OԨ1CZίKSh9:{N8mU1_y4)U7!;DZz0+_ǯ:!G%U.7܌5ksvXa~yj `]3[ я>: ]-LP مdJ"!@BB݊T%P$JL[ tz攧5kŋpII۽yp8 ^8~מ28L`]+RM۶B9HSyy͛KK)B6J (**6 Y'ND sЇ-4 hhs'x_,lE>βVwE@6nTlZ0;svTSؒO^TukQZf ֲafn!1콃6:pw/Ei_bTʉUy}݊rwlid5ik3إoѱi늴Do*ױ:3~~őZQrh6zk?T޳l~Qnekʩp`59;mݪL:MN|Twf!=PB?8{쥥!ww}{/Mx[؎0Mu 10j{61 뀒BH" %QQ hL)%p5t])]q4ipІiz0u_|EqE9lA%Kx,^#]!ͽƠD[qmO =̛ݱkNDDXq騵 #d'{@jf@db4Y3v9I^5[B)Eտ &v,khYfk ۶0K{Xڧ[ess#Yl!kCSthtӪ׵}Uv퍶r#L]RX&&TL:PR `IfAҪ~$U&_c|pפ7Wi3ޜ-{6o4yulnoYf:jvݪߩ!<2&+A5gP#WĜhɞEQ |a3Pxa>E -)s~>/,!PSi PiaeRa( !-SL鳔ϔB!P iYiH!eJ))e!-PR() PJ)e*ee2z@zzzzիרQu릥eff&%%![냵뺶mGbX̶5M*u8m8N,b㸮&<$]8_ra%Y1w歺RuUgx{*w歺i;qAEݶm5BnAڵm-:n轹yv--[[5]1lk{o>ޡ귂B~it%ams:p|6э[vZy;:;6*]c.t^I7o7]Qfi6%ιgK ~\֭k-[g49ԙUXqڶey^ پpY6nhlu kn-> A J `e( @A5  )!rD( )JI%U$]TpN:uܹseee:uҥK(ر#L) 0 4MuH)$lڲxqnQAv/2fRÐ+ߩEômztmy]*^sn;{Zwwa׺yai:uE-sҽ{c:tj5~7#k0iknOZuc}J̦mG~UVLSngdCl!BZz`;5ލr~XwzV/v}MN>eǧ\cҷ|/=u7T ]p#Zoxchz-[lbSvhӦC~nYhU޻ذY-5Ln_S5nێ-@ug֡#?1!y-'+5iѲE~~hסiU{7O͋0&(B >S! !$&FbDnT_] 37p4jBe88$ld .4H$5k/ݻ_~)իעEL<3.\ȇo1;!Z))RD$~\ k; B/" vnYqd߽8:􁿤V(!r?d15߮B+Mx041-rpv7vcPȃlq__3vгߤ~4n[UOOJ>rSҜȻ[؆CS'<|L5kO/ 0_?sΗ[H5[OYK@8{+m]Gt'''9KY?r߬ 6&vatYx@ly֛zvku?3F;]:b@Fj@Df}-*"LR[ϑܷ&fajs9սI8}_,>WWe՝Y;yg7b;V?juu4h 33įн{5F1TNbxwjM @%)ՠzo4 Sh ::\^Na;UHe-SNhcG4Q9om1su$1 3èMQI pr4%KP >!-KDm p\0$6Y&MN̶]È7ʒB )ډ؎#D H RJ׶KohWH!ăuufaYܣ c1듆T}&\S!"gjҐ %Z6i- "ZDSA4|BT! P!5SBā(  D{!W)8KvcqP S^Vc{歴u\MP[aZH R!bʐpȍ!Ȳ|eJJC&lj"KZ;BmkB5.%''8*{NFDM{@Do0c9~+O}2 ɕ܌1~e Joʬgc=0xDdzMޗKo ܃"_";biySW>9wN8lcq>"@aZ5i)$4PB!ЋI^'@M$z&ÁqI`EX: (~P#!E D]睊""W&;B#A1cbU$6M3bpʣ045 (4 [Bs0D_\HbwpT{J!h!%Q @P؉:`JHD_XJ?@ ~_)UZRLL1rI (v喒[Q R H+e*Cc1e< IDAT$Q$("H @H*ާ3{Ġ78/W?{KŠo)jM(% ?`@IJ A^b{8#1cy h=[Zij;?J)qpGJD+o2 jBMD7Fe / 4վ+Ui FWHgdjc1c\_ &ȆJ)ɻ&oEMDSD!A +zjG8wY1cɍ Ӓ[Q JjLpp]p\!H &r5\S<Jc1v겲2W{0YSĨNPD\*Dos!Er4M?!ي:.A slGc!i~!@)v@0Jc1 0bulMЉ&(:^A( 2A K!(e`PZA^7A**Bݚ1cueEmh}LҠ5 ND ]W w[k0LH9]BHv! @a1cuBH@HHN1Z I@)o:/#5F ͈^":DNՌ1ck"( g@ "w5 @ M1 W @ [-Ap\c1%p8lVyw;`Jt\LRPB 2-::l) 5I̘@nI8""L+*ZABb^GBe>c1ò|(Rɫ S*kZ -QUn(t]ҚLD$T 4A 0AI4 ӈ?Rc1vA!K ~.-u)JmҀ%HljJ!(Ѯ  W@ZE~ra1`][su>W?4`aTN|ߓ*[r }-)1cu B+@a6Uv:I>(IP|$s4 )خ^F@|='"D u@Jm"yQ݌1cO\M:!1DWecPF%G`@cD1 DiD W(%* "hWK(ءh̑]W |>@'\zCD,_\ @!@IiqY c1"*AHW:A}ZZD)1/@I r" C*Rx!JL}y C F ~$c1`}rEk!"FulKIiZ#u]D)+@@p5(cJX,,,//Wa(庮8JrGY>Sm@va(ear.`1`]s5x]J'[MioҀXM&|?LSg&T>:`.e%c1q)ByT+@ 1FL$m.qϖ¨CR !KD2E $)h5 3vˈȻA(Gt9".*c1'a&6F$ˇ>C$ ZIMs ~Ii`_jBQ-& Ѥ%RDW&@II$I6!qBH!Akh (C(֌1cO:(D@Ӥ@, 蠅𚠽 /f) {(l@oQutO j^=a1cI@W;.9lp\Dt{H+ Z&u2ٶeYjWkr,'fK\"@B/\A -:Iskcu|^״UUwejo%IAd\Ĕp>I]vݩ'cu-z02:&a˧E|Q9x"HI+FejQ%e,nEz '/Zy V΀B{T$F'5$'iR"\וR:Cu]0Hk j4kYi'Rn/}%r\^9+\8^\{-|vhMY ޘޚ㿠jm/m5ӡ_s7z=߽]֏ӆW3`RFcyY૭NW7ɽ91yu6cnE:\H&] "@ޝ@..l Pcv\0 1z!h!4$]햺}ch+@D»ñJC7"*e3eQaqrBP"\2B ޥB m D!H*%m`]C5&&%g6i|~ϲCvRe*p$ ZkǶ֎dNm$ -~/qq]nȩk ~36r❗ϦHJovj:B^!dssvE i*0g͝mARqڹLXg=-xvWd-oqJP}Vf̒tv7̚sI=Gsi5ί91GM:,m\ K҈+4"B']i$M@QlGHؚl Ṕ"`9]@B )-QD@mco_CWh=2.RDy36؞u_ܴZ.NڼtsnZrAM3│ξVgo^mvuwn~Z:+=^Ŭ7/867 _ ֿ$TѰ%B髍6S>ڋN}kW<1匥.i~Ug6]+|Ϝߍ隳[ {} y9Nh;^ȸ uwP)SjS$~K\^J  ;^k.'~F7E'ZejCDE~6s|zQű|m]7 |cUV;77/cQR^ϟ.j̗&Qo7.Z4o_<Ϳ70[3% z8sޔ;_] js vgnoth pW/?0u{Nxw^3jFvu10ЦS5J)W?qӣo&X{ǴY?M\?f袑\Px1Nt=[zZk͞oՅr{m Vk٪Z]S^N>l? ̱-w}M`M9?=eEt[ӷEa`c엇 <Dt ﱗR-9ЪB.|ț6};.zlYƋFO}e+VۿC6nTlZ*;^:JO@Es[ݪۿxl♭:vh߮}#⢗Ox2]=}trոE@?og$c Wn/ց[ƾ&>N+۽TZ\m2]ZTB@Hf;*~w:wşMzj.[t+aqfʗ<۫kbNd76k&yq}!o{Cu:㌮]θfҵW͹7,1~i??Di7|y ux/_>䕗vO=Fv|psK㭫(^IsG /l yɫcw{c͢Z"719+WN2{%ޮvEWerYgCCqʹ}7}`koc 1emٺm{^y0Xat9cRܧ6̻18X3;6ǯcĥ 1cqf1c5c1cc1cc1`c1kc18X3c18X3c11c1֌1cqf1cqf1c5c1cc1`c1`c1 x0ApYY8D{FCDT0 7kc***D"@ !!m0jqR۶f0p$INN6M󷜪k D4 #)))ac,p}:B!5c1v8sb f8kc!"noEec1cc1`c1kc18X3czIO!0~;xE}&Dڍ wn^f*p> HIŖLzƲylyl]5 NoC{vnZƴ֔6kzڡu##_;A”.׍߷J{9tv֯_mڴ]8X3(QVr^:s=}svU5[1wy#fUQ]9gv]$7;{f `aZrWax#}4?%x"w`cҡ=;rrb97f-j<W}4'gƌV=ޭɋY;?NڼtsnZV!,E̞7K?jȟNoY՛M|Kg/jvuwn~Z:;9]olccaPMWC| }z}4b@oO_僊1vT1jpf`Ţ6HjEFtjtW }s§o:䦉Zǰ!#&;mE; wi;ߙcG[cv҅w[(7U&4?okT[DZ_9/߯X8|{]~, ;]%"9,Э(/:@c+wq,Nzk1XeWLw S{4)/xfڷk߹Ǯ7k*6-\>0vtwodI$ JoܢyU 7Y4 Wm#~:+wq,Nzk1X&R3"wkT^]s%{vEû/߽~f}6''s8gʴJ_<8iNɯy./pSRHxO iu(Щfc11% +]kۖcx%{B}V}iXZ6lʿwWHm$E[u;%WMuk6X :wiR;t= =Vjm]c=X/#33igvܣ/K\>o>bj4lޡ_nSek#ŋ"z΍cto Q.Ztw==M}ofm*Jzwm4k!.j&cb6ڵmj~ڶL lw/NC98qm7׮I30˶w]v:c%nfFЋH;[֭xi9Yѿ_ /yifj}q+swk&<vݘDef|KE Mi?vs^V{?嚟G^pw _ҌHMy뫭^c_< =;k=kE/;]л?ǍXO!3Q~W@ 233O iY~cj]\;65nsss5joqٓm0N[)HAA&;CbcㆫoX3c11c1֌1cqf1cqf1c5c1cccD!"D8X3c'RqmJ5c1vrne(A5c1vW\\8^׎HJJJ|>_ j1XlF( Bk:DTJ%&&rfc_A ;9q)c1cc1`c1kc1kc18X3c11cZf1VᲲ2qx_7K0<^{ZS֌1ɮ(Dqo۶a5}AD8Niim{*q)c!G"d4kb50p8\^^)5c,p:yX B{8X3a91#d8{1 IDAT8X3a6O*?ni{O9X3c18X3c11c1֌1c1֌1Ǝ"풇f?b1֌1jIΙ9ٳ?f} rrQGg?vYC.L|e ?xfGgׯ?"JSoՁ &wW?jo{[4)kc5?3ba'N];w]h ~(z~O\}; xbh{hde}IJv|U{S͸K.-5=`cӡ=;rrr~ʚ?cƜuk"[y?~_Mxz#輻_'7g]XT0z}~ĩ#^tΧy_)_Sd\{\껦|w_{tTty2/Kwyu[7-{iy@o(8?,˱ WbeveYiQjeyyQSԲCKͻȳ3/<@RK@*x"~>ߑóϸSzl6l޲%Y/u{{~#gv[qWh- ҥجvh$'.ӷ/o\Zjjɋz?_y4y>79bn϶nV1BCoӽK{dp|J e;~$^ҏ4M<5?ߨF"yC=4^WIϧ%3=SUR !S]9u|4p֔ vN&?6Ȫ2} \}s vK֔` p3ֵB$G>z`)׿.]NN^4oΓɖU>%p&^N{czL_W\]5%X\oN֜ YV)ft6mִL |ClEܶ#gg8}B8B$3.V?bEqfǵ_pɹ)qg mq&%*MW?Ĉ5`&.5E `5@ Xkn$Ie($QSj 5h4A?v]PSj 5xzz3YF(b6===)5bzNζlD;l6[NNNԔ_\`jyyyyyy;E$F]" p z~j ML X Xka=܌Zz\$5l6:n&rLӳUSŒkK^$yzzt:5]VVb^^^8e۵Z7(0Lv`0P UӜTQ,˲bʲl>>>kn#lX C$Idggk[UӂzH$˲,%{:. %%EzxxbOEk$z}^^5 5U%//WQdYV`0 558;Vu8ԴԴt潸v@55(f"I-+RSתiԫ`v sp脫`(Xjnn:**`RJ_M4r3@;y2"11>11Ɉ [|'{53^; ¼/` Etyowmܸj73 o[5o46o/;]KqI!/86>jZmQv!8 };zR|_G"5oݎ?~y^WV !<7vHTq Um|try\=$UOSm7&-?Z[X6)a**j:"#####*Kfp}?g.~1̩K<,;m6B-4.xڡvBsj6}~zg%{~,ڎ;sGߙ*#3wS23_%*!JFpW[nP-7ݐ>p'Cc=@֍v|/vy*?ܣZU%L׮<QE+ ˞{~so?=fUq6oWӡ?'9T]K_#f$n$I̿͜@fL/*!K~*z{i;ܾ oe. ؙ⼉c8"7-x;wv:;OhoO|ѱ#/-9OH/yX{|lUkW^kzsz`U.#>Qʯ{NĞO{hJFcO^sA[>r[jڽjs|3Ƥ54x,L޾藳Β<=}45ZɣJz^3)ۖl;d~nvAQ_㔕MtoV<1wX/Y_v\?WiUDO7燌tRz7kOE$}y6I"ڹm_h/` .Jn=׮_^f&Ep[Seo2WKPwwO_rqc L~^S^ZΟ>cYIϯvZ !>{yw9uy֓M>4e{g ޻dO;' 17jlI׎]!VMrcN 1%o Y\FԮ̉v:BZZ! { 000$$On8kj$ȑp7h4fddi'%%QI/n nn@FFƭ\UjZ * FrrrժUE׏˞"bə(5-*HsM(/.tɪ cUh7 YlGv ](rчVM%IeArՀJFp8臲nk4jZqjfYl[\g~~>e(fӓVzTptL&///5^t6(vgftzVt:V{̙N3''̙3ZE{.`0hڼr٣K' ]7#_o^`K:I_xnE x{ן{Qn攨+f}݁4jmA!DݺuK \6 .]ܢ *wߖlVp)%oߜph2=YϋնUÀ YmkzLІ"<4EfUoMA^iB,:'&ysIѰǧW>wM' OPҳN)?|=f)~#y|9uBrv}3e^Bl]c_~s ѨoQ/$䢵xE5o]P%O>YQ] /PG -/x]>B<Ԗ,Rl[\w7Q!TOU?M-@LzfºBIRIJΑv -^~ƺv袝q"uܟ|A߶]]KͰ pg7*;O'g"==) ( !e6 x6Bǩ-KO쒲cPo40KG<[KtAF_=}riZmGk~ّ|P23_%f/H^,~{Bx7e*\}eCDCwZ]vfs !4@aKc5ThJ9# 5Z?'k<`Svsĕy>> ֩,yn=hޜ' Ǔ-t6btFuPzo^oyNZ% 9kA%ĥ S䂵$IBemr85cJǾMW IE'NwvdYKӝSӠlhH7g&}u?Y6j~:$N@ NM;k'{%d?y[.QįnQĚ=4jڴIX.v2aȂpB9WɞWޚx|N~ cU7݊XS*1|gJ\/T:%~";=k!_%Yx|}Wݖ $z@4?{̿8ſZ24?eg-R+w_Ş[{΄%&Hӊ#DomxW^ջx\HY2֬JT>8uE BCDZLl;q핰Pcv!T~êgGF&^2U>wud@5~\w-Zf(UA4P¢aK-=۴-[9~>vwpٻuM՟d.YԼQ~͚ԐRrzm崤ZMS ܢGGeSZ-AjFNU)d)ۖl6|gTF5?ՠu?8Mxw9ehv;,nCV!ԡp*!G]sG?9zj݊o+N_-铛zbt)875O} ޚS)h)]2޳WjsN]2|Bԍ5 k [p.۸ BEuS\b#/^(V.-:!Zc{ÝTo? Xl S^5iv+&ƌ ; W"=i4!nje "bH Xkk` $)B??HD?` @)h4~(vFÍ5@xzz3h](b6=== (%z^eggl6u6-''Gz:y j֮N$FM;@דML X Xka=b)k|$` @iX,vT lv999WөTfY-KVVf!Xpf I,˲,'@yRRRZ+>\(yyyrIeEQ C~~"X\njPv=y55(RnP^.ẕRYXk@@5|5PQ0p5WN#e>vʎ;`*A7w^sS'ufF%ؿs|vnrv\yx=*5TOMX>j9pIDAT+s-}9K%Sot 9N{LqEj۪a@ڊa32^|=lv-j!Tjzh摚퟿ONq mSuk^?Ñpdǟq~D+ĘO(|vQ>^}:'ENwWMШVI)}6}~<~G江xGt=NӅx":n24e{>9vɐ6 hrqK4tjot#a;WM=o$$$[/Oh@ȩFvsQdIO҃**Wjޅ&|5=6}1fKq=ێ2(~;_}|H X@Ŧmcޜ`Rk4O͔y YvQ`[4OtpSw0q򬱟Pթs '7NS؄>4{}o}ʥM{NjF5 {"FwpTřo8~u<\yE%eg_ݤBht{%1oNίiS߉6Stg>61ÖiUk׼<8g~4ۮfwgu9uiypޢcs^q X@Ŗk钣v!-KOlMٱ?|Ʒ)B۲'B$z理5JHOO-68O5*DҒmz^M !9*Dmg G8l O=~k'gƝ3j[ ..; !ԭK.^lM;e>\W#w$d9E7ps'#%d9dsc5֮|/Gu[nB?BAy>>. VUTB8ԋf?pFփy?}<\,SӢӺר)E]ִ™t6`Zbq&+8lQ<7XR.VP vYI-jՒ<y"gz'p&%8 7yy\r !*PrwLo:.j{i.C9,m'T 1HJ|nꐺ^ yvdD~XeeoE*vvn=3i&F&XU }7UR$Ǯ@M52k-,+6a".HвEV =[-*ս-2LV-la9IVqH*(#3'9l]}^7iƔs(ŭ鈹dM֫hQrӪl;Ǵr@anOw8elSQ֬{_rnB5>{YG|/ΤDfWU׫0rE8Vjͺ߶S'mZJff+5TMOJɿ CJXNSSԝV;_\sJ]{=vBnqSѢ#)!NiPܴnM)əV.jZMS ܢGW%V}gjW3m֤zzJM{5-mYj@ \'-zw!$Z_^>^}/ߛ(q4nM7&ly۩0ܜlk iZ˱_e>۫s/E6w̙埉+ɭŨMTEhܳfs|VAηQ'} (ϪnN=qݎ{\-Z+fgXR^RĎM/Q|9޻OnSkLG6~NFi*ڧGVّ{#Wo>B(ٻݷ%;Û&M,0zw!TzˮC៖9zᩚ#r{*J mDw|{@^3sEsj ꡓh'd|c’~~n,k܌b mgSI#GјrDnC!Ο?Ho^rrrժUEqS"b(k` rUA.;/( @ ໬,P)Rj@%X\nfi4%@55zt: r:&ˋ` mZ3grrr@999gΜj.*Xn$IRWV%&&2(OT*GPPPp~e` pl-7ru"X\MWQV}&XPo܈ L@yê  Xkk` 55@iS-$-\;Iddd8i4F1 ` @RRRjժjnOJJJII AU~/N]V |^a?M1똝kEQ222j֬R>bRVzK=Z_> " 'hP9Z}+#Z.*|+!Y[vS³Eܣ+=YIAc_<1{h~6<+;o.X_%V7le˖_lej|;4YI?3wٮ1<3ֵ3NLM=bO?,.tJjo"X SAoمX+k-L<q%ܹ,`]vjk<`SmO۟V뫑jU៥lToɹ$kJB8@TK*9֪j,H*zu+'ٞ{N{#y8EHJ!nLT`-ԍ;{.4/qݺ/g1YWmyߨ\%fmzn]Sdrȷ-Bh>jpMο֮o:U5'|ѪN*f?p̄5U?%;e+B˩ɏݬ9ֆ$ BPt;/w~v{FpB!YzœpxLJIWu)(@{i47_NScJsRJ酖(6UcJ3?]p9BdqݴZo7ON\+;5.A$FSrex͝jZ.4:wv\r45NaU` 55@ Xk` ` 5@@ X Xk` 5@@ X Xk` 5@ Xkk` 55@ Xkk` 55@ Xk{ 00.L' `3E \IENDB`