gtk_paradise 0.9.120 → 0.11.19

data/lib/gtk_paradise/gtk_classes/about_dialog.rb

@@ -8,12 +8,16 @@
 # =========================================================================== #
 module Gtk
 
-class AboutDialog
+class AboutDialog # === Gtk::AboutDialog
+
+  require 'gtk_paradise/toplevel_methods/determine_which_gtk_version_is_in_use.rb'
 
   # ========================================================================= #
   # Alias popup towards run.
   # ========================================================================= #
-  alias popup run # === popup
+  unless Gtk.do_we_use_gtk4?
+    alias popup run # === popup
+  end
 
   # ========================================================================= #
   # === = author=

data/lib/gtk_paradise/gtk_classes/alignment.rb

@@ -12,7 +12,10 @@ module Gtk
   # You can use .add() to add to a Gtk::Alignment instance.
   # ========================================================================= #
   def self.alignment(
-      a = 0.5, b = 0.5, c = 0, d = 0
+      a = 0.5,
+      b = 0.5,
+      c = 0,
+      d = 0
     )
     ::Gtk::Alignment.new(a, b, c, d)
   end

data/lib/gtk_paradise/gtk_classes/application.rb

@@ -12,6 +12,8 @@
 # =========================================================================== #
 module Gtk
 
+  require 'gtk_paradise/gtk_classes/application_window.rb'
+
   # ========================================================================= #
   # === Gtk.application
   #
@@ -19,12 +21,100 @@ module Gtk
   #
   #   Gtk::Application.new("org.gtk.example", :flags_none)
   #
+  # If a block is given then this will be assumed to mean that
+  # we want to evaluate that block within the given application.
+  #
+  # Usage example for the latter use case:
+  #
+  #   application = Gtk.default_application('interactive.caesar.cipher') {{
+  #     widget_to_use: Roebe::InteractiveCaesarCipher.new
+  #   }}
+  #
+  # Simpler usageexample:
+  #
+  #   application = Gtk.default_application(:infer) {{
+  #     widget_to_use: Roebe::InteractiveCaesarCipher.new
+  #   }}
+  #
+  # The namespace should be something like 'org.gtk.example_application'.
+  # If no '.' is included then Gtk::Application will complain.
   # ========================================================================= #
   def self.application(
-      namespace       = 'org.gtk.example',
-      use_these_flags = :flags_none
+      namespace       = :infer,
+      use_these_flags = :flags_none,
+      &block
     )
-    ::Gtk::Application.new(namespace, use_these_flags)
-  end
+    # ======================================================================= #
+    # The namespace may be a Symbol, such as :infer. Either way if it is
+    # a Symbol it must be sanitized.
+    # ======================================================================= #
+    if namespace.is_a? Symbol
+      case namespace
+      # ===================================================================== #
+      # === :infer
+      #
+      # In this case we will infer the name from $PROGRAM_NAME.
+      # ===================================================================== #
+      when :infer
+        program_name = $PROGRAM_NAME.dup
+        program_name = File.basename(program_name) if program_name.include?('/')
+        program_name = program_name.delete_suffix(File.extname(program_name)).dup
+        program_name.tr!('_','.') if program_name.include? '_'
+        namespace = program_name
+      end
+    end
+    # ======================================================================= #
+    # Check that the namespace has at the least one '.' character.
+    # ======================================================================= #
+    unless namespace.include? '.'
+      e 'Note that the namespace must include . such as '\
+        'in org.gnome.foobar_application'
+    end
+    application = ::Gtk::Application.new(namespace, use_these_flags)
+    # ======================================================================= #
+    # === Handle blocks next
+    # ======================================================================= #
+    if block_given?
+      yielded = yield
+      # ===================================================================== #
+      # === Handle Hashes next
+      # ===================================================================== #
+      if yielded.is_a? Hash
+        # =================================================================== #
+        # === :widget_to_use
+        # =================================================================== #
+        if yielded.has_key? :widget_to_use
+          add_this_widget = yielded[:widget_to_use]
+          application.signal_connect(:activate) { |app|
+            # =============================================================== #
+            # Construct a new application-window next:
+            # =============================================================== #
+            application_window = ::Gtk::ApplicationWindow.new(app)
+            if add_this_widget.respond_to?(:title?)
+              application_window.title = add_this_widget.title?
+            end
+            # =============================================================== #
+            # Handle width and height settings automatically if the
+            # child widget responds to the methods width? and height?
+            # next:
+            # =============================================================== #
+            if add_this_widget.respond_to?(:width?) and
+               add_this_widget.respond_to?(:height?)
+              application_window.set_default_size(
+                add_this_widget.width?.to_i,
+                add_this_widget.height?.to_i
+              )
+            else
+              application_window.set_default_size(1200, 800)
+            end
+            application_window << add_this_widget
+            application_window.show
+          }
+          application.run
+        end
+      end
+    end
+    return application
+  end; self.instance_eval { alias default_application application } # === Gtk.default_application
 
 end

data/lib/gtk_paradise/gtk_classes/application_window.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# This is unavailable in ruby-gtk2, so we need to check at the beginning
+# for this.
+# =========================================================================== #
+# require 'gtk_paradise/gtk_classes/application_window.rb'
+# =========================================================================== #
+require 'gtk_paradise/toplevel_methods/determine_which_gtk_version_is_in_use.rb'
+
+# =========================================================================== #
+# Do the conditional check here.
+# =========================================================================== #
+if ::Gtk.use_gtk3? or ::Gtk.use_gtk4?
+
+module Gtk
+
+class ApplicationWindow
+
+  alias << set_child # === <<
+
+end; end
+
+end

data/lib/gtk_paradise/gtk_classes/box.rb

@@ -2,317 +2,154 @@
 # Encoding: UTF-8
 # frozen_string_literal: true
 # =========================================================================== #
+# === Gtk::Box
+#
+# Note that this is for Gtk::Box, which is new since as of ruby-gtk3.
+# =========================================================================== #
 # require 'gtk_paradise/gtk_classes/box.rb'
 # =========================================================================== #
-module Gtk
+require 'gtk_paradise/toplevel_methods/determine_which_gtk_version_is_in_use.rb'
 
-  require 'gtk_paradise/gtk_classes/vbox.rb'
-  require 'gtk_paradise/toplevel_methods/determine_which_gtk_version_is_in_use.rb'
+return if ::Gtk.do_we_use_gtk2?
 
-  # ========================================================================= #
-  # === Gtk.create_paned_hbox
-  #
-  # This method will create a HBox with several widgets inside of it.
-  #
-  # The widgets go into the only parameter for this method, aptly
-  # called *widgets.
-  #
-  # You can pass in a block to specify the (optional) padding.
-  #
-  # An example for this would be:
-  #
-  #   Gtk.create_paned_hbox(widget1, widget2) { 10 }
-  #
-  # Usage examples:
-  #
-  #   Gtk.create_paned_hbox(Gtk::Button.new,Gtk::Button.new, Gtk::Button.new)
-  #   Gtk.create_paned_hbox(widget1, widget2)
-  #   Gtk.paned(a, b, c)
-  #
-  # ========================================================================= #
-  def self.create_paned_hbox(*widgets)
-    widgets.flatten!
-    default_padding = block_given? ? yield : 2
-    if do_we_use_gtk2?
-      hbox = Gtk::HBox.new
-    else
-      hbox = Gtk::Box.new(:horizontal)
-    end
-    if do_we_use_gtk2?
-      widgets.size.times { |entry| # Next batch-add it onto the hbox here.
-        hbox.pack_start(widgets[entry],true,true, default_padding)
-      }
-    else
-      widgets.size.times { |entry| # Next batch-add it onto the hbox here.
-        hbox.pack_start(widgets[entry], expand: true, fill: true, padding: default_padding)
-      }
-    end
-    return hbox.show
-  end; self.instance_eval { alias chbox       create_paned_hbox } # === Gtk.chbox
-       self.instance_eval { alias create_hbox create_paned_hbox } # === Gtk.create_hbox
-       self.instance_eval { alias hbox        create_paned_hbox } # === Gtk.hbox
-       self.instance_eval { alias add_hbox    create_paned_hbox } # === Gtk.add_hbox
-       self.instance_eval { alias hpaned      create_paned_hbox } # === Gtk.hpaned
-       self.instance_eval { alias paned_hbox  create_paned_hbox } # === Gtk.paned_hbox
+# =========================================================================== #
+# We assume only ruby-gtk3 and ruby-gtk4 to be here past this point.
+# =========================================================================== #
+module Gtk
 
-  # ========================================================================= #
-  # === Gtk.event_box
-  #
-  # If an argument is supplied to this method then it is assumed that
-  # the user wants to attach a particular widget to a Gtk::EventBox,
-  # as-is.
-  # ========================================================================= #
-  def self.event_box(
-      optional_argument = nil
-    )
-    if optional_argument
-      ::Gtk::EventBox.new.add(optional_argument)
-    else
-      ::Gtk::EventBox.new
-    end
-  end; self.instance_eval { alias eventbox event_box } # === Gtk.eventbox
+class Box # This is specifically for gtk3 and gtk4.
 
-  # ========================================================================= #
-  # === Gtk.padded_vbox
-  # ========================================================================= #
-  def self.padded_vbox(
-      n_padding_to_use = 8
-    )
-    _ = vbox
-    _.set_border_width(n_padding_to_use)
-    return _
+  if respond_to? :set_spacing
+    alias set_padding set_spacing # === set_padding
   end
 
   # ========================================================================= #
-  # === Gtk.padded_hbox
+  # === text
   # ========================================================================= #
-  def self.padded_hbox(
-      n_padding_to_use = 8
-    )
-    _ = hbox
-    _.set_border_width(n_padding_to_use)
-    return _
+  def text(i, padding_to_use = 2)
+    minimal(::Gtk::Label.new(i), padding_to_use)
   end
 
   # ========================================================================= #
-  # === Gtk.create_paned_vbox
-  #
-  # This will use a default padding of 2.
+  # === add_space
   #
-  # create_paned_vbox(widget1,widget2)
+  # This is, ultimately for now, just a vertical "spacer". At a later
+  # time we may have to query the orientation of the box, but for
+  # now it just sufficed for my use case to define it as vertical.
   # ========================================================================= #
-  def self.create_paned_vbox(*widgets)
-    default_padding = block_given? ? yield : 2
-    if do_we_use_gtk2?
-      vbox = ::Gtk::VBox.new
-    else # else we assume that ruby-gtk3 is used.
-      vbox = ::Gtk::Box.new(:vertical)
-    end
-    widgets.flatten!
-    widgets.size.times { |t|
-      if do_we_use_gtk2?
-        vbox.pack_start(widgets[t], true, true, default_padding)
-      else
-        vbox.pack_start(widgets[t], expand: true, fill: true, padding: default_padding)
-      end
-    }
-    return vbox.show
-  end; self.instance_eval { alias vbox       create_paned_vbox } # === Gtk.vbox
-       self.instance_eval { alias add_vbox   create_paned_vbox } # === Gtk.add_vbox
-       self.instance_eval { alias paned_vbox create_paned_vbox } # === Gtk.paned_vbox
+  def add_space
+    ::Gtk.vertical_spacer
+  end
+
+end
+
+# =========================================================================== #
+# === Gtk.create_vbox
+# =========================================================================== #
+def self.create_vbox(i = ARGV)
+  box = ::Gtk::Box.new(:vertical)
+  [i].flatten.compact.each {|widget_to_be_added|
+    box.add_or_append(widget_to_be_added)
+  }
+  return box
+end; self.instance_eval { alias vbox        create_vbox } # === Gtk.vbox
+     self.instance_eval { alias return_vbox create_vbox } # === Gtk.return_vbox
 
+# =========================================================================== #
+# === Gtk.hbox
+#
+# This method accepts a variable amount of input, which will be
+# the widgets that we will put into this widget.
+#
+# Keep in mind that input to this method may be like this:
+#
+#   hbox = gtk_hbox(
+#      bold_label: 'Merge these images together:',
+#      entry: @gtk_entry_for_merging_images
+#    )
+#
+# Note that since as of September 2022 this is permissive, even for
+# ruby-gtk3, as ruby-gtk2 will specifically only pull in vbox.rb
+# and hbox.rb.
+# =========================================================================== #
+def self.hbox(
+    *boxes, &block
+  )
+  append_mode = :minimal
+  _ = ::Gtk::Box.new(:horizontal)
+  # ========================================================================= #
+  # Handle blocks next
+  # ========================================================================= #
+  if block_given?
+    yielded = yield
+    case yielded
+    when :maximal
+      append_mode = :maximal
+    end
+    if boxes.empty?
+      boxes = [yielded]
+    end
+  end
   # ========================================================================= #
-  # === Gtk.hbox
-  #
-  # This method accepts a variable amount of input, which will be
-  # the widgets that we will put into this widget.
-  #
-  # Keep in mind that input to this method may be like this:
-  #
-  #   hbox = gtk_hbox(
-  #      bold_label: 'Merge these images together:',
-  #      entry: @gtk_entry_for_merging_images
-  #    )
-  #
+  # Handle the "boxes" argument next.
   # ========================================================================= #
-  def self.hbox(*boxes, &block)
-    if do_we_use_gtk2?
-      _ = ::Gtk::HBox.new
-    else # else we are using gtk3, most likely.
-      _ = ::Gtk::Box.new(:horizontal, 0)
-    end
-    # ======================================================================= #
-    # Handle blocks next
-    # ======================================================================= #
-    if block_given?
-      yielded = yield
-      if boxes.empty?
-        boxes = [yielded]
-      end
+  boxes.flatten.each {|box|
+    if box.is_a? String
+      box = ::Gtk.text(box)
     end
     # ======================================================================= #
-    # Handle the "boxes" argument next.
+    # === Handle Hashes next
     # ======================================================================= #
-    boxes.flatten.each {|box|
+    if box.is_a? Hash
       # ===================================================================== #
-      # === Handle Hashes next
+      # We must iterate through this Hash now, via .each_pair, to retain
+      # the original structure. Otherwise the gtk-entry may appear on
+      # the left side, whereas it was specified last in that Hash.
       # ===================================================================== #
-      if box.is_a? Hash
+      box.each_pair {|key, value|
+        case key
         # =================================================================== #
-        # We must iterate through this Hash now, via .each_pair, to retain
-        # the original structure. Otherwise the gtk-entry may appear on
-        # the left side, whereas it was specified last in that Hash.
+        # === hbox = gtk_hbox {{ spacing: 10 }}
         # =================================================================== #
-        box.each_pair {|key, value|
-          case key
-          # ================================================================= #
-          # === hbox = gtk_hbox {{ spacing: 10 }}
-          # ================================================================= #
-          when :spacing
-            _.set_spacing(value)
-          # ================================================================= #
-          # === entry
-          #
-          # This entry point assumes that the user provided a Gtk::Entry
-          # to this method.
-          # ================================================================= #
-          when :entry
+        when :spacing
+          _.set_spacing(value)
+        # =================================================================== #
+        # === entry
+        #
+        # This entry point assumes that the user provided a Gtk::Entry
+        # to this method.
+        # =================================================================== #
+        when :entry
+          if append_mode == :maximal
+            _.maximal(value) # Add the widget here at once.
+          else
             _.minimal(value) # Add the widget here at once.
-          # ================================================================= #
-          # === :bold_label
-          # ================================================================= #
-          when :bold_label
-            _.minimal(gtk_label(value).make_bold)
+          end
+        # =================================================================== #
+        # === :bold_label
+        # =================================================================== #
+        when :bold_label
+          if append_mode == :maximal
+            _.maximal(gtk_label(value).make_bold)
           else
-            # =============================================================== #
-            # At this point we should check whether the key is unhandled.
-            # =============================================================== #
-            puts 'Unhandled keys in the Hash: '+key.to_s
+            _.minimal(gtk_label(value).make_bold)
           end
-        }
+        else
+          # ================================================================= #
+          # At this point we should check whether the key is unhandled.
+          # ================================================================= #
+          puts 'Unhandled keys in the Hash: '+key.to_s
+        end
+      }
+    else
+      if append_mode == :maximal
+        _.maximal(box)
       else
         _.minimal(box)
       end
-    }
-    _ # And return our widget here.
-  end
-
-if do_we_use_gtk2?
-
-  # ========================================================================= #
-  # === Gtk::HBox
-  # ========================================================================= #
-  class HBox
-
-    alias pack pack_start # === pack
-
-  end
-
-  # ========================================================================= #
-  # === Add an "alias" to HBox if we use ruby-gtk2.
-  # ========================================================================= #
-  Hbox = ::Gtk::HBox
-
-  # ========================================================================= #
-  # === Gtk.return_hbox
-  # ========================================================================= #
-  def self.return_hbox
-    ::Gtk::HBox.new
-  end
-
-  # ========================================================================= #
-  # === Gtk.create_paned_hbox_first_big
-  #
-  # First widget takes up most space here.
-  #
-  #   Gtk.create_paned_hbox_first_big(Gtk::Button.new, Gtk::Button.new, Gtk::Button.new)
-  #
-  # ========================================================================= #
-  def self.create_paned_hbox_first_big(*widgets)
-    widgets.flatten! # Don't forget to flatten here.
-    hbox = ::Gtk::HBox.new
-    widgets.size.times { |t|
-      if t == 0
-        hbox.pack_start(widgets[t], true, true,1)
-      else
-        hbox.pack_start(widgets[t], false, true,1)
-      end
-    }
-    return hbox.show
-  end
-
-  # ========================================================================= #
-  # === Gtk.create_paned_vbox_last_big
-  #
-  # For this method, the first widget passed in (aka the first argument)
-  # will take up most space here. This may fit if you want to use a 
-  # large image on the left-hand side, and then some label on the right
-  # hand side describing when this picture was taken, or a similar
-  # use case.
-  #
-  # Usage example:
-  #
-  #   create_paned_vbox_last_big(Gtk::Button.new, Gtk::Button.new, Gtk::Button.new)
-  #
-  # ========================================================================= #
-  def self.create_paned_vbox_last_big(*widgets)
-    widgets.flatten!
-    how_many_slots = widgets.size
-    vbox = ::Gtk::VBox.new
-    how_many_slots.times { |entry|
-      case entry
-      when 0
-        vbox.pack_start(widgets[entry], false, true, 1)
-      else
-        vbox.maximal(widgets[entry], 1)
-      end
-    }
-    return vbox.show
-  end
-
-  # ========================================================================= #
-  # === Gtk.create_paned_hbox_last_big
-  #
-  # First widget takes up most space here. hbox means "horizontal box".
-  #
-  # Usage example via the gtk-paradise gem:
-  #
-  #   Gtk.create_paned_hbox_last_bigg(gtk_button, gtk_button, gtk_button)
-  #
-  # ========================================================================= #
-  def self.create_paned_hbox_last_big(*widgets)
-    how_many_slots = widgets.size
-    hbox = ::Gtk::HBox.new
-    how_many_slots.times { |t|
-      case t
-      when 0
-        hbox.pack_start(widgets[t],false,true,1)
-      else
-        hbox.pack_start(widgets[t],true,true,1)
-      end
-    }
-    return hbox.show
-  end
-
-else # else assume ruby-gtk3 here.
-
-  class Box # This is specifically for gtk3.
-
-    alias set_padding set_spacing # === set_padding
-
-    # ======================================================================= #
-    # === add_space
-    #
-    # This is, ultimately for now, just a vertical "spacer". At a later
-    # time we may have to query the orientation of the box, but for
-    # now it just sufficed for my use case to define it as vertical.
-    # ======================================================================= #
-    def add_space
-      ::Gtk.vertical_spacer
     end
-
-  end
-
+  }
+  _ # And return our widget here.
 end
 
 end