gtk3 2.2.5-x64-mingw32 → 3.0.0-x64-mingw32

data/sample/misc/pango-layout.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+=begin
+  pangolayout.rb - Ruby/GTK sample script.
+
+  Copyright (c) 2005-2015  Ruby-GNOME2 Project Team
+  This program is licenced under the same licence as Ruby-GNOME2.
+=end
+
+require "gtk3"
+
+RADIUS =  80
+N_WORDS = 16
+HEIGHT = 400
+WIDTH = 400
+
+class PaintableWindow < Gtk::Window
+  attr_reader :x, :y, :width, :height
+
+  def initialize(name)
+    super(name)
+    set_app_paintable(true)
+    set_decorated(true)
+    set_default_size(WIDTH, HEIGHT)
+    signal_connect("destroy") { Gtk.main_quit }
+    set_double_buffered(false)
+
+    # Get the size attributes when the window is resized
+    signal_connect "size-allocate" do |_widget, rectangle|
+      @x = rectangle.x
+      @y = rectangle.y
+      @width = rectangle.width
+      @height = rectangle.height
+    end
+
+    signal_connect "screen-changed" do |widget, _old_screen|
+      screen_changed(widget)
+    end
+
+    screen_changed(self)
+  end
+
+  def supports_alpha?
+    @supports_alpha
+  end
+
+  private
+
+  def screen_changed(widget)
+    visual = widget.screen.rgba_visual
+    if visual && widget.screen.composited?
+      set_visual(visual)
+      @supports_alpha = true
+    else
+      set_visual(widget.screen.system_visual)
+      @supports_alpha = false
+    end
+  end
+end
+
+pangolayout = PaintableWindow.new("Pango Render")
+
+pangolayout.signal_connect "draw" do |widget, cr|
+  # Redraw on a clean destination
+  # http://cairographics.org/manual/cairo-cairo-t.html#cairo-operator-t
+  cr.set_operator(Cairo::OPERATOR_SOURCE)
+
+  if widget.supports_alpha?
+    cr.set_source_rgba(0, 0, 0, 0.3)
+  else
+    cr.set_source_rgb(1, 1, 1)
+  end
+
+  cr.paint
+
+  device_radius = [widget.width, widget.height].min / 6.0
+  cr.translate(device_radius + (widget.width - 2 * device_radius) / 2.0,
+               device_radius + (widget.height - 2 * device_radius) / 2.0)
+  cr.scale(device_radius / RADIUS, device_radius / RADIUS)
+
+  pango_layout = cr.create_pango_layout
+  pango_layout.text = "Ruby-GNOME2"
+  pango_layout.font_description = Pango::FontDescription.new("Sans Bold 14")
+
+  N_WORDS.times do |i|
+    angle = 360 * i / N_WORDS.to_f
+    cr.set_source_rgb((65_535 * rand) / 65_355,
+                      (65_535 * rand) / 65_355,
+                      (65_535 * rand) / 65_355)
+
+    cr.rotate((angle * Math::PI) / 180.0)
+    cr.update_pango_layout(pango_layout)
+    width, _height = pango_layout.size
+    cr.move_to((width / 2) / Pango::SCALE, RADIUS)
+    cr.show_pango_layout(pango_layout)
+  end
+end
+
+pangolayout.show
+
+Gtk.main

data/sample/misc/pointer-grab.rb

@@ -0,0 +1,36 @@
+=begin
+  pointer_grab.rb - Gdk::Window#pointer_grab/ungrab sample script.
+
+  Copyright (C) 2001-2015 Masao Mutoh<mutoh@highway.ne.jp>
+  This program is licenced under the same licence as Ruby-GNOME.
+=end
+
+require "gtk3"
+
+window = Gtk::Window.new("Pointer grab/ungrab sample")
+
+cursor = Gdk::Cursor.new(:watch)
+button1 = Gtk::Button.new(:label => "Grab Window!")
+button2 = Gtk::Button.new(:label => "Ungrab Window!")
+
+button1.signal_connect("clicked") do
+  Gdk.pointer_grab(window.window, true, :button_press_mask,
+                   window.window, cursor, Gdk::CURRENT_TIME)
+  p Gdk.pointer_is_grabbed?
+end
+
+button2.signal_connect("clicked") do
+  Gdk.pointer_ungrab(Gdk::CURRENT_TIME)
+  p Gdk.pointer_is_grabbed?
+end
+
+vbox = Gtk::Box.new(:vertical, 0)
+vbox.add(button1)
+vbox.add(button2)
+
+window.add(vbox)
+window.set_default_size(200, 100)
+window.show_all
+window.signal_connect("destroy") { Gtk.main_quit }
+
+Gtk.main

data/sample/misc/print.rb

@@ -1,245 +1,246 @@
 #!/usr/bin/env ruby
 =begin
-  print.rb - Gtk::Print* sample
+   print.rb - Gtk::Print* sample
 
-  Copyright (C) 2007 Mathieu Blondel
-  This program is licenced under the same licence as Ruby-GNOME2.
-
-  $Id: print.rb,v 1.1 2007/08/05 15:41:31 mutoh Exp $
+   Copyright (C) 2007 Mathieu Blondel
+   Copyright (C) 2007-2015 Ruby-GNOME2 Project Team
+   This program is licenced under the same licence as Ruby-GNOME2.
 =end
 
-require 'gtk3'
+require "gtk3"
 
 # Values returned by a Pango::Layout or set in a Pango::Layout
 # are always multiple of Pango::SCALE. Those are convenience methods to
 # deal with that.
 class Pango::Layout
-    def size_in_points
-        self.size.collect { |v| v / Pango::SCALE }
-    end
+  def size_in_points
+    size.collect { |v| v / Pango::SCALE }
+  end
 
-    def width_in_points
-        self.size[0] / Pango::SCALE
-    end
+  def width_in_points
+    size[0] / Pango::SCALE
+  end
 
-    def height_in_points
-        self.size[1] / Pango::SCALE
-    end
+  def height_in_points
+    size[1] / Pango::SCALE
+  end
 
-    def width_in_points=(width)
-        self.width = width * Pango::SCALE
-    end
+  def width_in_points=(width)
+    self.width = width * Pango::SCALE
+  end
 end
 
 class Print < Gtk::PrintOperation
-
-    FONT = Pango::FontDescription.new("sans 12")
-    FONT_SMALL = Pango::FontDescription.new("sans 8")
-
-    FONT_SIZE = 12
-    FONT_SMALL_SIZE = 8
-
-    def initialize (parent_window, text)
-        super()
-        @parent_window = parent_window
-        @text = text
-
-        # with this option disabled, the origin is the the upper left corner
-        # *taking into consideration margins* !
-        self.use_full_page = false
-        self.unit = Gtk::PaperSize::Unit::POINTS
-
-        # set default paper size
-        page_setup = Gtk::PageSetup.new
-        paper_size = Gtk::PaperSize.new(Gtk::PaperSize.default)
-        page_setup.paper_size_and_default_margins = paper_size
-        self.default_page_setup = page_setup
-
-        # show a progress bar
-        self.show_progress = true        
-
-        # You must choose between "paginate" and "begin-print".
-        # "begin-print" is emitted only once and "paginate" is emitted
-        # until the block returns true.
-        # In both cases, you must set the number of pages at the end with
-        # Gtk::PrintOperation#n_pages=
-        signal_connect("begin-print") do |pop, context|
-            puts "calls begin-print"
-            cr = context.cairo_context
-            paragraphs = @text.split("\n")
-            layouts = []
-            paragraphs.each do |para|
-                layouts << create_layout(cr, para)
-            end
-
-            # distribute paragraph layouts among pages
-            @page_layouts = []
-
-            curr_height = 0
-            n_pages = 0
-            layouts.each do |layout|
-                height = layout.height_in_points
-                if curr_height + height > real_page_height
-                    n_pages += 1
-                    curr_height = 0
-                end
-                @page_layouts[n_pages] ||= []
-                @page_layouts[n_pages] << layout
-                curr_height += height
-            end
-
-            pop.n_pages = n_pages + 1
-        end
-
-        signal_connect("draw-page") do |pop, context, page_num|
-            puts "calls draw-page %d" % page_num
-
-            cr = context.cairo_context
-
-            x, y = [0,0] # this means we start at the upper left margin  
-
-            if @page_layouts[page_num]
-                @page_layouts[page_num].each do |layout|
-                    cr.move_to(x,y)
-                    cr.show_pango_layout(layout)            
-                    y += layout.height_in_points
-                end
-                total_pages = @page_layouts.length
-            else
-                total_pages = 1
-            end
-            
-            # page_num starts at 0
-            draw_footer(cr, page_num + 1, total_pages)
+  FONT = Pango::FontDescription.new("sans 12")
+  FONT_SMALL = Pango::FontDescription.new("sans 8")
+
+  FONT_SIZE = 12
+  FONT_SMALL_SIZE = 8
+
+  def initialize(parent_window, text)
+    super()
+    @parent_window = parent_window
+    @text = text
+
+    # with this option disabled, the origin is the the upper left corner
+    # *taking into consideration margins* !
+    self.use_full_page = false
+    self.unit = Gtk::Unit::POINTS
+
+    # set default paper size
+    page_setup = Gtk::PageSetup.new
+    paper_size = Gtk::PaperSize.new(Gtk::PaperSize.default)
+    page_setup.paper_size_and_default_margins = paper_size
+    self.default_page_setup = page_setup
+
+    # show a progress bar
+    self.show_progress = true
+
+    # You must choose between "paginate" and "begin-print".
+    # "begin-print" is emitted only once and "paginate" is emitted
+    # until the block returns true.
+    # In both cases, you must set the number of pages at the end with
+    # Gtk::PrintOperation#n_pages=
+    signal_connect("begin-print") do |pop, context|
+      puts "calls begin-print"
+      cr = context.cairo_context
+      paragraphs = @text.split("\n")
+      layouts = []
+      paragraphs.each do |para|
+        layouts << create_layout(cr, para)
+      end
+
+      # distribute paragraph layouts among pages
+      @page_layouts = []
+
+      curr_height = 0
+      n_pages = 0
+      layouts.each do |layout|
+        height = layout.height_in_points
+        if curr_height + height > real_page_height
+          n_pages += 1
+          curr_height = 0
         end
-    end
-
-    def run_print_dialog
-        res = run(Action::PRINT_DIALOG, @parent_window)
-        case res
-            when RESULT_ERROR
-                puts "error"
-            when RESULT_CANCEL
-                puts "cancelled"
-            when RESULT_APPLY
-                puts "applied"
-            when RESULT_IN_PROGRESS
-                puts "in progress"
-        end
-    end
-
-    def run_preview
-        res = run(Action::PREVIEW, @parent_window)
-    end
-
-    private
-
-    def page_height
-        setup = self.default_page_setup
-        # this takes margins into consideration, contrary to get_paper_height
-        setup.get_page_height(Gtk::PaperSize::Unit::POINTS)
-    end
+        @page_layouts[n_pages] ||= []
+        @page_layouts[n_pages] << layout
+        curr_height += height
+      end
 
-    def page_width
-        setup = self.default_page_setup
-        width = setup.get_page_width(Gtk::PaperSize::Unit::POINTS)
+      pop.n_pages = n_pages + 1
     end
 
-    def real_page_height
-        page_height - footer_height
-    end
-
-    def footer_height
-        5 * FONT_SMALL_SIZE
-    end
+    signal_connect("draw-page") do |_pop, context, page_num|
+      puts format("calls draw-page %d", page_num)
+      cr = context.cairo_context
 
-    def create_layout(cr, text)
-        layout = cr.create_pango_layout
+      x, y = [0, 0] # this means we start at the upper left margin
 
-        layout.width_in_points = page_width
-        layout.font_description = FONT
-        layout.wrap = Pango::Layout::WrapMode::CHAR
-        layout.ellipsize = Pango::Layout::ELLIPSIZE_NONE
-        layout.single_paragraph_mode = false
-
-        layout.text = text
+      if @page_layouts[page_num]
+        @page_layouts[page_num].each do |layout|
+          cr.move_to(x, y)
+          cr.show_pango_layout(layout)
+          y += layout.height_in_points
+        end
+        total_pages = @page_layouts.length
+      else
+        total_pages = 1
+      end
 
-        layout
+      # page_num starts at 0
+      draw_footer(cr, page_num + 1, total_pages)
     end
-
-    def draw_footer(cr, nth_page, total_page)        
-        layout = cr.create_pango_layout
-        layout.alignment = Pango::Layout::ALIGN_RIGHT
-        layout.font_description = FONT_SMALL
-        layout.text = "Page %d/%d" % [nth_page, total_page] + "\n" + \
-            Time.now.strftime("Printed on %Y/%m/%d at %H:%M") + "\n" + \
-                "Powered by Ruby-GNOME2!"
-        width, height = layout.size_in_points
-        x, y = [page_width, page_height]
-        x -= width
-        y -= height
-        cr.move_to(x, y)
-        cr.show_pango_layout(layout)
-        cr.rel_move_to(width, -2)
-        cr.rel_line_to(-page_width, 0)
-        cr.stroke
+  end
+
+  def run_print_dialog
+    res = run(Gtk::PrintOperationAction::PRINT_DIALOG, @parent_window)
+    case res
+    when Gtk::PrintOperationResult::ERROR
+      puts "error"
+    when Gtk::PrintOperationResult::CANCEL
+      puts "cancelled"
+    when Gtk::PrintOperationResult::APPLY
+      puts "applied"
+    when Gtk::PrintOperationResult::IN_PROGRESS
+      puts "in progress"
     end
-
+  end
+
+  def run_preview
+    res = run(Gtk::PrintOperationAction::PREVIEW, @parent_window)
+  end
+
+  private
+
+  def page_height
+    setup = default_page_setup
+    # this takes margins into consideration, contrary to get_paper_height
+    setup.get_page_height(Gtk::Unit::POINTS)
+  end
+
+  def page_width
+    setup = default_page_setup
+    width = setup.get_page_width(Gtk::Unit::POINTS)
+  end
+
+  def real_page_height
+    page_height - footer_height
+  end
+
+  def footer_height
+    5 * FONT_SMALL_SIZE
+  end
+
+  def create_layout(cr, text)
+    layout = cr.create_pango_layout
+
+    layout.width_in_points = page_width
+    layout.font_description = FONT
+    layout.wrap = Pango::Layout::WrapMode::CHAR
+    layout.ellipsize = Pango::Layout::ELLIPSIZE_NONE
+    layout.single_paragraph_mode = false
+
+    layout.text = text
+
+    layout
+  end
+
+  def draw_footer(cr, nth_page, total_page)
+    layout = cr.create_pango_layout
+    layout.alignment = Pango::Layout::ALIGN_RIGHT
+    layout.font_description = FONT_SMALL
+    layout.text = format("Page %d/%d\n%s\nPowered by Ruby-GNOME2!",
+                         nth_page, total_page,
+                         Time.now.strftime("Printed on %Y/%m/%d at %H:%M"))
+    width, height = layout.size_in_points
+    x, y = [page_width, page_height]
+    x -= width
+    y -= height
+    cr.move_to(x, y)
+    cr.show_pango_layout(layout)
+    cr.rel_move_to(width, -2)
+    cr.rel_line_to(-page_width, 0)
+    cr.stroke
+  end
 end
 
 class Window < Gtk::Window
+  def initialize
+    super
 
-    def initialize
-        super
+    signal_connect("delete-event") { Gtk.main_quit }
 
-        signal_connect("delete-event") { Gtk.main_quit }
+    set_default_size(600, 600)
 
-        set_default_size(600, 600)
+    @textview = Gtk::TextView.new
+    @textview.wrap_mode = Gtk::WrapMode::WORD
+    fill_buffer
 
-        @textview = Gtk::TextView.new
-        @textview.wrap_mode = Gtk::TextTag::WrapMode::WORD
+    hbox = Gtk::Box.new(:horizontal)
 
-        hbox = Gtk::Box.new(:horizontal)
-
-        page_setup_button = Gtk::Button.new
-        page_setup_button.label = "Page setup"
-        page_setup_button.signal_connect("clicked") do
-            @page_setup = Print::run_page_setup_dialog(self, # parent window
-                                                       @page_setup)
-        end
+    page_setup_button = Gtk::Button.new(:label => "Page setup")
+    page_setup_button.signal_connect("clicked") do
+      @page_setup = Gtk.print_run_page_setup_dialog(self, # parent window
+                                                    @page_setup)
+    end
+    print_preview_button = Gtk::Button.new(:label => "Print Preview")
+    print_preview_button.signal_connect("clicked") do
+      printop = Print.new(self, @textview.buffer.text)
+      printop.default_page_setup = @page_setup if @page_setup
+      printop.run_preview
+    end
 
-        print_preview_button = Gtk::Button.new(:stock_id => Gtk::Stock::PRINT_PREVIEW)
-        print_preview_button.signal_connect("clicked") do
-            printop = Print.new(self, @textview.buffer.text)
-            printop.default_page_setup = @page_setup if @page_setup
-            printop.run_preview
-        end
+    print_button = Gtk::Button.new(:label => "Print")
+    print_button.signal_connect("clicked") do
+      printop = Print.new(self, @textview.buffer.text)
+      printop.default_page_setup = @page_setup if @page_setup
+      printop.run_print_dialog
+    end
 
-        print_button = Gtk::Button.new(:stock_id => Gtk::Stock::PRINT)
-        print_button.signal_connect("clicked") do
-            printop = Print.new(self, @textview.buffer.text)
-            printop.default_page_setup = @page_setup if @page_setup
-            printop.run_print_dialog
-        end
+    [page_setup_button, print_preview_button, print_button].each do |b|
+      hbox.pack_start(b, :expand => true, :fill => true)  # expand, fill
+    end
 
-        [page_setup_button, print_preview_button, print_button].each do |b|
-            hbox.pack_start(b, true, true)  # expand, fill
-        end
+    vbox = Gtk::Box.new(:vertical)
+    scroll = Gtk::ScrolledWindow.new
+    @textview.show
+    scroll.add(@textview)
+    scroll.set_policy(:automatic, :automatic)
+    vbox.pack_start(scroll, :expand => true, :fill => true)
+    vbox.pack_end(hbox, :expand => false, :fill => false)
 
-        scrollbar = Gtk::Scrollbar.new(:vertical)
+    add(vbox)
 
-        vbox = Gtk::Box.new(:vertical)
-        scroll = Gtk::ScrolledWindow.new.add(@textview)        
-        scroll.set_policy(:automatic, :automatic)
-        vbox.pack_start(scroll)
-        vbox.pack_end(hbox, false, false)
+    show_all
+  end
 
-        add(vbox)
+  private
 
-        show_all
-        
+  def fill_buffer
+    open(__FILE__).read.each_line do |line|
+      @textview.buffer.insert_at_cursor(line)
     end
-
+    @textview.buffer.place_cursor(@textview.buffer.start_iter)
+  end
 end
 
 Window.new