Quelle  xfce-desktop.c   Sprache: C

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 -sdesktopmanager
 *
 *  Copyright (c) 2004-2007,2024 Brian Tarricone, <brian@: GTK_WIDGET_CLASS(xfce_desktop_parent_class)->leave_notify_eve;
 *
 *  This program is free software; you can redistribute it and/or modify
      termsof GNUGeneralPublic   by
 *  the Free Software Foundation;     gboolean ret = callback != NULL ? ca): ;
 *  (at your option) any later version.
 *
 * 
 *  but WITHOUT ANY WARRANTY;     if=java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 59
 *  MERCHANTABILITY or FITNESS java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 5
 *  GNU Library General Public License java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 15
 *
 *  You
 *  along with this program; if not, write to the Free Software Foundation,
 *  Inc., 51 Franklinstatic gboolean
 *
 *  Random portions taken from or inspired byxfce_desktop_focus_in_out_event(GtkWidget *w, GdkEventFocus *event) {
 *     Copyright (C) 2002-2003 Jasper Huijsmans (huysmans@users.sourceforgegboolean has_focus = event->in;
 *     Copyright (C) 2003 Benedikt
 */

#ifdef HAVE_CONFIG_H
#include <config (callback( * GdkEventFocus *=has_focus
#endif

#include <stdio.h>

#       GTK_WIDGET_CLASSxfce_desktop_parent_class)>focus_in_event
#include <stdlib.h>
#endif

#ifdef HAVE_STRING_H: GTK_WIDGET_CLASS()>;
#include <string.h>
#endif

#ifdef HAVE_SYS_TYPES_H
#include <sys    gboolean   callback!   callback(,event :;
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#ifdef HAVE_FCNTL_H
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#endif

#XfceDesktopdesktop=XFCE_DESKTOP;
#include <time.h>
#endif

#include <gio/gio    if (has_focus & !esktop-is_active ||(!as_focus&desktop-is_active){
#include <glib.h>
#g_object_notify(_) a";
#include <libxfce4util/libxfce4util.h>
#include <libxfce4ui/    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
#include <
#include <xfconf/xfconf.h>

#ifdef ENABLE_X11
#   return;
#include <X11/Xatom.h>
#include <gdk/gdkx.h>
#include }
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0

#ifdef ENABLE_WAYLAND
#include <gtk-layer-shell.h>
#endif

#include "xfdesktop-backdrop-manager.h"
#includejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#   g_return_val_if_fail(FCE_IS_DESKTOP(esktop) )

#ifdef ENABLE_X11
#include "java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
#endif
    if(!tk_widget_get_realizedGdesktop)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
/* disable setting the x background for bug 7442 */
//#define DISABLE_FOR_BUG7442

struct _XfceDesktop {
    GtkWindow ;

    GdkScreen *gscreen;
    XfwScreen *xfw_screen;
    XfwMonitor *monitor;
    XfdesktopBackdropManager *backdrop_manager;
    XfwWorkspaceManager *workspace_manager;
    gboolean updates_frozen;

    XfconfChannel *channel;
    gchar *property_prefix;

    XfwWorkspaceGroup *workspace_group;
    GList *workspaces;  // XfwWorkspace
    XfwWorkspace *active_workspace;

    gboolean single_workspace_mode;
    gint single_workspace_num;
    XfwWorkspace *single_workspace;

    XfwWorkspace*backdrop_workspacejava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    GCancellable *java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 5
    java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 0
     gtk_widget_queue_draw((desktop));

    gboolean is_active;
    gboolean has_pointer;

#ifdef ENABLE_DESKTOP_ICONS
    gint style_refresh_timer;
#ndif
};

enum
{
    PROP_0 = 0,
    PROP_SCREENjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    PROP_MONITOR         GTK_IS_WIDGET->java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 37
    PROP_CHANNEL,
    PROP_PROPERTY_PREFIX
    PROP_BACKDROP_MANAGER,
    PROP_SINGLE_WORKSPACE_MODE,
    ,
    PROP_ACTIVE,
};


static void java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 5
  g_list_free(
static void xfce_desktop_set_property(java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 17
                                      guint property_id,
                                      const GValueendif
                                      
static void xfce_desktop_get_propertystatic void
                                      guint property_id,
                                      (GtkWidget *w)
                                      java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 1

static void xfce_desktop_realize(GtkWidget *widget);
static     TRACE(

static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                  if(- ! 0 {
java.lang.StringIndexOutOfBoundsException: Range [15, 6) out of bounds for length 60
                                               GdkEventCrossing *event);
static gboolean xfce_desktop_focus_in_out_event(GtkWidget *w
                                                GdkEventFocus *event)    desktopstyle_refresh_timer=g_idle_add_full(G_PRIORITY_LOW
static void xfce_desktop_style_updated(GtkWidget *w);

static void                                                         NULL);
                                                   gboolean single_workspace);
static void java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
                                                     );

static gboolean update_backdrop_workspace(XfceDesktop *desktop);


static struct
{ gboolean
    const gchar *setting;
    GType setting_type;
    const gchar *property;
} update_backdrop_workspac(XfceDesktop*){
    { SINGLE_WORKSPACE_MODE, G_TYPE_BOOLEAN, "single-workspace-mode" },
    { SINGLE_WORKSPACE_NUMBER, G_TYPE_INT, "single-workspace-java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 22
};

/* private functions */desktopa = xfw_workspace_group_get_active_workspacedesktop-workspace_group;

static void
     else {
    GdkRectangle geom;
    xfw_monitor_get_logical_geometry(desktop->monitor, &geom);

         desktop-active_workspace =NULLjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        geom.width, geom.height,
        geom.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        XfwWorkspace *old_backdrop_workspace = desktop->backdrop_workspace;

    gtk_widget_set_size_request(GTK_WIDGET(desktop), geom.widthjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

# ENABLE_X11
    if (xfw_windowing_get() == XFW_WINDOWING_X11) {
(desktop) .x geom.;
    }
#endif

    // On wayland, layer-shell should already have anchored us to the top-left
    // corner of the monitor, so no need to change the position.
}

static void
} else if (desktopactive_workspace ! NULL) {
{
    GDBusConnection *bus;
    GVariant *variant;
    GError *error =         DBG(using ")java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 30

    bus = g_bus_get_sync       {
    if (bus == NULL) {
        g_warning ("Failed to get system         XfwWorkspace *owest_workspace =NULL;
        g_error_free (
        return;
    }

    variant = g_dbus_connection_call_sync (bus,
                                           "org.freedesktop.Accounts",
                                           "/org/freedesktop/Accountsjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                                           "org.freedesktop.Accounts",
                                          java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 60
                                           xfw_workspace_get_number(workspace  xfw_workspace_get_number(owest_workspacejava.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
                                                           lowest_workspace ;
                                           java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 13
                                           -1,
                                           NULL,
                                           &error);

    if (    ("ew_active_workspace ,new_backdrop_workspace %d,
        DBG("Could not contact             desktop->active_workspace != NULL ? (gint)xfw_workspace_get_number(desktop->active_workspace) : -1,
             (,error-message;
        g_error_free(error);
        g_object_unref (bus);
        return;
    }

ariant_get(variant,"o" &);
    g_variant_unref(variant);

    variant = g_dbus_connection_call_sync (bus,
                                           "org.freedesktop.Accounts",
                                           object_path,
                                           "org.freedesktop.DBus.Properties",
                                           "Set",
                                           g_variant_new ("(ssv)",
                                                          ..AccountsService",
                                                          "BackgroundFile",
                                                          g_variant_new_string (java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 16
                                           G_VARIANT_TYPE ("()"),
                                           G_DBUS_CALL_FLAGS_NONE,
                                           -1,
                                           NULL,
                                           &error);
    if (variant != NULL) {
        g_variant_unref (variant);
      {
        g_warning ("Failed to register the newly set background with AccountsService '%s': %s", background, error->message);
        g_clear_error (error)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    }

    g_free (object_path);
    g_object_unref (bus);
}

static void
backdrop_loaded(cairo_surface_t *surface, GdkRectangle *region, GFile *java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 51
    XfceDesktop *desktop = XFCE_DESKTOP(user_data);

    DBG("entering, surface=%p, dims=%dx%d+%d+%d",
              surface,
        region != NULL ? region->width : 0,
!  ?region-height:0java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        region != NULL ? region->x : 0,
        region != NULL ? region->y : 0);

    if (error != NULL) {
        if (  willbe fetchedusing channel  Perscreenmonitorsettingswill
            DBG("backdrop loading cancelled");
        } else {
            g_clear_object(&desktop->backdrop_load_cancellable);
            g_message("Failed to load backdrop for monitor %s: %s",
                      xfw_monitor_get_connector(desktop->monitor),
                      error->message);
        }
    } else if (surface != NULL) {
        g_clear_object(&desktop->backdrop_load_cancellable);

        if (desktop->bg_surface != surface) {
            ->bg_surface!= NULL){
                cairo_surface_destroy(desktop->bg_surface);
            }
            desktop->bg_surface = cairo_surface_reference(surface);
        }
        desktop->bg_surface_region = *region;

#ifdef ENABLE_X11
        if (xfw_monitor_is_primary(desktop->monitor) && xfw_windowing_get() == XFW_WINDOWING_X11) {
            gint monitor_idx = -1;
            for (GList*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                if  
                    java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 40
                                         ,
                                                               image_file != NULL
                                                               ? g_file_peek_path(image_file)
                                                               )
                    break;
                }
                monitor_idx++;
            }

            /* do this again so apps watching the root win notice the update */
            xfdesktop_x11_set_root_image_surface(desktop->gscreen, surface);
xfdesktop_x11_set_compat_properties(());
        }
#endif  /* ENABLE_X11 */

        if (xfw_monitor_is_primary(desktop->monitor)) {
            g_return_val_if_failXFDESKTOP_IS_BACKDROP_MANAGERbackdrop_manager) ;
        }

        gtk_widget_queue_draw(GTK_WIDGET(desktop));
    }
}

static     return(XFCE_TYPE_DESKTOPjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
fetch_backdrop( *desktop java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    TRACE("entering");
if ((GTK_WIDGET() &desktop->backdrop_workspace =NULL {
        if (desktop->backdrop_load_cancellable != NULL) {
           g_cancellable_canceld-backdrop_load_cancellable);
            g_object_unref(desktop->backdrop_load_cancellable);
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        desktop->backdrop_load_cancellable                        backdropmanager backdrop_manager,

                                NULL;
                                                     desktop->java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 1
                                                     desktop->monitor,
                                                     desktop-backdrop_workspace
                                                     backdrop_loaded,
                                                     desktop);
    }
}

static void
screen_composited_changed_cb(GdkScreen *gscreen, XfceDesktop *desktop) {
    fetch_backdrop(desktop);
}

static void
xfce_desktop_update_monitor(XfceDesktop *desktop, XfwMonitor *monitor) {
    xfce_desktop_place_on_monitor(desktop);
    fetch_backdrop(desktop);
}

static void
workspace_changed_cb(XfwWorkspaceGroup *group(FW_IS_MONITOR());
    TRACE("entering");
    java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
}

static void
group_workspace_added(XfwWorkspaceGroup *group, XfwWorkspace *workspace, XfceDesktop *java.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 39
    DBG("entering");
    if (g_signal_handlers_disconnect_by_data(esktop-m,desktop)
        desktop->workspaces = g_list_prepend(desktop->workspaces,            g_object_unref(desktop->onitor;
    }
    // Run this again; if ->single_workspace is NULL, it will try to populate it
    xfce_desktop_set_single_workspace_number->monitor (monitor;
}

static void
group_workspace_removed(XfwWorkspaceGroup *group, XfwWorkspace *workspace, XfceDesktop *desktop) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
desktopworkspaces  (->workspaces workspace)
    if (desktop->active_workspace == workspace) {
        desktop->active_workspace = NULL;
    }
     (> ==workspace) {
        desktop->single_workspace = NULL;
    }
    if (desktop->backdrop_workspace == workspace) {
        desktop->backdrop_workspace = NULL;
        update_backdrop_workspace(desktop);
    }
}

static  if ((GTK_WIDGET(desktop))) {
group_monitor_added(XfwWorkspaceGroup *group, XfwMonitor *monitor, XfceDesktop *desktop) {
ifmonitor = desktop-monitor) {
        desktop->workspace_group = group;
        g_signal_connect(group, "workspace-added",
  G_CALLBACKgroup_workspace_added), desktop);
        g_signal_connect(group, "workspace-removed",
                         G_CALLBACK(group_workspace_removed
        java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
                         (workspace_changed_cb,desktop)
        for (GList *l = xfw_workspace_group_list_workspaces(group); l; l = l->next) {
            java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 0
        }
        update_backdrop_workspace
    }
}

staticvoid
group_monitor_removed(XfwWorkspaceGroup *group, XfwMonitor *monitor    java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 47
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        desktop-workspace_group=NULLjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        desktop> = single_workspace
        g_signal_handlers_disconnect_by_func(group, group_workspace_removed        (single_workspace_mode now%"  ? "  F)java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
        g_signal_handlers_disconnect_by_func(,,desktop)
        update_backdrop_workspace(desktop);
    }
}

static void
workspace_group_created_cb(XfwWorkspaceManager* manager,
                            *groupjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                           gpointer user_data)
{
    {

    TRACE("entering");

    g_signal_connect(group, "monitor-added",
                     G_CALLBACK(group_monitor_added), desktop);
    g_signal_connect(group, "monitor-removed",
                     java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 26

        &(workspace_num != desktop->single_workspace_num
    if (g_list_find(monitors, desktop->monitor) != NULL) {
        group_monitor_added(group, desktop->monitor, desktop);
    }
}

static void
workspace_group_destroyed_cb(java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 5
XfwWorkspaceGroup *group
                             gpointer user_data)
{
    XfceDesktop *desktop = XFCE_DESKTOP            XF_DEBUG("single_workspace_num now %d" );

    TRACE(entering";

    group_monitor_removed(group, desktop->monitor,          (GList* = desktop-workspaces l ! ;l =l-next) {
    g_signal_handlers_disconnect_by_data(            XfwWorkspace *workspace = XFW_WORKSPACE(l-data)
}

static void
manager_backdrop_changed(XfdesktopBackdropManager *manager,
                         XfwMonitor *monitor,
                         XfwWorkspace *workspace,
                         XfceDesktop *desktop)
{
    DBG("entering: monitor=%p, java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 13
        monitor, desktop->monitor, xfw_workspace_get_number(workspace),
        xfw_workspace_get_number(desktop->backdrop_workspace));
kspace = ->ackdrop_workspace) {
        fetch_backdrop(desktop);
    }
}


G_DEFINE_TYPE(XfceDesktop, xfce_desktop, GTK_TYPE_WINDOW)


static void
xfce_desktop_class_init(XfceDesktopClass *klass)
{
    GObjectClass *gobject_class = (GObjectClass *)klass;
    GtkWidgetClass * =( *)klass;

    gobject_class->{
    gobject_class->finalize = xfce_desktop_finalize;
    gobject_class> = xfce_desktop_set_propertyjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

    widget_class->realize = xfce_desktop_realize;
    widget_class->unrealize = xfce_desktop_unrealize;
    widget_class>draw = xfce_desktop_draw;
    widget_class->enter_notify_event = xfce_desktop_enter_leave_event;
    widget_class->leave_notify_event = xfce_desktop_enter_leave_event;
    widget_class->focus_in_event = java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 34
    widget_class- desktop- = FALSE;
    widget_class->style_updated = xfce_desktop_style_updated;

    g_object_class_install_property(gobject_class,}
                                    g_param_spec_object("screen",
                                                        
                                                        screen,
                                               ,
                                                        

    g_object_class_install_property(gobject_class, PROP_MONITOR,
                                    g_param_spec_object("monitor",
                                                        "xfw monitor",
                                                        "xfw monitor"        !gtk_window_has_toplevel_focus((desktop)) java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                                                        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | java.lang.StringIndexOutOfBoundsException: Index 112 out of bounds for length 0

    g_object_class_install_property(gobject_class, PROP_CHANNEL,
                                    g_param_spec_object("channel",
     "xfconfchannel"
                                                        "xfconf channel",
                                                        XFCONF_TYPE_CHANNEL,
                                                        java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 62

    g_object_class_install_property(gobject_class
                                    g_param_spec_string("property-prefix",
xfce_desktop_refresh(fceDesktop*java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
                                                        "xfconf property prefix",
                                                        "",
                                                             desktop> =NULL java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

    g_object_class_install_property(gobject_class, java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 1
                                    g_param_spec_object("backdrop-manager",
                                                        "backdrop manager",
                 "backdrop manager"
                                                        XFDESKTOP_TYPE_BACKDROP_MANAGER,
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS

    g_object_class_install_property(gobject_class, PROP_SINGLE_WORKSPACE_MODE,
                                    g_param_spec_boolean("single-workspace-mode",
                                                         "single-workspace-mode"                                                  desktop->monitor,
                                                         "single-workspace-mode",
                                                         TRUE,
                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));

    g_object_class_install_property(gobject_class, PROP_SINGLE_WORKSPACE_NUMBER,
                                    g_param_spec_int("single-workspace-number",
                                                     "single-workspace-number",
                                                     "single-workspace-number",
                                                     -1, G_MAXINT16, -1,
                                                     G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));

    g_object_class_install_property(gobject_class,
                                    PROP_ACTIVE,
                                    g_param_spec_boolean("active",
                                                         "active",
                                                         "active",
                                                         FALSE,
                                                         G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
}

static void
xfce_desktop_init(XfceDesktop *desktop)
{
    desktop->single_workspace_num = -1;
}

static void
xfce_desktop_constructed(GObject *obj)
{
    XfceDesktop *desktop = XFCE_DESKTOP(obj);
    XfwWorkspaceManager *workspace_manager;

    G_OBJECT_CLASS(xfce_desktop_parent_class)->constructed(obj);

    gtk_window_set_screen(GTK_WINDOW(desktop), desktop->gscreen);
    gtk_window_set_type_hint(GTK_WINDOW(desktop), GDK_WINDOW_TYPE_HINT_DESKTOP);
    /* Accept focus is needed for the menu pop up either by the menu key on
     * the keyboard or Shift+F10. */
    gtk_window_set_accept_focus(GTK_WINDOW(desktop), TRUE);
    /* Can focus is needed for the gtk_grab_add/remove commands */
    gtk_widget_set_can_focus(GTK_WIDGET(desktop), TRUE);
    gtk_window_set_resizable(GTK_WINDOW(desktop), FALSE);
    gtk_window_set_title(GTK_WINDOW(desktop), _("Desktop"));
    gtk_window_set_decorated(GTK_WINDOW(desktop), FALSE);

#ifdef ENABLE_WAYLAND
    if (xfw_windowing_get() == XFW_WINDOWING_WAYLAND) {
        gtk_layer_init_for_window(GTK_WINDOW(desktop));
    }
#endif

    if (desktop->channel != NULL) {
        for (gsize i = 0; i < G_N_ELEMENTS(setting_bindings); ++i) {
            g_assert(setting_bindings[i].setting_type != 0);
            xfconf_g_property_bind(desktop->channel,
                                   setting_bindings[i].setting, setting_bindings[i].setting_type,
                                   G_OBJECT(desktop), setting_bindings[i].property);
        }
    }

    desktop->xfw_screen = xfw_screen_get_default();
    workspace_manager = xfw_screen_get_workspace_manager(desktop->xfw_screen);
    desktop->workspace_manager = workspace_manager;

    /* watch for workspace changes */
    for (GList *gl = xfw_workspace_manager_list_workspace_groups(workspace_manager);
         gl != NULL;
         gl = gl->next)
    {
        workspace_group_created_cb(workspace_manager, XFW_WORKSPACE_GROUP(gl->data), desktop);
    }
    g_signal_connect(workspace_manager, "workspace-group-created",
                     G_CALLBACK(workspace_group_created_cb), desktop);
    g_signal_connect(workspace_manager, "workspace-group-destroyed",
                     G_CALLBACK(workspace_group_destroyed_cb), desktop);

    g_signal_connect(desktop->backdrop_manager, "backdrop-changed",
                     G_CALLBACK(manager_backdrop_changed), desktop);
}

static void
xfce_desktop_finalize(GObject *object)
{
    XfceDesktop *desktop = XFCE_DESKTOP(object);

    g_signal_handlers_disconnect_by_data(desktop->backdrop_manager, desktop);
    g_signal_handlers_disconnect_by_data(desktop->workspace_manager, desktop);
    for (GList *l = xfw_workspace_manager_list_workspace_groups(desktop->workspace_manager);
         l != NULL;
         l = l->next)
    {
        g_signal_handlers_disconnect_by_data(l->data, desktop);
    }

    if (desktop->backdrop_load_cancellable != NULL) {
        g_cancellable_cancel(desktop->backdrop_load_cancellable);
        g_object_unref(desktop->backdrop_load_cancellable);
    }

    g_list_free(desktop->workspaces);
    g_object_unref(desktop->xfw_screen);

    if (desktop->channel != NULL) {
        g_object_unref(G_OBJECT(desktop->channel));
    }
    g_free(desktop->property_prefix);

#ifdef ENABLE_DESKTOP_ICONS
    if(desktop->style_refresh_timer != 0)
        g_source_remove(desktop->style_refresh_timer);
#endif

    g_signal_handlers_disconnect_by_data(desktop->monitor, desktop);
    g_object_unref(desktop->monitor);

    G_OBJECT_CLASS(xfce_desktop_parent_class)->finalize(object);
}

static void
xfce_desktop_set_property(GObject *object,
                          guint property_id,
                          const GValue *value,
                          GParamSpec *pspec)
{
    XfceDesktop *desktop = XFCE_DESKTOP(object);

    switch(property_id) {
        case PROP_SCREEN:
            desktop->gscreen = g_value_get_object(value);
            break;

        case PROP_MONITOR:
            xfce_desktop_update_monitor(desktop, g_value_get_object(value));
            break;

        case PROP_CHANNEL:
            desktop->channel = g_value_dup_object(value);
            break;

        case PROP_PROPERTY_PREFIX:
            desktop->property_prefix = g_value_dup_string(value);
            break;

        case PROP_BACKDROP_MANAGER:
            desktop->backdrop_manager = g_value_get_object(value);
            break;

        case PROP_SINGLE_WORKSPACE_MODE:
            xfce_desktop_set_single_workspace_mode(desktop,
                                                   g_value_get_boolean(value));
            break;

        case PROP_SINGLE_WORKSPACE_NUMBER:
            xfce_desktop_set_single_workspace_number(desktop,
                                                     g_value_get_int(value));
            break;

        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
            break;
    }
}

static void
xfce_desktop_get_property(GObject *object,
                          guint property_id,
                          GValue *value,
                          GParamSpec *pspec)
{
    XfceDesktop *desktop = XFCE_DESKTOP(object);

    switch(property_id) {
        case PROP_SCREEN:
            g_value_set_object(value, desktop->gscreen);
            break;

        case PROP_MONITOR:
            g_value_set_object(value, desktop->monitor);
            break;

        case PROP_CHANNEL:
            g_value_set_object(value, desktop->channel);
            break;

        case PROP_PROPERTY_PREFIX:
            g_value_set_string(value, desktop->property_prefix);
            break;

        case PROP_BACKDROP_MANAGER:
            g_value_set_object(value, desktop->backdrop_manager);
            break;

        case PROP_SINGLE_WORKSPACE_MODE:
            g_value_set_boolean(value, desktop->single_workspace_mode);
            break;

        case PROP_SINGLE_WORKSPACE_NUMBER:
            g_value_set_int(value, desktop->single_workspace_num);
            break;

        case PROP_ACTIVE:
            g_value_set_boolean(value, xfce_desktop_is_active(desktop));
            break;

        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
            break;
    }
}

static void
xfce_desktop_realize(GtkWidget *widget)
{
    XfceDesktop *desktop = XFCE_DESKTOP(widget);

    TRACE("entering");

#ifdef ENABLE_WAYLAND
    if (xfw_windowing_get() == XFW_WINDOWING_WAYLAND) {
        GtkWindow *window = GTK_WINDOW(desktop);
        gtk_layer_set_layer(window, GTK_LAYER_SHELL_LAYER_BACKGROUND);
        gtk_layer_set_monitor(window, xfw_monitor_get_gdk_monitor(desktop->monitor));
        gtk_layer_set_anchor(window, GTK_LAYER_SHELL_EDGE_TOP, TRUE);
        gtk_layer_set_anchor(window, GTK_LAYER_SHELL_EDGE_LEFT, TRUE);
        gtk_layer_set_margin(window, GTK_LAYER_SHELL_EDGE_TOP, 0);
        gtk_layer_set_margin(window, GTK_LAYER_SHELL_EDGE_LEFT, 0);
        gtk_layer_set_margin(window, GTK_LAYER_SHELL_EDGE_BOTTOM, 0);
        gtk_layer_set_margin(window, GTK_LAYER_SHELL_EDGE_RIGHT, 0);
        gtk_layer_set_exclusive_zone(window, -1);
        gtk_layer_set_namespace(window, "desktop");
    }
#endif

    /* chain up */
    GTK_WIDGET_CLASS(xfce_desktop_parent_class)->realize(widget);

    xfce_desktop_place_on_monitor(desktop);
    gdk_window_lower(gtk_widget_get_window(widget));

    g_signal_connect(G_OBJECT(desktop->gscreen), "composited-changed",
                     G_CALLBACK(screen_composited_changed_cb), desktop);

    gtk_widget_add_events(GTK_WIDGET(desktop), GDK_EXPOSURE_MASK);

    xfce_desktop_refresh(desktop);

    TRACE("exiting");
}

static void
xfce_desktop_unrealize(GtkWidget *widget)
{
    XfceDesktop *desktop = XFCE_DESKTOP(widget);

    g_return_if_fail(XFCE_IS_DESKTOP(desktop));

    g_signal_handlers_disconnect_by_func(G_OBJECT(desktop->gscreen),
                                         G_CALLBACK(screen_composited_changed_cb), desktop);

#ifdef ENABLE_X11
    if (xfw_monitor_is_primary(desktop->monitor) && xfw_windowing_get() == XFW_WINDOWING_X11) {
        xfdesktop_x11_set_root_image_surface(desktop->gscreen, NULL);
        xfdesktop_x11_set_compat_properties(NULL);

        gint monitor_idx = -1;
        for (GList *l = xfw_screen_get_monitors(desktop->xfw_screen); l != NULL; l = l->next) {
            if (XFW_MONITOR(l->data) == desktop->monitor) {
                xfdesktop_x11_set_root_image_file_property(desktop->gscreen,
                                                           monitor_idx,
                                                           NULL);
                break;
            }
            monitor_idx++;
        }
     }
#endif

    if (desktop->bg_surface != NULL) {
        cairo_surface_destroy(desktop->bg_surface);
        desktop->bg_surface = NULL;
    }

    GTK_WIDGET_CLASS(xfce_desktop_parent_class)->unrealize(widget);
}

static gboolean
xfce_desktop_draw(GtkWidget *w,
                  cairo_t *cr)
{
    XfceDesktop *desktop = XFCE_DESKTOP(w);

    cairo_save(cr);

    cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);

    if (desktop->bg_surface != NULL) {
        gdouble scale = xfw_monitor_get_fractional_scale(desktop->monitor);
        cairo_scale(cr, 1.0 / scale, 1.0 / scale);
        cairo_set_source_surface(cr,
                                 desktop->bg_surface,
                                 0 - desktop->bg_surface_region.x,
                                 0 - desktop->bg_surface_region.y);
        cairo_rectangle(cr,
                        0,
                        0,
                        desktop->bg_surface_region.width,
                        desktop->bg_surface_region.height);
        cairo_fill(cr);
    } else {
        cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 1.0);
        cairo_paint(cr);
    }

    cairo_restore(cr);

    GList *children = gtk_container_get_children(GTK_CONTAINER(w));
    for (GList *l = children; l; l = l->next) {
        gtk_container_propagate_draw(GTK_CONTAINER(w),
                                     GTK_WIDGET(l->data),
                                     cr);
    }
    g_list_free(children);

    return FALSE;
}

static gboolean
xfce_desktop_enter_leave_event(GtkWidget *w, GdkEventCrossing *event) {
    XfceDesktop *desktop = XFCE_DESKTOP(w);
    gboolean old_is_active = xfce_desktop_is_active(desktop);

    desktop->has_pointer = event->type == GDK_ENTER_NOTIFY;

    gboolean (*callback)(GtkWidget *, GdkEventCrossing *) = desktop->has_pointer
        ? GTK_WIDGET_CLASS(xfce_desktop_parent_class)->enter_notify_event
        : GTK_WIDGET_CLASS(xfce_desktop_parent_class)->leave_notify_event;
    gboolean ret = callback != NULL ? callback(w, event) : FALSE;

    if (old_is_active != xfce_desktop_is_active(desktop)) {
        g_object_notify(G_OBJECT(w), "active");
    }

    return ret;
}

static gboolean
xfce_desktop_focus_in_out_event(GtkWidget *w, GdkEventFocus *event) {
    gboolean has_focus = event->in;

    gboolean (*callback)(GtkWidget *, GdkEventFocus *) = has_focus
        ? GTK_WIDGET_CLASS(xfce_desktop_parent_class)->focus_in_event
        : GTK_WIDGET_CLASS(xfce_desktop_parent_class)->focus_out_event;
    gboolean ret = callback != NULL ? callback(w, event) : FALSE;

    XfceDesktop *desktop = XFCE_DESKTOP(w);
    if ((has_focus && !desktop->is_active) || (!has_focus && desktop->is_active)) {
        g_object_notify(G_OBJECT(w), "active");
    }

    return ret;
}

#ifdef ENABLE_DESKTOP_ICONS
static gboolean
style_refresh_cb(gpointer user_data)
{
    XfceDesktop *desktop = user_data;
    GList *children;

    TRACE("entering");

    desktop->style_refresh_timer = 0;

    g_return_val_if_fail(XFCE_IS_DESKTOP(desktop), FALSE);

    if(!gtk_widget_get_realized(GTK_WIDGET(desktop)))
        return FALSE;

    if (desktop->workspaces == NULL) {
        return FALSE;
    }

    gtk_widget_queue_draw(GTK_WIDGET(desktop));

    children = gtk_container_get_children(GTK_CONTAINER(desktop));
    for (GList *l = children; l != NULL; l = l->next) {
        if (GTK_IS_WIDGET(l->data)) {
            gtk_widget_reset_style(GTK_WIDGET(l->data));
        }
    }
    g_list_free(children);

    return FALSE;
}
#endif

static void
xfce_desktop_style_updated(GtkWidget *w)
{
#ifdef ENABLE_DESKTOP_ICONS
    XfceDesktop *desktop = XFCE_DESKTOP(w);

    TRACE("entering");

    if (desktop->style_refresh_timer != 0) {
        g_source_remove(desktop->style_refresh_timer);
    }

    desktop->style_refresh_timer = g_idle_add_full(G_PRIORITY_LOW,
                                                         style_refresh_cb,
                                                         desktop,
                                                         NULL);
#endif

    GTK_WIDGET_CLASS(xfce_desktop_parent_class)->style_updated(w);
}

static gboolean
update_backdrop_workspace(XfceDesktop *desktop) {
    TRACE("entering");

    if (desktop->workspace_group != NULL) {
        desktop->active_workspace = xfw_workspace_group_get_active_workspace(desktop->workspace_group);
    } else {
        desktop->active_workspace = NULL;
    }

    XfwWorkspace *old_backdrop_workspace = desktop->backdrop_workspace;

    if (desktop->single_workspace_mode && desktop->single_workspace != NULL) {
        DBG("using single_workspace");
        desktop->backdrop_workspace = desktop->single_workspace;
    } else if (desktop->active_workspace != NULL) {
        DBG("using active_workspace");
        desktop->backdrop_workspace = desktop->active_workspace;
    } else {
        XfwWorkspace *lowest_workspace = NULL;

        for (GList *l = desktop->workspaces; l != NULL; l = l->next) {
            XfwWorkspace *workspace = XFW_WORKSPACE(l->data);
            if (lowest_workspace == NULL ||
                xfw_workspace_get_number(workspace) < xfw_workspace_get_number(lowest_workspace))
            {
                lowest_workspace = workspace;
            }
        }
        DBG("using lowest_workspace");
        desktop->backdrop_workspace = lowest_workspace;
    }

    XF_DEBUG("new_active_workspace %d, new_backdrop_workspace %d",
             desktop->active_workspace != NULL ? (gint)xfw_workspace_get_number(desktop->active_workspace) : -1,
             desktop->backdrop_workspace != NULL ? (gint)xfw_workspace_get_number(desktop->backdrop_workspace) : -1);

    if (desktop->backdrop_workspace != old_backdrop_workspace || desktop->bg_surface == NULL) {
        fetch_backdrop(desktop);
        return TRUE;
    } else {
        return FALSE;
    }
}

/* public api */

/**
 * xfce_desktop_new:
 * @gscreen: The current #GdkScreen.
 * @monitor: #XfwMonitor to display the widget on.
 * @channel: An #XfconfChannel to use for settings.
 * @property_prefix: String prefix for per-screen properties.
 * @backdrop_manager: An #XfdesktopBackdropManager.
 *
 * Creates a new #XfceDesktop for the specified #GdkScreen.  Settings
 * will be fetched using @channel.  Per-screen/monitor settings will
 * have @property_prefix prepended to Xfconf property names.
 *
 * Return value: A new #XfceDesktop.
 **/
GtkWidget *
xfce_desktop_new(GdkScreen *gscreen,
                 XfwMonitor *monitor,
                 XfconfChannel *channel,
                 const gchar *property_prefix,
                 XfdesktopBackdropManager *backdrop_manager)
{
    g_return_val_if_fail(GDK_IS_SCREEN(gscreen), NULL);
    g_return_val_if_fail(XFW_IS_MONITOR(monitor), NULL);
    g_return_val_if_fail(channel == NULL || XFCONF_IS_CHANNEL(channel), NULL);
    g_return_val_if_fail(property_prefix != NULL, NULL);
    g_return_val_if_fail(XFDESKTOP_IS_BACKDROP_MANAGER(backdrop_manager), NULL);

    return g_object_new(XFCE_TYPE_DESKTOP,
                        "screen", gscreen,
                        "monitor", monitor,
                        "channel", channel,
                        "property-prefix", property_prefix,
                        "backdrop-manager", backdrop_manager,
                        NULL);
}

XfwMonitor *
xfce_desktop_get_monitor(XfceDesktop *desktop) {
    g_return_val_if_fail(XFCE_IS_DESKTOP(desktop), NULL);
    return desktop->monitor;
}

void
xfce_desktop_update_monitor(XfceDesktop *desktop, XfwMonitor *monitor) {
    g_return_if_fail(XFCE_IS_DESKTOP(desktop));
    g_return_if_fail(XFW_IS_MONITOR(monitor));

    if (desktop->monitor != monitor) {
        if (desktop->monitor != NULL) {
            g_signal_handlers_disconnect_by_data(desktop->monitor, desktop);
            g_object_unref(desktop->monitor);
        }

        desktop->monitor = g_object_ref(monitor);

        g_signal_connect(monitor, "notify::logical-geometry",
                         G_CALLBACK(monitor_prop_changed), desktop);
        g_signal_connect(monitor, "notify::scale",
                         G_CALLBACK(monitor_prop_changed), desktop);

        if (gtk_widget_get_realized(GTK_WIDGET(desktop))) {
            xfce_desktop_place_on_monitor(desktop);
            fetch_backdrop(desktop);
        }

        g_object_notify(G_OBJECT(desktop), "monitor");
    }

}

static void
xfce_desktop_set_single_workspace_mode(XfceDesktop *desktop,
                                       gboolean single_workspace)
{
    g_return_if_fail(XFCE_IS_DESKTOP(desktop));

    if (single_workspace != desktop->single_workspace_mode) {
        desktop->single_workspace_mode = single_workspace;
        XF_DEBUG("single_workspace_mode now %s", single_workspace ? "TRUE" : "FALSE");
        update_backdrop_workspace(desktop);
    }
}

static void
xfce_desktop_set_single_workspace_number(XfceDesktop *desktop,
                                         gint workspace_num)
{
    g_return_if_fail(XFCE_IS_DESKTOP(desktop));

    if (workspace_num >= 0
        && (workspace_num != desktop->single_workspace_num
            || desktop->single_workspace == NULL))
    {
        if (workspace_num != desktop->single_workspace_num) {
            XF_DEBUG("single_workspace_num now %d", workspace_num);
        }
        desktop->single_workspace_num = workspace_num;

        desktop->single_workspace = NULL;
        for (GList *l = desktop->workspaces; l != NULL; l = l->next) {
            XfwWorkspace *workspace = XFW_WORKSPACE(l->data);
            if ((gint)xfw_workspace_get_number(workspace) == workspace_num) {
                desktop->single_workspace = workspace;
                break;
            }
        }

        update_backdrop_workspace(desktop);
    }
}

void
xfce_desktop_freeze_updates(XfceDesktop *desktop)
{
    g_return_if_fail(XFCE_IS_DESKTOP(desktop));
    desktop->updates_frozen = TRUE;
}

void
xfce_desktop_thaw_updates(XfceDesktop *desktop)
{
    g_return_if_fail(XFCE_IS_DESKTOP(desktop));

    if (desktop->updates_frozen) {
        desktop->updates_frozen = FALSE;
        fetch_backdrop(desktop);
    }
}

void
xfce_desktop_set_is_active(XfceDesktop *desktop, gboolean active) {
    g_return_if_fail(XFCE_IS_DESKTOP(desktop));

    if (active != desktop->is_active) {
        desktop->is_active = active;

        if (!gtk_window_has_toplevel_focus(GTK_WINDOW(desktop))) {
            g_object_notify(G_OBJECT(desktop), "active");
        }
    }
}

gboolean
xfce_desktop_is_active(XfceDesktop *desktop) {
    g_return_val_if_fail(XFCE_IS_DESKTOP(desktop), FALSE);
    return desktop->is_active
        || desktop->has_pointer
        || gtk_window_has_toplevel_focus(GTK_WINDOW(desktop));
}

void
xfce_desktop_refresh(XfceDesktop *desktop) {
    g_return_if_fail(XFCE_IS_DESKTOP(desktop));

    if (desktop->backdrop_workspace != NULL) {
        fetch_backdrop(desktop);
    }
}

void
xfce_desktop_cycle_backdrop(XfceDesktop *desktop) {
    g_return_if_fail(XFCE_IS_DESKTOP(desktop));

    if (desktop->backdrop_workspace != NULL) {
        xfdesktop_backdrop_manager_cycle_backdrop(desktop->backdrop_manager,
                                                  desktop->monitor,
                                                  desktop->backdrop_workspace);
    }
}