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 __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 connect(args = [], path = '', wait = 0):
"""Deze functie maakt het mogelijk om openoffice vanaf de python-interpeter te starten en te bedienen.
path is het pad naar OpenOffice en args een list van command-line argumenten.
wait is het aantal seconden dat deze functie wacht met retourneren wanneer hij klaar is. Dit is handig wanneer je
bestanden aan het laden bent, wat de OOConext is pas bruikbaar wanneer dat bestand geladen is.
"""
if not path:
path = getoopath()
exe = os.path.join(path, 'scalc')
if sys.platform.startswith('win'):
exe += '.exe'
command = [exe, '-accept=pipe,name=unopipe;urp;']
command.extend(args)
os.spawnv(os.P_NOWAIT, exe, command)
xlc = uno.getComponentContext()
resolver = xlc.ServiceManager.createInstanceWithContext('com.sun.star.bridge.UnoUrlResolver', xlc)
con = 'uno:pipe,name=unopipe;urp;StarOffice.ComponentContext'
for i in range(20):
try:
print 'Poging %i' % i
ctx = resolver.resolve(con)
OOContext(ctx)
if wait:
print 'Even wachten...'
sleep(wait)
print 'Gelukt'
return
except:
sleep(0.5)
print 'Mislukt'
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 __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 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 get_uno_desktop(self):
"""
On non-Windows platforms, use Uno. Get the OpenOffice desktop
which will be used to manage impress
"""
log.debug(u'get UNO Desktop Openoffice')
uno_instance = None
loop = 0
log.debug(u'get UNO Desktop Openoffice - getComponentContext')
context = uno.getComponentContext()
log.debug(u'get UNO Desktop Openoffice - createInstaneWithContext - UnoUrlResolver')
resolver = context.ServiceManager.createInstanceWithContext(u'com.sun.star.bridge.UnoUrlResolver', context)
while uno_instance is None and loop < 3:
try:
uno_instance = get_uno_instance(resolver)
except:
log.warn(u'Unable to find running instance ')
self.start_process()
loop += 1
try:
self.manager = uno_instance.ServiceManager
log.debug(u'get UNO Desktop Openoffice - createInstanceWithContext'
u' - Desktop')
desktop = self.manager.createInstanceWithContext("com.sun.star.frame.Desktop", uno_instance)
return desktop
except:
log.warn(u'Failed to get UNO desktop')
return None
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 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
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 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 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 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 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 __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 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 __init__(self, host, port):
localContext = uno.getComponentContext()
localServiceManager = localContext.ServiceManager
resolver = localServiceManager.createInstanceWithContext("com.sun.star.bridge.UnoUrlResolver", localContext)
self.context = resolver.resolve("uno:socket,host=" + host + ",port=" + str(port) + ";urp;StarOffice.ComponentContext")
self.svcManager = self.context.ServiceManager
self.inputProps = (PropertyValue("Hidden", 0, True, 0),)
def ooo_connect():
"""
Connection to open office server.
Fill a dictionnary and return it
"""
# 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
try:
ctx = resolver.resolve("uno:socket,host=localhost,port=%s;urp;StarOffice.ComponentContext"%(options.port))
except:
raise Exception("Can't connect to openoffice.org server")
smgr = ctx.ServiceManager
# get the central desktop object
desktop = smgr.createInstanceWithContext("com.sun.star.frame.Desktop",ctx)
d = dict()
d['ctx'] = ctx
d['smgr'] = smgr
d['doc'] = None
d['desktop'] = desktop
return d
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 connect(self, connectStr):
localContext = uno.getComponentContext()
resolver = localContext.ServiceManager.createInstanceWithContext(
"com.sun.star.bridge.UnoUrlResolver", localContext)
ctx = resolver.resolve( connectStr )
orb = ctx.ServiceManager
return orb
def expandUri(uri):
if uri.startswith("vnd.sun.star.expand:"):
uri = uri.replace("vnd.sun.star.expand:", "", 1)
uri = uno.getComponentContext().getByName("/singletons/com.sun.star.util.theMacroExpander").expandMacros(uri)
if uri.startswith("file:"):
uri = uno.absolutize("", uri) # necessary to get rid of .. in uri
return uri
def main():
connectionString = "socket,host=localhost,port=2002"
url = "uno:" + connectionString + ";urp;StarOffice.ComponentContext"
localCtx = uno.getComponentContext()
localSmgr = localCtx.ServiceManager
resolver = localSmgr.createInstanceWithContext(
"com.sun.star.bridge.UnoUrlResolver", localCtx)
ctx = resolver.resolve(url)
smgr = ctx.ServiceManager
rowset =smgr.createInstanceWithContext("com.sun.star.sdb.RowSet", ctx)
rowset.DataSourceName = "Bibliography"
rowset.CommandType = COMMAND
rowset.Command = "SELECT IDENTIFIER, AUTHOR FROM biblio"
rowset.execute();
print("Identifier\tAuthor")
id = rowset.findColumn("IDENTIFIER")
author = rowset.findColumn("AUTHOR")
while rowset.next():
print(rowset.getString(id) + "\t" + repr(rowset.getString(author)))
rowset.dispose();
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 main():
retVal = 0
outputfile = "output.swx"
opts, args = getopt.getopt(sys.argv[1:], "hco:", ["help", "connection-string=", "outfile" ])
url = "uno:socket,host=localhost,port=2002;urp;StarOffice.ComponentContext"
for o, a in opts:
if o in ("-h", "--help"):
usage()
sys.exit()
if o in ("-c", "--connection-string" ):
url = "uno:" + a + ";urp;StarOffice.ComponentContext"
if o in ("-o", "--outfile"):
outputfile = a
if not len( args ):
usage()
sys.exit()
try:
ctxLocal = uno.getComponentContext()
smgrLocal = ctxLocal.ServiceManager
resolver = smgrLocal.createInstanceWithContext(
"com.sun.star.bridge.UnoUrlResolver", ctxLocal )
ctx = resolver.resolve( url )
smgr = ctx.ServiceManager
desktop = smgr.createInstanceWithContext("com.sun.star.frame.Desktop", ctx )
except NoConnectException, e:
sys.stderr.write("OpenOffice process not found or not listening (" + e.Message + ")\n")
sys.exit(1)
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 convert(self):
"""Convert the document"""
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")
smgr = ctx.ServiceManager
desktop = smgr.createInstanceWithContext("com.sun.star.frame.Desktop", ctx)
# load the document
url = unohelper.systemPathToFileUrl(self.fullname)
doc = desktop.loadComponentFromURL(url, "_blank", 0, ())
filterName = "swriter: HTML (StarWriter)"
storeProps = (PropertyValue("FilterName", 0, filterName, 0),)
# pre-create a empty file for security reason
url = unohelper.systemPathToFileUrl(self.outputfile)
doc.storeToURL(url, storeProps)
try:
doc.close(True)
except CloseVetoException:
pass
# maigic to release some resource
ctx.ServiceManager
def oless_from_inputstream(inputstream):
import uno
context = uno.getComponentContext()
sm = context.ServiceManager
name = 'com.sun.star.embed.OLESimpleStorage'
args = (inputstream, )
return sm.createInstanceWithArgumentsAndContext(name, args, context)
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 connect(self, no_startup=False):
"""
Connect to OpenOffice.
If a connection cannot be established try to start OpenOffice.
"""
localContext = uno.getComponentContext()
resolver = localContext.ServiceManager.createInstanceWithContext(
"com.sun.star.bridge.UnoUrlResolver", localContext)
context = None
did_start = False
n = 0
while n < 6:
try:
context = resolver.resolve(
"uno:socket,host=localhost,port=%d;urp;StarOffice.ComponentContext"
% self.port)
break
except NoConnectException:
pass
# If first connect failed then try starting OpenOffice.
if n == 0:
# Exit loop if startup not desired.
if no_startup:
break
self.startup()
did_start = True
# Pause and try again to connect
time.sleep(1)
n += 1
if not context:
raise Exception, "Failed to connect to OpenOffice on port %d" % self.port
desktop = context.ServiceManager.createInstanceWithContext(
"com.sun.star.frame.Desktop", context)
if not desktop:
raise Exception, "Failed to create OpenOffice desktop on port %d" % self.port
if did_start:
_started_desktops[self.port] = desktop
return desktop
def getPathesFromPackage( rootUrl, sfa ):
ret = ()
try:
fileUrl = rootUrl + "/META-INF/manifest.xml"
inputStream = sfa.openFileRead( fileUrl )
parser = uno.getComponentContext().ServiceManager.createInstance( "com.sun.star.xml.sax.Parser" )
handler = ManifestHandler( rootUrl )
parser.setDocumentHandler( handler )
parser.parseStream( InputSource( inputStream , "", fileUrl, fileUrl ) )
for i in tuple(handler.urlList):
if not isPyFileInPath( sfa, i ):
handler.urlList.remove(i)
ret = tuple( handler.urlList )
except UnoException, e:
text = lastException2String()
log.debug( "getPathesFromPackage " + fileUrl + " Exception: " +text )
pass
def configuration_access(path, write=False):
"""Creates a XNameAccess instance for read and write access to the
configuration at the given node path."""
ctx = uno.getComponentContext()
configurationProvider = ctx.ServiceManager.createInstance(
'com.sun.star.configuration.ConfigurationProvider')
value = PropertyValue()
value.Name = 'nodepath'
value.Value = path
if write:
servicename = 'com.sun.star.configuration.ConfigurationUpdateAccess'
else:
servicename = 'com.sun.star.configuration.ConfigurationAccess'
configurationAccess = configurationProvider.createInstanceWithArguments(
servicename, (value, ))
return configurationAccess
def TestDialogs():
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")
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, ())
oDialogModel = smgr.createInstanceWithContext(
"com.sun.star.awt.UnoControlDialogModel", ctx)
print(oDialogModel)
oDialog = smgr.createInstanceWithContext(
"com.sun.star.awt.UnoControlDialog", ctx)
oDialog.setModel(oDialogModel)
oDialogControl = oDialog.getControls()
sPropNames = [
'Height', 'Moveable', 'Name', 'PositionX', 'PositionY', 'Step',
'TabIndex', 'Title', 'Width'
]
#sValues = [uno.Any('Numeric',380),uno.Any('bool',True),uno.Any("MyTestDialog"),uno.Any(102),41,0,0,'OpenOffice',250]
#oDialogModel.setPropertyValues(sPropNames,sValues)
oDialogModel.Height = 100
oDialogModel.Moveable = True
oDialogModel.Name = "MyTestDialog"
oDialogModel.PositionX = 102
oDialogModel.PositionY = 41
oDialogModel.Step = 0
oDialogModel.TabIndex = 0
oDialogModel.Title = "Select The Formula Resources"
oDialogModel.Width = 250
oButtonModel = smgr.createInstanceWithContext(
"com.sun.star.awt.UnoControlButtonModel", ctx)
#oUnoControlModel = smgr.createInstanceWithContext("com.sun.star.awt.UnoControlDialogElement",ctx)
#parentWin = oDialogModel.CurrentController.Frame.ContainerWindow
createCheckBox(ctx, oDialogModel)
#oDialogModel.insertByName("CheckBox2",addCheckBox(ctx,"formula2",0))
oDialog.setVisible(False)
oToolkit = smgr.createInstanceWithContext("com.sun.star.awt.Toolkit", ctx)
oDialog.createPeer(oToolkit, oToolkit.getDesktopWindow())
print(oDialog.execute())
print(oDialogControl)
def main(*args):
ctx = uno.getComponentContext()
smgr = ctx.ServiceManager
try:
ui_locale = gettext.translation(
'base',
localedir=urllib.url2pathname(
get_main_directory("com.addon.pagenumbering") +
'python/locales'),
languages=[getLanguage()])
except Exception, e:
ui_locale = gettext.translation(
'base',
localedir=urllib.url2pathname(
get_main_directory("com.addon.pagenumbering") +
'python/locales'),
languages=["en"])
def __init__(self, nPositionX=None, nPositionY=None, nWidth=None, nHeight=None, sTitle=None):
self.sTitle = sTitle
self.LocalContext = uno.getComponentContext()
self.ServiceManager = self.LocalContext.ServiceManager
self.Toolkit = self.ServiceManager.createInstanceWithContext("com.sun.star.awt.ExtToolkit", self.LocalContext)
# --------------create dialog container and set model and properties
self.DialogContainer = self.ServiceManager.createInstanceWithContext("com.sun.star.awt.UnoControlDialog", self.LocalContext)
self.DialogModel = self.ServiceManager.createInstance("com.sun.star.awt.UnoControlDialogModel")
self.DialogContainer.setModel(self.DialogModel)
self.DialogModel.PositionX = nPositionX
self.DialogModel.PositionY = nPositionY
self.DialogModel.Height = nHeight
self.DialogModel.Width = nWidth
self.DialogModel.Name = "Default"
self.DialogModel.Closeable = True
self.DialogModel.Moveable = True
def __init__(self, ctx, *args):
global spellchecker
global SMGR
self.ctx = ctx
self.ServiceName = "com.sun.star.linguistic2.Proofreader"
self.ImplementationName = "org.openoffice.comp.pyuno.Lightproof." + pkg
self.SupportedServiceNames = (self.ServiceName, )
self.locales = []
for i in locales:
l = locales[i]
self.locales += [Locale(l[0], l[1], l[2])]
self.locales = tuple(self.locales)
currentContext = uno.getComponentContext()
SMGR = currentContext.ServiceManager
spellchecker = SMGR.createInstanceWithContext(
"com.sun.star.linguistic2.SpellChecker", currentContext)
lightproof_handler_nb_NO.load(currentContext)
def _connect(self):
try:
localContext = uno.getComponentContext()
resolver = localContext.ServiceManager.createInstanceWithContext(
"com.sun.star.bridge.UnoUrlResolver", localContext)
smgr = resolver.resolve(self.connectstr)
remoteContext = smgr.getPropertyValue("DefaultContext")
self.desktop = smgr.createInstanceWithContext(
"com.sun.star.frame.Desktop", remoteContext)
return self.desktop
except (NoConnectException, ConnectionSetupException):
logging.exception("UNO server not started.")
raise
def showPanels(panelWin, url):
"""
Create a new panel object when the sidebar is initialized
or whenever a panel becomes visible
"""
ctx = uno.getComponentContext()
# url is set in Sidebar.xcu
if url == 'private:resource/toolpanel/autotextaddon/Panel1':
pos_y = 20
app = Panel1(panelWin)
app.showDialog()
panel_height = app.getHeight()
return panel_height + pos_y
def insert_hd1(*args):
ctx = uno.getComponentContext()
smgr = ctx.ServiceManager
# get the doc from the scripting context which is made available to all scripts
Doc = XSCRIPTCONTEXT.getDocument()
UndoManager = Doc.getUndoManager()
ParaStyles = Doc.StyleFamilies.getByName("ParagraphStyles")
#xray(smgr, ctx, ParaStyles)
#Create view cursor to take current cursor position
ViewCursor = Doc.CurrentController.getViewCursor()
#xray(smgr, ctx, ViewCursor)
UndoManager.enterUndoContext("Style to Heading 1")
ViewCursor.ParaStyleName = "Heading 1"
UndoManager.leaveUndoContext()
def connect(self):
proc = self.get_proc()
if proc is None:
self.start()
for attempt in range(15):
try:
context = uno.getComponentContext()
resolver = self._svc_create(context, RESOLVER)
context = resolver.resolve("uno:%s" % CONNECTION)
return self._svc_create(context, DESKTOP)
except NoConnectException:
log.warning("No connection to LibreOffice (%s)", attempt)
time.sleep(2)
except DisposedException:
raise SystemFailure("Bridge is disposed.")
raise SystemFailure("No connection to LibreOffice")
def copyUsingPropertySetInfo(srcObj, dstObj):
"""
Cope the whole PropertySet of an UNO object to an other instance.
"""
ctx = uno.getComponentContext()
smgr = ctx.ServiceManager
sPInfo = srcObj.getPropertySetInfo()
dPInfo = dstObj.getPropertySetInfo()
oProps = sPInfo.getProperties()
for i in xrange(len(oProps)):
oProp = oProps[i]
try:
if dPInfo.hasPropertyByName(oProp.Name):
xray(smgr, ctx, oProp.Type)
if oProp.Type.getName() == dPInfo.getPropertyByName(
oProp.Name).Type.getName():
oSValue = srcObj.getPropertyValue(oProp.Name)
if canCopyTypeWithAssignment(oSValue):
if (uno.getConstantByName(
"com.sun.star.beans.PropertyAttribute.READONLY"
) and oProp.Attributes) == False:
if oProp.Name != "GridLines":
dstObj.setPropertyValue(oProp.Name, oSValue)
elif uno.IsArray(oSValue):
pass
else:
oDValue = dstObj.getPropertyValue(oProp.Name)
if oDValue == None or uno.IsEmpty(oDValue):
if (uno.getConstantByName(
"com.sun.star.beans.PropertyAttribute.READONLY"
) and oProp.Attributes) == False:
dstObj.setPropertyValue(oProp.Name, oSValue)
elif uno.HasUnoInterfaces(
oSValue,
"com.sun.star.beans.XPropertySet"):
if oSValue.SupportsService(
"com.sun.star.text.Text"):
pass
else:
copyUsingPropertySetInfo(oSValue, oDValue)
except Exception, e:
xray(smgr, ctx, e.message)
return
def uno_open(file):
"""This function should really just be in uno
file -- Location of the file to open - must be a FieldFile
returns an uno document
"""
local = uno.getComponentContext()
resolver = local.ServiceManager.createInstanceWithContext("com.sun.star.bridge.UnoUrlResolver", local)
context = resolver.resolve("uno:socket,host=localhost,port=2002;urp;StarOffice.ComponentContext")
desktop = context.ServiceManager.createInstanceWithContext("com.sun.star.frame.Desktop", context)
if 'amazonaws' in settings.STATIC_URL and hasattr(file, 'url'):
file_url = file.url
else:
if isinstance(file, FieldFile):
# We want the File then
file = file.file
file_url = "file://" + str(file)
return desktop.loadComponentFromURL(file_url ,"_blank", 0, ())
def createWriterDocument(
self
): #get the doc from the scripting context which is made available to all scripts
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"
)
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, ())
return doc
def connect(self, socket):
""" Tries to connect to the LibreOffice instance through the specified socket"""
xLocalContext = uno.getComponentContext()
xUnoResolver = xLocalContext.ServiceManager.createInstanceWithContext(
"com.sun.star.bridge.UnoUrlResolver", xLocalContext)
url = "uno:" + socket + ";urp;StarOffice.ComponentContext"
print("OfficeConnection: connecting to: " + url)
while True:
if self.soffice and self.soffice.poll() is not None:
raise Exception("soffice has stopped.")
try:
xContext = xUnoResolver.resolve(url)
return xContext
except pyuno.getClass("com.sun.star.connection.NoConnectException"):
print("NoConnectException: sleeping...")
time.sleep(1)
def __init__(self,
autostart=False,
office='soffice \
--accept="socket,host=localhost,port=2002;urp;"',
connection_string="\
uno:socket,host=localhost,port=2002;urp;StarOffice.ComponentContext",
timeout=30,
attempt_period=0.1):
"""
Constructor
@type autostart: bool
@param autostart: Auto Starts Libre/Open Office with a listening socket
@type office: string
@param office: Libre/Open Office startup string
@type connection_string: string
@param connection_string: Libre/Open office initialization string
@type timeout: int
@param timeout: Timeout for starting Libre/Open Office in seconds
@type attempt_period: int
@param attempt_period: Timeout between attempts in seconds
"""
self._sheets = None
self._fields = None
self._connection_string = connection_string
# LibreOffice variables.
self._oResolver = None
self._oContext = None
self._oDesktop = None
self._oDoc = None
self._oLocal = uno.getComponentContext()
if self._oLocal:
self._oResolver = \
self._oLocal.ServiceManager.createInstanceWithContext(
"com.sun.star.bridge.UnoUrlResolver", self._oLocal)
if autostart:
self._autostart_office(office, timeout, attempt_period)
else:
self._init_doc()
def getSelectedText():
connected = False
while not connected:
try:
# Establish a connection with the LO API Service
localContext = uno.getComponentContext()
resolver = localContext.ServiceManager.createInstanceWithContext(
"com.sun.star.bridge.UnoUrlResolver", localContext)
ctx = resolver.resolve(
"uno:pipe,name=open365_LO;urp;StarOffice.ComponentContext")
smgr = ctx.ServiceManager
connected = True
except Exception:
time.sleep(0.5)
desktop = smgr.createInstanceWithContext("com.sun.star.frame.Desktop", ctx)
getSelectedTextFunc = getSelectedTextFuncs[sys.argv[1]]
return getSelectedTextFunc(desktop)
def MyMacro(*args):
"""Write Helo World in Writer"""
try:
ctx = remote_ctx # use in development
except:
ctx = uno.getComponentContext() # use in production
# get desktop
desktop = ctx.getByName("/singletons/com.sun.star.frame.theDesktop")
# get document
document = desktop.getCurrentComponent()
# access the document's text property
text = document.Text
# create a cursor
cursor = text.createTextCursor()
# insert the text into the document
text.insertString(cursor, "Hello World", 0)
def __init__(self, port=DEFAULT_OPENOFFICE_PORT):
self.parser = OOoDocumentParser()
self.vnConverter = VietnameseTextConverter(decoderPrefix='internal_')
self.oVnConverter = OOoVietnameseTextConverter(self.vnConverter)
self.parser.setTextPortionConverter(self.oVnConverter)
localContext = uno.getComponentContext()
resolver = localContext.ServiceManager.createInstanceWithContext(
"com.sun.star.bridge.UnoUrlResolver", localContext)
try:
context = resolver.resolve(
"uno:socket,host=localhost,port=%s;urp;StarOffice.ComponentContext"
% port)
except NoConnectException:
raise DocumentConversionException, "failed to connect to OpenOffice.org on port %s" % port
self.desktop = context.ServiceManager.createInstanceWithContext(
"com.sun.star.frame.Desktop", context)
self._setupLogging()
def get_connection(retry=2):
while retry > 0:
try:
localContext = uno.getComponentContext()
resolver = localContext.ServiceManager.createInstanceWithContext(
"com.sun.star.bridge.UnoUrlResolver", localContext)
ctx = resolver.resolve(CONN_STRING)
return ctx
except:
retry -= 1
kill_and_relaunch_oo()
time.sleep(8)
raise Exception(
'could not launch oo, please read README.txt section Openoffice for troubleshooting'
)
def __init__(self, input, output):
self.url_input=input
self.url_output=output
self.localContext = uno.getComponentContext()
self.resolver = self.localContext.ServiceManager.createInstanceWithContext(
"com.sun.star.bridge.UnoUrlResolver", self.localContext)
self.ctx = self.resolver.resolve("uno:socket,host=localhost,port=8100;urp;StarOffice.ComponentContext")
self.smgr = self.ctx.ServiceManager
self.desktop = self.smgr.createInstanceWithContext("com.sun.star.frame.Desktop", self.ctx)
#self.loader = self.smgr.createInstanceWithContext("com.sun.star.frame.XComponentLoader", self.desktop)
#load files
properties = []
p=PropertyValue()
p.Name = "Hidden"
p.Value = True
properties.append(p)
self.doc = self.desktop.loadComponentFromURL(self.url_input, "_default", 0, tuple(properties))
def open_filepicker(title, path=None, mode=10, filter_tuple=None):
"""
Possible modes: http://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1ui_1_1dialogs_1_1TemplateDescription.html
mode 0: simple open
mode 10 : file save with option "automatic file name extension"
"""
oCtx = uno.getComponentContext()
oServiceManager = oCtx.getServiceManager()
filepicker = oServiceManager.createInstanceWithArgumentsAndContext(
"com.sun.star.ui.dialogs.OfficeFilePicker", (mode, ), oCtx)
if path:
filepicker.setDisplayDirectory(path)
if filter_tuple:
filepicker.appendFilter(filter_tuple[0], filter_tuple[1])
filepicker.Title = title
if filepicker.execute():
return filepicker.getFiles()[0]
def initializeOptionsOnce():
ctx = uno.getComponentContext()
smgr = ctx.getServiceManager()
readConfig, writeConfig = optionsdialog.createConfigAccessor(
ctx, smgr,
"/com.philolog.hoplitekb.ExtensionData/Leaves/HKBSettingsNode")
defaults = readConfig("Defaults/Width", "Defaults/Height",
"Defaults/UnicodeMode")
#set current value
cfgnames = "Width", "Height", "UnicodeMode"
maxwidth, maxheight, umode = readConfig(*cfgnames)
umode = umode or defaults[2]
if umode == "PrecomposedPUA":
setUnicodeMode(1)
elif umode == "CombiningOnly":
setUnicodeMode(2)
else:
setUnicodeMode(0)
def __init__(self,
host=DEFAULT_OPENOFFICE_HOST,
port=DEFAULT_OPENOFFICE_PORT):
# UNO component context
self.localContext = uno.getComponentContext()
self.serviceManager = self.localContext.ServiceManager
# UnoUrlResolver
self.resolver = self.localContext.ServiceManager.createInstanceWithContext(
"com.sun.star.bridge.UnoUrlResolver", self.localContext)
try:
self.context = self.resolver.resolve(
"uno:socket,host=%s,port=%s;urp;StarOffice.ComponentContext" %
(host, port))
except NoConnectException:
raise (DocumentConversionException,
"failed to connect to OpenOffice.org on port %s" % port)
self.desktop = self.context.ServiceManager.createInstanceWithContext(
"com.sun.star.frame.Desktop", self.context)
def __init__(self,
host='localhost',
port=DEFAULT_OPENOFFICE_PORT,
ooo_restart_cmd=None):
self._host = host
self._port = port
self._ooo_restart_cmd = ooo_restart_cmd
self.localContext = uno.getComponentContext()
self.serviceManager = self.localContext.ServiceManager
self._resolver = self.serviceManager.createInstanceWithContext(
"com.sun.star.bridge.UnoUrlResolver", self.localContext)
try:
self._context = self._resolver.resolve(
"uno:socket,host=%s,port=%s;urp;StarOffice.ComponentContext" %
(host, port))
except IllegalArgumentException, exception:
raise DocumentConversionException("The url is invalid (%s)" %
exception)
def __init__( self, ctx, *args ):
if log.isDebugLevel():
mystr = ""
for i in args:
if len(mystr) > 0:
mystr = mystr +","
mystr = mystr + str(i)
log.debug( "Entering PythonScriptProvider.ctor" + mystr )
storageType = ""
if isinstance(args[0],unicode ):
storageType = args[0]
else:
storageType = args[0].SCRIPTING_DOC_URI
isPackage = storageType.endswith( ":uno_packages" )
try:
# urlHelper = ctx.ServiceManager.createInstanceWithArgumentsAndContext(
# "com.sun.star.script.provider.ScriptURIHelper", (LANGUAGENAME, storageType), ctx)
urlHelper = MyUriHelper( ctx, storageType )
log.isDebugLevel() and log.debug( "got urlHelper " + str( urlHelper ) )
rootUrl = expandUri( urlHelper.getRootStorageURI() )
log.isDebugLevel() and log.debug( storageType + " transformed to " + rootUrl )
ucbService = "com.sun.star.ucb.SimpleFileAccess"
sfa = ctx.ServiceManager.createInstanceWithContext( ucbService, ctx )
if not sfa:
log.debug("PythonScriptProvider couldn't instantiate " +ucbService)
raise RuntimeException(
"PythonScriptProvider couldn't instantiate " +ucbService, self)
self.provCtx = ProviderContext(
storageType, sfa, urlHelper, ScriptContext( uno.getComponentContext(), None ) )
if isPackage:
mapPackageName2Path = getPackageName2PathMap( sfa, storageType )
self.provCtx.setPackageAttributes( mapPackageName2Path , rootUrl )
self.dirBrowseNode = PackageBrowseNode( self.provCtx, LANGUAGENAME, rootUrl )
else:
self.dirBrowseNode = DirBrowseNode( self.provCtx, LANGUAGENAME, rootUrl )
except Exception, e:
text = lastException2String()
log.debug( "PythonScriptProvider could not be instantiated because of : " + text )
raise e
def connect():
"""
Start LibreOffice with
libreoffice -calc -accept="socket,host=localhost,port=2002;urp;StarOffice.ServiceManager"
and call this from a Python interactive console
"""
import uno
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" )
smgr = ctx.ServiceManager
desktop = smgr.createInstanceWithContext( "com.sun.star.frame.Desktop",ctx)
# get current document model
model = desktop.getCurrentComponent()
return SpreadSheet(model.Sheets)
def mousePressed(self, ev):
global sorted_by_title
dialog = ev.Source.getContext()
action_command = ev
smgr = self.ctx.ServiceManager
auto_list = dialog.getControl("SavedAutotext")
selected_pos = auto_list.getSelectedItemPos()
psm = uno.getComponentContext().ServiceManager
dps = psm.createInstance("com.sun.star.text.AutoTextContainer")
oRange = dps.getByName(current_group)
selected_autotext = oRange.getByIndex(sorted_by_title[selected_pos][1])
# getString
preview_label = dialog.getControl("PreviewLabel")
preview_label.setText(selected_autotext.getString())
def get_parent():
ctx = uno.getComponentContext()
smgr = ctx.ServiceManager
desktop = smgr.createInstanceWithContext("com.sun.star.frame.Desktop", ctx)
if desktop.CurrentFrame:
parent = desktop.CurrentFrame.ContainerWindow
else:
enum = desktop.Components.createEnumeration()
comps = []
while enum.hasMoreElements():
comps.append(enum.nextElement())
doc = comps[0]
parent = doc.CurrentController.Frame.ContainerWindow
return parent
def getServiceManager(cHost="localhost", cPort="2002"):
"""Get the ServiceManager from the running OpenOffice.org.
Then retain it in the global variable goServiceManager for future use.
This is similar to the GetProcessServiceManager() in OOo Basic.
"""
global goServiceManager
if not goServiceManager:
# Get the uno component context from the PyUNO runtime
oLocalContext = uno.getComponentContext()
# Create the UnoUrlResolver on the Python side.
oLocalResolver = oLocalContext.ServiceManager.createInstanceWithContext(
"com.sun.star.bridge.UnoUrlResolver", oLocalContext)
# Connect to the running OpenOffice.org and get its context.
oContext = oLocalResolver.resolve("uno:socket,host=" + cHost +
",port=" + cPort +
";urp;StarOffice.ComponentContext")
# Get the ServiceManager object
goServiceManager = oContext.ServiceManager
return goServiceManager