glib2 0.90.2-x86-mingw32

data/sample/timeout.rb

@@ -0,0 +1,28 @@
+=begin
+  timeout.rb - Sample for GLib::Timeout, GLib::MainLoop.
+
+  Copyright (C) 2005 Ruby-GNOME2 Project Team
+  This program is licenced under the same licence as Ruby-GNOME2.
+
+  $Id: timeout.rb,v 1.2 2005/07/14 17:05:22 mutoh Exp $
+=end
+
+require 'glib2'
+
+mainloop = GLib::MainLoop.new(nil, true)
+
+i = 0
+GLib::Timeout.add(1000) {
+  i += 1
+  p "timeout-#{i}"
+  if i > 9
+    mainloop.quit 
+    false # the source is removed.
+  else
+    true  # continue ...
+  end
+}
+
+mainloop.run
+
+p "quit..."

data/sample/timeout2.rb

@@ -0,0 +1,35 @@
+=begin
+  timeout2.rb - Sample for GLib::Timeout, GLib::MainLoop.
+
+  Copyright (C) 2005 Ruby-GNOME2 Project Team
+  This program is licenced under the same licence as Ruby-GNOME2.
+
+  $Date: 2005/03/13 15:43:32 $
+  $Id: timeout2.rb,v 1.2 2005/03/13 15:43:32 mutoh Exp $
+=end
+
+require 'glib2'
+
+context = GLib::MainContext.new
+
+mainloop = GLib::MainLoop.new(context, true)
+
+source = GLib::Timeout.source_new(1000)
+
+i = 0
+source.set_callback {
+  i += 1
+  p "timeout2-#{i}"
+  if i > 9
+    mainloop.quit 
+    false # the source is removed.
+  else
+    true  # continue ...
+  end
+
+}
+source.attach(context)
+
+mainloop.run
+
+p "quit..."

data/sample/timer.rb

@@ -0,0 +1,40 @@
+=begin
+  timer.rb - Sample for GLib::Timer
+
+  Copyright (C) 2005 Ruby-GNOME2 Project Team
+  This program is licenced under the same licence as Ruby-GNOME2.
+
+  $Id: timer.rb,v 1.1 2005/10/14 19:48:41 mutoh Exp $
+=end
+
+require 'glib2'
+
+timer = GLib::Timer.new
+
+timer.start
+puts "start (status = running) : #{timer.elapsed}"
+
+sleep(3)
+
+puts "after 3 sec (status = running) : #{timer.elapsed}"
+
+sleep(3)
+
+puts "after 3 sec (status = running) : #{timer.elapsed}"
+timer.stop
+puts "stop (status = stoped) : #{timer.elapsed}"
+
+sleep(3)
+puts "after 3 sec (status = stoped) : #{timer.elapsed}"
+
+timer.continue
+puts "continue (status = running) : #{timer.elapsed}"
+sleep(3)
+puts "after 3 sec (status = running) : #{timer.elapsed}"
+
+timer.reset
+puts "reset (status = running) : #{timer.elapsed}"
+sleep(3)
+puts "after 3 sec (status = running) : #{timer.elapsed}"
+
+

data/sample/type-register.rb

@@ -0,0 +1,103 @@
+=begin
+  type-register.rb - Sample for GLib::Object
+
+  You also need Ruby/GTK.
+
+  Copyright (C) 2004-2006 Ruby-GNOME2 Project Team
+  This program is licenced under the same licence as Ruby-GNOME2.
+
+  $Date: 2006/06/17 14:31:22 $
+  $Id: type-register.rb,v 1.9 2006/06/17 14:31:22 mutoh Exp $
+=end
+
+require 'gtk2'
+
+class MyButton < Gtk::Button
+  type_register
+
+  def initialize(label = nil)
+    # XXX: 
+    # When type_register() is used.
+    # super is equivalent to GLib::Object#initialize.
+    super("label" => label)
+    @fuga = 0
+  end
+
+  # override existing default handler of "clicked" signal.
+  def signal_do_clicked(*args)
+    puts "MyButton#signal_do_clicked enter"
+    #p caller
+    super
+    puts "MyButton#signal_do_clicked leave"
+  end
+
+  # define new signal "hoge"
+  signal_new("hoge",                  # name
+             GLib::Signal::RUN_FIRST, # flags
+             nil,                     # accumulator (XXX: not supported yet)
+             nil,                     # return type (void == nil)
+	     Integer, Integer         # parameter types
+             )
+  # define default handler of "hoge" signal
+  def signal_do_hoge(a, b)
+    puts "MyButton#signal_do_hoge enter"
+    #p caller
+    puts "MyButton#signal_do_hoge leave"
+  end
+
+  # define new property "fuga"
+  install_property(GLib::Param::Int.new("fuga", # name
+                                        "Fuga", # nick
+                                        "fuga hoge", # blurb
+                                        0,     # min
+                                        10000, # max
+                                        0,     # default
+                                        GLib::Param::READABLE |
+                                        GLib::Param::WRITABLE))
+  # implementation of the property "fuga"
+  def fuga
+    puts "MyButton#fuga is called"
+    @fuga
+  end
+  def fuga=(arg)
+    puts "MyButton#fuga= is called"
+    @fuga = arg
+    notify("fuga")
+  end
+end
+
+class MyButton2 < MyButton
+  type_register("MyButton2")
+
+  # override default handler of "clicked" signal
+  def signal_do_clicked(*args)
+    puts "MyButton2#signal_do_clicked enter"
+    super(*args)
+    puts "MyButton2#signal_do_clicked leave"
+  end
+
+  # override default handler of "hoge" signal
+  def signal_do_hoge(a, b)
+    puts "MyButton2#signal_do_hoge enter"
+    puts "a, b = #{a}, #{b}"
+    super
+    puts "MyButton2#signal_do_hoge leave"
+  end
+end
+
+b = MyButton2.new("Hello")
+p b
+p b.label
+p b.gtype
+b.clicked
+b.signal_emit("hoge", 1, 2)
+
+b.signal_connect("notify"){|obj, pspec|
+  puts "#{b} notify #{pspec}"
+}
+
+p b.get_property("fuga")
+b.set_property("fuga", 1)
+p b.get_property("fuga")
+
+p MyButton2.ancestors

data/sample/type-register2.rb

@@ -0,0 +1,104 @@
+=begin
+  type-register2.rb - Sample for GLib::Object
+
+  You also need Ruby/GTK.
+
+  Copyright (C) 2004-2006 Ruby-GNOME2 Project Team
+  This program is licenced under the same licence as Ruby-GNOME2.
+
+  $Date: 2006/06/17 14:31:22 $
+  $Id: type-register2.rb,v 1.3 2006/06/17 14:31:22 mutoh Exp $
+=end
+
+require 'gtk2'
+
+class MyButton < Gtk::Button
+  type_register
+
+  def initialize(label = nil)
+    # XXX: 
+    # When type_register() is used.
+    # super is equivalent to GLib::Object#initialize.
+    super("label" => label)
+    @fuga = 0
+  end
+
+  # override existing default handler of "clicked" signal.
+  def signal_do_clicked(*args)
+    puts "MyButton#signal_do_clicked enter"
+    #p caller
+    super
+    puts "MyButton#signal_do_clicked leave"
+  end
+
+  # define new signal "hoge"
+  signal_new("hoge",                  # name
+             GLib::Signal::RUN_FIRST, # flags
+             nil,                     # accumulator (XXX: not supported yet)
+             GLib::Type["void"],      # return type
+             GLib::Type["gint"], GLib::Type["gint"] # parameter types
+             )
+  # define default handler of "hoge" signal
+  def signal_do_hoge(a, b)
+    puts "MyButton#signal_do_hoge enter"
+    #p caller
+    puts "MyButton#signal_do_hoge leave"
+  end
+
+  # define new property "fuga"
+  install_property(GLib::Param::Int.new("fuga", # name
+                                        "Fuga", # nick
+                                        "fuga hoge", # blurb
+                                        0,     # min
+                                        10000, # max
+                                        0,     # default
+                                        GLib::Param::READABLE |
+                                        GLib::Param::WRITABLE))
+  # implementation of the property "fuga"
+  def fuga
+    puts "MyButton#fuga is called"
+    @fuga
+  end
+  def fuga=(arg)
+    puts "MyButton#fuga= is called"
+    @fuga = arg
+    notify("fuga")
+  end
+end
+
+class MyButton2 < MyButton
+  type_register("MyButton2")
+
+  # override default handler of "clicked" signal
+  def signal_do_clicked(*args)
+    puts "MyButton2#signal_do_clicked enter"
+    super(*args)
+    puts "MyButton2#signal_do_clicked leave"
+  end
+
+  # override default handler of "hoge" signal
+  def signal_do_hoge(a, b)
+    puts "MyButton2#signal_do_hoge enter"
+    puts "a, b = #{a}, #{b}"
+    #p caller
+    super
+    puts "MyButton2#signal_do_hoge leave"
+  end
+end
+
+b = MyButton2.new("Hello")
+p b
+p b.label
+p b.gtype
+b.clicked
+b.signal_emit("hoge", 1, 2)
+
+b.signal_connect("notify"){|obj, pspec|
+  puts "#{b} notify #{pspec}"
+}
+
+p b.get_property("fuga")
+b.set_property("fuga", 1)
+p b.get_property("fuga")
+
+p MyButton2.ancestors

data/sample/utils.rb

@@ -0,0 +1,54 @@
+=begin
+  utils.rb - Sample for GLib module function produced by rbglib_utils.c
+
+  Copyright (C) 2004 Masao Mutoh
+  This program is licenced under the same licence as Ruby-GNOME2.
+
+  $Date: 2004/10/21 15:50:21 $
+  $Id: utils.rb,v 1.2 2004/10/21 15:50:21 mutoh Exp $
+=end
+                                                                                
+require 'glib2'
+
+if GLib.check_version?(2, 2, 0)
+  GLib.application_name = "application name"
+  puts "GLib.application_name = #{GLib.application_name}"
+end
+
+GLib.prgname = "program name"
+puts "GLib.prgname = #{GLib.prgname}"
+
+puts "GLib.getenv('HOME') = #{GLib.getenv('HOME')}"
+if GLib.check_version?(2, 4, 0)
+  GLib.setenv("FOO", "foo")
+  puts "GLib.getenv('FOO') = #{GLib.getenv('FOO')}"
+  GLib.unsetenv("FOO")
+  puts "GLib.getenv('FOO') = #{GLib.getenv('FOO')}"
+end
+
+puts "GLib.user_name = #{GLib.user_name}"
+puts "GLib.real_name = #{GLib.real_name}"
+puts "GLib.home_dir  = #{GLib.home_dir}"
+puts "GLib.tmp_dir   = #{GLib.tmp_dir}"
+puts "GLib.current_dir = #{GLib.current_dir}"
+puts "GLib.path_is_absolute?('./') = #{GLib.path_is_absolute?("./")}"
+puts "GLib.path_skip_root('/usr/local/bin/ruby') = #{GLib.path_skip_root('/usr/local/bin/ruby')}"
+puts "GLib.path_get_basename(GLib.home_dir) = #{GLib.path_get_basename(GLib.home_dir)}"
+puts "GLib.path_get_dirname(GLib.home_dir) = #{GLib.path_get_dirname(GLib.home_dir)}"
+puts "GLib.find_program_in_path(GLib.prgname) = #{GLib.find_program_in_path(GLib.prgname)}"
+puts "GLib.bit_nth_lsf(3, 1) = #{GLib.bit_nth_lsf(3, 1)}"
+puts "GLib.bit_nth_msf(3, 1) = #{GLib.bit_nth_msf(3, 1)}"
+puts "GLib.bit_storage(3) = #{GLib.bit_storage(3)}"
+puts "GLib.spaced_primes_closest(10) = #{GLib.spaced_primes_closest(10)}"
+
+keys = {
+  "foo"  => 1 << 0,
+  "bar"  => 1 << 1,
+  "hoge" => 1 << 2,
+  "fuga" => 1 << 3
+}
+
+puts GLib.parse_debug_string("foo", keys)
+puts GLib.parse_debug_string("bar", keys)
+puts GLib.parse_debug_string("foo:bar:hoge", keys)
+puts GLib.parse_debug_string("foo:bar:hoge:fuga", keys)

data/test/glib-test-init.rb

@@ -0,0 +1,6 @@
+$VERBOSE = true
+
+glib_top = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+
+$LOAD_PATH.unshift(File.join(glib_top, "test-unit", "lib"))
+require 'test/unit'

data/test/glib-test-utils.rb

@@ -0,0 +1,12 @@
+module GLibTestUtils
+  private
+  def only_glib_version(major, minor, micro)
+    unless GLib.check_version?(major, minor, micro)
+      omit("Require GLib >= #{major}.#{minor}.#{micro}")
+    end
+  end
+
+  def only_win32
+    omit("Only for Win32 platform") unless GLib.os_win32?
+  end
+end

data/test/run-test.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+base = File.expand_path(File.join(File.dirname(__FILE__)))
+top = File.expand_path(File.join(base, ".."))
+
+$LOAD_PATH.unshift(top)
+require 'test/glib-test-init'
+
+if system("which make > /dev/null")
+  system("cd #{top.dump} && make > /dev/null") or exit(1)
+end
+
+$LOAD_PATH.unshift(File.join(top, "ext", "glib2"))
+$LOAD_PATH.unshift(File.join(top, "lib"))
+
+$LOAD_PATH.unshift(base)
+require 'glib-test-utils'
+
+require 'glib2'
+
+exit Test::Unit::AutoRunner.run(true, base)

data/test/test_enum.rb

@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+require 'test/unit'
+require 'glib2'
+
+class TestEnum < Test::Unit::TestCase
+  def test_enum_by_symbol
+    original = [0x00c1].pack("U*") # A with acute
+
+    assert_equal(GLib::UTF8.normalize(original, GLib::NormalizeMode::NFD),
+                 GLib::UTF8.normalize(original, :nfd))
+    assert_equal(GLib::UTF8.normalize(original, GLib::NormalizeMode::NFD),
+                 GLib::UTF8.normalize(original, :NFD))
+
+    assert_raise(TypeError) do
+      GLib::UTF8.normalize(original, :unknown)
+    end
+  end
+
+  def test_enum_by_string
+    original = [0x00c1].pack("U*") # A with acute
+
+    assert_equal(GLib::UTF8.normalize(original, GLib::NormalizeMode::NFD),
+                 GLib::UTF8.normalize(original, "nfd"))
+    assert_equal(GLib::UTF8.normalize(original, GLib::NormalizeMode::NFD),
+                 GLib::UTF8.normalize(original, "NFD"))
+
+    assert_raise(TypeError) do
+      GLib::UTF8.normalize(original, "unknown")
+    end
+  end
+
+  def test_flags_simple
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS, :keep_comments)
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS, :KEEP_COMMENTS)
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS, "keep_comments")
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS, "KEEP_COMMENTS")
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS, "keep COMMENTS")
+
+    assert_raise(TypeError) do
+      assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS, :unknown)
+    end
+
+    assert_raise(TypeError) do
+      assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS, "UNKNOWN")
+    end
+  end
+
+  def test_flags_by_array
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS |
+                         GLib::KeyFile::KEEP_TRANSLATIONS,
+                         [:keep_comments, :keep_translations])
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS |
+                         GLib::KeyFile::KEEP_TRANSLATIONS,
+                         [:keep_COMMENTS, "KEEP_TRANSLATIONS"])
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS |
+                         GLib::KeyFile::KEEP_TRANSLATIONS,
+                         ["keep_comments", "KEEP_translations"])
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS |
+                         GLib::KeyFile::KEEP_TRANSLATIONS,
+                         [:keep_comments, GLib::KeyFile::KEEP_TRANSLATIONS])
+
+    assert_raise(TypeError) do
+      assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS |
+                           GLib::KeyFile::KEEP_TRANSLATIONS,
+                           [:keep_comments, nil, :keep_translations])
+    end
+  end
+
+  def test_flags_or
+    assert_equal(GLib::KeyFile::KEEP_COMMENTS,
+                 GLib::KeyFile::KEEP_COMMENTS | [])
+    assert_equal(GLib::KeyFile::KEEP_COMMENTS |
+                 GLib::KeyFile::KEEP_TRANSLATIONS ,
+                 GLib::KeyFile::KEEP_COMMENTS | [:keep_translations])
+  end
+
+  private
+  def assert_key_file_load(flags, convenience_flags)
+    data = <<-EOD
+[SECTION]
+KEY=VALUE
+# comment
+
+KEY[ja]=値
+EOD
+
+    expected_key_file = GLib::KeyFile.new
+    expected_key_file.load_from_data(data, flags)
+
+    actual_key_file = GLib::KeyFile.new
+    actual_key_file.load_from_data(data, convenience_flags)
+
+    assert_equal(expected_key_file.get_value("SECTION", "KEY"),
+                 actual_key_file.get_value("SECTION", "KEY"))
+
+    assert_equal(expected_key_file.to_data,
+                 actual_key_file.to_data)
+  end
+end

data/test/test_file_utils.rb

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+class TestGLibFileUtils < Test::Unit::TestCase
+  include GLibTestUtils
+
+  def test_format_size_for_display
+    only_glib_version(2, 16, 0)
+
+    assert_equal("1.0 KB", GLib.format_size_for_display(1024))
+    assert_equal("10.0 KB", GLib.format_size_for_display(1024 * 10))
+    assert_equal("1.0 MB", GLib.format_size_for_display(1024 * 1024))
+    assert_equal("1.5 MB", GLib.format_size_for_display(1024 * 1024 * 1.5))
+    assert_equal("1.0 GB", GLib.format_size_for_display(1024 * 1024 * 1024))
+  end
+end

data/test/test_glib2.rb

@@ -0,0 +1,120 @@
+require 'test/unit'
+require 'glib2'
+
+class TestGLib < Test::Unit::TestCase
+
+  def test_version
+    assert_kind_of(Array, GLib::VERSION)
+    assert_equal(GLib::VERSION.length, 3)
+    assert(GLib::VERSION.all?{|i| i.is_a? Integer })
+
+    assert_kind_of(Integer, GLib::MAJOR_VERSION)
+    assert_kind_of(Integer, GLib::MINOR_VERSION)
+    assert_kind_of(Integer, GLib::MICRO_VERSION)
+
+    assert_kind_of(Array, GLib::BINDING_VERSION)
+    assert_equal(GLib::BINDING_VERSION.length, 3)
+    assert(GLib::BINDING_VERSION.all?{|i| i.is_a? Integer })
+  end
+
+  def test_priority
+    assert_kind_of(Integer, GLib::PRIORITY_HIGH)
+    assert_kind_of(Integer, GLib::PRIORITY_DEFAULT)
+    assert_kind_of(Integer, GLib::PRIORITY_HIGH_IDLE)
+    assert_kind_of(Integer, GLib::PRIORITY_DEFAULT_IDLE)
+    assert_kind_of(Integer, GLib::PRIORITY_LOW)
+  end
+
+  def test_int64
+  end
+
+  def test_convert
+    assert_kind_of(String, GLib.charset)
+
+    sjis = "\202\261\202\361\202\311\202\277\202\315\220\242\212E"
+    euc  = "\244\263\244\363\244\313\244\301\244\317\300\244\263\246"
+    utf8 = "\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257\344\270\226\347\225\214"
+    assert_equal(GLib.convert(sjis, "UTF-8", "SHIFT_JIS"), utf8)
+    assert_equal(GLib.convert(sjis, "EUC-JP", "SHIFT_JIS"), euc)
+    assert_equal(GLib.convert(sjis, "SHIFT_JIS", "SHIFT_JIS"), sjis)
+    assert_equal(GLib.convert(euc, "UTF-8", "EUC-JP"), utf8)
+    assert_equal(GLib.convert(euc, "EUC-JP", "EUC-JP"), euc)
+    assert_equal(GLib.convert(euc, "SHIFT_JIS", "EUC-JP"), sjis)
+    assert_equal(GLib.convert(utf8, "UTF-8", "UTF-8"), utf8)
+    assert_equal(GLib.convert(utf8, "EUC-JP", "UTF-8"), euc)
+    assert_equal(GLib.convert(utf8, "SHIFT_JIS", "UTF-8"), sjis)
+
+    # rb_define_module_function(mGLib, "locale_to_utf8", rbglib_m_locale_to_utf8, 1);
+    # rb_define_module_function(mGLib, "locale_from_utf8", rbglib_m_locale_from_utf8, 1);
+    # rb_define_module_function(mGLib, "filename_to_utf8", rbglib_m_filename_to_utf8, 1);
+    # rb_define_module_function(mGLib, "filename_from_utf8", rbglib_m_filename_from_utf8, 1);
+    # 
+    # rb_define_module_function(mGLib, "filename_to_uri", rbglib_m_filename_to_uri, -1);
+    # rb_define_module_function(mGLib, "filename_from_uri", rbglib_m_filename_from_uri, 1);
+
+  end
+
+  def test_messages
+    #rb_define_module_function(mGLog, "set_handler", rbglib_m_log_set_handler, 2);
+    #rb_define_module_function(mGLog, "remove_handler", rbglib_m_log_remove_handler, 2);
+  end
+
+  def test_object
+    assert_raises(GLib::NoPropertyError) {
+      GLib::Object.property("foo")
+    }
+
+    assert_raises(GLib::NoSignalError) {
+      GLib::Object.signal("foo")
+    }
+  end
+
+  def test_interface_extend
+    assert_raises(TypeError){
+      Object.__send__(:include, GLib::TypePlugin)
+    }
+  end
+
+  def test_signal_has_handler_pending
+    obj = GLib::Object.new
+    signal_name = "notify"
+
+    assert(!obj.signal_has_handler_pending?(signal_name))
+
+    h = obj.signal_connect(signal_name){}
+    assert(obj.signal_has_handler_pending?(signal_name))
+
+    obj.signal_handler_block(h) {
+      assert(obj.signal_has_handler_pending?(signal_name, true))
+      assert(!obj.signal_has_handler_pending?(signal_name, false))
+    }
+    assert(obj.signal_has_handler_pending?(signal_name, false))
+
+    obj.signal_handler_disconnect(h)
+    assert(!obj.signal_has_handler_pending?(signal_name))
+
+    obj = nil
+  end
+
+  def test_signal_handler_disconnect_and_gc
+    obj = GLib::Object.new
+    klass = Class.new
+    1000.times {
+      a = klass.new
+      id = obj.signal_connect("notify") { p a }
+      obj.signal_handler_disconnect(id)
+    }
+    GC.start
+    ary = []
+    ObjectSpace.each_object(klass) { |a| ary.push(a) }
+    assert_operator(ary.size, :<, 1000)
+  end
+
+  def test_gtype
+    assert_equal(GLib::Object.gtype, GLib::Type["GObject"])
+    assert_equal(GLib::Interface.gtype, GLib::Type["GInterface"])
+
+    obj = GLib::Object.new
+    assert_equal(obj.gtype, GLib::Object.gtype)
+  end
+end