gtk3 3.0.9-x64-mingw32 → 3.1.0-x64-mingw32

data/sample/gtk-demo/glarea.rb

@@ -0,0 +1,277 @@
+# Copyright (c) 2016 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+=begin
+=  OpenGL Area
+
+ GtkGLArea is a widget that allows custom drawing using OpenGL calls.
+=end
+require "opengl"
+OpenGL.load_lib
+include OpenGL
+
+class GlareaDemo
+  X_AXIS, Y_AXIS, Z_AXIS = (0..2).to_a
+  # The object we are drawing
+  VERTEX_DATA = [0.0, 0.5, 0.0, 1.0,
+                 0.5, -0.366, 0.0, 1.0,
+                 -0.5, -0.366, 0.0, 1.0].freeze
+
+  def initialize(main_window)
+    # Rotation angles on each axis
+    @rotation_angles = [0.0, 0.0, 0.0]
+    @window = Gtk::Window.new(:toplevel)
+    @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.spacing = 6
+    @window.add(box)
+
+    @gl_area = Gtk::GLArea.new
+    @gl_area.hexpand = true
+    @gl_area.vexpand = true
+    box.add(@gl_area)
+
+    # We need to initialize and free GL resources, so we use
+    # the realize and unrealize signals on the widget
+    @gl_area.signal_connect "realize" do |widget|
+      # We need to set up our state when we realize the GtkGLArea widget
+      widget.make_current
+      unless widget.error
+        init_buffers
+        @program, @mvp_location = init_shaders
+      end
+    end
+
+    @gl_area.signal_connect "unrealize" do |widget|
+      widget.make_current
+      unless widget.error
+        # We should tear down the state when unrealizing
+        glDeleteProgram(@program)
+      end
+    end
+
+    # The main "draw" call for GtkGLArea
+    @gl_area.signal_connect "render" do |area, _context|
+      return false if area.error
+
+      # Clear the viewport
+      glClearColor(0.5, 0.5, 0.5, 1.0)
+      glClear(GL_COLOR_BUFFER_BIT)
+      draw_triangle
+      glFlush
+      true
+    end
+
+    controls = Gtk::Box.new(:vertical, false)
+    box.add(controls)
+    controls.hexpand = true
+    (0..2).each do |i|
+      controls.add(create_axis_slider(i))
+    end
+
+    button = Gtk::Button.new(:label => "Quit")
+    button.hexpand = true
+    box.add(button)
+    button.signal_connect "clicked" do
+      @window.destroy
+    end
+  end
+
+  def run
+    if !@window.visible?
+      @window.show_all
+    else
+      @window.destroy
+    end
+    @window
+  end
+
+  private
+
+  def init_buffers
+    vao = "    "
+    glGenVertexArrays(1, vao)
+    gl_vao = vao.unpack("L")[0]
+    @position_buffer = gl_vao
+    glBindVertexArray(gl_vao)
+
+    # This is the buffer that holds the vertices
+    buffer = "    "
+    glGenBuffers(1, buffer)
+    gl_vbo = buffer.unpack("L")[0]
+    glBindBuffer(GL_ARRAY_BUFFER, gl_vbo)
+    glBufferData(GL_ARRAY_BUFFER, 3 * 4 * Fiddle::SIZEOF_FLOAT,
+                 VERTEX_DATA.pack("F*"), GL_STATIC_DRAW)
+    glBindBuffer(GL_ARRAY_BUFFER, 0)
+  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)
+    vertex = create_shader(GL_VERTEX_SHADER, src_vertex)
+    return [0, nil] if vertex.zero?
+    fragment = create_shader(GL_FRAGMENT_SHADER, src_fragment)
+    return [0, nil] if fragment.zero?
+
+    program = glCreateProgram
+    glAttachShader(program, vertex)
+    glAttachShader(program, fragment)
+    glLinkProgram(program)
+    # Check if the program is valid
+    linked_buf = "    "
+    glGetProgramiv(program, GL_LINK_STATUS, linked_buf)
+    status = linked_buf.unpack("L")[0]
+    if status.zero?
+      log_len = "    "
+      glGetShaderiv(program, GL_INFO_LOG_LENGTH, log_len)
+      len = log_len.unpack("L")[0]
+      info_log = " " * (len + 1)
+      glGetProgramInfoLog(program, len, nil, info_log)
+      STDERR.puts "Linking failure:\n#{info_log}\n"
+      glDeleteProgram(program)
+      glDeleteShader(vertex)
+      glDeleteShader(fragment)
+      program = 0
+    end
+    mvp = glGetUniformLocation(program, "mvp")
+    [program, mvp]
+  end
+
+  def create_shader(type, source)
+    # Load the shaders sources
+    shader = glCreateShader(type)
+
+    glShaderSource(shader, 1, [source].pack("p"), [source.bytesize].pack("I"))
+    # Compile the vertex shader
+    glCompileShader(shader)
+    # Check the vertex shader compilation
+    compiled_buf = "    "
+    glGetShaderiv(shader, GL_COMPILE_STATUS, compiled_buf)
+    status = compiled_buf.unpack("L")[0]
+    if status.zero?
+      log_len = "    "
+      glGetShaderiv(shader, GL_INFO_LOG_LENGTH, log_len)
+      len = log_len.unpack("L")[0]
+      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"
+      return 0
+    end
+    shader
+  end
+
+  def draw_triangle
+    # Compute the model view projection matrix using the rotation angles
+    # specified through the GtkRange widgets
+    mvp = compute_mvp
+    # Use our program
+    glUseProgram(@program)
+    # Update the "mvp" matrix we use in the shader
+    glUniformMatrix4fv(@mvp_location, 1, GL_FALSE, mvp.pack("F16"))
+    # Use the vertices in our buffer
+    glBindBuffer(GL_ARRAY_BUFFER, @position_buffer)
+    glEnableVertexAttribArray(0)
+    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0)
+
+    # Draw the three vertices as a triangle
+    glDrawArrays(GL_TRIANGLES, 0, 3)
+
+    # We finished using the buffers and program
+    glDisableVertexAttribArray(0)
+    glBindBuffer(GL_ARRAY_BUFFER, 0)
+    glUseProgram(0)
+  end
+
+  def compute_mvp
+    phi = @rotation_angles[X_AXIS]
+    theta = @rotation_angles[Y_AXIS]
+    psi = @rotation_angles[Z_AXIS]
+    res = Array.new(16, 0.0)
+    x = phi * (Math::PI / 180.0)
+    y = theta * (Math::PI / 180.0)
+    z = psi * (Math::PI / 180.0)
+    c1 = Math.cos(x)
+    c2 = Math.cos(y)
+    c3 = Math.cos(z)
+    s1 = Math.sin(x)
+    s2 = Math.sin(y)
+    s3 = Math.sin(z)
+    c3c2 = c3 * c2
+    s3c1 = s3 * c1
+    c3s2s1 = c3 * s2 * s1
+    s3s1 = s3 * s1
+    c3s2c1 = c3 * s2 * c1
+    s3c2 = s3 * c2
+    c3c1 = c3 * c1
+    s3s2s1 = s3 * s2 * s1
+    c3s1 = c3 * s1
+    s3s2c1 = s3 * s2 * c1
+    c2s1 = c2 * s1
+    c2c1 = c2 * c1
+
+    # initialize to the identity matrix
+    res[0] = 1.0
+    res[5] = 1.0
+    res[10] = 1.0
+    res[15] = 1.0
+
+    # apply all three rotations using the three matrices:
+    #
+    # ⎡  c3 s3 0 ⎤ ⎡ c2  0 -s2 ⎤ ⎡ 1   0  0 ⎤
+    # ⎢ -s3 c3 0 ⎥ ⎢  0  1   0 ⎥ ⎢ 0  c1 s1 ⎥
+    # ⎣   0  0 1 ⎦ ⎣ s2  0  c2 ⎦ ⎣ 0 -s1 c1 ⎦
+
+    res[0] = c3c2
+    res[1] = -s3c2
+    res[2] = s2
+    res[3] = 0.0
+    res[4] = s3c1 + c3s2s1
+    res[5] = c3c1 - s3s2s1
+    res[6] = -c2s1
+    res[7] = 0.0
+    res[8] = s3s1 - c3s2c1
+    res[9] = c3s1 + s3s2c1
+    res[10] = c2c1
+    res[11] = 0.0
+    res[12] = 0.0
+    res[13] = 0.0
+    res[14] = 0.0
+    res[15] = 1.0
+    res
+  end
+
+  def create_axis_slider(axis)
+    box = Gtk::Box.new(:horizontal, 0)
+    text = case axis
+           when X_AXIS
+             "X axis"
+           when Y_AXIS
+             "Y axis"
+           when Z_AXIS
+             "Z axis"
+           end
+    label = Gtk::Label.new(text)
+    box.add(label)
+    label.show
+
+    adj = Gtk::Adjustment.new(0.0, 0.0, 360.0, 1.0, 12.0, 0.0)
+    adj.signal_connect "value-changed" do |widget|
+      # Updte the rotation angle
+      @rotation_angles[axis] = widget.value
+      # Update the contents of the GL drawing area
+      @gl_area.queue_draw
+    end
+    slider = Gtk::Scale.new(:horizontal, adj)
+    box.add(slider)
+    slider.hexpand = true
+    slider.show
+    box.show
+    box
+  end
+end

data/sample/gtk-demo/headerbar.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2015 Ruby-GNOME2 Project Team
+# Copyright (c) 2015-2016 Ruby-GNOME2 Project Team
 # This program is licenced under the same licence as Ruby-GNOME2.
 #
 =begin
@@ -12,18 +12,18 @@ or right.
 
 It is commonly used with gtk_window_set_titlebar()
 =end
-module HeaderbarDemo
-  def self.run_demo(main_window)
-    window = Gtk::Window.new(:toplevel)
-    window.screen = main_window.screen
-    window.set_default_size(600, 400)
+class HeaderbarDemo
+  def initialize(main_window)
+    @window = Gtk::Window.new(:toplevel)
+    @window.screen = main_window.screen
+    @window.set_default_size(600, 400)
 
     header = Gtk::HeaderBar.new
-    header.set_show_close_button(true)
-    header.set_title("Welcome to Facebook - Log in, sign up or learn more")
-    header.set_has_subtitle(false)
+    header.show_close_button = true
+    header.title = "Welcome to Facebook - Log in, sign up or learn more"
+    header.has_subtitle = false
 
-    button = Gtk::Button.new()
+    button = Gtk::Button.new
 
     icon = Gio::ThemedIcon.new("mail-send-receive-symbolic")
     image = Gtk::Image.new(:icon => icon, :size => :button)
@@ -45,13 +45,15 @@ module HeaderbarDemo
     box.add(button)
 
     header.pack_start(box)
-    window.set_titlebar(header)
-    window.add(Gtk::TextView.new())
+    @window.titlebar = header
+    @window.add(Gtk::TextView.new)
+  end
 
-    if !window.visible?
-      window.show_all
+  def run
+    if !@window.visible?
+      @window.show_all
     else
-      window.destroy
+      @window.destroy
     end
   end
 end

data/sample/gtk-demo/hypertext.rb

@@ -1,205 +1,184 @@
-# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# Copyright (c) 2016 Ruby-GNOME2 Project Team
 # This program is licenced under the same licence as Ruby-GNOME2.
 #
-# $Id: hypertext.rb,v 1.2 2005/12/01 09:27:01 ktou Exp $
 =begin
-= Text Widget/Hypertext
+=  Text View/Hypertext
 
-Usually, tags modify the appearance of text in the view, e.g. making it
-bold or colored or underlined. But tags are not restricted to appearance.
-They can also affect the behavior of mouse and key presses, as this demo
-shows.
+ Usually, tags modify the appearance of text in the view, e.g. making it
+ bold or colored or underlined. But tags are not restricted to appearance.
+ They can also affect the behavior of mouse and key presses, as this demo
+ shows.
 =end
+class HypertextDemo
+  def initialize(main_window)
+    initialize_window(main_window)
+    initialize_cursors(main_window)
+    initialize_view
 
-require 'common'
-
-module Demo
-  class Hypertext < BasicWindow
-    def initialize
-      super('Hypertext')
-
-      @hand_cursor = Gdk::Cursor.new(Gdk::Cursor::HAND2)
-      @regular_cursor = Gdk::Cursor.new(Gdk::Cursor::XTERM)
-      @hovering = false
-
-      set_default_size(450, 450)
-      self.border_width = 0
-
-      view = Gtk::TextView.new
-
-      view.wrap_mode = :word
-
-      view.signal_connect('key-press-event') do |*args|
-        key_press_event(*args)
-      end
-      view.signal_connect('event-after') do |*args|
-        event_after(*args)
-      end
-      view.signal_connect('motion-notify-event') do |*args|
-        motion_notify_event(*args)
-      end
-      view.signal_connect('visibility-notify-event') do |*args|
-        visibility_notify_event(*args)
+    @view.signal_connect "key-press-event" do |_widget, event|
+      case event.keyval
+      when Gdk::Keyval::KEY_Return, Gdk::Keyval::KEY_KP_Enter
+        iter = @buffer.get_iter_at_mark(@buffer.get_mark("insert"))
+        follow_if_link(iter) if iter
       end
 
-      buffer = view.buffer
-
-      sw = Gtk::ScrolledWindow.new
-      sw.set_policy(:automatic,
-                    :automatic)
-
-      add(sw)
-      sw.add(view)
-
-      show_page(buffer, 1)
+      false
     end
 
+    # Links can also be activated by clicking or tapping.
+    @view.signal_connect "event-after" do |widget, event|
+      if event.is_a?(Gdk::EventButton) && event.button == 1
+        buffer = widget.buffer
 
-    # Inserts a piece of text into the buffer, giving it the usual
-    # appearance of a hyperlink in a web browser: blue and underlined.
-    # Additionally, attaches some data on the tag, to make it recognizable
-    # as a link.
-    def insert_link(buffer, iter, text, page)
-      tag = buffer.create_tag(nil,
-                              {
-                                'foreground' => 'blue',
-                                'underline' => Pango::AttrUnderline::SINGLE,
-                              })
-      tag.page = page
-
-      buffer.insert(iter, text, tag)
-      print("Insert #{tag}:#{page}\n")
-    end
+        # we shouldn't follow a link if the user has selected something
+        range = buffer.selection_bounds
+        return false if range && range[0].offset != range[1].offset
 
-    # Fills the buffer with text and interspersed links. In any real
-    # hypertext app, this method would parse a file to identify the links.
-    def show_page(buffer, page)
-      puts
-
-      buffer.text = ''
-      iter = buffer.get_iter_at(:offset => 0)
-
-      case page
-      when 1
-        buffer.insert(iter, 'Some text ot show that simple ')
-        insert_link(buffer, iter, 'hypertext', 3)
-        buffer.insert(iter, ' can easily be realized with ')
-        insert_link(buffer, iter, 'tags', 2)
-        buffer.insert(iter, '.')
-      when 2
-        buffer.insert(iter,
-                      %Q[A tag is an attribute that can be applied to some range of text. For example, a tag might be called "bold" and make the text insid the tag bold. However, the tag concept is more general than that; tags don't have to affect appearance. They can instead affect the behavior of mouse and key presses, "lock" a range of text so the user can't edit it, or countless other things.])
-        buffer.insert(iter, "\n")
-        insert_link(buffer, iter, 'Go back', 1)
-      when 3
-        tag = buffer.create_tag(nil,
-                                {
-                                  'weight' =>
-                                    Pango::FontDescription::WEIGHT_BOLD
-                                })
-        buffer.insert(iter, "hypertext:\n", tag);
-        buffer.insert(iter, %Q[machine-readable text that is not sequential but is organized so that related items of information are connected.\n])
-        insert_link(buffer, iter, 'Go back', 1)
+        x, y = widget.window_to_buffer_coords(:widget, event.x, event.y)
+        iter = widget.get_iter_at_location(x, y)
+        follow_if_link(iter) if iter
+      else
+        false
       end
     end
 
-    # Looks at all tags covering the position of iter in the text view,
-    # and if one of them is a link, follow it by showing the page identified
-    # by the data attached to it.
-    def follow_if_link(text_view, iter)
-      tags = iter.tags
-      tags.each do |tag|
-        print("Follow #{tag}:#{tag.page}\n")
-        if tag.page
-          show_page(text_view.buffer, tag.page)
-          break
-        end
-      end
-    end
-
-    # Links can be activated by pressing Enter.
-    def key_press_event(text_view, event)
-      case event.keyval
-      when Gdk::Keyval::KEY_Return, Gdk::Keyval::KEY_KP_Enter
-        buffer = text_view.buffer
-        iter = buffer.get_iter_at_mark(buffer.get_mark("insert"))
-        follow_if_link(text_view, iter)
-      end
+    @view.signal_connect "motion-notify-event" do |widget, event|
+      x, y = widget.window_to_buffer_coords(:widget, event.x, event.y)
+      set_cursor_if_appropriate(widget, x, y)
+      widget.window.pointer
 
       false
     end
 
-    # Links can also be activated by clicking.
-    def event_after(text_view, event)
-      unless event.kind_of?(Gdk::EventButton) and event.button == 1
-        return false
-      end
+    sw = Gtk::ScrolledWindow.new
+    sw.set_policy(:automatic, :automatic)
+    @window.add(sw)
+    sw.add(@view)
+    show_page(1)
+    sw.show_all
+  end
 
-      buffer = text_view.buffer
+  def run
+    if !@window.visible?
+      @window.show_all
+    else
+      @window.destroy
+    end
+    @window
+  end
 
-      # we shouldn't follow a link if the user has selected something
-      range = buffer.selection_bounds
-      if range and range[0].offset != range[1].offset
-        return false
-      end
+  private
 
-      x, y = text_view.window_to_buffer_coords(Gtk::TextView::WINDOW_WIDGET,
-                                               event.x, event.y)
-      iter = text_view.get_iter_at_location(x, y)
+  def initialize_window(main_window)
+    @window = Gtk::Window.new(:toplevel)
+    @window.screen = main_window.screen
+    @window.title = "Hypertext"
+    @window.set_default_size(450, 450)
+    @window.border_width = 0
+  end
 
-      follow_if_link(text_view, iter)
-    end
+  def initialize_cursors(main_window)
+    display = main_window.display
+    @hand_cursor = Gdk::Cursor.new("pointer", :display => display)
+    @regular_cursor = Gdk::Cursor.new("text", :display => display)
+  end
 
-    # Looks at all tags covering the position (x, y) in the text view,
-    # and if one of them is a link, change the cursor to the "hands" cursor
-    # typically used by web browsers.
-    def set_cursor_if_appropriate(text_view, x, y)
+  def initialize_view
+    @view = Gtk::TextView.new
+    @view.wrap_mode = :word
+    @view.left_margin = 20
+    @view.right_margin = 20
+    @buffer = @view.buffer
+  end
 
-      buffer = text_view.buffer
-      iter = text_view.get_iter_at_location(x, y)
+  # Fills the buffer with text and interspersed links. In any real
+  # hypertext app, this method would parse a file to identify the links.
+  def show_page(page)
+    @buffer.text = ""
+    case page
+    when 1
+      generate_page_1
+    when 2
+      generate_page_2
+    when 3
+      generate_page_3
+    end
+  end
 
-      hovering = false
+  def generate_page_1
+    iter = @buffer.get_iter_at(:offset => 0)
+    @buffer.insert(iter, "Some text to show that simple")
+    insert_link(iter, "hyper text", 3)
+    @buffer.insert(iter, " can easily be realized with ")
+    insert_link(iter, "tags", 2)
+    @buffer.insert(iter, ".")
+  end
 
-      tags = iter.tags
-      tags.each do |t|
-        if t.page
-          hovering = true
-          break
-        end
-      end
+  def generate_page_2
+    iter = @buffer.get_iter_at(:offset => 0)
+    @buffer.insert(iter, <<-EOF)
+A tag is an attribute that can be applied to some range of text.
+For example, a tag might be called "bold" and make the text inside
+the tag bold. However, the tag concept is more general than that;
+tags don't have to affect appearance. They can instead affect the
+behavior of mouse and key presses, "lock" a range of text so the
+user can't edit it, or countless other things.\n
+EOF
+    insert_link(iter, "Goback", 1)
+  end
 
-      if hovering != @hovering
-        @hovering = hovering
+  def generate_page_3
+    iter = @buffer.get_iter_at(:offset => 0)
+    tag = @buffer.create_tag(nil,
+                             "weight" => Pango::FontDescription::WEIGHT_BOLD)
+    @buffer.insert(iter, "hypertext:\n", :tags => [tag])
+    @buffer.insert(iter, <<-EOF)
+machine-readable text that is not sequential but is organized
+so that related items of information are connected
+EOF
+    insert_link(iter, "Go back", 1)
+  end
 
-        window = text_view.get_window(Gtk::TextView::WINDOW_TEXT)
+  def insert_link(iter, text, page)
+    tag = @buffer.create_tag(nil,
+                             "foreground" => "blue",
+                             "underline" => Pango::AttrUnderline::SINGLE)
+    tag.page = page
+    @buffer.insert(iter, text, :tags => [tag])
+  end
 
-        window.cursor = if @hovering
-                          @hand_cursor
-                        else
-                          @regular_cursor
-                        end
+  # Looks at all tags covering the position of iter in the text view,
+  # and if one of them is a link, follow it by showing the page identified
+  # by the data attached to it.
+  def follow_if_link(iter)
+    tags = iter.tags
+    tags.each do |tag|
+      if tag.page
+        show_page(tag.page)
+        break
       end
     end
+  end
 
-    # Update the cursor image if the pointer moved.
-    def motion_notify_event(text_view, event)
-      x, y = text_view.window_to_buffer_coords(Gtk::TextView::WINDOW_WIDGET,
-                                               event.x, event.y)
-      set_cursor_if_appropriate(text_view, x, y)
-      text_view.window.pointer
-
-      false
+  # Looks at all tags covering the position (x, y) in the text view,
+  # and if one of them is a link, change the cursor to the "hands" cursor
+  # typically used by web browsers.
+  def set_cursor_if_appropriate(text_view, x, y)
+    iter = text_view.get_iter_at_location(x, y)
+    return unless iter
+    hovering = false
+    tags = iter.tags
+    tags.each do |tag|
+      if tag.page
+        hovering = true
+        break
+      end
     end
 
-    # Also update the cursor image if the window becomes visible
-    # (e.g. when a window covering it got iconified).
-    def visibility_notify_event (text_view, event)
-      window, wx, wy = text_view.window.pointer
-      bx, by = text_view.window_to_buffer_coords(Gtk::TextView::WINDOW_WIDGET,
-                                                 wx, wy)
-      set_cursor_if_appropriate(text_view, bx, by)
-
-      false
+    if hovering != @hovering
+      @hovering = hovering
+      window = text_view.get_window(:text)
+      window.cursor = @hovering ? @hand_cursor : @regular_cursor
     end
   end
 end