Python uno.getComponentContext函数代码示例

    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