gtk3 0.0.1 → 1.2.0

data/sample/gtk-demo/printing.rb

@@ -0,0 +1,128 @@
+# Copyright (c) 2008 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+=begin
+= Printing
+
+Gtk::PrintOperation offers a simple API to support printing
+in a cross-platform way.
+=end
+
+require 'common'
+
+module Demo
+  class Printing < BasicWindow
+    Data = Struct.new(:font_size, :lines_per_page, :lines, :n_pages)
+    HEADER_HEIGHT = 10 * 72 / 25.4
+    HEADER_GAP = 3 * 72 / 25.4
+
+    def initialize
+      super('Printing')
+
+      button = Gtk::Button.new("Print...")
+      button.signal_connect("clicked") do
+        begin
+          run_print_operation
+        rescue
+          dialog = Gtk::MessageDialog.new(self, :destroy_with_parent, :error,
+                                          :close, $!.message)
+          dialog.signal_connect("response") do
+            dialog.destroy
+            true
+          end
+          dialog.show
+        end
+        true
+      end
+      add(button)
+    end
+
+    private
+    def run_print_operation
+      operation = Gtk::PrintOperation.new
+
+      data = Data.new
+      data.font_size = 12.0
+      operation.signal_connect("begin-print") do |_operation, context|
+        on_begin_print(_operation, context, data)
+      end
+      operation.signal_connect("draw-page") do |_operation, context, page_number|
+        on_draw_page(_operation, context, page_number, data)
+      end
+      operation.signal_connect("end-print") do |_operation, context|
+        on_end_print(_operation, context, data)
+      end
+
+      operation.use_full_page = false
+      operation.unit = :points
+
+      operation.run(:print_dialog, self)
+    end
+
+    def on_begin_print(operation, context, data)
+      height = context.height - HEADER_HEIGHT - HEADER_GAP
+      data.lines_per_page = (height / data.font_size).floor
+      data.lines = File.readlines(__FILE__)
+      data.n_pages = (data.lines.size - 1) / data.lines_per_page + 1
+      operation.set_n_pages(data.n_pages)
+    end
+
+    def on_draw_page(operation, context, page_number, data)
+      cr = context.cairo_context
+      draw_header(cr, operation, context, page_number, data)
+      draw_body(cr, operation, context, page_number, data)
+    end
+
+    def draw_header(cr, operation, context, page_number, data)
+      width = context.width
+
+      cr.rectangle(0, 0, width, HEADER_HEIGHT)
+      cr.set_source_rgb(0.8, 0.8, 0.8)
+      cr.fill_preserve
+
+      cr.set_source_rgb(0, 0, 0)
+      cr.line_width = 1
+      cr.stroke
+
+      layout = context.create_pango_layout
+      layout.font_description = "sans 14"
+
+      layout.text = File.basename(__FILE__)
+      text_width, text_height = layout.pixel_size
+
+      if (text_width > width)
+        layout.width = width
+        layout.ellipsize = :start
+        text_width, text_height = layout.pixel_size
+      end
+
+      y = (HEADER_HEIGHT - text_height) / 2
+
+      cr.move_to((width - text_width) / 2, y)
+      cr.show_pango_layout(layout)
+
+      layout.text = "#{page_number + 1}/#{data.n_pages}"
+      layout.width = -1
+      text_width, text_height = layout.pixel_size
+      cr.move_to(width - text_width - 4, y)
+      cr.show_pango_layout(layout)
+    end
+
+    def draw_body(cr, operation, context, page_number, data)
+      layout = context.create_pango_layout
+      description = Pango::FontDescription.new("monosapce")
+      description.size = data.font_size * Pango::SCALE
+      layout.font_description = description
+
+      cr.move_to(0, HEADER_HEIGHT + HEADER_GAP)
+      start_line = page_number * data.lines_per_page
+      data.lines[start_line, data.lines_per_page].each do |line|
+        layout.text = line
+        cr.show_pango_layout(layout)
+        cr.rel_move_to(0, data.font_size)
+      end
+    end
+
+    def on_end_print(operation, context, data)
+    end
+  end
+end

data/sample/gtk-demo/rotated_text.rb

@@ -0,0 +1,84 @@
+# Copyright (c) 2005 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 GDK and Pango to draw rotated and transformed text. 
+The use of Gdk::PangoRenderer in this example is a somewhat advanced technique; most applications can simply use Gdk::Drawable#draw_layout. 
+We use it here mostly because that allows us to work in user coordinates - that is, coordinates prior to the application of the transformation matrix, rather than device coordinates.
+As of GTK+-2.6, the ability to draw transformed and anti-aliased graphics as shown in this example is only present for text. 
+With GTK+-2.8, a new graphics system called "Cairo" will be introduced that provides these capabilities and many more for all types of graphics.
+=end
+require 'common'
+
+module Demo
+  class RotatedText < BasicWindow
+    RADIUS = 150
+    N_WORDS = 10
+    FONT = "Sans Bold 27"
+
+    def initialize
+      super('Rotated Text')
+
+      unless Gtk.check_version?(2, 6, 0)
+         add(Gtk::Label.new("This sample requires GTK+ 2.6.0 or later"))
+         return
+      end
+
+      drawing_area = Gtk::DrawingArea.new
+      add(drawing_area)
+      drawing_area.modify_bg(Gtk::STATE_NORMAL, Gdk::Color.new(65535, 65535, 65535))
+
+      drawing_area.signal_connect("expose_event") do
+	matrix = Pango::Matrix.new
+
+	# Get the default renderer for the screen, and set it up for drawing
+	renderer = Gdk::PangoRenderer.get_default(drawing_area.screen)
+	renderer.drawable = drawing_area.window
+	renderer.gc = style.black_gc
+	width = drawing_area.allocation.width
+	height = drawing_area.allocation.height
+
+	# Set up a transformation matrix so that the user space coordinates for
+	# the centered square where we draw are [-RADIUS, RADIUS], [-RADIUS, RADIUS]
+	# We first center, then change the scale
+	device_radius = [width, height].min / 2.0
+
+	matrix.translate!(device_radius + (width - 2 * device_radius) / 2.0,
+			  device_radius + (height - 2 * device_radius) / 2.0)
+	matrix.scale!(device_radius / RADIUS, device_radius / RADIUS)
+
+	# Create a PangoLayout, set the font and text
+	context = Gdk::Pango.context
+	layout = Pango::Layout.new(context)
+	layout.text = "Text"
+	layout.font_description = Pango::FontDescription.new(FONT)
+
+	# Draw the layout N_WORDS times in a circle
+	(0...N_WORDS).each do |i|
+	  rotated_matrix = matrix.dup
+	  angle = 360 * i / N_WORDS.to_f
+
+	  # Gradient from red at angle == 60 to blue at angle == 300
+	  red = 65535 * (1 + Math.cos((angle - 60) * Math::PI / 180.0)) / 2
+	  color = Gdk::Color.new(red, 0, 65535 - red) 
+	  renderer.set_override_color(Pango::Renderer::PART_FOREGROUND, color)
+
+	  rotated_matrix.rotate!(angle)
+	  context.matrix = rotated_matrix
+
+	  # Inform Pango to re-layout the text with the new transformation matrix
+	  layout.context_changed
+	  width, height = layout.size
+	  renderer.draw_layout(layout, - width / 2, - RADIUS * Pango::SCALE)
+	end
+	# Clean up default renderer, since it is shared
+	renderer.set_override_color(Gdk::PangoRenderer::PART_FOREGROUND, nil)
+	renderer.drawable = nil
+	renderer.gc = nil
+      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, true, true, 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, true, true, 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, false, false, 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, false, false, 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/stock_browser.rb

@@ -0,0 +1,235 @@
+# 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::HBox.new(false, 8)
+      add(hbox)
+
+      sw = Gtk::ScrolledWindow.new
+      sw.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC)
+      hbox.pack_start(sw, false, false, 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, false)
+      column.set_attributes(cell_renderer, "stock_id" => 1)
+
+      cell_renderer = Gtk::CellRendererText.new
+      column.pack_start(cell_renderer, 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, false, false, 0)
+
+      frame = Gtk::Frame.new('Selected Item')
+      align.add(frame)
+
+      vbox = Gtk::VBox.new(false, 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, false, false, 0)
+
+      vbox.pack_start(display.icon_image, false, false, 0)
+
+      vbox.pack_start(display.label_accel_label, false, false, 0)
+      vbox.pack_start(display.const_label, false, false, 0)
+      vbox.pack_start(display.id_label, false, false, 0)
+
+      selection = treeview.selection
+      selection.mode = Gtk::SELECTION_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 == Gtk::IconSize::MENU end || sizes.first
+
+	  info.small_icon = render_icon(info.id, size, '')
+
+	  unless size == Gtk::IconSize::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(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 = Gtk::IconSize::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