gtk3 2.2.4-x64-mingw32

data/sample/gtk-demo/reset.css

@@ -0,0 +1,69 @@
+/* @import this colorsheet to get the default values for every property.
+ * This is useful when writing special CSS tests that should not be
+ * inluenced by themes - not even the default ones.
+ * Keep in mind that the output will be very ugly and not look like
+ * anything GTK.
+ * Also, when adding new style properties, please add them here.
+ */
+
+* {
+  color: inherit;
+  font-size: inherit;
+  background-color: initial;
+  font-family: inherit;
+  font-style: inherit;
+  font-variant: inherit;
+  font-weight: inherit;
+  text-shadow: inherit;
+  icon-shadow: inherit;
+  box-shadow: initial;
+  margin-top: initial;
+  margin-left: initial;
+  margin-bottom: initial;
+  margin-right: initial;
+  padding-top: initial;
+  padding-left: initial;
+  padding-bottom: initial;
+  padding-right: initial;
+  border-top-style: initial;
+  border-top-width: initial;
+  border-left-style: initial;
+  border-left-width: initial;
+  border-bottom-style: initial;
+  border-bottom-width: initial;
+  border-right-style: initial;
+  border-right-width: initial;
+  border-top-left-radius: initial;
+  border-top-right-radius: initial;
+  border-bottom-right-radius: initial;
+  border-bottom-left-radius: initial;
+  outline-style: initial;
+  outline-width: initial;
+  outline-offset: initial;
+  background-clip: initial;
+  background-origin: initial;
+  background-size: initial;
+  background-position: initial;
+  border-top-color: initial;
+  border-right-color: initial;
+  border-bottom-color: initial;
+  border-left-color: initial;
+  outline-color:  initial;
+  background-repeat: initial;
+  background-image: initial;
+  border-image-source: initial;
+  border-image-repeat: initial;
+  border-image-slice: initial;
+  border-image-width: initial;
+  transition-property: initial;
+  transition-duration: initial;
+  transition-timing-function: initial;
+  transition-delay: initial;
+  engine: initial;
+  gtk-key-bindings: initial;
+
+  -GtkWidget-focus-line-width: 0;
+  -GtkWidget-focus-padding: 0;
+  -GtkNotebook-initial-gap: 0;
+}
+

data/sample/gtk-demo/rotated_text.rb

@@ -0,0 +1,72 @@
+# Copyright (c) 2005-2014  Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+# $Id: rotated_text.rb,v 1.2 2005/03/05 15:01:16 mutoh Exp $
+=begin
+= Rotated Text
+
+This demo shows how to use Cairo and Pango to draw rotated and transformed text.
+=end
+require "common"
+
+module Demo
+  class RotatedText < BasicWindow
+    RADIUS = 150
+    N_WORDS = 10
+    FONT = "Sans Bold 27"
+
+    def initialize
+      super("Rotated Text")
+
+      drawing_area = Gtk::DrawingArea.new
+      add(drawing_area)
+      drawing_area.override_background_color(:normal, Gdk::RGBA.new(1.0,
+                                                                    1.0,
+                                                                    1.0,
+                                                                    0.0))
+
+      drawing_area.signal_connect("draw") do |_drawing_area, cairo_context|
+        cairo_context.set_source_rgb(1.0, 1.0, 1.0)
+        cairo_context.paint
+        cairo_context.save do
+          width, height = size
+          cairo_context.scale(width.to_f / (RADIUS * 2),
+                              height.to_f / (RADIUS * 2))
+          draw_text(cairo_context)
+        end
+      end
+    end
+
+    private
+    def draw_text(cairo_context)
+      # Center coordinates on the middle of the region we are drawing
+      cairo_context.translate(RADIUS, RADIUS)
+
+      # Create a PangoLayout, set the font and text
+      layout = cairo_context.create_pango_layout
+
+      layout.text = "Text"
+      layout.font_description = Pango::FontDescription.new(FONT)
+
+      # Draw the layout N_WORDS times in a circle
+      N_WORDS.times do |i|
+        angle = (360.0 * i) / N_WORDS
+
+        cairo_context.save do
+          # Gradient from red at angle == 60 to blue at angle == 240
+          red = (1 + Math.cos((angle - 60) * Math::PI / 180.0)) / 2
+          cairo_context.set_source_rgb(red, 0.0, 1.0 - red)
+
+          cairo_context.rotate(angle * Math::PI / 180.0)
+
+          # Inform Pango to re-layout the text with the new transformation
+          cairo_context.update_pango_layout(layout)
+
+          width, height = layout.size
+          cairo_context.move_to(-(width / Pango::SCALE) / 2, -RADIUS)
+          cairo_context.show_pango_layout(layout)
+        end
+      end
+    end
+  end
+end

data/sample/gtk-demo/sizegroup.rb

@@ -0,0 +1,118 @@
+# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+# $Id: sizegroup.rb,v 1.5 2005/02/12 23:02:43 kzys Exp $
+=begin
+= Size Groups
+
+Gtk::SizeGroup provides a mechanism for grouping a number of
+widgets together so they all request the same amount of space.
+This is typically useful when you want a column of widgets to
+have the same size, but you can't use a Gtk::Table widget.
+
+Note that size groups only affect the amount of space requested,
+not the size that the widgets finally receive. If you want the
+widgets in a Gtk::SizeGroup to actually be the same size, you need
+to pack them in such a way that they get the size they request
+and not more. For example, if you are packing your widgets
+into a table, you would not include the Gtk::FILL flag.
+=end
+require 'common'
+
+module Demo
+  class SizeGroup < Gtk::Dialog
+    def initialize
+      super('GtkSizeGroup', nil, 0,
+            [Gtk::Stock::CLOSE, Gtk::Dialog::RESPONSE_NONE])
+
+      color_options = %w(Red Green Blue)
+      dash_options = %w(Solid Dashed Dotted)
+      end_options = %w(Square Round Arrow)
+
+      set_resizable(false)
+
+      signal_connect('response') do
+        destroy
+      end
+
+      vbox = Gtk::VBox.new(false, 5)
+      self.vbox.pack_start(vbox, :expand => true, :fill => true, :padding => 0)
+      vbox.set_border_width(5)
+
+      size_group = Gtk::SizeGroup.new(Gtk::SizeGroup::HORIZONTAL)
+
+      ## Create one frame holding color options
+      frame = Gtk::Frame.new('Color Options')
+      vbox.pack_start(frame, :expand => true, :fill => true, :padding => 0)
+
+      table = Gtk::Table.new(2, 2, false)
+      table.set_border_width(5)
+      table.set_row_spacings(5)
+      table.set_column_spacings(10)
+      frame.add(table)
+
+      add_row(table, 0, size_group, '_Foreground', color_options)
+      add_row(table, 1, size_group, '_Background', color_options)
+
+      ## And another frame holding line style options
+      frame = Gtk::Frame.new('Line Options')
+      vbox.pack_start(frame, :expand => false, :fill => false, :padding => 0)
+
+      table = Gtk::Table.new(2, 2, false)
+      table.set_border_width(5)
+      table.set_row_spacings(5)
+      table.set_column_spacings(10)
+      frame.add(table)
+
+      add_row(table, 0, size_group, '_Dashing', dash_options)
+      add_row(table, 1, size_group, '_Line ends', end_options)
+
+      # And a check button to turn grouping on and off
+      check_button = Gtk::CheckButton.new('_Enable grouping', true)
+      vbox.pack_start(check_button, :expand => false, :fill => false, :padding => 0)
+
+      check_button.set_active(true)
+      check_button.signal_connect('toggled', size_group) do |check_button, size_group|
+        new_mode = if check_button.active?
+                     Gtk::SizeGroup::HORIZONTAL
+                   else
+                     Gtk::SizeGroup::VERTICAL
+                   end
+        size_group.set_mode(new_mode)
+      end
+    end
+
+    def add_row(table, row, size_group, label_text, options)
+      label = Gtk::Label.new(label_text, true)
+      label.set_alignment(0, 1)
+      table.attach(label,
+                   0, 1,                    row, row + 1,
+                   Gtk::EXPAND | Gtk::FILL, 0,
+                   0,                       0)
+
+      option_menu = create_option_menu(options)
+      label.set_mnemonic_widget(option_menu)
+      size_group.add_widget(option_menu)
+      table.attach(option_menu,
+                   1, 2,                    row, row + 1,
+                   0,                       0,
+                   0,                       0)
+    end
+
+    def create_option_menu(strings)
+      menu = Gtk::Menu.new
+
+      strings.each do |str|
+        menu_item = Gtk::MenuItem.new(str)
+        menu_item.show
+
+        menu.append(menu_item)
+      end
+
+      option_menu = Gtk::OptionMenu.new
+      option_menu.set_menu(menu)
+
+      return option_menu
+    end
+  end
+end

data/sample/gtk-demo/spinner.rb

@@ -0,0 +1,59 @@
+# Copyright (c) 2013 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+=begin
+= Spinner
+
+GtkSpinner allows to show that background activity is on-going.
+=end
+require 'common'
+
+module Demo
+  class Spinner < Gtk::Dialog
+    def initialize
+      super(:title => 'Spinner',
+            :parent => nil,
+            :flags => nil,
+            :buttons => [[:close, :none]])
+
+      signal_connect(:response) {self.destroy}
+      signal_connect(:destroy) {self.destroy}
+
+      self.resizable = false
+
+      vbox = Gtk::Box.new :vertical, 5
+
+      self.content_area.pack_start vbox, :expand => true, :fill => true, :padding => 0
+      vbox.border_width = 5
+
+      # Sensitive
+      hbox = Gtk::Box.new :horizontal, 5
+      @spinner_sensitive = Gtk::Spinner.new
+      hbox.add @spinner_sensitive
+      hbox.add Gtk::Entry.new
+      vbox.add hbox
+
+      # Disabled
+      hbox = Gtk::Box.new :horizontal, 5
+      @spinner_insensitive = Gtk::Spinner.new
+      hbox.add @spinner_insensitive
+      hbox.add Gtk::Entry.new
+      vbox.add hbox
+      hbox.sensitive = false
+
+      button = Gtk::Button.new :stock_id => :media_play
+      button.signal_connect(:clicked) do
+        @spinner_sensitive.start
+        @spinner_insensitive.start
+      end
+      vbox.add button
+
+      button = Gtk::Button.new :stock_id => :media_stop
+      button.signal_connect(:clicked) do
+        @spinner_sensitive.stop
+        @spinner_insensitive.stop
+      end
+      vbox.add button
+    end
+  end
+end

data/sample/gtk-demo/stock_browser.rb

@@ -0,0 +1,233 @@
+# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+# $Id: stock_browser.rb,v 1.5 2005/02/12 23:02:43 kzys Exp $
+=begin
+= Stock Item and Icon Browser
+
+This source code for this demo doesn't demonstrate anything
+particularly useful in applications. The purpose of the 'demo' is
+just to provide a handy place to browse the available stock icons
+and stock items.
+=end
+require 'common'
+
+module Demo
+  class StockBrowser < BasicWindow
+    Item = Struct.new('Item',
+      :stock_id, :label, :modifier, :keyval, :translation_domain)
+    ItemInfo = Struct.new('ItemInfo',
+      :id, :item, :small_icon, :const, :accel_str)
+    ItemDisplay = Struct.new('ItemDisplay',
+      :type_label, :const_label, :id_label, :label_accel_label,
+      :icon_image)
+
+    def initialize
+      super('Stock Icons and Items')
+      set_default_size(-1, 500)
+
+      self.border_width = 8
+
+      hbox = Gtk::Box.new(:horizontal, 8)
+      add(hbox)
+
+      sw = Gtk::ScrolledWindow.new
+      sw.set_policy(:never, :automatic)
+      hbox.pack_start(sw, :expand => false, :fill => false, :padding => 0)
+
+      model = create_model
+
+      treeview = Gtk::TreeView.new(model)
+      sw.add(treeview)
+
+      column = Gtk::TreeViewColumn.new
+      column.title = 'Const'
+
+      cell_renderer = Gtk::CellRendererPixbuf.new
+      column.pack_start(cell_renderer, :expand => false)
+      column.set_attributes(cell_renderer, "stock_id" => 1)
+
+      cell_renderer = Gtk::CellRendererText.new
+      column.pack_start(cell_renderer, :expand => true)
+      column.set_cell_data_func(cell_renderer) do |column, cell, model, iter|
+        cell.text = iter[0].const
+      end
+
+      treeview.append_column(column)
+
+      cell_renderer = Gtk::CellRendererText.new
+      treeview.insert_column(-1, 'Label', cell_renderer) do |col, cell, model, iter|
+        info = iter[0]
+        cell.text = info.item.label if info
+      end
+
+      cell_renderer = Gtk::CellRendererText.new
+      treeview.insert_column(-1, 'Accel', cell_renderer) do |col, cell, model, iter|
+        info = iter[0]
+        cell.text = info.accel_str if info
+      end
+
+      cell_renderer = Gtk::CellRendererText.new
+      treeview.insert_column(-1, 'ID', cell_renderer) do |col, cell, model, iter|
+        info = iter[0]
+        cell.text = info.id if info
+      end
+
+      align = Gtk::Alignment.new(0.5, 0.0, 0.0, 0.0)
+      hbox.pack_end(align, :expand => false, :fill => false, :padding => 0)
+
+      frame = Gtk::Frame.new('Selected Item')
+      align.add(frame)
+
+      vbox = Gtk::Box.new(:vertical, 8)
+      vbox.border_width = 4
+      frame.add(vbox)
+
+      display = ItemDisplay.new
+      class << treeview
+        @display = nil
+        attr_accessor :display
+      end
+      treeview.display = display
+
+      display.type_label = Gtk::Label.new
+      display.const_label = Gtk::Label.new
+      display.id_label = Gtk::Label.new
+      display.label_accel_label = Gtk::Label.new
+      display.icon_image = Gtk::Image.new # empty image
+
+      vbox.pack_start(display.type_label, :expand => false, :fill => false, :padding => 0)
+
+      vbox.pack_start(display.icon_image, :expand => false, :fill => false, :padding => 0)
+
+      vbox.pack_start(display.label_accel_label, :expand => false, :fill => false, :padding => 0)
+      vbox.pack_start(display.const_label, :expand => false, :fill => false, :padding => 0)
+      vbox.pack_start(display.id_label, :expand => false, :fill => false, :padding => 0)
+
+      selection = treeview.selection
+      selection.mode = :single
+
+      selection.signal_connect('changed') do |s|
+        selection_changed(s)
+      end
+    end
+
+    def create_model
+      store = Gtk::ListStore.new(ItemInfo, String, String, String)
+
+      list_ids = Gtk::Stock.ids
+      list_ids.sort! do |a, b|
+        a.to_s <=> b.to_s
+      end
+      list_ids.each do |stock_id|
+        info = ItemInfo.new
+
+        info.id = stock_id
+
+        begin
+          info.item = Item.new(*Gtk::Stock.lookup(stock_id))
+        rescue ArgumentError
+          info.item = Item.new
+        end
+
+        # only show icons for stock IDs that have default icons
+        icon_set = Gtk::IconFactory.lookup_default(info.id.to_s)
+        if icon_set
+          # See what sizes this stock icon really exists at
+          sizes = icon_set.sizes
+
+          # Use menu size if it exists, otherwise first size found
+          size = sizes.find do |s| s == :menu end || sizes.first
+
+          info.small_icon = render_icon_pixbuf(info.id, size)
+
+          unless size == :menu
+            # Make the result the proper size for our thumbnail
+            w, h = Gtk::IconSize.lookup(size)
+
+            scaled = info.small_icon.scale(w, h, Gdk::Pixbuf::INTERP_BILINEAR)
+            info.small_icon = scaled
+          end
+
+        else
+          info.small_icon = nil
+        end
+
+        if info.item.keyval
+          info.accel_str = Gtk::Accelerator.to_name(info.item.keyval,
+                      info.item.modifier)
+        else
+          info.accel_str = ''
+        end
+
+        info.const = id_to_const(info.id)
+
+        iter = store.append
+        iter[0] = info
+        iter[1] = info.id
+      end
+
+      return store
+    end
+
+    def selection_changed(selection)
+      treeview = selection.tree_view
+      display = treeview.display
+
+      iter = selection.selected
+      info = iter[0]
+
+      display.type_label.label = if info.small_icon and info.item.label
+                                   'Icon and Item'
+                                 elsif info.small_icon
+                                   'Icon Only'
+                                 elsif info.item.label
+                                   'Item Only'
+                                 else
+                                   '???????'
+                                 end
+      display.const_label.label = info.const
+      display.id_label.label = info.id
+
+      if info.item.label
+        str = "%s %s" % [info.item.label, info.accel_str]
+        display.label_accel_label.set_text(str, true)
+      else
+        display.label_accel_label.set_text('')
+      end
+
+      if info.small_icon
+        display.icon_image.set_from_stock(info.id, get_largest_size(info.id))
+      else
+        display.icon_image.pixbuf = nil
+      end
+    end
+
+    def get_largest_size(symbol)
+      set = Gtk::IconFactory.lookup_default(symbol.id2name)
+      best_size = :invalid
+      best_pixels = 0
+
+      sizes = set.sizes
+      sizes.collect! do |i|
+        width, height = Gtk::IconSize.lookup(i)
+        [i, width * height]
+      end
+      return (sizes.max do |a, b| a[1] <=> b[1] end)[0]
+    end
+
+    def id_to_const(id)
+      const = ''
+
+      s = id.id2name
+      if s =~ /^gtk-/
+        const += 'Gtk::Stock::'
+        s[0,4] = ''
+      end
+
+      const += s.upcase.gsub(/-/, '_')
+
+      const
+    end
+  end
+end