def __connectOpenOfficeService(self, host, puerto):
        localContext = uno.getComponentContext()
        resolver = localContext.ServiceManager.createInstanceWithContext(
                "com.sun.star.bridge.UnoUrlResolver", uno.getComponentContext())
        
        #self.dispatchHelper = localContext.ServiceManager.createInstanceWithContext("com.sun.star.frame.DispatchHelper", uno.getComponentContext())

        smgr = resolver.resolve("uno:socket,host=" + host + ",port=" + puerto + ";urp;StarOffice.ServiceManager")
        remoteContext = smgr.getPropertyValue("DefaultContext")
        return smgr.createInstanceWithContext("com.sun.star.frame.Desktop", remoteContext)

def xray(myObject):
    try:
        sm = uno.getComponentContext().ServiceManager
        mspf = sm.createInstanceWithContext("com.sun.star.script.provider.MasterScriptProviderFactory", uno.getComponentContext())
        scriptPro = mspf.createScriptProvider("")
        xScript = scriptPro.getScript("vnd.sun.star.script:XrayTool._Main.Xray?language=Basic&location=application")
        xScript.invoke((myObject,), (), ())
        return
    except:
        raise _rtex("Basic library Xray is not installed", uno.getComponentContext())

 def setUp(self):
        
 
     Cmd = "libreoffice"
     Cmd = '%s --headless --norestore "--accept=socket,host=localhost,port=2002;urp;"'%(Cmd)
        
     print "issuing: %s"%Cmd
     # os.system( Cmd ) wont work, since it wait for the process to end...
     os.popen(Cmd)
     time.sleep(0.5)
     
     # get the uno component context from the PyUNO runtime
     self.localContext = uno.getComponentContext()
     
     # create the UnoUrlResolver
     self.resolver = self.localContext.ServiceManager.createInstanceWithContext(
                     "com.sun.star.bridge.UnoUrlResolver", self.localContext )
     
     # connect to the running office
     self.ctx = self.resolver.resolve( "uno:socket,host=localhost,port=2002;urp;StarOffice.ComponentContext" )
     self.smgr = self.ctx.ServiceManager
     
     # get the central desktop object
     self.desktop = self.smgr.createInstanceWithContext( "com.sun.star.frame.Desktop",self.ctx)
     
     # access the current calc document
     self.model = self.desktop.getCurrentComponent()
     pass

def FolderPathBox(title='Get directory path'):
    ctx = uno.getComponentContext()
    smgr = ctx.getServiceManager()
    folder_picker = smgr.createInstanceWithContext("com.sun.star.ui.dialogs.FolderPicker", ctx)
    folder_picker.setTitle(title)
    folder_picker.execute()
    return folder_picker.getDirectory()

	def initialize(self):
		logging.debug("PropertyManager.initialize: starting")
		self.__setUiLanguage()

		VoikkoHandlePool.getInstance().setGlobalBooleanOption(PropertyManager.VOIKKO_OPT_IGNORE_DOT, True)
		VoikkoHandlePool.getInstance().setGlobalBooleanOption(PropertyManager.VOIKKO_OPT_NO_UGLY_HYPHENATION, True)

		# Set these options globally until OOo bug #97945 is resolved.
		VoikkoHandlePool.getInstance().setGlobalBooleanOption(PropertyManager.VOIKKO_OPT_ACCEPT_TITLES_IN_GC, True)
		VoikkoHandlePool.getInstance().setGlobalBooleanOption(PropertyManager.VOIKKO_OPT_ACCEPT_BULLETED_LISTS_IN_GC, True)

		VoikkoHandlePool.getInstance().setGlobalBooleanOption(PropertyManager.VOIKKO_OPT_ACCEPT_UNFINISHED_PARAGRAPHS_IN_GC, True)

		compContext = uno.getComponentContext()
		servManager = compContext.ServiceManager
		self.__linguPropSet = servManager.createInstanceWithContext("com.sun.star.linguistic2.LinguProperties", compContext)
		self.__linguPropSet.addPropertyChangeListener("IsSpellWithDigits", self)
		self.__linguPropSet.addPropertyChangeListener("IsSpellUpperCase", self)
		logging.debug("PropertyManager.initialize: property manager initalized")

		# synchronize the local settings from global preferences
		self.__setProperties(self.__linguPropSet)
		self.readVoikkoSettings()
		# request that all users of linguistic services run the spellchecker and hyphenator
		# again with updated settings
		event = LinguServiceEvent()
		event.nEvent = SPELL_CORRECT_WORDS_AGAIN | SPELL_WRONG_WORDS_AGAIN | HYPHENATE_AGAIN | PROOFREAD_AGAIN
		self.__sendLinguEvent(event)

   def __init__(self, headless = False):
      if "UNO_PATH" in os.environ:
         office = os.environ["UNO_PATH"]
      else:
         if platform.startswith("win"):
            # XXX
            office = ""
         else:
            # Lets hope that works..
            office = '/usr/bin'
      office = os.path.join(office, "soffice")
      if platform.startswith("win"):
          office += ".exe"

      self._pidfile = "/tmp/markup_renderer_OOinstance" #XXX Windows compat needed
      xLocalContext = uno.getComponentContext()
      self._resolver = xLocalContext.ServiceManager.createInstanceWithContext("com.sun.star.bridge.UnoUrlResolver", xLocalContext)
      self._socket = "name=markupRendererPipe"

      args = ["--invisible", "--nologo", "--nodefault", "--norestore", "--nofirststartwizard"]
      if headless:
         args.append("--headless")

      if platform.startswith("win"):
         cmdArray = ['"' + office + '"']
      else:
         cmdArray = [office]
      cmdArray += args + ["--accept=pipe,%s;urp" % self._socket]
      if( not os.path.isfile(self._pidfile)):
         self.pid = os.spawnv(os.P_NOWAIT, office, cmdArray)
         f = open(self._pidfile,"w")
         f.write(str(self.pid))

 def start_ooo(self):
     """
     Start OpenOffice.org process
     TODO: The presentation/Impress plugin may already have it running
     """
     if is_win():
         self.start_ooo_process()
         self.desktop = self.ooo_manager.createInstance('com.sun.star.frame.Desktop')
     else:
         context = uno.getComponentContext()
         resolver = context.ServiceManager.createInstanceWithContext('com.sun.star.bridge.UnoUrlResolver', context)
         uno_instance = None
         loop = 0
         while uno_instance is None and loop < 5:
             try:
                 uno_instance = get_uno_instance(resolver)
             except NoConnectException:
                 time.sleep(0.1)
                 log.exception("Failed to resolve uno connection")
                 self.start_ooo_process()
                 loop += 1
             else:
                 manager = uno_instance.ServiceManager
                 self.desktop = manager.createInstanceWithContext("com.sun.star.frame.Desktop", uno_instance)
                 return
         raise Exception('Unable to start LibreOffice')

def OdtConverter(conf,inputs,outputs):
	# get the uno component context from the PyUNO runtime  
	localContext = uno.getComponentContext()

	# create the UnoUrlResolver 
	# on a single line
	resolver = 	localContext.ServiceManager.createInstanceWithContext	("com.sun.star.bridge.UnoUrlResolver", localContext )

	# connect to the running office                                 
	ctx = resolver.resolve( conf["oo"]["server"].replace("::","=")+";urp;StarOffice.ComponentContext" )
	smgr = ctx.ServiceManager

	# get the central desktop object
	desktop = smgr.createInstanceWithContext( "com.sun.star.frame.Desktop",ctx)

	# get the file name
	adressDoc=systemPathToFileUrl(conf["main"]["dataPath"]+"/"+inputs["InputDoc"]["value"])

	propFich=PropertyValue("Hidden", 0, True, 0),

	myDocument=0
	try:
	    myDocument = desktop.loadComponentFromURL(adressDoc,"_blank",0,propFich)
	except CannotConvertException, e:
	    print >> sys.stderr,  'Impossible de convertir le fichier pour les raisons suivantes : \n'
	    print >> sys.stderr,  e
	    sys.exit(0)

 def connect(self):
     '''Connects to OpenOffice'''
     if os.name == 'nt':
         import socket
     import uno
     from com.sun.star.connection import NoConnectException
     try:
         # Get the uno component context from the PyUNO runtime
         localContext = uno.getComponentContext()
         # Create the UnoUrlResolver
         resolver = localContext.ServiceManager.createInstanceWithContext(
             "com.sun.star.bridge.UnoUrlResolver", localContext)
         # Connect to the running office
         self.ooContext = resolver.resolve(
             'uno:socket,host=localhost,port=%d;urp;StarOffice.' \
             'ComponentContext' % self.port)
         # Is seems that we can't define a timeout for this method.
         # I need it because, for example, when a web server already listens
         # to the given port (thus, not a OpenOffice instance), this method
         # blocks.
         smgr = self.ooContext.ServiceManager
         # Get the central desktop object
         self.oo = smgr.createInstanceWithContext(
             'com.sun.star.frame.Desktop', self.ooContext)
     except NoConnectException, nce:
         raise ConverterError(CONNECT_ERROR % (self.port, nce))

 def suche(self):  
     # Fuer eine Fehlersuche, die bei jedem Methodenaufruf gestartet wird
     
     try:
         ctx = uno.getComponentContext()  
         smgr = ctx.ServiceManager
         desktop = smgr.createInstanceWithContext( "com.sun.star.frame.Desktop",ctx)
         doc = desktop.getCurrentComponent()
         
         secs = doc.TextSections
         el_names = secs.ElementNames
         
         for n in el_names:
             if 'Bereich' in n:
                 pd()
         
     except Exception as e:
         print(tb())
         #pd()
         return e
     
     return None
     
     
          

def unoConnect(host, port):
    ctx = uno.getComponentContext()
    srv_manager = ctx.getServiceManager() 
    resolver = ctx.ServiceManager.createInstanceWithContext("com.sun.star.bridge.UnoUrlResolver", ctx)
    context = resolver.resolve("uno:socket,host="+ str(host) +",port="+ str(port) +";urp;StarOffice.ComponentContext")
    desktop = context.ServiceManager.createInstanceWithContext("com.sun.star.frame.Desktop", ctx)
    return desktop

    def __init__(self, host='localhost', port=DEFAULT_OPENOFFICE_PORT, ooo_restart_cmd=None):
        self._host = host
        self._port = port
        self.logger = logging.getLogger('main')
        self._ooo_restart_cmd = ooo_restart_cmd
        self.localContext = uno.getComponentContext()
        self.serviceManager = self.localContext.ServiceManager
        resolvervector = "com.sun.star.bridge.UnoUrlResolver"
        self._resolver = self.serviceManager.createInstanceWithContext(resolvervector, self.localContext)
        try:
            self.connectOffice()
        except IllegalArgumentException as exception:
            raise DocumentConversionException("The url is invalid (%s)" % exception)
        except NoConnectException as exception:
            if self._restart_ooo():
                # We try again once
                try:
                    self.connectOffice()
                except NoConnectException as exception:
                    raise DocumentConversionException(
                        "Failed to connect to OpenOffice.org on host %s, port %s. %s" % (host, port, exception))
            else:
                raise DocumentConversionException(
                    "Failed to connect to OpenOffice.org on host %s, port %s. %s" % (host, port, exception))

        except ConnectionSetupException as exception:
            raise DocumentConversionException("Not possible to accept on a local resource (%s)" % exception)

    def documentEventOccured(self,ev):

        ctx = uno.getComponentContext()
        smgr = ctx.ServiceManager
        toolkit = smgr.createInstanceWithContext("com.sun.star.awt.Toolkit", ctx)    
        desktop = smgr.createInstanceWithContext( "com.sun.star.frame.Desktop",ctx)
        
        if ev.EventName == 'OnLayoutFinished':
            self.eventb.removeDocumentEventListener(self.listener)

            try:
                # um den Listener nur einmal anzusprechen
                if g.geladen == 'neu':
                    g.geladen = 'alt'    
                if desktop.Name == '':
                    desktop.Name = 'gestartet'
                    
                    from threading import Thread

                    def sleeper(desktop1):   
                        import time
                        #time.sleep(2)  
                        URL="private:factory/swriter"
                        desktop1.ActiveFrame.loadComponentFromURL(URL,'_top','',())  

                    t = Thread(target=sleeper,args=(desktop,))
                    t.start()
                    
            except Exception as e:
                log(inspect.stack,tb())

def main():
    args = parse_args()

    connect_string = 'socket,host=localhost,port=2002;urp'

    # Start OpenOffice.org, listen for connections and open testing document
    os.system(
        "/usr/bin/libreoffice '--accept={};' --calc ./costing_test_doc.ods &"
        .format(connect_string))

    # Get local context info
    localContext = uno.getComponentContext()
    resolver = localContext.ServiceManager.createInstanceWithContext(
        "com.sun.star.bridge.UnoUrlResolver", localContext)

    ctx = None

    # Wait until the OO.o starts and connection is established
    while ctx is None:
        try:
            ctx = resolver.resolve(
                "uno:{};StarOffice.ComponentContext".format(connect_string))
        except:
            pass

    # Execute our job
    if args.command == 'import_pricing':
        blah = ImportEC2Pricing(ctx)
        blah.execute(())
    elif args.command == 'import_instance_data':
        blah2 = ImportEC2InstanceData(ctx)
        blah2.execute(())

def startOOAndConnect():
    """
    Start OO in child process and connect to them.
    Return OO component context object.
    """
    pid = os.fork()
    if not pid:
      pid = os.getpid()
      os.setpgid(pid,pid)
      os.system("soffice -headless -norestore '-accept=socket,host=localhost,port=%s;urp;' &" % OOCONV_PORT)
      while 1:
          time.sleep(1)
    else:
        limit = time.time() + OOCONV_MAX_STARTUP_TIME
        ctx = None
        context = uno.getComponentContext()
        resolver=context.ServiceManager.createInstanceWithContext(
            "com.sun.star.bridge.UnoUrlResolver", context)

        while time.time() < limit:
            try:
                ctx = resolver.resolve(
                    "uno:socket,host=localhost,port=%s;urp;StarOffice.ComponentContext" % OOCONV_PORT)
                break
            except:
                pass
            time.sleep(5)
        if ctx is None:
            pgid = os.getpgid(pid)
            os.killpg(pgid, signal.SIGTERM)                        
            return None, None
        return ctx, pid

def getServiceManager(host, port, uno_path, office_binary_path):
  """Get the ServiceManager from the running OpenOffice.org.
  """
  # Add in sys.path the path of pyuno
  if uno_path not in sys.path:
    sys.path.append(uno_path)
  fundamentalrc_file = '%s/fundamentalrc' % office_binary_path
  if os.path.exists(fundamentalrc_file) and \
      'URE_BOOTSTRAP' not in os.environ:
    os.putenv('URE_BOOTSTRAP', 'vnd.sun.star.pathname:%s' % fundamentalrc_file)
  import uno
  # Get the uno component context from the PyUNO runtime
  uno_context = uno.getComponentContext()
  # Create the UnoUrlResolver on the Python side.
  url_resolver = "com.sun.star.bridge.UnoUrlResolver"
  resolver = uno_context.ServiceManager.createInstanceWithContext(url_resolver,
                                                                  uno_context)
  # Connect to the running OpenOffice.org and get its
  # context.
  # Retry 10 times if needed.
  for i in range(10):
    try:
      uno_connection = resolver.resolve("uno:socket,host=%s,port=%s;urp;StarOffice.ComponentContext" % (host, port))
      break
    except:
      # I don't know how to import com.sun.star.connection.NoConnectException
      time.sleep(1)
  # Get the ServiceManager object
  return uno_connection.ServiceManager

 def createAvailableResourcesDialog(self,query,textList,imagesList):
     #localContext = uno.getComponentContext()
     #resolver = localContext.ServiceManager.createInstanceWithContext("com.sun.star.bridge.UnoUrlResolver", localContext )
     #ctx = resolver.resolve( "uno:socket,host=localhost,port=2002;urp;StarOffice.ComponentContext" )
     ctx=uno.getComponentContext()
     smgr = ctx.ServiceManager
     desktop = smgr.createInstanceWithContext( "com.sun.star.frame.Desktop",ctx)
     doc = desktop.getCurrentComponent()
     if not hasattr(doc, "Text"):
         doc = desktop.loadComponentFromURL( "private:factory/swriter","_blank", 0, () )
     oDialog = smgr.createInstanceWithContext("com.sun.star.awt.UnoControlDialog",ctx)      
     oDialogModel = self.createDialog(ctx,smgr,120,True,"DialogResourceList",100,100,0,0,"Resource List",200)        
     self.createLabel(oDialogModel, "formulaLabel", query, 10, 100, 5, 5)  
     oDialog.setVisible(False)
     self.createDialogButton(oDialogModel, "GetResourcesButton", 15, 50, 25, 100, "Get Resources")
     txtEnd = self.addTextCheckBoxesToDialog(textList, oDialogModel)                 #get the end of the text
     imgEnd = self.addImageTextBoxesToDialog(query,txtEnd,imagesList, oDialogModel)  #get the end of the images
     oDialogModel.Width =imgEnd                                          #set the dialog width
     oDialogModel.Height = max(100,txtEnd+25)                            #set the dialog height
     oDialog.setModel(oDialogModel)
     oButton1 = oDialog.getControl("GetResourcesButton")
     oButton1.getModel().PositionY = txtEnd+5                            #reposition the button
     oButton1.setActionCommand("commanded")
     oButton1.addActionListener(MyActionListener(oDialog))
     oToolkit = smgr.createInstanceWithContext("com.sun.star.awt.Toolkit", ctx)
     oDialog.createPeer(oToolkit,oToolkit.getDesktopWindow()) 
     return oDialog     

        def __init__(self, filename):
            """Create a reader"""
            local = uno.getComponentContext()
            resolver = local.ServiceManager.createInstanceWithContext(
                                "com.sun.star.bridge.UnoUrlResolver", local)

            try:
                context = resolver.resolve(
                    "uno:socket,host=localhost,port=2002;"
                    "urp;StarOffice.ComponentContext")
            except NoConnectException:
                raise Exception(CONNECT_MSG)

            desktop = context.ServiceManager.createInstanceWithContext(
                                        "com.sun.star.frame.Desktop", context)

            cwd = systemPathToFileUrl(os.getcwd())
            file_url = absolutize(cwd, systemPathToFileUrl(
                    os.path.join(os.getcwd(), filename)))
            in_props = PropertyValue("Hidden", 0, True, 0),
            document = desktop.loadComponentFromURL(
                file_url, "_blank", 0, in_props)
            self.rules = document.Sheets.getByName(u'rules')
            try:
                self.invalid = document.Sheets.getByName(u'invalid')
            except NoSuchElementException:
                self.invalid = None

def main():
  try:
    # Log
    f = open('/var/log/mediboard/doctopdf', 'a');
    f.write('---' + time.strftime('%d/%m/%y %H:%M',time.localtime()) + '---\n')
    f.write('Convert '+ sys.argv[1] + ' to ' + sys.argv[2] + '\n');
    
    local = uno.getComponentContext()
    resolver = local.ServiceManager.createInstanceWithContext("com.sun.star.bridge.UnoUrlResolver", local)
    context = resolver.resolve("uno:socket,host=localhost,port=8100;urp;StarOffice.ComponentContext")
    desktop = context.ServiceManager.createInstanceWithContext("com.sun.star.frame.Desktop", context)
    
    document = desktop.loadComponentFromURL("file://"+sys.argv[1], "_blank", 0, ())
    
    from com.sun.star.beans import PropertyValue
    property = (
      PropertyValue("FilterName", 0, "writer_pdf_Export", 0),
    )
    
    document.storeToURL("file://"+sys.argv[2], property)
    
    document.close(True)
    print '1'
    
    # Fin de log
    f.write('Successfully converted \n')
    f.close()
  except Exception as inst:
    f.write(traceback.format_exc() + '\n')
    f.close()
    print '0'

    def create_document(self):
        localContext = uno.getComponentContext()
        				   
        resolver = localContext.ServiceManager.createInstanceWithContext(
        				"com.sun.star.bridge.UnoUrlResolver", localContext )
        
        self.smgr = resolver.resolve( "uno:socket,host=localhost,port=2003;urp;StarOffice.ServiceManager" )
        remoteContext = self.smgr.getPropertyValue( "DefaultContext" )

        desktop = self.smgr.createInstanceWithContext( "com.sun.star.frame.Desktop",remoteContext)
        
        # open a writer document
        self.doc = desktop.loadComponentFromURL( "private:factory/swriter","_blank", 0, () )
        
        # shortcuts
        self.text = self.doc.Text
        self.cursor = self.text.createTextCursor()

        doc_id = uuid.uuid1().hex
        self.docs[doc_id] = {
            'text':   self.text,
            'cursor': self.cursor,
            'doc':    self.doc
        }

        return doc_id