gtk2 0.20.1 → 0.90.2

data/sample/gtk-demo/menus.rb

@@ -0,0 +1,172 @@
+# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+# $Id: menus.rb,v 1.4 2005/02/12 23:02:43 kzys Exp $
+=begin
+= Menus
+
+There are several widgets involved in displaying menus. The
+Gtk::MenuBar widget is a horizontal menu bar, which normally appears
+at the top of an application. The Gtk::Menu widget is the actual menu
+that pops up. Both Gtk::MenuBar and Gtk::Menu are subclasses of
+Gtk::MenuShell; a Gtk::MenuShell contains menu items
+(Gtk::MenuItem). Each menu item contains text and/or images and can
+be selected by the user.
+
+There are several kinds of menu item, including plain Gtk::MenuItem,
+Gtk::CheckMenuItem which can be checked/unchecked, Gtk::RadioMenuItem
+which is a check menu item that's in a mutually exclusive group,
+Gtk::SeparatorMenuItem which is a separator bar, Gtk::TearoffMenuItem
+which allows a Gtk::Menu to be torn off, and Gtk::ImageMenuItem which
+can place a Gtk::Image or other widget next to the menu text.
+
+A Gtk::MenuItem can have a submenu, which is simply a Gtk::Menu to pop
+up when the menu item is selected. Typically, all menu items in a menu bar
+have submenus.
+
+The Gtk::OptionMenu widget is a button that pops up a Gtk::Menu when clicked.
+It's used inside dialogs and such.
+
+Gtk::ItemFactory provides a higher-level interface for creating menu bars
+and menus; while you can construct menus manually, most people don't
+do that. There's a separate demo for Gtk::ItemFactory.
+=end
+require 'common'
+
+module Demo
+  class Menus < BasicWindow
+    def initialize
+      super('menus')
+      self.border_width = 0
+
+      accel_group = Gtk::AccelGroup.new
+      add_accel_group(accel_group)
+
+
+      box1 = Gtk::VBox.new(false, 0)
+      add(box1)
+
+      menubar = Gtk::MenuBar.new
+      box1.pack_start(menubar, false, true, 0)
+
+      menu = create_menu(2, true)
+
+      menuitem = Gtk::MenuItem.new("test\nline2")
+      menuitem.submenu = menu
+      menubar.append(menuitem)
+      menuitem.show
+
+      menuitem = Gtk::MenuItem.new('foo')
+      menuitem.submenu = create_menu(3, true)
+      menubar.append(menuitem)
+      menuitem.show
+
+      menuitem = Gtk::MenuItem.new('bar')
+      menuitem.submenu = create_menu(4, true)
+      menuitem.right_justified = true
+      menubar.append(menuitem)
+      menuitem.show
+
+      box2 = Gtk::VBox.new(false, 10)
+      box2.border_width = 10
+      box1.pack_start(box2, true, true, 0)
+      box2.show
+
+      menu = create_menu(1, false)
+      # menu.accel_group = accel_group
+
+      menuitem = Gtk::SeparatorMenuItem.new
+      menu.append(menuitem)
+      menuitem.show
+
+      menuitem = Gtk::CheckMenuItem.new('Accelerate Me')
+      menu.append(menuitem)
+      menuitem.show
+      menuitem.add_accelerator('activate',
+			       accel_group,
+			       Gdk::Keyval::GDK_F1,
+			       0,
+			       Gtk::ACCEL_VISIBLE)
+      menuitem = Gtk::CheckMenuItem.new('Accelerator Locked')
+      menu.append(menuitem)
+      menuitem.show
+      menuitem.add_accelerator('activate',
+			       accel_group,
+			       Gdk::Keyval::GDK_F2,
+			       0,
+			       Gtk::ACCEL_VISIBLE | Gtk::ACCEL_LOCKED)
+      menuitem = Gtk::CheckMenuItem.new('Accelerators Frozen')
+      menu.append(menuitem)
+      menuitem.show
+      menuitem.add_accelerator('activate',
+			       accel_group,
+			       Gdk::Keyval::GDK_F2,
+			       0,
+			       Gtk::ACCEL_VISIBLE)
+      menuitem.add_accelerator('activate',
+			       accel_group,
+			       Gdk::Keyval::GDK_F3,
+			       0,
+			       Gtk::ACCEL_VISIBLE)
+
+      optionmenu = Gtk::OptionMenu.new
+      optionmenu.menu = menu
+      optionmenu.history = 3
+      box2.pack_start(optionmenu, true, true, 0)
+      optionmenu.show
+
+      separator = Gtk::HSeparator.new
+      box1.pack_start(separator, false, true, 0)
+      separator.show
+
+      box2 = Gtk::VBox.new(false, 10)
+      box2.border_width = 10
+      box1.pack_start(box2, false, true, 0)
+      box2.show
+
+      button = Gtk::Button.new('close')
+      button.signal_connect('clicked') do
+	quit
+      end
+      box2.pack_start(button, true, true, 0)
+      button.flags = Gtk::Widget::CAN_DEFAULT
+      button.grab_default
+      button.show
+    end
+
+
+    def create_menu (depth, tearoff)
+      if depth < 1
+	return nil
+      end
+
+      menu = Gtk::Menu.new
+      group = nil
+
+      if tearoff
+	menuitem = Gtk::TearoffMenuItem.new
+	menu.append(menuitem)
+	menuitem.show
+      end
+
+      5.times do |i|
+	buf = sprintf('item %2d - %d', depth, i + 1)
+	menuitem = Gtk::RadioMenuItem.new(buf)
+	group = menuitem.group
+
+	menu.append(menuitem)
+	menuitem.show
+	if i == 3
+	  menuitem.sensitive = false
+	end
+
+	if submenu = create_menu(depth - 1, true)
+	  menuitem.submenu = submenu
+	end
+      end
+
+      menu.show
+      return menu
+    end
+  end
+end

data/sample/gtk-demo/panes.rb

@@ -0,0 +1,156 @@
+# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+# $Id: panes.rb,v 1.5 2005/02/12 23:06:07 kzys Exp $
+=begin
+= Paned Widgets
+
+The Gtk::HPaned and Gtk::VPaned Widgets divide their content
+area into two panes with a divider in between that the
+user can adjust. A separate child is placed into each
+pane.
+
+There are a number of options that can be set for each pane.
+This test contains both a horizontal (HPaned) and a vertical
+(VPaned) widget, and allows you to adjust the options for
+each side of each widget.
+=end
+require 'common'
+
+module Demo
+  class Panes < BasicWindow
+    def initialize
+      super('Panes')
+      self.border_width = 0
+
+      vbox = Gtk::VBox.new(false, 0)
+      add(vbox)
+
+      vpaned = Gtk::VPaned.new
+      vbox.pack_start(vpaned, true, true, 0)
+      vpaned.border_width = 5
+
+      hpaned = Gtk::HPaned.new
+      vpaned.add1(hpaned)
+
+      frame = Gtk::Frame.new
+      frame.shadow_type = Gtk::SHADOW_IN
+      frame.set_size_request(60, 60)
+      hpaned.add1(frame)
+
+      button = Gtk::Button.new('_Hi there', true)
+      frame.add(button)
+
+      frame = Gtk::Frame.new
+      frame.shadow_type = Gtk::SHADOW_IN
+      frame.set_size_request(80, 60)
+      hpaned.add2(frame)
+
+      frame = Gtk::Frame.new
+      frame.shadow_type = Gtk::SHADOW_IN
+      frame.set_size_request(60, 80)
+      vpaned.add2(frame)
+
+      # Now create toggle buttons to control sizing
+
+      vbox.pack_start(create_pane_options(hpaned,
+					  'Horizontal', 'Left', 'Right'),
+		      false, false, 0)
+
+      vbox.pack_start(create_pane_options(vpaned,
+					  'Vertical', 'Top', 'Bottom'),
+		      false, false, 0)
+    end
+
+    def create_pane_options(paned, frame_label, label1, label2)
+      frame = Gtk::Frame.new(frame_label)
+      frame.border_width = 4
+
+      table = Gtk::Table.new(3, 2, true)
+      frame.add(table)
+
+      label = Gtk::Label.new(label1)
+      table.attach_defaults(label, 0, 1, 0, 1)
+
+      check_button = Gtk::CheckButton.new('_Resize', true)
+      table.attach_defaults(check_button, 0, 1, 1, 2)
+      check_button.signal_connect('toggled') do
+	toggle_resize(paned.child1)
+      end
+
+      check_button = Gtk::CheckButton.new('_Shrink', true)
+      table.attach_defaults(check_button, 0, 1, 2, 3)
+      check_button.active = true
+      check_button.signal_connect('toggled') do
+	toggle_shrink(paned.child1)
+      end
+
+      label = Gtk::Label.new(label2)
+      table.attach_defaults(label, 1, 2, 0, 1)
+
+      check_button = Gtk::CheckButton.new('_Resize')
+      table.attach_defaults(check_button, 1, 2, 1, 2)
+      check_button.active = true
+      check_button.signal_connect('toggled') do
+	toggle_resize(paned.child2)
+      end
+
+      check_button = Gtk::CheckButton.new('_Shrink')
+      table.attach_defaults(check_button, 1, 2, 2, 3)
+      check_button.active = true
+      check_button.signal_connect('toggled') do
+	toggle_shrink(paned.child2)
+      end
+
+      return frame
+    end
+
+    def toggle_resize(child)
+      paned = child.parent
+      is_child1 = (child == paned.child1)
+
+      resize = if is_child1
+		 paned.child1_resize?
+	       else
+		 paned.child2_resize?
+	       end
+
+      shrink = if is_child1
+		 paned.child1_shrink?
+	       else
+		 paned.child2_shrink?
+	       end
+
+      child.parent.remove(child)
+      if is_child1
+	paned.pack1(child, !resize, shrink)
+      else
+	paned.pack2(child, !resize, shrink)
+      end
+    end
+
+    def toggle_shrink(child)
+      paned = child.parent
+      is_child1 = (child == paned.child1)
+
+      resize = if is_child1
+		 paned.child1_resize?
+	       else
+		 paned.child2_resize?
+	       end
+
+      shrink = if is_child1
+		 paned.child1_shrink?
+	       else
+		 paned.child2_shrink?
+	       end
+
+      child.parent.remove(child)
+      if is_child1
+	paned.pack1(child, resize, !shrink)
+      else
+	paned.pack2(child, resize, !shrink)
+      end
+    end
+  end
+end

data/sample/gtk-demo/pixbufs.rb

@@ -0,0 +1,176 @@
+# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+# $Id: pixbufs.rb,v 1.5 2005/02/12 23:02:43 kzys Exp $
+=begin
+= Pixbufs
+
+A Gdk::Pixbuf represents an image, normally in RGB or RGBA format.
+Pixbufs are normally used to load files from disk and perform
+image scaling.
+
+This demo is not all that educational, but looks cool. It was written
+by Extreme Pixbuf Hacker Federico Mena Quintero. It also shows
+off how to use Gtk::DrawingArea to do a simple animation.
+
+Look at the Image demo for additional pixbuf usage examples.
+=end
+
+require 'common'
+
+module Demo
+  class Pixbufs < BasicWindow
+    FRAME_DELAY = 50
+
+    BACKGROUND_NAME = 'background.jpg'
+
+    IMAGE_NAMES = [
+      'apple-red.png',
+      'gnome-applets.png',
+      'gnome-calendar.png',
+      'gnome-foot.png',
+      'gnome-gmush.png',
+      'gnome-gimp.png',
+      'gnome-gsame.png',
+      'gnu-keys.png',
+      'ruby-gnome2-logo.png'
+    ]
+
+    CYCLE_LEN = 60
+    def initialize
+      super('Pixbufs')
+      set_resizable(false)
+
+      @background = nil
+      @frame = nil
+      @frame_num = 0
+      @images = []
+
+      begin
+	load_pixbufs
+
+	set_size_request(@background.width, @background.height)
+
+	@frame = Gdk::Pixbuf.new(Gdk::Pixbuf::COLORSPACE_RGB,
+				 false, 8,
+				 @background.width, @background.height)
+
+	@da = Gtk::DrawingArea.new
+
+	@da.signal_connect('expose_event') do |w, e|
+	  expose_cb(w, e)
+	end
+
+	add(@da)
+
+	timeout_id = Gtk.timeout_add(FRAME_DELAY) do
+          timeout
+	end
+        signal_connect('destroy') do
+          Gtk.timeout_remove(timeout_id)
+        end
+      rescue
+	dialog = Gtk::MessageDialog.new(self,
+					Gtk::Dialog::DESTROY_WITH_PARENT,
+					Gtk::MessageDialog::ERROR,
+					Gtk::MessageDialog::BUTTONS_CLOSE,
+					"Failed to load an image: #{$!.message}")
+
+	dialog.signal_connect('response') do
+	  dialog.destroy
+	end
+
+	dialog.show
+      end
+    end
+
+    def load_pixbufs
+      # Loads the images for the demo
+
+      if @background
+	return # already loaded earlier
+      end
+
+      # 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.
+      #
+      filename = Demo.find_file(BACKGROUND_NAME)
+      @background = Gdk::Pixbuf.new(filename)
+
+      IMAGE_NAMES.each_with_index do |basename, i|
+	filename = Demo.find_file(basename)
+
+	@images[i] = Gdk::Pixbuf.new(filename)
+      end
+    end
+
+    def expose_cb(widget, event)
+      rowstride = @frame.rowstride
+
+      pixels = @frame.pixels
+      pixels[0, rowstride * event.area.y + event.area.x * 3] = ''
+
+      Gdk::RGB.draw_rgb_image(widget.window,
+                              widget.style.black_gc,
+                              event.area.x, event.area.y,
+                              event.area.width, event.area.height,
+                              Gdk::RGB::Dither::NORMAL,
+                              pixels, rowstride,
+                              event.area.x, event.area.y)
+      true
+    end
+
+    # Timeout handler to regenerate the frame
+    def timeout
+      @background.copy_area(0, 0, @background.width, @background.height,
+                           @frame, 0, 0)
+
+      f = Float(@frame_num % CYCLE_LEN) / CYCLE_LEN;
+
+      xmid = @background.width / 2.0
+      ymid = @background.height / 2.0
+
+      radius = [xmid, ymid].min / 2.0
+
+      @images.each_with_index do |image, i|
+        ang = 2.0 * Math::PI * Float(i) / IMAGE_NAMES.length - f * 2.0 * Math::PI
+
+        r = radius + (radius / 3.0) * Math.sin(f * 2.0 * Math::PI)
+
+        xpos = (xmid + r * Math.cos(ang) - image.width / 2.0 + 0.5).floor
+        ypos = (ymid + r * Math.sin(ang) - image.height / 2.0 + 0.5).floor
+
+        k = if (i & 1) == 1
+              Math.sin(f * 2.0 * Math::PI)
+            else
+              Math.cos(f * 2.0 * Math::PI)
+            end
+        k = [0.25, 2.0 * k * k].max
+
+        r1 = Gdk::Rectangle.new(xpos, ypos, image.width * k, image.height * k)
+        r2 = Gdk::Rectangle.new(0, 0, @background.width, @background.height)
+
+        dest = r1.intersect(r2)
+        if dest
+          @frame.composite!(image, dest.x, dest.y, dest.width, dest.height,
+                            xpos, ypos, k, k, Gdk::Pixbuf::INTERP_NEAREST,
+                            if (i & 1) == 1
+                              [
+                                127,
+                                (255 * Math.sin(f * 2.0 * Math::PI)).abs
+                              ].max
+                            else
+                              [
+                                127,
+                                (255 * Math.cos(f * 2.0 * Math::PI)).abs
+                              ].max
+                            end)
+        end
+      end
+      @da.queue_draw
+      @frame_num += 1
+      true
+    end
+  end
+end