gtk4 4.0.3 → 4.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fd29b5c43f2bbf99765dd2b0a165351a55ba71244c10392eed5f443f7953f13
-  data.tar.gz: 7ed521f6ebb50e85924f9a80c46c172540f8565f148d84d8d71f6940f17ea22c
+  metadata.gz: cd956d7d34f4285571a9afaf17f4b942f973de302868f8a6b854692467b4dc16
+  data.tar.gz: c171947ea6785c3b529f0b05f9251388c4edacbe3b1f8ff401252e5dc2cf5d63
 SHA512:
-  metadata.gz: 7c3658a5a78e4bc7854ece88656989a8710b238f4f39199b6c737953c52eec2c284fd3dbdb6e7db149efbca8be35d47c15706e04301ae7b31cae7a25445d713f
-  data.tar.gz: 2d96bbe7d280d461c2a0b67033619e88a57c4409dedabe56156b67099ba9f87dbd83253f3ba83069d6c6538198167b2ca2f18d6b0fd642b4336eacd75247c946
+  metadata.gz: 2ad4711c7b084a033c558d924029bdbd73190fd4fa805d6584d3d73429c89057689e7a9eaa9afa63bbc8466174c6718cf97a13c78ae696a85d52a25c84edb0c6
+  data.tar.gz: 151c10f1af8eed7f1144ce5a9a626872b51ca711055b90ff762df4d57135e0b4b0105c684f6951ebef3974197d12b8dbb706f310f068bf413ff096c617b9c338

data/ext/gtk4/extconf.rb

@@ -80,6 +80,16 @@ end
 create_pkg_config_file("Ruby/GTK4", package_id)
 
 $defs << "-DRUBY_GTK4_COMPILATION"
+case RUBY_PLATFORM
+when /darwin/
+  symbols_in_external_bundles = [
+    "_rbgobj_gc_mark_instance",
+    "_rbgobj_register_mark_func",
+  ]
+  symbols_in_external_bundles.each do |symbol|
+    $DLDFLAGS << " -Wl,-U,#{symbol}"
+  end
+end
 create_makefile(module_name)
 
 pkg_config_dir = with_config("pkg-config-dir")

data/ext/gtk4/rb-gtk4-cell-layout.c

@@ -0,0 +1,41 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2015-2022  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
+ */
+
+#include "rb-gtk4-private.h"
+
+static void
+rb_gtk4_cell_layout_mark(gpointer object)
+{
+    GtkCellLayout *cell_layout = object;
+
+    GList *renderers = gtk_cell_layout_get_cells(cell_layout);
+    GList *node;
+    for (node = renderers; node; node = g_list_next(node)) {
+        GtkCellRenderer *renderer = node->data;
+        rbgobj_gc_mark_instance(renderer);
+    }
+    g_list_free(renderers);
+}
+
+void
+rb_gtk4_cell_layout_init(void)
+{
+    rbgobj_register_mark_func(GTK_TYPE_CELL_LAYOUT, rb_gtk4_cell_layout_mark);
+}

data/ext/gtk4/rb-gtk4-private.h

@@ -29,5 +29,7 @@
 
 #include "rb-gtk4.h"
 
+G_GNUC_INTERNAL void rb_gtk4_cell_layout_init(void);
+G_GNUC_INTERNAL void rb_gtk4_tree_view_init(void);
 G_GNUC_INTERNAL void rb_gtk4_widget_init(void);
 G_GNUC_INTERNAL void rb_gtk4_window_init(void);

data/ext/gtk4/rb-gtk4-tree-view.c

@@ -0,0 +1,44 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2015-2022  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
+ */
+
+#include "rb-gtk4-private.h"
+
+static void
+rb_gtk4_tree_view_mark(gpointer object)
+{
+    GtkTreeView *tree_view = object;
+
+    GList *columns = gtk_tree_view_get_columns(tree_view);
+    GList *node;
+    for (node = columns; node; node = g_list_next(node)) {
+        GtkTreeViewColumn *column = node->data;
+        rbgobj_gc_mark_instance(column);
+    }
+    g_list_free(columns);
+
+    GtkTreeSelection *selection = gtk_tree_view_get_selection(tree_view);
+    rbgobj_gc_mark_instance(selection);
+}
+
+void
+rb_gtk4_tree_view_init(void)
+{
+    rbgobj_register_mark_func(GTK_TYPE_TREE_VIEW, rb_gtk4_tree_view_mark);
+}

data/ext/gtk4/rb-gtk4.c

@@ -23,6 +23,8 @@
 void
 Init_gtk4(void)
 {
+    rb_gtk4_cell_layout_init();
+    rb_gtk4_tree_view_init();
     rb_gtk4_widget_init();
     rb_gtk4_window_init();
 }

data/lib/gtk4/deprecated.rb

@@ -629,7 +629,7 @@ module Gtk
           [{file: image}]
         end
       when Symbol
-        [{icon_name: iamge}]
+        [{icon_name: image}]
       when GdkPixbuf::Pixbuf
         [{:pixbuf => image}]
       when Gio::Icon

data/lib/gtk4/scrolled-window.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014  Ruby-GNOME2 Project Team
+# Copyright (C) 2014-2022  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
@@ -18,7 +18,9 @@ module Gtk
   class ScrolledWindow
     alias_method :initialize_raw, :initialize
     def initialize(hadjustment=nil, vadjustment=nil)
-      initialize_raw(hadjustment, vadjustment)
+      initialize_raw
+      set_hadjustment(hadjustment) if hadjustment
+      set_vadjustment(vadjustment) if vadjustment
     end
   end
 end

data/lib/gtk4/widget.rb

@@ -106,6 +106,10 @@ module Gtk
 
     private
     def initialize_post
+      super
+
+      GObjectIntrospection::Loader.reference_gobject(self, sink: true)
+
       klass = self.class
       return unless klass.have_template?
       return unless respond_to?(:init_template)

data/sample/examples/action-namespace.rb

@@ -123,7 +123,7 @@ application.signal_connect "activate" do |app|
   button.menu_model = buttonmenu
   button.halign = :center
   button.valign = :start
-  win.add(button)
+  win.set_child(button)
   win.show
 end
 

data/sample/examples/builder.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #
-# Copyright (C) 2013-2018  Ruby-GNOME2 Project Team
+# Copyright (C) 2013-2022  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
@@ -16,26 +16,33 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-# example from https://github.com/GNOME/gtk/blob/master/examples/builder.c
+# example from https://gitlab.gnome.org/GNOME/gtk/blob/main/examples/builder.c
 
 require_relative "utils"
 
 require_gtk4
 
-# Construct a GtkBuilder instance and load our UI description
-builder = Gtk::Builder.new(:file => "#{path}/builder.ui")
+app = Gtk::Application.new("org.gtk.example", :flags_none)
 
-# Connect signal handlers to the constructed widgets.
-window = builder["window"]
-window.signal_connect("destroy") { Gtk.main_quit }
+app.signal_connect "activate" do
+  # Construct a GtkBuilder instance and load our UI description
+  builder = Gtk::Builder.new(file: File.join(__dir__, "builder.ui"))
 
-button = builder["button1"]
-button.signal_connect("clicked") { puts "Hello World!" }
+  # Connect signal handlers to the constructed widgets.
+  window = builder["window"]
+  window.set_application(app)
 
-button = builder["button2"]
-button.signal_connect("clicked") { puts "Hello World!" }
+  button = builder["button1"]
+  button.signal_connect("clicked") { puts "Hello World!" }
 
-button = builder["quit"]
-button.signal_connect("clicked") { Gtk.main_quit }
+  button = builder["button2"]
+  button.signal_connect("clicked") { puts "Hello World!" }
+
+  button = builder["quit"]
+  button.signal_connect("clicked") { window.close }
+
+  window.show
+end
+
+app.run
 
-Gtk.main

data/sample/examples/builder.ui

@@ -1,44 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
 <interface>
   <object id="window" class="GtkWindow">
-    <property name="visible">True</property>
     <property name="title">Grid</property>
     <child>
       <object id="grid" class="GtkGrid">
-        <property name="visible">True</property>
         <child>
           <object id="button1" class="GtkButton">
-            <property name="visible">True</property>
             <property name="label">Button 1</property>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">0</property>
+            </layout>
           </object>
-          <packing>
-            <property name="left-attach">0</property>
-            <property name="top-attach">0</property>
-          </packing>
         </child>
         <child>
           <object id="button2" class="GtkButton">
-            <property name="visible">True</property>
             <property name="label">Button 2</property>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">0</property>
+            </layout>
           </object>
-          <packing>
-            <property name="left-attach">1</property>
-            <property name="top-attach">0</property>
-          </packing>
         </child>
         <child>
           <object id="quit" class="GtkButton">
-            <property name="visible">True</property>
             <property name="label">Quit</property>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">1</property>
+              <property name="column-span">2</property>
+            </layout>
           </object>
-          <packing>
-            <property name="left-attach">0</property>
-            <property name="top-attach">1</property>
-            <property name="width">2</property>
-          </packing>
         </child>
       </object>
-      <packing>
-      </packing>
     </child>
   </object>
 </interface>
+

data/sample/examples/drawing.rb

@@ -34,17 +34,13 @@ def draw_brush(widget, surface, x, y)
   cr = Cairo::Context.new(surface)
   cr.rectangle(x - 3, y - 3, 6, 6)
   cr.fill
-  widget.queue_draw_area(x - 3, y - 3, 6, 6)
+  widget.queue_draw
 end
 
 def generate_surface_from_widget(widget)
-  surface = nil
-  if widget.window
-    surface = widget.window.create_similar_surface(Cairo::CONTENT_COLOR,
-                                                   widget.allocated_width,
-                                                   widget.allocated_height)
-  end
-  surface
+  widget.native.surface.create_similar_surface(Cairo::CONTENT_COLOR,
+                                               widget.allocated_width,
+                                               widget.allocated_height)
 end
 
 myapp = Gtk::Application.new("org.gtk.example", :flags_none)
@@ -60,14 +56,10 @@ myapp.signal_connect "activate" do |app|
     win.destroy
   end
 
-  frame = Gtk::Frame.new
-  frame.shadow_type = Gtk::ShadowType::IN
-  win.add(frame)
-
   drawing_area = Gtk::DrawingArea.new
   # Set a minimum size
   drawing_area.set_size_request(100, 100)
-  frame.add(drawing_area)
+  win.set_child(drawing_area)
 
   drawing_area.set_draw_func do |da, cr|
     if surface.nil?
@@ -82,15 +74,16 @@ myapp.signal_connect "activate" do |app|
     cr.paint
   end
 
-  drawing_area.signal_connect_after "size-allocate" do |da, alloc|
+  drawing_area.signal_connect_after "resize" do |da, alloc|
     surface.destroy if surface
     surface = generate_surface_from_widget(da)
     # Initialize the surface to white
     clear_surface(surface) if surface
   end
 
-  drag = Gtk::GestureDrag.new(drawing_area)
+  drag = Gtk::GestureDrag.new
   drag.button = Gdk::BUTTON_PRIMARY
+  drawing_area.add_controller(drag)
 
   start_x = 0.0
   start_y = 0.0
@@ -109,8 +102,9 @@ myapp.signal_connect "activate" do |app|
     draw_brush(drawing_area, surface, start_x + x, start_y + y)
   end
 
-  press = Gtk::GestureMultiPress.new(drawing_area)
+  press = Gtk::GestureClick.new
   press.button = Gdk::BUTTON_SECONDARY
+  drawing_area.add_controller(press)
   press.signal_connect "pressed" do |gesture, n_press, x, y|
     clear_surface(surface)
     drawing_area.queue_draw

data/sample/examples/grid_packing.rb

@@ -33,7 +33,7 @@ application.signal_connect "activate" do |app|
   grid = Gtk::Grid.new
 
   # Pack the container in the window
-  win.add(grid)
+  win.set_child(grid)
 
   button = Gtk::Button.new(:label => "Button 1")
   button.signal_connect("clicked") { puts "Hello World!" }

data/sample/examples/hello_world.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #
-# Copyright (C) 2013-2018  Ruby-GNOME2 Project Team
+# Copyright (C) 2013-2022  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
@@ -16,7 +16,7 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-# example from https://github.com/GNOME/gtk/blob/master/examples/hello-world.c
+# example from https://gitlab.gnome.org/GNOME/gtk/blob/main/examples/hello/hello-world.c
 
 require_relative "utils"
 
@@ -25,22 +25,22 @@ require_gtk4
 application = Gtk::Application.new("org.gtk.example", :flags_none)
 
 application.signal_connect "activate" do |app|
-  win = Gtk::ApplicationWindow.new(app)
-  win.title = "window"
-  win.set_default_size(200, 200)
+  window = Gtk::ApplicationWindow.new(app)
+  window.title = "Window"
+  window.set_default_size(200, 200)
 
-  button_box = Gtk::ButtonBox.new(:horizontal)
-  win.add(button_box)
+  button = Gtk::Button.new(label: "Hello World")
+  button.halign = :center
+  button.valign = :center
 
-  button = Gtk::Button.new(:label => "Hello World")
   button.signal_connect "clicked" do
     puts "Hello World"
-    win.destroy
+    window.destroy
   end
 
-  button_box.add(button)
+  window.child = button
 
-  win.show
+  window.show
 end
 
 application.run

data/sample/examples/window_default.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+#
+# Copyright (C) 2022  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
+
+# example from https://gitlab.gnome.org/GNOME/gtk/blob/main/examples/window-default.c
+#
+# License: LGPL2.1+
+
+require_relative "utils"
+
+require_gtk4
+
+application = Gtk::Application.new("org.gtk.example", :flags_none)
+
+application.signal_connect "activate" do |app|
+  window = Gtk::ApplicationWindow.new(app)
+  window.title = "Window"
+  window.set_default_size(200, 200)
+  window.show
+end
+
+application.run

data/sample/getting-started/README.md

@@ -1,4 +1,357 @@
 # Ruby/GTK4 getting started
 
-There are scripts ported from
-https://docs.gtk.org/gtk4/getting_started.html .
+This is a ruby adaptation of the [official tutorial](https://docs.gtk.org/gtk4/getting_started.html) for the C language.
+
+The Gtk4 module of the ruby-gnome project is an implementation of the ruby bindings for GTK.
+
+GTK is a [widget toolkit](http://en.wikipedia.org/wiki/Widget_toolkit). Each user interface created by GTK consists of widgets. Widgets are organized in a hierarchy. The window widget is the main container. The user interface is then built by adding buttons, drop-down menus, input fields, and other widgets to the window. If you are creating complex user interfaces it is recommended to use `Gtk::Builder` and its GTK-specific markup description language, instead of assembling the interface manually.
+
+GTK is event-driven. The toolkit listens for events such as a click on a button, and passes the event to your application.
+
+This chapter contains some tutorial information to get you started with GTK programming. It assumes that you have GTK, its dependencies and ruby with the gtk4 gem installed.
+
+## Basics
+To begin our introduction to GTK, we’ll start with a very simple application. This program will create an empty 200 × 200 pixel window.
+
+![example-0](images/example-0.png)
+
+```ruby
+# example-0.rb
+require "gtk4"
+
+application = Gtk::Application.new("org.gtk.example", :flags_none)
+
+application.signal_connect "activate" do |app|
+  window = Gtk::ApplicationWindow.new(app)
+  window.title = "Window"
+  window.set_default_size(200, 200)
+  window.show
+end
+
+application.run
+```
+
+When creating a Gtk::Application you need to pick an application identifier (a name) and input to `Gtk::Application#new` as parameter. For this example *org.gtk.example* is used but for choosing an identifier for your application see this [guide](https://wiki.gnome.org/HowDoI/ChooseApplicationID).
+
+Lastly `Gtk::Application#new` takes a `Gio::ApplicationFlags` constant as input for your application, if your application would have special needs (those constants can be replaced by theirs respective symbol ie. `Gio::ApplicationFlags::FLAGS_NONE` == `:flags_none`). You must know that `Gio:::Application` ignores arguments passed to `Gio::Application#run` on the Windows systems. It always uses command line arguments even when we pass an empty array to `Gio::Application#run`.
+
+If you plan to create a cross-platform application, it is recommanded to use the `:handles_command_line` flags and the *command-line* signal. (reference : https://github.com/ruby-gnome/ruby-gnome/issues/721 ).
+
+Next we add instructions for the "activate" event of the `Gtk::Application` instance we created. The activate signal will be sent when your application is launched with the method `Gtk::Application#run` on the line below. This method also takes as arguments a ruby array of string. This allows GTK to parse specific command line arguments that control the behavior of GTK itself. Your application can override the command line handling, e.g. to open files passed on the commandline.
+
+A window title is set using `Gtk::ApplicationWindow#title=`. This setter function takes a string as input.
+
+Finally the window size is set using `Gtk::ApplicationWindow#set_default_size` and the window is then shown by GTK via `Gtk::Widget#show`.
+
+While the program is running, GTK is receiving *events*. These are typically input events caused by the user interacting with your program, but also things like messages from the window manager or other applications. GTK processes these and as a result, signals may be emitted on your widgets. Connecting handlers for these signals is how you normally make your program do something in response to user input.
+
+The following example is slightly more complex, and tries to showcase some of the capabilities of GTK.
+
+## Hello, World
+
+In the long tradition of programming languages and libraries, this example is called *Hello, World*.
+
+![example-1](images/example-1.png)
+
+```ruby
+# example-1.rb
+application = Gtk::Application.new("org.gtk.example", :flags_none)
+
+application.signal_connect "activate" do |app|
+  window = Gtk::ApplicationWindow.new(app)
+  window.title = "Window"
+  window.set_default_size(200, 200)
+
+  button_box = Gtk::Box.new(:horizontal)
+  button_box.halign = :center
+  button_box.valign = :center
+  window.set_child(button_box)
+
+  button = Gtk::Button.new(label: "Hello World")
+
+  button.signal_connect "clicked" do
+    puts "Hello World"
+    window.destroy
+  end
+  button_box.append(button)
+
+  window.show
+end
+
+application.run
+```
+
+As seen above, example-1.rb builds further upon example-0.rb by adding a button to our window, with the label “Hello World”.
+
+The button_box variable stores a `Gtk::Box` object, which is GTK's way of controlling the size and layout of widgets. The `Gtk::Box` is created with the method `Gtk::Box#new` which takes a `Gtk::Orientation `constant as parameter or the related symbols (`:vertical` or `:horizontal`).
+
+The buttons which this box will contain can either be stored horizontally or vertically but this does not matter in this particular case as we are dealing with only one button. After initializing button_box with horizontal orientation, the code adds the button_box widget to the window widget using `Gtk::Box#append`.
+
+Next the button variable is initialized in similar manner. The method `Gtk::Button#new` is called which returns a `Gtk::Button` to be stored in button. A label is set using a ruby hash as argument: `label: "Hello World"`. Afterwards button is added to our button_box.
+
+Using the method `Gtk::Button#signal_connect` we add instructions, so that when the button is clicked, a message will be displayed in the terminal if the GTK application was started from one.
+
+After that, `Gtk::ApplicationWindow#destroy` is called. This method is inherited from `Gtk::Widget`. This has the effect that when the button is clicked, the whole GTK window is destroyed. More information about creating buttons can be found [here](https://wiki.gnome.org/HowDoI/Buttons).
+
+The rest of the code in example-1.rb is identical to example-0.rb. Next section will elaborate further on how to add several GtkWidgets to your GTK application.
+
+## Packing
+
+When creating an application, you’ll want to put more than one widget inside a window. When you do so, it becomes important to control how each widget is positioned and sized. This is where packing comes in.
+
+GTK comes with a large variety of layout containers whose purpose it is to control the layout of the child widgets that are added to them, like:
+
+* [Gtk::Box](https://docs.gtk.org/gtk4/class.Box.html)
+* [Gtk::Grid](https://docs.gtk.org/gtk4/class.Grid.html)
+* [Gtk::Revealer](https://docs.gtk.org/gtk4/class.Revealer.html)
+* [Gtk::Stack](https://docs.gtk.org/gtk4/class.Stack.html)
+* [Gtk::Overlay](https://docs.gtk.org/gtk4/class.Overlay.html)
+* [Gtk::Paned](https://docs.gtk.org/gtk4/class.Paned.html)
+* [Gtk::Expander](https://docs.gtk.org/gtk4/class.Expander.html)
+* [Gtk::Fixed](https://docs.gtk.org/gtk4/class.Fixed.html)
+
+The following example shows how the `Gtk::Grid` container lets you arrange several buttons:
+
+![example-2](images/example-2.png)
+
+```ruby
+# example-2.rb
+require "gtk4"
+
+application = Gtk::Application.new("org.gtk.example", :flags_none)
+
+application.signal_connect "activate" do |app|
+  # Create a new window and set its title
+  win = Gtk::ApplicationWindow.new(app)
+  win.title = "Window"
+
+  # Here we construct the container that is going to pack our buttons.
+  grid = Gtk::Grid.new
+
+  # Pack the container in the window
+  win.set_child(grid)
+
+  button = Gtk::Button.new(label: "Button 1")
+  button.signal_connect("clicked") { puts "Hello World!" }
+
+  # Place the first button in the grid cell (0, 0), and make it fill
+  # just 1 cell horizontally and vertically (ie no spanning)
+  grid.attach(button, 0, 0, 1, 1)
+
+  button = Gtk::Button.new(label: "Button 2")
+  button.signal_connect("clicked") { puts "Hello World!" }
+
+  # Place the second button in the grid cell (1, 0), and make it fill
+  # just 1 cell horizontally and vertically (ie no spanning)
+  grid.attach(button, 1, 0, 1, 1)
+
+  button = Gtk::Button.new(label: "Quit")
+  button.signal_connect("clicked") { win.destroy }
+
+  # Place the Quit button in the grid cell (0, 1), and make it
+  # span 2 columns.
+  grid.attach(button, 0, 1, 2, 1)
+
+  win.show
+end
+
+application.run
+```
+
+## Custom Drawing
+
+Many widgets, like buttons, do all their drawing themselves. You just tell them the label you want to see, and they figure out what font to use, draw the button outline and focus rectangle, etc. Sometimes, it is necessary to do some custom drawing. In that case, a `Gtk::DrawingArea` might be the right widget to use. It offers a canvas on which you can draw by setting its draw function.
+
+The contents of a widget often need to be partially or fully redrawn, e.g. when another window is moved and uncovers part of the widget, or when the window containing it is resized. It is also possible to explicitly cause a widget to be redrawn, by calling `Gtk::Widget#queue_draw`. GTK takes care of most of the details by providing a ready-to-use cairo context to the draw function.
+
+The following example shows how to use a draw function with `Gtk::DrawingArea`. It is a bit more complicated than the previous examples, since it also demonstrates input event handling with event controllers.
+
+![example-3](images/example-3.png)
+
+### Drawing in response to input
+
+```ruby
+# example-3.rb
+require "gtk4"
+
+def clear_surface(surface)
+  cr = Cairo::Context.new(surface)
+  cr.set_source_rgb(1, 1, 1)
+  cr.paint
+  cr.destroy
+end
+
+# Draw a rectangle on the surface at the given position
+def draw_brush(widget, surface, x, y)
+  cr = Cairo::Context.new(surface)
+  cr.rectangle(x - 3, y - 3, 6, 6)
+  cr.fill
+  widget.queue_draw
+end
+
+def generate_surface_from_widget(widget)
+  widget.native.surface.create_similar_surface(Cairo::CONTENT_COLOR,
+                                               widget.allocated_width,
+                                               widget.allocated_height)
+end
+
+myapp = Gtk::Application.new("org.gtk.example", :flags_none)
+
+myapp.signal_connect "activate" do |app|
+  win = Gtk::ApplicationWindow.new(app)
+  win.set_title("Drawing Area")
+
+  surface = nil
+
+  win.signal_connect "destroy" do
+    surface.destroy if surface
+    win.destroy
+  end
+
+  drawing_area = Gtk::DrawingArea.new
+  # Set a minimum size
+  drawing_area.set_size_request(100, 100)
+  win.set_child(drawing_area)
+
+  drawing_area.set_draw_func do |da, cr|
+    if surface.nil?
+      surface = generate_surface_from_widget(da)
+      ## Initialize the surface to white
+      clear_surface(surface)
+    end
+    # Redraw the screen from the surface. Note that the draw
+    # callback receives a ready-to-be-used cairo_t that is already
+    # clipped to only draw the exposed areas of the widget
+    cr.set_source(surface, 0, 0)
+    cr.paint
+  end
+
+  drawing_area.signal_connect_after "resize" do |da, alloc|
+    surface.destroy if surface
+    surface = generate_surface_from_widget(da)
+    # Initialize the surface to white
+    clear_surface(surface) if surface
+  end
+
+  drag = Gtk::GestureDrag.new
+  drag.button = Gdk::BUTTON_PRIMARY
+  drawing_area.add_controller(drag)
+
+  start_x = 0.0
+  start_y = 0.0
+
+  drag.signal_connect "drag-begin" do |gesture, x, y|
+    start_x = x
+    start_y = y
+    draw_brush(drawing_area, surface, x, y)
+  end
+
+  drag.signal_connect "drag-update" do |gesture, x, y|
+    draw_brush(drawing_area, surface, start_x + x, start_y + y)
+  end
+
+  drag.signal_connect "drag-end" do |gesture, x, y|
+    draw_brush(drawing_area, surface, start_x + x, start_y + y)
+  end
+
+  press = Gtk::GestureClick.new
+  press.button = Gdk::BUTTON_SECONDARY
+  drawing_area.add_controller(press)
+  press.signal_connect "pressed" do |gesture, n_press, x, y|
+    clear_surface(surface)
+    drawing_area.queue_draw
+  end
+  win.show
+end
+
+myapp.run
+```
+
+## Building user interfaces
+When constructing a more complicated user interface, with dozens or hundreds of widgets, doing all the setup work in code is cumbersome, and making changes becomes next to impossible.
+
+Thankfully, GTK supports the separation of user interface layout from your business logic, by using UI descriptions in an XML format that can be parsed by the `Gtk::Builder` class.
+
+### Packing buttons with GtkBuilder
+
+Create a new file with the following content:
+
+```ruby
+# example-4.rb
+require "gtk4"
+
+app = Gtk::Application.new("org.gtk.example", :flags_none)
+
+app.signal_connect "activate" do
+  # Construct a GtkBuilder instance and load our UI description
+  builder = Gtk::Builder.new(file: File.join(__dir__, "builder.ui"))
+
+  # Connect signal handlers to the constructed widgets.
+  window = builder["window"]
+  window.set_application(app)
+
+  button = builder["button1"]
+  button.signal_connect("clicked") { puts "Hello World!" }
+
+  button = builder["button2"]
+  button.signal_connect("clicked") { puts "Hello World!" }
+
+  button = builder["quit"]
+  button.signal_connect("clicked") { window.close }
+
+  window.show
+end
+
+app.run
+```
+
+Then, create a new file with the following content named `builder.ui`.
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object id="window" class="GtkWindow">
+    <property name="title">Grid</property>
+    <child>
+      <object id="grid" class="GtkGrid">
+        <child>
+          <object id="button1" class="GtkButton">
+            <property name="label">Button 1</property>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">0</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object id="button2" class="GtkButton">
+            <property name="label">Button 2</property>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">0</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object id="quit" class="GtkButton">
+            <property name="label">Quit</property>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">1</property>
+              <property name="column-span">2</property>
+            </layout>
+          </object>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>
+```
+
+The usage of the `Gtk::Builder` is easy, we just create an instance from the
+file "builder.ui" with `Gtk::Builder.new(file: path/to/builder.ui)`. Then you can access every widget or part of the interface thanks to its name: `window = builder["window"]`. Note that `Gtk::Builder` can also be used to construct objects that are not widgets, such as tree models, adjustments, etc.
+
+It is also possible to embed the UI description in the source code as a string and use `GtkBuilder::add_from_string` to load it. But keeping the UI description in a separate file has several advantages:
+
+* it is easier to isolate the UI code from the business logic of your application
+* it is easier to restructure your UI into separate classes using composite widget templates

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gtk4
 version: !ruby/object:Gem::Version
-  version: 4.0.3
+  version: 4.0.5
 platform: ruby
 authors:
 - The Ruby-GNOME Project Team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-13 00:00:00.000000000 Z
+date: 2022-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: atk
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.0.3
+        version: 4.0.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.0.3
+        version: 4.0.5
 - !ruby/object:Gem::Dependency
   name: gdk4
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.0.3
+        version: 4.0.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.0.3
+        version: 4.0.5
 description: Ruby/GTK4 is a Ruby binding of GTK+-4.x.
 email: ruby-gnome2-devel-en@lists.sourceforge.net
 executables: []
@@ -49,7 +49,9 @@ files:
 - README.md
 - Rakefile
 - ext/gtk4/extconf.rb
+- ext/gtk4/rb-gtk4-cell-layout.c
 - ext/gtk4/rb-gtk4-private.h
+- ext/gtk4/rb-gtk4-tree-view.c
 - ext/gtk4/rb-gtk4-widget.c
 - ext/gtk4/rb-gtk4-window.c
 - ext/gtk4/rb-gtk4.c
@@ -121,7 +123,12 @@ files:
 - sample/examples/grid_packing.rb
 - sample/examples/hello_world.rb
 - sample/examples/utils.rb
+- sample/examples/window_default.rb
 - sample/getting-started/README.md
+- sample/getting-started/images/example-0.png
+- sample/getting-started/images/example-1.png
+- sample/getting-started/images/example-2.png
+- sample/getting-started/images/example-3.png
 homepage: https://ruby-gnome2.osdn.jp/
 licenses:
 - LGPL-2.1+