← Back to branch summary

~noskcaj/ubuntu/vivid/gthumb/flickr-https

« back to all changes in this revision

Viewing changes to extensions/slideshow/gth-slideshow.c

  • Committer: Package Import Robot
  • Author(s): Jackson Doak
  • Date: 2014-04-08 06:31:09 UTC
  • mfrom: (1.3.20)
  • Revision ID: package-import@ubuntu.com-20140408063109-tk845map8ji6uxvd
Tags: 3:3.3.1.is.3.2.7-0ubuntu1
https://launchpad.net/bugs/1290691
* Revert to newest upstream stable release. LP: #1290691
  - Refresh patches

Show diffs side-by-side

added added

removed removed

Lines of Context:
extensions/slideshow/gth-slideshow.c
62
62
        GthSlideshowDirection  direction;
63
63
#if HAVE_CLUTTER
64
64
        ClutterTimeline       *timeline;
 
65
        ClutterAlpha          *alpha;
65
66
        ClutterActor          *image1;
66
67
        ClutterActor          *image2;
67
68
        ClutterActor          *paused_actor;
130
131
}
131
132
 
132
133
 
133
 
static void _gth_slideshow_load_next_image (GthSlideshow *self);
134
 
 
135
 
 
136
 
static void
137
 
preloader_load_ready_cb (GObject        *source_object,
138
 
                         GAsyncResult   *result,
139
 
                         gpointer        user_data)
140
 
{
141
 
        GthSlideshow *self = user_data;
142
 
        GthFileData  *requested;
143
 
        GthImage     *image;
144
 
        int           requested_size;
145
 
        int           original_width;
146
 
        int           original_height;
147
 
        GError       *error = NULL;
148
 
 
149
 
        if (! gth_image_preloader_load_finish (GTH_IMAGE_PRELOADER (source_object),
150
 
                                               result,
151
 
                                               &requested,
152
 
                                               &image,
153
 
                                               &requested_size,
154
 
                                               &original_width,
155
 
                                               &original_height,
156
 
                                               &error))
157
 
        {
158
 
                g_clear_error (&error);
159
 
                _gth_slideshow_load_next_image (self);
160
 
                return;
161
 
        }
162
 
 
163
 
        _g_object_unref (self->priv->current_pixbuf);
164
 
        self->priv->current_pixbuf = gth_image_get_pixbuf (image);
165
 
 
166
 
        if (self->priv->current_pixbuf == NULL) {
167
 
                _gth_slideshow_load_next_image (self);
168
 
                return;
169
 
        }
170
 
 
171
 
        self->priv->one_loaded = TRUE;
172
 
        self->priv->projector->image_ready (self, self->priv->current_pixbuf);
173
 
 
174
 
        _g_object_unref (requested);
175
 
        _g_object_unref (image);
176
 
}
177
 
 
178
 
 
179
134
static void
180
135
_gth_slideshow_load_current_image (GthSlideshow *self)
181
136
{
220
175
        gth_image_preloader_load (self->priv->preloader,
221
176
                                  requested_file,
222
177
                                  MAX (screen_width, screen_height),
223
 
                                  NULL,
224
 
                                  preloader_load_ready_cb,
225
 
                                  self,
226
 
                                  2,
227
178
                                  next_file,
228
 
                                  prev_file);
 
179
                                  prev_file,
 
180
                                  NULL);
229
181
}
230
182
 
231
183
 
291
243
 
292
244
 
293
245
static void
 
246
image_preloader_requested_ready_cb (GthImagePreloader  *preloader,
 
247
                                    GthFileData        *requested,
 
248
                                    GthImage           *image,
 
249
                                    int                 original_width,
 
250
                                    int                 original_height,
 
251
                                    GError             *error,
 
252
                                    gpointer            user_data)
 
253
{
 
254
        GthSlideshow *self = user_data;
 
255
 
 
256
        if (error != NULL) {
 
257
                g_clear_error (&error);
 
258
                _gth_slideshow_load_next_image (self);
 
259
                return;
 
260
        }
 
261
 
 
262
        _g_object_unref (self->priv->current_pixbuf);
 
263
        self->priv->current_pixbuf = gth_image_get_pixbuf (image);
 
264
 
 
265
        if (self->priv->current_pixbuf == NULL) {
 
266
                _gth_slideshow_load_next_image (self);
 
267
                return;
 
268
        }
 
269
 
 
270
        self->priv->one_loaded = TRUE;
 
271
        self->priv->projector->image_ready (self, self->priv->current_pixbuf);
 
272
}
 
273
 
 
274
 
 
275
static void
294
276
gth_slideshow_finalize (GObject *object)
295
277
{
296
278
        GthSlideshow *self = GTH_SLIDESHOW (object);
466
448
        self->priv->random_order = FALSE;
467
449
        self->priv->current_pixbuf = NULL;
468
450
        self->priv->screensaver = gth_screensaver_new (NULL);
469
 
        self->priv->preloader = gth_image_preloader_new ();
 
451
 
 
452
        self->priv->preloader = gth_image_preloader_new (GTH_LOAD_POLICY_ONE_STEP, 3);
 
453
        g_signal_connect (self->priv->preloader,
 
454
                          "requested_ready",
 
455
                          G_CALLBACK (image_preloader_requested_ready_cb),
 
456
                          self);
470
457
}
471
458
 
472
459
 
487
474
                                                             NULL);
488
475
        if (self->priv->pause_pixbuf == NULL)
489
476
                self->priv->pause_pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
490
 
                                                                     "media-playback-pause-symbolic",
 
477
                                                                     GTK_STOCK_MEDIA_PAUSE,
491
478
                                                                     100,
492
479
                                                                     0,
493
480
                                                                     NULL);
739
726
        self->priv->paint_paused = FALSE;
740
727
 
741
728
        self->priv->viewer = gth_image_viewer_new ();
 
729
        gth_image_viewer_set_black_background (GTH_IMAGE_VIEWER (self->priv->viewer), TRUE);
742
730
        gth_image_viewer_hide_frame (GTH_IMAGE_VIEWER (self->priv->viewer));
743
731
        gth_image_viewer_set_fit_mode (GTH_IMAGE_VIEWER (self->priv->viewer), GTH_FIT_SIZE);
744
732
        gth_image_viewer_set_zoom_change (GTH_IMAGE_VIEWER (self->priv->viewer), GTH_ZOOM_CHANGE_FIT_SIZE);
 
733
        gth_image_viewer_set_transp_type (GTH_IMAGE_VIEWER (self->priv->viewer), GTH_TRANSP_TYPE_BLACK);
745
734
        gth_image_viewer_set_zoom_quality (GTH_IMAGE_VIEWER (self->priv->viewer), GTH_ZOOM_QUALITY_LOW);
746
735
        gth_image_viewer_add_painter (GTH_IMAGE_VIEWER (self->priv->viewer), default_projector_pause_painter, self);
747
736
 
801
790
 
802
791
        clutter_actor_get_size (self->stage, &stage_w, &stage_h);
803
792
 
804
 
        clutter_actor_set_pivot_point (texture, stage_w / 2.0, stage_h / 2.0);
 
793
        clutter_actor_set_anchor_point (texture, 0.0, 0.0);
805
794
        clutter_actor_set_opacity (texture, 255);
806
 
        clutter_actor_set_rotation_angle (texture, CLUTTER_X_AXIS, 0.0);
807
 
        clutter_actor_set_rotation_angle (texture, CLUTTER_Y_AXIS, 0.0);
808
 
        clutter_actor_set_rotation_angle (texture, CLUTTER_Z_AXIS, 0.0);
 
795
        clutter_actor_set_rotation (texture,
 
796
                                    CLUTTER_X_AXIS,
 
797
                                    0.0,
 
798
                                    stage_w / 2.0,
 
799
                                    stage_h / 2.0,
 
800
                                    0.0);
 
801
        clutter_actor_set_rotation (texture,
 
802
                                    CLUTTER_Y_AXIS,
 
803
                                    0.0,
 
804
                                    stage_w / 2.0,
 
805
                                    stage_h / 2.0,
 
806
                                    0.0);
 
807
        clutter_actor_set_rotation (texture,
 
808
                                    CLUTTER_Z_AXIS,
 
809
                                    0.0,
 
810
                                    stage_w / 2.0,
 
811
                                    stage_h / 2.0,
 
812
                                    0.0);
809
813
        clutter_actor_set_scale (texture, 1.0, 1.0);
810
814
}
811
815
 
824
828
        }
825
829
 
826
830
        if ((self->current_image != NULL) && (self->next_image != NULL)) {
827
 
                clutter_actor_set_child_above_sibling (CLUTTER_ACTOR (self->stage), self->current_image, self->next_image);
 
831
                clutter_actor_raise (self->current_image, self->next_image);
828
832
                clutter_actor_hide (self->next_image);
829
833
        }
830
834
 
885
889
        if (self->priv->transition != NULL)
886
890
                gth_transition_frame (self->priv->transition,
887
891
                                      self,
888
 
                                      clutter_timeline_get_progress (self->priv->timeline));
 
892
                                      clutter_alpha_get_alpha (self->priv->alpha));
889
893
 
890
894
        if (self->first_frame)
891
895
                self->first_frame = FALSE;
983
987
clutter_projector_finalize (GthSlideshow *self)
984
988
{
985
989
        _g_object_unref (self->priv->timeline);
 
990
        _g_object_unref (self->priv->alpha);
986
991
}
987
992
 
988
993
 
1013
1018
 
1014
1019
        clutter_actor_get_size (self->stage, &stage_w, &stage_h);
1015
1020
        clutter_actor_set_position (self->priv->paused_actor, stage_w / 2.0, stage_h / 2.0);
1016
 
        clutter_actor_set_pivot_point (self->priv->paused_actor, 0.5, 0.5);
 
1021
        clutter_actor_set_anchor_point_from_gravity (self->priv->paused_actor, CLUTTER_GRAVITY_CENTER);
1017
1022
        clutter_actor_set_scale (self->priv->paused_actor, 1.0, 1.0);
1018
1023
        clutter_actor_set_opacity (self->priv->paused_actor, 255);
1019
 
        clutter_actor_set_child_above_sibling (CLUTTER_ACTOR (self->stage), self->priv->paused_actor, NULL);
 
1024
        clutter_actor_raise_top (self->priv->paused_actor);
1020
1025
        clutter_actor_show (self->priv->paused_actor);
1021
1026
 
1022
 
        clutter_actor_save_easing_state (self->priv->paused_actor);
1023
 
        clutter_actor_set_easing_mode (self->priv->paused_actor, CLUTTER_LINEAR);
1024
 
        clutter_actor_set_easing_duration (self->priv->paused_actor, 500);
1025
 
        clutter_actor_set_scale (self->priv->paused_actor, 3.0, 3.0);
1026
 
        clutter_actor_set_opacity (self->priv->paused_actor, 0);
1027
 
        clutter_actor_restore_easing_state (self->priv->paused_actor);
 
1027
        clutter_actor_animate (self->priv->paused_actor,
 
1028
                               CLUTTER_LINEAR, 500,
 
1029
                               "opacity", 0,
 
1030
                               "scale-x", 3.0,
 
1031
                               "scale-y", 3.0,
 
1032
                               NULL);
1028
1033
}
1029
1034
 
1030
1035
 
1177
1182
        embed = gtk_clutter_embed_new ();
1178
1183
        self->stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (embed));
1179
1184
        clutter_stage_hide_cursor (CLUTTER_STAGE (self->stage));
1180
 
        clutter_actor_set_background_color (CLUTTER_ACTOR (self->stage), &background_color);
 
1185
        clutter_stage_set_color (CLUTTER_STAGE (self->stage), &background_color);
1181
1186
 
1182
1187
        self->priv->last_button_event_time = 0;
1183
1188
        g_signal_connect (self->stage, "button-press-event", G_CALLBACK (stage_input_cb), self);
1187
1192
 
1188
1193
        self->priv->image1 = gtk_clutter_texture_new ();
1189
1194
        clutter_actor_hide (self->priv->image1);
1190
 
        clutter_actor_add_child (CLUTTER_ACTOR (self->stage), self->priv->image1);
 
1195
        clutter_container_add_actor (CLUTTER_CONTAINER (self->stage), self->priv->image1);
1191
1196
 
1192
1197
        self->priv->image2 = gtk_clutter_texture_new ();
1193
1198
        clutter_actor_hide (self->priv->image2);
1194
 
        clutter_actor_add_child (CLUTTER_ACTOR (self->stage), self->priv->image2);
 
1199
        clutter_container_add_actor (CLUTTER_CONTAINER (self->stage), self->priv->image2);
1195
1200
 
1196
1201
        self->current_image = NULL;
1197
1202
        self->next_image = self->priv->image1;
1198
1203
 
1199
1204
        self->priv->timeline = clutter_timeline_new (GTH_TRANSITION_DURATION);
1200
 
        clutter_timeline_set_progress_mode (self->priv->timeline, CLUTTER_EASE_IN_OUT_SINE);
1201
1205
        g_signal_connect (self->priv->timeline, "completed", G_CALLBACK (animation_completed_cb), self);
1202
1206
        g_signal_connect (self->priv->timeline, "new-frame", G_CALLBACK (animation_frame_cb), self);
1203
1207
        g_signal_connect (self->priv->timeline, "started", G_CALLBACK (animation_started_cb), self);
1204
1208
 
 
1209
        self->priv->alpha = clutter_alpha_new_full (self->priv->timeline, CLUTTER_EASE_IN_OUT_SINE);
 
1210
 
1205
1211
        self->priv->paused_actor = gtk_clutter_texture_new ();
1206
1212
        if (self->priv->pause_pixbuf != NULL)
1207
1213
                gtk_clutter_texture_set_from_pixbuf (GTK_CLUTTER_TEXTURE (self->priv->paused_actor),
1208
1214
                                                     self->priv->pause_pixbuf,
1209
1215
                                                     NULL);
1210
1216
        else
1211
 
                gtk_clutter_texture_set_from_icon_name (GTK_CLUTTER_TEXTURE (self->priv->paused_actor),
1212
 
                                                        GTK_WIDGET (self),
1213
 
                                                        "media-playback-pause-symbolic",
1214
 
                                                        GTK_ICON_SIZE_DIALOG,
1215
 
                                                        NULL);
 
1217
                gtk_clutter_texture_set_from_stock (GTK_CLUTTER_TEXTURE (self->priv->paused_actor),
 
1218
                                                    GTK_WIDGET (self),
 
1219
                                                    GTK_STOCK_MEDIA_PAUSE,
 
1220
                                                    GTK_ICON_SIZE_DIALOG,
 
1221
                                                    NULL);
1216
1222
        clutter_actor_hide (self->priv->paused_actor);
1217
 
        clutter_actor_add_child (CLUTTER_ACTOR (self->stage), self->priv->paused_actor);
 
1223
        clutter_container_add_actor (CLUTTER_CONTAINER (self->stage), self->priv->paused_actor);
1218
1224
 
1219
1225
        g_signal_connect (self, "size-allocate", G_CALLBACK (gth_slideshow_size_allocate_cb), self);
1220
1226