[93370] | 1 | /* $Id: display-helper-gnome3.cpp 99620 2023-05-05 09:08:00Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
[93423] | 3 | * Guest Additions - Gnome3 Desktop Environment helper.
|
---|
| 4 | *
|
---|
[93370] | 5 | * A helper for X11/Wayland Client which performs Gnome Desktop
|
---|
| 6 | * Environment specific actions.
|
---|
| 7 | */
|
---|
| 8 |
|
---|
| 9 | /*
|
---|
[98103] | 10 | * Copyright (C) 2006-2023 Oracle and/or its affiliates.
|
---|
[93370] | 11 | *
|
---|
[96407] | 12 | * This file is part of VirtualBox base platform packages, as
|
---|
| 13 | * available from https://www.virtualbox.org.
|
---|
| 14 | *
|
---|
| 15 | * This program is free software; you can redistribute it and/or
|
---|
| 16 | * modify it under the terms of the GNU General Public License
|
---|
| 17 | * as published by the Free Software Foundation, in version 3 of the
|
---|
| 18 | * License.
|
---|
| 19 | *
|
---|
| 20 | * This program is distributed in the hope that it will be useful, but
|
---|
| 21 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 22 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
| 23 | * General Public License for more details.
|
---|
| 24 | *
|
---|
| 25 | * You should have received a copy of the GNU General Public License
|
---|
| 26 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
| 27 | *
|
---|
| 28 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
[93370] | 29 | */
|
---|
| 30 |
|
---|
| 31 | /**
|
---|
| 32 | * This helper implements communication protocol between gnome-settings-daemon
|
---|
| 33 | * and itself using interface defined in (revision e88467f9):
|
---|
| 34 | *
|
---|
| 35 | * https://gitlab.gnome.org/GNOME/mutter/-/blob/main/src/org.gnome.Mutter.DisplayConfig.xml
|
---|
| 36 | */
|
---|
| 37 |
|
---|
| 38 | #include "VBoxClient.h"
|
---|
| 39 | #include "display-helper.h"
|
---|
| 40 |
|
---|
| 41 | #include <stdio.h>
|
---|
| 42 | #include <stdlib.h>
|
---|
| 43 |
|
---|
| 44 | #include <VBox/log.h>
|
---|
| 45 | #include <VBox/VBoxGuestLib.h>
|
---|
| 46 |
|
---|
| 47 | #include <iprt/env.h>
|
---|
| 48 | #include <iprt/initterm.h>
|
---|
| 49 | #include <iprt/message.h>
|
---|
| 50 | #include <iprt/dir.h>
|
---|
| 51 | #include <iprt/err.h>
|
---|
| 52 | #include <iprt/mem.h>
|
---|
| 53 | #include <iprt/string.h>
|
---|
| 54 |
|
---|
[93379] | 55 | /** Load libDbus symbols needed for us. */
|
---|
| 56 | #include <VBox/dbus.h>
|
---|
| 57 | /* Declarations of the functions that we need from libXrandr. */
|
---|
| 58 | #define VBOX_DBUS_GENERATE_BODY
|
---|
| 59 | #include <VBox/dbus-calls.h>
|
---|
| 60 |
|
---|
[93370] | 61 | /** D-bus parameters for connecting to Gnome display service. */
|
---|
| 62 | #define VBOXCLIENT_HELPER_DBUS_DESTINATION "org.gnome.Mutter.DisplayConfig"
|
---|
| 63 | #define VBOXCLIENT_HELPER_DBUS_PATH "/org/gnome/Mutter/DisplayConfig"
|
---|
| 64 | #define VBOXCLIENT_HELPER_DBUS_IFACE "org.gnome.Mutter.DisplayConfig"
|
---|
| 65 | #define VBOXCLIENT_HELPER_DBUS_GET_METHOD "GetCurrentState"
|
---|
| 66 | #define VBOXCLIENT_HELPER_DBUS_APPLY_METHOD "ApplyMonitorsConfig"
|
---|
| 67 |
|
---|
| 68 | /** D-bus communication timeout value, milliseconds.*/
|
---|
| 69 | #define VBOXCLIENT_HELPER_DBUS_TIMEOUT_MS (1 * 1000)
|
---|
| 70 |
|
---|
| 71 | /** gnome-settings-daemon ApplyMonitorsConfig method:
|
---|
| 72 | * 0: verify - test if configuration can be applied and do not change anything,
|
---|
| 73 | * 1: temporary - apply configuration temporary, all will be reverted after re-login,
|
---|
| 74 | * 2: persistent - apply configuration permanently (asks for user confirmation).
|
---|
| 75 | */
|
---|
| 76 | #define VBOXCLIENT_APPLY_DISPLAY_CONFIG_METHOD (1)
|
---|
| 77 |
|
---|
| 78 | /**
|
---|
| 79 | * Helper macro which is used in order to simplify code when batch of
|
---|
| 80 | * values needed to be parsed out of D-bus. Macro prevents execution
|
---|
| 81 | * of the 'next' command if 'previous' one was failed (tracked via
|
---|
| 82 | * local variable _ret). It is required that '_ret' should be initialized
|
---|
| 83 | * to TRUE before batch started.
|
---|
| 84 | *
|
---|
| 85 | * @param _ret Local variable which is used in order to track execution flow.
|
---|
| 86 | * @param _call A function (with full arguments) which returns 'dbus_bool_t'.
|
---|
| 87 | */
|
---|
| 88 | #define VBCL_HLP_GNOME3_NEXT(_ret, _call) \
|
---|
| 89 | { _ret &= _ret ? _call : _ret; if (!ret) VBClLogError(__FILE__ ":%d: check fail here!\n", __LINE__); }
|
---|
| 90 |
|
---|
| 91 | /**
|
---|
| 92 | * This structure describes sub-part of physical monitor state
|
---|
| 93 | * required to compose a payload for calling ApplyMonitorsConfig method. */
|
---|
| 94 | struct vbcl_hlp_gnome3_physical_display_state
|
---|
| 95 | {
|
---|
| 96 | /** Physical display connector name string. */
|
---|
| 97 | char *connector;
|
---|
| 98 | /** Current mode name string for physical display. */
|
---|
| 99 | char *mode;
|
---|
| 100 | };
|
---|
| 101 |
|
---|
| 102 | /**
|
---|
| 103 | * Verify if data represented by D-bus message iteration corresponds to given data type.
|
---|
| 104 | *
|
---|
| 105 | * @return True if D-bus message iteration corresponds to given data type, False otherwise.
|
---|
| 106 | * @param iter D-bus message iteration.
|
---|
| 107 | * @param type D-bus data type.
|
---|
| 108 | */
|
---|
[93378] | 109 | static dbus_bool_t vbcl_hlp_gnome3_verify_data_type(DBusMessageIter *iter, int type)
|
---|
[93370] | 110 | {
|
---|
| 111 | if (!iter)
|
---|
| 112 | return false;
|
---|
| 113 |
|
---|
| 114 | if (dbus_message_iter_get_arg_type(iter) != type)
|
---|
| 115 | return false;
|
---|
| 116 |
|
---|
| 117 | return true;
|
---|
| 118 | }
|
---|
| 119 |
|
---|
| 120 | /**
|
---|
| 121 | * Verifies D-bus iterator signature.
|
---|
| 122 | *
|
---|
| 123 | * @return True if iterator signature matches to given one.
|
---|
| 124 | * @param iter D-bus iterator to check.
|
---|
| 125 | * @param signature Expected iterator signature.
|
---|
| 126 | */
|
---|
[93378] | 127 | static dbus_bool_t vbcl_hlp_gnome3_check_iter_signature(DBusMessageIter *iter, const char *signature)
|
---|
[93370] | 128 | {
|
---|
| 129 | char *iter_signature;
|
---|
| 130 | dbus_bool_t match;
|
---|
| 131 |
|
---|
| 132 | if ( !iter
|
---|
| 133 | || !signature)
|
---|
| 134 | {
|
---|
| 135 | return false;
|
---|
| 136 | }
|
---|
| 137 |
|
---|
| 138 | /* In case of dbus_message_iter_get_signature() returned memory should be freed by us. */
|
---|
| 139 | iter_signature = dbus_message_iter_get_signature(iter);
|
---|
| 140 | match = (strcmp(iter_signature, signature) == 0);
|
---|
| 141 |
|
---|
| 142 | if (!match)
|
---|
| 143 | VBClLogError("iter signature mismatch: '%s' vs. '%s'\n", signature, iter_signature);
|
---|
| 144 |
|
---|
| 145 | if (iter_signature)
|
---|
| 146 | dbus_free(iter_signature);
|
---|
| 147 |
|
---|
| 148 | return match;
|
---|
| 149 | }
|
---|
| 150 |
|
---|
| 151 | /**
|
---|
| 152 | * Verifies D-bus message signature.
|
---|
| 153 | *
|
---|
| 154 | * @return True if message signature matches to given one.
|
---|
[93380] | 155 | * @param message D-bus message to check.
|
---|
[93370] | 156 | * @param signature Expected message signature.
|
---|
| 157 | */
|
---|
[93378] | 158 | static dbus_bool_t vbcl_hlp_gnome3_check_message_signature(DBusMessage *message, const char *signature)
|
---|
[93370] | 159 | {
|
---|
| 160 | char *message_signature;
|
---|
| 161 | dbus_bool_t match;
|
---|
| 162 |
|
---|
| 163 | if ( !message
|
---|
| 164 | || !signature)
|
---|
| 165 | {
|
---|
| 166 | return false;
|
---|
| 167 | }
|
---|
| 168 |
|
---|
| 169 | /* In case of dbus_message_get_signature() returned memory need NOT be freed by us. */
|
---|
| 170 | message_signature = dbus_message_get_signature(message);
|
---|
| 171 | match = (strcmp(message_signature, signature) == 0);
|
---|
| 172 |
|
---|
| 173 | if (!match)
|
---|
| 174 | VBClLogError("message signature mismatch: '%s' vs. '%s'\n", signature, message_signature);
|
---|
| 175 |
|
---|
| 176 | return match;
|
---|
| 177 | }
|
---|
| 178 |
|
---|
| 179 | /**
|
---|
| 180 | * Jump into DBUS_TYPE_ARRAY iter container and initialize sub-iterator
|
---|
| 181 | * aimed to traverse container child nodes.
|
---|
| 182 | *
|
---|
| 183 | * @return True if operation was successful, False otherwise.
|
---|
| 184 | * @param iter D-bus iter of type DBUS_TYPE_ARRAY.
|
---|
| 185 | * @param array Returned sub-iterator.
|
---|
| 186 | */
|
---|
[93378] | 187 | static dbus_bool_t vbcl_hlp_gnome3_iter_get_array(DBusMessageIter *iter, DBusMessageIter *array)
|
---|
[93370] | 188 | {
|
---|
| 189 | if (!iter || !array)
|
---|
| 190 | return false;
|
---|
| 191 |
|
---|
| 192 | if (vbcl_hlp_gnome3_verify_data_type(iter, DBUS_TYPE_ARRAY))
|
---|
| 193 | {
|
---|
| 194 | dbus_message_iter_recurse(iter, array);
|
---|
| 195 | /* Move to the next iter, returned value not important. */
|
---|
| 196 | dbus_message_iter_next(iter);
|
---|
| 197 | return true;
|
---|
| 198 | }
|
---|
| 199 | else
|
---|
| 200 | {
|
---|
| 201 | VBClLogError(
|
---|
| 202 | "cannot get array: argument signature '%s' does not match to type of array\n",
|
---|
| 203 | dbus_message_iter_get_signature(iter));
|
---|
| 204 | }
|
---|
| 205 |
|
---|
| 206 | return false;
|
---|
| 207 | }
|
---|
| 208 |
|
---|
| 209 | /**
|
---|
| 210 | * Get value of D-bus iter of specified simple type (numerals, strings).
|
---|
| 211 | *
|
---|
| 212 | * @return True if operation was successful, False otherwise.
|
---|
| 213 | * @param iter D-bus iter of type simple type.
|
---|
| 214 | * @param type D-bus data type.
|
---|
| 215 | * @param value Returned value.
|
---|
| 216 | */
|
---|
[93378] | 217 | static dbus_bool_t vbcl_hlp_gnome3_iter_get_basic(DBusMessageIter *iter, int type, void *value)
|
---|
[93370] | 218 | {
|
---|
| 219 | if (!iter || !value)
|
---|
| 220 | return false;
|
---|
| 221 |
|
---|
| 222 | if (vbcl_hlp_gnome3_verify_data_type(iter, type))
|
---|
| 223 | {
|
---|
| 224 | dbus_message_iter_get_basic(iter, value);
|
---|
| 225 | /* Move to the next iter, returned value not important. */
|
---|
| 226 | dbus_message_iter_next(iter);
|
---|
| 227 | return true;
|
---|
| 228 | }
|
---|
| 229 | else
|
---|
| 230 | {
|
---|
| 231 | VBClLogError(
|
---|
| 232 | "cannot get value: argument signature '%s' does not match to specified type\n",
|
---|
| 233 | dbus_message_iter_get_signature(iter));
|
---|
| 234 | }
|
---|
| 235 |
|
---|
| 236 | return false;
|
---|
| 237 | }
|
---|
| 238 |
|
---|
| 239 | /**
|
---|
| 240 | * Lookup simple value (numeral, string, bool etc) in D-bus dictionary
|
---|
| 241 | * by given key and type.
|
---|
| 242 | *
|
---|
| 243 | * @return True value is found, False otherwise.
|
---|
| 244 | * @param dict D-bus iterator which represents dictionary.
|
---|
| 245 | * @param key_match Dictionary key.
|
---|
| 246 | * @param type Type of value.
|
---|
| 247 | * @param value Returning value.
|
---|
| 248 | */
|
---|
[93378] | 249 | static dbus_bool_t vbcl_hlp_gnome3_lookup_dict(DBusMessageIter *dict, const char *key_match, int type, void *value)
|
---|
[93370] | 250 | {
|
---|
| 251 | dbus_bool_t found = false;
|
---|
| 252 |
|
---|
| 253 | if (!dict || !key_match)
|
---|
| 254 | return false;
|
---|
| 255 |
|
---|
| 256 | if (!vbcl_hlp_gnome3_check_iter_signature(dict, "{sv}"))
|
---|
| 257 | return false;
|
---|
| 258 |
|
---|
| 259 | do
|
---|
| 260 | {
|
---|
| 261 | dbus_bool_t ret = true;
|
---|
| 262 | DBusMessageIter iter;
|
---|
| 263 | char *key = NULL;
|
---|
| 264 |
|
---|
| 265 | /* Proceed to part a{ > sv < } of a{sv}. */
|
---|
| 266 | dbus_message_iter_recurse(dict, &iter);
|
---|
| 267 |
|
---|
| 268 | /* Should be TRUE in order to satisfy VBCL_HLP_GNOME3_NEXT() requirements. */
|
---|
| 269 | AssertReturn(ret, false);
|
---|
| 270 |
|
---|
| 271 | /* Proceed to part a{ > s < v} of a{sv}. */
|
---|
| 272 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&iter, DBUS_TYPE_STRING, &key));
|
---|
| 273 |
|
---|
| 274 | /* Check if key matches. */
|
---|
| 275 | if (strcmp(key_match, key) == 0)
|
---|
| 276 | {
|
---|
| 277 | DBusMessageIter value_iter;
|
---|
| 278 |
|
---|
| 279 | /* Proceed to part a{s > v < } of a{sv}. */
|
---|
| 280 | dbus_message_iter_recurse(&iter, &value_iter);
|
---|
| 281 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&value_iter, type, value));
|
---|
| 282 |
|
---|
| 283 | /* Make sure there are no more arguments. */
|
---|
| 284 | VBCL_HLP_GNOME3_NEXT(ret, !dbus_message_iter_has_next(&value_iter));
|
---|
| 285 |
|
---|
| 286 | if (ret)
|
---|
| 287 | {
|
---|
| 288 | found = true;
|
---|
| 289 | break;
|
---|
| 290 | }
|
---|
| 291 | }
|
---|
| 292 | }
|
---|
| 293 | while (dbus_message_iter_next(dict));
|
---|
| 294 |
|
---|
| 295 | return found;
|
---|
| 296 | }
|
---|
| 297 |
|
---|
| 298 | /**
|
---|
| 299 | * Go through available modes and pick up the one which has property 'is-current' set.
|
---|
| 300 | * See GetCurrentState interface documentation for more details. Returned string memory
|
---|
| 301 | * must be freed by calling function.
|
---|
| 302 | *
|
---|
| 303 | * @return Mode name as a string if found, NULL otherwise.
|
---|
| 304 | * @param modes List of monitor modes.
|
---|
| 305 | */
|
---|
[93378] | 306 | static char *vbcl_hlp_gnome3_lookup_monitor_current_mode(DBusMessageIter *modes)
|
---|
[93370] | 307 | {
|
---|
| 308 | char *szCurrentMode = NULL;
|
---|
| 309 | DBusMessageIter modes_iter;
|
---|
| 310 |
|
---|
| 311 | /* De-serialization parameters for 'modes': (siiddada{sv}). */
|
---|
| 312 | char *id = NULL;
|
---|
| 313 | int32_t width = 0;
|
---|
| 314 | int32_t height = 0;
|
---|
| 315 | double refresh_rate = 0;
|
---|
| 316 | double preferred_scale = 0;
|
---|
| 317 | DBusMessageIter supported_scales;
|
---|
| 318 | DBusMessageIter properties;
|
---|
| 319 |
|
---|
| 320 | if (!modes)
|
---|
| 321 | return NULL;
|
---|
| 322 |
|
---|
| 323 | if(!vbcl_hlp_gnome3_check_iter_signature(modes, "(siiddada{sv})"))
|
---|
| 324 | return NULL;
|
---|
| 325 |
|
---|
| 326 | do
|
---|
| 327 | {
|
---|
| 328 | static const char *key_match = "is-current";
|
---|
| 329 | dbus_bool_t default_mode_found = false;
|
---|
| 330 | dbus_bool_t ret = true;
|
---|
| 331 |
|
---|
| 332 | /* Should be TRUE in order to satisfy VBCL_HLP_GNOME3_NEXT() requirements. */
|
---|
| 333 | AssertReturn(ret, NULL);
|
---|
| 334 |
|
---|
| 335 | /* Proceed to part a( > siiddada{sv} < ) of a(siiddada{sv}). */
|
---|
| 336 | dbus_message_iter_recurse(modes, &modes_iter);
|
---|
| 337 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&modes_iter, DBUS_TYPE_STRING, &id));
|
---|
| 338 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&modes_iter, DBUS_TYPE_INT32, &width));
|
---|
| 339 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&modes_iter, DBUS_TYPE_INT32, &height));
|
---|
| 340 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&modes_iter, DBUS_TYPE_DOUBLE, &refresh_rate));
|
---|
| 341 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&modes_iter, DBUS_TYPE_DOUBLE, &preferred_scale));
|
---|
| 342 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_array(&modes_iter, &supported_scales));
|
---|
| 343 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_array(&modes_iter, &properties));
|
---|
| 344 |
|
---|
| 345 | ret = vbcl_hlp_gnome3_lookup_dict(&properties, key_match, DBUS_TYPE_BOOLEAN, &default_mode_found);
|
---|
| 346 | if (ret && default_mode_found)
|
---|
| 347 | {
|
---|
| 348 | szCurrentMode = strdup(id);
|
---|
| 349 | break;
|
---|
| 350 | }
|
---|
| 351 | }
|
---|
| 352 | while (dbus_message_iter_next(modes));
|
---|
| 353 |
|
---|
| 354 | return szCurrentMode;
|
---|
| 355 | }
|
---|
| 356 |
|
---|
| 357 | /**
|
---|
| 358 | * Parse physical monitors list entry. See GetCurrentState interface documentation for more details.
|
---|
| 359 | *
|
---|
| 360 | * @return True if monitors list entry has been successfully parsed, False otherwise.
|
---|
| 361 | * @param physical_monitors_in D-bus iterator representing list of physical monitors.
|
---|
| 362 | * @param connector Connector name (out).
|
---|
| 363 | * @param vendor Vendor name (out).
|
---|
| 364 | * @param product Product name (out).
|
---|
| 365 | * @param physical_monitor_serial Serial number (out).
|
---|
| 366 | * @param modes List of monitor modes (out).
|
---|
| 367 | * @param physical_monitor_properties A D-bus dictionary containing monitor properties (out).
|
---|
| 368 | */
|
---|
[93378] | 369 | static dbus_bool_t vbcl_hlp_gnome3_parse_physical_monitor_record(
|
---|
[93370] | 370 | DBusMessageIter *physical_monitors_in,
|
---|
| 371 | char **connector,
|
---|
| 372 | char **vendor,
|
---|
| 373 | char **product,
|
---|
| 374 | char **physical_monitor_serial,
|
---|
| 375 | DBusMessageIter *modes,
|
---|
| 376 | DBusMessageIter *physical_monitor_properties)
|
---|
| 377 | {
|
---|
| 378 | dbus_bool_t ret = true;
|
---|
| 379 |
|
---|
| 380 | DBusMessageIter physical_monitors_in_iter;
|
---|
| 381 | DBusMessageIter physical_monitors_in_description_iter;
|
---|
| 382 |
|
---|
| 383 | if ( !physical_monitors_in
|
---|
| 384 | || !connector
|
---|
| 385 | || !vendor
|
---|
| 386 | || !product
|
---|
| 387 | || !physical_monitor_serial
|
---|
| 388 | || !modes
|
---|
| 389 | || !physical_monitor_properties)
|
---|
| 390 | {
|
---|
| 391 | return false;
|
---|
| 392 | }
|
---|
| 393 |
|
---|
| 394 | /* Validate signature. */
|
---|
| 395 | if (!vbcl_hlp_gnome3_check_iter_signature(physical_monitors_in, "((ssss)a(siiddada{sv})a{sv})"))
|
---|
| 396 | return false;
|
---|
| 397 |
|
---|
| 398 | /* Proceed to part ( > (ssss)a(siiddada{sv})a{sv} < ) of ((ssss)a(siiddada{sv})a{sv}). */
|
---|
| 399 | dbus_message_iter_recurse(physical_monitors_in, &physical_monitors_in_iter);
|
---|
| 400 |
|
---|
| 401 | /* Should be TRUE in order to satisfy VBCL_HLP_GNOME3_NEXT() requirements. */
|
---|
| 402 | AssertReturn(ret, false);
|
---|
| 403 |
|
---|
| 404 | /* Proceed to part ( > (ssss) < a(siiddada{sv})a{sv}) of ((ssss)a(siiddada{sv})a{sv}). */
|
---|
| 405 | dbus_message_iter_recurse(&physical_monitors_in_iter, &physical_monitors_in_description_iter);
|
---|
| 406 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&physical_monitors_in_description_iter, DBUS_TYPE_STRING, connector));
|
---|
| 407 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&physical_monitors_in_description_iter, DBUS_TYPE_STRING, vendor));
|
---|
| 408 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&physical_monitors_in_description_iter, DBUS_TYPE_STRING, product));
|
---|
| 409 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&physical_monitors_in_description_iter, DBUS_TYPE_STRING, physical_monitor_serial));
|
---|
| 410 |
|
---|
| 411 | /* Proceed to part ((ssss) > a(siiddada{sv}) < a{sv}) of ((ssss)a(siiddada{sv})a{sv}). */
|
---|
| 412 | if (ret)
|
---|
| 413 | dbus_message_iter_next(&physical_monitors_in_iter);
|
---|
| 414 |
|
---|
| 415 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_array(&physical_monitors_in_iter, modes));
|
---|
| 416 |
|
---|
| 417 | /* Proceed to part ((ssss)a(siiddada{sv}) > a{sv} < ) of ((ssss)a(siiddada{sv})a{sv}). */
|
---|
| 418 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_array(&physical_monitors_in_iter, physical_monitor_properties));
|
---|
| 419 |
|
---|
| 420 | /* Make sure there are no more arguments. */
|
---|
| 421 | VBCL_HLP_GNOME3_NEXT(ret, !dbus_message_iter_has_next(&physical_monitors_in_iter));
|
---|
| 422 |
|
---|
| 423 | return ret;
|
---|
| 424 | }
|
---|
| 425 |
|
---|
| 426 | /**
|
---|
| 427 | * Parse logical monitors list entry. See GetCurrentState interface documentation for more details.
|
---|
| 428 | *
|
---|
| 429 | * @return True if monitors list entry has been successfully parsed, False otherwise.
|
---|
| 430 | * @param logical_monitors_in D-bus iterator representing list of logical monitors.
|
---|
| 431 | * @param x Monitor X position (out).
|
---|
| 432 | * @param y Monitor Y position (out).
|
---|
| 433 | * @param scale Monitor scale factor (out).
|
---|
| 434 | * @param transform Current monitor transform (rotation) (out).
|
---|
| 435 | * @param primary A flag which indicates if monitor is set as primary (out).
|
---|
| 436 | * @param monitors List of physical monitors which are displaying this logical monitor (out).
|
---|
| 437 | * @param properties List of monitor properties (out).
|
---|
| 438 | */
|
---|
[93378] | 439 | static dbus_bool_t vbcl_hlp_gnome3_parse_logical_monitor_record(
|
---|
[93370] | 440 | DBusMessageIter *logical_monitors_in,
|
---|
| 441 | int32_t *x,
|
---|
| 442 | int32_t *y,
|
---|
| 443 | double *scale,
|
---|
| 444 | uint32_t *transform,
|
---|
| 445 | dbus_bool_t *primary,
|
---|
| 446 | DBusMessageIter *monitors,
|
---|
| 447 | DBusMessageIter *properties)
|
---|
| 448 | {
|
---|
| 449 | dbus_bool_t ret = true;
|
---|
| 450 |
|
---|
| 451 | /* Iter used to traverse logical monitor parameters: @a(iiduba(ssss)a{sv}). */
|
---|
| 452 | DBusMessageIter logical_monitors_in_iter;
|
---|
| 453 |
|
---|
| 454 | if ( !logical_monitors_in
|
---|
| 455 | || !x
|
---|
| 456 | || !y
|
---|
| 457 | || !scale
|
---|
| 458 | || !transform
|
---|
| 459 | || !primary
|
---|
| 460 | || !monitors
|
---|
| 461 | || !properties)
|
---|
| 462 |
|
---|
| 463 | /* Should be TRUE in order to satisfy VBCL_HLP_GNOME3_NEXT() requirements. */
|
---|
| 464 | AssertReturn(ret, false);
|
---|
| 465 |
|
---|
| 466 | /* Proceed to part @a( > iiduba(ssss)a{sv} < ) of @a(iiduba(ssss)a{sv}). */
|
---|
| 467 | dbus_message_iter_recurse(logical_monitors_in, &logical_monitors_in_iter);
|
---|
| 468 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&logical_monitors_in_iter, DBUS_TYPE_INT32, x));
|
---|
| 469 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&logical_monitors_in_iter, DBUS_TYPE_INT32, y));
|
---|
| 470 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&logical_monitors_in_iter, DBUS_TYPE_DOUBLE, scale));
|
---|
| 471 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&logical_monitors_in_iter, DBUS_TYPE_UINT32, transform));
|
---|
| 472 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&logical_monitors_in_iter, DBUS_TYPE_BOOLEAN, primary));
|
---|
| 473 | /* Proceed to part @a(iidub > a(ssss) < a{sv}) of @a(iiduba(ssss)a{sv}). */
|
---|
| 474 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_array(&logical_monitors_in_iter, monitors));
|
---|
| 475 | /* Proceed to part @a(iiduba(ssss) > a{sv} < ) of @a(iiduba(ssss)a{sv}). */
|
---|
| 476 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_array(&logical_monitors_in_iter, properties));
|
---|
| 477 |
|
---|
| 478 | /* Make sure there are no more arguments. */
|
---|
| 479 | VBCL_HLP_GNOME3_NEXT(ret, !dbus_message_iter_has_next(&logical_monitors_in_iter));
|
---|
| 480 |
|
---|
| 481 | return ret;
|
---|
| 482 | }
|
---|
| 483 |
|
---|
| 484 | /**
|
---|
| 485 | * Get list of physical monitors parameters from D-bus iterator.
|
---|
| 486 | *
|
---|
| 487 | * Once this function was traversed 'physical_monitors_in' iterator, we are in the
|
---|
| 488 | * end of the list of physical monitors parameters. So, it is important to do it once.
|
---|
| 489 | *
|
---|
| 490 | * @return True if monitors parameters were successfully discovered, False otherwise.
|
---|
| 491 | * @param physical_monitors_in D-bus iterator representing list of physical monitors.
|
---|
| 492 | * @param state Storage to put monitors state to.
|
---|
| 493 | * @param state_records_max Size of state storage.
|
---|
| 494 | * @param cPhysicalMonitors Actual number of physical displays parsed.
|
---|
| 495 | */
|
---|
[93378] | 496 | static dbus_bool_t vbcl_hlp_gnome3_get_physical_monitors_state(
|
---|
[93370] | 497 | DBusMessageIter *physical_monitors_in,
|
---|
| 498 | vbcl_hlp_gnome3_physical_display_state *state,
|
---|
| 499 | uint32_t state_records_max,
|
---|
| 500 | uint32_t *cPhysicalMonitors)
|
---|
| 501 | {
|
---|
| 502 | dbus_bool_t ret = true;
|
---|
| 503 | uint32_t iMonitor = 0;
|
---|
| 504 |
|
---|
| 505 | if ( !physical_monitors_in
|
---|
| 506 | || !state
|
---|
| 507 | || !cPhysicalMonitors)
|
---|
| 508 | {
|
---|
| 509 | return false;
|
---|
| 510 | }
|
---|
| 511 |
|
---|
| 512 | /* Validate signature. */
|
---|
| 513 | if (!vbcl_hlp_gnome3_check_iter_signature(physical_monitors_in, "((ssss)a(siiddada{sv})a{sv})"))
|
---|
| 514 | return false;
|
---|
| 515 |
|
---|
| 516 | /* Should be TRUE in order to satisfy VBCL_HLP_GNOME3_NEXT() requirements. */
|
---|
| 517 | AssertReturn(ret, false);
|
---|
| 518 |
|
---|
| 519 | do
|
---|
| 520 | {
|
---|
| 521 | char *connector = NULL;
|
---|
| 522 | char *vendor = NULL;
|
---|
| 523 | char *product = NULL;
|
---|
| 524 | char *physical_monitor_serial = NULL;
|
---|
| 525 | DBusMessageIter modes;
|
---|
| 526 | DBusMessageIter physical_monitor_properties;
|
---|
| 527 |
|
---|
| 528 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_parse_physical_monitor_record(
|
---|
| 529 | physical_monitors_in, &connector, &vendor, &product, &physical_monitor_serial,
|
---|
| 530 | &modes, &physical_monitor_properties));
|
---|
| 531 |
|
---|
| 532 | if (iMonitor < state_records_max)
|
---|
| 533 | {
|
---|
| 534 | state[iMonitor].connector = connector;
|
---|
| 535 | state[iMonitor].mode = vbcl_hlp_gnome3_lookup_monitor_current_mode(&modes);
|
---|
| 536 |
|
---|
| 537 | /* Check if both parameters were discovered successfully. */
|
---|
| 538 | VBCL_HLP_GNOME3_NEXT(ret, state[iMonitor].connector && state[iMonitor].mode);
|
---|
| 539 | }
|
---|
| 540 |
|
---|
| 541 | iMonitor++;
|
---|
| 542 |
|
---|
| 543 | }
|
---|
| 544 | while (ret && dbus_message_iter_next(physical_monitors_in));
|
---|
| 545 |
|
---|
| 546 | if (iMonitor >= state_records_max)
|
---|
| 547 | {
|
---|
| 548 | VBClLogError("physical monitors list is too big (%u)\n", iMonitor);
|
---|
| 549 | ret = false;
|
---|
| 550 | }
|
---|
| 551 |
|
---|
| 552 | *cPhysicalMonitors = iMonitor;
|
---|
| 553 |
|
---|
| 554 | return ret;
|
---|
| 555 | }
|
---|
| 556 |
|
---|
| 557 | /**
|
---|
| 558 | * Release monitors state resources.
|
---|
| 559 | *
|
---|
| 560 | * @param state Array of monitor states.
|
---|
| 561 | * @param cPhysicalMonitors Number of elements in array.
|
---|
| 562 | */
|
---|
[93378] | 563 | static void vbcl_hlp_gnome3_free_physical_monitors_state(
|
---|
[93370] | 564 | vbcl_hlp_gnome3_physical_display_state *state,
|
---|
| 565 | uint32_t cPhysicalMonitors)
|
---|
| 566 | {
|
---|
| 567 | if (!state || !cPhysicalMonitors)
|
---|
| 568 | return;
|
---|
| 569 |
|
---|
| 570 | for (uint32_t i = 0; i < cPhysicalMonitors; i++)
|
---|
| 571 | {
|
---|
| 572 | /* Only free() what we allocated ourselves. */
|
---|
| 573 | if (state[i].mode)
|
---|
| 574 | free(state[i].mode);
|
---|
| 575 | }
|
---|
| 576 | }
|
---|
| 577 |
|
---|
| 578 | /**
|
---|
[96868] | 579 | * Add dictionary element with boolean value into an array.
|
---|
| 580 | *
|
---|
| 581 | * @return True on success, False otherwise.
|
---|
| 582 | * @param parent_iter Array to add dictionary element into.
|
---|
| 583 | * @param key Dictionary key.
|
---|
| 584 | * @param value Boolean value for given key.
|
---|
| 585 | */
|
---|
| 586 | static dbus_bool_t vbcl_hlp_gnome3_add_dict_bool_entry(
|
---|
| 587 | DBusMessageIter *parent_iter, const char *key, const dbus_bool_t value)
|
---|
| 588 | {
|
---|
| 589 | dbus_bool_t ret = true;
|
---|
| 590 |
|
---|
| 591 | DBusMessageIter sub_iter_key;
|
---|
| 592 | DBusMessageIter sub_iter_value;
|
---|
| 593 |
|
---|
| 594 | RT_ZERO(sub_iter_key);
|
---|
| 595 | RT_ZERO(sub_iter_value);
|
---|
| 596 |
|
---|
| 597 | /* Should be TRUE in order to satisfy VBCL_HLP_GNOME3_NEXT() requirements. */
|
---|
| 598 | AssertReturn(ret, false);
|
---|
| 599 |
|
---|
| 600 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_open_container(parent_iter, DBUS_TYPE_DICT_ENTRY, NULL, &sub_iter_key));
|
---|
| 601 | {
|
---|
| 602 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_append_basic(&sub_iter_key, DBUS_TYPE_STRING, &key));
|
---|
| 603 |
|
---|
| 604 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_open_container(&sub_iter_key, ((int) 'v'), "b", &sub_iter_value));
|
---|
| 605 | {
|
---|
| 606 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_append_basic(&sub_iter_value, DBUS_TYPE_BOOLEAN, &value));
|
---|
| 607 | }
|
---|
| 608 |
|
---|
| 609 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_close_container(&sub_iter_key, &sub_iter_value));
|
---|
| 610 | }
|
---|
| 611 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_close_container(parent_iter, &sub_iter_key));
|
---|
| 612 |
|
---|
| 613 | return ret;
|
---|
| 614 | }
|
---|
| 615 |
|
---|
| 616 | /**
|
---|
[93370] | 617 | * This function is responsible for gathering current display
|
---|
| 618 | * information (via its helper functions), compose a payload
|
---|
| 619 | * for ApplyMonitorsConfig method and finally send configuration
|
---|
| 620 | * change to gnome-settings-daemon over D-bus.
|
---|
| 621 | *
|
---|
| 622 | * @return IPRT status code.
|
---|
| 623 | * @param connection Handle to D-bus connection.
|
---|
| 624 | * @param serial Serial number obtained from GetCurrentState interface,
|
---|
| 625 | * needs to be passed to ApplyMonitorsConfig.
|
---|
| 626 | * @param physical_monitors_in List of physical monitors (see GetCurrentState).
|
---|
| 627 | * @param logical_monitors_in List of logical monitors (see GetCurrentState).
|
---|
| 628 | * @param idPrimaryDisplay ID (number) of display which is requested to be set as primary.
|
---|
| 629 | */
|
---|
[93378] | 630 | static int vbcl_hlp_gnome3_convert_and_apply_display_settings(
|
---|
[93370] | 631 | DBusConnection *connection,
|
---|
| 632 | uint32_t serial,
|
---|
| 633 | DBusMessageIter *physical_monitors_in,
|
---|
| 634 | DBusMessageIter *logical_monitors_in,
|
---|
| 635 | uint32_t idPrimaryDisplay)
|
---|
| 636 | {
|
---|
| 637 | int rc = VERR_INVALID_PARAMETER;
|
---|
| 638 | uint32_t iLogicalMonitor = 0;
|
---|
| 639 | uint32_t cPhysicalMonitors = 0;
|
---|
| 640 | int32_t method = VBOXCLIENT_APPLY_DISPLAY_CONFIG_METHOD;
|
---|
| 641 |
|
---|
| 642 | dbus_bool_t ret = true;
|
---|
| 643 | DBusError error;
|
---|
| 644 | DBusMessage *reply = NULL;;
|
---|
| 645 | DBusMessage *message = NULL;
|
---|
| 646 | DBusMessageIter message_iter;
|
---|
| 647 | DBusMessageIter logical_monitors_out_iter;
|
---|
| 648 | DBusMessageIter properties_out_iter;
|
---|
| 649 |
|
---|
| 650 | struct vbcl_hlp_gnome3_physical_display_state
|
---|
| 651 | physical_monitors_state[VBOX_DRMIPC_MONITORS_MAX];
|
---|
| 652 |
|
---|
| 653 | if ( !connection
|
---|
| 654 | || !physical_monitors_in
|
---|
| 655 | || !logical_monitors_in)
|
---|
| 656 | {
|
---|
| 657 | return VERR_INVALID_PARAMETER;
|
---|
| 658 | }
|
---|
| 659 |
|
---|
| 660 | /* Important for error handling code path when dbus_message_iter_abandon_container_if_open() is in place. */
|
---|
| 661 | RT_ZERO(message_iter);
|
---|
| 662 | RT_ZERO(logical_monitors_out_iter);
|
---|
| 663 | RT_ZERO(properties_out_iter);
|
---|
| 664 |
|
---|
| 665 | message = dbus_message_new_method_call(
|
---|
| 666 | VBOXCLIENT_HELPER_DBUS_DESTINATION,
|
---|
| 667 | VBOXCLIENT_HELPER_DBUS_PATH,
|
---|
| 668 | VBOXCLIENT_HELPER_DBUS_IFACE,
|
---|
| 669 | VBOXCLIENT_HELPER_DBUS_APPLY_METHOD);
|
---|
| 670 | if (!message)
|
---|
| 671 | {
|
---|
| 672 | VBClLogError("unable to apply monitors config: no memory\n");
|
---|
| 673 | return VERR_NO_MEMORY;
|
---|
| 674 | }
|
---|
| 675 |
|
---|
| 676 | /* Start composing payload for ApplyMonitorsConfig method: (uu@a(iiduba(ssa{sv}))@a{sv}). */
|
---|
| 677 | dbus_message_iter_init_append(message, &message_iter);
|
---|
| 678 |
|
---|
| 679 | /* Should be TRUE in order to satisfy VBCL_HLP_GNOME3_NEXT() requirements. */
|
---|
[96869] | 680 | AssertReturn(ret, VERR_INVALID_PARAMETER);
|
---|
[93370] | 681 |
|
---|
| 682 | /* Get list of physical monitors parameters. */
|
---|
| 683 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_get_physical_monitors_state(
|
---|
| 684 | physical_monitors_in, physical_monitors_state, VBOX_DRMIPC_MONITORS_MAX, &cPhysicalMonitors));
|
---|
| 685 |
|
---|
| 686 | /* ( >u< u@a(iiduba(ssa{sv}))@a{sv}) of (uu@a(iiduba(ssa{sv}))@a{sv}). */
|
---|
| 687 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_append_basic(&message_iter, DBUS_TYPE_UINT32, &serial));
|
---|
| 688 | /* (u >u< @a(iiduba(ssa{sv}))@a{sv}) of (uu@a(iiduba(ssa{sv}))@a{sv}). */
|
---|
| 689 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_append_basic(&message_iter, DBUS_TYPE_UINT32, &method));
|
---|
| 690 |
|
---|
| 691 | /* Parameter "monitors" of method ApplyMonitorsConfig.
|
---|
| 692 | * Part (uu >@a(iiduba(ssa{sv}))< @a{sv}) of (uu@a(iiduba(ssa{sv}))@a{sv}). */
|
---|
| 693 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_open_container(&message_iter, DBUS_TYPE_ARRAY, "(iiduba(ssa{sv}))", &logical_monitors_out_iter));
|
---|
| 694 |
|
---|
| 695 | /* Iterate over current configuration monitors (@logical_monitors
|
---|
| 696 | * parameter of GetCurrentState interface) and compose the rest part of message. */
|
---|
| 697 | do
|
---|
| 698 | {
|
---|
| 699 | /* De-serialization parameters for @logical_monitors data (see GetCurrentState interface documentation). */
|
---|
| 700 | int32_t x = 0;
|
---|
| 701 | int32_t y = 0;
|
---|
| 702 | double scale = 0;
|
---|
| 703 | uint32_t transform = 0;
|
---|
| 704 | dbus_bool_t primary = false;
|
---|
| 705 | dbus_bool_t isPrimary = false;
|
---|
| 706 | DBusMessageIter monitors;
|
---|
| 707 | DBusMessageIter properties;
|
---|
| 708 |
|
---|
| 709 | /* These iterators are used in order to compose sub-containers of the message. */
|
---|
| 710 | DBusMessageIter sub_iter0;
|
---|
| 711 | DBusMessageIter sub_iter1;
|
---|
[96868] | 712 | DBusMessageIter sub_iter2;
|
---|
[93370] | 713 | DBusMessageIter sub_iter3;
|
---|
| 714 | /* Important for error handling code path when dbus_message_iter_abandon_container_if_open() is in place. */
|
---|
| 715 | RT_ZERO(sub_iter0);
|
---|
| 716 | RT_ZERO(sub_iter1);
|
---|
| 717 | RT_ZERO(sub_iter2);
|
---|
| 718 | RT_ZERO(sub_iter3);
|
---|
| 719 |
|
---|
| 720 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_parse_logical_monitor_record(
|
---|
| 721 | logical_monitors_in, &x, &y, &scale, &transform, &primary, &monitors, &properties));
|
---|
| 722 |
|
---|
| 723 | if (ret)
|
---|
| 724 | {
|
---|
| 725 | /* Whether current display supposed to be set as primary. */
|
---|
| 726 | isPrimary = (iLogicalMonitor == idPrimaryDisplay);
|
---|
| 727 |
|
---|
| 728 | /* Compose part (uu@a( > iiduba(ssa{sv}) < )@a{sv}) of (uu@a(iiduba(ssa{sv}))@a{sv}). */
|
---|
| 729 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_open_container(&logical_monitors_out_iter, DBUS_TYPE_STRUCT, NULL, &sub_iter0));
|
---|
| 730 | {
|
---|
| 731 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_append_basic(&sub_iter0, DBUS_TYPE_INT32, &x));
|
---|
| 732 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_append_basic(&sub_iter0, DBUS_TYPE_INT32, &y));
|
---|
| 733 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_append_basic(&sub_iter0, DBUS_TYPE_DOUBLE, &scale));
|
---|
| 734 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_append_basic(&sub_iter0, DBUS_TYPE_UINT32, &transform));
|
---|
| 735 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_append_basic(&sub_iter0, DBUS_TYPE_BOOLEAN, &isPrimary));
|
---|
| 736 |
|
---|
| 737 | /* Compose part (uu@a(iidub > a(ssa{sv}) < )@a{sv}) of (uu@a(iiduba(ssa{sv}))@a{sv}). */
|
---|
| 738 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_open_container(&sub_iter0, DBUS_TYPE_ARRAY, "(ssa{sv})", &sub_iter1));
|
---|
| 739 | {
|
---|
| 740 | /* Compose part (uu@a(iiduba > (ssa{sv}) < )@a{sv}) of (uu@a(iiduba(ssa{sv}))@a{sv}). */
|
---|
| 741 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_open_container(&sub_iter1, DBUS_TYPE_STRUCT, NULL, &sub_iter2));
|
---|
| 742 | {
|
---|
| 743 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_append_basic(&sub_iter2, DBUS_TYPE_STRING, &physical_monitors_state[iLogicalMonitor].connector));
|
---|
| 744 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_append_basic(&sub_iter2, DBUS_TYPE_STRING, &physical_monitors_state[iLogicalMonitor].mode));
|
---|
| 745 |
|
---|
[96868] | 746 | /* Compose part (uu@a(iiduba(ss > a{sv} < ))@a{sv}) of (uu@a(iiduba(ssa{sv}))@a{sv}). */
|
---|
[93370] | 747 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_open_container(&sub_iter2, DBUS_TYPE_ARRAY, "{sv}", &sub_iter3));
|
---|
[96868] | 748 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_add_dict_bool_entry(&sub_iter3, "is-current", true));
|
---|
| 749 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_add_dict_bool_entry(&sub_iter3, "is-preferred", true));
|
---|
[93370] | 750 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_close_container(&sub_iter2, &sub_iter3));
|
---|
| 751 | }
|
---|
| 752 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_close_container(&sub_iter1, &sub_iter2));
|
---|
| 753 | }
|
---|
| 754 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_close_container(&sub_iter0, &sub_iter1));
|
---|
| 755 | }
|
---|
| 756 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_close_container(&logical_monitors_out_iter, &sub_iter0));
|
---|
| 757 |
|
---|
| 758 | iLogicalMonitor++;
|
---|
| 759 |
|
---|
| 760 | if (!ret)
|
---|
| 761 | {
|
---|
| 762 | dbus_message_iter_abandon_container_if_open(&sub_iter2, &sub_iter3);
|
---|
| 763 | dbus_message_iter_abandon_container_if_open(&sub_iter1, &sub_iter2);
|
---|
| 764 | dbus_message_iter_abandon_container_if_open(&sub_iter0, &sub_iter1);
|
---|
| 765 | dbus_message_iter_abandon_container_if_open(&logical_monitors_out_iter, &sub_iter0);
|
---|
| 766 | }
|
---|
| 767 | }
|
---|
| 768 | else
|
---|
| 769 | {
|
---|
| 770 | break;
|
---|
| 771 | }
|
---|
| 772 |
|
---|
| 773 | }
|
---|
| 774 | while (ret && dbus_message_iter_next(logical_monitors_in));
|
---|
| 775 |
|
---|
| 776 | /* Finish with parameter "monitors" of method ApplyMonitorsConfig. */
|
---|
| 777 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_close_container(&message_iter, &logical_monitors_out_iter));
|
---|
| 778 |
|
---|
| 779 | /* Parameter "properties" of method ApplyMonitorsConfig (empty dict).
|
---|
| 780 | * Part (uu@a(iiduba(ssa{sv})) >@a{sv}< ) of (uu@a(iiduba(ssa{sv}))@a{sv}).*/
|
---|
| 781 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_open_container(&message_iter, DBUS_TYPE_ARRAY, "{sv}", &properties_out_iter));
|
---|
| 782 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_close_container(&message_iter, &properties_out_iter));
|
---|
| 783 |
|
---|
| 784 | if (ret)
|
---|
| 785 | {
|
---|
| 786 | dbus_error_init(&error);
|
---|
| 787 |
|
---|
| 788 | reply = dbus_connection_send_with_reply_and_block(connection, message, VBOXCLIENT_HELPER_DBUS_TIMEOUT_MS, &error);
|
---|
| 789 | if (reply)
|
---|
| 790 | {
|
---|
| 791 | VBClLogInfo("display %d has been set as primary\n", idPrimaryDisplay);
|
---|
| 792 | dbus_message_unref(reply);
|
---|
| 793 | rc = VINF_SUCCESS;
|
---|
| 794 | }
|
---|
| 795 | else
|
---|
| 796 | {
|
---|
| 797 | VBClLogError("unable to apply monitors config: %s\n",
|
---|
| 798 | dbus_error_is_set(&error) ? error.message : "unknown error");
|
---|
| 799 | dbus_error_free(&error);
|
---|
| 800 | rc = VERR_INVALID_PARAMETER;
|
---|
| 801 | }
|
---|
| 802 | }
|
---|
| 803 | else
|
---|
| 804 | {
|
---|
| 805 | VBClLogError("unable to apply monitors config: cannot compose monitors config\n");
|
---|
| 806 |
|
---|
| 807 | dbus_message_iter_abandon_container_if_open(&message_iter, &logical_monitors_out_iter);
|
---|
| 808 | dbus_message_iter_abandon_container_if_open(&message_iter, &properties_out_iter);
|
---|
| 809 |
|
---|
| 810 | rc = VERR_INVALID_PARAMETER;
|
---|
| 811 | }
|
---|
| 812 |
|
---|
| 813 | /* Clean physical monitors state. */
|
---|
| 814 | vbcl_hlp_gnome3_free_physical_monitors_state(physical_monitors_state, cPhysicalMonitors);
|
---|
| 815 |
|
---|
| 816 | dbus_message_unref(message);
|
---|
| 817 |
|
---|
| 818 | return rc;
|
---|
| 819 | }
|
---|
| 820 |
|
---|
| 821 | /**
|
---|
| 822 | * This function parses GetCurrentState interface call reply and passes it for further processing.
|
---|
| 823 | *
|
---|
| 824 | * @return IPRT status code.
|
---|
| 825 | * @param connection Handle to D-bus connection.
|
---|
| 826 | * @param idPrimaryDisplay ID (number) of display which is requested to be set as primary.
|
---|
| 827 | * @param reply Reply message of GetCurrentState call.
|
---|
| 828 | */
|
---|
[93378] | 829 | static int vbcl_hlp_gnome3_process_current_display_layout(
|
---|
[93370] | 830 | DBusConnection *connection, uint32_t idPrimaryDisplay, DBusMessage *reply)
|
---|
| 831 | {
|
---|
| 832 | static const char *expected_signature = "ua((ssss)a(siiddada{sv})a{sv})a(iiduba(ssss)a{sv})a{sv}";
|
---|
| 833 |
|
---|
| 834 | dbus_bool_t ret = true;
|
---|
| 835 | DBusMessageIter iter;
|
---|
| 836 | int rc = VERR_GENERAL_FAILURE;
|
---|
| 837 |
|
---|
| 838 | uint32_t serial = 0;
|
---|
| 839 | DBusMessageIter monitors;
|
---|
| 840 | DBusMessageIter logical_monitors_in;
|
---|
| 841 | DBusMessageIter properties;
|
---|
| 842 |
|
---|
| 843 | if (!reply)
|
---|
| 844 | {
|
---|
| 845 | return VERR_INVALID_PARAMETER;
|
---|
| 846 | }
|
---|
| 847 |
|
---|
| 848 | /* Parse VBOXCLIENT_HELPER_DBUS_GET_METHOD reply payload:
|
---|
| 849 | *
|
---|
| 850 | * (u@a((ssss)a(siiddada{sv})a{sv})@a(iiduba(ssss)a{sv})@a{sv}).
|
---|
| 851 | *
|
---|
| 852 | * Method return the following arguments: monitors, logical_monitors, properties.
|
---|
| 853 | */
|
---|
| 854 |
|
---|
| 855 | /* Should be TRUE in order to satisfy VBCL_HLP_GNOME3_NEXT() requirements. */
|
---|
[96869] | 856 | AssertReturn(ret, VERR_INVALID_PARAMETER);
|
---|
[93370] | 857 |
|
---|
| 858 | /* Important: in order to avoid libdbus asserts during parsing, its signature should be verified at first. */
|
---|
| 859 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_check_message_signature(reply, expected_signature));
|
---|
| 860 |
|
---|
| 861 | VBCL_HLP_GNOME3_NEXT(ret, dbus_message_iter_init(reply, &iter));
|
---|
| 862 | if (ret)
|
---|
| 863 | {
|
---|
| 864 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_basic(&iter, DBUS_TYPE_UINT32, &serial));
|
---|
| 865 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_array(&iter, &monitors));
|
---|
| 866 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_array(&iter, &logical_monitors_in));
|
---|
| 867 | VBCL_HLP_GNOME3_NEXT(ret, vbcl_hlp_gnome3_iter_get_array(&iter, &properties));
|
---|
| 868 |
|
---|
| 869 | /* Make sure there are no more arguments. */
|
---|
| 870 | if (ret && !dbus_message_iter_has_next(&iter))
|
---|
| 871 | {
|
---|
| 872 | rc = vbcl_hlp_gnome3_convert_and_apply_display_settings(
|
---|
| 873 | connection, serial, &monitors, &logical_monitors_in, idPrimaryDisplay);
|
---|
| 874 | }
|
---|
| 875 | else
|
---|
| 876 | {
|
---|
| 877 | VBClLogError("cannot fetch current displays configuration: incorrect number of arguments\n");
|
---|
| 878 | rc = VERR_INVALID_PARAMETER;
|
---|
| 879 | }
|
---|
| 880 | }
|
---|
| 881 | else
|
---|
| 882 | {
|
---|
| 883 | VBClLogError("cannot fetch current displays configuration: no data\n");
|
---|
| 884 | rc = VERR_INVALID_PARAMETER;
|
---|
| 885 | }
|
---|
| 886 |
|
---|
| 887 | return rc;
|
---|
| 888 | }
|
---|
| 889 |
|
---|
| 890 | /**
|
---|
| 891 | * This function establishes D-bus connection, requests gnome-settings-daemon
|
---|
| 892 | * to provide current display configuration via GetCurrentState interface call
|
---|
| 893 | * and passes this information further to helper functions in order to set
|
---|
| 894 | * requested display as primary.
|
---|
| 895 | *
|
---|
| 896 | * @return IPRT status code.
|
---|
| 897 | * @param idPrimaryDisplay A display ID which is requested to be set as primary.
|
---|
| 898 | */
|
---|
[93378] | 899 | static DECLCALLBACK(int) vbcl_hlp_gnome3_set_primary_display(uint32_t idPrimaryDisplay)
|
---|
[93370] | 900 | {
|
---|
| 901 | int rc = VERR_GENERAL_FAILURE;
|
---|
| 902 |
|
---|
| 903 | DBusConnection *connection = NULL;
|
---|
| 904 | DBusMessage *message = NULL;
|
---|
| 905 | DBusError error;
|
---|
| 906 |
|
---|
| 907 | rc = RTDBusLoadLib();
|
---|
| 908 | if (RT_FAILURE(rc))
|
---|
| 909 | {
|
---|
| 910 | VBClLogError("unable to load D-bus library\n");
|
---|
| 911 | return VERR_SYMBOL_NOT_FOUND;
|
---|
| 912 | }
|
---|
| 913 |
|
---|
| 914 | dbus_error_init(&error);
|
---|
| 915 | connection = dbus_bus_get(DBUS_BUS_SESSION, &error);
|
---|
| 916 | if (!dbus_error_is_set(&error))
|
---|
| 917 | {
|
---|
| 918 | message = dbus_message_new_method_call(
|
---|
| 919 | VBOXCLIENT_HELPER_DBUS_DESTINATION,
|
---|
| 920 | VBOXCLIENT_HELPER_DBUS_PATH,
|
---|
| 921 | VBOXCLIENT_HELPER_DBUS_IFACE,
|
---|
| 922 | VBOXCLIENT_HELPER_DBUS_GET_METHOD);
|
---|
| 923 |
|
---|
| 924 | if (message)
|
---|
| 925 | {
|
---|
| 926 | DBusMessage *reply;
|
---|
| 927 |
|
---|
| 928 | reply = dbus_connection_send_with_reply_and_block(connection, message, VBOXCLIENT_HELPER_DBUS_TIMEOUT_MS, &error);
|
---|
| 929 | if (!dbus_error_is_set(&error))
|
---|
| 930 | {
|
---|
| 931 | rc = vbcl_hlp_gnome3_process_current_display_layout(connection, idPrimaryDisplay, reply);
|
---|
| 932 | dbus_message_unref(reply);
|
---|
| 933 | }
|
---|
| 934 | else
|
---|
| 935 | {
|
---|
| 936 | VBClLogError("unable to get current display configuration: %s\n", error.message);
|
---|
| 937 | dbus_error_free(&error);
|
---|
| 938 | rc = VERR_INVALID_PARAMETER;
|
---|
| 939 | }
|
---|
| 940 |
|
---|
| 941 | dbus_message_unref(message);
|
---|
| 942 | }
|
---|
| 943 | else
|
---|
| 944 | {
|
---|
| 945 | VBClLogError("unable to get current display configuration: no memory\n");
|
---|
| 946 | rc = VERR_NO_MEMORY;
|
---|
| 947 | }
|
---|
| 948 |
|
---|
| 949 | dbus_connection_flush(connection);
|
---|
| 950 | }
|
---|
| 951 | else
|
---|
| 952 | {
|
---|
| 953 | VBClLogError("unable to establish dbus connection: %s\n", error.message);
|
---|
| 954 | dbus_error_free(&error);
|
---|
| 955 | rc = VERR_INVALID_HANDLE;
|
---|
| 956 | }
|
---|
| 957 |
|
---|
| 958 | return rc;
|
---|
| 959 | }
|
---|
| 960 |
|
---|
| 961 | /**
|
---|
| 962 | * @interface_method_impl{VBCLDISPLAYHELPER,pfnProbe}
|
---|
| 963 | */
|
---|
[93378] | 964 | static DECLCALLBACK(int) vbcl_hlp_gnome3_probe(void)
|
---|
[93370] | 965 | {
|
---|
[99585] | 966 | const char *pszCurrentDesktop = RTEnvGet(VBGH_ENV_XDG_CURRENT_DESKTOP);
|
---|
[93370] | 967 |
|
---|
| 968 | /* GNOME3 identifies itself by XDG_CURRENT_DESKTOP environment variable.
|
---|
| 969 | * It can slightly vary for different distributions, but we assume that this
|
---|
| 970 | * variable should at least contain sub-string 'GNOME' in its value. */
|
---|
| 971 | if (pszCurrentDesktop && RTStrStr(pszCurrentDesktop, "GNOME"))
|
---|
| 972 | return VINF_SUCCESS;
|
---|
| 973 |
|
---|
| 974 | return VERR_NOT_FOUND;
|
---|
| 975 | }
|
---|
| 976 |
|
---|
| 977 | /**
|
---|
| 978 | * @interface_method_impl{VBCLDISPLAYHELPER,pfnInit}
|
---|
| 979 | */
|
---|
[93378] | 980 | static DECLCALLBACK(int) vbcl_hlp_gnome3_init(void)
|
---|
[93370] | 981 | {
|
---|
| 982 | int rc;
|
---|
| 983 |
|
---|
[99620] | 984 | if (VBClGetDisplayServerType() == VBGHDISPLAYSERVERTYPE_X11)
|
---|
[93370] | 985 | {
|
---|
| 986 | rc = vbcl_hlp_generic_init();
|
---|
| 987 | VBClLogInfo("attempt to start generic helper routines, rc=%Rrc\n", rc);
|
---|
| 988 | }
|
---|
| 989 |
|
---|
| 990 | return VINF_SUCCESS;
|
---|
| 991 | }
|
---|
| 992 |
|
---|
| 993 | /**
|
---|
| 994 | * @interface_method_impl{VBCLDISPLAYHELPER,pfnTerm}
|
---|
| 995 | */
|
---|
[93378] | 996 | static DECLCALLBACK(int) vbcl_hlp_gnome3_term(void)
|
---|
[93370] | 997 | {
|
---|
| 998 | int rc;
|
---|
| 999 |
|
---|
[99620] | 1000 | if (VBClGetDisplayServerType() == VBGHDISPLAYSERVERTYPE_X11)
|
---|
[93370] | 1001 | {
|
---|
| 1002 | rc = vbcl_hlp_generic_term();
|
---|
| 1003 | VBClLogInfo("attempt to stop generic helper routines, rc=%Rrc\n", rc);
|
---|
| 1004 | }
|
---|
| 1005 |
|
---|
| 1006 | return VINF_SUCCESS;
|
---|
| 1007 | }
|
---|
| 1008 |
|
---|
| 1009 | /* Helper callbacks. */
|
---|
| 1010 | const VBCLDISPLAYHELPER g_DisplayHelperGnome3 =
|
---|
| 1011 | {
|
---|
| 1012 | "GNOME3", /* .pszName */
|
---|
| 1013 | vbcl_hlp_gnome3_probe, /* .pfnProbe */
|
---|
| 1014 | vbcl_hlp_gnome3_init, /* .pfnInit */
|
---|
| 1015 | vbcl_hlp_gnome3_term, /* .pfnTerm */
|
---|
| 1016 | vbcl_hlp_gnome3_set_primary_display, /* .pfnSetPrimaryDisplay */
|
---|
| 1017 | vbcl_hlp_generic_subscribe_display_offset_changed, /* .pfnSubscribeDisplayOffsetChangeNotification */
|
---|
| 1018 | vbcl_hlp_generic_unsubscribe_display_offset_changed, /* .pfnUnsubscribeDisplayOffsetChangeNotification */
|
---|
| 1019 | };
|
---|