gtk3 2.2.4-x64-mingw32

data/sample/gtk-demo/dialog.rb

@@ -0,0 +1,137 @@
+# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+# $Id: dialog.rb,v 1.5 2005/02/12 23:02:43 kzys Exp $
+=begin
+= Dialog and Message Boxes
+
+Dialog widgets are used to pop up a transient window for user feedback.
+=end
+
+require 'common'
+
+module Demo
+  class Dialog < Demo::BasicWindow
+    def initialize
+      @count = 1
+
+      super('Dialogs')
+      set_border_width(8)
+
+      frame = Gtk::Frame.new('Dialogs')
+      add(frame)
+
+      vbox = Gtk::VBox.new(false, 8)
+      vbox.set_border_width(8)
+      frame.add(vbox)
+
+      # Standard message dialog
+      hbox = Gtk::Box.new(:horizontal, 0)
+      vbox.pack_start(hbox, :expand => false, :fill => false, :padding => 0)
+      button = Gtk::Button.new('_Message Dialog', true)
+      button.signal_connect('clicked') do
+        message_dialog_clicked
+      end
+      hbox.pack_start(button, :expand => false, :fill => false, :padding => 0)
+
+      vbox.pack_start(Gtk::HSeparator.new, :expand => false, :fill => false, :padding => 0)
+
+      # Interactive dialog
+      hbox = Gtk::Box.new(:horizontal, 8)
+      vbox.pack_start(hbox, :expand => false, :fill => false, :padding => 0)
+      vbox2 = Gtk::VBox.new(false, 0)
+
+      button = Gtk::Button.new('_Interactive Dialog')
+      button.signal_connect('clicked') do
+        interactive_dialog_clicked
+      end
+      hbox.pack_start(vbox2, :expand => false, :fill => false, :padding => 0)
+      vbox2.pack_start(button, :expand => false, :fill => false, :padding => 0)
+
+      table = Gtk::Table.new(2, 2, false)
+      table.set_row_spacings(4)
+      table.set_column_spacings(4)
+      hbox.pack_start(table, :expand => false, :fill => false, :padding => 0)
+
+      label = Gtk::Label.new('_Entry 1', true)
+      table.attach_defaults(label, 0, 1, 0, 1)
+
+      @entry1 = Gtk::Entry.new
+      table.attach_defaults(@entry1, 1, 2, 0, 1)
+      label.set_mnemonic_widget(@entry1)
+
+      label = Gtk::Label.new('E_ntry 2', true)
+
+      table.attach_defaults(label, 0, 1, 1, 2)
+
+      @entry2 = Gtk::Entry.new
+      table.attach_defaults(@entry2, 1, 2, 1, 2)
+      label.set_mnemonic_widget(@entry2)
+    end
+
+    def message_dialog_clicked
+      dialog = Gtk::MessageDialog.new(self,
+                                      Gtk::Dialog::MODAL |
+                                      Gtk::Dialog::DESTROY_WITH_PARENT,
+                                      Gtk::MessageDialog::INFO,
+                                      Gtk::MessageDialog::BUTTONS_OK,
+                                      <<EOS)
+This message box has been popped up the following
+number of times:
+
+#{@count}
+EOS
+      dialog.run
+      dialog.destroy
+      @count += 1
+    end
+
+    def interactive_dialog_clicked
+      dialog = Gtk::Dialog.new('Interactive Dialog',
+                               self,
+                               Gtk::Dialog::MODAL |
+                               Gtk::Dialog::DESTROY_WITH_PARENT,
+                               [Gtk::Stock::OK, Gtk::Dialog::RESPONSE_OK],
+                               ["_Non-stock Button", Gtk::Dialog::RESPONSE_CANCEL]
+                               )
+
+      hbox = Gtk::Box.new(:horizontal, 0)
+      hbox.set_border_width(8)
+      dialog.vbox.pack_start(hbox, :expand => false, :fill => false, :padding => 0)
+
+      stock = Gtk::Image.new(Gtk::Stock::DIALOG_QUESTION, Gtk::IconSize::DIALOG)
+      hbox.pack_start(stock, :expand => false, :fill => false, :padding => 0)
+
+      table = Gtk::Table.new(2, 2, false)
+      table.set_row_spacings(4)
+      table.set_column_spacings(4)
+      hbox.pack_start(table, :expand => true, :fill => true, :padding => 0)
+      label = Gtk::Label.new('_Entry 1', true)
+      table.attach_defaults(label,
+                            0, 1, 0, 1)
+      local_entry1 = Gtk::Entry.new
+      local_entry1.text = @entry1.text
+      table.attach_defaults(local_entry1, 1, 2, 0, 1)
+      label.set_mnemonic_widget(local_entry1)
+
+      label = Gtk::Label.new('E_ntry 2', true)
+      table.attach_defaults(label,
+                            0, 1, 1, 2)
+
+      local_entry2 = Gtk::Entry.new
+      local_entry2.text = @entry2.text
+      table.attach_defaults(local_entry2, 1, 2, 1, 2)
+      label.set_mnemonic_widget(local_entry2)
+
+      hbox.show_all
+      response = dialog.run
+
+      if response == Gtk::Dialog::RESPONSE_OK
+        @entry1.text = local_entry1.text
+        @entry2.text = local_entry2.text
+      end
+      dialog.destroy
+    end
+  end
+end
+

data/sample/gtk-demo/drawingarea.rb

@@ -0,0 +1,205 @@
+# 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 $
+=begin
+= Drawing Area
+
+Gtk::DrawingArea 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.
+
+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
+
+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
+
+      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>")
+      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("draw") do |widget, event|
+        checkerboard_draw(widget, event)
+      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)
+
+      da = Gtk::DrawingArea.new
+      # set a minimum size
+      da.set_size_request(100, 100)
+
+      frame.add(da)
+
+      # 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
+
+      # 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
+
+      # 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)
+    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
+
+    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
+    end
+
+    # 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 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)
+      # 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
+    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
+  end
+end

data/sample/gtk-demo/editable_cells.rb

@@ -0,0 +1,173 @@
+# Copyright (c) 2003-2005 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
+
+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'
+
+module Demo
+  class EditableCells < BasicWindow
+    Item = Struct.new('Item', :number, :product, :editable)
+    COLUMN_NUMBER, COLUMN_PRODUCT, COLUMN_EDITABLE, NUM_COLUMNS = *(0..4).to_a
+
+    def initialize
+      super('Shopping list')
+      self.border_width = 5
+
+      vbox = Gtk::VBox.new(false, 5)
+      add(vbox)
+
+      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 = Gtk::SHADOW_ETCHED_IN
+      sw.set_policy(:automatic, :automatic)
+      vbox.pack_start(sw, :expand => true, :fill => true, :padding => 0)
+
+      # create model
+      model = create_model
+
+      # create tree view
+      treeview = Gtk::TreeView.new(model)
+      treeview.rules_hint = true
+      treeview.selection.mode = Gtk::SELECTION_SINGLE
+
+      add_columns(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)
+
+      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('Remove item')
+      button.signal_connect('clicked') do
+        remove_item(treeview)
+      end
+      hbox.pack_start(button, :expand => true, :fill => true, :padding => 0)
+
+      set_default_size(320, 200)
+    end
+
+    def create_model
+      # create array
+      @articles = []
+
+      add_items
+
+      # create list store
+      model = Gtk::ListStore.new(Integer, String, TrueClass)
+
+      # add items
+      @articles.each do |article|
+        iter = model.append
+
+        article.each_with_index do |value, index|
+          iter.set_value(index, value)
+        end
+      end
+      return model
+    end
+
+    def add_items
+      item = Item.new(3, 'bottles of coke', true)
+      @articles.push(item)
+
+      item = Item.new(5, 'packages of noodles', true)
+      @articles.push(item)
+
+      item = Item.new(2, 'packages of chocolate chip cookies', true)
+      @articles.push(item)
+
+      item = Item.new(1, 'can vanilla ice cream', true)
+      @articles.push(item)
+
+      item = Item.new(6, 'eggs', true)
+      @articles.push(item)
+    end
+
+    def add_columns(treeview)
+      model = treeview.model
+
+      # 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
+
+      # 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,
+                             })
+    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
+    end
+
+    def add_item(model)
+      foo = Item.new(0, 'Description here', true)
+      @articles.concat([foo])
+
+      iter = model.append
+      foo.each_with_index do |value, index|
+        iter.set_value(index, value)
+      end
+    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
+    end
+  end
+end