Imported Upstream version 0.18.1upstream/0.18.1

1 files changed, 351 insertions, 0 deletions

diff --git a/src/slideshow/TransitionEffects.vala b/src/slideshow/TransitionEffects.vala
new file mode 100644
index 0000000..7b10543
--- /dev/null
+++ b/src/slideshow/TransitionEffects.vala
@@ -0,0 +1,351 @@
+/* Copyright 2010 Maxim Kartashev
+ * Copyright 2011-2014 Yorba Foundation
+ *
+ * This software is licensed under the GNU LGPL (version 2.1 or later).
+ * See the COPYING file in this distribution.
+ */
+
+public class TransitionEffectsManager {
+    public const string NULL_EFFECT_ID = NullTransitionDescriptor.EFFECT_ID;
+    public const string RANDOM_EFFECT_ID = RandomEffectDescriptor.EFFECT_ID;
+    private static TransitionEffectsManager? instance = null;
+    
+    // effects are stored by effect ID
+    private Gee.Map<string, Spit.Transitions.Descriptor> effects = new Gee.HashMap<
+        string, Spit.Transitions.Descriptor>();
+    private Spit.Transitions.Descriptor null_descriptor = new NullTransitionDescriptor();
+    private Spit.Transitions.Descriptor random_descriptor = new RandomEffectDescriptor();
+    
+    private TransitionEffectsManager() {
+        load_transitions();
+        Plugins.Notifier.get_instance().pluggable_activation.connect(load_transitions);
+    }
+    
+    ~TransitionEffectsManager() {
+        Plugins.Notifier.get_instance().pluggable_activation.disconnect(load_transitions);
+    }
+    
+    private void load_transitions() {
+        effects.clear();
+        
+        // add null and random effect first
+        effects.set(null_descriptor.get_id(), null_descriptor);
+        effects.set(random_descriptor.get_id(),random_descriptor);
+
+        // load effects from plug-ins
+        Gee.Collection<Spit.Pluggable> pluggables = Plugins.get_pluggables_for_type(
+            typeof(Spit.Transitions.Descriptor));
+        foreach (Spit.Pluggable pluggable in pluggables) {
+            int pluggable_interface = pluggable.get_pluggable_interface(Spit.Transitions.CURRENT_INTERFACE,
+                Spit.Transitions.CURRENT_INTERFACE);
+            if (pluggable_interface != Spit.Transitions.CURRENT_INTERFACE) {
+                warning("Unable to load transitions plug-in %s: reported interface %d",
+                    Plugins.get_pluggable_module_id(pluggable), pluggable_interface);
+                
+                continue;
+            }
+            
+            Spit.Transitions.Descriptor desc = (Spit.Transitions.Descriptor) pluggable;
+            if (effects.has_key(desc.get_id()))
+                warning("Multiple transitions loaded with same effect ID %s", desc.get_id());
+            else
+                effects.set(desc.get_id(), desc);
+        }
+    }
+    
+    public static void init() {
+        instance = new TransitionEffectsManager();
+    }
+    
+    public static void terminate() {
+        instance = null;
+    }
+    
+    public static TransitionEffectsManager get_instance() {
+        assert(instance != null);
+        
+        return instance;
+    }
+    
+    public Gee.Collection<string> get_effect_ids() {
+        return effects.keys;
+    }
+    
+    public Gee.Collection<string> get_effect_names(owned CompareDataFunc? comparator = null) {
+        Gee.Collection<string> effect_names = new Gee.TreeSet<string>((owned) comparator);
+        foreach (Spit.Transitions.Descriptor desc in effects.values)
+            effect_names.add(desc.get_pluggable_name());
+        
+        return effect_names;
+    }
+    
+    public string? get_id_for_effect_name(string effect_name) {
+        foreach (Spit.Transitions.Descriptor desc in effects.values) {
+            if (desc.get_pluggable_name() == effect_name)
+                return desc.get_id();
+        }
+        
+        return null;
+    }
+    
+    public Spit.Transitions.Descriptor? get_effect_descriptor(string effect_id) {
+        return effects.get(effect_id);
+    }
+    
+    public string get_effect_name(string effect_id) {
+        Spit.Transitions.Descriptor? desc = get_effect_descriptor(effect_id);
+        
+        return (desc != null) ? desc.get_pluggable_name() : _("(None)");
+    }
+    
+    public Spit.Transitions.Descriptor get_null_descriptor() {
+        return null_descriptor;
+    }
+    
+    public TransitionClock? create_transition_clock(string effect_id) {
+        Spit.Transitions.Descriptor? desc = get_effect_descriptor(effect_id);
+        
+        return (desc != null) ? new TransitionClock(desc) : null;
+    }
+    
+    public TransitionClock create_null_transition_clock() {
+        return new TransitionClock(null_descriptor);
+    }
+}
+
+public class TransitionClock {
+    // This method is called by TransitionClock to indicate that it's time for the transition to be
+    // repainted.  The callback should call TransitionClock.paint() with the appropriate Drawable
+    // either immediately or quite soon (in an expose event).
+    public delegate void RepaintCallback();
+    
+    private Spit.Transitions.Descriptor desc;
+    private Spit.Transitions.Effect effect;
+    private int desired_fps;
+    private int min_fps;
+    private int current_fps = 0;
+    private OpTimer paint_timer;
+    private Spit.Transitions.Visuals? visuals = null;
+    private Spit.Transitions.Motion? motion = null;
+    private unowned RepaintCallback? repaint = null;
+    private uint timer_id = 0;
+    private ulong time_started = 0;
+    private int frame_number = 0;
+    private bool cancelled = false;
+    
+    public TransitionClock(Spit.Transitions.Descriptor desc) {
+        this.desc = desc;
+        
+        effect = desc.create(new Plugins.StandardHostInterface(desc, "transitions"));
+        effect.get_fps(out desired_fps, out min_fps);
+        
+        paint_timer = new OpTimer(desc.get_pluggable_name());
+    }
+    
+    ~TransitionClock() {
+        cancel_timer();
+        debug("%s tick_msec=%d min/desired/current fps=%d/%d/%d", paint_timer.to_string(),
+            (motion != null) ? motion.tick_msec : 0, min_fps, desired_fps, current_fps);
+    }
+    
+    public bool is_in_progress() {
+        return (!cancelled && motion != null) ? frame_number < motion.total_frames : false;
+    }
+    
+    public void start(Spit.Transitions.Visuals visuals, Spit.Transitions.Direction direction,
+        int duration_msec, RepaintCallback repaint) {
+        reset();
+        
+        // if no desired FPS, this is a no-op transition
+        if (desired_fps == 0)
+            return;
+        
+        this.visuals = visuals;
+        this.repaint = repaint;
+        motion = new Spit.Transitions.Motion(direction, desired_fps, duration_msec);
+        
+        effect.start(visuals, motion);
+        
+        // start the timer
+        // TODO: It may be smarter to not use Timeout naively, as it does not attempt to catch up
+        // when tick() is called late.
+        time_started = now_ms();
+        timer_id = Timeout.add_full(Priority.HIGH, motion.tick_msec, tick);
+    }
+    
+    // This resets all state for the clock.  No check is done if the clock is running.
+    private void reset() {
+        visuals = null;
+        motion = null;
+        repaint = null;
+        cancel_timer();
+        time_started = 0;
+        frame_number = 1;
+        current_fps = 0;
+        cancelled = false;
+    }
+    
+    private void cancel_timer() {
+        if (timer_id != 0) {
+            Source.remove(timer_id);
+            timer_id = 0;
+        }
+    }
+    
+    // Calculate current FPS rate and returns true if it's above minimum
+    private bool is_fps_ok() {
+        assert(time_started > 0);
+        
+        if (frame_number <= 3) 
+            return true; // don't bother measuring if statistical data are too small
+        
+        double elapsed_msec = (double) (now_ms() - time_started);
+        if (elapsed_msec <= 0.0)
+            return true;
+        
+        current_fps = (int) ((frame_number * 1000.0) / elapsed_msec);
+        if (current_fps < min_fps) {
+            debug("Transition rate of %dfps below minimum of %dfps (elapsed=%lf frames=%d)",
+                current_fps, min_fps, elapsed_msec, frame_number);
+        }
+        
+        return (current_fps >= min_fps);
+    }
+    
+    // Cancels current transition.
+    public void cancel() {
+        cancelled = true;
+        cancel_timer();
+        effect.cancel();
+        
+        // repaint to complete the transition
+        repaint();
+    }
+    
+    // Call this whenever using a TransitionClock in the expose event.  Returns false if the
+    // transition has completed, in which case the caller should paint the final result.
+    public bool paint(Cairo.Context ctx, int width, int height) {
+        if (!is_in_progress())
+            return false;
+        
+        paint_timer.start();
+        
+        ctx.save();
+        
+        if (effect.needs_clear_background()) {
+            ctx.set_source_rgba(visuals.bg_color.red, visuals.bg_color.green, visuals.bg_color.blue,
+                visuals.bg_color.alpha);
+            ctx.rectangle(0, 0, width, height);
+            ctx.fill();
+        }
+        
+        effect.paint(visuals, motion, ctx, width, height, frame_number);
+        
+        ctx.restore();
+        
+        paint_timer.stop();
+        
+        return true;
+    }
+    
+    private bool tick() {
+        if (!is_fps_ok()) {
+            debug("Cancelling transition: below minimum fps");
+            cancel();
+        }
+        
+        // repaint always; this timer tick will go away when the frames have exhausted (and
+        // guarantees the first frame is painted before advancing the counter)
+        repaint();
+        
+        if (!is_in_progress()) {
+            cancel_timer();
+            
+            return false;
+        }
+        
+        // advance to the next frame
+        if (frame_number < motion.total_frames)
+            effect.advance(visuals, motion, ++frame_number);
+        
+        return true;
+    }
+}
+
+public class NullTransitionDescriptor : Object, Spit.Pluggable, Spit.Transitions.Descriptor {
+    public const string EFFECT_ID = "org.yorba.shotwell.transitions.null";
+    
+    public int get_pluggable_interface(int min_host_version, int max_host_version) {
+        return Spit.Transitions.CURRENT_INTERFACE;
+    }
+    
+    public unowned string get_id() {
+        return EFFECT_ID;
+    }
+    
+    public unowned string get_pluggable_name() {
+        return _("None");
+    }
+    
+    public void get_info(ref Spit.PluggableInfo info) {
+    }
+    
+    public void activation(bool enabled) {
+    }
+    
+    public Spit.Transitions.Effect create(Spit.HostInterface host) {
+        return new NullEffect();
+    }
+}
+
+public class NullEffect : Object, Spit.Transitions.Effect {
+    public NullEffect() {
+    }
+    
+    public void get_fps(out int desired_fps, out int min_fps) {
+        desired_fps = 0;
+        min_fps = 0;
+    }
+    
+    public void start(Spit.Transitions.Visuals visuals, Spit.Transitions.Motion motion) {
+    }
+    
+    public bool needs_clear_background() {
+        return false;
+    }
+    
+    public void paint(Spit.Transitions.Visuals visuals, Spit.Transitions.Motion motion, Cairo.Context ctx,
+        int width, int height, int frame_number) {
+    }
+    
+    public void advance(Spit.Transitions.Visuals visuals, Spit.Transitions.Motion motion, int frame_number) {
+    }
+    
+    public void cancel() {
+    }
+}
+public class RandomEffectDescriptor : Object, Spit.Pluggable, Spit.Transitions.Descriptor {
+    public const string EFFECT_ID = "org.yorba.shotwell.transitions.random";
+
+    public int get_pluggable_interface(int min_host_version, int max_host_version) {
+        return Spit.Transitions.CURRENT_INTERFACE;
+    }
+
+    public unowned string get_id() {
+        return EFFECT_ID;
+    }
+    
+    public unowned string get_pluggable_name() {
+        return _("Random");
+    }
+
+    public void get_info(ref Spit.PluggableInfo info) {
+    }
+    
+    public void activation(bool enabled) {
+    }
+
+    public Spit.Transitions.Effect create(Spit.HostInterface host) {
+        return new NullEffect();
+    }
+}