1134 lines
34 KiB
C
1134 lines
34 KiB
C
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
|
||
*
|
||
* Copyright (C) 2010-2011 Red Hat, Inc.
|
||
*
|
||
* This program is free software; you can redistribute it and/or modify
|
||
* it under the terms of the GNU General Public License as published by
|
||
* the Free Software Foundation; either version 2 of the License, or
|
||
* (at your option) any later version.
|
||
*
|
||
* This program is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
* GNU General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU General Public License
|
||
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
||
*
|
||
*/
|
||
|
||
#include "config.h"
|
||
|
||
#include <stdlib.h>
|
||
#include <stdio.h>
|
||
|
||
#include <gtk/gtk.h>
|
||
#include <gio/gio.h>
|
||
#include <glib/gi18n-lib.h>
|
||
|
||
#include <gnome-bg/gnome-bg.h>
|
||
#include <gdesktop-enums.h>
|
||
|
||
#include "cc-background-item.h"
|
||
#include "gdesktop-enums-types.h"
|
||
#include "cc-background-enum-types.h"
|
||
|
||
typedef struct {
|
||
int width;
|
||
int height;
|
||
int scale_factor;
|
||
GdkPixbuf *thumbnail;
|
||
} CachedThumbnail;
|
||
|
||
struct _CcBackgroundItem
|
||
{
|
||
GObject parent_instance;
|
||
|
||
/* properties */
|
||
char *name;
|
||
char *uri;
|
||
char *uri_dark;
|
||
char *size;
|
||
GDesktopBackgroundStyle placement;
|
||
GDesktopBackgroundShading shading;
|
||
char *primary_color;
|
||
char *secondary_color;
|
||
char *source_url; /* Used by the Flickr source */
|
||
char *source_xml; /* Used by the Wallpapers source */
|
||
gboolean is_deleted;
|
||
gboolean needs_download;
|
||
CcBackgroundItemFlags flags;
|
||
guint64 modified;
|
||
|
||
/* internal */
|
||
char *mime_type;
|
||
int width;
|
||
int height;
|
||
|
||
CachedThumbnail cached_thumbnail;
|
||
CachedThumbnail cached_thumbnail_dark;
|
||
};
|
||
|
||
enum {
|
||
PROP_0,
|
||
PROP_NAME,
|
||
PROP_URI,
|
||
PROP_URI_DARK,
|
||
PROP_PLACEMENT,
|
||
PROP_SHADING,
|
||
PROP_PRIMARY_COLOR,
|
||
PROP_SECONDARY_COLOR,
|
||
PROP_IS_DELETED,
|
||
PROP_SOURCE_URL,
|
||
PROP_SOURCE_XML,
|
||
PROP_FLAGS,
|
||
PROP_SIZE,
|
||
PROP_NEEDS_DOWNLOAD,
|
||
PROP_MODIFIED,
|
||
N_PROPS
|
||
};
|
||
|
||
static GParamSpec *props [N_PROPS];
|
||
static GMutex thread_mutex;
|
||
static GQueue thread_queue;
|
||
static GThread *thread;
|
||
|
||
static void cc_background_item_finalize (GObject *object);
|
||
|
||
G_DEFINE_TYPE (CcBackgroundItem, cc_background_item, G_TYPE_OBJECT)
|
||
|
||
typedef struct
|
||
{
|
||
GList link;
|
||
GTask *task;
|
||
GTaskThreadFunc func;
|
||
} RunInThread;
|
||
|
||
static gpointer
|
||
run_in_thread_worker (gpointer data)
|
||
{
|
||
gboolean exiting = FALSE;
|
||
|
||
while (!exiting) {
|
||
RunInThread *state;
|
||
|
||
g_mutex_lock (&thread_mutex);
|
||
if ((state = g_queue_peek_head (&thread_queue))) {
|
||
g_queue_unlink (&thread_queue, &state->link);
|
||
} else {
|
||
exiting = TRUE;
|
||
thread = NULL;
|
||
}
|
||
|
||
g_mutex_unlock (&thread_mutex);
|
||
|
||
if (state != NULL) {
|
||
state->func (state->task,
|
||
g_task_get_source_object (state->task),
|
||
g_task_get_task_data (state->task),
|
||
g_task_get_cancellable (state->task));
|
||
g_clear_object (&state->task);
|
||
g_free (state);
|
||
}
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
static void
|
||
run_in_thread (GTask *task,
|
||
GTaskThreadFunc func)
|
||
{
|
||
RunInThread *state;
|
||
|
||
g_assert (G_IS_TASK (task));
|
||
g_assert (func != NULL);
|
||
|
||
state = g_new0 (RunInThread, 1);
|
||
state->link.data = state;
|
||
state->task = g_object_ref (task);
|
||
state->func = func;
|
||
|
||
g_mutex_lock (&thread_mutex);
|
||
g_queue_push_tail_link (&thread_queue, &state->link);
|
||
if (thread == NULL)
|
||
thread = g_thread_new ("[cc-background-item]", run_in_thread_worker, NULL);
|
||
g_mutex_unlock (&thread_mutex);
|
||
}
|
||
|
||
static GnomeBG *
|
||
item_to_gnome_bg (CcBackgroundItem *item,
|
||
gboolean dark)
|
||
{
|
||
GnomeBG *bg;
|
||
char *uri;
|
||
g_autoptr(GFile) file = NULL;
|
||
g_autofree gchar *filename = NULL;
|
||
GdkRGBA pcolor = { 0, 0, 0, 0 };
|
||
GdkRGBA scolor = { 0, 0, 0, 0 };
|
||
|
||
uri = dark ? item->uri_dark: item->uri;
|
||
|
||
g_return_val_if_fail (uri != NULL, NULL);
|
||
|
||
bg = gnome_bg_new ();
|
||
|
||
file = g_file_new_for_commandline_arg (uri);
|
||
filename = g_file_get_path (file);
|
||
gnome_bg_set_filename (bg, filename);
|
||
|
||
if (item->primary_color != NULL) {
|
||
gdk_rgba_parse (&pcolor, item->primary_color);
|
||
}
|
||
if (item->secondary_color != NULL) {
|
||
gdk_rgba_parse (&scolor, item->secondary_color);
|
||
}
|
||
|
||
gnome_bg_set_rgba (bg, item->shading, &pcolor, &scolor);
|
||
gnome_bg_set_placement (bg, item->placement);
|
||
|
||
return bg;
|
||
}
|
||
|
||
gboolean
|
||
cc_background_item_changes_with_time (CcBackgroundItem *item)
|
||
{
|
||
g_autoptr(GnomeBG) bg = NULL;
|
||
g_autoptr(GnomeBG) bg_dark = NULL;
|
||
gboolean changes = FALSE;
|
||
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), FALSE);
|
||
|
||
if (item->uri != NULL) {
|
||
bg = item_to_gnome_bg (item, FALSE);
|
||
changes |= gnome_bg_changes_with_time (bg);
|
||
}
|
||
if (item->uri_dark != NULL && !changes) {
|
||
bg_dark = item_to_gnome_bg (item, TRUE);
|
||
changes |= gnome_bg_changes_with_time (bg_dark);
|
||
}
|
||
|
||
return changes;
|
||
}
|
||
|
||
gboolean
|
||
cc_background_item_has_dark_version (CcBackgroundItem *item)
|
||
{
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), FALSE);
|
||
|
||
return item->uri && item->uri_dark;
|
||
}
|
||
|
||
static void
|
||
update_size (CcBackgroundItem *item)
|
||
{
|
||
g_autoptr(GnomeBG) bg = NULL;
|
||
|
||
g_clear_pointer (&item->size, g_free);
|
||
|
||
if (item->uri == NULL) {
|
||
item->size = g_strdup ("");
|
||
} else {
|
||
bg = item_to_gnome_bg (item, FALSE);
|
||
if (gnome_bg_has_multiple_sizes (bg) || gnome_bg_changes_with_time (bg)) {
|
||
item->size = g_strdup (_("multiple sizes"));
|
||
} else {
|
||
gdk_pixbuf_get_file_info (gnome_bg_get_filename (bg),
|
||
&item->width,
|
||
&item->height);
|
||
/* translators: 100 × 100px
|
||
* Note that this is not an "x", but U+00D7 MULTIPLICATION SIGN */
|
||
item->size = g_strdup_printf (_("%d × %d"),
|
||
item->width,
|
||
item->height);
|
||
}
|
||
}
|
||
}
|
||
|
||
typedef struct
|
||
{
|
||
GnomeDesktopThumbnailFactory *thumbs;
|
||
GnomeBG *bg;
|
||
GdkRectangle monitor_layout;
|
||
int width;
|
||
int height;
|
||
int scale_factor;
|
||
guint dark : 1;
|
||
guint cached_result : 1;
|
||
} GetThumbnailAsync;
|
||
|
||
static void
|
||
get_thumbnail_async_free (gpointer data)
|
||
{
|
||
GetThumbnailAsync *state = data;
|
||
|
||
g_clear_object (&state->thumbs);
|
||
g_clear_object (&state->bg);
|
||
g_free (state);
|
||
}
|
||
|
||
static void
|
||
cc_background_item_get_thumbnail_worker (GTask *task,
|
||
gpointer source_object,
|
||
gpointer task_data,
|
||
GCancellable *cancellable)
|
||
{
|
||
GetThumbnailAsync *state = task_data;
|
||
CcBackgroundItem *item = source_object;
|
||
GdkPixbuf *pixbuf;
|
||
|
||
g_assert (G_IS_TASK (task));
|
||
g_assert (CC_IS_BACKGROUND_ITEM (item));
|
||
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
|
||
g_assert (state != NULL);
|
||
g_assert (state->thumbs != NULL);
|
||
|
||
pixbuf = gnome_bg_create_thumbnail (state->bg,
|
||
state->thumbs,
|
||
&state->monitor_layout,
|
||
state->scale_factor * state->width,
|
||
state->scale_factor * state->height);
|
||
|
||
if (pixbuf != NULL)
|
||
g_task_return_pointer (task, pixbuf, g_object_unref);
|
||
else
|
||
g_task_return_new_error (task,
|
||
G_IO_ERROR,
|
||
G_IO_ERROR_FAILED,
|
||
"Failed to load pixbuf");
|
||
}
|
||
|
||
void
|
||
cc_background_item_get_thumbnail_async (CcBackgroundItem *item,
|
||
GnomeDesktopThumbnailFactory *thumbs,
|
||
int width,
|
||
int height,
|
||
int scale_factor,
|
||
gboolean dark,
|
||
GCancellable *cancellable,
|
||
GAsyncReadyCallback callback,
|
||
gpointer user_data)
|
||
{
|
||
g_autoptr(GdkMonitor) monitor = NULL;
|
||
g_autoptr(GTask) task = NULL;
|
||
GetThumbnailAsync *state;
|
||
CachedThumbnail *thumbnail;
|
||
GListModel *monitors;
|
||
GdkDisplay *display;
|
||
|
||
g_return_if_fail (CC_IS_BACKGROUND_ITEM (item));
|
||
g_return_if_fail (width > 0 && height > 0);
|
||
g_return_if_fail (thumbs != NULL);
|
||
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
|
||
|
||
task = g_task_new (item, cancellable, callback, user_data);
|
||
g_task_set_source_tag (task, cc_background_item_get_thumbnail_async);
|
||
|
||
state = g_new0 (GetThumbnailAsync, 1);
|
||
g_task_set_task_data (task, state, get_thumbnail_async_free);
|
||
|
||
thumbnail = dark ? &item->cached_thumbnail_dark : &item->cached_thumbnail;
|
||
|
||
/* Use the cached thumbnail if the sizes match */
|
||
if (thumbnail->thumbnail &&
|
||
thumbnail->width == width &&
|
||
thumbnail->height == height &&
|
||
thumbnail->scale_factor == scale_factor) {
|
||
state->cached_result = TRUE;
|
||
g_task_return_pointer (task, g_object_ref (thumbnail->thumbnail), g_object_unref);
|
||
return;
|
||
}
|
||
|
||
display = gdk_display_get_default ();
|
||
monitors = gdk_display_get_monitors (display);
|
||
monitor = g_list_model_get_item (monitors, 0);
|
||
|
||
state->thumbs = g_object_ref (thumbs);
|
||
gdk_monitor_get_geometry (monitor, &state->monitor_layout);
|
||
state->width = width;
|
||
state->height = height;
|
||
state->scale_factor = scale_factor;
|
||
state->dark = !!dark;
|
||
state->bg = item_to_gnome_bg (item, dark);
|
||
|
||
/* g_task_run_in_thread() will use a threadpool which may jump the
|
||
* number of parallel workers to around 10. On low-memory systems, that
|
||
* could cause excessive memory use to the point of paging.
|
||
*
|
||
* What we really want is non-blocking more than massive concurrency,
|
||
* so use a single worker thread but retain GTask usage.
|
||
*/
|
||
run_in_thread (task, cc_background_item_get_thumbnail_worker);
|
||
}
|
||
|
||
GdkPixbuf *
|
||
cc_background_item_get_thumbnail_finish (CcBackgroundItem *item,
|
||
GAsyncResult *result,
|
||
GError **error)
|
||
{
|
||
GdkPixbuf *pixbuf;
|
||
GetThumbnailAsync *state;
|
||
CachedThumbnail *thumbnail;
|
||
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), NULL);
|
||
g_return_val_if_fail (G_IS_TASK (result), NULL);
|
||
|
||
if (!(pixbuf = g_task_propagate_pointer (G_TASK (result), error)))
|
||
return NULL;
|
||
|
||
state = g_task_get_task_data (G_TASK (result));
|
||
|
||
if (state->cached_result)
|
||
return pixbuf;
|
||
|
||
thumbnail = state->dark ? &item->cached_thumbnail_dark : &item->cached_thumbnail;
|
||
|
||
/* Cache the new thumbnail */
|
||
if (g_set_object (&thumbnail->thumbnail, pixbuf)) {
|
||
thumbnail->width = state->width;
|
||
thumbnail->height = state->height;
|
||
thumbnail->scale_factor = state->scale_factor;
|
||
}
|
||
|
||
return pixbuf;
|
||
}
|
||
|
||
static void
|
||
update_info (CcBackgroundItem *item,
|
||
GFileInfo *_info)
|
||
{
|
||
g_autoptr(GFileInfo) info = NULL;
|
||
|
||
if (_info == NULL) {
|
||
g_autoptr(GFile) file = NULL;
|
||
|
||
file = g_file_new_for_uri (item->uri);
|
||
|
||
info = g_file_query_info (file,
|
||
G_FILE_ATTRIBUTE_STANDARD_NAME ","
|
||
G_FILE_ATTRIBUTE_STANDARD_SIZE ","
|
||
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
|
||
G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME ","
|
||
G_FILE_ATTRIBUTE_TIME_MODIFIED,
|
||
G_FILE_QUERY_INFO_NONE,
|
||
NULL,
|
||
NULL);
|
||
} else {
|
||
info = g_object_ref (_info);
|
||
}
|
||
|
||
g_clear_pointer (&item->mime_type, g_free);
|
||
|
||
if (info == NULL
|
||
|| g_file_info_get_content_type (info) == NULL) {
|
||
if (item->uri == NULL) {
|
||
item->mime_type = g_strdup ("image/x-no-data");
|
||
g_free (item->name);
|
||
item->name = g_strdup (_("No Desktop Background"));
|
||
}
|
||
} else {
|
||
if (item->name == NULL)
|
||
item->name = g_strdup (g_file_info_get_display_name (info));
|
||
|
||
item->mime_type = g_strdup (g_file_info_get_content_type (info));
|
||
if (item->modified == 0)
|
||
item->modified = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
|
||
}
|
||
}
|
||
|
||
gboolean
|
||
cc_background_item_load (CcBackgroundItem *item,
|
||
GFileInfo *info)
|
||
{
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), FALSE);
|
||
|
||
if (item->uri == NULL)
|
||
return TRUE;
|
||
|
||
update_info (item, info);
|
||
|
||
if (item->mime_type == NULL
|
||
|| !(g_str_has_prefix (item->mime_type, "image/")
|
||
|| strcmp (item->mime_type, "application/xml") == 0))
|
||
return FALSE;
|
||
|
||
/* FIXME we should handle XML files as well */
|
||
if (item->mime_type != NULL &&
|
||
g_str_has_prefix (item->mime_type, "image/")) {
|
||
g_autofree gchar *filename = NULL;
|
||
|
||
filename = g_filename_from_uri (item->uri, NULL, NULL);
|
||
gdk_pixbuf_get_file_info (filename,
|
||
&item->width,
|
||
&item->height);
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
static void
|
||
_set_name (CcBackgroundItem *item,
|
||
const char *value)
|
||
{
|
||
g_free (item->name);
|
||
item->name = g_strdup (value);
|
||
}
|
||
|
||
const char *
|
||
cc_background_item_get_name (CcBackgroundItem *item)
|
||
{
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), NULL);
|
||
|
||
return item->name;
|
||
}
|
||
|
||
static void
|
||
_add_flag (CcBackgroundItem *item,
|
||
CcBackgroundItemFlags flag)
|
||
{
|
||
item->flags |= flag;
|
||
g_object_notify_by_pspec (G_OBJECT (item), props[PROP_FLAGS]);
|
||
}
|
||
|
||
static void
|
||
_set_uri (CcBackgroundItem *item,
|
||
const char *value)
|
||
{
|
||
g_free (item->uri);
|
||
if (value && *value == '\0') {
|
||
item->uri = NULL;
|
||
} else {
|
||
if (value && strstr (value, "://") == NULL)
|
||
g_warning ("URI '%s' is invalid", value);
|
||
item->uri = g_strdup (value);
|
||
}
|
||
_add_flag (item, CC_BACKGROUND_ITEM_HAS_URI);
|
||
}
|
||
|
||
static void
|
||
_set_uri_dark (CcBackgroundItem *item,
|
||
const char *value)
|
||
{
|
||
g_free (item->uri_dark);
|
||
if (value && *value == '\0') {
|
||
item->uri_dark = NULL;
|
||
} else {
|
||
if (value && strstr (value, "://") == NULL)
|
||
g_warning ("URI '%s' is invalid", value);
|
||
item->uri_dark = g_strdup (value);
|
||
}
|
||
_add_flag (item, CC_BACKGROUND_ITEM_HAS_URI_DARK);
|
||
}
|
||
|
||
const char *
|
||
cc_background_item_get_uri (CcBackgroundItem *item)
|
||
{
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), NULL);
|
||
|
||
return item->uri;
|
||
}
|
||
|
||
const char *
|
||
cc_background_item_get_uri_dark (CcBackgroundItem *item)
|
||
{
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), NULL);
|
||
|
||
return item->uri_dark;
|
||
}
|
||
|
||
static void
|
||
_set_placement (CcBackgroundItem *item,
|
||
GDesktopBackgroundStyle value)
|
||
{
|
||
item->placement = value;
|
||
_add_flag (item, CC_BACKGROUND_ITEM_HAS_PLACEMENT);
|
||
}
|
||
|
||
static void
|
||
_set_shading (CcBackgroundItem *item,
|
||
GDesktopBackgroundShading value)
|
||
{
|
||
item->shading = value;
|
||
_add_flag (item, CC_BACKGROUND_ITEM_HAS_SHADING);
|
||
}
|
||
|
||
static void
|
||
_set_primary_color (CcBackgroundItem *item,
|
||
const char *value)
|
||
{
|
||
g_free (item->primary_color);
|
||
item->primary_color = g_strdup (value);
|
||
_add_flag (item, CC_BACKGROUND_ITEM_HAS_PCOLOR);
|
||
}
|
||
|
||
const char *
|
||
cc_background_item_get_pcolor (CcBackgroundItem *item)
|
||
{
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), NULL);
|
||
|
||
return item->primary_color;
|
||
}
|
||
|
||
static void
|
||
_set_secondary_color (CcBackgroundItem *item,
|
||
const char *value)
|
||
{
|
||
g_free (item->secondary_color);
|
||
item->secondary_color = g_strdup (value);
|
||
_add_flag (item, CC_BACKGROUND_ITEM_HAS_SCOLOR);
|
||
}
|
||
|
||
const char *
|
||
cc_background_item_get_scolor (CcBackgroundItem *item)
|
||
{
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), NULL);
|
||
|
||
return item->secondary_color;
|
||
}
|
||
|
||
GDesktopBackgroundStyle
|
||
cc_background_item_get_placement (CcBackgroundItem *item)
|
||
{
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), G_DESKTOP_BACKGROUND_STYLE_SCALED);
|
||
|
||
return item->placement;
|
||
}
|
||
|
||
GDesktopBackgroundShading
|
||
cc_background_item_get_shading (CcBackgroundItem *item)
|
||
{
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), G_DESKTOP_BACKGROUND_SHADING_SOLID);
|
||
|
||
return item->shading;
|
||
}
|
||
|
||
static void
|
||
_set_is_deleted (CcBackgroundItem *item,
|
||
gboolean value)
|
||
{
|
||
item->is_deleted = value;
|
||
}
|
||
|
||
static void
|
||
_set_source_url (CcBackgroundItem *item,
|
||
const char *value)
|
||
{
|
||
g_free (item->source_url);
|
||
item->source_url = g_strdup (value);
|
||
}
|
||
|
||
const char *
|
||
cc_background_item_get_source_url (CcBackgroundItem *item)
|
||
{
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), NULL);
|
||
|
||
return item->source_url;
|
||
}
|
||
|
||
static void
|
||
_set_source_xml (CcBackgroundItem *item,
|
||
const char *value)
|
||
{
|
||
g_free (item->source_xml);
|
||
item->source_xml = g_strdup (value);
|
||
}
|
||
|
||
const char *
|
||
cc_background_item_get_source_xml (CcBackgroundItem *item)
|
||
{
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), NULL);
|
||
|
||
return item->source_xml;
|
||
}
|
||
|
||
CcBackgroundItemFlags
|
||
cc_background_item_get_flags (CcBackgroundItem *item)
|
||
{
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), 0);
|
||
|
||
return item->flags;
|
||
}
|
||
|
||
const char *
|
||
cc_background_item_get_size (CcBackgroundItem *item)
|
||
{
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), NULL);
|
||
|
||
update_size (item);
|
||
|
||
return item->size;
|
||
}
|
||
|
||
static void
|
||
_set_needs_download (CcBackgroundItem *item,
|
||
gboolean value)
|
||
{
|
||
item->needs_download = value;
|
||
}
|
||
|
||
gboolean
|
||
cc_background_item_get_needs_download (CcBackgroundItem *item)
|
||
{
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), 0);
|
||
|
||
return item->needs_download;
|
||
}
|
||
|
||
static void
|
||
_set_modified (CcBackgroundItem *item,
|
||
guint64 value)
|
||
{
|
||
item->modified = value;
|
||
}
|
||
|
||
guint64
|
||
cc_background_item_get_modified (CcBackgroundItem *item)
|
||
{
|
||
g_return_val_if_fail (CC_IS_BACKGROUND_ITEM (item), 0);
|
||
|
||
return item->modified;
|
||
}
|
||
|
||
static void
|
||
cc_background_item_set_property (GObject *object,
|
||
guint prop_id,
|
||
const GValue *value,
|
||
GParamSpec *pspec)
|
||
{
|
||
CcBackgroundItem *self;
|
||
|
||
self = CC_BACKGROUND_ITEM (object);
|
||
|
||
switch (prop_id) {
|
||
case PROP_NAME:
|
||
_set_name (self, g_value_get_string (value));
|
||
break;
|
||
case PROP_URI:
|
||
_set_uri (self, g_value_get_string (value));
|
||
break;
|
||
case PROP_URI_DARK:
|
||
_set_uri_dark (self, g_value_get_string (value));
|
||
break;
|
||
case PROP_PLACEMENT:
|
||
_set_placement (self, g_value_get_enum (value));
|
||
break;
|
||
case PROP_SHADING:
|
||
_set_shading (self, g_value_get_enum (value));
|
||
break;
|
||
case PROP_PRIMARY_COLOR:
|
||
_set_primary_color (self, g_value_get_string (value));
|
||
break;
|
||
case PROP_SECONDARY_COLOR:
|
||
_set_secondary_color (self, g_value_get_string (value));
|
||
break;
|
||
case PROP_IS_DELETED:
|
||
_set_is_deleted (self, g_value_get_boolean (value));
|
||
break;
|
||
case PROP_SOURCE_URL:
|
||
_set_source_url (self, g_value_get_string (value));
|
||
break;
|
||
case PROP_SOURCE_XML:
|
||
_set_source_xml (self, g_value_get_string (value));
|
||
break;
|
||
case PROP_NEEDS_DOWNLOAD:
|
||
_set_needs_download (self, g_value_get_boolean (value));
|
||
break;
|
||
case PROP_MODIFIED:
|
||
_set_modified (self, g_value_get_uint64 (value));
|
||
break;
|
||
default:
|
||
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
||
break;
|
||
}
|
||
}
|
||
|
||
static void
|
||
cc_background_item_get_property (GObject *object,
|
||
guint prop_id,
|
||
GValue *value,
|
||
GParamSpec *pspec)
|
||
{
|
||
CcBackgroundItem *self;
|
||
|
||
self = CC_BACKGROUND_ITEM (object);
|
||
|
||
switch (prop_id) {
|
||
case PROP_NAME:
|
||
g_value_set_string (value, self->name);
|
||
break;
|
||
case PROP_URI:
|
||
g_value_set_string (value, self->uri);
|
||
break;
|
||
case PROP_URI_DARK:
|
||
g_value_set_string (value, self->uri_dark);
|
||
break;
|
||
case PROP_PLACEMENT:
|
||
g_value_set_enum (value, self->placement);
|
||
break;
|
||
case PROP_SHADING:
|
||
g_value_set_enum (value, self->shading);
|
||
break;
|
||
case PROP_PRIMARY_COLOR:
|
||
g_value_set_string (value, self->primary_color);
|
||
break;
|
||
case PROP_SECONDARY_COLOR:
|
||
g_value_set_string (value, self->secondary_color);
|
||
break;
|
||
case PROP_IS_DELETED:
|
||
g_value_set_boolean (value, self->is_deleted);
|
||
break;
|
||
case PROP_SOURCE_URL:
|
||
g_value_set_string (value, self->source_url);
|
||
break;
|
||
case PROP_SOURCE_XML:
|
||
g_value_set_string (value, self->source_xml);
|
||
break;
|
||
case PROP_FLAGS:
|
||
g_value_set_flags (value, self->flags);
|
||
break;
|
||
case PROP_SIZE:
|
||
update_size (self);
|
||
g_value_set_string (value, self->size);
|
||
break;
|
||
case PROP_NEEDS_DOWNLOAD:
|
||
g_value_set_boolean (value, self->needs_download);
|
||
break;
|
||
case PROP_MODIFIED:
|
||
g_value_set_uint64 (value, self->modified);
|
||
break;
|
||
default:
|
||
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
||
break;
|
||
}
|
||
}
|
||
|
||
static GObject *
|
||
cc_background_item_constructor (GType type,
|
||
guint n_construct_properties,
|
||
GObjectConstructParam *construct_properties)
|
||
{
|
||
CcBackgroundItem *background_item;
|
||
|
||
background_item = CC_BACKGROUND_ITEM (G_OBJECT_CLASS (cc_background_item_parent_class)->constructor (type,
|
||
n_construct_properties,
|
||
construct_properties));
|
||
|
||
return G_OBJECT (background_item);
|
||
}
|
||
|
||
static void
|
||
cc_background_item_class_init (CcBackgroundItemClass *klass)
|
||
{
|
||
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
||
|
||
object_class->get_property = cc_background_item_get_property;
|
||
object_class->set_property = cc_background_item_set_property;
|
||
object_class->constructor = cc_background_item_constructor;
|
||
object_class->finalize = cc_background_item_finalize;
|
||
|
||
props[PROP_NAME] = g_param_spec_string ("name",
|
||
"name",
|
||
"name",
|
||
NULL,
|
||
G_PARAM_READWRITE);
|
||
|
||
props[PROP_URI] = g_param_spec_string ("uri",
|
||
"uri",
|
||
"uri",
|
||
NULL,
|
||
G_PARAM_READWRITE);
|
||
|
||
props[PROP_URI_DARK] = g_param_spec_string ("uri-dark",
|
||
"uri-dark",
|
||
"uri-dark",
|
||
NULL,
|
||
G_PARAM_READWRITE);
|
||
|
||
props[PROP_PLACEMENT] = g_param_spec_enum ("placement",
|
||
"placement",
|
||
"placement",
|
||
G_DESKTOP_TYPE_BACKGROUND_STYLE,
|
||
G_DESKTOP_BACKGROUND_STYLE_SCALED,
|
||
G_PARAM_READWRITE);
|
||
|
||
props[PROP_SHADING] = g_param_spec_enum ("shading",
|
||
"shading",
|
||
"shading",
|
||
G_DESKTOP_TYPE_BACKGROUND_SHADING,
|
||
G_DESKTOP_BACKGROUND_SHADING_SOLID,
|
||
G_PARAM_READWRITE);
|
||
|
||
props[PROP_PRIMARY_COLOR] = g_param_spec_string ("primary-color",
|
||
"primary-color",
|
||
"primary-color",
|
||
"#000000000000",
|
||
G_PARAM_READWRITE);
|
||
|
||
props[PROP_SECONDARY_COLOR] = g_param_spec_string ("secondary-color",
|
||
"secondary-color",
|
||
"secondary-color",
|
||
"#000000000000",
|
||
G_PARAM_READWRITE);
|
||
|
||
props[PROP_IS_DELETED] = g_param_spec_boolean ("is-deleted",
|
||
NULL,
|
||
NULL,
|
||
FALSE,
|
||
G_PARAM_READWRITE);
|
||
|
||
props[PROP_SOURCE_URL] = g_param_spec_string ("source-url",
|
||
"source-url",
|
||
"source-url",
|
||
NULL,
|
||
G_PARAM_READWRITE);
|
||
|
||
props[PROP_SOURCE_XML] = g_param_spec_string ("source-xml",
|
||
"source-xml",
|
||
"source-xml",
|
||
NULL,
|
||
G_PARAM_READWRITE);
|
||
|
||
props[PROP_FLAGS] = g_param_spec_flags ("flags",
|
||
"flags",
|
||
"flags",
|
||
CC_TYPE_BACKGROUND_ITEM_FLAGS,
|
||
0,
|
||
G_PARAM_READABLE);
|
||
|
||
props[PROP_SIZE] = g_param_spec_string ("size",
|
||
"size",
|
||
"size",
|
||
NULL,
|
||
G_PARAM_READABLE);
|
||
|
||
props[PROP_NEEDS_DOWNLOAD] = g_param_spec_boolean ("needs-download",
|
||
NULL,
|
||
NULL,
|
||
TRUE,
|
||
G_PARAM_READWRITE);
|
||
|
||
props[PROP_MODIFIED] = g_param_spec_uint64 ("modified",
|
||
"modified",
|
||
NULL,
|
||
0,
|
||
G_MAXUINT64,
|
||
0,
|
||
G_PARAM_READWRITE);
|
||
|
||
g_object_class_install_properties (object_class, N_PROPS, props);
|
||
}
|
||
|
||
static void
|
||
cc_background_item_init (CcBackgroundItem *item)
|
||
{
|
||
item->shading = G_DESKTOP_BACKGROUND_SHADING_SOLID;
|
||
item->placement = G_DESKTOP_BACKGROUND_STYLE_SCALED;
|
||
item->primary_color = g_strdup ("#000000000000");
|
||
item->secondary_color = g_strdup ("#000000000000");
|
||
item->needs_download = TRUE;
|
||
item->flags = 0;
|
||
item->modified = 0;
|
||
}
|
||
|
||
static void
|
||
cc_background_item_finalize (GObject *object)
|
||
{
|
||
CcBackgroundItem *item;
|
||
|
||
g_return_if_fail (object != NULL);
|
||
g_return_if_fail (CC_IS_BACKGROUND_ITEM (object));
|
||
|
||
item = CC_BACKGROUND_ITEM (object);
|
||
|
||
g_return_if_fail (item != NULL);
|
||
|
||
g_clear_object (&item->cached_thumbnail.thumbnail);
|
||
g_clear_object (&item->cached_thumbnail_dark.thumbnail);
|
||
g_free (item->name);
|
||
g_free (item->uri);
|
||
g_free (item->primary_color);
|
||
g_free (item->secondary_color);
|
||
g_free (item->mime_type);
|
||
g_free (item->size);
|
||
g_free (item->source_url);
|
||
g_free (item->source_xml);
|
||
|
||
G_OBJECT_CLASS (cc_background_item_parent_class)->finalize (object);
|
||
}
|
||
|
||
CcBackgroundItem *
|
||
cc_background_item_new (const char *uri)
|
||
{
|
||
GObject *object;
|
||
|
||
object = g_object_new (CC_TYPE_BACKGROUND_ITEM,
|
||
"uri", uri,
|
||
NULL);
|
||
|
||
return CC_BACKGROUND_ITEM (object);
|
||
}
|
||
|
||
CcBackgroundItem *
|
||
cc_background_item_copy (CcBackgroundItem *item)
|
||
{
|
||
CcBackgroundItem *ret;
|
||
|
||
ret = cc_background_item_new (item->uri);
|
||
ret->name = g_strdup (item->name);
|
||
ret->size = g_strdup (item->size);
|
||
ret->placement = item->placement;
|
||
ret->shading = item->shading;
|
||
ret->primary_color = g_strdup (item->primary_color);
|
||
ret->secondary_color = g_strdup (item->secondary_color);
|
||
ret->source_url = g_strdup (item->source_url);
|
||
ret->source_xml = g_strdup (item->source_xml);
|
||
ret->is_deleted = item->is_deleted;
|
||
ret->needs_download = item->needs_download;
|
||
ret->flags = item->flags;
|
||
|
||
return ret;
|
||
}
|
||
|
||
static const char *
|
||
flags_to_str (CcBackgroundItemFlags flag)
|
||
{
|
||
GFlagsClass *fclass;
|
||
GFlagsValue *value;
|
||
|
||
fclass = G_FLAGS_CLASS (g_type_class_peek (CC_TYPE_BACKGROUND_ITEM_FLAGS));
|
||
value = g_flags_get_first_value (fclass, flag);
|
||
|
||
g_assert (value);
|
||
|
||
return value->value_nick;
|
||
}
|
||
|
||
static const char *
|
||
enum_to_str (GType type,
|
||
int v)
|
||
{
|
||
GEnumClass *eclass;
|
||
GEnumValue *value;
|
||
|
||
eclass = G_ENUM_CLASS (g_type_class_peek (type));
|
||
value = g_enum_get_value (eclass, v);
|
||
|
||
g_assert (value);
|
||
|
||
return value->value_nick;
|
||
}
|
||
|
||
void
|
||
cc_background_item_dump (CcBackgroundItem *item)
|
||
{
|
||
g_autoptr(GString) flags = NULL;
|
||
int i;
|
||
|
||
g_return_if_fail (CC_IS_BACKGROUND_ITEM (item));
|
||
|
||
update_size (item);
|
||
|
||
g_debug ("name:\t\t\t%s", item->name);
|
||
g_debug ("URI:\t\t\t%s", item->uri ? item->uri : "NULL");
|
||
if (item->size)
|
||
g_debug ("size:\t\t\t'%s'", item->size);
|
||
flags = g_string_new (NULL);
|
||
for (i = 0; i < 5; i++) {
|
||
if (item->flags & (1 << i)) {
|
||
g_string_append (flags, flags_to_str (1 << i));
|
||
g_string_append_c (flags, ' ');
|
||
}
|
||
}
|
||
if (flags->len == 0)
|
||
g_string_append (flags, "-none-");
|
||
g_debug ("flags:\t\t\t%s", flags->str);
|
||
if (item->primary_color)
|
||
g_debug ("pcolor:\t\t\t%s", item->primary_color);
|
||
if (item->secondary_color)
|
||
g_debug ("scolor:\t\t\t%s", item->secondary_color);
|
||
g_debug ("placement:\t\t%s", enum_to_str (G_DESKTOP_TYPE_BACKGROUND_STYLE, item->placement));
|
||
g_debug ("shading:\t\t%s", enum_to_str (G_DESKTOP_TYPE_BACKGROUND_SHADING, item->shading));
|
||
if (item->source_url)
|
||
g_debug ("source URL:\t\t%s", item->source_url);
|
||
if (item->source_xml)
|
||
g_debug ("source XML:\t\t%s", item->source_xml);
|
||
g_debug ("deleted:\t\t%s", item->is_deleted ? "yes" : "no");
|
||
if (item->mime_type)
|
||
g_debug ("mime-type:\t\t%s", item->mime_type);
|
||
g_debug ("dimensions:\t\t%d x %d", item->width, item->height);
|
||
g_debug ("modified: %"G_GUINT64_FORMAT, item->modified);
|
||
g_debug (" ");
|
||
}
|
||
|
||
static gboolean
|
||
files_equal (const char *a,
|
||
const char *b)
|
||
{
|
||
g_autoptr(GFile) file1 = NULL;
|
||
g_autoptr(GFile) file2 = NULL;
|
||
|
||
if (a == NULL && b == NULL)
|
||
return TRUE;
|
||
|
||
if (a == NULL || b == NULL)
|
||
return FALSE;
|
||
|
||
file1 = g_file_new_for_commandline_arg (a);
|
||
file2 = g_file_new_for_commandline_arg (b);
|
||
|
||
return g_file_equal (file1, file2);
|
||
}
|
||
|
||
static gboolean
|
||
colors_equal (const char *a,
|
||
const char *b)
|
||
{
|
||
GdkRGBA color1, color2;
|
||
|
||
gdk_rgba_parse (&color1, a);
|
||
gdk_rgba_parse (&color2, b);
|
||
|
||
return gdk_rgba_equal (&color1, &color2);
|
||
}
|
||
|
||
gboolean
|
||
cc_background_item_compare (CcBackgroundItem *saved,
|
||
CcBackgroundItem *configured)
|
||
{
|
||
CcBackgroundItemFlags flags;
|
||
|
||
flags = saved->flags;
|
||
if (flags == 0)
|
||
return FALSE;
|
||
|
||
if (flags & CC_BACKGROUND_ITEM_HAS_URI) {
|
||
if (files_equal (saved->uri, configured->uri) == FALSE)
|
||
return FALSE;
|
||
}
|
||
if (flags & CC_BACKGROUND_ITEM_HAS_URI_DARK) {
|
||
if (files_equal (saved->uri_dark, configured->uri_dark) == FALSE)
|
||
return FALSE;
|
||
}
|
||
if (flags & CC_BACKGROUND_ITEM_HAS_SHADING) {
|
||
if (saved->shading != configured->shading)
|
||
return FALSE;
|
||
}
|
||
if (flags & CC_BACKGROUND_ITEM_HAS_PLACEMENT) {
|
||
if (saved->placement != configured->placement)
|
||
return FALSE;
|
||
}
|
||
if (flags & CC_BACKGROUND_ITEM_HAS_PCOLOR) {
|
||
if (colors_equal (saved->primary_color,
|
||
configured->primary_color) == FALSE) {
|
||
return FALSE;
|
||
}
|
||
}
|
||
if (flags & CC_BACKGROUND_ITEM_HAS_SCOLOR) {
|
||
if (colors_equal (saved->secondary_color,
|
||
configured->secondary_color) == FALSE) {
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
return TRUE;
|
||
}
|