gtk3 0.0.1 → 1.2.0

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::HBox.new(false, 0)
+      vbox.pack_start(hbox, false, false, 0)
+      button = Gtk::Button.new('_Message Dialog', true)
+      button.signal_connect('clicked') do
+	message_dialog_clicked
+      end
+      hbox.pack_start(button, false, false, 0)
+
+      vbox.pack_start(Gtk::HSeparator.new, false, false, 0)
+
+      # Interactive dialog
+      hbox = Gtk::HBox.new(false, 8)
+      vbox.pack_start(hbox, false, false, 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, false, false, 0)
+      vbox2.pack_start(button, false, false, 0)
+
+      table = Gtk::Table.new(2, 2, false)
+      table.set_row_spacings(4)
+      table.set_column_spacings(4)
+      hbox.pack_start(table, false, false, 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::HBox.new(false, 0)
+      hbox.set_border_width(8)
+      dialog.vbox.pack_start(hbox, false, false, 0)
+
+      stock = Gtk::Image.new(Gtk::Stock::DIALOG_QUESTION, Gtk::IconSize::DIALOG)
+      hbox.pack_start(stock, false, false, 0)
+
+      table = Gtk::Table.new(2, 2, false)
+      table.set_row_spacings(4)
+      table.set_column_spacings(4)
+      hbox.pack_start(table, true, true, 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,226 @@
+# Copyright (c) 2003-2005 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
+      @pixmap = nil
+      super('Drawing Area')
+
+      self.border_width = 8
+
+      vbox = Gtk::VBox.new(false, 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, false, false, 0)
+      
+      frame = Gtk::Frame.new
+      frame.shadow_type = Gtk::SHADOW_IN
+      vbox.pack_start(frame, true, true, 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)
+      end
+
+      ## Create the scribble area
+      label = Gtk::Label.new
+      label.set_markup('<u>Scribble area</u>')
+      vbox.pack_start(label, false, false, 0)
+      
+      frame = Gtk::Frame.new
+      frame.shadow_type = Gtk::SHADOW_IN
+      vbox.pack_start(frame, true, true, 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('expose_event') do |*args|
+	scribble_expose_event(*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 pixmap 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)
+
+      # We've handled the configure event, no need for further processing.
+      return true
+    end
+
+    CHECK_SIZE = 10
+    SPACING = 2
+    def checkerboard_expose(da)
+      # At the start of an expose 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
+      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
+      end
+      # return true because we've handled this event, so no
+      # further processing is required.
+      #
+      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)
+      return false
+    end
+
+  
+
+    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)
+
+      # 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
+  
+      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)
+      unless @pixmap
+	# paranoia check, in case we haven't gotten a configure event
+	return false
+      end
+
+      # 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.
+      
+      win, x, y, state = event.window.pointer
+
+      if (state & Gdk::Window::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,172 @@
+# 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!)'),
+		      false, false, 0)
+
+      sw = Gtk::ScrolledWindow.new
+      sw.shadow_type = Gtk::SHADOW_ETCHED_IN
+      sw.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC)
+      vbox.pack_start(sw, true, true, 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::HBox.new(true, 4)
+      vbox.pack_start(hbox, false, false, 0)
+
+      button = Gtk::Button.new('Add item')
+      button.signal_connect('clicked') do
+	add_item(model)
+      end
+      hbox.pack_start(button, true, true, 0)
+
+      button = Gtk::Button.new('Remove item')
+      button.signal_connect('clicked') do
+	remove_item(treeview)
+      end
+      hbox.pack_start(button, true, true, 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