gtk4 4.2.1 → 4.2.3

data/sample/demos/gtk-demo/glarea.rb

@@ -0,0 +1,323 @@
+# Copyright (C) 2024  Ruby-GNOME 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
+
+# Original:
+#   https://gitlab.gnome.org/GNOME/gtk/-/blob/main/demos/gtk-demo/glarea.c
+#
+# See the following for license information:
+#   * https://gitlab.gnome.org/GNOME/gtk/-/blob/main/AUTHORS
+#   * https://gitlab.gnome.org/GNOME/gtk/-/blob/main/COPYING
+
+require "opengl"
+
+class GtkGLAreaDemo < GtkDemo
+  X_AXIS = 0
+  Y_AXIS = 1
+  Z_AXIS = 2
+  N_AXISES = 3
+
+  def initialize
+    super(__FILE__,
+          "OpenGL/OpenGL Area",
+          "Gtk::GLArea is a widget that allows custom drawing using OpenGL calls.",
+          [])
+  end
+
+  def run(parent)
+    window = Gtk::Window.new
+    window.display = parent.display
+    window.title = "OpenGL Area"
+    window.set_default_size(400, 600)
+
+    box = Gtk::Box.new(:vertical)
+    box.margin_start = 12
+    box.margin_end = 12
+    box.margin_top = 12
+    box.margin_bottom = 12
+    box.spacing = 6
+    window.child = box
+
+    gl_area = Gtk::GLArea.new
+    gl_area.hexpand = true
+    gl_area.vexpand = true
+    gl_area.set_size_request(100, 200)
+    box.append(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
+      realize(gl_area)
+    end
+    gl_area.signal_connect("unrealize") do
+      unrealize(gl_area)
+    end
+
+    # The main "draw" call for GtkGLArea
+    gl_area.signal_connect("render") do
+      render(gl_area)
+    end
+
+    controls = Gtk::Box.new(:vertical)
+    controls.hexpand = true
+    box.append(controls)
+
+    N_AXISES.times do |i|
+      controls.append(create_axis_slider(gl_area, i))
+    end
+
+    button = Gtk::Button.new(label: "Quit")
+    button.hexpand = true
+    box.append(button)
+
+    button.signal_connect("clicked") do
+      window.destroy
+    end
+
+    window.present
+
+    window
+  end
+
+  private
+  # We need to set up our state when we realize the GtkGLArea widget
+  def realize(gl_area)
+    @rotation_angles = [0.0] * N_AXISES
+
+    GL.load_lib
+
+    gl_area.make_current
+    api_name = gl_area.api.nick
+    vertex_path = "/glarea/glarea-#{api_name}.vs.glsl"
+    fragment_path = "/glarea/glarea-#{api_name}.fs.glsl"
+    init_buffers
+    init_shaders(vertex_path, fragment_path)
+  end
+
+  # 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,
+  ]
+
+  def init_buffers
+    # We only use one VAO, so we always keep it bound
+    vao_buffer = " " * Fiddle::SIZEOF_UINT32_T
+    GL.GenVertexArrays(1, vao_buffer)
+    @vao = vao_buffer.unpack1("L")
+    GL.BindVertexArray(@vao)
+
+    # This is the buffer that holds the vertices
+    position_buffer = " " * Fiddle::SIZEOF_UINT32_T
+    GL.GenBuffers(1, position_buffer)
+    GL.GenBuffers(1, position_buffer)
+    @position = position_buffer.unpack1("L")
+    GL.BindBuffer(GL::ARRAY_BUFFER, @position)
+    GL.BufferData(GL::ARRAY_BUFFER,
+                  Fiddle::SIZEOF_FLOAT * VERTEX_DATA.size,
+                  VERTEX_DATA.pack("f*"),
+                  GL::STATIC_DRAW)
+    GL.BindBuffer(GL::ARRAY_BUFFER, 0)
+  end
+
+  # Initialize the shaders and link them into a program
+  def init_shaders(vertex_path, fragment_path)
+    @program = nil
+    vertex = 0
+    fragment = 0
+
+    begin
+      source = Gio::Resources.lookup_data(vertex_path)
+      vertex = create_shader(GL::VERTEX_SHADER, source.to_s)
+      return if vertex.zero?
+
+      source = Gio::Resources.lookup_data(fragment_path)
+      fragment = create_shader(GL::FRAGMENT_SHADER, source.to_s)
+      return if fragment.zero?
+
+      @program = GL.CreateProgram
+      return if @program.zero?
+
+      GL.AttachShader(@program, vertex)
+      GL.AttachShader(@program, fragment)
+
+      GL.LinkProgram(@program)
+
+      program_ok_buffer = " " * Fiddle::SIZEOF_UINT32_T
+      GL.GetProgramiv(@program, GL::LINK_STATUS, program_ok_buffer)
+      program_ok = (program_ok_buffer.unpack1("L") == GL::TRUE)
+      unless program_ok
+        log_length_buffer = " " * Fiddle::SIZEOF_UINT32_T
+        GL.GetProgramiv(@program, GL::INFO_LOG_LENGTH, log_length_buffer)
+        log_length = log_length_buffer.unpack1("L")
+        log = " " * log_length
+        GL.GetProgramInfoLog(@program, log_length, nil, log)
+        $stderr.puts("Linking failure:")
+        $stderr.puts(log)
+        GL.DeleteProgram(@program)
+        @program = nil
+        return
+      end
+
+      # Get the location of the "mvp" uniform
+      @mvp_location = GL.GetUniformLocation(@program, "mvp")
+
+      GL.DetachShader(@program, vertex)
+      GL.DetachShader(@program, fragment)
+    ensure
+      GL.DeleteShader(vertex) if vertex.zero?
+      GL.DeleteShader(fragment) if fragment.zero?
+    end
+  end
+
+  # Create and compile a shader
+  def create_shader(type, source)
+    shader = GL.CreateShader(type)
+    GL.ShaderSource(shader, 1, [source].pack("p"), nil)
+    GL.CompileShader(shader)
+
+    shader_ok_buffer = " " * Fiddle::SIZEOF_UINT32_T
+    GL.GetShaderiv(shader, GL::COMPILE_STATUS, shader_ok_buffer)
+    shader_ok = (shader_ok_buffer.unpack1("L") == GL::TRUE)
+    unless shader_ok
+      log_length_buffer = " " * Fiddle::SIZEOF_UINT32_t
+      GL.GetShaderiv(shader, GL::INFO_LOG_LENGTH, log_length_buffer)
+      log_length = log_length_buffer.unpack1("L")
+      log = " " * log_length
+      GL.GetShaderInfoLog(shader, log_length, nil, buffer)
+      type_name = (type == GL::VERTEX_SHADER ? "vertex" : "fragment")
+      $stderr.puts("Compile failure in #{type_name} shader:")
+      $stderr.puts(log)
+      GL.DeleteShader(shader)
+      return 0
+    end
+
+    shader
+  end
+
+  # We should tear down the state when unrealizing
+  def unrealize(gl_area)
+    gl_area.make_current
+    GL.DeleteBuffers(1, [[@position].pack("L")].pack("p"))
+    GL.DeleteProgram(@program)
+  end
+
+  def compute_mvp(phi, theta, psi)
+    x = phi * (Math::PI / 180.0)
+    y = theta * (Math::PI / 180.0)
+    z = psi * (Math::PI / 180.0)
+    c1 = Math.cos(x)
+    s1 = Math.sin(x)
+    c2 = Math.cos(y)
+    s2 = Math.sin(y)
+    c3 = Math.cos(z)
+    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
+
+    # 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 ⎦
+    mvp = [0.0] * 16
+    mvp[0] = c3c2;  mvp[4] = s3c1 + c3s2s1; mvp[8] = s3s1 - c3s2c1; mvp[12] = 0.0;
+    mvp[1] = -s3c2; mvp[5] = c3c1 - s3s2s1; mvp[9] = c3s1 + s3s2c1; mvp[13] = 0.0;
+    mvp[2] = s2;    mvp[6] = -c2s1;         mvp[10] = c2c1;         mvp[14] = 0.0;
+    mvp[3] = 0.0;   mvp[7] = 0.0;           mvp[11] = 0.0;          mvp[15] = 1.0;
+    mvp
+ end
+
+  def draw_triangle
+    # Compute the model view projection matrix using the
+    # rotation angles specified through the GtkRange widgets
+    mvp = compute_mvp(@rotation_angles[X_AXIS],
+                      @rotation_angles[Y_AXIS],
+                      @rotation_angles[Z_AXIS])
+
+    # Use our shaders
+    GL.UseProgram(@program)
+
+    # Update the "mvp" matrix we use in the shader
+    GL.UniformMatrix4fv(@mvp_location, 1, GL::FALSE, mvp.pack("f*"))
+
+    # Use the vertices in our buffer
+    GL.BindBuffer(GL::ARRAY_BUFFER, @position)
+    GL.EnableVertexAttribArray(0)
+    GL.VertexAttribPointer(0, 4, GL::FLOAT, GL::FALSE, 0, 0)
+
+    # Draw the three vertices as a triangle
+    GL.DrawArrays(GL::TRIANGLES, 0, 3)
+
+    # We finished using the buffers and program
+    GL.DisableVertexAttribArray(0)
+    GL.BindBuffer(GL::ARRAY_BUFFER, 0)
+    GL.UseProgram(0)
+  end
+
+  def render(gl_area)
+    # Clear the viewport
+    GL.ClearColor(0.5, 0.5, 0.5, 1.0)
+    GL.Clear(GL::COLOR_BUFFER_BIT)
+
+    # Draw our object
+    draw_triangle
+
+    # Flush the contents of the pipeline
+    GL.Flush
+
+    true
+  end
+
+  def create_axis_slider(gl_area, axis)
+    box = Gtk::Box.new(:horizontal)
+    case axis
+    when X_AXIS
+      text = "X axis"
+    when Y_AXIS
+      text = "Y axis"
+    when Z_AXIS
+      text = "Z axis"
+    end
+    label = Gtk::Label.new(text)
+    box.append(label)
+
+    adjustment = Gtk::Adjustment.new(0.0, 0.0, 360.0, 1.0, 12.0, 0.0)
+    adjustment.signal_connect("value-changed") do
+      @rotation_angles[axis] = adjustment.value
+      # Update the contents of the GL drawing area
+      gl_area.queue_draw
+    end
+
+    slider = Gtk::Scale.new(:horizontal, adjustment)
+    box.append(slider)
+    slider.hexpand = true
+
+    box
+  end
+
+  GtkDemo.register(new)
+end

data/sample/demos/gtk-demo/main-listitem.ui

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="GtkListItem">
+    <property name="focusable">0</property>
+    <property name="child">
+      <object class="GtkTreeExpander" id="expander">
+        <binding name="list-row">
+          <lookup name="item">GtkListItem</lookup>
+        </binding>
+        <property name="child">
+          <object class="GtkInscription">
+            <property name="hexpand">1</property>
+            <property name="nat-chars">25</property>
+            <property name="text-overflow">ellipsize-end</property>
+            <binding name="text">
+              <lookup name="title" type="GtkDemo">
+                <lookup name="item">expander</lookup>
+              </lookup>
+            </binding>
+          </object>
+        </property>
+      </object>
+    </property>
+  </template>
+</interface>

data/sample/demos/gtk-demo/main.rb

@@ -0,0 +1,264 @@
+#!/usr/bin/env ruby
+#
+# Copyright (C) 2024  Ruby-GNOME 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
+
+# Original:
+#   https://gitlab.gnome.org/GNOME/gtk/-/blob/main/demos/gtk-demo/main.c
+#
+# See the following for license information:
+#   * https://gitlab.gnome.org/GNOME/gtk/-/blob/main/AUTHORS
+#   * https://gitlab.gnome.org/GNOME/gtk/-/blob/main/COPYING
+
+require "gtk4"
+
+gresource = File.join(__dir__, "demo.gresource")
+gresource_xml = "#{gresource}.xml"
+need_generate = false
+if File.exist?(gresource)
+  need_generate = File.mtime(gresource_xml) > File.mtime(gresource)
+else
+  need_generate = true
+end
+if need_generate
+  unless system("glib-compile-resources",
+                "--target", gresource,
+                "--sourcedir", __dir__,
+                gresource_xml)
+    $stderr.puts("Failed to compile resource")
+    exit(false)
+  end
+end
+resource = Gio::Resource.load(gresource)
+Gio::Resources.register(resource)
+
+
+require_relative "demo"
+Dir.glob("#{__dir__}/*.rb") do |rb|
+  base_name = File.basename(rb, ".rb")
+  next if base_name == "main"
+  require_relative base_name
+end
+
+
+def run_demo(demo, window)
+  demo_window = demo.run(window)
+  demo_window.transient_for = window
+  demo_window.modal = true
+  demo_window
+end
+
+def create_demo_model(window)
+  store = Gio::ListStore.new(GtkDemo)
+  GtkDemo.all.each do |demo|
+    store.append(demo)
+  end
+  store
+end
+
+def load_file(demo, notebook, info_view)
+  notebook.n_pages.downto(1) do |i|
+    notebook.remove_page(i)
+  end
+
+  info_buffer = Gtk::TextBuffer.new
+  info_buffer.create_tag("title",
+                         size: 18 * Pango::SCALE,
+                         pixels_below_lines: 10)
+  info_buffer.begin_irreversible_action do
+    info_buffer_iter = info_buffer.get_iter_at(offset: 0)
+    info_buffer.insert(info_buffer_iter, demo.title, tags: ["title"])
+    info_buffer.insert(info_buffer_iter, "\n")
+    info_buffer.insert(info_buffer_iter, demo.description)
+  end
+  info_view.buffer = info_buffer
+end
+
+def select_item(selection, window, notebook, info_view)
+  row = selection.selected_item
+  notebook.sensitive = !!row
+  if row
+    demo = row.item
+    load_file(demo, notebook, info_view)
+    run_action = window.lookup_action("run")
+    run_action.enabled = true
+    window.title = demo.title
+  else
+    window.title = "No match"
+  end
+end
+
+
+app = Gtk::Application.new("com.github.ruby-gnome.gtk4.Demo",
+                           [:non_unique, :handles_command_line])
+
+about_action = Gio::SimpleAction.new("about")
+about_action.signal_connect("activate") do
+  dialog = Gtk::AboutDialog.new
+  dialog.modal = true
+  dialog.transient_for = app.active_window
+  dialog.destroy_with_parent = true
+  dialog.program_name = "Ruby/GTK4 Demo"
+  dialog.version = GLib::BINDING_VERSION.join(".")
+  dialog.copyright = "(C) 2024-#{Time.now.year} Ruby-GNOME Project Team"
+  dialog.license_type = Gtk::License::LGPL_2_1
+  dialog.website = "https://ruby-gnome.github.io/"
+  dialog.comments = "Program to demonstrate Ruby/GTK4 widgets"
+  dialog.authors = ["Ruby-GNOME Project Team"]
+  dialog.logo_icon_name = "org.gtk.Demo4"
+  dialog.title = "About Ruby/GTK4 Demo"
+  dialog.system_information = <<-INFO.chomp
+OS\t#{GLib.get_os_info(:name)} #{GLib.get_os_info(:version)}
+
+System Libraries
+\tGLib\t#{GLib::Version::STRING}
+\tPango\t#{Pango::Version::STRING}
+\tGTK\t#{Gtk::Version::STRING}
+
+A link can appear here: <https://ruby-gnome.github.io/>
+  INFO
+  dialog.present
+end
+app.add_action(about_action)
+
+quit_action = Gio::SimpleAction.new("quit")
+quit_action.signal_connect("activate") do
+  app.windows.each do |window|
+    window.destroy
+  end
+end
+app.add_action(quit_action)
+
+inspector_action = Gio::SimpleAction.new("inspector")
+inspector_action.signal_connect("activate") do
+  Gtk::Window.interactive_debugging = true
+end
+app.add_action(inspector_action)
+app.set_accels_for_action("app.about", ["F1"])
+app.set_accels_for_action("app.quit", ["<Control>q"])
+
+app.add_main_option("version",
+                    0,
+                    GLib::OptionFlags::NONE,
+                    GLib::OptionArg::NONE,
+                    "Show program version")
+app.add_main_option("run",
+                    0,
+                    GLib::OptionFlags::NONE,
+                    GLib::OptionArg::STRING,
+                    "Run an example",
+                    "EXAMPLE")
+app.add_main_option("list",
+                    0,
+                    GLib::OptionFlags::NONE,
+                    GLib::OptionArg::NONE,
+                    "List examples")
+app.add_main_option("auto-quit",
+                    0,
+                    GLib::OptionFlags::NONE,
+                    GLib::OptionArg::NONE,
+                    "Quit after a delay")
+run = nil
+list = false
+auto_quit = false
+app.signal_connect("command-line") do |_app, command_line|
+  run = command_line.options_dict.lookup("run", "s")
+  list = command_line.options_dict.lookup("list", "b")
+  auto_quit = command_line.options_dict.lookup("auto-quit", "b")
+  app.activate
+  0
+end
+
+app.signal_connect("handle-local-options") do |_app, options|
+  if options.lookup("version", "b")
+    puts("ruby-gtk4-demo: #{GLib::BINDING_VERSION.join(".")}")
+    0
+  else
+    -1
+  end
+end
+
+app.signal_connect("activate") do |_app|
+  builder = Gtk::Builder.new(resource: "/ui/main.ui")
+  window = builder["window"]
+  app.add_window(window)
+
+  run_action = Gio::SimpleAction.new("run")
+  run_action.signal_connect("activate") do
+    row = selection.selected_item
+    demo = row.item
+    run_demo(demo, window)
+  end
+  window.add_action(run_action)
+
+  notebook = builder["notebook"]
+
+  info_view = builder["info-textview"]
+  source_view = builder["source-textview"]
+  list_view = builder["listview"]
+  list_view.signal_connect("activate") do |_, position|
+    model = list_view.model
+    row = model.get_item(position)
+    run_demo(row.item, window)
+  end
+  search_bar = builder["searchbar"]
+  search_bar.signal_connect("notify::search-mode-enabled") do
+    unless search_bar.search_mode?
+      bar.child.text = ""
+    end
+  end
+
+  list_model = create_demo_model(window)
+  tree_model = Gtk::TreeListModel.new(list_model, false, true) do |item|
+    item.children_model
+  end
+  filter_model = Gtk::FilterListModel.new(tree_model, nil)
+  filter = Gtk::CustomFilter.new do
+    # TODO
+    true
+  end
+  filter_model.filter = filter
+
+  search_entry = builder["search-entry"]
+
+  selection = Gtk::SingleSelection.new(filter_model)
+  selection.signal_connect("notify::selected-item") do
+    select_item(selection, window, notebook, info_view)
+  end
+  list_view.model = selection
+  select_item(selection, window, notebook, info_view)
+
+  target_demo = nil
+  if run
+    GtkDemo.each do |demo|
+      if demo.name == run
+        target_demo = demo
+        break
+      end
+    end
+  end
+  if target_demo
+    demo_window = run_demo(target_demo, window)
+    # TODO: This doesn't work
+    demo_window.signal_connect("destroy") do
+      app.quit
+    end
+  else
+    window.present
+  end
+end
+
+app.run([$0] + ARGV)