clutter 2.2.4-x64-mingw32

data/sample/drop-action.rb

@@ -0,0 +1,196 @@
+#!/usr/bin/env ruby
+#
+# This sample code is a port of clutter/examples/drop-action.c.
+# It is licensed under the terms of the GNU Lesser General Public
+# License, version 2.1 or (at your option) later.
+#
+# Copyright (C) 2013  Ruby-GNOME2 Project Team
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "clutter"
+
+TARGET_SIZE = 200
+HANDLE_SIZE = 128
+
+stage = Clutter::Stage.new
+stage.title = "Drop Action"
+stage.signal_connect("destroy") do
+  Clutter.main_quit
+end
+
+target1 = Clutter::Actor.new
+target1.background_color = Clutter::Color.new(:scarlet_red_light)
+target1.set_size(TARGET_SIZE, TARGET_SIZE)
+target1.opacity = 64
+target1.add_constraint(Clutter::AlignConstraint.new(stage, :y_axis, 0.5))
+target1.x = 10
+target1.reactive = true
+
+on_target_over = lambda do |action, actor, over_p|
+  final_opacity = over_p ? 128 : 64
+
+  target = action.actor
+  target.save_easing_state do
+    target.easing_mode = :linear
+    target.opacity = final_opacity
+  end
+end
+
+target1.add_action_with_name("drop", Clutter::DropAction.new)
+drop_action = target1.get_action("drop")
+drop_action.signal_connect("over-in") do |_action, actor|
+  on_target_over.call(_action, actor, true)
+end
+drop_action.signal_connect("over-out") do |_action, actor|
+  on_target_over.call(_action, actor, false)
+end
+
+drag = nil
+drop_successful = false
+add_drag_object = lambda do |target|
+  if drag.nil?
+    drag = Clutter::Actor.new
+    drag.background_color = Clutter::Color.new(:sky_blue_light)
+    drag.set_size(HANDLE_SIZE, HANDLE_SIZE)
+    drag.set_position((TARGET_SIZE - HANDLE_SIZE) / 2.0,
+                      (TARGET_SIZE - HANDLE_SIZE) / 2.0)
+    drag.reactive = true
+
+    action = Clutter::DragAction.new
+    action.signal_connect("drag-begin") do |_action, _actor, event_x, event_y, modifiers|
+      x, y = _actor.position
+      handle = Clutter::Actor.new
+      handle.background_color = Clutter::Color.new(:sky_blue_dark)
+      handle.set_size(128, 128)
+      handle.set_position(event_x - x, event_y - y)
+      stage.add_child(handle)
+
+      _action.drag_handle = handle
+
+      _actor.save_easing_state do
+        _actor.easing_mode = :linear
+        _actor.opacity = 128
+      end
+
+      drop_successful = true
+    end
+    action.signal_connect("drag-end") do |_action, _actor, event_x, event_y, modifiers|
+      handle = _action.drag_handle
+      printf("Drag ended at: %.0f, %.0f\n", event_x, event_y)
+      _actor.save_easing_state do
+        _actor.easing_mode = :linear
+        _actor.opacity = 255
+      end
+
+      handle.save_easing_state do
+        if drop_successful
+          handle.easing_mode = :linear
+          handle.opacity = 0
+        else
+          parent = _actor.parent
+
+          parent.save_easing_state do
+            parent.easing_mode = :linear
+            parent.opacity = 255
+          end
+
+          x_pos, y_pos = _actor.transformed_position
+
+          handle.easing_mode = :ease_out_bounce
+          handle.set_position(x_pos, y_pos)
+          handle.opacity = 0
+        end
+      end
+
+      handle.signal_connect("transitions-completed") do |_actor|
+        _actor.destroy
+      end
+    end
+
+    drag.add_action(action)
+  end
+
+  parent = drag.parent
+  if parent == target
+    target.save_easing_state do
+      target.easing_mode = :linear
+      target.opacity = 255
+    end
+    return
+  end
+
+  if parent and parent != stage
+    parent.remove_child(drag)
+
+    parent.save_easing_state do
+      parent.easing_mode = :linear
+      parent.opacity = 64
+    end
+  end
+  target.add_child(drag)
+
+  target.save_easing_state do
+    target.easing_mode = :linear
+    target.opacity = 255
+  end
+end
+
+on_target_drop = lambda do |_action, actor, event_x, event_y|
+  succeeded, actor_x, actor_y = actor.transform_stage_point(event_x, event_y)
+  printf("Dropped at %.0f, %.0f (screen: %.0f, %.0f)\n",
+         actor_x, actor_y,
+         event_x, event_y)
+
+  drop_successful = TRUE;
+  add_drag_object.call(actor)
+end
+drop_action.signal_connect("drop", &on_target_drop)
+
+dummy = Clutter::Actor.new
+dummy.background_color = Clutter::Color.new(:orange_dark)
+dummy.set_size(640 - (2 * 10) - (2 * (TARGET_SIZE + 10)),
+               TARGET_SIZE)
+dummy.add_constraint(Clutter::AlignConstraint.new(stage, :x_axis, 0.5))
+dummy.add_constraint(Clutter::AlignConstraint.new(stage, :y_axis, 0.5))
+dummy.reactive = true
+
+target2 = Clutter::Actor.new
+target2.background_color = Clutter::Color.new(:chameleon_light)
+target2.set_size(TARGET_SIZE, TARGET_SIZE)
+target2.opacity = 64
+target2.add_constraint(Clutter::AlignConstraint.new(stage, :y_axis, 0.5))
+target2.x = 640 - TARGET_SIZE - 10
+target2.reactive = true
+
+target2.add_action_with_name("drop", Clutter::DropAction.new)
+drop_action = target2.get_action("drop")
+drop_action.signal_connect("over-in") do |_action, actor|
+  on_target_over.call(_action, actor, true)
+end
+drop_action.signal_connect("over-out") do |_action, actor|
+  on_target_over.call(_action, actor, false)
+end
+drop_action.signal_connect("drop", &on_target_drop)
+
+stage.add_child(target1)
+stage.add_child(dummy)
+stage.add_child(target2)
+
+add_drag_object.call(target1)
+
+stage.show
+
+Clutter.main

data/sample/easing-modes.rb

@@ -0,0 +1,141 @@
+#!/usr/bin/env ruby
+#
+# This sample code is a port of clutter/examples/easing-mode.c.
+# It is licensed under the terms of the GNU Lesser General Public
+# License, version 2.1 or (at your option) later.
+#
+# Copyright (C) 2013  Ruby-GNOME2 Project Team
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "optparse"
+
+require "clutter"
+
+duration = 1
+
+parser = OptionParser.new
+parser.on("--duration=SECONDS", Integer,
+          "Duration of the animation",
+          "(#{duration})") do |_duration|
+  duration = _duration
+end
+parser.parse!
+
+current_mode_index = 0
+easing_modes = Clutter::AnimationMode.values.reject do |mode|
+  mode == Clutter::AnimationMode::CUSTOM_MODE
+end
+
+help_text = lambda do
+  format = <<-EOT.chomp
+<b>Easing mode: %s (%d of %d)</b>
+Left click to tween
+Middle click to jump
+Right click to change the easing mode
+EOT
+  current_mode = easing_modes[current_mode_index]
+  format % [current_mode.nick, current_mode_index, easing_modes.size]
+end
+
+stage = Clutter::Stage.new
+stage.title = "Easing Modes"
+stage.background_color = Clutter::Color.new(:sky_blue_light)
+stage.signal_connect("destroy") do
+  Clutter.main_quit
+end
+
+main_stage = stage
+
+stage_width, stage_height = stage.size
+
+bouncer_width = 50
+bouncer_height = 50
+
+canvas = Clutter::Canvas.new
+canvas.signal_connect("draw") do |_canvas, cairo_context, width, height|
+  cairo_context.operator = :clear
+  cairo_context.paint
+
+  cairo_context.operator = :over
+
+  radius = [width, height].max
+
+  cairo_context.arc(radius / 2, radius / 2, radius / 2, 0.0, 2.0 * Math::PI)
+
+  bouncer_color = Clutter::Color.new(:scarlet_red_dark)
+
+  pattern = Cairo::RadialPattern.new(radius / 2, radius / 2, 0,
+                                     radius, radius, radius)
+  pattern.add_color_stop_rgba(0,
+                              bouncer_color.red / 255.0,
+                              bouncer_color.green / 255.0,
+                              bouncer_color.blue / 255.0,
+                              bouncer_color.alpha / 255.0)
+  pattern.add_color_stop_rgba(0.85,
+                              bouncer_color.red / 255.0,
+                              bouncer_color.green / 255.0,
+                              bouncer_color.blue / 255.0,
+                              0.25);
+
+  cairo_context.set_source(pattern)
+  cairo_context.fill
+
+  Clutter::Event::STOP
+end
+canvas.set_size(bouncer_width, bouncer_height)
+
+rectangle = Clutter::Actor.new
+rectangle.name = "bouncer"
+rectangle.set_size(bouncer_width, bouncer_height)
+rectangle.set_pivot_point(0.5, 0.5)
+rectangle.set_translation(bouncer_width / -2.0, bouncer_height / -2.0, 0.0)
+rectangle.reactive = true
+rectangle.content = canvas
+
+stage.add_child(rectangle)
+rectangle.set_position(stage_width / 2, stage_height / 2)
+
+label = Clutter::Text.new
+stage.add_child(label)
+label.markup = help_text.call
+label.line_alignment = :right
+label.add_constraint(Clutter::AlignConstraint.new(stage, :x_axis, 0.95))
+label.add_constraint(Clutter::AlignConstraint.new(stage, :y_axis, 0.95))
+easing_mode_label = label
+
+stage.signal_connect("button-press-event") do |actor, event|
+  case event.button
+  when Clutter::BUTTON_SECONDARY
+    current_mode_index = (current_mode_index + 1) % easing_modes.size
+    label.markup = help_text.call
+  when Clutter::BUTTON_MIDDLE
+    rectangle.set_position(event.x, event.y)
+  when Clutter::BUTTON_PRIMARY
+    current_mode = easing_modes[current_mode_index]
+    rectangle.save_easing_state do
+      rectangle.easing_mode = current_mode
+      rectangle.easing_duration = duration * 1000
+
+      rectangle.set_position(event.x, event.y)
+    end
+  end
+
+  Clutter::Event::STOP
+end
+
+stage.show
+
+Clutter.main

data/sample/flow-layout.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+#
+# This sample code is a port of clutter/examples/flow-layout.c.
+# It is licensed under the terms of the GNU Lesser General Public
+# License, version 2.1 or (at your option) later.
+#
+# Copyright (C) 2013  Ruby-GNOME2 Project Team
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "optparse"
+
+require "clutter"
+
+random_size_p = false
+n_rects       = 20
+vertical_p    = false
+homogeneous_p = false
+x_spacing     = 0
+y_spacing     = 0
+fixed_size_p  = false
+
+parser = OptionParser.new
+parser.on("--[no-]random-size",
+          "Randomly size the rectangles",
+          "(#{random_size_p})") do |boolean|
+  random_size_p = boolean
+end
+parser.on("--n-rects=N", Integer,
+          "Number of rectangles",
+          "(#{n_rects})") do |n|
+  n_rects = n
+end
+parser.on("--[no-]vertical",
+          "Set vertical orientation",
+          "(#{vertical_p})") do |boolean|
+  vertical_p = boolean
+end
+parser.on("--[no-]homogeneous",
+          "Whether the layout should be homogeneous",
+          "(#{homogeneous_p})") do |boolean|
+  homogeneous_p = boolean
+end
+parser.on("--x-spacing=PIXEL", Integer,
+          "Horizontal spacing between elements",
+          "(#{x_spacing})") do |pixel|
+  x_spacing = pixel
+end
+parser.on("--y-spacing=PIXEL", Integer,
+          "Vertical spacing between elements",
+          "(#{y_spacing})") do |pixel|
+  y_spacing = pixel
+end
+parser.on("--[no-]fixed-size",
+          "Fix the layout size",
+          "(#{fixed_size_p})") do |boolean|
+  fixed_size_p = boolean
+end
+parser.parse!
+
+stage = Clutter::Stage.new
+stage.background_color = Clutter::Color.new(:sky_blue_light)
+stage.title = "Flow Layout"
+stage.user_resizable = true
+stage.signal_connect("destroy") do
+  Clutter.main_quit
+end
+
+layout = Clutter::FlowLayout.new(vertical_p ? :vertical : :horizontal)
+layout.homogeneous = homogeneous_p
+layout.column_spacing = x_spacing
+layout.row_spacing = y_spacing
+
+box = Clutter::Actor.new
+box.layout_manager = layout
+box.background_color = Clutter::Color.new(:aluminium_2)
+stage.add_child(box)
+
+unless fixed_size_p
+  box.add_constraint(Clutter::BindConstraint.new(stage, :size, 0.0))
+end
+
+box.set_position(0, 0)
+box.name = "box"
+
+n_rects.times do |i|
+  color = Clutter::Color.hls(360.0 / n_rects * i,
+                             0.5,
+                             0.8)
+  rect = Clutter::Actor.new
+  rect.background_color = color
+  if random_size_p
+    width = rand(50..100)
+    height = rand(50..100)
+  else
+    width = height = 50.0
+  end
+
+  rect.set_size(width, height)
+  rect.name = "rect%02d" % i
+
+  box.add_child(rect)
+end
+
+stage.show
+
+Clutter.main