gtk3 3.1.0-x64-mingw32 → 3.1.1-x64-mingw32

data/sample/gtk-demo/fishbowl.ui

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <!-- interface-requires gtk+ 3.6 -->
+  <object class="GtkWindow" id="window">
+    <property name="title" translatable="yes">Fishbowl</property>
+    <child type="titlebar">
+      <object class="GtkHeaderBar" id="">
+        <property name="visible">True</property>
+        <property name="show-close-button">True</property>
+        <child>
+          <object class="GtkLabel" id="info_label">
+            <property name="visible">True</property>
+            <property name="label">0 icons - 0 fps</property>
+          </object>
+          <packing>
+            <property name="pack_type">end</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkToggleButton" id="changes_allow">
+            <property name="active">False</property>
+            <property name="visible" bind-source="changes_allow" bind-property="active" bind-flags="invert-boolean">True</property>
+            <property name="icon-name">changes-allow</property>
+            <property name="relief">none</property>
+          </object>
+          <packing>
+            <property name="pack_type">end</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkToggleButton" id="changes_prevent">
+            <property name="active" bind-source="changes_allow" bind-property="active" bind-flags="bidirectional|invert-boolean">True</property>
+            <property name="visible" bind-source="changes_prevent" bind-property="active" bind-flags="invert-boolean">False</property>
+            <property name="icon-name">changes-prevent</property>
+            <property name="relief">none</property>
+          </object>
+          <packing>
+            <property name="pack_type">end</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkFixed" id="bowl">
+        <property name="visible">True</property>
+      </object>
+    </child>
+  </object>
+</interface>

data/sample/gtk-demo/glarea-gles.fs.glsl

@@ -0,0 +1,7 @@
+precision highp float;
+
+void main() {
+  float lerpVal = gl_FragCoord.y / 500.0f;
+
+  gl_FragColor = mix(vec4(1.0f, 0.85f, 0.35f, 1.0f), vec4(0.2f, 0.2f, 0.2f, 1.0f), lerpVal);
+}

data/sample/gtk-demo/glarea-gles.vs.glsl

@@ -0,0 +1,7 @@
+attribute vec4 position;
+
+uniform mat4 mvp;
+
+void main() {
+  gl_Position = mvp * position;
+}

data/sample/gtk-demo/glarea.rb

@@ -24,9 +24,9 @@ class GlareaDemo
     @window.screen = main_window.screen
     @window.title = "OpenGL Area"
     @window.set_default_size(400, 600)
-    @window.border_width = 12
 
     box = Gtk::Box.new(:vertical, false)
+    box.margin = 12
     box.spacing = 6
     @window.add(box)
 
@@ -42,7 +42,7 @@ class GlareaDemo
       widget.make_current
       unless widget.error
         init_buffers
-        @program, @mvp_location = init_shaders
+        @program, @mvp_location = init_shaders(widget)
       end
     end
 
@@ -110,9 +110,18 @@ class GlareaDemo
   end
 
   # Initialize shaders and link them into a programm
-  def init_shaders
-    src_vertex = Gio::Resources.lookup_data("/glarea/glarea-vertex.glsl", 0)
-    src_fragment = Gio::Resources.lookup_data("/glarea/glarea-fragment.glsl", 0)
+  def init_shaders(widget)
+    context = widget.context
+
+    if context.use_es?
+      vertex_path = "/glarea/glarea-gles.vs.glsl"
+      fragment_path = "/glarea/glarea-gles.fs.glsl"
+    else
+      vertex_path = "/glarea/glarea-gl.vs.glsl"
+      fragment_path = "/glarea/glarea-gl.fs.glsl"
+    end
+    src_vertex = Gio::Resources.lookup_data(vertex_path, 0)
+    src_fragment = Gio::Resources.lookup_data(fragment_path, 0)
     vertex = create_shader(GL_VERTEX_SHADER, src_vertex)
     return [0, nil] if vertex.zero?
     fragment = create_shader(GL_FRAGMENT_SHADER, src_fragment)
@@ -160,7 +169,7 @@ class GlareaDemo
       info_log = " " * (len + 1)
       glGetShaderInfoLog(shader, len, nil, info_log)
       type_name = type == GL_VERTEX_SHADER ? "vertex" : "fragment"
-      STDERR.puts "Compile failure in #{type_name}:\n#{info_log}\n"
+      STDERR.puts "Compile failure in #{type_name}:\n#{info_log}"
       return 0
     end
     shader

data/sample/gtk-demo/hypertext.rb

@@ -74,7 +74,6 @@ class HypertextDemo
     @window.screen = main_window.screen
     @window.title = "Hypertext"
     @window.set_default_size(450, 450)
-    @window.border_width = 0
   end
 
   def initialize_cursors(main_window)

data/sample/gtk-demo/images.rb

@@ -1,197 +1,180 @@
-# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# Copyright (c) 2017 Ruby-GNOME2 Project Team
 # This program is licenced under the same licence as Ruby-GNOME2.
 #
-# $Id: images.rb,v 1.5 2006/04/08 12:30:03 mutoh Exp $
 =begin
-= Images
+=  Images
 
-Gtk::Image is used to display an image; the image can be in a number of formats.
-Typically, you load an image into a Gdk::Pixbuf, then display the pixbuf.
+ GtkImage is used to display an image; the image can be in a number of formats.
+ Typically, you load an image into a GdkPixbuf, then display the pixbuf.
 
-This demo code shows some of the more obscure cases, in the simple
-case a call to Gtk::Image.new is all you need.
+ This demo code shows some of the more obscure cases, in the simple
+ case a call to gtk_image_new_from_file() is all you need.
 
-If you want to put image data in your program as a String variable,
-use the make-inline-pixbuf program that comes with GTK+.
-This way you won't need to depend on loading external files, your
-application binary can be self-contained.
+ If you want to put image data in your program as a C variable,
+ use the make-inline-pixbuf program that comes with GTK+.
+ This way you won't need to depend on loading external files, your
+ application binary can be self-contained.
 =end
-require 'common'
-
-module Demo
-  class Images < BasicWindow
-    def initialize
-      @pixbuf_loader = nil
-      @load_timeout = 0
-      @image_stream = nil
-
-      super('Images')
-      signal_connect('destroy') do
-        cleanup_callback
-      end
-
-      self.border_width = 8
-
-      vbox = Gtk::VBox.new(false, 8)
-      vbox.border_width = 8
-      add(vbox)
-
-      label = Gtk::Label.new
-      label.set_markup('<u>Image loaded from a file</u>')
-      vbox.pack_start(label, :expand => false, :fill => false, :padding => 0)
-
-      frame = Gtk::Frame.new
-      frame.shadow_type = :in
-
-      # The alignment keeps the frame from growing when users resize
-      # the window
-      align = Gtk::Alignment.new(0.5, 0.5, 0, 0)
-      align.add(frame)
-      vbox.pack_start(align, :expand => false, :fill => false, :padding => 0)
-
-      # demo_find_file looks in the the current directory first,
-      # so you can run gtk-demo without installing GTK, then looks
-      # in the location where the file is installed.
-      pixbuf = nil
-      begin
-        filename = Demo.find_file('gtk-logo-rgb.gif')
-        pixbuf = Gdk::Pixbuf.new(filename)
-      rescue
-        # This code shows off error handling. You can just use
-        # Gtk::Image.new instead if you don't want to report
-        # errors to the user. If the file doesn't load when using
-        # Gtk::Image.new, a 'missing image' icon will
-        # be displayed instead.
-        dialog = Gtk::MessageDialog.new(self,
-                                        Gtk::Dialog::DESTROY_WITH_PARENT,
-                                        Gtk::MessageDialog::ERROR,
-                                        Gtk::MessageDialog::BUTTONS_CLOSE,
-                                        "Unable to open image file 'gtk-logo-rgb.gif': #{$1}")
-
-        dialog.signal_connect('response') do |widget, data|
-          widget.destroy
-        end
-        dialog.show
-      end
-
-      image = Gtk::Image.new(pixbuf)
-      frame.add(image)
-
-
-      # Animation
-      label = Gtk::Label.new
-      label.set_markup('<u>Animation loaded from a file</u>')
-      vbox.pack_start(label, :expand => false, :fill => false, :padding => 0)
-
-      frame = Gtk::Frame.new
-      frame.shadow_type = :in
-
-      # The alignment keeps the frame from growing when users resize
-      # the window
-      align = Gtk::Alignment.new(0.5, 0.5, 0, 0)
-      align.add(frame)
-      vbox.pack_start(align, :expand => false, :fill => false, :padding => 0)
-
-      filename = Demo.find_file('floppybuddy.gif')
-      image = Gtk::Image.new(filename)
-      frame.add(image)
 
+require "thread"
 
-      # Progressive
-      label = Gtk::Label.new
-      label.set_markup('<u>Progressive image loading</u>')
-      vbox.pack_start(label, :expand => false, :fill => false, :padding => 0)
-
-      frame = Gtk::Frame.new(nil)
-      frame.shadow_type = :in
-
-      # The alignment keeps the frame from growing when users resize
-      # the window
-      align = Gtk::Alignment.new(0.5, 0.5, 0, 0)
-      align.add(frame)
-      vbox.pack_start(align, :expand => false, :fill => false, :padding => 0)
-
-      # Create an empty image for now; the progressive loader
-      # will create the pixbuf and fill it in.
-      image = Gtk::Image.new
-      frame.add(image)
-
-      start_progressive_loading(image)
-
-      # Sensitivity control
-      button = Gtk::ToggleButton.new('_Insensitive', true)
-      vbox.pack_start(button, :expand => false, :fill => false, :padding => 0)
-
-      button.signal_connect('toggled') do |widget|
-        vbox.children.each do |widget|
-          if widget != button
-            widget.sensitive = ! button.active?
-          end
-        end
-      end
+class ImagesDemo
+  def initialize(main_window)
+    @window = Gtk::Window.new(:toplevel)
+    @window.screen = main_window.screen
+    @window.title = "Images"
+    @window.signal_connect "destroy" do
+      GLib::Source.remove(@load_timeout) if @load_timeout
+      @pixbuf_loader.close
     end
 
-    def start_progressive_loading(image)
-      @load_timeout = Gtk.timeout_add(150) do
-        progressive_timeout(image)
+    @vbox = Gtk::Box.new(:vertical, 8)
+    @vbox.margin = 16
+    @window.add(@vbox)
+
+    frame = generate_frame("<u>Image loaded from a file </u>")
+    image = Gtk::Image.new(:icon_name => "gtk3-demo", :size => :dialog)
+    frame.add(image)
+
+    # Animation
+    frame = generate_frame("<u>Animation loaded from a file</u>")
+    image = Gtk::Image.new(:resource => "/images/floppybuddy.gif")
+    frame.add(image)
+
+    # Symbolic icon
+    frame = generate_frame("<u>Symbolic themed icon</u>")
+    gicon = Gio::ThemedIcon.new("battery-caution-charging-symbolic")
+    image = Gtk::Image.new(:icon => gicon, :size => :dialog)
+    frame.add(image)
+
+    # Progressive
+    frame = generate_frame("<u>Progressive image loading</u>")
+
+    # Create an empty image for now; the progressive loader
+    # will create the pixbuf and fill it in.
+    image = Gtk::Image.new
+    frame.add(image)
+    start_progressive_loading(image)
+
+    # Sensitivity control
+    button = Gtk::ToggleButton.new(:label => "_Insensitive",
+                                   :use_underline => true)
+    @vbox.pack_start(button)
+    button.signal_connect "toggled" do |toggle|
+      @vbox.children.each do |child|
+        child.sensitive = !toggle.active? if child.class != Gtk::ToggleButton
       end
     end
+  end
 
-    def progressive_timeout(image)
-      if @image_stream
-        buf = @image_stream.read(256)
+  def run
+    if !@window.visible?
+      @window.show_all
+    else
+      @window.destroy
+    end
+    @window
+  end
 
-        @pixbuf_loader.write(buf)
+  private
+
+  def start_progressive_loading(image)
+    # This is obviously totally contrived (we slow down loading
+    # on purpose to show how incremental loading works).
+    # The real purpose of incremental loading is the case where
+    # you are reading data from a slow source such as the network.
+    # The timeout simply simulates a slow data source by inserting
+    # pauses in the reading process.
+    image_stream = nil
+    pixbuf_loader = nil
+    @load_timeout = GLib::Timeout.add(150) do
+      if image_stream
+        begin
+          buf = image_stream.read(256)
+        rescue => error
+          buf = ""
+          show_dialog_on_error("Failure reading image file 'alphatest.png': \
+                               #{error.message}")
+        end
 
-        if @image_stream.eof?
-          @image_stream.close
-          @image_stream = nil
+        if buf.empty?
+          # Errors can happen on close, e.g. if the image
+          # file was truncated we'll know on close that
+          # it was incomplete.
+          begin
+            image_stream.close
+          rescue => error
+            show_dialog_on_error("Failed to load image: #{error.message}")
+          end
 
-          @pixbuf_loader.close
-          @pixbuf_loader = nil
+          begin
+            pixbuf_loader.close
+          rescue => error
+            show_dialog_on_error("Failed to load image: #{error.message}")
+          end
+          GLib::Source::REMOVE
+        else
+          begin
+            pixbuf_loader.write(buf)
+          rescue => error
+            show_dialog_on_error("Failed to load image: #{error.message}")
+          end
+          GLib::Source::CONTINUE
         end
       else
-        filename = Demo.find_file('alphatest.png')
-        @image_stream = File.open(filename, 'rb')
-
-        if @pixbuf_loader != nil
-          @pixbuf_loader.close
-          @pixbuf_loader = nil
+        begin
+          image_stream = Gio::Resources.open_stream("/images/alphatest.png")
+        rescue => error
+          show_dialog_on_error(error.message)
         end
-
-        @pixbuf_loader = Gdk::PixbufLoader.new
-
-        @pixbuf_loader.signal_connect('area_prepared') do |loader|
+        pixbuf_loader.close if pixbuf_loader
+        pixbuf_loader = GdkPixbuf::PixbufLoader.new
+        pixbuf_loader.signal_connect "area-prepared" do |loader|
           pixbuf = loader.pixbuf
-
-          # Avoid displaying random memory contents, since the pixbuf
-          # isn't filled in yet.
-          pixbuf.fill!(0xaaaaaaff)
-
-          image.pixbuf = pixbuf
+          pixbuf.fill(0xaaaaaaff)
+          image.from_pixbuf = pixbuf
         end
 
-        @pixbuf_loader.signal_connect('area_updated') do
-          # We know the pixbuf inside the Gtk::Image has changed, but the image
-          # itself doesn't know this; so queue a redraw.  If we wanted to be
-          # really efficient, we could use a drawing area or something
-          # instead of a Gtk::Image, so we could control the exact position of
-          # the pixbuf on the display, then we could queue a draw for only
-          # the updated area of the image.
-          image.queue_draw
+        pixbuf_loader.signal_connect "area-updated" do
+          # progressive_updated_callback
+          # We know the pixbuf inside the GtkImage has changed, but the image
+          # itself doesn't know this; so give it a hint by setting the pixbuf
+          # again. Queuing a redraw used to be sufficient, but nowadays
+          # GtkImage uses GtkIconHelper which caches the pixbuf state and will
+          # just redraw from the cache.
+          pixbuf = image.pixbuf
+          image.from_pixbuf = pixbuf
         end
+        GLib::Source::CONTINUE
       end
-
-      # leave timeout installed
-      return true
     end
+    source = GLib::MainContext.default.find_source(@load_timeout)
+    source.name = "[gtk+] progressive_timeout"
+  end
 
-    def cleanup_callback
-      @pixbuf_loader.close if @pixbuf_loader
-      @pixbuf_loader = nil
-      if @load_timeout != 0
-        Gtk.timeout_remove(@load_timeout)
-      end
-    end
+  def show_dialog_on_error(message)
+    dialog = Gtk::MessageDialog.new(:parent => @window,
+                                    :flags => :destroy_with_parent,
+                                    :type => :error, :buttons => :close,
+                                    :message => message)
+    dialog.modal = true
+    dialog.present
+    dialog.signal_connect("response") { |w| w.destroy }
+    GLib::Source.remove(@load_timeout)
+    @load_timeout = nil
+    false
+  end
+
+  def generate_frame(title)
+    label = Gtk::Label.new
+    label.markup = title
+    @vbox.pack_start(label)
+
+    frame = Gtk::Frame.new
+    frame.shadow_type = :in
+    frame.halign = :center
+    frame.valign = :center
+    @vbox.pack_start(frame)
+    frame
   end
 end