merge win32ole from rough

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2508 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

ext/win32ole/sample/excel1.rb

@@ -0,0 +1,22 @@
+require 'win32ole'
+
+#application = WIN32OLE.new('Excel.Application.5')
+application = WIN32OLE.new('Excel.Application')
+
+application.visible = TRUE
+workbook = application.Workbooks.Add();
+worksheet = workbook.Worksheets(1);
+worksheet.Range("A1:D1").value = ["North","South","East","West"];
+worksheet.Range("A2:B2").value = [5.2, 10];
+worksheet.Range("C2").value = 8;
+worksheet.Range("D2").value = 20;
+
+range = worksheet.Range("A1:D2");
+range.Select
+chart = workbook.Charts.Add;
+
+workbook.saved = TRUE;
+
+application.ActiveWorkbook.Close(0);
+application.Quit();
+

ext/win32ole/sample/excel2.rb

@@ -0,0 +1,30 @@
+require 'win32ole'
+
+#   -4100 is the value for the Excel constant xl3DColumn.
+ChartTypeVal = -4100;
+
+#   Creates OLE object to Excel
+#excel = WIN32OLE.new("excel.application.5")
+excel = WIN32OLE.new("excel.application")
+
+# Create and rotate the chart
+
+excel['Visible'] = TRUE;
+excel.Workbooks.Add();
+excel.Range("a1")['Value'] = 3;
+excel.Range("a2")['Value'] = 2;
+excel.Range("a3")['Value'] = 1;
+excel.Range("a1:a3").Select();
+excelchart = excel.Charts.Add();
+excelchart['Type'] = ChartTypeVal;
+
+i = 30
+i.step(180, 10) do |rot|
+#    excelchart['Rotation'] = rot;
+    excelchart.rotation=rot;
+end
+# Done, bye
+
+excel.ActiveWorkbook.Close(0);
+excel.Quit();
+

ext/win32ole/sample/excel3.rb

@@ -0,0 +1,13 @@
+require 'win32ole'
+
+#application = WIN32OLE.new('Excel.Application.5')
+application = WIN32OLE.new('Excel.Application')
+
+application.visible = TRUE
+workbook = application.Workbooks.Add();
+sheet = workbook.Worksheets(1);
+sheetS = workbook.Worksheets
+puts "The number of sheets is #{sheetS.count}"
+puts "Now add 2 sheets after of `#{sheet.name}`"
+sheetS.add({'count'=>2, 'after'=>sheet})
+puts "The number of sheets is #{sheetS.count}"

ext/win32ole/sample/ie.rb

@@ -0,0 +1,11 @@
+require 'win32ole'
+url = 'http://www.ruby-lang.org/'
+ie = WIN32OLE.new('InternetExplorer.Application')
+ie.visible = TRUE
+ie.gohome
+print "Now navigate Ruby home page... Please enter."
+gets
+ie.navigate(url)
+print "Now quit Internet Explorer... Please enter."
+gets
+ie.Quit()

ext/win32ole/sample/ieconst.rb

@@ -0,0 +1,32 @@
+require 'win32ole'
+
+ie = WIN32OLE.new('InternetExplorer.Application')
+=begin
+WIN32OLE.const_load(ie)
+WIN32OLE.constants.sort.each do |c|
+  puts "#{c} = #{WIN32OLE.const_get(c)}"
+end
+=end
+
+module IE_CONST
+end
+
+WIN32OLE.const_load(ie, IE_CONST)
+IE_CONST.constants.sort.each do |c|
+  puts "#{c} = #{IE_CONST.const_get(c)}"
+end
+
+#------------------------------------------------------------
+# Remark!!! CONSTANTS has not tested enoughly!!!
+# CONSTANTS is alpha release.
+# If there are constants which first letter is not [a-zA-Z],
+# like a '_Foo', then maybe you can access the value by 
+# using CONSTANTS['_Foo']
+#------------------------------------------------------------
+IE_CONST::CONSTANTS.each do |k, v|
+  puts "#{k} = #{v}"
+end
+
+puts WIN32OLE::VERSION
+ie.quit
+

ext/win32ole/sample/ienavi.rb

@@ -0,0 +1,40 @@
+require 'win32ole'
+
+$urls = []
+
+def navigate(url)
+  $urls << url
+end
+
+def stop_msg_loop
+  puts "Now Stop IE..."
+  $LOOP = FALSE;
+end
+
+def default_handler(event, *args)
+  case event
+  when "BeforeNavigate"
+    puts "Now Navigate #{args[0]}..."
+  end
+end
+
+ie = WIN32OLE.new('InternetExplorer.Application')
+ie.visible = TRUE
+ie.gohome
+
+ev = WIN32OLE_EVENT.new(ie, 'DWebBrowserEvents')
+
+ev.on_event {|*args| default_handler(*args)}
+ev.on_event("NavigateComplete") {|url| navigate(url)}
+ev.on_event("Quit") {|*args| stop_msg_loop} 
+
+$LOOP = TRUE
+while ($LOOP)
+  WIN32OLE_EVENT.message_loop
+end
+
+puts "You Navigated the URLs ..."
+$urls.each_with_index do |url, i|
+  puts "(#{i+1}) #{url}"
+end
+

ext/win32ole/sample/oledirs.rb

@@ -0,0 +1,23 @@
+#
+# You need WSH(Windows Scripting Host) to run this script.
+#
+
+require "win32ole"
+
+def listup(items)
+#  items.each do |i|
+  for i in items
+    puts i.name 
+  end
+end
+
+fs = WIN32OLE.new("Scripting.FileSystemObject")
+
+folder = fs.GetFolder(".")
+
+puts "--- folder of #{folder.path} ---"
+listup(folder.SubFolders)
+
+puts "--- files of #{folder.path} ---"
+listup(folder.Files)
+

ext/win32ole/sample/olegen.rb

@@ -0,0 +1,348 @@
+#-----------------------------
+# olegen.rb
+# $Date$
+# $Revision$
+#-----------------------------
+
+require 'win32ole'
+
+class WIN32COMGen
+  def initialize(typelib)
+    @typelib = typelib
+    @reciever = ""
+  end
+  attr_reader :typelib
+
+  def ole_classes(typelib)
+    begin
+      @ole = WIN32OLE.new(typelib)
+      [@ole.ole_obj_help]
+    rescue
+      WIN32OLE_TYPE.ole_classes(typelib)
+    end
+  end
+
+  def generate_args(method)
+    args = []
+    if method.size_opt_params >= 0
+      size_required_params = method.size_params - method.size_opt_params
+    else
+      size_required_params = method.size_params - 1
+    end
+    size_required_params.times do |i|
+      if method.params[i] && method.params[i].optional?
+        args.push "arg#{i}=nil"
+      else
+        args.push "arg#{i}"
+      end
+    end
+    if method.size_opt_params >= 0
+      method.size_opt_params.times do |i|
+        args.push "arg#{i + size_required_params}=nil"
+      end
+    else
+      args.push "*arg"
+    end
+    args.join(", ")
+  end
+
+  def generate_argtype(typedetails)
+    ts = ''
+    typedetails.each do |t|
+      case t
+      when 'CARRAY', 'VOID', 'UINT', 'RESULT', 'DECIMAL', 'I8', 'UI8' 
+#	  raise "Sorry type\"" + t + "\" not supported"
+      ts << "\"??? NOT SUPPORTED TYPE:`#{t}'\""
+      when 'USERDEFINED', 'Unknown Type 9'
+        ts << 'VT_DISPATCH'
+        break;
+      when 'SAFEARRAY'
+        ts << 'VT_ARRAY|'
+      when 'PTR'
+        ts << 'VT_BYREF|'
+      when 'INT'
+        ts << 'VT_I4'
+      else
+        if String === t
+          ts << 'VT_' + t
+        end
+      end
+    end
+    if ts.empty?
+      ts = 'VT_VARIANT'
+    elsif ts[-1] == ?|
+	ts += 'VT_VARIANT'
+    end
+    ts
+  end
+
+  def generate_argtypes(method, proptypes)
+    types = method.params.collect{|param|
+      generate_argtype(param.ole_type_detail)
+    }.join(", ")
+    if proptypes
+      types += ", " if types.size > 0 
+      types += generate_argtype(proptypes)
+    end
+    types
+  end
+
+  def generate_method_body(method, disptype, types=nil)
+    "    ret = #{@reciever}#{disptype}(#{method.dispid}, [" +
+    generate_args(method).gsub("=nil", "") +
+    "], [" +
+    generate_argtypes(method, types) +
+    "])\n" +
+    "    @lastargs = WIN32OLE::ARGV\n" +
+    "    ret"
+  end
+
+  def generate_method_help(method, type = nil)
+    str = "  # "  
+    if type 
+      str += type
+    else
+      str += method.return_type
+    end
+    str += " #{method.name}"
+    if method.event?
+      str += " EVENT"
+      str += " in #{method.event_interface}"
+    end
+    if method.helpstring && method.helpstring != ""
+      str += "\n  # "
+      str += method.helpstring
+    end
+    args_help = generate_method_args_help(method)
+    if args_help
+      str += "\n"
+      str += args_help
+    end
+    str
+  end
+
+  def generate_method_args_help(method)
+    args = []
+    method.params.each_with_index {|param, i|
+      h = "  #   #{param.ole_type} arg#{i} --- #{param.name}" 
+      inout = []
+      inout.push "IN" if param.input?
+      inout.push "OUT" if param.output?
+      h += " [#{inout.join('/')}]"
+      h += " ( = #{param.default})" if param.default
+      args.push h
+    }
+    if args.size > 0
+      args.join("\n")
+    else
+      nil
+    end
+  end
+
+  def generate_method(method, disptype, io = STDOUT, types = nil)
+    io.puts "\n"
+    io.puts  generate_method_help(method)
+    if method.invoke_kind == 'PROPERTYPUT'
+      io.print "  def #{method.name}=("
+    else
+      io.print "  def #{method.name}("
+    end
+    io.print generate_args(method)
+    io.puts ")"
+    io.puts generate_method_body(method, disptype, types)
+    io.puts "  end"
+  end
+
+  def generate_propputref_methods(klass, io = STDOUT)
+    klass.ole_methods.select {|method|
+      method.invoke_kind == 'PROPERTYPUTREF' && method.visible?
+    }.each do |method|
+      generate_method(method, io)
+    end
+  end
+
+  def generate_properties_with_args(klass, io = STDOUT)
+    klass.ole_methods.select {|method|
+      method.invoke_kind == 'PROPERTYGET' &&
+      method.visible? &&
+      method.size_params > 0
+    }.each do |method|
+      types = method.return_type_detail 
+      io.puts "\n"
+      io.puts  generate_method_help(method, types[0])
+      io.puts  "  def #{method.name}"
+      if klass.ole_type == "Class"
+        io.print "    OLEProperty.new(@dispatch, #{method.dispid}, [" 
+      else
+        io.print "    OLEProperty.new(self, #{method.dispid}, [" 
+      end
+      io.print generate_argtypes(method, nil)
+      io.print "], ["
+      io.print generate_argtypes(method, types)
+      io.puts "])"
+      io.puts  "  end"
+    end
+  end
+
+  def generate_propput_methods(klass, io = STDOUT)
+    klass.ole_methods.select {|method|
+      method.invoke_kind == 'PROPERTYPUT' && method.visible? &&
+      method.size_params == 1
+    }.each do |method|
+      ms = klass.ole_methods.select {|m|
+        m.invoke_kind == 'PROPERTYGET' &&
+        m.dispid == method.dispid
+      }
+      types = []
+      if ms.size == 1
+        types = ms[0].return_type_detail
+      end
+      generate_method(method, '_setproperty', io, types)
+    end
+  end
+
+  def generate_propget_methods(klass, io = STDOUT)
+    klass.ole_methods.select {|method|
+      method.invoke_kind == 'PROPERTYGET' && method.visible? &&
+      method.size_params == 0
+    }.each do |method|
+      generate_method(method, '_getproperty', io)
+    end
+  end
+
+  def generate_func_methods(klass, io = STDOUT)
+    klass.ole_methods.select {|method|
+      method.invoke_kind == "FUNC" && method.visible?
+    }.each do |method|
+      generate_method(method, '_invoke', io)
+    end
+  end
+
+  def generate_methods(klass, io = STDOUT)
+    generate_propget_methods(klass, io)
+    generate_propput_methods(klass, io)
+    generate_properties_with_args(klass, io)
+    generate_func_methods(klass, io)
+#   generate_propputref_methods(klass, io)
+  end
+
+  def generate_constants(klass, io = STDOUT)
+    klass.variables.select {|v|
+      v.visible? && v.variable_kind == 'CONSTANT'
+    }.each do |v|
+      io.print "  "
+      io.print v.name.sub(/^./){|c| c.upcase}
+      io.print " = "
+      io.puts  v.value
+    end
+  end
+
+  def class_name(klass)
+    klass_name = klass.name
+    if klass.ole_type == "Class" &&
+       klass.guid &&
+       klass.progid
+       klass_name = klass.progid.gsub(/\./, '_')
+    end
+    if /^[A-Z]/ !~ klass_name || Module.constants.include?(klass_name)
+      klass_name = 'OLE' + klass_name
+    end
+    klass_name
+  end
+
+  def define_initialize(klass)
+    <<STR
+
+  def initialize(obj = nil)
+    @clsid = "#{klass.guid}"
+    @progid = "#{klass.progid}"
+    if obj.nil?
+      @dispatch = WIN32OLE.new @progid
+    else
+      @dispatch = obj
+    end
+  end
+STR
+  end
+
+  def define_include
+    "  include WIN32OLE::VARIANT"
+  end
+
+  def define_instance_variables
+    "  attr_reader :lastargs"
+  end
+
+  def define_method_missing
+    <<STR
+
+  def method_missing(cmd, *arg)
+    @dispatch.method_missing(cmd, *arg)
+  end
+STR
+  end
+
+  def define_class(klass, io = STDOUT)
+    io.puts "class #{class_name(klass)} # #{klass.name}"
+    io.puts define_include
+    io.puts define_instance_variables
+    io.puts "  attr_reader :dispatch"
+    io.puts "  attr_reader :clsid"
+    io.puts "  attr_reader :progid"
+    io.puts define_initialize(klass)
+    io.puts define_method_missing
+  end
+
+  def define_module(klass, io = STDOUT)
+    io.puts "module #{class_name(klass)}"
+    io.puts define_include
+    io.puts define_instance_variables
+  end
+
+  def generate_class(klass, io = STDOUT)
+    io.puts "\n# #{klass.helpstring}"
+    if klass.ole_type == "Class" &&
+       klass.guid &&
+       klass.progid
+      @reciever = "@dispatch."
+      define_class(klass, io)
+    else
+      @reciever = ""
+      define_module(klass, io)
+    end
+    generate_constants(klass, io)
+    generate_methods(klass, io)
+    io.puts "end"
+  end
+
+  def generate(io = STDOUT)
+    io.puts "require 'win32ole'"
+    io.puts "require 'win32ole/property'"
+
+    ole_classes(typelib).select{|klass|
+      klass.visible? &&
+      (klass.ole_type == "Class" || 
+       klass.ole_type == "Interface" || 
+       klass.ole_type == "Dispatch" ||
+       klass.ole_type == "Enum")
+    }.each do |klass|
+      generate_class(klass, io)
+    end
+    begin
+      @ole.quit if @ole
+    rescue 
+    end
+  end
+end
+
+require 'win32ole'
+if __FILE__ == $0
+  if ARGV.size == 0
+    $stderr.puts "usage: #{$0} Type Library [...]"
+    exit 1
+  end
+  ARGV.each do |typelib|
+    comgen = WIN32COMGen.new(typelib)
+    comgen.generate
+  end
+end