gtk3 2.2.4-x64-mingw32

data/sample/gtk-demo/images.rb

@@ -0,0 +1,197 @@
+# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+# $Id: images.rb,v 1.5 2006/04/08 12:30:03 mutoh Exp $
+=begin
+= Images
+
+Gtk::Image is used to display an image; the image can be in a number of formats.
+Typically, you load an image into a Gdk::Pixbuf, then display the pixbuf.
+
+This demo code shows some of the more obscure cases, in the simple
+case a call to Gtk::Image.new is all you need.
+
+If you want to put image data in your program as a String variable,
+use the make-inline-pixbuf program that comes with GTK+.
+This way you won't need to depend on loading external files, your
+application binary can be self-contained.
+=end
+require 'common'
+
+module Demo
+  class Images < BasicWindow
+    def initialize
+      @pixbuf_loader = nil
+      @load_timeout = 0
+      @image_stream = nil
+
+      super('Images')
+      signal_connect('destroy') do
+        cleanup_callback
+      end
+
+      self.border_width = 8
+
+      vbox = Gtk::VBox.new(false, 8)
+      vbox.border_width = 8
+      add(vbox)
+
+      label = Gtk::Label.new
+      label.set_markup('<u>Image loaded from a file</u>')
+      vbox.pack_start(label, :expand => false, :fill => false, :padding => 0)
+
+      frame = Gtk::Frame.new
+      frame.shadow_type = :in
+
+      # The alignment keeps the frame from growing when users resize
+      # the window
+      align = Gtk::Alignment.new(0.5, 0.5, 0, 0)
+      align.add(frame)
+      vbox.pack_start(align, :expand => false, :fill => false, :padding => 0)
+
+      # demo_find_file looks in the the current directory first,
+      # so you can run gtk-demo without installing GTK, then looks
+      # in the location where the file is installed.
+      pixbuf = nil
+      begin
+        filename = Demo.find_file('gtk-logo-rgb.gif')
+        pixbuf = Gdk::Pixbuf.new(filename)
+      rescue
+        # This code shows off error handling. You can just use
+        # Gtk::Image.new instead if you don't want to report
+        # errors to the user. If the file doesn't load when using
+        # Gtk::Image.new, a 'missing image' icon will
+        # be displayed instead.
+        dialog = Gtk::MessageDialog.new(self,
+                                        Gtk::Dialog::DESTROY_WITH_PARENT,
+                                        Gtk::MessageDialog::ERROR,
+                                        Gtk::MessageDialog::BUTTONS_CLOSE,
+                                        "Unable to open image file 'gtk-logo-rgb.gif': #{$1}")
+
+        dialog.signal_connect('response') do |widget, data|
+          widget.destroy
+        end
+        dialog.show
+      end
+
+      image = Gtk::Image.new(pixbuf)
+      frame.add(image)
+
+
+      # Animation
+      label = Gtk::Label.new
+      label.set_markup('<u>Animation loaded from a file</u>')
+      vbox.pack_start(label, :expand => false, :fill => false, :padding => 0)
+
+      frame = Gtk::Frame.new
+      frame.shadow_type = :in
+
+      # The alignment keeps the frame from growing when users resize
+      # the window
+      align = Gtk::Alignment.new(0.5, 0.5, 0, 0)
+      align.add(frame)
+      vbox.pack_start(align, :expand => false, :fill => false, :padding => 0)
+
+      filename = Demo.find_file('floppybuddy.gif')
+      image = Gtk::Image.new(filename)
+      frame.add(image)
+
+
+      # Progressive
+      label = Gtk::Label.new
+      label.set_markup('<u>Progressive image loading</u>')
+      vbox.pack_start(label, :expand => false, :fill => false, :padding => 0)
+
+      frame = Gtk::Frame.new(nil)
+      frame.shadow_type = :in
+
+      # The alignment keeps the frame from growing when users resize
+      # the window
+      align = Gtk::Alignment.new(0.5, 0.5, 0, 0)
+      align.add(frame)
+      vbox.pack_start(align, :expand => false, :fill => false, :padding => 0)
+
+      # Create an empty image for now; the progressive loader
+      # will create the pixbuf and fill it in.
+      image = Gtk::Image.new
+      frame.add(image)
+
+      start_progressive_loading(image)
+
+      # Sensitivity control
+      button = Gtk::ToggleButton.new('_Insensitive', true)
+      vbox.pack_start(button, :expand => false, :fill => false, :padding => 0)
+
+      button.signal_connect('toggled') do |widget|
+        vbox.children.each do |widget|
+          if widget != button
+            widget.sensitive = ! button.active?
+          end
+        end
+      end
+    end
+
+    def start_progressive_loading(image)
+      @load_timeout = Gtk.timeout_add(150) do
+        progressive_timeout(image)
+      end
+    end
+
+    def progressive_timeout(image)
+      if @image_stream
+        buf = @image_stream.read(256)
+
+        @pixbuf_loader.write(buf)
+
+        if @image_stream.eof?
+          @image_stream.close
+          @image_stream = nil
+
+          @pixbuf_loader.close
+          @pixbuf_loader = nil
+        end
+      else
+        filename = Demo.find_file('alphatest.png')
+        @image_stream = File.open(filename, 'rb')
+
+        if @pixbuf_loader != nil
+          @pixbuf_loader.close
+          @pixbuf_loader = nil
+        end
+
+        @pixbuf_loader = Gdk::PixbufLoader.new
+
+        @pixbuf_loader.signal_connect('area_prepared') do |loader|
+          pixbuf = loader.pixbuf
+
+          # Avoid displaying random memory contents, since the pixbuf
+          # isn't filled in yet.
+          pixbuf.fill!(0xaaaaaaff)
+
+          image.pixbuf = pixbuf
+        end
+
+        @pixbuf_loader.signal_connect('area_updated') do
+          # We know the pixbuf inside the Gtk::Image has changed, but the image
+          # itself doesn't know this; so queue a redraw.  If we wanted to be
+          # really efficient, we could use a drawing area or something
+          # instead of a Gtk::Image, so we could control the exact position of
+          # the pixbuf on the display, then we could queue a draw for only
+          # the updated area of the image.
+          image.queue_draw
+        end
+      end
+
+      # leave timeout installed
+      return true
+    end
+
+    def cleanup_callback
+      @pixbuf_loader.close if @pixbuf_loader
+      @pixbuf_loader = nil
+      if @load_timeout != 0
+        Gtk.timeout_remove(@load_timeout)
+      end
+    end
+  end
+end

data/sample/gtk-demo/infobar.rb

@@ -0,0 +1,78 @@
+# Copyright (c) 2013 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+=begin
+= Info bar
+
+Info bar widgets are used to report important messages to the user.
+=end
+require 'common'
+
+module Demo
+  class InfoBar < BasicWindow
+    def initialize
+      super('Info Bars')
+
+      self.border_width = 8
+
+
+      vbox = Gtk::Box.new :vertical
+      self.add vbox
+
+      bar = Gtk::InfoBar.new
+      vbox.pack_start bar, :expand => false, :fill => false, :padding => 0
+      bar.message_type = :info
+      label = Gtk::Label.new 'This is an info bar with message type GTK_MESSAGE_INFO'
+      bar.content_area.pack_start label, :expand => false, :fill => false, :padding => 0
+
+      bar = Gtk::InfoBar.new
+      vbox.pack_start bar, :expand => false, :fill => false, :padding => 0
+      bar.message_type = :warning
+      label = Gtk::Label.new 'This is an info bar with message type GTK_MESSAGE_WARNING'
+      bar.content_area.pack_start label, :expand => false, :fill => false, :padding => 0
+
+      bar = Gtk::InfoBar.new [:ok, :ok]
+      bar.signal_connect(:response) {|widget, response_id| on_bar_response widget, response_id}
+      vbox.pack_start bar, :expand => false, :fill => false, :padding => 0
+      bar.message_type = :question
+      label = Gtk::Label.new 'This is an info bar with message type GTK_MESSAGE_QUESTION'
+      bar.content_area.pack_start label, :expand => false, :fill => false, :padding => 0
+
+      bar = Gtk::InfoBar.new
+      vbox.pack_start bar, :expand => false, :fill => false, :padding => 0
+      bar.message_type = :error
+      label = Gtk::Label.new 'This is an info bar with message type GTK_MESSAGE_ERROR'
+      bar.content_area.pack_start label, :expand => false, :fill => false, :padding => 0
+
+      bar = Gtk::InfoBar.new
+      vbox.pack_start bar, :expand => false, :fill => false, :padding => 0
+      bar.message_type = :other
+      label = Gtk::Label.new 'This is an info bar with message type GTK_MESSAGE_OTHER'
+      bar.content_area.pack_start label, :expand => false, :fill => false, :padding => 0
+
+
+      frame = Gtk::Frame.new 'Info bars'
+      vbox.pack_start frame, :expand => false, :fill => false, :padding => 8
+
+      vbox2 = Gtk::Box.new :vertical, 8
+      vbox2.border_width = 8
+      frame.add vbox2
+
+      # Standard message dialog
+      label = Gtk::Label.new 'An example of different info bars'
+      vbox2.pack_start label, :expand => false, :fill => false, :padding => 0
+    end
+
+    def on_bar_response info_bar, response_id
+      dialog = Gtk::MessageDialog.new :parent => self,
+                                      :flags => [:modal, :destroy_with_parent],
+                                      :type => :info,
+                                      :buttons_type => :ok,
+                                      :message => 'You clicked a button on an info bar'
+
+      dialog.set_secondary_text "Your response has id %d" % response_id
+      dialog.signal_connect(:response) {dialog.destroy}
+      dialog.show_all
+    end
+  end
+end

data/sample/gtk-demo/item_factory.rb

@@ -0,0 +1,94 @@
+# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+# $Id: item_factory.rb,v 1.4 2005/02/12 23:02:43 kzys Exp $
+=begin
+= Item Factory
+
+The Gtk::ItemFactory object allows the easy creation of menus
+from an array of descriptions of menu items.
+=end
+require 'common'
+
+module Demo
+  class ItemFactory < BasicWindow
+    def initialize
+      super('Item Factory')
+
+      accel_group = Gtk::AccelGroup.new
+      item_factory = Gtk::ItemFactory.new(Gtk::ItemFactory::TYPE_MENU_BAR,
+                                          '<main>', accel_group)
+
+      add_accel_group(accel_group)
+      set_border_width(0)
+      ifactory_cb = proc do |data, widget|
+        puts "ItemFactory: activated \"#{Gtk::ItemFactory.path_from_widget(widget)}\""
+      end
+      menu_items = [
+        ['/_File'],
+        ['/File/tearoff1',
+          '<Tearoff>', nil, nil, ifactory_cb],
+        ['/File/_New',
+          '<Item>', '<control>N', nil, ifactory_cb],
+        ['/File/_Open',
+          '<Item>', '<control>O', nil, ifactory_cb],
+        ['/File/_Save',
+          '<Item>', '<control>S', nil, ifactory_cb],
+        ['/File/Save _As...',
+          '<Item>', nil, nil, ifactory_cb],
+        ['/File/sep1', '<Separator>'],
+        ['/File/_Quit',
+          '<Item>', '<control>Q', nil, ifactory_cb],
+
+        ['/_Preferences'],
+        ['/_Preferences/_Color'],
+        [ '/_Preferences/Color/_Red',
+          '<RadioItem>', nil, nil, ifactory_cb],
+        ['/_Preferences/Color/_Green',
+          '/Preferences/Color/Red', nil, nil, ifactory_cb],
+        ['/_Preferences/Color/_Blue',
+          '/Preferences/Color/Red', nil, nil, ifactory_cb],
+        ['/_Preferences/_Shape'],
+        ['/_Preferences/Shape/_Square',
+          '<RadioItem>', nil, nil, ifactory_cb],
+        [ '/_Preferences/Shape/_Rectangle',
+          '/Preferences/Shape/Square', nil, nil, ifactory_cb],
+        [ '/_Preferences/Shape/_Oval',
+          '/Preferences/Shape/Rectangle', nil, nil, ifactory_cb],
+
+        [ '/_Help', '<LastBranch>'],
+        [ '/Help/_About', '<Item>', nil, nil, ifactory_cb],
+      ]
+      item_factory.create_items(menu_items)
+
+      item_factory.get_item('/Preferences/Shape/Oval').set_active(true)
+
+      box1 = Gtk::VBox.new(false, 0)
+      add(box1)
+
+      box1.pack_start(item_factory.get_widget('<main>'), :expand => false, :fill => false, :padding => 0)
+
+      label = Gtk::Label.new("Type\n<alt>\nto start")
+      label.set_size_request(200, 200)
+      label.set_alignment(0.5, 0.5)
+      box1.pack_start(label, :expand => true, :fill => true, :padding => 0)
+
+      separator = Gtk::HSeparator.new
+      box1.pack_start(separator)
+
+
+      box2 = Gtk::VBox.new(false, 10)
+      box2.set_border_width(10)
+      box1.pack_start(box2, :expand => false, :fill => true, :padding => 0)
+
+      button = Gtk::Button.new('close')
+      # TODO: Need signal_connect_swapped?
+      button.signal_connect('clicked') do
+        quit
+      end
+      box2.pack_start(button, :expand => true, :fill => true, :padding => 0)
+      button.set_flags(Gtk::Widget::CAN_DEFAULT)
+      button.grab_default
+    end
+  end
+end

data/sample/gtk-demo/links.rb

@@ -0,0 +1,53 @@
+# Copyright (c) 2013 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+=begin
+= Links
+
+GtkLabel can show hyperlinks. The default action is to call gtk_show_uri() on their URI, but it is possible to override this with a custom handler.
+=end
+require 'common'
+
+module Demo
+  class Links < BasicWindow
+    def initialize
+      super('Links')
+
+      title = 'Links'
+      border_width = 12
+      signal_connect(:destroy) {self.destroy}
+
+      label = Gtk::Label.new "Some <a href=\"http://en.wikipedia.org/wiki/Text\"" +
+                             "title=\"plain text\">text</a> may be marked up\n" +
+                             "as hyperlinks, which can be clicked\n" +
+                             "or activated via <a href=\"keynav\">keynav</a>\n" +
+                             "and they work fine with other markup, like when\n" +
+                             "searching on <a href=\"http://www.google.com/\">" +
+                             "<span color=\"#0266C8\">G</span><span color=\"#F90101\">o</span>" +
+                             "<span color=\"#F2B50F\">o</span><span color=\"#0266C8\">g</span>" +
+                             "<span color=\"#00933B\">l</span><span color=\"#F90101\">e</span>" +
+                             "</a>."
+      label.use_markup = true
+      label.signal_connect(:activate_link) {|widget, uri| activate_link uri}
+      add label
+      label.show
+    end
+
+    def activate_link uri
+      if uri == 'keynav'
+        dialog = Gtk::MessageDialog.new :parent => self,
+                   :flags => :destroy_with_parent,
+                   :type => :info,
+                   :buttons_type => :ok
+
+        dialog.markup = "The term <i>keynav</i> is a shorthand for " +
+                        "keyboard navigation and refers to the process of using " +
+                        "a program (exclusively) via keyboard input."
+        dialog.present
+        dialog.signal_connect(:response) {dialog.destroy}
+        return true
+      end
+      false
+    end
+  end
+end

data/sample/gtk-demo/list_store.rb

@@ -0,0 +1,138 @@
+# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+# $Id: list_store.rb,v 1.5 2005/02/06 18:25:13 kzys Exp $
+=begin
+= Tree View/List Store
+
+The Gtk::ListStore is used to store data in list form, to be used
+later on by a Gtk::TreeView to display it. This demo builds a
+simple Gtk::ListStore and displays it. See the Stock Browser
+demo for a more advanced example.
+=end
+require 'common'
+
+module Demo
+  class ListStore < BasicWindow
+    Bug = Struct.new('Bug', :fixed, :number, :severity, :description)
+    COLUMN_FIXED, COLUMN_NUMBER, COLUMN_SEVERITY, COLUMN_DESCRIPTION,
+      NUM_COLUMNS = *(0..5).to_a
+    DATA = [
+      [ false, 60482, 'Normal',     'scrollable notebooks and hidden tabs' ],
+      [ false, 60620, 'Critical',   'gdk_window_clear_area (gdkwindow-win32.c) is not thread-safe' ],
+      [ false, 50214, 'Major',      'Xft support does not clean up correctly' ],
+      [ true,  52877, 'Major',      'GtkFileSelection needs a refresh method. ' ],
+      [ false, 56070, 'Normal',     "Can't click button after setting in sensitive" ],
+      [ true,  56355, 'Normal',     'GtkLabel - Not all changes propagate correctly' ],
+      [ false, 50055, 'Normal',     'Rework width/height computations for TreeView' ],
+      [ false, 58278, 'Normal',     "gtk_dialog_set_response_sensitive  doesn't work" ],
+      [ false, 55767, 'Normal',     'Getters for all setters' ],
+      [ false, 56925, 'Normal',     'Gtkcalender size' ],
+      [ false, 56221, 'Normal',     'Selectable label needs right-click copy menu' ],
+      [ true,  50939, 'Normal',     'Add shift clicking to GtkTextView' ],
+      [ false, 6112,  'Enhancement','netscape-like collapsable toolbars' ],
+      [ false, 1,     'Normal',     'First bug :=)' ],
+    ].collect do |ary|
+      Bug.new(*ary)
+    end
+    def initialize
+      super('GtkListStore demo')
+      self.border_width = 8
+
+      vbox = Gtk::VBox.new(false, 8)
+      add(vbox)
+
+      label = Gtk::Label.new('This is the bug list (note: not based on real data, it would be nice to have a nice ODBC interface to bugzilla or so, though).')
+      vbox.pack_start(label, :expand => false, :fill => false, :padding => 0)
+
+      sw = Gtk::ScrolledWindow.new(nil, nil)
+      sw.shadow_type = Gtk::SHADOW_ETCHED_IN
+      sw.set_policy(Gtk::POLICY_NEVER, :automatic)
+      vbox.pack_start(sw, :expand => true, :fill => true, :padding => 0)
+
+      # create tree model
+      model = create_model
+
+      # create tree view
+      treeview = Gtk::TreeView.new(model)
+      treeview.rules_hint = true
+      treeview.search_column = COLUMN_DESCRIPTION
+
+      sw.add(treeview)
+
+      # add columns to the tree view
+      add_columns(treeview)
+
+      set_default_size(280, 250)
+    end
+
+    def create_model
+      # create list store
+      store = Gtk::ListStore.new(TrueClass, Integer, String, String)
+
+      # add data to the list store
+      DATA.each do |bug|
+        iter = store.append
+        bug.each_with_index do |value, index|
+          iter[index] = value
+        end
+      end
+      return store
+    end
+
+    def add_columns(treeview)
+      # column for fixed toggles
+      renderer = Gtk::CellRendererToggle.new
+      renderer.signal_connect('toggled') do |cell, path|
+        fixed_toggled(treeview.model, path)
+      end
+
+      column = Gtk::TreeViewColumn.new('Fixed?',
+                                       renderer,
+                                       'active' => COLUMN_FIXED)
+
+      # set this column to a fixed sizing (of 50 pixels)
+      column.sizing = Gtk::TreeViewColumn::FIXED
+      column.fixed_width = 50
+      treeview.append_column(column)
+
+      # column for bug numbers
+      renderer = Gtk::CellRendererText.new
+      column = Gtk::TreeViewColumn.new('Bug number',
+                                       renderer,
+                                       'text' => COLUMN_NUMBER)
+      column.set_sort_column_id(COLUMN_NUMBER)
+      treeview.append_column(column)
+
+      # column for severities
+      renderer = Gtk::CellRendererText.new
+      column = Gtk::TreeViewColumn.new('Severity',
+                                       renderer,
+                                       'text' => COLUMN_SEVERITY)
+      column.set_sort_column_id(COLUMN_SEVERITY)
+      treeview.append_column(column)
+
+      # column for description
+      renderer = Gtk::CellRendererText.new
+      column = Gtk::TreeViewColumn.new('Description',
+                                       renderer,
+                                       'text' => COLUMN_DESCRIPTION)
+      column.set_sort_column_id(COLUMN_DESCRIPTION)
+      treeview.append_column(column)
+    end
+
+    def fixed_toggled(model, path_str)
+      path = Gtk::TreePath.new(path_str)
+
+      # get toggled iter
+      iter = model.get_iter(path)
+      fixed =iter[COLUMN_FIXED]
+
+      # do something with the value
+      fixed ^= 1
+
+      # set new value
+      iter[COLUMN_FIXED] = fixed
+    end
+  end
+end