rubyuno 0.3.0

data/lib/rubyuno.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+#
+#  Copyright 2011 Tsutomu Uchino
+# 
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  
+#    http://www.apache.org/licenses/LICENSE-2.0
+#  
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+require 'rubyuno/rubyuno'
+require 'rubyuno/uno'
+require 'rubyuno/uno/connector'

data/lib/rubyuno/uno.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+#
+#  Copyright 2011 Tsutomu Uchino
+# 
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  
+#    http://www.apache.org/licenses/LICENSE-2.0
+#  
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+require 'rubyuno/rubyuno'
+
+module Uno
+  @@ctx = Rubyuno.get_component_context # initialize runo internal
+
+  Rubyuno.uno_require 'com.sun.star.lang.XTypeProvider'
+
+  # Uno.msgbox(message="", title="", buttons=1, type="messbox", peer=nil) -> Integer
+  # Shows message dialog on top frame window or specific window.
+  # @message [String] message to show
+  # @title [String] title for the message box
+  # @param [String] type can be messbox, infobox, warningbox, errorbox or querybox.
+  # @param [Fixnum] buttons is combination of constants css.awt.MessageBoxButtons.
+  # @param [object] peer window peer to show the dialog.
+  # @return [Fixnum] depends on buttons, see buttons
+  def Uno.msgbox(message="", title="", buttons=1, type="messbox", peer=nil)
+    unless peer
+      ctx = Rubyuno.get_component_context
+      desktop = ctx.getServiceManager.createInstanceWithContext(
+                   "com.sun.star.frame.Desktop", ctx)
+      doc = desktop.getCurrentComponent
+      peer = doc.getCurrentController.getFrame.getContainerWindow if doc
+    end
+    if peer
+      rectangle = Rubyuno.uno_require("com.sun.star.awt.Rectangle")
+      msgbox = peer.getToolkit.createMessageBox(
+          peer, rectangle.new, type, buttons, title, message)
+      n = msgbox.execute
+      msgbox.dispose
+      return n
+    end
+  end
+
+  UNO_TYPES = {}
+  # Keeps type information about a class which implements 
+  # css.lang.XTypeProvider interface.
+  class << UNO_TYPES
+  
+    def types(klass)
+      return find_type(klass)[0]
+    end
+    
+    def id(klass)
+      return find_type(klass)[1]
+    end
+    
+    private
+    
+    def find_type(klass)
+      value = self[klass]
+      value = self[klass] = [get_uno_types(klass), Uno.uuid] unless value
+      return value
+    end
+    
+    def get_uno_types(klass)
+      types = []
+      klass.ancestors.each do |m|
+        if m.const_defined?(:UNO_TYPE_NAME)
+          c = m.const_get(:UNO_TYPE_NAME)
+          types << Uno.get_type(c)
+        end
+      end
+      types.uniq!
+      return types
+    end
+  end
+
+  # This is base module which is used to define UNO component, 
+  # just include this module like the following:
+  #   class MyListener
+  #      include Uno::UnoBase
+  #      include ...other interfaces
+  #   end
+  # The adapter needs to know its types (interfaces) are implemented by the 
+  # component, therefore methods of this module provide it.
+  # If it should be class itself, implement XTypeProvider interface to 
+  # the class.
+  module UnoBase
+    include Rubyuno::Com::Sun::Star::Lang::XTypeProvider
+    def getTypes
+      return Uno::UNO_TYPES.types self.class
+    end
+    
+    def getImplementationId
+      return Uno::UNO_TYPES.id self.class
+    end
+  end
+end

data/lib/rubyuno/uno/connector.rb

@@ -0,0 +1,97 @@
+# coding: utf-8
+#
+#  Copyright 2011 Tsutomu Uchino
+# 
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  
+#    http://www.apache.org/licenses/LICENSE-2.0
+#  
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+require 'rubyuno/rubyuno'
+
+module Uno
+  Rubyuno.uno_require 'com.sun.star.connection.NoConnectException'
+  Rubyuno.uno_require 'com.sun.star.connection.ConnectionSetupException'
+  
+#
+# Helps to connect to the office by RPC with UNO protocol.
+# 
+# These environmental variables should be set before to load 'runo' 
+# module.
+# URE_BOOTSTRAP specifies to fundamental(rc|.ini) placed under 
+#   openoffice.org3/program directory.
+# LD_LIBRARY_PATH path to URE library and program directory of the office. 
+# 
+  module Connector
+  
+    class NoConnectionError < StandardError
+    end
+    
+    PIPE_NAME_PREFIX = "rubypipe_"
+    
+    @@sleep_time = 2.0
+    @@retry = 5
+    
+    attr_accessor :sleep_time, :retry
+    
+    # Read Professional UNO chapter of Developer's Guide about 
+    # UNO Remote protocol.
+    def self.bootstrap(office="soffice", type="socket", 
+         host="localhost", port=2083, pipe_name=nil, nodelay=false)
+      url, argument = self.url_construct(type, host, port, pipe_name, nodelay)
+      r = self.resolver_get
+      c = nil
+      n = 0
+      begin
+        c = self.connect(url, r)
+      rescue Rubyuno::Com::Sun::Star::Uno::Exception => e
+        raise e if e.uno_instance_of?(
+            Rubyuno::Com::Sun::Star::Connection::ConnectionSetupException)
+        n += 1
+        (raise NoConnectionError,"") if n > @@retry
+        spawn(ENV, office, argument)
+        sleep(@@sleep_time)
+        retry
+      end
+      return c
+    end
+    
+    def self.connect(url, resolver=nil)
+      resolver = self.resolver_get unless resolver
+      return resolver.resolve(url)
+    end
+    
+    def self.url_construct(type="socket", 
+         host="localhost", port=2083, pipe_name=nil, nodelay=false)
+      case type
+      when "socket"
+        part = "socket,host=#{host},port=#{port}," +
+                  "tcpNoDelay=#{nodelay ? 1 : 0};urp;"
+        url = "uno:#{part}StarOffice.ComponentContext"
+        argument = "-accept=#{part}StarOffice.ServiceManager"
+      when "pipe"
+        pipe_name = "#{PIPE_NAME_PREFIX}#{srand * 10000}" unless pipe_name
+        part = "pipe,name=#{pipe_name};urp;"
+        url = "uno:#{part}StarOffice.ServiceManager"
+        argument = "-accept=#{part}StarOffice.ComponentContext"
+      else
+        raise ArgumentError, "Illegal connection type (#{type})"
+      end
+      return url, argument
+    end
+    
+    def self.resolver_get
+      ctx = Rubyuno.get_component_context
+      return ctx.getServiceManager.createInstanceWithContext(
+                      "com.sun.star.bridge.UnoUrlResolver", ctx)
+    end
+  end
+end

data/lib/rubyuno/version.rb

@@ -0,0 +1,3 @@
+module Rubyuno
+  VERSION = "0.3.0"
+end

data/rubyuno.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/rubyuno/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Daniel Vandersluis", "Tsutomu Uchino"]
+  gem.email         = ["daniel@codexed.com", "hanya.runo@gmail.com"]
+  gem.description   = %q{Ruby-OpenOffice UNO native bridge}
+  gem.summary       = %q{rubyuno is a Ruby-UNO (Universal Network Object) bridge, used to interact with OpenOffice.org}
+  gem.homepage      = "http://www.github.com/dvandersluis/rubyuno"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.extensions    = ['ext/rubyuno/extconf.rb']
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "rubyuno"
+  gem.require_paths = ["lib"]
+  gem.version       = Rubyuno::VERSION
+end

data/sample/calc-chart.rb

@@ -0,0 +1,66 @@
+# coding: utf-8
+
+require 'uno.rb'
+
+desktop = Runo.get_desktop
+if desktop
+  # create new Spreadsheet document
+  doc = desktop.loadComponentFromURL('private:factory/scalc', '_blank', 0, [])
+  Rect, Prop, CellRangeAddress = Runo.uno_require('com.sun.star.awt.Rectangle', 
+                                'com.sun.star.beans.PropertyValue', 
+                                'com.sun.star.table.CellRangeAddress')
+  def make_prop(name, value)
+    prop = Prop.new
+    prop.Name = name
+    prop.Value = value
+    prop
+  end
+  
+  # get sheet and cell range and set data
+  sheet = doc.getSheets.getByIndex(0)
+  cell_range = sheet.getCellRangeByPosition(0, 0, 1, 2)
+  cell_range.setDataArray([['X', 'Y'], [0, 5], [2, 10]])
+  
+  # chart container
+  charts = sheet.getCharts
+  
+  rect = Rect.new(1300, 1300, 7000, 5000)
+  chart_name = 'chart2'
+  if charts.hasByName(chart_name)
+    charts.removeByName(chart_name)
+  end
+  
+  charts.addNewByName(chart_name, rect, [CellRangeAddress.new], false, false)
+  chart = charts.getByName(chart_name).getEmbeddedObject
+  
+  diagram = chart.getFirstDiagram
+  type_manager = chart.getChartTypeManager
+  template = type_manager.createInstance(
+      'com.sun.star.chart2.template.ScatterLineSymbol')
+  template.changeDiagram(diagram)
+  data_prov = chart.getDataProvider
+  
+  coords = diagram.getCoordinateSystems
+  coord = coords[0]
+  
+  chart_types = coord.getChartTypes
+  chart_type = chart_types[0]
+  
+  
+  props = Array.new
+  props << make_prop('CellRangeRepresentation', cell_range.AbsoluteName)
+  
+  props << make_prop('DataRowSource', Runo.uno_require('com.sun.star.chart.ChartDataRowSource.COLUMNS'))
+  props << make_prop('FirstCellAsLabel', false)
+  props << make_prop('HasCategories', true)
+  
+  data_source = data_prov.createDataSource(props)
+  
+  args = Array.new
+  args << make_prop('HasCategories', true)
+  
+  template.changeDiagramData(diagram, data_source, args)
+end
+
+
+

data/sample/dialog_listener.rb

@@ -0,0 +1,70 @@
+
+require 'uno.rb'
+
+ctx = Runo::Connector.bootstrap
+
+desktop = Runo.get_desktop
+p desktop
+unless desktop
+  puts 'failed to get desktop.'
+  exit
+end
+
+#ctx = Runo.get_component_context
+Runo.uno_require('com.sun.star.awt.XActionListener')
+
+class ButtonListener
+  include Runo::Base
+  include Runo::Com::Sun::Star::Awt::XActionListener
+  
+  # XEventListener
+  # must be defined for all listeners
+  def disposing(ev)
+  end
+  
+  # XActionListener
+  # called at button pushed
+  def actionPerformed(ev)
+    dlg = ev.Source.getContext
+    dlg.getControl('edit').setText(Time.now.to_s)
+  end
+end
+
+# this runtime dialog creation is just a demonstration.
+# make a dialog with dialog editor of OpenOffice.org and 
+# create instance of the dialog using css.awt.DialogProvider service.
+def create_dialog(ctx)
+  awt_prefix = 'com.sun.star.awt'
+  smgr = ctx.getServiceManager
+  dlg = smgr.createInstanceWithContext("#{awt_prefix}.UnoControlDialog", ctx)
+  dlg_model = smgr.createInstanceWithContext("#{awt_prefix}.UnoControlDialogModel", ctx)
+  #mri = smgr.createInstanceWithContext('mytools.Mri', ctx)
+  #Runo.invoke(mri, 'inspect', [dlg])
+  dlg.setModel(dlg_model)
+  dlg_model.setPropertyValues(
+      ['Height', 'PositionX', 'PositionY', 'Width'], 
+      [55, 100, 100, 80])
+  
+  btn_model = dlg_model.createInstance("#{awt_prefix}.UnoControlButtonModel")
+  edit_model = dlg_model.createInstance("#{awt_prefix}.UnoControlEditModel")
+  btn_model.setPropertyValues(
+      ['Height', 'Label', 'PositionX', 'PositionY', 'Width'], 
+      [20, '~Push', 5, 30, 70])
+  edit_model.setPropertyValues(
+      ['Height', 'PositionX', 'PositionY', 'Width'], 
+      [20, 5, 5, 70])
+  dlg_model.insertByName('btn', btn_model)
+  dlg_model.insertByName('edit', edit_model)
+  
+  # set button listener
+  dlg.getControl('btn').addActionListener(ButtonListener.new)
+  dlg.setVisible(true)
+  dlg.execute
+  dlg.dispose # call dispose method to destroy adapter to ensure free
+end
+
+create_dialog(ctx)
+
+
+
+

data/sample/filter-names.rb

@@ -0,0 +1,123 @@
+# coding: utf-8
+
+require 'runo'
+
+# Shows list of filter names that are installed your environment.
+# 
+# meaning of the list:
+#   UIName: name shown in the file open dialog
+#   Name: filter name that is used in API
+#   Type: file type
+#   Import: importable?
+#   Export: exportable?
+#   FilterService: service name of filtering service
+#   UIComponent: dialog service
+#   UserData: configuration data
+#
+# @param [Runo::RunoProxy] component context of remote server
+#
+def write_filter_names(ctx)
+  def flag_to_s(flags)
+    i = (flags & 1) == 1 ? 'X' : '-'
+    e = (flags & 2) == 2 ? 'X' : '-'
+    [i, e]
+  end
+  docTypes = {'com.sun.star.text.TextDocument'=> [], 
+              'com.sun.star.sheet.SpreadsheetDocument'=> [], 
+              'com.sun.star.drawing.DrawingDocument'=> [], 
+              'com.sun.star.text.WebDocument'=> [], 
+              'com.sun.star.presentation.PresentationDocument'=> [], 
+              'com.sun.star.formula.FormulaProperties'=> [], 
+              'com.sun.star.text.GlobalDocument'=> [], 
+              'com.sun.star.sdb.OfficeDatabaseDocument'=> [], 
+              'com.sun.star.chart2.ChartDocument'=> []}
+  ids = {'UIName'=> 0, 'Name'=> 1, 'Type'=> 2, 
+         'FilterService'=> 5, 'UIComponent'=> 6}
+  # filter factory provides all existing filters
+  ff = ctx.getServiceManager.createInstanceWithContext(
+    'com.sun.star.document.FilterFactory', ctx)
+  names = ff.getElementNames
+  
+  for name in names
+    doc_type = ''
+    d = Array.new(8, '')
+    ps = ff.getByName(name)
+    
+    for pv in ps
+      n = pv.Name
+      if n == 'DocumentService'
+        doc_type = pv.Value
+      end
+      pos = ids[n]
+      if pos === nil
+        if n == 'Flags'
+          d[3], d[4] = flag_to_s(pv.Value)
+        elsif n == 'UserData'
+          d[7] = pv.Value.join
+        end
+      else
+        d[pos] = pv.Value
+      end
+    end
+    if ! doc_type.empty?
+      docTypes[doc_type] << d
+    end
+  end
+  
+  # create new spreadsheet document from desktop
+  desktop = ctx.getServiceManager\
+                .createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
+  doc = desktop.loadComponentFromURL('private:factory/scalc', '_blank', 0, [])
+  
+  # lock controllers and disabel the modified status changing make little bit fast
+  doc.disableSetModified
+  doc.lockControllers
+  
+  sheets = doc.getSheets
+  n = sheets.getCount
+  
+  h = ['UIName', 'Name', 'Type', 'Import', 'Export', 
+    'FilterService', 'UIComponent', 'UserData']
+  
+  for k, v in docTypes
+    v.unshift(h)
+    sheet_name = k[k.rindex('.') + 1..-1].sub('Document', '').sub('Properties', '')
+    # create and insert new sheet
+    sheet = doc.createInstance('com.sun.star.sheet.Spreadsheet')
+    sheets.insertByName(sheet_name, sheet)
+    r = sheet.getCellRangeByPosition(0, 0, 7, v.size - 1)
+    
+    # set data from array, is faster than iteration of all cells
+    r.setDataArray(v)
+    r.getColumns.OptimalWidth = true
+  end
+  
+  # remove disuse sheets. index
+  for i in 0..n-1
+    sheets.removeByName(sheets.getByIndex(0).getName)
+  end
+  
+  # remove lockings
+  doc.enableSetModified
+  doc.unlockControllers
+  print "done.\n"
+end
+
+
+def get_ctx(local_ctx)
+  if local_ctx
+    uno_url = 'uno:socket,host=localhost,port=2083;urp;StarOffice.ComponentContext'
+    local_smgr = local_ctx.getServiceManager
+    resolver = local_smgr\
+        .createInstanceWithContext('com.sun.star.bridge.UnoUrlResolver', local_ctx)
+    ctx = resolver.resolve(uno_url)
+  end
+end
+
+
+ctx = get_ctx(Runo.get_component_context)
+if ctx
+  write_filter_names(ctx)
+end
+
+