gtk3 1.2.6-x86-mingw32 → 2.0.0-x86-mingw32

data/Rakefile

@@ -1,20 +1,22 @@
 # -*- ruby -*-
 
 $LOAD_PATH.unshift("./../glib2/lib")
-require 'gnome2-raketask'
+require 'gnome2/rake/package-task'
 
-package = GNOME2Package.new do |_package|
-  _package.summary = "Ruby/GTK3 is a Ruby binding of GTK+-3.x."
-  _package.description = "Ruby/GTK3 is a Ruby binding of GTK+-3.x."
-  _package.dependency.gem.runtime = ["glib2",
-                                     "gio2",
-                                     "atk",
-                                     "pango",
-                                     "gdk_pixbuf2",
-                                     "gdk3"]
-  _package.win32.packages = ["gtk+"]
-  _package.win32.dependencies = []
-  _package.required_ruby_version = ">= 1.9.2"
-  _package.post_install_message = "This library is experimental."
+package_task = GNOME2::Rake::PackageTask.new do |package|
+  package.summary = "Ruby/GTK3 is a Ruby binding of GTK+-3.x."
+  package.description = "Ruby/GTK3 is a Ruby binding of GTK+-3.x."
+  package.dependency.gem.runtime = [
+    "glib2",
+    "gio2",
+    "atk",
+    "pango",
+    "gdk_pixbuf2",
+    "gdk3",
+  ]
+  package.windows.packages = []
+  package.windows.dependencies = []
+  package.required_ruby_version = ">= 1.9.2"
+  package.post_install_message = "This library is experimental."
 end
-package.define_tasks
+package_task.define

data/ext/gtk3/rbgtk-tree-model.c

@@ -83,6 +83,17 @@ rg_get_iter(VALUE self, VALUE path)
     return val;
 }
 
+static VALUE
+rg_get_path(VALUE self, VALUE iter)
+{
+    GtkTreePath *path;
+    VALUE rb_path;
+    path = gtk_tree_model_get_path(_SELF(self), RVAL2GTKTREEITER(iter));
+    rb_path = GTKTREEPATH2RVAL(path);
+    gtk_tree_path_free(path);
+    return rb_path;
+}
+
 static VALUE
 rg_get_value(VALUE self, VALUE iter, VALUE column)
 {
@@ -216,6 +227,7 @@ Init_gtk_treemodel(VALUE mGtk)
     RG_DEF_METHOD(get_column_type, 1);
     RG_DEF_METHOD(iter_first, 0);
     RG_DEF_METHOD(get_iter, 1);
+    RG_DEF_METHOD(get_path, 1);
     RG_DEF_METHOD(get_value, 2);
     RG_DEF_METHOD(each, 0);
     RG_DEF_METHOD(row_changed, 2);

data/lib/gtk3/base.rb

@@ -10,7 +10,7 @@ require 'gdk3'
 base_dir = Pathname.new(__FILE__).dirname.dirname.dirname.expand_path
 vendor_dir = base_dir + "vendor" + "local"
 vendor_bin_dir = vendor_dir + "bin"
-GLib.prepend_environment_path(vendor_bin_dir)
+GLib.prepend_dll_path(vendor_bin_dir)
 begin
   major, minor, _ = RUBY_VERSION.split(/\./)
   require "#{major}.#{minor}/gtk3.so"

data/sample/gtk-demo/appwindow.rb

@@ -111,8 +111,8 @@ module Demo
 
       ## Create document
       sw = Gtk::ScrolledWindow.new
-      sw.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC)
-      sw.shadow_type = Gtk::SHADOW_IN
+      sw.set_policy(:automatic, :automatic)
+      sw.shadow_type = :in
       table.attach(sw,
 		   # X direction            # Y direction
 		   0, 1,                    2, 3,

data/sample/gtk-demo/button_box.rb

@@ -15,57 +15,56 @@ module Demo
       super('Button Boxes')
       set_border_width(10)
 
-      main_vbox = Gtk::VBox.new(false, 0)
+      main_vbox = Gtk::Box.new(:vertical)
       add(main_vbox)
 
       frame_horiz = Gtk::Frame.new('Horizontal Button Boxes')
-      main_vbox.pack_start(frame_horiz, true, true, 10)
+      main_vbox.pack_start(frame_horiz, :expand => true, :fill => true, :padding => 10)
 
-      vbox = Gtk::VBox.new(false, 0)
+      vbox = Gtk::Box.new(:vertical)
       vbox.set_border_width(10)
       frame_horiz.add(vbox)
 
-      vbox.pack_start(create_bbox(true, 'Spread', 40, Gtk::ButtonBox::SPREAD),
-		      true, true, 0)
-      
-      vbox.pack_start(create_bbox(true, 'Edge', 40, Gtk::ButtonBox::EDGE),
-		      true, true, 5)
-      
-      vbox.pack_start(create_bbox(true, 'Start', 40, Gtk::ButtonBox::START),
-		      true, true, 5)
-      
-      vbox.pack_start(create_bbox(true, 'End', 40, Gtk::ButtonBox::END),
-		      true, true, 5)
-      
+      vbox.pack_start(create_bbox(true, 'Spread', 40, :spread),
+                      :expand => true, :fill => true, :padding => 0)
+
+      vbox.pack_start(create_bbox(true, 'Edge', 40, :edge),
+                      :expand => true, :fill => true, :padding => 5)
+
+      vbox.pack_start(create_bbox(true, 'Start', 40, :start),
+                      :expand => true, :fill => true, :padding => 5)
+
+      vbox.pack_start(create_bbox(true, 'End', 40, :end),
+                      :expand => true, :fill => true, :padding => 5)
+
       frame_vert = Gtk::Frame.new('Vertical Button Boxes')
-      main_vbox.pack_start(frame_vert, true, true, 10)
+      main_vbox.pack_start(frame_vert, :expand => true, :fill => true, :padding => 10)
 
-      hbox = Gtk::HBox.new(false, 0)
+     hbox = Gtk::Box.new(:horizontal, 0)
       hbox.set_border_width(10)
       frame_vert.add(hbox)
 
-      hbox.pack_start(create_bbox(false, 'Spread', 30, Gtk::ButtonBox::SPREAD),
-		      true, true, 0)
-      
-      hbox.pack_start(create_bbox(false, 'Edge', 30, Gtk::ButtonBox::EDGE),
-		      true, true, 5)
-      
-      hbox.pack_start(create_bbox(false, 'Start', 30, Gtk::ButtonBox::START),
-		      true, true, 5)
-      
-      hbox.pack_start(create_bbox(false, 'End', 30, Gtk::ButtonBox::END),
-		      true, true, 5)
-      
+      hbox.pack_start(create_bbox(false, 'Spread', 30, :spread),
+                      :expand => true, :fill => true, :padding => 0)
+
+      hbox.pack_start(create_bbox(false, 'Edge', 30, :edge),
+                      :expand => true, :fill => true, :padding => 5)
+
+      hbox.pack_start(create_bbox(false, 'Start', 30, :start),
+                      :expand => true, :fill => true, :padding => 5)
+
+      hbox.pack_start(create_bbox(false, 'End', 30, :end),
+                      :expand => true, :fill => true, :padding => 5)
     end
 
     def create_bbox(horizontal, title, spacing, layout)
       frame = Gtk::Frame.new(title)
-      
+
       bbox = if horizontal
-	       Gtk::HButtonBox.new
-	     else
-	       Gtk::VButtonBox.new
-	     end
+               Gtk::ButtonBox.new(:horizontal)
+             else
+               Gtk::ButtonBox.new(:vertical)
+             end
 
       bbox.set_border_width(5)
       frame.add(bbox)
@@ -74,8 +73,8 @@ module Demo
       bbox.set_spacing(spacing)
 
       [Gtk::Stock::OK, Gtk::Stock::CANCEL, Gtk::Stock::HELP].each do |stock|
-	button = Gtk::Button.new(stock)
-	bbox.add(button)
+        button = Gtk::Button.new(:stock_id => stock)
+        bbox.add(button)
       end
 
       return frame

data/sample/gtk-demo/cairo-operator.rb

@@ -32,8 +32,8 @@ module Demo
       remove(@drawing_area)
       
       vbox = Gtk::VBox.new
-      vbox.pack_start(@drawing_area, true, true)
-      vbox.pack_start(operator_selector, false, false)
+      vbox.pack_start(@drawing_area, :expand => true, :fill => true)
+      vbox.pack_start(operator_selector, :expand => false, :fill => false)
       add(vbox)
     end
 

data/sample/gtk-demo/changedisplay.rb

@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+#
 # Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
 # This program is licenced under the same licence as Ruby-GNOME2.
 #
@@ -54,45 +56,35 @@ module Demo
       @current_display = nil
       @current_screen = nil
 
-      super('Change Screen or display',
-	    nil, # parent
-	    Gtk::Dialog::NO_SEPARATOR,
-	    [Gtk::Stock::CLOSE, Gtk::Dialog::RESPONSE_CLOSE],
-	    ['Change', Gtk::Dialog::RESPONSE_OK])
+      super(
+        :title => 'Change Screen or display',
+        :buttons => [
+          [:close, :close],
+          ['Change', :ok]
+        ]
+      )
 
       set_default_size(300, 400)
       signal_connect('response') do |dialog, response_id|
-	if response_id == Gtk::Dialog::RESPONSE_OK
-          if Gtk.check_version?(2, 2, 0)
-            query_change_display
-          else
-            puts "This sample requires GTK+ 2.2.0 or later"
-          end
-	else
-	  destroy # Gtk.main_quit?
-	end
-      end
-      signal_connect('destroy') do
-
-      end
-
-      unless Gtk.check_version?(2, 2, 0)
-         vbox.add(Gtk::Label.new("This sample requires GTK+ 2.2.0 or later"))
-         return
+        if response_id == Gtk::ResponseType::OK
+          query_change_display
+        else
+          destroy
+        end
       end
 
-      vbox = Gtk::VBox.new(false, 5)
+      vbox = Gtk::Box.new(:vertical, 5)
       vbox.set_border_width(8)
 
-      self.vbox.pack_start(vbox, true, true)
+      self.child.pack_start(vbox, :expand => true, :fill => true)
 
-      @size_group = Gtk::SizeGroup.new(Gtk::SizeGroup::HORIZONTAL)
+      @size_group = Gtk::SizeGroup.new(:horizontal)
 
       frame = create_display_frame
-      vbox.pack_start(frame, true, true)
+      vbox.pack_start(frame, :expand => true, :fill => true)
 
       frame = create_screen_frame
-      vbox.pack_start(frame, true, true)
+      vbox.pack_start(frame, :expand => true, :fill => true)
 
       initialize_displays
     end
@@ -104,14 +96,14 @@ module Demo
       manager = Gdk::DisplayManager.get
 
       manager.displays.each do |display|
-	add_display(display)
+        add_display(display)
       end
 
       handler_id = manager.signal_connect('display_opened') do |display|
-	add_display(display)
+        add_display(display)
       end
       signal_connect('destroy') do
-	manager.signal_handler_disconnect(handler_id)
+        manager.signal_handler_disconnect(handler_id)
       end
     end
 
@@ -120,17 +112,17 @@ module Demo
       @screen_model.clear
 
       if @current_display
-	n_screens = @current_display.n_screens
+        n_screens = @current_display.n_screens
 
-	n_screens.times do |i|
-	  iter = @screen_model.append
-	  iter.set_value(SCREEN_COLUMN_NUMBER, i)
-	  iter.set_value(SCREEN_COLUMN_SCREEN, @current_display.get_screen(i))
+        n_screens.times do |i|
+          iter = @screen_model.append
+          iter.set_value(SCREEN_COLUMN_NUMBER, i)
+          iter.set_value(SCREEN_COLUMN_SCREEN, @current_display.get_screen(i))
 
-	  if i == 0
-	    @screen_selection.select_iter(iter)
-	  end
-	end
+          if i == 0
+            @screen_selection.select_iter(iter)
+          end
+        end
       end
     end
 
@@ -138,31 +130,31 @@ module Demo
     def create_display_frame
       frame, tree_view, button_vbox = create_frame('Display')
 
-      button = left_align_button_new('_Open...')
+      button = left_align_button_new('_Open…')
       button.signal_connect('clicked') do
-	open_display_cb
+        open_display_cb
       end
-      button_vbox.pack_start(button, false, false, 0)
+      button_vbox.pack_start(button, :expand => false, :fill => false, :padding => 0)
 
       button = left_align_button_new('_Close')
       button.signal_connect('clicked') do
-	if @current_display
-	  @current_display.close
-	end
+        if @current_display
+          @current_display.close
+        end
       end
-      button_vbox.pack_start(button, false, false, 0)
+      button_vbox.pack_start(button, :expand => false, :fill => false, :padding => 0)
 
       @display_model = Gtk::ListStore.new(String, Gdk::Display)
       tree_view.model = @display_model
 
       column = Gtk::TreeViewColumn.new('Name',
-				       Gtk::CellRendererText.new,
-				       {'text' => DISPLAY_COLUMN_NAME})
+                                       Gtk::CellRendererText.new,
+                                       {'text' => DISPLAY_COLUMN_NAME})
       tree_view.append_column(column)
 
       selection = tree_view.selection
       selection.signal_connect('changed') do
-	display_changed_cb(selection)
+        display_changed_cb(selection)
       end
 
       return frame
@@ -176,17 +168,17 @@ module Demo
       tree_view.model = @screen_model
 
       column = Gtk::TreeViewColumn.new('Number',
-				       Gtk::CellRendererText.new,
-				       {'text' => SCREEN_COLUMN_NUMBER})
+                                       Gtk::CellRendererText.new,
+                                       {'text' => SCREEN_COLUMN_NUMBER})
       tree_view.append_column(column)
 
       @screen_selection = tree_view.selection
       @screen_selection.signal_connect('changed') do |selection|
-	@current_screen = if iter = selection.selected
-			    iter.get_value(SCREEN_COLUMN_SCREEN)
-			  else
-			    nil
-			  end
+        @current_screen = if iter = selection.selected
+                            iter.get_value(SCREEN_COLUMN_SCREEN)
+                          else
+                            nil
+                          end
       end
 
       return frame
@@ -199,24 +191,24 @@ module Demo
     def create_frame(title)
       frame = Gtk::Frame.new(title)
 
-      hbox = Gtk::HBox.new(false, 8)
+      hbox = Gtk::Box.new(:horizontal, 8)
       hbox.set_border_width(8)
       frame.add(hbox)
 
       scrollwin = Gtk::ScrolledWindow.new
-      scrollwin.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC)
-      scrollwin.shadow_type = Gtk::SHADOW_IN
-      hbox.pack_start(scrollwin, true, true)
+      scrollwin.set_policy(:never, :automatic)
+      scrollwin.shadow_type = :in
+      hbox.pack_start(scrollwin, :expand => true, :fill => true)
 
       tree_view = Gtk::TreeView.new
       tree_view.headers_visible = false
       scrollwin.add(tree_view)
 
       selection = tree_view.selection
-      selection.mode = Gtk::SELECTION_BROWSE
+      selection.mode = :browse
 
-      button_vbox = Gtk::VBox.new(false, 5)
-      hbox.pack_start(button_vbox, false, false)
+      button_vbox = Gtk::Box.new(:vertical, 5)
+      hbox.pack_start(button_vbox, :expand => false, :fill => false)
 
       @size_group.add_widget(button_vbox)
 
@@ -227,7 +219,7 @@ module Demo
     # are left-aligned, rather than centered. This function creates a button
     # and left-aligns it contents.
     def left_align_button_new(label)
-      button = Gtk::Button.new(label, true)
+      button = Gtk::Button.new(:mnemonic => label)
       button.child.set_alignment(0.0, 0.5)
 
       return button
@@ -237,16 +229,16 @@ module Demo
     # Prompts the user for a toplevel window to move, and then moves
     # that window to the currently selected display
     def query_change_display
-      screen = self.window.screen
+      screen = self.screen
 
       toplevel = query_for_toplevel(screen,
                                     "Please select the toplevel\n"+
                                     "to move to the new screen")
 
       if toplevel
-	toplevel.screen = @current_screen
+        toplevel.screen = @current_screen
       else
-	screen.display.beep
+        screen.display.beep
       end
     end
 
@@ -258,13 +250,13 @@ module Demo
 
       display = screen.display
 
-      popup = Gtk::Window.new(Gtk::Window::POPUP)
+      popup = Gtk::Window.new(:popup)
       popup.screen = screen
       popup.modal = true
-      popup.window_position = Gtk::Window::POS_CENTER
+      popup.window_position = :center
 
       frame = Gtk::Frame.new
-      frame.set_shadow_type(Gtk::SHADOW_OUT)
+      frame.set_shadow_type(:out)
       popup.add(frame)
 
       label = Gtk::Label.new(prompt)
@@ -274,35 +266,38 @@ module Demo
       popup.show_all
 
       # TODO: Gdk::Cursor.new(screen.display, Gdk::Cursor::CROSSHAIR)
-      cursor = Gdk::Cursor.new(Gdk::Cursor::CROSSHAIR)
-
-      if Gdk::pointer_grab(popup.window, false,
-			   Gdk::Event::BUTTON_RELEASE_MASK,
-			   nil,
-			   cursor,
-			   Gdk::Event::CURRENT_TIME) == Gdk::GRAB_SUCCESS
-	clicked = false
-
-	popup.signal_connect('button-release-event') do
-	  clicked = true
-	end
-
-	# Process events until clicked is set by button_release_event_cb.
-	# We pass in may_block = true since we want to wait if there
-	# are no events currently.
-	until clicked
-	  Gtk.main_iteration # TODO: GLib::main_context_iteration(nil, true)
-
-	  toplevel = find_toplevel_at_pointer(screen.display)
-	  if toplevel == popup
-	    toplevel = nil
-	  end
-	end
-
-	popup.destroy
-	Gdk.flush # Really release the grab
-
-	return toplevel
+      cursor = Gdk::Cursor.new(:crosshair)
+
+      if Gdk::pointer_grab(
+        popup.window,
+        false,
+        :button_release_mask,
+        nil,
+        cursor,
+        Gdk::Event::CURRENT_TIME
+      ) == Gdk::GRAB_SUCCESS
+      clicked = false
+
+        popup.signal_connect('button-release-event') do
+          clicked = true
+        end
+
+        # Process events until clicked is set by button_release_event_cb.
+        # We pass in may_block = true since we want to wait if there
+        # are no events currently.
+        until clicked
+          Gtk.main_iteration # TODO: GLib::main_context_iteration(nil, true)
+
+          toplevel = find_toplevel_at_pointer(screen.display)
+          if toplevel == popup
+            toplevel = nil
+          end
+        end
+
+        popup.destroy
+        Gdk.flush # Really release the grab
+
+        return toplevel
       end
     end
 
@@ -313,52 +308,56 @@ module Demo
       # The user data field of a GdkWindow is used to store a pointer
       # to the widget that created it.
       if pointer_window
-	widget = pointer_window.user_data
+        widget = pointer_window.user_data
       end
 
       return (if widget
-		widget.toplevel
-	      else
-		nil
-	      end)
+                widget.toplevel
+              else
+                nil
+              end)
     end
 
     # Called when the user clicks on 'Open...' in the display
     # frame. Prompts for a new display, and then opens a connection
     # to that display.
     def open_display_cb
-      dialog = Gtk::Dialog.new('Open Display',
-			       self,
-			       Gtk::Dialog::MODAL,
-			       [Gtk::Stock::CANCEL, Gtk::Dialog::RESPONSE_CANCEL],
-			       [Gtk::Stock::OK, Gtk::Dialog::RESPONSE_OK])
-
-      dialog.default_response = Gtk::Dialog::RESPONSE_OK
+      dialog = Gtk::Dialog.new(
+        :title => 'Open Display',
+        :parent => self,
+        :flags => :modal,
+        :buttons => [
+          [:cancel, :cancel],
+          [:ok, :ok]
+         ]
+      )
+
+      dialog.default_response = Gtk::ResponseType::OK
       display_entry = Gtk::Entry.new
       display_entry.activates_default = true
       dialog_label =
-	Gtk::Label.new("Please enter the name of\nthe new display\n")
+        Gtk::Label.new("Please enter the name of\nthe new display\n")
 
-      dialog.vbox.add(dialog_label)
-      dialog.vbox.add(display_entry)
+      dialog.child.add(dialog_label)
+      dialog.child.add(display_entry)
 
       display_entry.grab_focus
-      dialog.vbox.show_all
+      dialog.child.show_all
 
       result = nil
       until result
-	response_id = dialog.run
-	break if response_id != Gtk::Dialog::RESPONSE_OK
-
-	new_screen_name = display_entry.text
-
-	unless new_screen_name.empty?
-	  begin
-	    result = Gdk::Dispaly.open(new_screen_name)
-	  rescue
-	    dialog_label.text = "Can't open display :\n\t%s\nplease try another one\n" % [new_screen_name]
-	  end
-	end
+        response_id = dialog.run
+        break if response_id != Gtk::ResponseType::OK
+
+        new_screen_name = display_entry.text
+
+        unless new_screen_name.empty?
+          begin
+            result = Gdk::Dispaly.open(new_screen_name)
+          rescue
+            dialog_label.text = "Can't open display :\n\t%s\nplease try another one\n" % [new_screen_name]
+          end
+        end
       end
       dialog.destroy
     end
@@ -368,11 +367,11 @@ module Demo
     # screens.
     def display_changed_cb(selection)
       @current_display =
-	if iter = selection.selected
-	  iter.get_value(DISPLAY_COLUMN_DISPLAY)
-	else
-	  nil
-	end
+        if iter = selection.selected
+          iter.get_value(DISPLAY_COLUMN_DISPLAY)
+        else
+          nil
+        end
       fill_screens
     end
 
@@ -385,11 +384,11 @@ module Demo
       iter.set_value(DISPLAY_COLUMN_DISPLAY, display)
 
       handler_id = display.signal_connect('closed') do
-	display_closed_cb(display)
+        display_closed_cb(display)
       end
 
       signal_connect('destroy') do
-	display.signal_handler_disconnect(handler_id)
+        display.signal_handler_disconnect(handler_id)
       end
     end
 
@@ -397,11 +396,11 @@ module Demo
     # Remove it from our list of displays.
     def display_closed_cb(display)
       @display_model.each do |model, path, iter|
-	tmp_display = iter.get_value( DISPLAY_COLUMN_DISPLAY)
-	if tmp_display == display
-	  @display_model.remove(iter)
-	  break
-	end
+        tmp_display = iter.get_value( DISPLAY_COLUMN_DISPLAY)
+        if tmp_display == display
+          @display_model.remove(iter)
+          break
+        end
       end
     end
   end