gtk3 2.1.0-x86-mingw32 → 2.2.0-x86-mingw32

data/sample/gtk-demo/appwindow.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# Copyright (c) 2003-2014 Ruby-GNOME2 Project Team
 # This program is licenced under the same licence as Ruby-GNOME2.
 #
 # $Id: appwindow.rb,v 1.7 2005/03/05 15:01:16 mutoh Exp $
@@ -26,98 +26,98 @@ module Demo
       add_accel_group(accel_group)
 
       item_factory = Gtk::ItemFactory.new(Gtk::ItemFactory::TYPE_MENU_BAR,
-					  '<main>', accel_group)
+                                          '<main>', accel_group)
       # create menu items
       menuitem_cb = proc do |data, widget|
-	# TODO: Show item-factory's path to menu item
-	dialog = Gtk::MessageDialog.new(self,
-					Gtk::Dialog::DESTROY_WITH_PARENT,
-					Gtk::MessageDialog::INFO,
-					Gtk::MessageDialog::BUTTONS_CLOSE,
-					"You selected or toggled the menu item \"#{Gtk::ItemFactory.path_from_widget(widget)}\"")
-	
-	# Close dialog on user response
-	dialog.signal_connect('response') do |widget, data|
-	  widget.destroy
-	end
-	
-	dialog.show
+        # TODO: Show item-factory's path to menu item
+        dialog = Gtk::MessageDialog.new(self,
+                                        Gtk::Dialog::DESTROY_WITH_PARENT,
+                                        Gtk::MessageDialog::INFO,
+                                        Gtk::MessageDialog::BUTTONS_CLOSE,
+                                        "You selected or toggled the menu item \"#{Gtk::ItemFactory.path_from_widget(widget)}\"")
+
+        # Close dialog on user response
+        dialog.signal_connect('response') do |widget, data|
+          widget.destroy
+        end
+
+        dialog.show
       end
 
       menu_items = [
-	["/_File"],
-	["/_File/_New",
-	  "<StockItem>", "<control>N", Gtk::Stock::NEW,  menuitem_cb],
-	["/_File/_Open",
-	  "<StockItem>", "<control>O", Gtk::Stock::OPEN, menuitem_cb],
-	["/File/_Save",
-	  "<StockItem>", "<control>S", Gtk::Stock::SAVE, menuitem_cb],
-	["/File/Save _As...",
-	  "<StockItem>", nil,          Gtk::Stock::SAVE, menuitem_cb],
-	["/File/sep1",
-	  "<Separator>", nil,          nil,              menuitem_cb],
-	["/File/Quit",
-	  "<StockItem>", "<control>Q", Gtk::Stock::QUIT, menuitem_cb],
-
-	["/_Preferences"],
-	["/_Preferences/_Color"],
-	["/_Preferences/Color/_Red",
-	  "<RadioItem>",            nil, nil, menuitem_cb],
-	["/_Preferences/Color/_Green",
-	  "/Preferences/Color/Red", nil, nil, menuitem_cb],
-	["/_Preferences/Color/_Blue",
-	  "/Preferences/Color/Red", nil, nil, menuitem_cb],
-	
-	["/Preferences/_Shape"],
-	["/Preferences/Shape/_Square",
-	  "<RadioItem>",                 nil, nil, menuitem_cb],
-	["/Preferences/Shape/_Rectangle",
-	  "/Preferences/Shape/Square",   nil, nil, menuitem_cb],
-	["/Preferences/Shape/_Oval",
-	  "/Preferences/Shape/Square",   nil, nil, menuitem_cb],
-
-	# If you wanted this to be right justified you would use
-	# "<LastBranch>", not "<Branch>".  Right justified help menu
-	# items are generally considered a bad idea now days.
-	["/_Help"],
-	["/Help/_About", "<Item>", nil, nil, Proc.new{about_cb}],
+        ["/_File"],
+        ["/_File/_New",
+          "<StockItem>", "<control>N", Gtk::Stock::NEW,  menuitem_cb],
+        ["/_File/_Open",
+          "<StockItem>", "<control>O", Gtk::Stock::OPEN, menuitem_cb],
+        ["/File/_Save",
+          "<StockItem>", "<control>S", Gtk::Stock::SAVE, menuitem_cb],
+        ["/File/Save _As...",
+          "<StockItem>", nil,          Gtk::Stock::SAVE, menuitem_cb],
+        ["/File/sep1",
+          "<Separator>", nil,          nil,              menuitem_cb],
+        ["/File/Quit",
+          "<StockItem>", "<control>Q", Gtk::Stock::QUIT, menuitem_cb],
+
+        ["/_Preferences"],
+        ["/_Preferences/_Color"],
+        ["/_Preferences/Color/_Red",
+          "<RadioItem>",            nil, nil, menuitem_cb],
+        ["/_Preferences/Color/_Green",
+          "/Preferences/Color/Red", nil, nil, menuitem_cb],
+        ["/_Preferences/Color/_Blue",
+          "/Preferences/Color/Red", nil, nil, menuitem_cb],
+
+        ["/Preferences/_Shape"],
+        ["/Preferences/Shape/_Square",
+          "<RadioItem>",                 nil, nil, menuitem_cb],
+        ["/Preferences/Shape/_Rectangle",
+          "/Preferences/Shape/Square",   nil, nil, menuitem_cb],
+        ["/Preferences/Shape/_Oval",
+          "/Preferences/Shape/Square",   nil, nil, menuitem_cb],
+
+        # If you wanted this to be right justified you would use
+        # "<LastBranch>", not "<Branch>".  Right justified help menu
+        # items are generally considered a bad idea now days.
+        ["/_Help"],
+        ["/Help/_About", "<Item>", nil, nil, Proc.new{about_cb}],
       ]
       item_factory.create_items(menu_items)
 
       table.attach(item_factory.get_widget('<main>'),
-		   # X direction            # Y direction
-		   0, 1,                    0, 1,
-		   Gtk::EXPAND | Gtk::FILL, 0,
-		   0,                       0)
+                   # X direction            # Y direction
+                   0, 1,                    0, 1,
+                   Gtk::EXPAND | Gtk::FILL, 0,
+                   0,                       0)
 
       ## Create the toolbar
       toolbar = Gtk::Toolbar.new
       # toolbar.set_toolbar_style(Gtk::Toolbar::BOTH)
       toolbar.append(Gtk::Stock::OPEN,
-		     "This is a demo button with an 'open' icon"
-		     ) do toolbar_cb end
+                     "This is a demo button with an 'open' icon"
+                     ) do toolbar_cb end
       toolbar.append(Gtk::Stock::QUIT,
-		     "This is a demo button with an 'quit' icon"
-		     ) do toolbar_cb end
+                     "This is a demo button with an 'quit' icon"
+                     ) do toolbar_cb end
       toolbar.append_space
       toolbar.append(:demo_gtk_logo,
-		     "This is a demo button with an 'gtk' icon"
-		     ) do toolbar_cb end
+                     "This is a demo button with an 'gtk' icon"
+                     ) do toolbar_cb end
       table.attach(toolbar,
-		   # X direction            # Y direction
-		   0, 1,                    1, 2,
-		   Gtk::EXPAND | Gtk::FILL, 0,
-		   0,                       0)
+                   # X direction            # Y direction
+                   0, 1,                    1, 2,
+                   Gtk::EXPAND | Gtk::FILL, 0,
+                   0,                       0)
 
       ## Create document
       sw = Gtk::ScrolledWindow.new
       sw.set_policy(:automatic, :automatic)
       sw.shadow_type = :in
       table.attach(sw,
-		   # X direction            # Y direction
-		   0, 1,                    2, 3,
-		   Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL,
-		   0,                       0)
+                   # X direction            # Y direction
+                   0, 1,                    2, 3,
+                   Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL,
+                   0,                       0)
 
       set_default_size(200, 200)
 
@@ -127,32 +127,32 @@ module Demo
       ## Create statusbar
       statusbar = Gtk::Statusbar.new
       table.attach(statusbar,
-		   # X direction            # Y direction
-		   0, 1,                    3, 4,
-		   Gtk::EXPAND | Gtk::FILL, 0,
-		   0,                       0)
+                   # X direction            # Y direction
+                   0, 1,                    3, 4,
+                   Gtk::EXPAND | Gtk::FILL, 0,
+                   0,                       0)
 
       # Show text widget info in the statusbar
       buffer = contents.buffer
       buffer.signal_connect('changed') do |buffer|
-	update_statusbar(buffer, statusbar)
+        update_statusbar(buffer, statusbar)
       end
       # cursor moved
       buffer.signal_connect('mark_set') do |buffer, iter, mark|
-	update_statusbar(buffer, statusbar)
+        update_statusbar(buffer, statusbar)
       end
     end
 
     def toolbar_cb(*args)
       dialog = Gtk::MessageDialog.new(self,
-				      Gtk::Dialog::DESTROY_WITH_PARENT,
-				      Gtk::MessageDialog::INFO,
-				      Gtk::MessageDialog::BUTTONS_CLOSE,
-				      "You selected a toolbar button")
+                                      Gtk::Dialog::DESTROY_WITH_PARENT,
+                                      Gtk::MessageDialog::INFO,
+                                      Gtk::MessageDialog::BUTTONS_CLOSE,
+                                      "You selected a toolbar button")
 
       # Close dialog on user response
       dialog.signal_connect('response') do |widget, data|
-	widget.destroy
+        widget.destroy
       end
 
       dialog.show
@@ -165,8 +165,8 @@ module Demo
       end
 
       authors = ["Peter Mattis", "Spencer Kimball", "Josh MacDonald", "and many more..."]
-      documentors = ["Owen Taylor", "Tony Gale", "Mattias Clasen <mclasen@redhat.com>",  
-	"and many more..."]
+      documentors = ["Owen Taylor", "Tony Gale", "Mattias Clasen <mclasen@redhat.com>",
+        "and many more..."]
       license = %Q[
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public License as
@@ -185,23 +185,23 @@ Boston, MA 02111-1307, USA.
 ]
 
       transparent = Gdk::Pixbuf.new(Demo.find_file("gtk-logo-rgb.gif")).add_alpha(true, 0xff, 0xff, 0xff)
-      
+
       Gtk::AboutDialog.set_email_hook {|about, link|
-	puts "send mail to #{link}"
+        puts "send mail to #{link}"
       }
       Gtk::AboutDialog.set_url_hook {|about, link|
-	puts "show url #{link}"
+        puts "show url #{link}"
       }
       Gtk::AboutDialog.show(self,
-			    :name => "GTK+ Code Demos",
-			    :version => Gtk::VERSION.join("."),
-			    :copyright => "(C) 1997-2004 The GTK+ Team",
-			    :license => license,
-			    :website => "http://www.gtk.org",
-			    :comments => "Program to demonstrate GTK+ functions.",
-			    :authors => authors,
-			    :documenters => documentors,
-			    :logo => transparent)
+                            :name => "GTK+ Code Demos",
+                            :version => Gtk::VERSION.join("."),
+                            :copyright => "(C) 1997-2004 The GTK+ Team",
+                            :license => license,
+                            :website => "http://www.gtk.org",
+                            :comments => "Program to demonstrate GTK+ functions.",
+                            :authors => authors,
+                            :documenters => documentors,
+                            :logo => transparent)
     end
 
     def update_statusbar(buffer, statusbar)
@@ -210,7 +210,7 @@ Boston, MA 02111-1307, USA.
       iter = buffer.get_iter_at_mark(buffer.get_mark('insert'))
 
       statusbar.push(0,
-		     "Cursor at row #{iter.line} column #{iter.line_offset} - #{buffer.char_count} chars in document")
+                     "Cursor at row #{iter.line} column #{iter.line_offset} - #{buffer.char_count} chars in document")
     end
 
     def register_stock_icons

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

@@ -18,20 +18,20 @@ From http://cairographics.org/samples/operator_add.html,
      http://cairographics.org/samples/operator_saturate.html and
      http://cairographics.org/samples/operator_xor.html
 =end
-require 'common'
+require "common"
 
 module Demo
   class CairoOperator < CairoWindow
     def initialize
-      super('cairo operator')
+      super("cairo operator")
       @operator = Cairo::OPERATOR_ADD
 
       set_default_size(400, 400)
-      
+
       @drawing_area = child
       remove(@drawing_area)
-      
-      vbox = Gtk::VBox.new
+
+      vbox = Gtk::Box.new(:vertical)
       vbox.pack_start(@drawing_area, :expand => true, :fill => true)
       vbox.pack_start(operator_selector, :expand => false, :fill => false)
       add(vbox)
@@ -47,9 +47,9 @@ module Demo
         cr.set_source(image, 0.0, 0.0)
         cr.paint
       end
-      
+
       cr.set_operator(@operator)
-      
+
       cr.set_source_rgba(1, 0, 0, 0.5)
       cr.rectangle(0.2, 0.2, 0.5, 0.5)
       cr.fill
@@ -62,7 +62,7 @@ module Demo
     end
 
     def operator_selector
-      combo = Gtk::ComboBox.new
+      combo = Gtk::ComboBoxText.new
       operators = []
       Cairo.constants.each do |name|
         operators << name if /^OPERATOR_/ =~ name

data/sample/gtk-demo/drawingarea.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# Copyright (c) 2003-2014 Ruby-GNOME2 Project Team
 # This program is licenced under the same licence as Ruby-GNOME2.
 #
 # $Id: drawingarea.rb,v 1.5 2005/02/12 23:02:43 kzys Exp $
@@ -18,50 +18,49 @@ and drag in the scribble area to draw squiggles. Resize the window
 to clear the area.
 =end
 
-require 'common'
+require "common"
 
 module Demo
   class DrawingArea < BasicWindow
     def initialize
       # Pixmap for scribble area, to store current scribbles
-      @pixmap = nil
-      super('Drawing Area')
+      @cairo_context = nil
+      super("Drawing Area")
 
       self.border_width = 8
 
-      vbox = Gtk::VBox.new(false, 8)
+      vbox = Gtk::Box.new(:vertical, 8)
       vbox.border_width = 8
       add(vbox)
 
-      
       ## Create the checkerboard area
       label = Gtk::Label.new
-      label.set_markup('<u>Checkerboard pattern</u>')
+      label.set_markup("<u>Checkerboard pattern</u>")
       vbox.pack_start(label, :expand => false, :fill => false, :padding => 0)
-      
+
       frame = Gtk::Frame.new
       frame.shadow_type = :in
       vbox.pack_start(frame, :expand => true, :fill => true, :padding => 0)
-      
+
       da = Gtk::DrawingArea.new
       # set a minimum size
       da.set_size_request(100, 100)
 
       frame.add(da)
 
-      da.signal_connect('expose_event') do |widget, event|
-	checkerboard_expose(widget)
+      da.signal_connect("draw") do |widget, event|
+        checkerboard_draw(widget, event)
       end
 
       ## Create the scribble area
       label = Gtk::Label.new
-      label.set_markup('<u>Scribble area</u>')
+      label.set_markup("<u>Scribble area</u>")
       vbox.pack_start(label, :expand => false, :fill => false, :padding => 0)
-      
+
       frame = Gtk::Frame.new
       frame.shadow_type = :in
       vbox.pack_start(frame, :expand => true, :fill => true, :padding => 0)
-      
+
       da = Gtk::DrawingArea.new
       # set a minimum size
       da.set_size_request(100, 100)
@@ -69,42 +68,34 @@ module Demo
       frame.add(da)
 
       # Signals used to handle backing pixmap
-      da.signal_connect('expose_event') do |*args|
-	scribble_expose_event(*args)
+      da.signal_connect("draw") do |*args|
+        scribble_draw(*args)
       end
-      da.signal_connect('configure_event') do |widget, event|
-	scribble_configure_event(widget)
+      da.signal_connect("configure-event") do |widget, event|
+        scribble_configure_event(widget)
       end
-      
+
       # Event signals
-      da.signal_connect('motion_notify_event') do |*args|
-	scribble_motion_notify_event(*args)
+      da.signal_connect("motion-notify-event") do |*args|
+        scribble_motion_notify_event(*args)
       end
-      da.signal_connect('button_press_event') do |*args|
-	scribble_button_press_event(*args)
+      da.signal_connect("button-press-event") do |*args|
+        scribble_button_press_event(*args)
       end
-      
+
       # Ask to receive events the drawing area doesn't normally
       # subscribe to
       da.events |= (Gdk::Event::LEAVE_NOTIFY_MASK |
-		    Gdk::Event::BUTTON_PRESS_MASK |
-		    Gdk::Event::POINTER_MOTION_MASK |
-		    Gdk::Event::POINTER_MOTION_HINT_MASK)
+                    Gdk::Event::BUTTON_PRESS_MASK |
+                    Gdk::Event::POINTER_MOTION_MASK |
+                    Gdk::Event::POINTER_MOTION_HINT_MASK)
     end
 
-    # Create a new pixmap of the appropriate size to store our scribbles
+    # Create a new surface of the appropriate size to store our scribbles
     def scribble_configure_event(widget)
-      @pixmap = Gdk::Pixmap.new(self.window,
-				widget.allocation.width,
-				widget.allocation.height,
-				-1)
-
-      # Initialize the pixmap to white
-      @pixmap.draw_rectangle(widget.style.white_gc,
-			     true,
-			     0, 0,
-			     widget.allocation.width,
-			     widget.allocation.height)
+      @cairo_context = widget.window.create_cairo_context
+      @cairo_context.set_source_rgb(1, 1, 1)
+      @cairo_context.paint
 
       # We've handled the configure event, no need for further processing.
       return true
@@ -112,41 +103,32 @@ module Demo
 
     CHECK_SIZE = 10
     SPACING = 2
-    def checkerboard_expose(da)
-      # At the start of an expose handler, a clip region of event.area
+    def checkerboard_draw(da, cairo_context)
+      # At the start of a draw handler, a clip region of event.area
       # is set on the window, and event.area has been cleared to the
       # widget's background color. The docs for
       # gdk_window_begin_paint_region give more details on how this
       # works.
-  
-
-      # It would be a bit more efficient to keep these
-      # GC's around instead of recreating on each expose, but
-      # this is the lazy/slow way.
-      gc1 = Gdk::GC.new(da.window)
-      gc1.rgb_fg_color = Gdk::Color.new(30000, 0, 30000)
-      
-      gc2 = Gdk::GC.new(da.window)
-      gc2.rgb_fg_color = Gdk::Color.new(65535, 65535, 65535)
 
       xcount = 0
+      width  = da.allocated_width
+      height = da.allocated_height
       SPACING.step(da.allocation.width, CHECK_SIZE + SPACING) do |i|
-	ycount = xcount % 2; # start with even/odd depending on row
-	SPACING.step(da.allocation.height, CHECK_SIZE + SPACING) do |j|
-	  gc = if ycount % 2 == 1
-		 gc1
-	       else
-		 gc2
-	       end
-	  
-	  # If we're outside event.area, this will do nothing.
-	  # It might be mildly more efficient if we handled
-	  # the clipping ourselves, but again we're feeling lazy.
-
-	  da.window.draw_rectangle(gc, true, i, j, CHECK_SIZE, CHECK_SIZE)
-	  ycount += 1
-	end
-	xcount += 1
+        ycount = xcount % 2; # start with even/odd depending on row
+        SPACING.step(da.allocation.height, CHECK_SIZE + SPACING) do |j|
+          if ycount % 2 == 1
+            cairo_context.set_source_rgb(0.45777, 0, 0.45777)
+          else
+            cairo_context.set_source_rgb(1, 1, 1)
+          end
+
+          # If we're outside the clip, this will do nothing.
+          cairo_context.fill do
+            cairo_context.rectangle(i, j, CHECK_SIZE, CHECK_SIZE)
+          end
+          ycount += 1
+        end
+        xcount += 1
       end
       # return true because we've handled this event, so no
       # further processing is required.
@@ -154,43 +136,36 @@ module Demo
       return true
     end
 
-    # Redraw the screen from the pixmap
-    def scribble_expose_event(widget, event)
-      # We use the 'foreground GC' for the widget since it already exists,
-      # but honestly any GC would work. The only thing to worry about
-      # is whether the GC has an inappropriate clip region set.
-      widget.window.draw_drawable(widget.style.fg_gc(widget.state),
-				  @pixmap,
-				  # Only copy the area that was exposed.
-				  event.area.x, event.area.y,
-				  event.area.x, event.area.y,
-				  event.area.width, event.area.height)
+    # Redraw the screen from the surface
+    def scribble_draw(widget, event)
+      event.set_source(@cairo_context.target)
+      event.paint
       return false
     end
 
-  
-
+    # Draw a rectangle on the screen
     def draw_brush(widget, x, y)
       update_rect = Gdk::Rectangle.new(x - 3, y - 3, 6, 6)
 
-      # Paint to the pixmap, where we store our state
-      @pixmap.draw_rectangle(widget.style.black_gc,
-			    true,
-			    update_rect.x, update_rect.y,
-			    update_rect.width, update_rect.height)
+      # Paint to the surface, where we store our state
+      @cairo_context.fill do
+        @cairo_context.set_source_rgb(0, 0, 0)
+        @cairo_context.rectangle(update_rect.x,
+                                 update_rect.y,
+                                 update_rect.width,
+                                 update_rect.height)
+      end
 
       # Now invalidate the affected region of the drawing area.
       widget.window.invalidate(update_rect, false)
     end
 
     def scribble_button_press_event(widget, event)
-      unless @pixmap
-	# paranoia check, in case we haven't gotten a configure event
-	return false
-      end
-  
+      # paranoia check, in case we haven't gotten a configure event
+      return false unless @cairo_context
+
       if event.button == 1
-	draw_brush(widget, event.x, event.y)
+        draw_brush(widget, event.x, event.y)
       end
 
       # We've handled the event, stop processing
@@ -198,10 +173,8 @@ module Demo
     end
 
     def scribble_motion_notify_event(widget, event)
-      unless @pixmap
-	# paranoia check, in case we haven't gotten a configure event
-	return false
-      end
+      # paranoia check, in case we haven't gotten a configure event
+      return false unless @cairo_context
 
       # This call is very important; it requests the next motion event.
       # If you don't call Gdk::Window#pointer you'll only get
@@ -212,11 +185,13 @@ module Demo
       # By requesting the next event as we handle the current one,
       # we avoid getting a huge number of events faster than we
       # can cope.
-      
-      win, x, y, state = event.window.pointer
 
-      if (state & Gdk::Window::BUTTON1_MASK) != 0
-	draw_brush(widget, x, y)
+      # NOTE: Gdk::EventMotion#window will be restored from Ruby/GDK3 2.1.1.
+      # win, x, y, state = event.window.get_device_position(event.device)
+      win, x, y, state = widget.window.get_device_position(event.device)
+
+      if (state & :button1_mask) != 0
+        draw_brush(widget, x, y)
       end
 
       # We've handled it, stop processing