gtk3 3.0.9-x64-mingw32 → 3.1.0-x64-mingw32

data/sample/gtk-demo/drawingarea.rb

@@ -1,205 +1,172 @@
-# Copyright (c) 2003-2014 Ruby-GNOME2 Project Team
+# Copyright (c) 2016 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 $
 =begin
-= Drawing Area
+=  Drawing Area
 
-Gtk::DrawingArea is a blank area where you can draw custom displays
-of various kinds.
+ GtkDrawingArea is a blank area where you can draw custom displays
+ of various kinds.
 
-This demo has two drawing areas. The checkerboard area shows
-how you can just draw something; all you have to do is write
-a signal handler for expose_event, as shown here.
+ This demo has two drawing areas. The checkerboard area shows
+ how you can just draw something; all you have to do is write
+ a signal handler for expose_event, as shown here.
 
-The 'scribble' area is a bit more advanced, and shows how to handle
-events such as button presses and mouse motion. Click the mouse
-and drag in the scribble area to draw squiggles. Resize the window
-to clear the area.
+ The "scribble" area is a bit more advanced, and shows how to handle
+ events such as button presses and mouse motion. Click the mouse
+ and drag in the scribble area to draw squiggles. Resize the window
+ to clear the area.
 =end
+class DrawingareaDemo
+  def initialize(main_window)
+    @window = Gtk::Window.new(:toplevel)
+    @window.screen = main_window.screen
+    @window.title = "Drawing Area"
+    @window.border_width = 8
+
+    initialize_vbox
+    create_the_checkerboard_area
+    create_the_scribble_area
+  end
 
-require "common"
-
-module Demo
-  class DrawingArea < BasicWindow
-    def initialize
-      # Pixmap for scribble area, to store current scribbles
-      @cairo_context = nil
-      super("Drawing Area")
-
-      self.border_width = 8
+  def run
+    if !@window.visible?
+      @window.show_all
+    else
+      @window.destroy
+    end
+    @window
+  end
 
-      vbox = Gtk::Box.new(:vertical, 8)
-      vbox.border_width = 8
-      add(vbox)
+  private
 
-      ## Create the checkerboard area
-      label = Gtk::Label.new
-      label.set_markup("<u>Checkerboard pattern</u>")
-      vbox.pack_start(label, :expand => false, :fill => false, :padding => 0)
+  def initialize_vbox
+    @vbox = Gtk::Box.new(:vertical, 8)
+    @vbox.border_width = 8
+    @window.add(@vbox)
+  end
 
-      frame = Gtk::Frame.new
-      frame.shadow_type = :in
-      vbox.pack_start(frame, :expand => true, :fill => true, :padding => 0)
+  def create_da_in_frame(text)
+    label = Gtk::Label.new
+    label.set_markup(text, :use_underline => true)
+    @vbox.pack_start(label, :expand => false, :fill => false, :padding => 0)
 
-      da = Gtk::DrawingArea.new
-      # set a minimum size
-      da.set_size_request(100, 100)
+    frame = Gtk::Frame.new
+    frame.shadow_type = :in
+    @vbox.pack_start(frame, :expand => true, :fill => true, :padding => 0)
 
-      frame.add(da)
+    da = Gtk::DrawingArea.new
+    da.set_size_request(100, 100)
+    frame.add(da)
+    da
+  end
 
-      da.signal_connect("draw") do |widget, event|
-        checkerboard_draw(widget, event)
+  def checkerboard_draw(da, cr)
+    check_size = 10
+    spacing = 2
+    # At the start of a draw handler, a clip region has been set on
+    # the Cairo context, and the contents have been cleared to the
+    # widget's background color. The docs for
+    # gdk_window_begin_paint_region() give more details on how this
+    # works.
+    ycount = 0
+    xcount = 0
+    i = spacing
+    while i < da.allocated_width
+      j = spacing
+      ycount = xcount % 2 # start with even/odd depending on row
+      while j < da.allocated_height
+        if ycount % 2
+          cr.set_source_rgb(0.45777, 0, 0.45777)
+        else
+          cr.set_source_rgb(1, 1, 1)
+        end
+        # if we are outside the clip, this will do nothing
+        cr.rectangle(i, j, check_size, check_size)
+        cr.fill
+        j += check_size + spacing
+        ++ycount
       end
+      i += check_size + spacing
+      ++xcount
+    end
+  end
 
-      ## Create the scribble area
-      label = Gtk::Label.new
-      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)
+  def create_the_checkerboard_area
+    da = create_da_in_frame("<u>Checkerboard pattern</u>")
+    da.signal_connect "draw" do |widget, cr|
+      checkerboard_draw(widget, cr)
+    end
+  end
 
-      da = Gtk::DrawingArea.new
-      # set a minimum size
-      da.set_size_request(100, 100)
+  def scribble_configure_event(da)
+    @surface.destroy if @surface
+
+    @surface = da.window.create_similar_surface(Cairo::CONTENT_COLOR,
+                                                da.allocated_width,
+                                                da.allocated_height)
+    # initialize the surface to white
+    cr = Cairo::Context.new(@surface)
+    cr.set_source_rgb(1, 1, 1)
+    cr.paint
+    cr.destroy
+    # we have handled the configure event, no need to further processing
+    true
+  end
 
-      frame.add(da)
+  def scribble_draw(cr)
+    # Redraw the screen from the surface
+    cr.set_source(@surface, 0, 0)
+    cr.paint
+    false
+  end
 
-      # Signals used to handle backing pixmap
-      da.signal_connect("draw") do |*args|
-        scribble_draw(*args)
-      end
-      da.signal_connect("configure-event") do |widget, event|
-        scribble_configure_event(widget)
-      end
+  def draw_brush(widget, x, y)
+    cr = Cairo::Context.new(@surface)
+    cr.rectangle(x - 3, y - 3, 6, 6)
+    cr.fill
+    cr.destroy
+    widget.queue_draw_area(x - 3, y - 3, 6, 6)
+  end
 
-      # Event signals
-      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)
-      end
+  def scribble_button_press_event(da, event)
+    return false unless @surface
+    draw_brush(da, event.x, event.y) if event.button == Gdk::BUTTON_PRIMARY
+    true
+  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)
+  def scribble_motion_notify_event(da, event)
+    return false unless @surface
+    _window, x, y, state = event.window.get_device_position(event.device)
+    if (state & Gdk::EventMask::BUTTON_PRESS_MASK.to_i).nonzero?
+      draw_brush(da, x, y)
     end
+    true
+  end
 
-    # Create a new surface of the appropriate size to store our scribbles
-    def scribble_configure_event(widget)
-      allocation = widget.allocation
-      surface = widget.window.create_similar_surface(:color,
-                                                     allocation.width,
-                                                     allocation.height)
-      @cairo_context = Cairo::Context.new(surface)
-      @cairo_context.set_source_rgb(1, 1, 1)
-      @cairo_context.paint
-
-      # We've handled the configure event, no need for further processing.
-      return true
-    end
+  def create_the_scribble_area
+    da = create_da_in_frame("<u>Scribble area</u>")
 
-    CHECK_SIZE = 10
-    SPACING = 2
-    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.
-
-      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|
-          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.
-      #
-      return true
+    da.signal_connect "draw" do |_widget, cr|
+      scribble_draw(cr)
     end
 
-    # Redraw the screen from the surface
-    def scribble_draw(widget, event)
-      event.set_source(@cairo_context.target)
-      event.paint
-      return false
+    da.signal_connect "configure-event" do |widget|
+      scribble_configure_event(widget)
     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 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)
+    da.signal_connect "motion-notify-event" do |widget, event|
+      scribble_motion_notify_event(widget, event)
     end
 
-    def scribble_button_press_event(widget, event)
-      # 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)
-      end
-
-      # We've handled the event, stop processing
-      return true
+    da.signal_connect "button-press-event" do |widget, event|
+      scribble_button_press_event(widget, event)
     end
 
-    def scribble_motion_notify_event(widget, event)
-      # 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
-      # a single motion event. The reason is that we specified
-      # Gdk::POINTER_MOTION_HINT_MASK to Gtk::Widget#set_events.
-      # If we hadn't specified that, we could just use event.x, event.y
-      # as the pointer location. But we'd also get deluged in events.
-      # By requesting the next event as we handle the current one,
-      # we avoid getting a huge number of events faster than we
-      # can cope.
-
-      # 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
-      return true
-    end
+#    da.events |= (Gdk::EventMask::LEAVE_NOTIFY_MASK |
+#                    Gdk::EventMask::BUTTON_PRESS_MASK |
+#                    Gdk::EventMask::POINTER_MOTION_MASK |
+#                    Gdk::EventMask::POINTER_MOTION_HINT_MASK)
+    da.add_events([:leave_notify_mask, :button_press_mask,
+                   :pointer_motion_mask, :pointer_motion_hint_mask])
   end
 end

data/sample/gtk-demo/editable_cells.rb

@@ -1,173 +1,212 @@
-# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# Copyright (c) 2016 Ruby-GNOME2 Project Team
 # This program is licenced under the same licence as Ruby-GNOME2.
 #
-# $Id: editable_cells.rb,v 1.7 2005/02/06 18:25:13 kzys Exp $
 =begin
-= Tree View/Editable Cells
+=  Tree View/Editable Cells
 
-This demo demonstrates the use of editable cells in a Gtk::TreeView. If
-you're new to the Gtk::TreeView widgets and associates, look into
-the Gtk::ListStore example first.
-=end
-require 'common'
+ This demo demonstrates the use of editable cells in a GtkTreeView. If
+ you're new to the GtkTreeView widgets and associates, look into
+ the GtkListStore example first. It also shows how to use the
+ GtkCellRenderer::editing-started signal to do custom setup of the
+ editable widget.
 
-module Demo
-  class EditableCells < BasicWindow
-    Item = Struct.new('Item', :number, :product, :editable)
-    COLUMN_NUMBER, COLUMN_PRODUCT, COLUMN_EDITABLE, NUM_COLUMNS = *(0..4).to_a
+ The cell renderers used in this demo are GtkCellRendererText,
+ GtkCellRendererCombo and GtkCellRendererProgress.
+=end
+class EditableCellsDemo
+  Item = Struct.new("Item", :number, :product, :yummy)
+  COL_ITEM_NUM, COL_ITEM_PROD, COL_ITEM_YUMMY = *(0..3).to_a
+  COL_NUM_TEXT = 0
 
-    def initialize
-      super('Shopping list')
-      self.border_width = 5
+  def initialize(main_window)
+    @window = Gtk::Window.new(:toplevel)
+    @window.screen = main_window.screen
+    @window.title = "Editable Cells"
+    @window.border_width = 5
 
-      vbox = Gtk::VBox.new(false, 5)
-      add(vbox)
+    vbox = Gtk::Box.new(:vertical, 5)
+    @window.add(vbox)
+    label = Gtk::Label.new("Shopping list (you can edit the cells)")
+    vbox.pack_start(label, :expand => false, :fill => true, :padding => 0)
 
-      vbox.pack_start(Gtk::Label.new('Shopping list (you can edit the cells!)'),
-                      :expand => false, :fill => false, :padding => 0)
+    sw = Gtk::ScrolledWindow.new
+    sw.shadow_type = :etched_in
+    sw.set_policy(:automatic, :automatic)
+    vbox.pack_start(sw, :expand => true, :fill => true, :padding => 0)
 
-      sw = Gtk::ScrolledWindow.new
-      sw.shadow_type = Gtk::SHADOW_ETCHED_IN
-      sw.set_policy(:automatic, :automatic)
-      vbox.pack_start(sw, :expand => true, :fill => true, :padding => 0)
+    # create models
+    create_items_model
+    create_numbers_model
 
-      # create model
-      model = create_model
+    # create tree view
+    @treeview = Gtk::TreeView.new(@items_model)
+    @treeview.selection.mode = :single
 
-      # create tree view
-      treeview = Gtk::TreeView.new(model)
-      treeview.rules_hint = true
-      treeview.selection.mode = Gtk::SELECTION_SINGLE
+    add_columns
 
-      add_columns(treeview)
+    sw.add(@treeview)
 
-      sw.add(treeview)
+    # Some buttons
+    hbox = Gtk::Box.new(:horizontal, 4)
+    hbox.homogeneous = true
+    vbox.pack_start(hbox, :expand => false, :fill => false, :padding => 0)
 
-      # some buttons
-      hbox = Gtk::Box.new(:horizontal, 4)
-      hbox.homogeneous = true
-      vbox.pack_start(hbox, :expand => false, :fill => false, :padding => 0)
+    button = Gtk::Button.new(:label => "Add item")
+    button.signal_connect("clicked") { add_item }
+    hbox.pack_start(button, :expand => true, :fill => true, :padding => 0)
 
-      button = Gtk::Button.new('Add item')
-      button.signal_connect('clicked') do
-        add_item(model)
-      end
-      hbox.pack_start(button, :expand => true, :fill => true, :padding => 0)
+    button = Gtk::Button.new(:label => "Remove item")
+    button.signal_connect("clicked") { remove_item }
 
-      button = Gtk::Button.new('Remove item')
-      button.signal_connect('clicked') do
-        remove_item(treeview)
-      end
-      hbox.pack_start(button, :expand => true, :fill => true, :padding => 0)
+    hbox.pack_start(button, :expand => true, :fill => true, :padding => 0)
+    @window.set_default_size(320, 200)
+  end
 
-      set_default_size(320, 200)
+  def run
+    if !@window.visible?
+      @window.show_all
+    else
+      @window.destroy
     end
+    @window
+  end
 
-    def create_model
-      # create array
-      @articles = []
+  private
+
+  def add_item
+    return if @items.nil?
+    item = Item.new(0, "Description here", 50)
+    @items << item
+
+    # Insert a row below the current one
+    path = @treeview.cursor[0]
+    iter = if path
+             current = @items_model.get_iter(path)
+             @items_model.insert_after(current)
+           else
+             @items_model.insert(-1)
+           end
+
+    # set the data for the new row
+    item.each_with_index do |value, index|
+      iter[index] = value
+    end
 
-      add_items
+    # Move focus to the new row
+    path = @items_model.get_path(iter)
+    column = @treeview.get_column(0)
+    @treeview.set_cursor(path, column, false)
+  end
 
-      # create list store
-      model = Gtk::ListStore.new(Integer, String, TrueClass)
+  def remove_item
+    selection = @treeview.selection
+    iter = selection.selected
+    if iter
+      path = @items_model.get_path(iter)
+      i = path.indices[0]
+      @items_model.remove(iter)
+      @items.delete_at(i)
+    end
+  end
 
-      # add items
-      @articles.each do |article|
-        iter = model.append
+  def add_items
+    @items << Item.new(3, "bottles of coke", 20)
+    @items << Item.new(5, "packages of noodles", 50)
+    @items << Item.new(2, "packages of chocolate chip cookies", 90)
+    @items << Item.new(1, "can vanilla ice cream", 60)
+    @items << Item.new(6, "eggs", 10)
+  end
 
-        article.each_with_index do |value, index|
-          iter.set_value(index, value)
-        end
-      end
-      return model
+  def create_items_model
+    @items = []
+    add_items
+
+    # Create list store
+    @items_model = Gtk::ListStore.new(Integer, String, Integer, TrueClass)
+    @items.each do |item|
+      iter = @items_model.append
+      iter[COL_ITEM_NUM] = item.number
+      iter[COL_ITEM_PROD] = item.product
+      iter[COL_ITEM_YUMMY] = item.yummy
     end
+  end
 
-    def add_items
-      item = Item.new(3, 'bottles of coke', true)
-      @articles.push(item)
+  def create_numbers_model
+    @numbers_model = Gtk::ListStore.new(String, Integer)
+    (1..10).each do |n|
+      iter = @numbers_model.append
+      iter[COL_NUM_TEXT] = n.to_s
+    end
+  end
 
-      item = Item.new(5, 'packages of noodles', true)
-      @articles.push(item)
+  def add_columns
+    add_number_column
+    add_product_column
+    add_yummy_column
+  end
 
-      item = Item.new(2, 'packages of chocolate chip cookies', true)
-      @articles.push(item)
+  def add_number_column
+    renderer = Gtk::CellRendererCombo.new
+    renderer.model = @numbers_model
+    renderer.text_column = COL_NUM_TEXT
+    renderer.has_entry = false
+    renderer.editable = true
 
-      item = Item.new(1, 'can vanilla ice cream', true)
-      @articles.push(item)
+    renderer.signal_connect "edited" do |cell, path, new_text|
+      cell_edited(cell, path, new_text)
+    end
 
-      item = Item.new(6, 'eggs', true)
-      @articles.push(item)
+    renderer.signal_connect "editing-started" do |_cell, editable, path|
+      editable.set_row_separator_func do |model, iter|
+        path = model.get_path(iter)
+        idx = path.indices[0]
+        idx == 5
+      end
     end
 
-    def add_columns(treeview)
-      model = treeview.model
+    def renderer.column
+      COL_ITEM_NUM
+    end
 
-      # number column
-      renderer = Gtk::CellRendererText.new
-      renderer.signal_connect('edited') do |*args|
-        cell_edited(*args.push(model))
-      end
-      treeview.insert_column(-1, 'Number', renderer,
-                             {
-                               :text => COLUMN_NUMBER,
-                               :editable => COLUMN_EDITABLE,
-                             })
-      def renderer.column
-        COLUMN_NUMBER
-      end
+    @treeview.insert_column(-1, "Number", renderer, :text => COL_ITEM_NUM)
+  end
 
-      # product column
-      renderer = Gtk::CellRendererText.new
-      renderer.signal_connect('edited') do |*args|
-        cell_edited(*args.push(model))
-      end
-      def renderer.column
-        COLUMN_PRODUCT
-      end
-      treeview.insert_column(-1, 'Product', renderer,
-                             {
-                               :text => COLUMN_PRODUCT,
-                               :editable => COLUMN_EDITABLE,
-                             })
+  def add_product_column
+    renderer = Gtk::CellRendererText.new
+    renderer.editable = true
+    renderer.signal_connect "edited" do |cell, path, new_text|
+      cell_edited(cell, path, new_text)
     end
 
-    def cell_edited(cell, path_string, new_text, model)
-      path = Gtk::TreePath.new(path_string)
-
-      column = cell.column
-
-      iter = model.get_iter(path)
-      case column
-      when COLUMN_NUMBER
-        i = iter.path.indices[0]
-        @articles[i].number = new_text.to_i
-        iter.set_value(column, @articles[i].number)
-      when COLUMN_PRODUCT
-        i = iter.path.indices[0]
-        @articles[i].product = new_text
-        iter.set_value(column, @articles[i].product)
-      end
+    def renderer.column
+      COL_ITEM_PROD
     end
 
-    def add_item(model)
-      foo = Item.new(0, 'Description here', true)
-      @articles.concat([foo])
+    @treeview.insert_column(-1, "Product", renderer, :text => COL_ITEM_PROD)
+  end
 
-      iter = model.append
-      foo.each_with_index do |value, index|
-        iter.set_value(index, value)
-      end
+  def add_yummy_column
+    renderer = Gtk::CellRendererProgress.new
+    def renderer.column
+      COL_ITEM_YUMMY
     end
+    @treeview.insert_column(-1, "Yummy", renderer, :value => COL_ITEM_YUMMY)
+  end
 
-    def remove_item(treeview)
-      model = treeview.model
-      selection = treeview.selection
-
-      if iter = selection.selected
-        @articles.delete_at(iter.path.indices[0])
-        model.remove(iter)
-      end
+  def cell_edited(cell, path_string, new_text)
+    path = Gtk::TreePath.new(path_string)
+    column = cell.column
+    iter = @items_model.get_iter(path)
+
+    case column
+    when COL_ITEM_NUM
+      i = path.indices[0]
+      @items[i].number = new_text.to_i
+      iter.set_value(column, @items[i].number)
+    when COL_ITEM_PROD
+      i = path.indices[0]
+      @items[i].product = new_text
+      iter.set_value(column, @items[i].product)
     end
   end
 end