311 lines
11 KiB
Python
Executable File
311 lines
11 KiB
Python
Executable File
#! /opt/openoffice4/program/python
|
|
# -*- coding: utf-8 -*-
|
|
# Office Basic macro source synchronizer.
|
|
# by imacat <imacat@mail.imacat.idv.tw>, 2016-08-31
|
|
|
|
from __future__ import print_function
|
|
import argparse
|
|
import os
|
|
import sys
|
|
import time
|
|
|
|
|
|
def append_uno_path():
|
|
""" Appends the path of the uno module to the import path. """
|
|
|
|
for p in sys.path:
|
|
if os.path.exists(os.path.join(p, "uno.py")):
|
|
return
|
|
# For uno.py on MacOS
|
|
cand = "/Applications/OpenOffice.app/Contents/MacOS"
|
|
if os.path.exists(os.path.join(cand, "uno.py")):
|
|
sys.path.append(cand)
|
|
return
|
|
# Finds uno.py for MS-Windows
|
|
cand = sys.executable
|
|
while cand != os.path.dirname(cand):
|
|
cand = os.path.dirname(cand)
|
|
if os.path.exists(os.path.join(cand, "uno.py")):
|
|
sys.path.append(cand)
|
|
return
|
|
|
|
append_uno_path()
|
|
import uno
|
|
from com.sun.star.connection import NoConnectException
|
|
|
|
|
|
def main():
|
|
""" The main program. """
|
|
t_start = time.time()
|
|
global args
|
|
|
|
# Parses the arguments
|
|
parse_args()
|
|
|
|
# Connects to the OpenOffice
|
|
oo = OpenOffice(args.port)
|
|
|
|
# Synchronize the Basic macros.
|
|
sync_macros(oo)
|
|
|
|
print("Done. %02d:%02d elapsed." %
|
|
(int((time.time() - t_start) / 60),
|
|
(time.time() - t_start) % 60), file=sys.stderr)
|
|
|
|
|
|
def parse_args():
|
|
""" Parses the arguments. """
|
|
global args
|
|
|
|
parser = argparse.ArgumentParser(
|
|
description=("Synchronize the local Basic scripts"
|
|
" with OpenOffice/LibreOffice Basic."))
|
|
parser.add_argument(
|
|
"projdir", metavar="dir", nargs="?", default=os.getcwd(),
|
|
help=("The project source directory"
|
|
" (default to the current directory)."))
|
|
parser.add_argument(
|
|
"library", metavar="Library", nargs="?",
|
|
help=("The Library to upload/download the macros"
|
|
" (default to the name of the directory)."))
|
|
parser.add_argument(
|
|
"--get", action="store_true",
|
|
help="Downloads the macros instead of upload.")
|
|
parser.add_argument(
|
|
"-p", "--port", metavar="N", type=int, default=2002,
|
|
help=("The TCP port to communicate with "
|
|
"OpenOffice/LibreOffice with (default: %(default)s)"))
|
|
parser.add_argument(
|
|
"-r", "--run", metavar="Module.Macro",
|
|
help="The macro to run after the upload, if any.")
|
|
parser.add_argument(
|
|
"-v", "--version", action="version", version="%(prog)s 0.1")
|
|
args = parser.parse_args()
|
|
|
|
# Obtains the absolute path
|
|
args.projdir = os.path.abspath(args.projdir)
|
|
# Obtains the library name from the path
|
|
if args.library is None:
|
|
args.library = os.path.basename(args.projdir)
|
|
|
|
return
|
|
|
|
|
|
def sync_macros(oo):
|
|
""" Synchronize the Basic macros. """
|
|
global args
|
|
|
|
libraries = oo.service_manager.createInstance(
|
|
"com.sun.star.script.ApplicationScriptLibraryContainer")
|
|
# Downloads the macros from OpenOffice
|
|
if args.get:
|
|
modules = read_basic_modules(libraries, args.library)
|
|
if len(modules) == 0:
|
|
print("ERROR: Library %s does not exist" % args.library,
|
|
file=sys.stderr)
|
|
return
|
|
update_source_dir(args.projdir, modules)
|
|
|
|
# Uploads the macros onto OpenOffice
|
|
else:
|
|
modules = read_in_source_dir(args.projdir)
|
|
if len(modules) == 0:
|
|
print("ERROR: Found no source macros in %s" %
|
|
args.projdir,
|
|
file=sys.stderr)
|
|
return
|
|
update_basic_modules(libraries, args.library, modules, oo)
|
|
if args.run is not None:
|
|
factory = oo.service_manager.DefaultContext.getByName(
|
|
"/singletons/com.sun.star.script.provider."
|
|
"theMasterScriptProviderFactory")
|
|
provider = factory.createScriptProvider("")
|
|
script = provider.getScript(
|
|
"vnd.sun.star.script:%s.%s"
|
|
"?language=Basic&location=application" %
|
|
(args.library, args.run))
|
|
script.invoke((), (), ())
|
|
return
|
|
|
|
|
|
def read_in_source_dir(projdir):
|
|
""" Reads-in the source macros. """
|
|
modules = {}
|
|
for entry in os.listdir(projdir):
|
|
path = os.path.join(projdir, entry)
|
|
if os.path.isfile(path) and entry.lower().endswith(".vb"):
|
|
modname = entry[0:-3]
|
|
f = open(path)
|
|
modules[modname] = f.read().decode("utf-8").replace(
|
|
"\r\n", "\n")
|
|
f.close()
|
|
return modules
|
|
|
|
|
|
def update_source_dir(projdir, modules):
|
|
""" Updates the source macros. """
|
|
curmods = {}
|
|
is_in_sync = True
|
|
for entry in os.listdir(projdir):
|
|
path = os.path.join(projdir, entry)
|
|
if os.path.isfile(path) and entry.lower().endswith(".vb"):
|
|
modname = entry[0:-3]
|
|
curmods[modname] = entry
|
|
for modname in sorted(modules.keys()):
|
|
if modname not in curmods:
|
|
path = os.path.join(projdir, modname + ".vb")
|
|
f = open(path, "w")
|
|
f.write(modules[modname])
|
|
f.close()
|
|
print("%s.vb added." % modname, file=sys.stderr)
|
|
is_in_sync = False
|
|
else:
|
|
path = os.path.join(projdir, curmods[modname])
|
|
f = open(path, "r+")
|
|
if modules[modname] != f.read().replace("\r\n", "\n"):
|
|
f.seek(0)
|
|
f.truncate(0)
|
|
f.write(modules[modname])
|
|
print("%s updated." % curmods[modname],
|
|
file=sys.stderr)
|
|
is_in_sync = False
|
|
f.close()
|
|
for modname in sorted(curmods.keys()):
|
|
if modname not in modules:
|
|
path = os.path.join(projdir, curmods[modname])
|
|
os.remove(path)
|
|
print("%s removed." % curmods[modname], file=sys.stderr)
|
|
is_in_sync = False
|
|
if is_in_sync:
|
|
print("Everything is in sync.", file=sys.stderr)
|
|
return
|
|
|
|
|
|
def read_basic_modules(libraries, libname):
|
|
""" Reads the OpenOffice Basic macros from the macros storage. """
|
|
modules = {}
|
|
if not libraries.hasByName(libname):
|
|
return modules
|
|
libraries.loadLibrary(libname)
|
|
library = libraries.getByName(libname)
|
|
for modname in library.getElementNames():
|
|
modules[modname] = library.getByName(modname).encode("utf-8")
|
|
return modules
|
|
|
|
|
|
def update_basic_modules(libraries, libname, modules, oo):
|
|
""" Updates the OpenOffice Basic macros storage. """
|
|
if not libraries.hasByName(libname):
|
|
libraries.createLibrary(libname)
|
|
print("Script library %s created." % libname, file=sys.stderr)
|
|
create_dialog_library(oo, libname)
|
|
library = libraries.getByName(libname)
|
|
for modname in sorted(modules.keys()):
|
|
library.insertByName(modname, modules[modname])
|
|
print("Module %s added." % modname, file=sys.stderr)
|
|
else:
|
|
libraries.loadLibrary(libname)
|
|
library = libraries.getByName(libname)
|
|
curmods = sorted(library.getElementNames())
|
|
for modname in sorted(modules.keys()):
|
|
if modname not in curmods:
|
|
library.insertByName(modname, modules[modname])
|
|
print("Module %s added." % modname, file=sys.stderr)
|
|
elif modules[modname] != library.getByName(modname):
|
|
library.replaceByName(modname, modules[modname])
|
|
print("Module %s updated." % modname, file=sys.stderr)
|
|
for modname in curmods:
|
|
if modname not in modules:
|
|
library.removeByName(modname)
|
|
print("Module %s removed." % modname, file=sys.stderr)
|
|
if libraries.isModified():
|
|
libraries.storeLibraries()
|
|
else:
|
|
print("Everything is in sync.", file=sys.stderr)
|
|
return
|
|
|
|
|
|
def create_dialog_library(oo, libname):
|
|
""" Creates the dialog library. """
|
|
libraries = oo.service_manager.createInstance(
|
|
"com.sun.star.script.ApplicationDialogLibraryContainer")
|
|
libraries.createLibrary(libname)
|
|
print("Dialog library %s created." % libname, file=sys.stderr)
|
|
libraries.storeLibraries()
|
|
|
|
|
|
class OpenOffice:
|
|
""" The OpenOffice connection. """
|
|
|
|
def __init__(self, port=2002):
|
|
"""Initializes the object."""
|
|
self.port = port
|
|
self.bootstrap_context = None
|
|
self.service_manager = None
|
|
self.desktop = None
|
|
self.connect()
|
|
|
|
def connect(self):
|
|
"""Connects to the running OpenOffice process."""
|
|
# Obtains the local context
|
|
local_context = uno.getComponentContext()
|
|
# Obtains the local service manager
|
|
local_service_manager = local_context.getServiceManager()
|
|
# Obtains the URL resolver
|
|
url_resolver = local_service_manager.createInstanceWithContext(
|
|
"com.sun.star.bridge.UnoUrlResolver", local_context)
|
|
# Obtains the context
|
|
url = ("uno:socket,host=localhost,port=%d;"
|
|
"urp;StarOffice.ComponentContext") % self.port
|
|
while True:
|
|
try:
|
|
self.bootstrap_context = url_resolver.resolve(url)
|
|
except NoConnectException:
|
|
self.start_oo()
|
|
else:
|
|
break
|
|
# Obtains the service manager
|
|
self.service_manager = self.bootstrap_context.getServiceManager()
|
|
# Obtains the desktop service
|
|
self.desktop = self.service_manager.createInstanceWithContext(
|
|
"com.sun.star.frame.Desktop", self.bootstrap_context)
|
|
|
|
def start_oo(self):
|
|
"""Starts the OpenOffice in server listening mode"""
|
|
# For MS-Windows, which does not have fork()
|
|
if os.name == "nt":
|
|
from subprocess import Popen
|
|
ooexec = os.path.join(
|
|
os.path.dirname(uno.__file__), "soffice.exe")
|
|
DETACHED_PROCESS = 0x00000008
|
|
Popen([ooexec,
|
|
"-accept=socket,host=localhost,port=%d;urp;" %
|
|
self.port],
|
|
close_fds=True, creationflags=DETACHED_PROCESS)
|
|
time.sleep(2)
|
|
return
|
|
|
|
# For POSIX systems, including Linux and MacOSX
|
|
try:
|
|
pid = os.fork()
|
|
except OSError:
|
|
print("Failed to fork().", file=sys.stderr)
|
|
sys.exit(1)
|
|
if pid != 0:
|
|
time.sleep(2)
|
|
return
|
|
os.setsid()
|
|
ooexec = os.path.join(
|
|
os.path.dirname(uno.__file__), "soffice")
|
|
try:
|
|
os.execl(ooexec, ooexec,
|
|
"-accept=socket,host=localhost,port=%d;urp;" %
|
|
self.port)
|
|
except OSError:
|
|
print("%s: Failed to run the OpenOffice server." % ooexec,
|
|
file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
if __name__ == "__main__":
|
|
main()
|