← Back to branch summary

~aurelien-riv/+junk/livewallpaper

« back to all changes in this revision

Viewing changes to livewallpaper-core/background.c

  • Committer: Maximilian Schnarr
  • Date: 2012-11-09 18:29:41 UTC
  • mfrom: (86.1.1 livewallpaper-0.3)
  • Revision ID: fyrmir@gmx.de-20121109182941-nrbq0bu26zn4ng6q
Merged bugfix from 0.3 branch and improved custom background handling.

Show diffs side-by-side

added added

removed removed

Lines of Context:
livewallpaper-core/background.c
49
49
#include <livewallpaper/core.h>
50
50
 
51
51
 
 
52
typedef enum
 
53
{
 
54
        LwBackgroundDefault,
 
55
        LwBackgroundCustomImage,
 
56
        LwBackgroundSingleColor,
 
57
        LwBackgroundHorizontalGradient,
 
58
        LwBackgroundVerticalGradient
 
59
} LwBackgroundMode;
 
60
 
52
61
#define LW_BACKGROUND_GET_PRIVATE(obj)  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), LW_TYPE_BACKGROUND, LwBackgroundPrivate))
53
62
 
54
63
struct _LwBackgroundPrivate
55
64
{
 
65
        GSettings *settings;
 
66
 
 
67
        LwBackgroundMode bg_mode;
 
68
 
 
69
        LwTexture *bg_texture;
 
70
        LwBackgroundRenderType bg_render_type;
 
71
 
56
72
        LwTexture *default_bg;
57
73
        LwBackgroundRenderType default_render_type;
58
74
 
59
 
        LwTexture *custom_bg;
60
 
        LwBackgroundRenderType custom_render_type;
61
 
 
62
75
        gchar *image;
63
76
        LwBackgroundRenderType render_type;
 
77
 
64
78
        GdkRGBA primary_color;
65
79
        GdkRGBA secondary_color;
66
 
        LwBackgroundShadingType shading_type;
67
80
};
68
81
 
69
82
enum
74
87
        PROP_RENDER_TYPE,
75
88
        PROP_PRIMARY_COLOR,
76
89
        PROP_SECONDARY_COLOR,
77
 
        PROP_SHADING_TYPE,
78
90
 
79
91
        N_PROPERTIES
80
92
};
83
95
 
84
96
G_DEFINE_TYPE(LwBackground, lw_background, G_TYPE_OBJECT)
85
97
 
 
98
static void lw_background_changed(GSettings *settings, gchar *key, LwBackground *self);
 
99
 
86
100
/**
87
101
 * lw_background_new_with_default_image:
88
102
 * @filename: Name of the default background image
102
116
 
103
117
        background->priv->default_bg = lw_texture_new_from_file(filename, error);
104
118
        background->priv->default_render_type = type;
 
119
        
 
120
        lw_background_changed(background->priv->settings, "default-bg", background);
105
121
 
106
122
        return background;
107
123
}
111
127
                          GdkColor *secondary_color,
112
128
                          LwBackgroundShadingType type)
113
129
{
 
130
        LwTexture *texture;
114
131
        guint width, height;
115
132
        GLushort data[8];
116
133
 
142
159
                        height = 1;
143
160
        }
144
161
 
145
 
        return lw_texture_new_from_data((guchar *) data, width, height, GL_RGBA, GL_UNSIGNED_SHORT);
 
162
        texture = lw_texture_new_from_data((guchar *) data, width, height, GL_RGBA, GL_UNSIGNED_SHORT);
 
163
        lw_texture_set_filter(texture, GL_LINEAR);
 
164
 
 
165
        return texture;
146
166
}
147
167
 
148
168
static LwTexture*
182
202
        background->priv->default_bg = create_texture_from_color(primary_color, secondary_color, type);
183
203
        background->priv->default_render_type = LwBackgroundStretched;
184
204
 
185
 
        lw_texture_set_filter(background->priv->default_bg, GL_LINEAR);
 
205
        lw_background_changed(background->priv->settings, "default-bg", background);
186
206
 
187
207
        return background;
188
208
}
189
209
 
190
210
static void
191
 
lw_background_update_custom_bg(LwBackground *self)
192
 
{
193
 
        if(self->priv->image && self->priv->shading_type == LwBackgroundCustomImage)
194
 
        {
195
 
                GError *error = NULL;
196
 
 
197
 
                /* Load image */
198
 
                if(self->priv->custom_bg != NULL)
199
 
                        g_object_unref(self->priv->custom_bg);
200
 
 
201
 
                self->priv->custom_bg = lw_texture_new_from_file(self->priv->image, &error);
202
 
                if(error != NULL)
203
 
                {
204
 
                        if(strlen(self->priv->image) != 0)
205
 
                                g_warning("Could not load custom background image: %s", error->message);
206
 
                        g_error_free(error);
207
 
 
208
 
                        /* Use color gradient as background */
209
 
                        g_free(self->priv->image);
210
 
                        self->priv->image = NULL;
211
 
                        lw_background_update_custom_bg(self);
212
 
                        return;
213
 
                }
214
 
 
215
 
                self->priv->custom_render_type = self->priv->render_type;
216
 
        }
217
 
        else
218
 
        {
219
 
                /* Create color gradient */
220
 
                if(self->priv->custom_bg != NULL)
221
 
                        g_object_unref(self->priv->custom_bg);
222
 
 
223
 
                self->priv->custom_bg = create_texture_from_rgba(&self->priv->primary_color,
224
 
                                                                 &self->priv->secondary_color,
225
 
                                                                 self->priv->shading_type);
226
 
                self->priv->custom_render_type = LwBackgroundStretched;
227
 
 
228
 
                lw_texture_set_filter(self->priv->custom_bg, GL_LINEAR);
229
 
        }
230
 
}
231
 
 
232
 
static void
233
211
lw_background_set_property(GObject *object,
234
212
                           guint property_id,
235
213
                           const GValue *value,
242
220
                case PROP_IMAGE:
243
221
                        g_free(self->priv->image);
244
222
                        self->priv->image = g_strdup(g_value_get_string(value));
245
 
                        lw_background_update_custom_bg(self);
 
223
                        if(self->priv->bg_mode == LwBackgroundCustomImage)
 
224
                                lw_background_changed(self->priv->settings, "bg-image", self);
246
225
                        break;
247
226
 
248
227
                case PROP_RENDER_TYPE:
249
228
                        self->priv->render_type = g_value_get_uint(value);
250
 
                        if(self->priv->image != NULL)
251
 
                                self->priv->custom_render_type = self->priv->render_type;
 
229
                        if(self->priv->bg_mode == LwBackgroundCustomImage)
 
230
                                self->priv->bg_render_type = self->priv->render_type;
252
231
                        break;
253
232
 
254
233
                case PROP_PRIMARY_COLOR:
255
234
                        self->priv->primary_color = *((GdkRGBA*) g_value_get_boxed(value));
256
 
                        lw_background_update_custom_bg(self);
 
235
                        if(self->priv->bg_mode == LwBackgroundSingleColor ||
 
236
                           self->priv->bg_mode == LwBackgroundHorizontalGradient ||
 
237
                           self->priv->bg_mode == LwBackgroundVerticalGradient)
 
238
                                lw_background_changed(self->priv->settings, "bg-primary-color", self);
257
239
                        break;
258
240
 
259
241
                case PROP_SECONDARY_COLOR:
260
242
                        self->priv->secondary_color = *((GdkRGBA*) g_value_get_boxed(value));
261
 
                        lw_background_update_custom_bg(self);
262
 
                        break;
263
 
 
264
 
                case PROP_SHADING_TYPE:
265
 
                        self->priv->shading_type = g_value_get_uint(value);
266
 
                        lw_background_update_custom_bg(self);
 
243
                        if(self->priv->bg_mode == LwBackgroundHorizontalGradient ||
 
244
                           self->priv->bg_mode == LwBackgroundVerticalGradient)
 
245
                                lw_background_changed(self->priv->settings, "bg-secondary-color", self);
267
246
                        break;
268
247
 
269
248
                default:
298
277
                        g_value_set_boxed(value, &self->priv->secondary_color);
299
278
                        break;
300
279
 
301
 
                case PROP_SHADING_TYPE:
302
 
                        g_value_set_uint(value, self->priv->shading_type);
303
 
                        break;
304
 
 
305
280
                default:
306
281
                        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
307
282
                        break;
322
297
        gint width  = lw_output_get_width(output),
323
298
             height = lw_output_get_height(output);
324
299
        gint tex_width, tex_height;
325
 
        LwTexture* tex;
326
 
        LwBackgroundRenderType type;
 
300
        LwTexture* tex = self->priv->bg_texture;
 
301
        LwBackgroundRenderType type = self->priv->bg_render_type;
327
302
        LwTextureMatrix m;
328
303
 
329
 
        /* Get the right background */
330
 
        if(self->priv->shading_type == LwBackgroundDefault)
 
304
        if(tex == NULL && self->priv->default_bg != NULL)
331
305
        {
 
306
                /* Fallback to default background */
332
307
                tex = self->priv->default_bg;
333
308
                type = self->priv->default_render_type;
334
309
        }
335
 
        else
336
 
        {
337
 
                tex = self->priv->custom_bg;
338
 
                type = self->priv->custom_render_type;
339
 
        }
340
 
 
341
 
        if(tex == NULL) return;
 
310
        else if(tex == NULL) return;
342
311
 
343
312
        tex_width = lw_texture_get_width(tex);
344
313
        tex_height = lw_texture_get_height(tex);
447
416
}
448
417
 
449
418
static void
450
 
lw_background_bg_render_type_changed(GSettings *settings, gchar *key, LwBackground *self)
 
419
lw_background_changed(GSettings *settings, gchar *key, LwBackground *self)
 
420
{
 
421
        (void) key;
 
422
 
 
423
        if(self->priv->bg_texture)
 
424
        {
 
425
                g_object_unref(self->priv->bg_texture);
 
426
                self->priv->bg_texture = NULL;
 
427
        }
 
428
 
 
429
        self->priv->bg_mode = g_settings_get_enum(settings, "bg-mode");
 
430
        switch(self->priv->bg_mode)
 
431
        {
 
432
                case LwBackgroundCustomImage:
 
433
                {
 
434
                        GError *error = NULL;
 
435
 
 
436
                        /* Load image */
 
437
                        self->priv->bg_texture = lw_texture_new_from_file(self->priv->image, &error);
 
438
 
 
439
                        if(error != NULL)
 
440
                        {
 
441
                                if(strlen(self->priv->image) != 0)
 
442
                                        g_warning("Could not load custom background image: %s", error->message);
 
443
                                g_error_free(error);
 
444
                        }
 
445
 
 
446
                        self->priv->bg_render_type = self->priv->render_type;
 
447
                        break;
 
448
                }
 
449
 
 
450
                case LwBackgroundSingleColor:
 
451
                        self->priv->bg_texture = create_texture_from_rgba(&self->priv->primary_color,
 
452
                                                                      &self->priv->secondary_color,
 
453
                                                                      LwBackgroundSolid);
 
454
                        self->priv->bg_render_type = LwBackgroundStretched;
 
455
                        break;
 
456
 
 
457
                case LwBackgroundHorizontalGradient:
 
458
                        self->priv->bg_texture = create_texture_from_rgba(&self->priv->primary_color,
 
459
                                                                      &self->priv->secondary_color,
 
460
                                                                      LwBackgroundHorizontal);
 
461
                        self->priv->bg_render_type = LwBackgroundStretched;
 
462
                        break;
 
463
 
 
464
                case LwBackgroundVerticalGradient:
 
465
                        self->priv->bg_texture = create_texture_from_rgba(&self->priv->primary_color,
 
466
                                                                      &self->priv->secondary_color,
 
467
                                                                      LwBackgroundVertical);
 
468
                        self->priv->bg_render_type = LwBackgroundStretched;
 
469
                        break;
 
470
 
 
471
                case LwBackgroundDefault:
 
472
                default:
 
473
                        self->priv->bg_texture = self->priv->default_bg;
 
474
                        if(self->priv->default_bg)
 
475
                                g_object_ref(self->priv->default_bg);
 
476
                        self->priv->bg_render_type = self->priv->default_render_type;
 
477
        }
 
478
}
 
479
 
 
480
static void
 
481
lw_background_render_type_changed(GSettings *settings, gchar *key, LwBackground *self)
451
482
{
452
483
        (void) key;
453
484
 
455
486
}
456
487
 
457
488
static void
458
 
lw_background_bg_shading_type_changed(GSettings *settings, gchar *key, LwBackground *self)
459
 
{
460
 
        (void) key;
461
 
 
462
 
        g_object_set(self, "shading-type", g_settings_get_enum(settings, "bg-shading-type"), NULL);
463
 
}
464
 
 
465
 
static void
466
489
lw_background_init(LwBackground *self)
467
490
{
468
491
        GSettings *settings = g_settings_new("net.launchpad.livewallpaper");
469
492
        self->priv = LW_BACKGROUND_GET_PRIVATE(self);
 
493
        self->priv->settings = settings;
 
494
 
 
495
        self->priv->bg_mode = LwBackgroundDefault;
 
496
 
 
497
        self->priv->bg_texture = NULL;
 
498
        self->priv->bg_render_type = LwBackgroundZoom;
470
499
 
471
500
        self->priv->default_bg = NULL;
472
501
        self->priv->default_render_type = LwBackgroundZoom;
473
502
 
474
 
        self->priv->custom_bg = NULL;
475
 
        self->priv->custom_render_type = LwBackgroundZoom;
476
 
 
477
 
        self->priv->render_type = g_settings_get_enum(settings, "bg-render-type");
478
 
        self->priv->shading_type = g_settings_get_enum(settings, "bg-shading-type");
479
 
 
480
503
        /* Bind settings to properties */
 
504
        g_signal_connect(settings, "changed::bg-mode", G_CALLBACK(lw_background_changed), self);
 
505
 
481
506
        g_settings_bind(settings, "bg-image", self, "image", G_SETTINGS_BIND_GET);
482
 
        g_signal_connect(settings, "changed::bg-render-type", G_CALLBACK(lw_background_bg_render_type_changed), self);
 
507
        g_signal_connect(settings, "changed::bg-render-type", G_CALLBACK(lw_background_render_type_changed), self);
 
508
        self->priv->render_type = g_settings_get_enum(settings, "bg-render-type");
483
509
 
484
510
        g_settings_bind_with_mapping(settings, "bg-primary-color", self, "primary-color", G_SETTINGS_BIND_GET,
485
511
                                     lw_color_get_color_mapping, lw_color_set_color_mapping, NULL, NULL);
486
512
        g_settings_bind_with_mapping(settings, "bg-secondary-color", self, "secondary-color", G_SETTINGS_BIND_GET,
487
513
                                     lw_color_get_color_mapping, lw_color_set_color_mapping, NULL, NULL);
488
 
        g_signal_connect(settings, "changed::bg-shading-type", G_CALLBACK(lw_background_bg_shading_type_changed), self);
489
514
}
490
515
 
491
516
static void
493
518
{
494
519
        LwBackground *self = LW_BACKGROUND(object);
495
520
 
 
521
        if(self->priv->settings)
 
522
        {
 
523
                g_object_unref(self->priv->settings);
 
524
                self->priv->settings = NULL;
 
525
        }
 
526
 
 
527
        if(self->priv->bg_texture)
 
528
        {
 
529
                g_object_unref(self->priv->bg_texture);
 
530
                self->priv->bg_texture = NULL;
 
531
        }
 
532
 
496
533
        if(self->priv->default_bg)
497
534
        {
498
535
                g_object_unref(self->priv->default_bg);
499
536
                self->priv->default_bg = NULL;
500
537
        }
501
538
 
502
 
        if(self->priv->custom_bg)
503
 
        {
504
 
                g_object_unref(self->priv->custom_bg);
505
 
                self->priv->custom_bg = NULL;
506
 
        }
507
 
 
508
539
        /* Chain up to the parent class */
509
540
        G_OBJECT_CLASS(lw_background_parent_class)->dispose(object);
510
541
}
533
564
        g_type_class_add_private(klass, sizeof(LwBackgroundPrivate));
534
565
 
535
566
        /**
536
 
         * LwBackground:shading-type:
537
 
         *
538
 
         * How to shade the background color
539
 
         */
540
 
        obj_properties[PROP_SHADING_TYPE] =
541
 
                g_param_spec_uint("shading-type",
542
 
                                  "Shading Type",
543
 
                                  "How to shade the background color",
544
 
                                  0,
545
 
                                  4,
546
 
                                  0,
547
 
                                  G_PARAM_READWRITE);
548
 
 
549
 
        /**
550
567
         * LwBackground:image:
551
568
         *
552
569
         * Path to use for the background image