gtk2 0.20.1 → 0.90.2

data/sample/gtk-demo/entry_completion.rb

@@ -0,0 +1,63 @@
+# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+# $Id: entry_completion.rb,v 1.3 2005/02/25 17:09:24 kzys Exp $
+=begin
+= Entry Completion (EntryCompletion)
+
+GtkEntryCompletion provides a mechanism for adding support for
+completion in GtkEntry.
+=end
+
+require 'common'
+
+module Demo
+  class EntryCompletion < Gtk::Dialog
+    def initialize
+      super('GtkEntryCompletion',
+	    nil, # parent
+	    0,
+	    [Gtk::Stock::CLOSE, Gtk::Dialog::RESPONSE_NONE])
+
+      self.resizable = false
+
+      signal_connect('response') do
+        self.destroy
+      end
+
+      vbox = Gtk::VBox.new(false, 5)
+      self.vbox.pack_start(vbox, true, true)
+      vbox.border_width = 5
+
+      label = Gtk::Label.new
+      label.markup = 'Completion demo, try writing <b>total</b> or <b>gnome</b> for example'
+      vbox.pack_start(label, false, false)
+
+      # Create our entry
+      entry = Gtk::Entry.new
+      vbox.pack_start(entry, false, false)
+
+      # Create the completion object
+      completion = Gtk::EntryCompletion.new
+
+      # Assign the completion to the entry
+      entry.completion = completion
+
+      # Create a tree model and use it as the completion model
+      completion.model = create_completion_model
+
+      # Use model column 0 as the text column
+      completion.text_column = 0
+    end
+
+
+    def create_completion_model
+      store = Gtk::ListStore.new(String)
+      %w(GNOME total totally).each do |word|
+        iter = store.append
+        iter[0] = word
+      end
+
+      store
+    end
+  end
+end

data/sample/gtk-demo/expander.rb

@@ -0,0 +1,40 @@
+# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+# $Id: expander.rb,v 1.2 2005/02/25 17:09:25 kzys Exp $
+=begin
+= Expander (Expander)
+
+GtkExpander allows to provide additional content that is initially hidden.
+This is also known as "disclosure triangle".
+=end
+
+require 'common'
+
+module Demo
+  class Expander < Gtk::Dialog
+    def initialize
+      super('GtkExpander',
+	    nil, # parent
+	    0,
+	    [Gtk::Stock::CLOSE, Gtk::Dialog::RESPONSE_NONE])
+      self.resizable = false
+
+      signal_connect('response') do
+        self.destroy
+      end
+
+      vbox = Gtk::VBox.new(false, 5)
+      self.vbox.pack_start(vbox, true, true)
+      vbox.border_width = 5
+
+      label = Gtk::Label.new('Expander demo. CLick on the triangle for details.')
+      vbox.pack_start(label, false, false)
+
+      # Create the expander
+      expander = Gtk::Expander.new('Details')
+      vbox.pack_start(expander, false, false)
+
+      expander.add(Gtk::Label.new('Details can be shown or hidden.'))
+    end
+  end
+end

data/sample/gtk-demo/hypertext.rb

@@ -0,0 +1,211 @@
+# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+# $Id: hypertext.rb,v 1.2 2005/12/01 09:27:01 ktou Exp $
+=begin
+= Text Widget/Hypertext
+
+Usually, tags modify the appearance of text in the view, e.g. making it
+bold or colored or underlined. But tags are not restricted to appearance.
+They can also affect the behavior of mouse and key presses, as this demo
+shows.
+=end
+
+require 'common'
+
+module Demo
+  class Hypertext < BasicWindow
+    def initialize
+      super('Hypertext')
+
+      @hand_cursor = Gdk::Cursor.new(Gdk::Cursor::HAND2)
+      @regular_cursor = Gdk::Cursor.new(Gdk::Cursor::XTERM)
+      @hovering = false
+
+      set_default_size(450, 450)
+      self.border_width = 0
+
+      view = Gtk::TextView.new
+
+      view.wrap_mode = Gtk::TextTag::WRAP_WORD
+
+      view.signal_connect('key-press-event') do |*args|
+        key_press_event(*args)
+      end
+      view.signal_connect('event-after') do |*args|
+        event_after(*args)
+      end
+      view.signal_connect('motion-notify-event') do |*args|
+        motion_notify_event(*args)
+      end
+      view.signal_connect('visibility-notify-event') do |*args|
+        visibility_notify_event(*args)
+      end
+
+      buffer = view.buffer
+
+      sw = Gtk::ScrolledWindow.new
+      sw.set_policy(Gtk::POLICY_AUTOMATIC,
+                    Gtk::POLICY_AUTOMATIC)
+
+      add(sw)
+      sw.add(view)
+
+      show_page(buffer, 1)
+    end
+
+
+    # Inserts a piece of text into the buffer, giving it the usual
+    # appearance of a hyperlink in a web browser: blue and underlined.
+    # Additionally, attaches some data on the tag, to make it recognizable
+    # as a link.
+    def insert_link(buffer, iter, text, page)
+      tag = buffer.create_tag(nil,
+                              {
+                                'foreground' => 'blue',
+                                'underline' => Pango::AttrUnderline::SINGLE,
+                              })
+      tag.page = page
+
+      buffer.insert(iter, text, tag)
+      print("Insert #{tag}:#{page}\n")
+    end
+
+    # Fills the buffer with text and interspersed links. In any real
+    # hypertext app, this method would parse a file to identify the links.
+    def show_page(buffer, page)
+      puts
+
+      buffer.text = ''
+      iter = buffer.get_iter_at_offset(0)
+
+      case page
+      when 1
+        buffer.insert(iter, 'Some text ot show that simple ')
+        insert_link(buffer, iter, 'hypertext', 3)
+        buffer.insert(iter, ' can easily be realized with ')
+        insert_link(buffer, iter, 'tags', 2)
+        buffer.insert(iter, '.')
+      when 2
+        buffer.insert(iter,
+                      %Q[A tag is an attribute that can be applied to some range of text. For example, a tag might be called "bold" and make the text insid the tag bold. However, the tag concept is more general than that; tags don't have to affect appearance. They can instead affect the behavior of mouse and key presses, "lock" a range of text so the user can't edit it, or countless other things.])
+        buffer.insert(iter, "\n")
+        insert_link(buffer, iter, 'Go back', 1)
+      when 3
+        tag = buffer.create_tag(nil,
+                                {
+                                  'weight' =>
+                                    Pango::FontDescription::WEIGHT_BOLD
+                                })
+        buffer.insert(iter, "hypertext:\n", tag);
+        buffer.insert(iter, %Q[machine-readable text that is not sequential but is organized so that related items of information are connected.\n])
+        insert_link(buffer, iter, 'Go back', 1)
+      end
+    end
+
+    # Looks at all tags covering the position of iter in the text view,
+    # and if one of them is a link, follow it by showing the page identified
+    # by the data attached to it.
+    def follow_if_link(text_view, iter)
+      tags = iter.tags
+      tags.each do |tag|
+        print("Follow #{tag}:#{tag.page}\n")
+        if tag.page
+          show_page(text_view.buffer, tag.page)
+          break
+        end
+      end
+    end
+
+    # Links can be activated by pressing Enter.
+    def key_press_event(text_view, event)
+      case event.keyval
+      when Gdk::Keyval::GDK_Return, Gdk::Keyval::GDK_KP_Enter
+        buffer = text_view.buffer
+        iter = buffer.get_iter_at_mark(buffer.get_mark("insert"))
+        follow_if_link(text_view, iter)
+      end
+
+      false
+    end
+
+    # Links can also be activated by clicking.
+    def event_after(text_view, event)
+      unless event.kind_of?(Gdk::EventButton) and event.button == 1
+        return false
+      end
+
+      buffer = text_view.buffer
+
+      # we shouldn't follow a link if the user has selected something
+      range = buffer.selection_bounds
+      if range and range[0].offset != range[1].offset
+        return false
+      end
+
+      x, y = text_view.window_to_buffer_coords(Gtk::TextView::WINDOW_WIDGET,
+                                               event.x, event.y)
+      iter = text_view.get_iter_at_location(x, y)
+
+      follow_if_link(text_view, iter)
+    end
+
+    # Looks at all tags covering the position (x, y) in the text view,
+    # and if one of them is a link, change the cursor to the "hands" cursor
+    # typically used by web browsers.
+    def set_cursor_if_appropriate(text_view, x, y)
+
+      buffer = text_view.buffer
+      iter = text_view.get_iter_at_location(x, y)
+
+      hovering = false
+
+      tags = iter.tags
+      tags.each do |t|
+        if t.page
+          hovering = true
+          break
+        end
+      end
+
+      if hovering != @hovering
+        @hovering = hovering
+
+        window = text_view.get_window(Gtk::TextView::WINDOW_TEXT)
+
+        window.cursor = if @hovering
+                          @hand_cursor
+                        else
+                          @regular_cursor
+                        end
+      end
+    end
+
+    # Update the cursor image if the pointer moved.
+    def motion_notify_event(text_view, event)
+      x, y = text_view.window_to_buffer_coords(Gtk::TextView::WINDOW_WIDGET,
+                                               event.x, event.y)
+      set_cursor_if_appropriate(text_view, x, y)
+      text_view.window.pointer
+
+      false
+    end
+
+    # Also update the cursor image if the window becomes visible
+    # (e.g. when a window covering it got iconified).
+    def visibility_notify_event (text_view, event)
+      window, wx, wy = text_view.window.pointer
+      bx, by = text_view.window_to_buffer_coords(Gtk::TextView::WINDOW_WIDGET,
+                                                 wx, wy)
+      set_cursor_if_appropriate(text_view, bx, by)
+
+      false
+    end
+  end
+end
+
+module Gtk
+  class TextTag
+    attr_accessor :page
+  end
+end

data/sample/gtk-demo/iconview.rb

@@ -0,0 +1,109 @@
+# Copyright (c) 2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+# $Id: iconview.rb,v 1.7 2007/08/05 15:41:31 mutoh Exp $
+=begin
+= Icon View (IconView)
+
+The Gtk::IconView widget is used to display and manipulate icons.
+It uses a Gtk::TreeModel for data storage, so the list store example
+might be helpful.
+=end
+$KCODE="u"
+require 'common'
+
+module Demo
+  class IconView < Demo::BasicWindow
+    COL_PATH, COL_DISPLAY_NAME, COL_IS_DIR, COL_PIXBUF = (0..3).to_a
+
+    def fill_store
+      @store.clear
+      Dir.glob(File.join(@parent, "*")).each do |path|
+	is_dir = FileTest.directory?(path)
+	iter = @store.append
+        # set COL_DISPLAY_NAME first because changing an iter will trigger the
+        # sort function; if we set something else first, the value of
+        # COL_DISPLAY_NAME for this row will be "nil" and the sort function will fail
+puts path
+#puts GLib.convert(GLib.filename_to_utf8(path), "Shift_JIS", "UTF-8")
+#puts File.basename(GLib.convert(GLib.filename_to_utf8(path), "Shift_JIS", "UTF-8"))
+#        iter[COL_DISPLAY_NAME] = File.basename(GLib.filename_to_utf8(path))
+        iter[COL_DISPLAY_NAME] = GLib.filename_to_utf8(path)
+	iter[COL_PATH] = path
+	iter[COL_IS_DIR] = is_dir
+	iter[COL_PIXBUF] = is_dir ? @folder_pixbuf : @file_pixbuf
+      end
+    end
+
+    def initialize
+      super('Gtk::IconView demo')
+      @file_pixbuf = Gdk::Pixbuf.new(Demo.find_file("gnome-fs-regular.png"))
+      @folder_pixbuf = Gdk::Pixbuf.new(Demo.find_file("gnome-fs-directory.png"))
+
+      @store = Gtk::ListStore.new(String, String, TrueClass, Gdk::Pixbuf)
+      @parent = "/"
+
+      @store.set_default_sort_func do |a, b|
+        if !a[COL_IS_DIR] and b[COL_IS_DIR]
+          1
+        elsif a[COL_IS_DIR] and !b[COL_IS_DIR]
+          -1
+        else
+          a[COL_DISPLAY_NAME] <=> b[COL_DISPLAY_NAME]
+        end
+      end
+      @store.set_sort_column_id(Gtk::TreeSortable::DEFAULT_SORT_COLUMN_ID,
+				Gtk::SORT_ASCENDING)
+
+      fill_store
+      set_default_size(650, 400)
+      set_border_width(8)
+
+      vbox = Gtk::VBox.new(false, 0)
+      add(vbox)
+
+      toolbar = Gtk::Toolbar.new
+      vbox.pack_start(toolbar, false, false, 0)
+
+      up_button = Gtk::ToolButton.new(Gtk::Stock::GO_UP)
+      up_button.important = true
+      up_button.sensitive = false
+      toolbar.insert(-1, up_button)
+      up_button.signal_connect("clicked") do
+	@parent = File.dirname(@parent)
+	fill_store
+	up_button.sensitive = @parent != "/"
+      end
+
+      home_button = Gtk::ToolButton.new(Gtk::Stock::HOME)
+      home_button.important = true
+      toolbar.insert(-1, home_button)
+      home_button.signal_connect("clicked") do
+	@parent = GLib.home_dir
+	fill_store
+	up_button.sensitive = true
+      end
+
+      sw = Gtk::ScrolledWindow.new
+      sw.shadow_type = Gtk::SHADOW_ETCHED_IN
+      sw.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC)
+      vbox.pack_start(sw, true, true, 0)
+
+      iconview = Gtk::IconView.new(@store)
+      iconview.selection_mode = Gtk::SELECTION_MULTIPLE
+      iconview.text_column = COL_DISPLAY_NAME
+      iconview.pixbuf_column = COL_PIXBUF
+      iconview.signal_connect("item_activated") do |iview, path|
+	iter = @store.get_iter(path)
+	if iter[COL_DISPLAY_NAME]
+	  @parent = iter[COL_PATH]
+	  fill_store
+	  up_button.sensitive = true
+	end
+      end
+      sw.add(iconview)
+      iconview.grab_focus
+    end
+  end
+end
+

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, false, false, 0)
+      
+      frame = Gtk::Frame.new
+      frame.shadow_type = Gtk::SHADOW_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, false, false, 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, false, false, 0)
+      
+      frame = Gtk::Frame.new
+      frame.shadow_type = Gtk::SHADOW_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, false, false, 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, false, false, 0)
+      
+      frame = Gtk::Frame.new(nil)
+      frame.shadow_type = Gtk::SHADOW_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, false, false, 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, false, false, 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