From 2688ba6461683908c643b2b0b0bef7bfde5560db Mon Sep 17 00:00:00 2001 From: Mauricio Baeza Date: Thu, 7 Oct 2021 14:22:30 -0500 Subject: [PATCH] First functional version --- .gitignore | 12 + VERSION | 1 + conf.py | 439 ++ easymacro.py | 7571 ++++++++++++++++++++++++++++ files/ZAZPass_v0.1.0.oxt | Bin 0 -> 62375 bytes images/logo.png | Bin 0 -> 9189 bytes source/Addons.xcu | 130 + source/META-INF/manifest.xml | 6 + source/Office/Accelerators.xcu | 49 + source/ZAZPass.py | 22 + source/description.xml | 26 + source/description/desc_en.txt | 1 + source/description/desc_es.txt | 1 + source/images/close.svg | 4 + source/images/eye-close.svg | 6 + source/images/eye-open.svg | 4 + source/images/insert.svg | 4 + source/images/new.svg | 6 + source/images/zazpass.png | Bin 0 -> 9189 bytes source/pythonpath/easymacro.py | 7571 ++++++++++++++++++++++++++++ source/pythonpath/stats.py | 331 ++ source/pythonpath/zpass.py | 348 ++ source/registration/license_en.txt | 14 + source/registration/license_es.txt | 14 + zaz.py | 823 +++ 25 files changed, 17383 insertions(+) create mode 100644 .gitignore create mode 100644 VERSION create mode 100644 conf.py create mode 100644 easymacro.py create mode 100644 files/ZAZPass_v0.1.0.oxt create mode 100644 images/logo.png create mode 100644 source/Addons.xcu create mode 100644 source/META-INF/manifest.xml create mode 100644 source/Office/Accelerators.xcu create mode 100644 source/ZAZPass.py create mode 100644 source/description.xml create mode 100644 source/description/desc_en.txt create mode 100644 source/description/desc_es.txt create mode 100755 source/images/close.svg create mode 100644 source/images/eye-close.svg create mode 100644 source/images/eye-open.svg create mode 100644 source/images/insert.svg create mode 100644 source/images/new.svg create mode 100644 source/images/zazpass.png create mode 100644 source/pythonpath/easymacro.py create mode 100644 source/pythonpath/stats.py create mode 100644 source/pythonpath/zpass.py create mode 100644 source/registration/license_en.txt create mode 100644 source/registration/license_es.txt create mode 100755 zaz.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..43d57fa --- /dev/null +++ b/.gitignore @@ -0,0 +1,12 @@ +__pycache__/ +*.py[cod] +*.po~ + +*.log + +# Virtualenv +.env/ +virtual/ + + + diff --git a/VERSION b/VERSION new file mode 100644 index 0000000..6c6aa7c --- /dev/null +++ b/VERSION @@ -0,0 +1 @@ +0.1.0 \ No newline at end of file diff --git a/conf.py b/conf.py new file mode 100644 index 0000000..1e03e95 --- /dev/null +++ b/conf.py @@ -0,0 +1,439 @@ +#!/usr/bin/env python3 + +# ~ This file is part of ZAZ. + +# ~ ZAZ is free software: you can redistribute it and/or modify +# ~ it under the terms of the GNU General Public License as published by +# ~ the Free Software Foundation, either version 3 of the License, or +# ~ (at your option) any later version. + +# ~ ZAZ is distributed in the hope that it will be useful, +# ~ but WITHOUT ANY WARRANTY; without even the implied warranty of +# ~ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# ~ GNU General Public License for more details. + +# ~ You should have received a copy of the GNU General Public License +# ~ along with ZAZ. If not, see . + + +import logging + + +# ~ Type extension: +# ~ 1 = normal extension +# ~ 2 = new component +# ~ 3 = Calc addin +TYPE_EXTENSION = 1 + +# ~ Your great extension name, not used spaces +NAME = 'ZAZPass' + +# ~ https://semver.org/ +VERSION = '0.1.0' + + +# ~ Should be unique, used URL inverse +ID = 'net.elmau.zaz.pass' + +# ~ If you extension will be multilanguage set: True +# ~ This feature used gettext, set pythonpath and easymacro in True +# ~ You can used PoEdit for edit PO files and generate MO files. +# ~ https://poedit.net/ +USE_LOCALES = True +DOMAIN = 'base' +PATH_LOCALES = 'locales' +PATH_PYGETTEXT = '/usr/lib/python3.9/Tools/i18n/pygettext.py' +# ~ You can use PoEdit for update locales too +PATH_MSGMERGE = 'msgmerge' + + +# ~ Show in extension manager +PUBLISHER = { + 'en': {'text': 'El Mau', 'link': 'https://git.cuates.net/elmau'}, + 'es': {'text': 'El Mau', 'link': 'https://git.cuates.net/elmau'}, +} + +# ~ Name in this folder for copy +ICON = 'images/logo.png' +# ~ Name inside extensions +ICON_EXT = f'{NAME.lower()}.png' + + +# ~ Change for you favorite license +LICENSE_EN = f"""This file is part of {NAME}. + + {NAME} is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + {NAME} is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with {NAME}. If not, see . +""" +LICENSE_ES = LICENSE_EN + +INFO = { + 'en': { + 'display_name': 'My first extension', + 'description': 'My great extension', + 'license': LICENSE_EN, + }, + 'es': { + 'display_name': 'Mi primer extensión', + 'description': 'Mi gran extensión', + 'license': LICENSE_ES, + }, +} + + +# ~ Menus, only for TYPE_EXTENSION = 1 +# ~ Parent can be: AddonMenu or OfficeMenuBar +# ~ For icons con name: NAME_16.bmp, used only NAME +# ~ PARENT = '' +# ~ MENU_MAIN = {} +# ~ Shortcut: Key + "Modifier Keys" +# ~ Important: Not used any shortcuts used for LibreOffice +# ~ SHIFT is mapped to Shift on all platforms. +# ~ MOD1 is mapped to Ctrl on Windows/Linux, while it is mapped to Cmd on Mac. +# ~ MOD2 is mapped to Alt on all platforms. +# ~ For example: Shift+Ctrl+Alt+T -> T_SHIFT_MOD1_MOD2 +PARENT = 'OfficeMenuBar' +MENU_MAIN = { + 'en': 'Zaz Passwords', + 'es': 'Zaz Contraseñas', +} +MENUS = ( + { + 'title': {'en': 'Insert password', 'es': 'Insertar contraseña'}, + 'argument': 'insert', + 'context': 'calc,writer', + 'icon': 'icon', + 'toolbar': True, + 'shortcut': 'P_SHIFT_MOD1_MOD2', + }, + { + 'title': {'en': 'Copy in clipboard', 'es': 'Copiar al portapapeles'}, + 'argument': 'copy', + 'context': 'calc,writer', + 'icon': 'icon', + 'toolbar': True, + 'shortcut': 'C_SHIFT_MOD1_MOD2', + }, + { + 'title': {'en': 'Generate password...', 'es': 'Generar contraseña...'}, + 'argument': 'generate', + 'context': 'calc,writer', + 'icon': 'icon', + 'toolbar': True, + 'shortcut': 'G_SHIFT_MOD1_MOD2', + }, +) + + +# ~ Functions, only for TYPE_EXTENSION = 3 +FUNCTIONS = { + 'test': { + 'displayname': {'en': 'test', 'es': 'prueba'}, + 'description': {'en': 'My test', 'es': 'Mi prueba'}, + 'parameters': { + 'value': { + 'displayname': {'en': 'value', 'es': 'valor'}, + 'description': {'en': 'The value', 'es': 'El valor'}, + }, + }, + }, +} +# ~ FUNCTIONS = {} + +EXTENSION = { + 'version': VERSION, + 'name': NAME, + 'id': ID, + 'icon': (ICON, ICON_EXT), + 'languages': tuple(INFO.keys()) +} + + +# ~ If used more libraries set python path in True and copy inside +# ~ If used easymacro pythonpath always is True, recommended +DIRS = { + 'meta': 'META-INF', + 'source': 'source', + 'description': 'description', + 'images': 'images', + 'registration': 'registration', + 'files': 'files', + 'office': 'Office', + 'locales': PATH_LOCALES, + 'pythonpath': True, +} + + +FILES = { + 'oxt': f'{NAME}_v{VERSION}.oxt', + 'py': f'{NAME}.py', + 'ext_desc': 'desc_{}.txt', + 'manifest': 'manifest.xml', + 'description': 'description.xml', + 'idl': f'X{NAME}.idl', + 'addons': 'Addons.xcu', + 'urd': f'X{NAME}.urd', + 'rdb': f'X{NAME}.rdb', + 'update': f'{NAME.lower()}.update.xml', + 'addin': 'CalcAddIn.xcu', + 'shortcut': 'Accelerators.xcu', + 'easymacro': True, +} + + +# ~ URLs for update for example +# ~ URL_XML_UPDATE = 'https://gitlab.com/USER/PROYECT/raw/BRANCH/FOLDERs/FILE_NAME' +URL_XML_UPDATE = '' +URL_OXT = '' + + +# ~ Default program for test: --calc, --writer, --draw +PROGRAM = '--calc' +# ~ Path to file for test +FILE_TEST = '' + +PATHS = { + 'idlc': '/usr/lib/libreoffice/sdk/bin/idlc', + 'include': '/usr/share/idl/libreoffice', + 'regmerge': '/usr/lib/libreoffice/program/regmerge', + 'soffice': ('soffice', PROGRAM, FILE_TEST), + 'install': ('unopkg', 'add', '-v', '-f', '-s'), + 'profile': '/home/mau/.config/libreoffice/4/user', + 'gettext': PATH_PYGETTEXT, + 'msgmerge': PATH_MSGMERGE, +} + + +SERVICES = { + 'job': "('com.sun.star.task.Job',)", + 'addin': "('com.sun.star.sheet.AddIn',)", +} + + +FORMAT = '%(asctime)s - %(levelname)s - %(message)s' +DATE = '%d/%m/%Y %H:%M:%S' +LEVEL_ERROR = logging.getLevelName(logging.ERROR) +LEVEL_INFO = logging.getLevelName(logging.INFO) +logging.addLevelName(logging.ERROR, f'\033[1;41m{LEVEL_ERROR}\033[1;0m') +logging.addLevelName(logging.INFO, f'\x1b[32m{LEVEL_INFO}\033[1;0m') +logging.basicConfig(level=logging.DEBUG, format=FORMAT, datefmt=DATE) +log = logging.getLogger(NAME) + + +def _methods(): + template = """ def {0}(self, {1}): + print({1}) + return 'ok'\n""" + functions = '' + for k, v in FUNCTIONS.items(): + args = ','.join(v['parameters'].keys()) + functions += template.format(k, args) + return functions + + +SRV = SERVICES['job'] +XSRV = 'XJobExecutor' +SRV_IMPORT = f'from com.sun.star.task import {XSRV}' +METHODS = """ def trigger(self, args='pyUNO'): + print('Hello World', args) + return\n""" + +if TYPE_EXTENSION > 1: + MENUS = () + XSRV = f'X{NAME}' + SRV_IMPORT = f'from {ID} import {XSRV}' +if TYPE_EXTENSION == 2: + SRV = f"('{ID}',)" + METHODS = """ def test(self, args='pyUNO'): + print('Hello World', args) + return\n""" +elif TYPE_EXTENSION == 3: + SRV = SERVICES['addin'] + METHODS = _methods() + + +DATA_PY = f"""import uno +import unohelper +{SRV_IMPORT} + + +ID_EXTENSION = '{ID}' +SERVICE = {SRV} + + +class {NAME}(unohelper.Base, {XSRV}): + + def __init__(self, ctx): + self.ctx = ctx + +{METHODS} + +g_ImplementationHelper = unohelper.ImplementationHelper() +g_ImplementationHelper.addImplementation({NAME}, ID_EXTENSION, SERVICE) +""" + +def _functions(): + a = '[in] any {}' + t = ' any {}({});' + f = '' + for k, v in FUNCTIONS.items(): + args = ','.join([a.format(k) for k, v in v['parameters'].items()]) + f += t.format(k, args) + return f + + +FILE_IDL = '' +if TYPE_EXTENSION > 1: + id_ext = ID.replace('.', '_') + interface = f'X{NAME}' + module = '' + for i, P in enumerate(ID.split('.')): + module += f'module {P} {{ ' + close_module = '}; ' * (i + 1) + functions = ' void test([in] any argument);' + if TYPE_EXTENSION == 3: + functions = _functions() + + FILE_IDL = f"""#ifndef __{id_ext}_idl__ +#define __{id_ext}_idl__ + +#include + +{module} + + interface {interface} : com::sun::star::uno::XInterface + {{ +{functions} + }}; + + service {P} {{ + interface {interface}; + }}; + +{close_module} +#endif +""" + + +def _parameters(args): + NODE = """ + +{displayname} + + +{description} + + """ + line = '{}{}' + node = '' + for k, v in args.items(): + displayname = '\n'.join( + [line.format(' ' * 16, k, v) for k, v in v['displayname'].items()]) + description = '\n'.join( + [line.format(' ' * 16, k, v) for k, v in v['description'].items()]) + values = { + 'name': k, + 'displayname': displayname, + 'description': description, + } + node += NODE.format(**values) + return node + + +NODE_FUNCTIONS = '' +if TYPE_EXTENSION == 3: + tmp = '{}{}' + NODE_FUNCTION = """ + +{displayname} + + +{description} + + + Add-In + + + AutoAddIn.{name} + + +{parameters} + + """ + + for k, v in FUNCTIONS.items(): + displayname = '\n'.join( + [tmp.format(' ' * 12, k, v) for k, v in v['displayname'].items()]) + description = '\n'.join( + [tmp.format(' ' * 12, k, v) for k, v in v['description'].items()]) + parameters = _parameters(v['parameters']) + values = { + 'name': k, + 'displayname': displayname, + 'description': description, + 'parameters': parameters, + } + NODE_FUNCTIONS += NODE_FUNCTION.format(**values) + + +FILE_ADDIN = f""" + + + + +{NODE_FUNCTIONS} + + + +""" + + +DATA_MANIFEST = [FILES['py'], f"Office/{FILES['shortcut']}", 'Addons.xcu'] +if TYPE_EXTENSION > 1: + DATA_MANIFEST.append(FILES['rdb']) +if TYPE_EXTENSION == 3: + DATA_MANIFEST.append('CalcAddIn.xcu') + +DATA_DESCRIPTION = { + 'identifier': {'value': ID}, + 'version': {'value': VERSION}, + 'display-name': {k: v['display_name'] for k, v in INFO.items()}, + 'icon': ICON_EXT, + 'publisher': PUBLISHER, + 'update': URL_XML_UPDATE, +} + +DATA_ADDONS = { + 'parent': PARENT, + 'images': DIRS['images'], + 'main': MENU_MAIN, + 'menus': MENUS, +} + +DATA = { + 'py': DATA_PY, + 'manifest': DATA_MANIFEST, + 'description': DATA_DESCRIPTION, + 'addons': DATA_ADDONS, + 'update': URL_OXT, + 'idl': FILE_IDL, + 'addin': FILE_ADDIN, +} + + +with open('VERSION', 'w') as f: + f.write(VERSION) + + +# ~ LICENSE_ACCEPT_BY = 'user' # or admin +# ~ LICENSE_SUPPRESS_ON_UPDATE = True diff --git a/easymacro.py b/easymacro.py new file mode 100644 index 0000000..bd060d4 --- /dev/null +++ b/easymacro.py @@ -0,0 +1,7571 @@ +#!/usr/bin/env python3 + +# == Rapid Develop Macros in LibreOffice == + +# ~ This file is part of ZAZ. + +# ~ https://git.cuates.net/elmau/zaz + +# ~ ZAZ is free software: you can redistribute it and/or modify +# ~ it under the terms of the GNU General Public License as published by +# ~ the Free Software Foundation, either version 3 of the License, or +# ~ (at your option) any later version. + +# ~ ZAZ is distributed in the hope that it will be useful, +# ~ but WITHOUT ANY WARRANTY; without even the implied warranty of +# ~ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# ~ GNU General Public License for more details. + +# ~ You should have received a copy of the GNU General Public License +# ~ along with ZAZ. If not, see . + +import base64 +import csv +import ctypes +import datetime +import getpass +import gettext +import hashlib +import io +import json +import logging +import os +import platform +import re +import shlex +import shutil +import socket +import ssl +import subprocess +import sys +import tempfile +import threading +import time +import traceback +import zipfile + +from collections import OrderedDict +from collections.abc import MutableMapping +from decimal import Decimal +from enum import IntEnum +from functools import wraps +from pathlib import Path +from pprint import pprint +from socket import timeout +from string import Template +from typing import Any, Union +from urllib.request import Request, urlopen +from urllib.error import URLError, HTTPError + +import imaplib +import smtplib +from smtplib import SMTPException, SMTPAuthenticationError +from email.mime.multipart import MIMEMultipart +from email.mime.base import MIMEBase +from email.mime.text import MIMEText +from email.utils import formatdate +from email import encoders +import mailbox + +import uno +import unohelper +from com.sun.star.awt import MessageBoxButtons as MSG_BUTTONS +from com.sun.star.awt.MessageBoxResults import YES +from com.sun.star.awt import Rectangle, Size, Point +from com.sun.star.awt.PosSize import POSSIZE, SIZE +from com.sun.star.awt import Key, KeyModifier, KeyEvent +from com.sun.star.container import NoSuchElementException +from com.sun.star.datatransfer import XTransferable, DataFlavor + +from com.sun.star.beans import PropertyValue, NamedValue +from com.sun.star.sheet import TableFilterField +from com.sun.star.table.CellContentType import EMPTY, VALUE, TEXT, FORMULA +from com.sun.star.util import Time, Date, DateTime + +from com.sun.star.text.ControlCharacter import PARAGRAPH_BREAK + +from com.sun.star.lang import Locale +from com.sun.star.lang import XEventListener +from com.sun.star.awt import XActionListener +from com.sun.star.awt import XMenuListener +from com.sun.star.awt import XMouseListener +from com.sun.star.awt import XMouseMotionListener +from com.sun.star.awt import XFocusListener +from com.sun.star.awt import XKeyListener +from com.sun.star.awt import XItemListener +from com.sun.star.awt import XTabListener +from com.sun.star.awt import XSpinListener +from com.sun.star.awt import XWindowListener +from com.sun.star.awt import XTopWindowListener +from com.sun.star.awt.grid import XGridDataListener +from com.sun.star.awt.grid import XGridSelectionListener +from com.sun.star.script import ScriptEventDescriptor + +from com.sun.star.io import IOException, XOutputStream + +# ~ https://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1awt_1_1FontUnderline.html +from com.sun.star.awt import FontUnderline +from com.sun.star.style.VerticalAlignment import TOP, MIDDLE, BOTTOM + +from com.sun.star.view.SelectionType import SINGLE, MULTI, RANGE + +from com.sun.star.sdb.CommandType import TABLE, QUERY, COMMAND + +try: + from peewee import Database, DateTimeField, DateField, TimeField, \ + __exception_wrapper__ +except ImportError as e: + Database = DateField = TimeField = DateTimeField = object + print('You need install peewee, only if you will develop with Base') + + +LOG_FORMAT = '%(asctime)s - %(levelname)s - %(message)s' +LOG_DATE = '%d/%m/%Y %H:%M:%S' +logging.addLevelName(logging.ERROR, '\033[1;41mERROR\033[1;0m') +logging.addLevelName(logging.DEBUG, '\x1b[33mDEBUG\033[1;0m') +logging.addLevelName(logging.INFO, '\x1b[32mINFO\033[1;0m') +logging.basicConfig(level=logging.DEBUG, format=LOG_FORMAT, datefmt=LOG_DATE) +log = logging.getLogger(__name__) + + +# ~ You can get custom salt +# ~ codecs.encode(os.urandom(16), 'hex') +# ~ but, not modify this file, modify in import file +SALT = b'c9548699d4e432dfd2b46adddafbb06d' + +TIMEOUT = 10 +LOG_NAME = 'ZAZ' +FILE_NAME_CONFIG = 'zaz-{}.json' + +LEFT = 0 +CENTER = 1 +RIGHT = 2 + +CALC = 'calc' +WRITER = 'writer' +DRAW = 'draw' +IMPRESS = 'impress' +BASE = 'base' +MATH = 'math' +BASIC = 'basic' +MAIN = 'main' +TYPE_DOC = { + CALC: 'com.sun.star.sheet.SpreadsheetDocument', + WRITER: 'com.sun.star.text.TextDocument', + DRAW: 'com.sun.star.drawing.DrawingDocument', + IMPRESS: 'com.sun.star.presentation.PresentationDocument', + BASE: 'com.sun.star.sdb.DocumentDataSource', + MATH: 'com.sun.star.formula.FormulaProperties', + BASIC: 'com.sun.star.script.BasicIDE', + MAIN: 'com.sun.star.frame.StartModule', +} + +OBJ_CELL = 'ScCellObj' +OBJ_RANGE = 'ScCellRangeObj' +OBJ_RANGES = 'ScCellRangesObj' +TYPE_RANGES = (OBJ_CELL, OBJ_RANGE) + +OBJ_SHAPE = 'com.sun.star.comp.sc.ScShapeObj' +OBJ_SHAPES = 'com.sun.star.drawing.SvxShapeCollection' +OBJ_GRAPHIC = 'SwXTextGraphicObject' + +OBJ_TEXTS = 'SwXTextRanges' +OBJ_TEXT = 'SwXTextRange' + +CLSID = { + 'FORMULA': '078B7ABA-54FC-457F-8551-6147e776a997', +} + +SERVICES = { + 'TEXT_EMBEDDED': 'com.sun.star.text.TextEmbeddedObject', + 'TEXT_TABLE': 'com.sun.star.text.TextTable', + 'GRAPHIC': 'com.sun.star.text.GraphicObject', +} + + +# ~ from com.sun.star.sheet.FilterOperator import EMPTY, NO_EMPTY, EQUAL, NOT_EQUAL +class FilterOperator(IntEnum): + EMPTY = 0 + NO_EMPTY = 1 + EQUAL = 2 + NOT_EQUAL = 3 + +# ~ https://api.libreoffice.org/docs/idl/ref/servicecom_1_1sun_1_1star_1_1awt_1_1UnoControlEditModel.html#a54d3ff280d892218d71e667f81ce99d4 +class Border(IntEnum): + NO_BORDER = 0 + BORDER = 1 + SIMPLE = 2 + + +# ~ https://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1sheet.html#aa5aa6dbecaeb5e18a476b0a58279c57a +class ValidationType(): + from com.sun.star.sheet.ValidationType \ + import ANY, WHOLE, DECIMAL, DATE, TIME, TEXT_LEN, LIST, CUSTOM +VT = ValidationType + + +# ~ https://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1sheet.html#aecf58149730f4c8c5c18c70f3c7c5db7 +class ValidationAlertStyle(): + from com.sun.star.sheet.ValidationAlertStyle \ + import STOP, WARNING, INFO, MACRO +VAS = ValidationAlertStyle + + +# ~ https://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1sheet_1_1ConditionOperator2.html +class ConditionOperator(): + from com.sun.star.sheet.ConditionOperator2 \ + import NONE, EQUAL, NOT_EQUAL, GREATER, GREATER_EQUAL, LESS, \ + LESS_EQUAL, BETWEEN, NOT_BETWEEN, FORMULA, DUPLICATE, NOT_DUPLICATE +CO = ConditionOperator + + +class DataPilotFieldOrientation(): + from com.sun.star.sheet.DataPilotFieldOrientation \ + import HIDDEN, COLUMN, ROW, PAGE, DATA +DPFO = DataPilotFieldOrientation + + +class CellInsertMode(): + from com.sun.star.sheet.CellInsertMode import DOWN, RIGHT, ROWS, COLUMNS +CIM = CellInsertMode + + +class CellDeleteMode(): + from com.sun.star.sheet.CellDeleteMode import UP, LEFT, ROWS, COLUMNS +CDM = CellDeleteMode + + +class FormButtonType(): + from com.sun.star.form.FormButtonType import PUSH, SUBMIT, RESET, URL +FBT = FormButtonType + + +class TextContentAnchorType(): + from com.sun.star.text.TextContentAnchorType \ + import AT_PARAGRAPH, AS_CHARACTER, AT_PAGE, AT_FRAME, AT_CHARACTER +TCAT = TextContentAnchorType + + +OS = platform.system() +IS_WIN = OS == 'Windows' +IS_MAC = OS == 'Darwin' +USER = getpass.getuser() +PC = platform.node() +DESKTOP = os.environ.get('DESKTOP_SESSION', '') +INFO_DEBUG = f"{sys.version}\n\n{platform.platform()}\n\n" + '\n'.join(sys.path) + +PYTHON = 'python' +if IS_WIN: + PYTHON = 'python.exe' + +_MACROS = {} +_start = 0 + +SECONDS_DAY = 60 * 60 * 24 +DIR = { + 'images': 'images', + 'locales': 'locales', +} + +KEY = { + 'enter': 1280, +} + +MODIFIERS = { + 'shift': KeyModifier.SHIFT, + 'ctrl': KeyModifier.MOD1, + 'alt': KeyModifier.MOD2, + 'ctrlmac': KeyModifier.MOD3, +} + +# ~ Menus +NODE_MENUBAR = 'private:resource/menubar/menubar' +MENUS = { + 'file': '.uno:PickList', + 'tools': '.uno:ToolsMenu', + 'help': '.uno:HelpMenu', + 'windows': '.uno:WindowList', + 'edit': '.uno:EditMenu', + 'view': '.uno:ViewMenu', + 'insert': '.uno:InsertMenu', + 'format': '.uno:FormatMenu', + 'styles': '.uno:FormatStylesMenu', + 'sheet': '.uno:SheetMenu', + 'data': '.uno:DataMenu', + 'table': '.uno:TableMenu', + 'form': '.uno:FormatFormMenu', + 'page': '.uno:PageMenu', + 'shape': '.uno:ShapeMenu', + 'slide': '.uno:SlideMenu', + 'show': '.uno:SlideShowMenu', +} + +DEFAULT_MIME_TYPE = 'png' +MIME_TYPE = { + 'png': 'image/png', + 'jpg': 'image/jpeg', +} + +MESSAGES = { + 'es': { + 'OK': 'Aceptar', + 'Cancel': 'Cancelar', + 'Select path': 'Seleccionar ruta', + 'Select directory': 'Seleccionar directorio', + 'Select file': 'Seleccionar archivo', + 'Incorrect user or password': 'Nombre de usuario o contraseña inválidos', + 'Allow less secure apps in GMail': 'Activa: Permitir aplicaciones menos segura en GMail', + } +} + + +CTX = uno.getComponentContext() +SM = CTX.getServiceManager() + + +def create_instance(name: str, with_context: bool=False, args: Any=None) -> Any: + if with_context: + instance = SM.createInstanceWithContext(name, CTX) + elif args: + instance = SM.createInstanceWithArguments(name, (args,)) + else: + instance = SM.createInstance(name) + return instance + + +def get_app_config(node_name: str, key: str=''): + name = 'com.sun.star.configuration.ConfigurationProvider' + service = 'com.sun.star.configuration.ConfigurationAccess' + cp = create_instance(name, True) + node = PropertyValue(Name='nodepath', Value=node_name) + try: + ca = cp.createInstanceWithArguments(service, (node,)) + if ca and not key: + return ca + if ca and ca.hasByName(key): + return ca.getPropertyValue(key) + except Exception as e: + error(e) + return '' + + +LANGUAGE = get_app_config('org.openoffice.Setup/L10N/', 'ooLocale') +LANG = LANGUAGE.split('-')[0] +try: + COUNTRY = LANGUAGE.split('-')[1] +except: + COUNTRY = '' +LOCALE = Locale(LANG, COUNTRY, '') +NAME = TITLE = get_app_config('org.openoffice.Setup/Product', 'ooName') +VERSION = get_app_config('org.openoffice.Setup/Product','ooSetupVersion') + +INFO_DEBUG = f"{NAME} v{VERSION} {LANGUAGE}\n\n{INFO_DEBUG}" + +node = '/org.openoffice.Office.Calc/Calculate/Other/Date' +y = get_app_config(node, 'YY') +m = get_app_config(node, 'MM') +d = get_app_config(node, 'DD') +DATE_OFFSET = datetime.date(y, m, d).toordinal() + + +def error(info): + log.error(info) + return + + +def debug(*args): + data = [str(a) for a in args] + log.debug('\t'.join(data)) + return + + +def info(*args): + data = [str(a) for a in args] + log.info('\t'.join(data)) + return + + +def save_log(path: str, data): + with open(path, 'a') as f: + f.write(f'{str(now())[:19]} -{LOG_NAME}- ') + pprint(data, stream=f) + return + + +def catch_exception(f): + @wraps(f) + def func(*args, **kwargs): + try: + return f(*args, **kwargs) + except Exception as e: + name = f.__name__ + if IS_WIN: + msgbox(traceback.format_exc()) + log.error(name, exc_info=True) + return func + + +def inspect(obj: Any) -> None: + zaz = create_instance('net.elmau.zaz.inspect') + if hasattr(obj, 'obj'): + obj = obj.obj + zaz.inspect(obj) + return + + +def mri(obj: Any) -> None: + m = create_instance('mytools.Mri') + if m is None: + msg = 'Extension MRI not found' + error(msg) + return + + if hasattr(obj, 'obj'): + obj = obj.obj + m.inspect(obj) + return + + +def run_in_thread(fn): + def run(*k, **kw): + t = threading.Thread(target=fn, args=k, kwargs=kw) + t.start() + return t + return run + + +def now(only_time: bool=False): + now = datetime.datetime.now() + if only_time: + now = now.time() + return now + + +def today(): + return datetime.date.today() + + +def _(msg): + if LANG == 'en': + return msg + + if not LANG in MESSAGES: + return msg + + return MESSAGES[LANG][msg] + + +def msgbox(message, title=TITLE, buttons=MSG_BUTTONS.BUTTONS_OK, type_msg='infobox'): + """ Create message box + type_msg: infobox, warningbox, errorbox, querybox, messbox + http://api.libreoffice.org/docs/idl/ref/interfacecom_1_1sun_1_1star_1_1awt_1_1XMessageBoxFactory.html + """ + toolkit = create_instance('com.sun.star.awt.Toolkit') + parent = toolkit.getDesktopWindow() + box = toolkit.createMessageBox(parent, type_msg, buttons, title, str(message)) + return box.execute() + + +def question(message, title=TITLE): + result = msgbox(message, title, MSG_BUTTONS.BUTTONS_YES_NO, 'querybox') + return result == YES + + +def warning(message, title=TITLE): + return msgbox(message, title, type_msg='warningbox') + + +def errorbox(message, title=TITLE): + return msgbox(message, title, type_msg='errorbox') + + +def get_type_doc(obj: Any) -> str: + for k, v in TYPE_DOC.items(): + if obj.supportsService(v): + return k + return '' + + +def _get_class_doc(obj: Any) -> Any: + classes = { + CALC: LOCalc, + WRITER: LOWriter, + DRAW: LODraw, + IMPRESS: LOImpress, + BASE: LOBase, + MATH: LOMath, + BASIC: LOBasic, + } + type_doc = get_type_doc(obj) + return classes[type_doc](obj) + + +def dict_to_property(values: dict, uno_any: bool=False): + ps = tuple([PropertyValue(Name=n, Value=v) for n, v in values.items()]) + if uno_any: + ps = uno.Any('[]com.sun.star.beans.PropertyValue', ps) + return ps + + +def _array_to_dict(values): + d = {v[0]: v[1] for v in values} + return d + + +def _property_to_dict(values): + d = {v.Name: v.Value for v in values} + return d + + +def json_dumps(data): + return json.dumps(data, indent=4, sort_keys=True) + + +def json_loads(data): + return json.loads(data) + + +def data_to_dict(data): + if isinstance(data, (tuple, list)) and isinstance(data[0], (tuple, list)): + return _array_to_dict(data) + + if isinstance(data, (tuple, list)) and isinstance(data[0], (PropertyValue, NamedValue)): + return _property_to_dict(data) + return {} + + +def _get_dispatch() -> Any: + return create_instance('com.sun.star.frame.DispatchHelper') + + +# ~ https://wiki.documentfoundation.org/Development/DispatchCommands +# ~ Used only if not exists in API +def call_dispatch(frame: Any, url: str, args: dict={}) -> None: + dispatch = _get_dispatch() + if hasattr(frame, 'frame'): + frame = frame.frame + opt = dict_to_property(args) + dispatch.executeDispatch(frame, url, '', 0, opt) + return + + +def get_desktop(): + return create_instance('com.sun.star.frame.Desktop', True) + + +def _date_to_struct(value): + if isinstance(value, datetime.datetime): + d = DateTime() + d.Year = value.year + d.Month = value.month + d.Day = value.day + d.Hours = value.hour + d.Minutes = value.minute + d.Seconds = value.second + elif isinstance(value, datetime.date): + d = Date() + d.Day = value.day + d.Month = value.month + d.Year = value.year + elif isinstance(value, datetime.time): + d = Time() + d.Hours = value.hour + d.Minutes = value.minute + d.Seconds = value.second + return d + + +def _struct_to_date(value): + d = None + if isinstance(value, Time): + d = datetime.time(value.Hours, value.Minutes, value.Seconds) + elif isinstance(value, Date): + if value != Date(): + d = datetime.date(value.Year, value.Month, value.Day) + elif isinstance(value, DateTime): + if value.Year > 0: + d = datetime.datetime( + value.Year, value.Month, value.Day, + value.Hours, value.Minutes, value.Seconds) + return d + + +def _get_url_script(args: dict): + library = args['library'] + name = args['name'] + language = args.get('language', 'Python') + location = args.get('location', 'user') + module = args.get('module', '.') + + if language == 'Python': + module = '.py$' + elif language == 'Basic': + module = f".{module}." + if location == 'user': + location = 'application' + + url = 'vnd.sun.star.script' + url = f'{url}:{library}{module}{name}?language={language}&location={location}' + return url + + +def _call_macro(args: dict): + #~ https://wiki.openoffice.org/wiki/Documentation/DevGuide/Scripting/Scripting_Framework_URI_Specification + + url = _get_url_script(args) + args = args.get('args', ()) + + service = 'com.sun.star.script.provider.MasterScriptProviderFactory' + factory = create_instance(service) + script = factory.createScriptProvider('').getScript(url) + result = script.invoke(args, None, None)[0] + + return result + + +def call_macro(args, in_thread=False): + result = None + if in_thread: + t = threading.Thread(target=_call_macro, args=(args,)) + t.start() + else: + result = _call_macro(args) + return result + + +def run(command, capture=False, split=False): + if split: + cmd = shlex.split(command) + result = subprocess.run(cmd, capture_output=capture, text=True, shell=IS_WIN) + if capture: + result = result.stdout + else: + result = result.returncode + else: + if capture: + result = subprocess.check_output(command, shell=True).decode() + else: + result = subprocess.Popen(command) + return result + + +def popen(command): + try: + proc = subprocess.Popen(shlex.split(command), shell=IS_WIN, + stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + for line in proc.stdout: + yield line.decode().rstrip() + except Exception as e: + error(e) + yield (e.errno, e.strerror) + + +def sleep(seconds): + time.sleep(seconds) + return + + +class TimerThread(threading.Thread): + + def __init__(self, event, seconds, macro): + threading.Thread.__init__(self) + self.stopped = event + self.seconds = seconds + self.macro = macro + + def run(self): + info('Timer started... {}'.format(self.macro['name'])) + while not self.stopped.wait(self.seconds): + _call_macro(self.macro) + info('Timer stopped... {}'.format(self.macro['name'])) + return + + +def start_timer(name, seconds, macro): + global _MACROS + _MACROS[name] = threading.Event() + thread = TimerThread(_MACROS[name], seconds, macro) + thread.start() + return + + +def stop_timer(name): + global _MACROS + _MACROS[name].set() + del _MACROS[name] + return + + +def install_locales(path: str, domain: str='base', dir_locales=DIR['locales']): + path_locales = _P.join(_P(path).path, dir_locales) + try: + lang = gettext.translation(domain, path_locales, languages=[LANG]) + lang.install() + _ = lang.gettext + except Exception as e: + from gettext import gettext as _ + error(e) + return _ + + +def _export_image(obj, args): + name = 'com.sun.star.drawing.GraphicExportFilter' + exporter = create_instance(name) + path = _P.to_system(args['URL']) + args = dict_to_property(args) + exporter.setSourceDocument(obj) + exporter.filter(args) + return _P.exists(path) + + +def sha256(data): + result = hashlib.sha256(data.encode()).hexdigest() + return result + + +def sha512(data): + result = hashlib.sha512(data.encode()).hexdigest() + return result + + +def get_config(key='', prefix='conf', default={}): + name_file = FILE_NAME_CONFIG.format(prefix) + values = {} + path = _P.join(_P.user_config, name_file) + if not _P.exists(path): + return default + + values = _P.from_json(path) + if key: + values = values.get(key, default) + + return values + + +def set_config(key, value, prefix='conf'): + name_file = FILE_NAME_CONFIG.format(prefix) + path = _P.join(_P.user_config, name_file) + values = get_config(prefix=prefix, default={}) + values[key] = value + result = _P.to_json(path, values) + return result + + +def start(): + global _start + + _start = now() + info(_start) + return + + +def end(get_seconds: bool=False): + global _start + + e = now() + td = e - _start + result = str(td) + if get_seconds: + result = td.total_seconds() + return result + + +def get_epoch(): + n = now() + return int(time.mktime(n.timetuple())) + + +def render(template, data): + s = Template(template) + return s.safe_substitute(**data) + + +def get_size_screen(): + res = '' + if IS_WIN: + user32 = ctypes.windll.user32 + res = f'{user32.GetSystemMetrics(0)}x{user32.GetSystemMetrics(1)}' + else: + try: + args = 'xrandr | grep "*" | cut -d " " -f4' + res = run(args, split=False) + except Exception as e: + error(e) + return res.strip() + + +def url_open(url, data=None, headers={}, verify=True, get_json=False, timeout=TIMEOUT): + err = '' + req = Request(url) + for k, v in headers.items(): + req.add_header(k, v) + try: + # ~ debug(url) + if verify: + if not data is None and isinstance(data, str): + data = data.encode() + response = urlopen(req, data=data, timeout=timeout) + else: + context = ssl._create_unverified_context() + response = urlopen(req, data=data, timeout=timeout, context=context) + except HTTPError as e: + error(e) + err = str(e) + except URLError as e: + error(e.reason) + err = str(e.reason) + except timeout: + err = 'timeout' + error(err) + else: + headers = dict(response.info()) + result = response.read().decode() + if get_json: + result = json.loads(result) + + return result, headers, err + + +def _get_key(password): + from cryptography.hazmat.primitives import hashes + from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC + + kdf = PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=SALT, + iterations=100000) + key = base64.urlsafe_b64encode(kdf.derive(password.encode())) + return key + + +def encrypt(data, password): + from cryptography.fernet import Fernet + + f = Fernet(_get_key(password)) + if isinstance(data, str): + data = data.encode() + token = f.encrypt(data).decode() + return token + + +def decrypt(token, password): + from cryptography.fernet import Fernet, InvalidToken + + data = '' + f = Fernet(_get_key(password)) + try: + data = f.decrypt(token.encode()).decode() + except InvalidToken as e: + error('Invalid Token') + return data + + +def switch_design_mode(doc): + call_dispatch(doc.frame, '.uno:SwitchControlDesignMode') + return + + +class SmtpServer(object): + + def __init__(self, config): + self._server = None + self._error = '' + self._sender = '' + self._is_connect = self._login(config) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + self.close() + + @property + def is_connect(self): + return self._is_connect + + @property + def error(self): + return self._error + + def _login(self, config): + name = config['server'] + port = config['port'] + is_ssl = config['ssl'] + self._sender = config['user'] + hosts = ('gmail' in name or 'outlook' in name) + try: + if is_ssl and hosts: + self._server = smtplib.SMTP(name, port, timeout=TIMEOUT) + self._server.ehlo() + self._server.starttls() + self._server.ehlo() + elif is_ssl: + self._server = smtplib.SMTP_SSL(name, port, timeout=TIMEOUT) + self._server.ehlo() + else: + self._server = smtplib.SMTP(name, port, timeout=TIMEOUT) + + self._server.login(self._sender, config['password']) + msg = 'Connect to: {}'.format(name) + debug(msg) + return True + except smtplib.SMTPAuthenticationError as e: + if '535' in str(e): + self._error = _('Incorrect user or password') + return False + if '534' in str(e) and 'gmail' in name: + self._error = _('Allow less secure apps in GMail') + return False + except smtplib.SMTPException as e: + self._error = str(e) + return False + except Exception as e: + self._error = str(e) + return False + return False + + def _body(self, msg): + body = msg.replace('\n', '
') + return body + + def send(self, message): + # ~ file_name = 'attachment; filename={}' + email = MIMEMultipart() + email['From'] = self._sender + email['To'] = message['to'] + email['Cc'] = message.get('cc', '') + email['Subject'] = message['subject'] + email['Date'] = formatdate(localtime=True) + if message.get('confirm', False): + email['Disposition-Notification-To'] = email['From'] + email.attach(MIMEText(self._body(message['body']), 'html')) + + paths = message.get('files', ()) + if isinstance(paths, str): + paths = (paths,) + for path in paths: + fn = _P(path).file_name + print('NAME', fn) + part = MIMEBase('application', 'octet-stream') + part.set_payload(_P.read_bin(path)) + encoders.encode_base64(part) + part.add_header('Content-Disposition', f'attachment; filename="{fn}"') + email.attach(part) + + receivers = ( + email['To'].split(',') + + email['CC'].split(',') + + message.get('bcc', '').split(',')) + try: + self._server.sendmail(self._sender, receivers, email.as_string()) + msg = 'Email sent...' + debug(msg) + if message.get('path', ''): + self.save_message(email, message['path']) + return True + except Exception as e: + self._error = str(e) + return False + return False + + def save_message(self, email, path): + mbox = mailbox.mbox(path, create=True) + mbox.lock() + try: + msg = mailbox.mboxMessage(email) + mbox.add(msg) + mbox.flush() + finally: + mbox.unlock() + return + + def close(self): + try: + self._server.quit() + msg = 'Close connection...' + debug(msg) + except: + pass + return + + +def _send_email(server, messages): + with SmtpServer(server) as server: + if server.is_connect: + for msg in messages: + server.send(msg) + else: + error(server.error) + return server.error + + +def send_email(server, message): + messages = message + if isinstance(message, dict): + messages = (message,) + t = threading.Thread(target=_send_email, args=(server, messages)) + t.start() + return + + +class ImapServer(object): + + def __init__(self, config): + self._server = None + self._error = '' + self._is_connect = self._login(config) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + self.close() + + @property + def is_connect(self): + return self._is_connect + + @property + def error(self): + return self._error + + def _login(self, config): + try: + # ~ hosts = 'gmail' in config['server'] + if config['ssl']: + self._server = imaplib.IMAP4_SSL(config['server'], config['port']) + else: + self._server = imaplib.IMAP4(config['server'], config['port']) + self._server.login(config['user'], config['password']) + self._server.select() + return True + except imaplib.IMAP4.error as e: + self._error = str(e) + return False + except Exception as e: + self._error = str(e) + return False + return False + + def get_folders(self, exclude=()): + folders = {} + result, subdir = self._server.list() + for s in subdir: + print(s.decode('utf-8')) + return folders + + def close(self): + try: + self._server.close() + self._server.logout() + msg = 'Close connection...' + debug(msg) + except: + pass + return + + +# ~ Classes + +class LOBaseObject(object): + + def __init__(self, obj): + self._obj = obj + + def __setattr__(self, name, value): + exists = hasattr(self, name) + if not exists and not name in ('_obj', '_index', '_view'): + setattr(self._obj, name, value) + else: + super().__setattr__(name, value) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + @property + def obj(self): + return self._obj + + +class LODocument(object): + + def __init__(self, obj): + self._obj = obj + self._cc = self.obj.getCurrentController() + self._undo = True + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + self.close() + + @property + def obj(self): + return self._obj + + @property + def title(self): + return self.obj.getTitle() + @title.setter + def title(self, value): + self.obj.setTitle(value) + + @property + def type(self): + return self._type + + @property + def uid(self): + return self.obj.RuntimeUID + + @property + def frame(self): + return self._cc.getFrame() + + @property + def is_saved(self): + return self.obj.hasLocation() + + @property + def is_modified(self): + return self.obj.isModified() + + @property + def is_read_only(self): + return self.obj.isReadonly() + + @property + def path(self): + return _P.to_system(self.obj.URL) + + @property + def dir(self): + return _P(self.path).path + + @property + def file_name(self): + return _P(self.path).file_name + + @property + def name(self): + return _P(self.path).name + + @property + def visible(self): + w = self.frame.ContainerWindow + return w.isVisible() + @visible.setter + def visible(self, value): + w = self.frame.ContainerWindow + w.setVisible(value) + + @property + def zoom(self): + return self._cc.ZoomValue + @zoom.setter + def zoom(self, value): + self._cc.ZoomValue = value + + @property + def undo(self): + return self._undo + @undo.setter + def undo(self, value): + self._undo = value + um = self.obj.UndoManager + if value: + try: + um.leaveUndoContext() + except: + pass + else: + um.enterHiddenUndoContext() + + def clear_undo(self): + self.obj.getUndoManager().clear() + return + + @property + def selection(self): + sel = self.obj.CurrentSelection + return sel + + @property + def table_auto_formats(self): + taf = create_instance('com.sun.star.sheet.TableAutoFormats') + return taf.ElementNames + + @property + def status_bar(self): + bar = self._cc.getStatusIndicator() + return bar + + def create_instance(self, name): + obj = self.obj.createInstance(name) + return obj + + def set_focus(self): + w = self.frame.ComponentWindow + w.setFocus() + return + + def copy(self): + call_dispatch(self.frame, '.uno:Copy') + return + + def insert_contents(self, args={}): + call_dispatch(self.frame, '.uno:InsertContents', args) + return + + def paste(self): + sc = create_instance('com.sun.star.datatransfer.clipboard.SystemClipboard') + transferable = sc.getContents() + self._cc.insertTransferable(transferable) + # ~ return self.obj.getCurrentSelection() + return + + # ~ def select(self, obj): + # ~ self._cc.select(obj) + # ~ return + + def to_pdf(self, path: str='', options: dict={}): + """ + https://wiki.documentfoundation.org/Macros/Python_Guide/PDF_export_filter_data + """ + args = options.copy() + stream = None + path_pdf = 'private:stream' + if path: + path_pdf = _P.to_url(path) + + filter_name = '{}_pdf_Export'.format(self.type) + filter_data = dict_to_property(args, True) + args = { + 'FilterName': filter_name, + 'FilterData': filter_data, + } + if not path: + stream = IOStream.output() + args['OutputStream'] = stream + + opt = dict_to_property(args) + try: + self.obj.storeToURL(path_pdf, opt) + except Exception as e: + error(e) + + if not stream is None: + stream = stream.buffer + + return stream + + def export(self, path: str='', filter_name: str='', options: dict={}): + FILTERS = { + 'xlsx': 'Calc MS Excel 2007 XML', + 'xls': 'MS Excel 97', + 'docx': 'MS Word 2007 XML', + 'doc': 'MS Word 97', + 'rtf': 'Rich Text Format', + } + args = options.copy() + stream = None + path_target = 'private:stream' + if path: + path_target = _P.to_url(path) + + filter_name = FILTERS.get(filter_name, filter_name) + filter_data = dict_to_property(args, True) + args = { + 'FilterName': filter_name, + 'FilterData': filter_data, + } + if not path: + stream = IOStream.output() + args['OutputStream'] = stream + + opt = dict_to_property(args) + try: + self.obj.storeToURL(path_target, opt) + except Exception as e: + error(e) + + if not stream is None: + stream = stream.buffer + + return stream + + def save(self, path: str='', options: dict={}): + if not path: + self.obj.store() + return + + args = options.copy() + path_target = _P.to_url(path) + + opt = dict_to_property(args) + try: + self.obj.storeAsURL(path_target, opt) + except Exception as e: + error(e) + + return + + def close(self): + self.obj.close(True) + return + + +class LOCellStyle(LOBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def name(self): + return self.obj.Name + + @property + def properties(self): + properties = self.obj.PropertySetInfo.Properties + data = {p.Name: getattr(self.obj, p.Name) for p in properties} + return data + @properties.setter + def properties(self, values): + _set_properties(self.obj, values) + + +class LOCellStyles(object): + + def __init__(self, obj, doc): + self._obj = obj + self._doc = doc + + def __len__(self): + return len(self.obj) + + def __getitem__(self, index): + return LOCellStyle(self.obj[index]) + + def __setitem__(self, key, value): + self.obj[key] = value + + def __delitem__(self, key): + if not isinstance(key, str): + key = key.Name + del self.obj[key] + + def __contains__(self, item): + return item in self.obj + + @property + def obj(self): + return self._obj + + @property + def names(self): + return self.obj.ElementNames + + def new(self, name: str=''): + obj = self._doc.create_instance('com.sun.star.style.CellStyle') + if name: + self.obj[name] = obj + obj = LOCellStyle(obj) + return obj + + +class LOCalc(LODocument): + + def __init__(self, obj): + super().__init__(obj) + self._type = CALC + self._sheets = obj.Sheets + + def __getitem__(self, index): + return LOCalcSheet(self._sheets[index]) + + def __setitem__(self, key, value): + self._sheets[key] = value + + def __len__(self): + return self._sheets.Count + + def __contains__(self, item): + return item in self._sheets + + @property + def names(self): + names = self.obj.Sheets.ElementNames + return names + + @property + def selection(self): + sel = self.obj.CurrentSelection + if sel.ImplementationName in TYPE_RANGES: + sel = LOCalcRange(sel) + elif sel.ImplementationName in OBJ_RANGES: + sel = LOCalcRanges(sel) + elif sel.ImplementationName == OBJ_SHAPES: + if len(sel) == 1: + sel = LOShape(sel[0]) + else: + debug(sel.ImplementationName) + return sel + + @property + def active(self): + return LOCalcSheet(self._cc.ActiveSheet) + + @property + def headers(self): + return self._cc.ColumnRowHeaders + @headers.setter + def headers(self, value): + self._cc.ColumnRowHeaders = value + + @property + def tabs(self): + return self._cc.SheetTabs + @tabs.setter + def tabs(self, value): + self._cc.SheetTabs = value + + @property + def cs(self): + return self.cell_styles + @property + def cell_styles(self): + obj = self.obj.StyleFamilies['CellStyles'] + return LOCellStyles(obj, self) + + @property + def db_ranges(self): + # ~ return LOCalcDataBaseRanges(self.obj.DataBaseRanges) + return self.obj.DatabaseRanges + + @property + def ranges(self): + obj = self.create_instance('com.sun.star.sheet.SheetCellRanges') + return LOCalcRanges(obj) + + def get_ranges(self, address: str): + ranges = self.ranges + ranges.add([sheet[address] for sheet in self]) + return ranges + + def activate(self, sheet): + obj = sheet + if isinstance(sheet, LOCalcSheet): + obj = sheet.obj + elif isinstance(sheet, str): + obj = self._sheets[sheet] + self._cc.setActiveSheet(obj) + return + + def new_sheet(self): + s = self.create_instance('com.sun.star.sheet.Spreadsheet') + return s + + def insert(self, name): + names = name + if isinstance(name, str): + names = (name,) + for n in names: + self._sheets[n] = self.new_sheet() + return LOCalcSheet(self._sheets[n]) + + def move(self, name, pos=-1): + index = pos + if pos < 0: + index = len(self) + if isinstance(name, LOCalcSheet): + name = name.name + self._sheets.moveByName(name, index) + return + + def remove(self, name): + if isinstance(name, LOCalcSheet): + name = name.name + self._sheets.removeByName(name) + return + + def copy_sheet(self, name, new_name='', pos=-1): + if isinstance(name, LOCalcSheet): + name = name.name + index = pos + if pos < 0: + index = len(self) + self._sheets.copyByName(name, new_name, index) + return LOCalcSheet(self._sheets[new_name]) + + def copy_from(self, doc, source='', target='', pos=-1): + index = pos + if pos < 0: + index = len(self) + + names = source + if not source: + names = doc.names + elif isinstance(source, str): + names = (source,) + + new_names = target + if not target: + new_names = names + elif isinstance(target, str): + new_names = (target,) + + for i, name in enumerate(names): + self._sheets.importSheet(doc.obj, name, index + i) + self[index + i].name = new_names[i] + + return LOCalcSheet(self._sheets[index]) + + def sort(self, reverse=False): + names = sorted(self.names, reverse=reverse) + for i, n in enumerate(names): + self.move(n, i) + return + + def render(self, data, sheet=None, clean=True): + if sheet is None: + sheet = self.active + return sheet.render(data, clean=clean) + + def select(self, rango): + self._cc.select(rango.obj) + return + + +class LOChart(object): + + def __init__(self, name, obj, draw_page): + self._name = name + self._obj = obj + self._eobj = self._obj.EmbeddedObject + self._type = 'Column' + self._cell = None + self._shape = self._get_shape(draw_page) + self._pos = self._shape.Position + + def __getitem__(self, index): + return LOBaseObject(self.diagram.getDataRowProperties(index)) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + @property + def obj(self): + return self._obj + + @property + def name(self): + return self._name + + @property + def diagram(self): + return self._eobj.Diagram + + @property + def type(self): + return self._type + @type.setter + def type(self, value): + self._type = value + if value == 'Bar': + self.diagram.Vertical = True + return + type_chart = f'com.sun.star.chart.{value}Diagram' + self._eobj.setDiagram(self._eobj.createInstance(type_chart)) + + @property + def cell(self): + return self._cell + @cell.setter + def cell(self, value): + self._cell = value + self._shape.Anchor = value.obj + + @property + def position(self): + return self._pos + @position.setter + def position(self, value): + self._pos = value + self._shape.Position = value + + def _get_shape(self, draw_page): + for shape in draw_page: + if shape.PersistName == self.name: + break + return shape + + +class LOSheetCharts(object): + + def __init__(self, obj, sheet): + self._obj = obj + self._sheet = sheet + + def __getitem__(self, index): + return LOChart(index, self.obj[index], self._sheet.draw_page) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + def __contains__(self, item): + return item in self.obj + + def __len__(self): + return len(self.obj) + + @property + def obj(self): + return self._obj + + def new(self, name, pos_size, data): + self.obj.addNewByName(name, pos_size, data, True, True) + return LOChart(name, self.obj[name], self._sheet.draw_page) + + +class LOSheetTableField(object): + + def __init__(self, obj): + self._obj = obj + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + @property + def obj(self): + return self._obj + + @property + def name(self): + return self.obj.Name + + @property + def orientation(self): + return self.obj.Orientation + @orientation.setter + def orientation(self, value): + self.obj.Orientation = value + + +# ~ com.sun.star.sheet.DataPilotFieldOrientation.ROW +class LOSheetTable(object): + + def __init__(self, obj): + self._obj = obj + self._source = None + + def __getitem__(self, index): + field = self.obj.DataPilotFields[index] + return LOSheetTableField(field) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + @property + def obj(self): + return self._obj + + @property + def filter(self): + return self.obj.ShowFilterButton + @filter.setter + def filter(self, value): + self.obj.ShowFilterButton = value + + @property + def source(self): + return self._source + @source.setter + def source(self, value): + self._source = value + self.obj.SourceRange = value.range_address + + @property + def rows(self): + return self.obj.RowFields + @rows.setter + def rows(self, values): + if not isinstance(values, tuple): + values = (values,) + for v in values: + with self[v] as f: + f.orientation = DPFO.ROW + @property + def columns(self): + return self.obj.ColumnFields + @columns.setter + def columns(self, values): + if not isinstance(values, tuple): + values = (values,) + for v in values: + with self[v] as f: + f.orientation = DPFO.COLUMN + + @property + def data(self): + return self.obj.DataFields + @data.setter + def data(self, values): + if not isinstance(values, tuple): + values = (values,) + for v in values: + with self[v] as f: + f.orientation = DPFO.DATA + + +class LOSheetTables(object): + + def __init__(self, obj, sheet): + self._obj = obj + self._sheet = sheet + + def __getitem__(self, index): + return LOSheetTable(self.obj[index]) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + def __contains__(self, item): + return item in self.obj + + @property + def obj(self): + return self._obj + + @property + def count(self): + return self.obj.Count + + @property + def names(self): + return self.obj.ElementNames + + def new(self, name, target): + table = self.obj.createDataPilotDescriptor() + self.obj.insertNewByName(name, target.address, table) + return LOSheetTable(self.obj[name]) + + def remove(self, name): + self.obj.removeByName(name) + return + + +# ~ class LOFormControl(LOBaseObject): +class LOFormControl(): + EVENTS = { + 'action': 'actionPerformed', + 'click': 'mousePressed', + } + TYPES = { + 'actionPerformed': 'XActionListener', + 'mousePressed': 'XMouseListener', + } + + def __init__(self, obj, view, form): + self._obj = obj + self._view = view + self._form = form + self._m = view.Model + self._index = -1 + + # ~ def __setattr__(self, name, value): + # ~ if name in ('_form', '_view', '_m', '_index'): + # ~ self.__dict__[name] = value + # ~ else: + # ~ super().__setattr__(name, value) + + def __str__(self): + return f'{self.name} ({self.type}) {[self.index]}' + + @property + def obj(self): + return self._obj + + @property + def form(self): + return self._form + + @property + def doc(self): + return self.obj.Parent.Forms.Parent + + @property + def name(self): + return self._m.Name + @name.setter + def name(self, value): + self._m.Name = value + + @property + def tag(self): + return self._m.Tag + @tag.setter + def tag(self, value): + self._m.Tag = value + + @property + def index(self): + return self._index + @index.setter + def index(self, value): + self._index = value + + @property + def enabled(self): + return self._m.Enabled + @enabled.setter + def enabled(self, value): + self._m.Enabled = value + + @property + def anchor(self): + return self.obj.Anchor + @anchor.setter + def anchor(self, value): + size = None + if hasattr(value, 'obj'): + size = getattr(value, 'size', None) + value = value.obj + self.obj.Anchor = value + if not size is None: + self.size = size + try: + self.obj.ResizeWithCell = True + except: + pass + + @property + def size(self): + return self.obj.Size + @size.setter + def size(self, value): + self.obj.Size = value + + @property + def events(self): + return self.form.getScriptEvents(self.index) + def add_event(self, name, macro): + if not 'name' in macro: + macro['name'] = '{}_{}'.format(self.name, name) + + event = ScriptEventDescriptor() + event.AddListenerParam = '' + event.EventMethod = self.EVENTS[name] + event.ListenerType = self.TYPES[event.EventMethod] + event.ScriptCode = _get_url_script(macro) + event.ScriptType = 'Script' + + for ev in self.events: + if ev.EventMethod == event.EventMethod and \ + ev.ListenerType == event.ListenerType: + self.form.revokeScriptEvent(self.index, + event.ListenerType, event.EventMethod, event.AddListenerParam) + break + + self.form.registerScriptEvent(self.index, event) + return + + def set_focus(self): + self._view.setFocus() + return + + +class LOFormControlLabel(LOFormControl): + + def __init__(self, obj, view, form): + super().__init__(obj, view, form) + + @property + def type(self): + return 'label' + + @property + def value(self): + return self._m.Label + @value.setter + def value(self, value): + self._m.Label = value + + +class LOFormControlText(LOFormControl): + + def __init__(self, obj, view, form): + super().__init__(obj, view, form) + + @property + def type(self): + return 'text' + + @property + def value(self): + return self._m.Text + @value.setter + def value(self, value): + self._m.Text = value + + +class LOFormControlButton(LOFormControl): + + def __init__(self, obj, view, form): + super().__init__(obj, view, form) + + @property + def type(self): + return 'button' + + @property + def value(self): + return self._m.Label + @value.setter + def value(self, value): + self._m.Text = Label + + @property + def url(self): + return self._m.TargetURL + @url.setter + def url(self, value): + self._m.TargetURL = value + self._m.ButtonType = FormButtonType.URL + + +FORM_CONTROL_CLASS = { + 'label': LOFormControlLabel, + 'text': LOFormControlText, + 'button': LOFormControlButton, +} + + +class LOForm(object): + MODELS = { + 'label': 'com.sun.star.form.component.FixedText', + 'text': 'com.sun.star.form.component.TextField', + 'button': 'com.sun.star.form.component.CommandButton', + } + + def __init__(self, obj, draw_page): + self._obj = obj + self._dp = draw_page + self._controls = {} + self._init_controls() + + def __getitem__(self, index): + control = self.obj[index] + return self._controls[control.Name] + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + def __contains__(self, item): + return item in self.obj + + def __len__(self): + return len(self.obj) + + def __str__(self): + return f'Form: {self.name}' + + def _init_controls(self): + types = { + 'com.sun.star.form.OFixedTextModel': 'label', + 'com.sun.star.form.OEditModel': 'text', + 'com.sun.star.form.OButtonModel': 'button', + } + for i, control in enumerate(self.obj): + name = control.Name + tipo = types[control.ImplementationName] + view = self.doc.CurrentController.getControl(control) + control = FORM_CONTROL_CLASS[tipo](control, view, self._obj) + control.index = i + setattr(self, name, control) + self._controls[name] = control + return + + @property + def obj(self): + return self._obj + + @property + def name(self): + return self.obj.Name + @name.setter + def name(self, value): + self.obj.Name = value + + @property + def source(self): + return self.obj.DataSourceName + @source.setter + def source(self, value): + self.obj.DataSourceName = value + + @property + def type(self): + return self.obj.CommandType + @type.setter + def type(self, value): + self.obj.CommandType = value + + @property + def command(self): + return self.obj.Command + @command.setter + def command(self, value): + self.obj.Command = value + + @property + def doc(self): + return self.obj.Parent.Parent + + def _special_properties(self, tipo, args): + if tipo == 'button': + # ~ if 'ImageURL' in args: + # ~ args['ImageURL'] = self._set_image_url(args['ImageURL']) + args['FocusOnClick'] = args.get('FocusOnClick', False) + return args + return args + + def add(self, args): + name = args['Name'] + tipo = args.pop('Type').lower() + w = args.pop('Width', 1000) + h = args.pop('Height', 200) + x = args.pop('X', 0) + y = args.pop('Y', 0) + control = self.doc.createInstance('com.sun.star.drawing.ControlShape') + control.setSize(Size(w, h)) + control.setPosition(Point(x, y)) + model = self.doc.createInstance(self.MODELS[tipo]) + args = self._special_properties(tipo, args) + _set_properties(model, args) + control.Control = model + index = len(self) + self.obj.insertByIndex(index, model) + self._dp.add(control) + view = self.doc.CurrentController.getControl(self.obj.getByName(name)) + control = FORM_CONTROL_CLASS[tipo](control, view, self.obj) + control.index = index + setattr(self, name, control) + self._controls[name] = control + return control + + +class LOSheetForms(object): + + def __init__(self, draw_page): + self._dp = draw_page + self._obj = draw_page.Forms + + def __getitem__(self, index): + return LOForm(self.obj[index], self._dp) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + def __contains__(self, item): + return item in self.obj + + def __len__(self): + return len(self.obj) + + @property + def obj(self): + return self._obj + + @property + def doc(self): + return self.obj.Parent + + @property + def count(self): + return len(self) + + @property + def names(self): + return self.obj.ElementNames + + def insert(self, name=''): + if not name: + name = f'form{self.count + 1}' + form = self.doc.createInstance('com.sun.star.form.component.Form') + self.obj.insertByName(name, form) + return LOForm(form, self._dp) + + def remove(self, index): + if isinstance(index, int): + self.obj.removeByIndex(index) + else: + self.obj.removeByName(index) + return + + +# ~ IsFiltered, +# ~ IsManualPageBreak, +# ~ IsStartOfNewPage +class LOSheetRows(object): + + def __init__(self, sheet, obj): + self._sheet = sheet + self._obj = obj + + def __getitem__(self, index): + if isinstance(index, int): + rows = LOSheetRows(self._sheet, self.obj[index]) + else: + rango = self._sheet[index.start:index.stop,0:] + rows = LOSheetRows(self._sheet, rango.obj.Rows) + return rows + + def __len__(self): + return self.obj.Count + + @property + def obj(self): + return self._obj + + @property + def visible(self): + return self._obj.IsVisible + @visible.setter + def visible(self, value): + self._obj.IsVisible = value + + @property + def color(self): + return self.obj.CellBackColor + @color.setter + def color(self, value): + self.obj.CellBackColor = value + + @property + def is_transparent(self): + return self.obj.IsCellBackgroundTransparent + @is_transparent.setter + def is_transparent(self, value): + self.obj.IsCellBackgroundTransparent = value + + @property + def height(self): + return self.obj.Height + @height.setter + def height(self, value): + self.obj.Height = value + + def optimal(self): + self.obj.OptimalHeight = True + return + + def insert(self, index, count): + self.obj.insertByIndex(index, count) + return + + def remove(self, index, count): + self.obj.removeByIndex(index, count) + return + + +# ~ IsManualPageBreak, +# ~ IsStartOfNewPage +class LOSheetColumns(object): + + def __init__(self, sheet, obj): + self._sheet = sheet + self._obj = obj + + def __getitem__(self, index): + if isinstance(index, (int, str)): + rows = LOSheetColumns(self._sheet, self.obj[index]) + else: + rango = self._sheet[0,index.start:index.stop] + rows = LOSheetColumns(self._sheet, rango.obj.Columns) + return rows + + def __len__(self): + return self.obj.Count + + @property + def obj(self): + return self._obj + + @property + def visible(self): + return self._obj.IsVisible + @visible.setter + def visible(self, value): + self._obj.IsVisible = value + + @property + def width(self): + return self.obj.Width + @width.setter + def width(self, value): + self.obj.Width = value + + def optimal(self): + self.obj.OptimalWidth = True + return + + def insert(self, index, count): + self.obj.insertByIndex(index, count) + return + + def remove(self, index, count): + self.obj.removeByIndex(index, count) + return + + +class LOCalcSheet(object): + + def __init__(self, obj): + self._obj = obj + + def __getitem__(self, index): + return LOCalcRange(self.obj[index]) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + def __str__(self): + return f'easymacro.LOCalcSheet: {self.name}' + + @property + def obj(self): + return self._obj + + @property + def name(self): + return self._obj.Name + @name.setter + def name(self, value): + self._obj.Name = value + + @property + def code_name(self): + return self._obj.CodeName + @code_name.setter + def code_name(self, value): + self._obj.CodeName = value + + @property + def visible(self): + return self._obj.IsVisible + @visible.setter + def visible(self, value): + self._obj.IsVisible = value + + @property + def is_protected(self): + return self._obj.isProtected() + + @property + def password(self): + return '' + @visible.setter + def password(self, value): + self.obj.protect(value) + + def unprotect(self, value): + try: + self.obj.unprotect(value) + return True + except: + pass + return False + + @property + def color(self): + return self._obj.TabColor + @color.setter + def color(self, value): + self._obj.TabColor = get_color(value) + + @property + def used_area(self): + cursor = self.get_cursor() + cursor.gotoEndOfUsedArea(True) + return LOCalcRange(self[cursor.AbsoluteName].obj) + + @property + def draw_page(self): + return LODrawPage(self.obj.DrawPage) + @property + def dp(self): + return self.draw_page + + @property + def shapes(self): + return self.draw_page + + @property + def doc(self): + return LOCalc(self.obj.DrawPage.Forms.Parent) + + @property + def charts(self): + return LOSheetCharts(self.obj.Charts, self) + + @property + def tables(self): + return LOSheetTables(self.obj.DataPilotTables, self) + + @property + def rows(self): + return LOSheetRows(self, self.obj.Rows) + + @property + def columns(self): + return LOSheetColumns(self, self.obj.Columns) + + @property + def forms(self): + return LOSheetForms(self.obj.DrawPage) + + @property + def events(self): + names = ('OnFocus', 'OnUnfocus', 'OnSelect', 'OnDoubleClick', + 'OnRightClick', 'OnChange', 'OnCalculate') + evs = self.obj.Events + events = {n: _property_to_dict(evs.getByName(n)) for n in names + if evs.getByName(n)} + return events + @events.setter + def events(self, values): + pv = '[]com.sun.star.beans.PropertyValue' + ev = self.obj.Events + for name, v in values.items(): + url = _get_url_script(v) + args = dict_to_property(dict(EventType='Script', Script=url)) + # ~ e.replaceByName(k, args) + uno.invoke(ev, 'replaceByName', (name, uno.Any(pv, args))) + + @property + def search_descriptor(self): + return self.obj.createSearchDescriptor() + + @property + def replace_descriptor(self): + return self.obj.createReplaceDescriptor() + + def activate(self): + self.doc.activate(self.obj) + return + + # ~ ??? + def clean(self): + doc = self.doc + sheet = doc.create_instance('com.sun.star.sheet.Spreadsheet') + doc._sheets.replaceByName(self.name, sheet) + return + + def move(self, pos=-1): + index = pos + if pos < 0: + index = len(self.doc) + self.doc._sheets.moveByName(self.name, index) + return + + def remove(self): + self.doc._sheets.removeByName(self.name) + return + + def copy(self, new_name='', pos=-1): + index = pos + if pos < 0: + index = len(self.doc) + self.doc._sheets.copyByName(self.name, new_name, index) + return LOCalcSheet(self.doc._sheets[new_name]) + + def copy_to(self, doc, target='', pos=-1): + index = pos + if pos < 0: + index = len(doc) + + new_name = target or self.name + new_pos = doc._sheets.importSheet(self.doc.obj, self.name, index) + sheet = doc[new_pos] + sheet.name = new_name + return sheet + + def get_cursor(self, cell=None): + if cell is None: + cursor = self.obj.createCursor() + else: + cursor = self.obj.createCursorByRange(cell) + return cursor + + def render(self, data, rango=None, clean=True): + if rango is None: + rango = self.used_area + return rango.render(data, clean) + + def find(self, search_string, rango=None): + if rango is None: + rango = self.used_area + return rango.find(search_string) + + +class LOCalcRange(object): + + def __init__(self, obj): + self._obj = obj + self._sd = None + self._is_cell = obj.ImplementationName == OBJ_CELL + + def __getitem__(self, index): + return LOCalcRange(self.obj[index]) + + def __iter__(self): + self._r = 0 + self._c = 0 + return self + + def __next__(self): + try: + rango = self[self._r, self._c] + except Exception as e: + raise StopIteration + self._c += 1 + if self._c == self.columns: + self._c = 0 + self._r +=1 + return rango + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + def __contains__(self, item): + return item.in_range(self) + + def __str__(self): + if self.is_none: + s = 'Range: None' + else: + s = f'Range: {self.name}' + return s + + @property + def obj(self): + return self._obj + + @property + def is_none(self): + return self.obj is None + + @property + def is_cell(self): + return self._is_cell + + @property + def back_color(self): + return self._obj.CellBackColor + @back_color.setter + def back_color(self, value): + self._obj.CellBackColor = get_color(value) + + @property + def dp(self): + return self.sheet.dp + + @property + def sheet(self): + return LOCalcSheet(self.obj.Spreadsheet) + + @property + def doc(self): + doc = self.obj.Spreadsheet.DrawPage.Forms.Parent + return LODocument(doc) + + @property + def name(self): + return self.obj.AbsoluteName + + @property + def code_name(self): + name = self.name.replace('$', '').replace('.', '_').replace(':', '') + return name + + @property + def columns(self): + return self.obj.Columns.Count + + @property + def column(self): + c1 = self.address.Column + c2 = c1 + 1 + ra = self.current_region.range_address + r1 = ra.StartRow + r2 = ra.EndRow + 1 + return LOCalcRange(self.sheet[r1:r2, c1:c2].obj) + + @property + def rows(self): + return LOSheetRows(self.sheet, self.obj.Rows) + + @property + def row(self): + r1 = self.address.Row + r2 = r1 + 1 + ra = self.current_region.range_address + c1 = ra.StartColumn + c2 = ra.EndColumn + 1 + return LOCalcRange(self.sheet[r1:r2, c1:c2].obj) + + @property + def type(self): + return self.obj.Type + + @property + def error(self): + return self.obj.getError() + + @property + def value(self): + v = None + if self.type == VALUE: + v = self.obj.getValue() + elif self.type == TEXT: + v = self.obj.getString() + elif self.type == FORMULA: + v = self.obj.getFormula() + return v + @value.setter + def value(self, data): + if isinstance(data, str): + if data[0] in '=': + self.obj.setFormula(data) + else: + self.obj.setString(data) + elif isinstance(data, Decimal): + self.obj.setValue(float(data)) + elif isinstance(data, (int, float, bool)): + self.obj.setValue(data) + elif isinstance(data, datetime.datetime): + d = data.toordinal() + t = (data - datetime.datetime.fromordinal(d)).seconds / SECONDS_DAY + self.obj.setValue(d - DATE_OFFSET + t) + elif isinstance(data, datetime.date): + d = data.toordinal() + self.obj.setValue(d - DATE_OFFSET) + elif isinstance(data, datetime.time): + d = (data.hour * 3600 + data.minute * 60 + data.second) / SECONDS_DAY + self.obj.setValue(d) + + @property + def str(self): + return self.obj.String + @str.setter + def str(self, value): + self.obj.setString(value) + + @property + def date(self): + value = int(self.obj.Value) + date = datetime.date.fromordinal(value + DATE_OFFSET) + return date + + @property + def time(self): + seconds = self.obj.Value * SECONDS_DAY + time_delta = datetime.timedelta(seconds=seconds) + time = (datetime.datetime.min + time_delta).time() + return time + + @property + def datetime(self): + return datetime.datetime.combine(self.date, self.time) + + @property + def data(self): + return self.obj.getDataArray() + @data.setter + def data(self, values): + if self._is_cell: + self.to_size(len(values), len(values[0])).data = values + else: + self.obj.setDataArray(values) + + @property + def dict(self): + rows = self.data + k = rows[0] + data = [dict(zip(k, r)) for r in rows[1:]] + return data + @dict.setter + def dict(self, values): + data = [tuple(values[0].keys())] + data += [tuple(d.values()) for d in values] + self.data = data + + @property + def formula(self): + return self.obj.getFormulaArray() + @formula.setter + def formula(self, values): + self.obj.setFormulaArray(values) + + @property + def array_formula(self): + return self.obj.ArrayFormula + @array_formula.setter + def array_formula(self, value): + self.obj.ArrayFormula = value + + @property + def address(self): + return self.obj.CellAddress + + @property + def range_address(self): + return self.obj.RangeAddress + + @property + def cursor(self): + cursor = self.obj.Spreadsheet.createCursorByRange(self.obj) + return cursor + + @property + def current_region(self): + cursor = self.cursor + cursor.collapseToCurrentRegion() + return LOCalcRange(self.sheet[cursor.AbsoluteName].obj) + + @property + def next_cell(self): + a = self.current_region.range_address + col = a.StartColumn + row = a.EndRow + 1 + return LOCalcRange(self.sheet[row, col].obj) + + @property + def position(self): + return self.obj.Position + + @property + def size(self): + return self.obj.Size + + @property + def possize(self): + data = { + 'Width': self.size.Width, + 'Height': self.size.Height, + 'X': self.position.X, + 'Y': self.position.Y, + } + return data + + @property + def visible(self): + cursor = self.cursor + rangos = cursor.queryVisibleCells() + rangos = LOCalcRanges(rangos) + return rangos + + @property + def merged_area(self): + cursor = self.cursor + cursor.collapseToMergedArea() + rango = LOCalcRange(self.sheet[cursor.AbsoluteName].obj) + return rango + + @property + def empty(self): + cursor = self.sheet.get_cursor(self.obj) + cursor = self.cursor + rangos = cursor.queryEmptyCells() + rangos = [LOCalcRange(self.sheet[r.AbsoluteName].obj) for r in rangos] + return tuple(rangos) + + @property + def merge(self): + return self.obj.IsMerged + @merge.setter + def merge(self, value): + self.obj.merge(value) + + @property + def style(self): + return self.obj.CellStyle + @style.setter + def style(self, value): + self.obj.CellStyle = value + + @property + def auto_format(self): + return '' + @auto_format.setter + def auto_format(self, value): + self.obj.autoFormat(value) + + @property + def validation(self): + return self.obj.Validation + @validation.setter + def validation(self, values): + current = self.validation + if not values: + current.Type = ValidationType.ANY + current.ShowInputMessage = False + else: + is_list = False + for k, v in values.items(): + if k == 'Type' and v == VT.LIST: + is_list = True + if k == 'Formula1' and is_list: + if isinstance(v, (tuple, list)): + v = ';'.join(['"{}"'.format(i) for i in v]) + setattr(current, k, v) + self.obj.Validation = current + + def select(self): + self.doc._cc.select(self.obj) + return + + def search(self, options, find_all=True): + rangos = None + + descriptor = self.sheet.search_descriptor + descriptor.setSearchString(options['Search']) + descriptor.SearchCaseSensitive = options.get('CaseSensitive', False) + descriptor.SearchWords = options.get('Words', False) + if hasattr(descriptor, 'SearchRegularExpression'): + descriptor.SearchRegularExpression = options.get('RegularExpression', False) + if hasattr(descriptor, 'SearchType') and 'Type' in options: + descriptor.SearchType = options['Type'] + + if find_all: + found = self.obj.findAll(descriptor) + else: + found = self.obj.findFirst(descriptor) + + if found: + if found.ImplementationName == OBJ_CELL: + rangos = LOCalcRange(found) + else: + rangos = [LOCalcRange(f) for f in found] + + return rangos + + def replace(self, options): + descriptor = self.sheet.replace_descriptor + descriptor.setSearchString(options['Search']) + descriptor.setReplaceString(options['Replace']) + descriptor.SearchCaseSensitive = options.get('CaseSensitive', False) + descriptor.SearchWords = options.get('Words', False) + if hasattr(descriptor, 'SearchRegularExpression'): + descriptor.SearchRegularExpression = options.get('RegularExpression', False) + if hasattr(descriptor, 'SearchType') and 'Type' in options: + descriptor.SearchType = options['Type'] + count = self.obj.replaceAll(descriptor) + return count + + def in_range(self, rango): + if isinstance(rango, LOCalcRange): + address = rango.range_address + else: + address = rango.RangeAddress + result = self.cursor.queryIntersection(address) + return bool(result.Count) + + def offset(self, rows=0, cols=1): + ra = self.range_address + col = ra.EndColumn + cols + row = ra.EndRow + rows + return LOCalcRange(self.sheet[row, col].obj) + + def to_size(self, rows, cols): + cursor = self.cursor + cursor.collapseToSize(cols, rows) + return LOCalcRange(self.sheet[cursor.AbsoluteName].obj) + + def move(self, target): + sheet = self.sheet.obj + sheet.moveRange(target.address, self.range_address) + return + + def insert(self, insert_mode=CIM.DOWN): + sheet = self.sheet.obj + sheet.insertCells(self.range_address, insert_mode) + return + + def delete(self, delete_mode=CDM.UP): + sheet = self.sheet.obj + sheet.removeRange(self.range_address, delete_mode) + return + + def copy_from(self, source): + self.sheet.obj.copyRange(self.address, source.range_address) + return + + def copy_to(self, target): + self.sheet.obj.copyRange(target.address, self.range_address) + return + + # ~ def copy_to(self, cell, formula=False): + # ~ rango = cell.to_size(self.rows, self.columns) + # ~ if formula: + # ~ rango.formula = self.formula + # ~ else: + # ~ rango.data = self.data + # ~ return + + # ~ def copy_from(self, rango, formula=False): + # ~ data = rango + # ~ if isinstance(rango, LOCalcRange): + # ~ if formula: + # ~ data = rango.formula + # ~ else: + # ~ data = rango.data + # ~ rows = len(data) + # ~ cols = len(data[0]) + # ~ if formula: + # ~ self.to_size(rows, cols).formula = data + # ~ else: + # ~ self.to_size(rows, cols).data = data + # ~ return + + def optimal_width(self): + self.obj.Columns.OptimalWidth = True + return + + def clean_render(self, template='\{(\w.+)\}'): + self._sd.SearchRegularExpression = True + self._sd.setSearchString(template) + self.obj.replaceAll(self._sd) + return + + def render(self, data, clean=True): + self._sd = self.sheet.obj.createSearchDescriptor() + self._sd.SearchCaseSensitive = False + for k, v in data.items(): + cell = self._render_value(k, v) + return cell + + def _render_value(self, key, value, parent=''): + cell = None + if isinstance(value, dict): + for k, v in value.items(): + # ~ print(1, 'RENDER', k, v) + cell = self._render_value(k, v, key) + return cell + elif isinstance(value, (list, tuple)): + self._render_list(key, value) + return + + search = f'{{{key}}}' + if parent: + search = f'{{{parent}.{key}}}' + ranges = self.find_all(search) + + if ranges is None: + return + + # ~ for cell in ranges or range(0): + for cell in ranges: + self._set_new_value(cell, search, value) + return LOCalcRange(cell) + + def _set_new_value(self, cell, search, value): + if not cell.ImplementationName == 'ScCellObj': + return + + if isinstance(value, str): + pattern = re.compile(search, re.IGNORECASE) + new_value = pattern.sub(value, cell.String) + cell.String = new_value + else: + LOCalcRange(cell).value = value + return + + def _render_list(self, key, rows): + for row in rows: + for k, v in row.items(): + self._render_value(k, v) + return + + def find(self, search_string): + if self._sd is None: + self._sd = self.sheet.obj.createSearchDescriptor() + self._sd.SearchCaseSensitive = False + + self._sd.setSearchString(search_string) + cell = self.obj.findFirst(self._sd) + if cell: + cell = LOCalcRange(cell) + return cell + + def find_all(self, search_string): + if self._sd is None: + self._sd = self.sheet.obj.createSearchDescriptor() + self._sd.SearchCaseSensitive = False + + self._sd.setSearchString(search_string) + ranges = self.obj.findAll(self._sd) + return ranges + + def filter(self, args, with_headers=True): + ff = TableFilterField() + ff.Field = args['Field'] + ff.Operator = args['Operator'] + if isinstance(args['Value'], str): + ff.IsNumeric = False + ff.StringValue = args['Value'] + else: + ff.IsNumeric = True + ff.NumericValue = args['Value'] + + fd = self.obj.createFilterDescriptor(True) + fd.ContainsHeader = with_headers + fd.FilterFields = ((ff,)) + # ~ self.obj.AutoFilter = True + self.obj.filter(fd) + return + + def copy_format_from(self, rango): + rango.select() + self.doc.copy() + self.select() + args = { + 'Flags': 'T', + 'MoveMode': 4, + } + url = '.uno:InsertContents' + call_dispatch(self.doc.frame, url, args) + return + + def to_image(self): + self.select() + self.doc.copy() + args = {'SelectedFormat': 141} + url = '.uno:ClipboardFormatItems' + call_dispatch(self.doc.frame, url, args) + return self.sheet.shapes[-1] + + def insert_image(self, path, options={}): + args = options.copy() + ps = self.possize + args['Width'] = args.get('Width', ps['Width']) + args['Height'] = args.get('Height', ps['Height']) + args['X'] = args.get('X', ps['X']) + args['Y'] = args.get('Y', ps['Y']) + # ~ img.ResizeWithCell = True + img = self.sheet.dp.insert_image(path, args) + img.anchor = self.obj + args.clear() + return img + + def insert_shape(self, tipo, args={}): + ps = self.possize + args['Width'] = args.get('Width', ps['Width']) + args['Height'] = args.get('Height', ps['Height']) + args['X'] = args.get('X', ps['X']) + args['Y'] = args.get('Y', ps['Y']) + + shape = self.sheet.dp.add(tipo, args) + shape.anchor = self.obj + args.clear() + return + + def filter_by_color(self, cell): + rangos = cell.column[1:,:].visible + for r in rangos: + for c in r: + if c.back_color != cell.back_color: + c.rows.visible = False + return + + def clear(self, what=1023): + # ~ http://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1sheet_1_1CellFlags.html + self.obj.clearContents(what) + return + + def transpose(self): + # ~ 'Flags': 'A', + # ~ 'FormulaCommand': 0, + # ~ 'SkipEmptyCells': False, + # ~ 'AsLink': False, + # ~ 'MoveMode': 4, + self.select() + self.doc.copy() + self.clear(1023) + self[0,0].select() + self.doc.insert_contents({'Transpose': True}) + _CB.set('') + return + + def transpose_data(self, formula=False): + data = self.data + if formula: + data = self.formula + data = tuple(zip(*data)) + self.clear(1023) + self[0,0].copy_from(data, formula=formula) + return + + def merge_by_row(self): + for r in range(len(self.rows)): + self[r].merge = True + return + + def fill(self, source=1): + self.obj.fillAuto(0, source) + return + + def _cast(self, t, v): + if not t: + return v + + if t == datetime.date: + nv = datetime.date.fromordinal(int(v) + DATE_OFFSET) + else: + nv = t(v) + return nv + + def get_data(self, types): + values = [ + [self._cast(types[i], v) for i, v in enumerate(row)] + for row in self.data + ] + return values + + +class LOCalcRanges(object): + + def __init__(self, obj): + self._obj = obj + self._ranges = {} + self._index = 0 + for r in obj: + sheet = r.Spreadsheet + rango = LOCalcRange(sheet[r.AbsoluteName]) + self._ranges[rango.name] = rango + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + def __len__(self): + return self._obj.Count + + def __contains__(self, item): + return self._obj.hasByName(item.name) + + def __iter__(self): + self._index = 0 + return self + + def __next__(self): + try: + r = self.obj[self._index] + rango = self._ranges[r.AbsoluteName] + except IndexError: + raise StopIteration + + self._index += 1 + return rango + + def __getitem__(self, index): + if isinstance(index, int): + r = self.obj[index] + rango = self._ranges[r.AbsoluteName] + else: + rango = self._ranges[index] + return rango + + @property + def obj(self): + return self._obj + + @property + def names(self): + return self.obj.ElementNames + + @property + def data(self): + return [r.data for r in self._ranges.values()] + + @property + def style(self): + return self.obj + @style.setter + def style(self, value): + self.obj.CellStyle = value + + def add(self, rangos): + if isinstance(rangos, LOCalcRange): + rangos = (rangos,) + for r in rangos: + self._ranges[r.name] = r + self.obj.addRangeAddress(r.range_address, False) + return + + def remove(self, rangos): + if isinstance(rangos, LOCalcRange): + rangos = (rangos,) + for r in rangos: + del self._ranges[r.name] + self.obj.removeRangeAddress(r.range_address) + return + + +class LOWriterStyles(object): + + def __init__(self, styles): + self._styles = styles + + @property + def names(self): + return {s.DisplayName: s.Name for s in self._styles} + + def __str__(self): + return '\n'.join(tuple(self.names.values())) + + +class LOWriterStylesFamilies(object): + + def __init__(self, styles): + self._styles = styles + + def __getitem__(self, index): + styles = { + 'Character': 'CharacterStyles', + 'Paragraph': 'ParagraphStyles', + 'Page': 'PageStyles', + 'Frame': 'FrameStyles', + 'Numbering': 'NumberingStyles', + 'Table': 'TableStyles', + 'Cell': 'CellStyles', + } + name = styles.get(index, index) + return LOWriterStyles(self._styles[name]) + + def __iter__(self): + self._index = 0 + return self + + def __next__(self): + obj = LOWriterStyles(self._styles[self._index]) + self._index += 1 + return obj + # ~ raise StopIteration + + @property + def names(self): + return self._styles.ElementNames + + def __str__(self): + return '\n'.join(self.names) + + +class LOWriterPageStyle(LOBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + def __str__(self): + return f'Page Style: {self.name}' + + @property + def name(self): + return self._obj.Name + + +class LOWriterPageStyles(object): + + def __init__(self, styles): + self._styles = styles + + def __getitem__(self, index): + return LOWriterPageStyle(self._styles[index]) + + @property + def names(self): + return self._styles.ElementNames + + def __str__(self): + return '\n'.join(self.names) + + +class LOWriterTextRange(object): + + def __init__(self, obj, doc): + self._obj = obj + self._doc = doc + self._is_paragraph = self.obj.ImplementationName == 'SwXParagraph' + self._is_table = self.obj.ImplementationName == 'SwXTextTable' + self._is_text = self.obj.ImplementationName == 'SwXTextPortion' + self._is_section = not self.obj.TextSection is None + self._parts = [] + if self._is_paragraph: + self._parts = [LOWriterTextRange(p, doc) for p in obj] + + def __iter__(self): + self._index = 0 + return self + + def __next__(self): + try: + obj = self._parts[self._index] + except IndexError: + raise StopIteration + + self._index += 1 + return obj + + @property + def obj(self): + return self._obj + + @property + def string(self): + s = '' + if not self._is_table: + s = self.obj.String + return s + @string.setter + def string(self, value): + self.obj.String = value + + @property + def value(self): + return self.string + @value.setter + def value(self, value): + self.string = value + + @property + def style(self): + s = '' + if self.is_paragraph: + s = self.obj.ParaStyleName + elif self.is_text: + s = self.obj.CharStyleName + return s + @style.setter + def style(self, value): + if self.is_paragraph: + self.obj.ParaStyleName = value + elif self.is_text: + self.obj.CharStyleName = value + + @property + def is_paragraph(self): + return self._is_paragraph + + @property + def is_table(self): + return self._is_table + + @property + def is_text(self): + return self._is_text + + @property + def is_section(self): + return self._is_section + + @property + def text(self): + return self.obj.Text + + @property + def cursor(self): + return self.text.createTextCursorByRange(self.obj) + + @property + def text_cursor(self): + return self.text.createTextCursor() + + @property + def dp(self): + return self._doc.dp + + @property + def paragraph(self): + cursor = self.cursor + cursor.gotoStartOfParagraph(False) + cursor.gotoNextParagraph(True) + return LOWriterTextRange(cursor, self._doc) + + def goto_start(self): + if self.is_section: + rango = self.obj.TextSection.Anchor.Start + else: + rango = self.obj.Start + return LOWriterTextRange(rango, self._doc) + + def goto_end(self): + if self.is_section: + rango = self.obj.TextSection.Anchor.End + else: + rango = self.obj.End + return LOWriterTextRange(rango, self._doc) + + def goto_previous(self, expand=True): + cursor = self.cursor + cursor.gotoPreviousParagraph(expand) + return LOWriterTextRange(cursor, self._doc) + + def goto_next(self, expand=True): + cursor = self.cursor + cursor.gotoNextParagraph(expand) + return LOWriterTextRange(cursor, self._doc) + + def go_left(self, from_self=True, count=1, expand=False): + cursor = self.cursor + if not from_self: + cursor = self.text_cursor + cursor.gotoRange(self.obj, False) + cursor.goLeft(count, expand) + return LOWriterTextRange(cursor, self._doc) + + def go_right(self, from_self=True, count=1, expand=False): + cursor = self.cursor + if not from_self: + cursor = self.text_cursor + cursor.gotoRange(self.obj, False) + cursor.goRight(count, expand) + return LOWriterTextRange(cursor, self._doc) + + def delete(self): + self.value = '' + return + + def offset(self): + cursor = self.cursor.getEnd() + return LOWriterTextRange(cursor, self._doc) + + def insert_content(self, data, cursor=None, replace=False): + if cursor is None: + cursor = self.cursor + self.text.insertTextContent(cursor, data, replace) + return + + def insert_math(self, formula, + anchor_type=TextContentAnchorType.AS_CHARACTER, + cursor=None, replace=False): + + math = self._doc.create_instance(SERVICES['TEXT_EMBEDDED']) + math.CLSID = CLSID['FORMULA'] + math.AnchorType = anchor_type + self.insert_content(math, cursor, replace) + math.EmbeddedObject.Component.Formula = formula + return math + + def new_line(self, count=1): + cursor = self.cursor + for i in range(count): + self.text.insertControlCharacter(cursor, PARAGRAPH_BREAK, False) + return LOWriterTextRange(cursor, self._doc) + + def insert_table(self, data): + table = self._doc.create_instance(SERVICES['TEXT_TABLE']) + rows = len(data) + cols = len(data[0]) + table.initialize(rows, cols) + self.insert_content(table) + table.DataArray = data + name = table.Name + table = LOWriterTextTable(self._doc.tables[name], self._doc) + return table + + def insert_shape(self, tipo, args={}): + # ~ args['Width'] = args.get('Width', 1000) + # ~ args['Height'] = args.get('Height', 1000) + # ~ args['X'] = args.get('X', 0) + # ~ args['Y'] = args.get('Y', 0) + shape = self._doc.dp.add(tipo, args) + # ~ shape.anchor = self.obj + return shape + + def insert_image(self, path, args={}): + w = args.get('Width', 1000) + h = args.get('Height', 1000) + + image = self._doc.create_instance(SERVICES['GRAPHIC']) + image.GraphicURL = _P.to_url(path) + image.AnchorType = TextContentAnchorType.AS_CHARACTER + image.Width = w + image.Height = h + self.insert_content(image) + return self._doc.dp.last + + +class LOWriterTextRanges(object): + + def __init__(self, obj, doc): + self._obj = obj + self._doc = doc + self._paragraphs = [LOWriterTextRange(p, doc) for p in obj] + + def __len__(self): + return len(self._paragraphs) + + def __getitem__(self, index): + return self._paragraphs[index] + + def __iter__(self): + self._index = 0 + return self + + def __next__(self): + try: + obj = self._paragraphs[self._index] + except IndexError: + raise StopIteration + + self._index += 1 + return obj + + @property + def obj(self): + return self._obj + + +class LOWriterTextTable(object): + + def __init__(self, obj, doc): + self._obj = obj + self._doc = doc + + @property + def obj(self): + return self._obj + + @property + def name(self): + return self._obj.Name + + @property + def data(self): + return self.obj.DataArray + @data.setter + def data(self, values): + self.obj.DataArray = values + + @property + def style(self): + return self.obj.TableTemplateName + @style.setter + def style(self, value): + self.obj.autoFormat(value) + + +class LOWriterTextTables(object): + + def __init__(self, doc): + self._doc = doc + self._obj = doc.obj.TextTables + + def __getitem__(self, key): + return LOWriterTextTable(self._obj[key], self._doc) + + def __len__(self): + return self._obj.Count + + def insert(self, data, text_range=None): + if text_range is None: + text_range = self._doc.selection + text_range.insert_table(data) + return + + +class LOWriter(LODocument): + + def __init__(self, obj): + super().__init__(obj) + self._type = WRITER + + @property + def text(self): + return self.paragraphs + + @property + def paragraphs(self): + return LOWriterTextRanges(self.obj.Text, self) + + @property + def tables(self): + return LOWriterTextTables(self) + + @property + def selection(self): + sel = self.obj.CurrentSelection + if sel.ImplementationName == OBJ_TEXTS: + if len(sel) == 1: + sel = LOWriterTextRanges(sel, self)[0] + else: + sel = LOWriterTextRanges(sel, self) + return sel + + if sel.ImplementationName == OBJ_SHAPES: + if len(sel) == 1: + sel = sel[0] + sel = LODrawPage(sel.Parent)[sel.Name] + return sel + + if sel.ImplementationName == OBJ_GRAPHIC: + sel = self.dp[sel.Name] + else: + debug(sel.ImplementationName) + + return sel + + @property + def dp(self): + return self.draw_page + @property + def shapes(self): + return self.draw_page + @property + def draw_page(self): + return LODrawPage(self.obj.DrawPage) + + @property + def view_cursor(self): + return self._cc.ViewCursor + + @property + def cursor(self): + return self.obj.Text.createTextCursor() + + @property + def view_cursor(self): + return self._cc.ViewCursor + + @property + def page_styles(self): + ps = self.obj.StyleFamilies['PageStyles'] + return LOWriterPageStyles(ps) + + @property + def styles(self): + return LOWriterStylesFamilies(self.obj.StyleFamilies) + + @property + def search_descriptor(self): + return self.obj.createSearchDescriptor() + + @property + def replace_descriptor(self): + return self.obj.createReplaceDescriptor() + + @property + def zoom(self): + return self._cc.ViewSettings.ZoomValue + @zoom.setter + def zoom(self, value): + self._cc.ViewSettings.ZoomValue = value + + def goto_start(self): + self.view_cursor.gotoStart(False) + return self.selection + + def goto_end(self): + self.view_cursor.gotoEnd(False) + return self.selection + + def search(self, options, find_all=True): + descriptor = self.search_descriptor + descriptor.setSearchString(options.get('Search', '')) + descriptor.SearchCaseSensitive = options.get('CaseSensitive', False) + descriptor.SearchWords = options.get('Words', False) + if 'Attributes' in options: + attr = dict_to_property(options['Attributes']) + descriptor.setSearchAttributes(attr) + if hasattr(descriptor, 'SearchRegularExpression'): + descriptor.SearchRegularExpression = options.get('RegularExpression', False) + if hasattr(descriptor, 'SearchType') and 'Type' in options: + descriptor.SearchType = options['Type'] + + result = False + if find_all: + found = self.obj.findAll(descriptor) + if len(found): + result = [LOWriterTextRange(f, self) for f in found] + else: + found = self.obj.findFirst(descriptor) + if found: + result = LOWriterTextRange(found, self) + + return result + + def replace(self, options): + descriptor = self.replace_descriptor + descriptor.setSearchString(options['Search']) + descriptor.setReplaceString(options['Replace']) + descriptor.SearchCaseSensitive = options.get('CaseSensitive', False) + descriptor.SearchWords = options.get('Words', False) + if 'Attributes' in options: + attr = dict_to_property(options['Attributes']) + descriptor.setSearchAttributes(attr) + if hasattr(descriptor, 'SearchRegularExpression'): + descriptor.SearchRegularExpression = options.get('RegularExpression', False) + if hasattr(descriptor, 'SearchType') and 'Type' in options: + descriptor.SearchType = options['Type'] + found = self.obj.replaceAll(descriptor) + return found + + def select(self, text): + if hasattr(text, 'obj'): + text = text.obj + self._cc.select(text) + return + + +class LOShape(LOBaseObject): + IMAGE = 'com.sun.star.drawing.GraphicObjectShape' + + def __init__(self, obj, index=-1): + self._index = index + super().__init__(obj) + + @property + def type(self): + t = self.shape_type[21:] + if self.is_image: + t = 'image' + return t + + @property + def shape_type(self): + return self.obj.ShapeType + + @property + def properties(self): + return {} + @properties.setter + def properties(self, values): + _set_properties(self.obj, values) + + @property + def is_image(self): + return self.shape_type == self.IMAGE + + @property + def name(self): + return self.obj.Name or f'{self.type}{self.index}' + @name.setter + def name(self, value): + self.obj.Name = value + + @property + def index(self): + return self._index + + @property + def size(self): + s = self.obj.Size + a = dict(Width=s.Width, Height=s.Height) + return a + + @property + def position(self): + return self.obj.Position + @property + def x(self): + return self.position.X + @property + def y(self): + return self.position.Y + + @property + def string(self): + return self.obj.String + @string.setter + def string(self, value): + self.obj.String = value + + @property + def description(self): + return self.obj.Description + @description.setter + def description(self, value): + self.obj.Description = value + + @property + def cell(self): + return self.anchor + + @property + def anchor(self): + obj = self.obj.Anchor + if obj.ImplementationName == OBJ_CELL: + obj = LOCalcRange(obj) + elif obj.ImplementationName == OBJ_TEXT: + obj = LOWriterTextRange(obj, LODocs().active) + else: + debug('Anchor', obj.ImplementationName) + return obj + @anchor.setter + def anchor(self, value): + if hasattr(value, 'obj'): + value = value.obj + try: + self.obj.Anchor = value + except Exception as e: + self.obj.AnchorType = value + + @property + def visible(self): + return self.obj.Visible + @visible.setter + def visible(self, value): + self.obj.Visible = value + + @property + def path(self): + return self.url + @property + def url(self): + url = '' + if self.is_image: + url = _P.to_system(self.obj.GraphicURL.OriginURL) + return url + + @property + def mimetype(self): + mt = '' + if self.is_image: + mt = self.obj.GraphicURL.MimeType + return mt + + @property + def linked(self): + l = False + if self.is_image: + l = self.obj.GraphicURL.Linked + return l + + def delete(self): + self.remove() + return + def remove(self): + self.obj.Parent.remove(self.obj) + return + + def save(self, path: str, mimetype=DEFAULT_MIME_TYPE): + if _P.is_dir(path): + name = self.name + ext = mimetype.lower() + else: + p = _P(path) + path = p.path + name = p.name + ext = p.ext.lower() + + path = _P.join(path, f'{name}.{ext}') + args = dict( + URL = _P.to_url(path), + MimeType = MIME_TYPE[ext], + ) + if not _export_image(self.obj, args): + path = '' + return path + + # ~ def save2(self, path: str): + # ~ size = len(self.obj.Bitmap.DIB) + # ~ data = self.obj.GraphicStream.readBytes((), size) + # ~ data = data[-1].value + # ~ path = _P.join(path, f'{self.name}.png') + # ~ _P.save_bin(path, b'') + # ~ return + + +class LODrawPage(LOBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + def __getitem__(self, index): + if isinstance(index, int): + shape = LOShape(self.obj[index], index) + else: + for i, o in enumerate(self.obj): + shape = self.obj[i] + name = shape.Name or f'shape{i}' + if name == index: + shape = LOShape(shape, i) + break + return shape + + def __iter__(self): + self._index = 0 + return self + + def __next__(self): + if self._index == self.count: + raise StopIteration + shape = self[self._index] + self._index += 1 + return shape + + + @property + def name(self): + return self.obj.Name + + @property + def doc(self): + return self.obj.Forms.Parent + + @property + def width(self): + return self.obj.Width + + @property + def height(self): + return self.obj.Height + + @property + def count(self): + return self.obj.Count + + @property + def last(self): + return self[self.count - 1] + + def create_instance(self, name): + return self.doc.createInstance(name) + + def add(self, type_shape, options={}): + args = options.copy() + """Insert a shape in page, type shapes: + Line + Rectangle + Ellipse + Text + Connector + """ + index = self.count + default_height = 3000 + if type_shape == 'Line': + default_height = 0 + w = args.pop('Width', 3000) + h = args.pop('Height', default_height) + x = args.pop('X', 1000) + y = args.pop('Y', 1000) + name = args.pop('Name', f'{type_shape.lower()}{index}') + + service = f'com.sun.star.drawing.{type_shape}Shape' + shape = self.create_instance(service) + shape.Size = Size(w, h) + shape.Position = Point(x, y) + shape.Name = name + self.obj.add(shape) + + if args: + _set_properties(shape, args) + + return LOShape(self.obj[index], index) + + def remove(self, shape): + if hasattr(shape, 'obj'): + shape = shape.obj + return self.obj.remove(shape) + + def remove_all(self): + while self.count: + self.obj.remove(self.obj[0]) + return + + def insert_image(self, path, options={}): + args = options.copy() + index = self.count + w = args.get('Width', 3000) + h = args.get('Height', 3000) + x = args.get('X', 1000) + y = args.get('Y', 1000) + name = args.get('Name', f'image{index}') + + image = self.create_instance('com.sun.star.drawing.GraphicObjectShape') + if isinstance(path, str): + image.GraphicURL = _P.to_url(path) + else: + gp = create_instance('com.sun.star.graphic.GraphicProvider') + properties = dict_to_property({'InputStream': path}) + image.Graphic = gp.queryGraphic(properties) + + self.obj.add(image) + image.Size = Size(w, h) + image.Position = Point(x, y) + image.Name = name + return LOShape(self.obj[index], index) + + +class LODrawImpress(LODocument): + + def __init__(self, obj): + super().__init__(obj) + + def __getitem__(self, index): + if isinstance(index, int): + page = self.obj.DrawPages[index] + else: + page = self.obj.DrawPages.getByName(index) + return LODrawPage(page) + + @property + def selection(self): + sel = self.obj.CurrentSelection[0] + # ~ return _get_class_uno(sel) + return sel + + @property + def current_page(self): + return LODrawPage(self._cc.getCurrentPage()) + + def paste(self): + call_dispatch(self.frame, '.uno:Paste') + return self.current_page[-1] + + def add(self, type_shape, args={}): + return self.current_page.add(type_shape, args) + + def insert_image(self, path, args={}): + self.current_page.insert_image(path, args) + return + + # ~ def export(self, path, mimetype='png'): + # ~ args = dict( + # ~ URL = _P.to_url(path), + # ~ MimeType = MIME_TYPE[mimetype], + # ~ ) + # ~ result = _export_image(self.obj, args) + # ~ return result + + +class LODraw(LODrawImpress): + + def __init__(self, obj): + super().__init__(obj) + self._type = DRAW + + +class LOImpress(LODrawImpress): + + def __init__(self, obj): + super().__init__(obj) + self._type = IMPRESS + + +class BaseDateField(DateField): + + def db_value(self, value): + return _date_to_struct(value) + + def python_value(self, value): + return _struct_to_date(value) + + +class BaseTimeField(TimeField): + + def db_value(self, value): + return _date_to_struct(value) + + def python_value(self, value): + return _struct_to_date(value) + + +class BaseDateTimeField(DateTimeField): + + def db_value(self, value): + return _date_to_struct(value) + + def python_value(self, value): + return _struct_to_date(value) + + +class FirebirdDatabase(Database): + field_types = {'BOOL': 'BOOLEAN', 'DATETIME': 'TIMESTAMP'} + + def __init__(self, database, **kwargs): + super().__init__(database, **kwargs) + self._db = database + + def _connect(self): + return self._db + + def create_tables(self, models, **options): + options['safe'] = False + tables = self._db.tables + models = [m for m in models if not m.__name__.lower() in tables] + super().create_tables(models, **options) + + def execute_sql(self, sql, params=None, commit=True): + with __exception_wrapper__: + cursor = self._db.execute(sql, params) + return cursor + + def last_insert_id(self, cursor, query_type=None): + # ~ debug('LAST_ID', cursor) + return 0 + + def rows_affected(self, cursor): + return self._db.rows_affected + + @property + def path(self): + return self._db.path + + +class BaseRow: + pass + + +class BaseQuery(object): + PY_TYPES = { + 'VARCHAR': 'getString', + 'INTEGER': 'getLong', + 'DATE': 'getDate', + # ~ 'SQL_LONG': 'getLong', + # ~ 'SQL_VARYING': 'getString', + # ~ 'SQL_FLOAT': 'getFloat', + # ~ 'SQL_BOOLEAN': 'getBoolean', + # ~ 'SQL_TYPE_DATE': 'getDate', + # ~ 'SQL_TYPE_TIME': 'getTime', + # ~ 'SQL_TIMESTAMP': 'getTimestamp', + } + # ~ TYPES_DATE = ('SQL_TYPE_DATE', 'SQL_TYPE_TIME', 'SQL_TIMESTAMP') + TYPES_DATE = ('DATE', 'SQL_TYPE_TIME', 'SQL_TIMESTAMP') + + def __init__(self, query): + self._query = query + self._meta = query.MetaData + self._cols = self._meta.ColumnCount + self._names = query.Columns.ElementNames + self._data = self._get_data() + + def __getitem__(self, index): + return self._data[index] + + def __iter__(self): + self._index = 0 + return self + + def __next__(self): + try: + row = self._data[self._index] + except IndexError: + raise StopIteration + self._index += 1 + return row + + def _to_python(self, index): + type_field = self._meta.getColumnTypeName(index) + # ~ print('TF', type_field) + value = getattr(self._query, self.PY_TYPES[type_field])(index) + if type_field in self.TYPES_DATE: + value = _struct_to_date(value) + return value + + def _get_row(self): + row = BaseRow() + for i in range(1, self._cols + 1): + column_name = self._meta.getColumnName(i) + value = self._to_python(i) + setattr(row, column_name, value) + return row + + def _get_data(self): + data = [] + while self._query.next(): + row = self._get_row() + data.append(row) + return data + + @property + def tuples(self): + data = [tuple(r.__dict__.values()) for r in self._data] + return tuple(data) + + @property + def dicts(self): + data = [r.__dict__ for r in self._data] + return tuple(data) + + +class LOBase(object): + DB_TYPES = { + str: 'setString', + int: 'setInt', + float: 'setFloat', + bool: 'setBoolean', + Date: 'setDate', + Time: 'setTime', + DateTime: 'setTimestamp', + } + # ~ setArray + # ~ setBinaryStream + # ~ setBlob + # ~ setByte + # ~ setBytes + # ~ setCharacterStream + # ~ setClob + # ~ setNull + # ~ setObject + # ~ setObjectNull + # ~ setObjectWithInfo + # ~ setPropertyValue + # ~ setRef + + def __init__(self, obj, args={}): + self._obj = obj + self._type = BASE + self._dbc = create_instance('com.sun.star.sdb.DatabaseContext') + self._rows_affected = 0 + path = args.get('path', '') + self._path = _P(path) + self._name = self._path.name + if _P.exists(path): + if not self.is_registered: + self.register() + db = self._dbc.getByName(self.name) + else: + db = self._dbc.createInstance() + db.URL = 'sdbc:embedded:firebird' + db.DatabaseDocument.storeAsURL(self._path.url, ()) + self.register() + self._obj = db + self._con = db.getConnection('', '') + + def __contains__(self, item): + return item in self.tables + + @property + def obj(self): + return self._obj + + @property + def name(self): + return self._name + + @property + def path(self): + return str(self._path) + + @property + def is_registered(self): + return self._dbc.hasRegisteredDatabase(self.name) + + @property + def tables(self): + tables = [t.Name.lower() for t in self._con.getTables()] + return tables + + @property + def rows_affected(self): + return self._rows_affected + + def register(self): + if not self.is_registered: + self._dbc.registerDatabaseLocation(self.name, self._path.url) + return + + def revoke(self, name): + self._dbc.revokeDatabaseLocation(name) + return True + + def save(self): + self.obj.DatabaseDocument.store() + self.refresh() + return + + def close(self): + self._con.close() + return + + def refresh(self): + self._con.getTables().refresh() + return + + def initialize(self, database_proxy, tables=[]): + db = FirebirdDatabase(self) + database_proxy.initialize(db) + if tables: + db.create_tables(tables) + return + + def _validate_sql(self, sql, params): + limit = ' LIMIT ' + for p in params: + sql = sql.replace('?', f"'{p}'", 1) + if limit in sql: + sql = sql.split(limit)[0] + sql = sql.replace('SELECT', f'SELECT FIRST {params[-1]}') + return sql + + def cursor(self, sql, params): + if sql.startswith('SELECT'): + sql = self._validate_sql(sql, params) + cursor = self._con.prepareStatement(sql) + return cursor + + if not params: + cursor = self._con.createStatement() + return cursor + + cursor = self._con.prepareStatement(sql) + for i, v in enumerate(params, 1): + t = type(v) + if not t in self.DB_TYPES: + error('Type not support') + debug((i, t, v, self.DB_TYPES[t])) + getattr(cursor, self.DB_TYPES[t])(i, v) + return cursor + + def execute(self, sql, params): + debug(sql, params) + cursor = self.cursor(sql, params) + + if sql.startswith('SELECT'): + result = cursor.executeQuery() + elif params: + result = cursor.executeUpdate() + self._rows_affected = result + self.save() + else: + result = cursor.execute(sql) + self.save() + + return result + + def select(self, sql): + debug('SELECT', sql) + if not sql.startswith('SELECT'): + return () + + cursor = self._con.prepareStatement(sql) + query = cursor.executeQuery() + return BaseQuery(query) + + def get_query(self, query): + sql, args = query.sql() + sql = self._validate_sql(sql, args) + return self.select(sql) + + +class LOMath(LODocument): + + def __init__(self, obj): + super().__init__(obj) + self._type = MATH + + +class LOBasic(LODocument): + + def __init__(self, obj): + super().__init__(obj) + self._type = BASIC + + +class LODocs(object): + _desktop = None + + def __init__(self): + self._desktop = get_desktop() + LODocs._desktop = self._desktop + + def __getitem__(self, index): + document = None + for i, doc in enumerate(self._desktop.Components): + if isinstance(index, int) and i == index: + document = _get_class_doc(doc) + break + elif isinstance(index, str) and doc.Title == index: + document = _get_class_doc(doc) + break + return document + + def __contains__(self, item): + doc = self[item] + return not doc is None + + def __iter__(self): + self._i = -1 + return self + + def __next__(self): + self._i += 1 + doc = self[self._i] + if doc is None: + raise StopIteration + else: + return doc + + def __len__(self): + # ~ len(self._desktop.Components) + for i, _ in enumerate(self._desktop.Components): + pass + return i + 1 + + @property + def active(self): + return _get_class_doc(self._desktop.getCurrentComponent()) + + @classmethod + def new(cls, type_doc=CALC, args={}): + if type_doc == BASE: + return LOBase(None, args) + + path = f'private:factory/s{type_doc}' + opt = dict_to_property(args) + doc = cls._desktop.loadComponentFromURL(path, '_default', 0, opt) + return _get_class_doc(doc) + + @classmethod + def open(cls, path, args={}): + """ Open document in path + Usually options: + Hidden: True or False + AsTemplate: True or False + ReadOnly: True or False + Password: super_secret + MacroExecutionMode: 4 = Activate macros + Preview: True or False + + http://api.libreoffice.org/docs/idl/ref/interfacecom_1_1sun_1_1star_1_1frame_1_1XComponentLoader.html + http://api.libreoffice.org/docs/idl/ref/servicecom_1_1sun_1_1star_1_1document_1_1MediaDescriptor.html + """ + path = _P.to_url(path) + opt = dict_to_property(args) + doc = cls._desktop.loadComponentFromURL(path, '_default', 0, opt) + if doc is None: + return + + return _get_class_doc(doc) + + def connect(self, path): + db = LOBase(None, {'path': path}) + return db + + +def _add_listeners(events, control, name=''): + listeners = { + 'addActionListener': EventsButton, + 'addMouseListener': EventsMouse, + 'addFocusListener': EventsFocus, + 'addItemListener': EventsItem, + 'addKeyListener': EventsKey, + 'addTabListener': EventsTab, + 'addSpinListener': EventsSpin, + } + if hasattr(control, 'obj'): + control = control.obj + # ~ debug(control.ImplementationName) + is_grid = control.ImplementationName == 'stardiv.Toolkit.GridControl' + is_link = control.ImplementationName == 'stardiv.Toolkit.UnoFixedHyperlinkControl' + is_roadmap = control.ImplementationName == 'stardiv.Toolkit.UnoRoadmapControl' + is_pages = control.ImplementationName == 'stardiv.Toolkit.UnoMultiPageControl' + + for key, value in listeners.items(): + if hasattr(control, key): + if is_grid and key == 'addMouseListener': + control.addMouseListener(EventsMouseGrid(events, name)) + continue + if is_link and key == 'addMouseListener': + control.addMouseListener(EventsMouseLink(events, name)) + continue + if is_roadmap and key == 'addItemListener': + control.addItemListener(EventsItemRoadmap(events, name)) + continue + + getattr(control, key)(listeners[key](events, name)) + + if is_grid: + controllers = EventsGrid(events, name) + control.addSelectionListener(controllers) + control.Model.GridDataModel.addGridDataListener(controllers) + return + + +def _set_properties(model, properties): + if 'X' in properties: + properties['PositionX'] = properties.pop('X') + if 'Y' in properties: + properties['PositionY'] = properties.pop('Y') + keys = tuple(properties.keys()) + values = tuple(properties.values()) + model.setPropertyValues(keys, values) + return + + +class EventsListenerBase(unohelper.Base, XEventListener): + + def __init__(self, controller, name, window=None): + self._controller = controller + self._name = name + self._window = window + + @property + def name(self): + return self._name + + def disposing(self, event): + self._controller = None + if not self._window is None: + self._window.setMenuBar(None) + + +class EventsSpin(EventsListenerBase, XSpinListener): + + def __init__(self, controller, name): + super().__init__(controller, name) + + def up(self, event): + event_name = f'{self.name}_up' + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def down(self, event): + event_name = f'{self.name}_up' + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def first(self, event): + event_name = f'{self.name}_first' + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def last(self, event): + event_name = f'{self.name}_last' + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + +class EventsMouse(EventsListenerBase, XMouseListener, XMouseMotionListener): + + def __init__(self, controller, name): + super().__init__(controller, name) + + def mousePressed(self, event): + event_name = '{}_click'.format(self._name) + if event.ClickCount == 2: + event_name = '{}_double_click'.format(self._name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def mouseReleased(self, event): + event_name = '{}_after_click'.format(self._name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def mouseEntered(self, event): + pass + + def mouseExited(self, event): + pass + + # ~ XMouseMotionListener + def mouseMoved(self, event): + pass + + def mouseDragged(self, event): + pass + + +class EventsMouseLink(EventsMouse): + + def __init__(self, controller, name): + super().__init__(controller, name) + self._text_color = 0 + + def mouseEntered(self, event): + model = event.Source.Model + self._text_color = model.TextColor or 0 + model.TextColor = get_color('blue') + return + + def mouseExited(self, event): + model = event.Source.Model + model.TextColor = self._text_color + return + + +class EventsButton(EventsListenerBase, XActionListener): + + def __init__(self, controller, name): + super().__init__(controller, name) + + def actionPerformed(self, event): + event_name = f'{self.name}_action' + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + +class EventsFocus(EventsListenerBase, XFocusListener): + CONTROLS = ( + 'stardiv.Toolkit.UnoControlEditModel', + ) + + def __init__(self, controller, name): + super().__init__(controller, name) + + def focusGained(self, event): + service = event.Source.Model.ImplementationName + # ~ print('Focus enter', service) + if service in self.CONTROLS: + obj = event.Source.Model + obj.BackgroundColor = COLOR_ON_FOCUS + return + + def focusLost(self, event): + service = event.Source.Model.ImplementationName + if service in self.CONTROLS: + obj = event.Source.Model + obj.BackgroundColor = -1 + return + + +class EventsKey(EventsListenerBase, XKeyListener): + """ + event.KeyChar + event.KeyCode + event.KeyFunc + event.Modifiers + """ + + def __init__(self, controller, name): + super().__init__(controller, name) + + def keyPressed(self, event): + pass + + def keyReleased(self, event): + event_name = '{}_key_released'.format(self._name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + # ~ else: + # ~ if event.KeyFunc == QUIT and hasattr(self._cls, 'close'): + # ~ self._cls.close() + return + + +class EventsItem(EventsListenerBase, XItemListener): + + def __init__(self, controller, name): + super().__init__(controller, name) + + def disposing(self, event): + pass + + def itemStateChanged(self, event): + event_name = '{}_item_changed'.format(self.name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + +class EventsItemRoadmap(EventsItem): + + def itemStateChanged(self, event): + dialog = event.Source.Context.Model + dialog.Step = event.ItemId + 1 + return + + +class EventsGrid(EventsListenerBase, XGridDataListener, XGridSelectionListener): + + def __init__(self, controller, name): + super().__init__(controller, name) + + def dataChanged(self, event): + event_name = '{}_data_changed'.format(self.name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def rowHeadingChanged(self, event): + pass + + def rowsInserted(self, event): + pass + + def rowsRemoved(self, evemt): + pass + + def selectionChanged(self, event): + event_name = '{}_selection_changed'.format(self.name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + +class EventsMouseGrid(EventsMouse): + selected = False + + def mousePressed(self, event): + super().mousePressed(event) + # ~ obj = event.Source + # ~ col = obj.getColumnAtPoint(event.X, event.Y) + # ~ row = obj.getRowAtPoint(event.X, event.Y) + # ~ print(col, row) + # ~ if col == -1 and row == -1: + # ~ if self.selected: + # ~ obj.deselectAllRows() + # ~ else: + # ~ obj.selectAllRows() + # ~ self.selected = not self.selected + return + + def mouseReleased(self, event): + # ~ obj = event.Source + # ~ col = obj.getColumnAtPoint(event.X, event.Y) + # ~ row = obj.getRowAtPoint(event.X, event.Y) + # ~ if row == -1 and col > -1: + # ~ gdm = obj.Model.GridDataModel + # ~ for i in range(gdm.RowCount): + # ~ gdm.updateRowHeading(i, i + 1) + return + + +class EventsTab(EventsListenerBase, XTabListener): + + def __init__(self, controller, name): + super().__init__(controller, name) + + def activated(self, id): + event_name = '{}_activated'.format(self.name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(id) + return + + +class EventsMenu(EventsListenerBase, XMenuListener): + + def __init__(self, controller): + super().__init__(controller, '') + + def itemHighlighted(self, event): + pass + + def itemSelected(self, event): + name = event.Source.getCommand(event.MenuId) + if name.startswith('menu'): + event_name = '{}_selected'.format(name) + else: + event_name = 'menu_{}_selected'.format(name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def itemActivated(self, event): + return + + def itemDeactivated(self, event): + return + + +class EventsWindow(EventsListenerBase, XTopWindowListener, XWindowListener): + + def __init__(self, cls): + self._cls = cls + super().__init__(cls.events, cls.name, cls._window) + + def windowOpened(self, event): + event_name = '{}_opened'.format(self._name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def windowActivated(self, event): + control_name = '{}_activated'.format(event.Source.Model.Name) + if hasattr(self._controller, control_name): + getattr(self._controller, control_name)(event) + return + + def windowDeactivated(self, event): + control_name = '{}_deactivated'.format(event.Source.Model.Name) + if hasattr(self._controller, control_name): + getattr(self._controller, control_name)(event) + return + + def windowMinimized(self, event): + pass + + def windowNormalized(self, event): + pass + + def windowClosing(self, event): + if self._window: + control_name = 'window_closing' + else: + control_name = '{}_closing'.format(event.Source.Model.Name) + + if hasattr(self._controller, control_name): + getattr(self._controller, control_name)(event) + # ~ else: + # ~ if not self._modal and not self._block: + # ~ event.Source.Visible = False + return + + def windowClosed(self, event): + control_name = '{}_closed'.format(event.Source.Model.Name) + if hasattr(self._controller, control_name): + getattr(self._controller, control_name)(event) + return + + # ~ XWindowListener + def windowResized(self, event): + sb = self._cls._subcont + sb.setPosSize(0, 0, event.Width, event.Height, SIZE) + event_name = '{}_resized'.format(self._name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def windowMoved(self, event): + pass + + def windowShown(self, event): + pass + + def windowHidden(self, event): + pass + + +# ~ BorderColor = ? +# ~ FontStyleName = ? +# ~ HelpURL = ? +class UnoBaseObject(object): + + def __init__(self, obj, path=''): + self._obj = obj + self._model = obj.Model + + def __setattr__(self, name, value): + exists = hasattr(self, name) + if not exists and not name in ('_obj', '_model'): + setattr(self._model, name, value) + else: + super().__setattr__(name, value) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + @property + def obj(self): + return self._obj + + @property + def model(self): + return self._model + @property + def m(self): + return self._model + + @property + def properties(self): + return {} + @properties.setter + def properties(self, values): + _set_properties(self.model, values) + + @property + def name(self): + return self.model.Name + + @property + def parent(self): + return self.obj.Context + + @property + def tag(self): + return self.model.Tag + @tag.setter + def tag(self, value): + self.model.Tag = value + + @property + def visible(self): + return self.obj.Visible + @visible.setter + def visible(self, value): + self.obj.setVisible(value) + + @property + def enabled(self): + return self.model.Enabled + @enabled.setter + def enabled(self, value): + self.model.Enabled = value + + @property + def step(self): + return self.model.Step + @step.setter + def step(self, value): + self.model.Step = value + + @property + def align(self): + return self.model.Align + @align.setter + def align(self, value): + self.model.Align = value + + @property + def valign(self): + return self.model.VerticalAlign + @valign.setter + def valign(self, value): + self.model.VerticalAlign = value + + @property + def font_weight(self): + return self.model.FontWeight + @font_weight.setter + def font_weight(self, value): + self.model.FontWeight = value + + @property + def font_height(self): + return self.model.FontHeight + @font_height.setter + def font_height(self, value): + self.model.FontHeight = value + + @property + def font_name(self): + return self.model.FontName + @font_name.setter + def font_name(self, value): + self.model.FontName = value + + @property + def font_underline(self): + return self.model.FontUnderline + @font_underline.setter + def font_underline(self, value): + self.model.FontUnderline = value + + @property + def text_color(self): + return self.model.TextColor + @text_color.setter + def text_color(self, value): + self.model.TextColor = value + + @property + def back_color(self): + return self.model.BackgroundColor + @back_color.setter + def back_color(self, value): + self.model.BackgroundColor = value + + @property + def multi_line(self): + return self.model.MultiLine + @multi_line.setter + def multi_line(self, value): + self.model.MultiLine = value + + @property + def help_text(self): + return self.model.HelpText + @help_text.setter + def help_text(self, value): + self.model.HelpText = value + + @property + def border(self): + return self.model.Border + @border.setter + def border(self, value): + # ~ Bug for report + self.model.Border = value + + @property + def width(self): + return self._model.Width + @width.setter + def width(self, value): + self.model.Width = value + + @property + def height(self): + return self.model.Height + @height.setter + def height(self, value): + self.model.Height = value + + def _get_possize(self, name): + ps = self.obj.getPosSize() + return getattr(ps, name) + + def _set_possize(self, name, value): + ps = self.obj.getPosSize() + setattr(ps, name, value) + self.obj.setPosSize(ps.X, ps.Y, ps.Width, ps.Height, POSSIZE) + return + + @property + def x(self): + if hasattr(self.model, 'PositionX'): + return self.model.PositionX + return self._get_possize('X') + @x.setter + def x(self, value): + if hasattr(self.model, 'PositionX'): + self.model.PositionX = value + else: + self._set_possize('X', value) + + @property + def y(self): + if hasattr(self.model, 'PositionY'): + return self.model.PositionY + return self._get_possize('Y') + @y.setter + def y(self, value): + if hasattr(self.model, 'PositionY'): + self.model.PositionY = value + else: + self._set_possize('Y', value) + + @property + def tab_index(self): + return self._model.TabIndex + @tab_index.setter + def tab_index(self, value): + self.model.TabIndex = value + + @property + def tab_stop(self): + return self._model.Tabstop + @tab_stop.setter + def tab_stop(self, value): + self.model.Tabstop = value + + @property + def ps(self): + ps = self.obj.getPosSize() + return ps + @ps.setter + def ps(self, ps): + self.obj.setPosSize(ps.X, ps.Y, ps.Width, ps.Height, POSSIZE) + + def set_focus(self): + self.obj.setFocus() + return + + def ps_from(self, source): + self.ps = source.ps + return + + def center(self, horizontal=True, vertical=False): + p = self.parent.Model + w = p.Width + h = p.Height + if horizontal: + x = w / 2 - self.width / 2 + self.x = x + if vertical: + y = h / 2 - self.height / 2 + self.y = y + return + + def move(self, origin, x=0, y=5, center=False): + if x: + self.x = origin.x + origin.width + x + else: + self.x = origin.x + if y: + h = origin.height + if y < 0: + h = 0 + self.y = origin.y + h + y + else: + self.y = origin.y + + if center: + self.center() + return + + +class UnoLabel(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'label' + + @property + def value(self): + return self.model.Label + @value.setter + def value(self, value): + self.model.Label = value + + +class UnoLabelLink(UnoLabel): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'link' + + +class UnoButton(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'button' + + @property + def value(self): + return self.model.Label + @value.setter + def value(self, value): + self.model.Label = value + + @property + def image(self): + return self.model.ImageURL + @image.setter + def image(self, value): + self.model.ImageURL = _P.to_url(value) + + +class UnoRadio(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'radio' + + @property + def value(self): + return self.model.Label + @value.setter + def value(self, value): + self.model.Label = value + + +class UnoCheckBox(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'checkbox' + + @property + def value(self): + return self.model.State + @value.setter + def value(self, value): + self.model.State = value + + @property + def label(self): + return self.model.Label + @label.setter + def label(self, value): + self.model.Label = value + + @property + def tri_state(self): + return self.model.TriState + @tri_state.setter + def tri_state(self, value): + self.model.TriState = value + + +# ~ https://api.libreoffice.org/docs/idl/ref/servicecom_1_1sun_1_1star_1_1awt_1_1UnoControlEditModel.html +class UnoText(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'text' + + @property + def value(self): + return self.model.Text + @value.setter + def value(self, value): + self.model.Text = value + + @property + def echochar(self): + return chr(self.model.EchoChar) + @echochar.setter + def echochar(self, value): + if value: + self.model.EchoChar = ord(value[0]) + else: + self.model.EchoChar = 0 + + def validate(self): + return + + +class UnoImage(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'image' + + @property + def value(self): + return self.url + @value.setter + def value(self, value): + self.url = value + + @property + def url(self): + return self.m.ImageURL + @url.setter + def url(self, value): + self.m.ImageURL = None + self.m.ImageURL = _P.to_url(value) + + +class UnoListBox(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + self._path = '' + + def __setattr__(self, name, value): + if name in ('_path',): + self.__dict__[name] = value + else: + super().__setattr__(name, value) + + @property + def type(self): + return 'listbox' + + @property + def value(self): + return self.obj.getSelectedItem() + + @property + def count(self): + return len(self.data) + + @property + def data(self): + return self.model.StringItemList + @data.setter + def data(self, values): + self.model.StringItemList = list(sorted(values)) + + @property + def path(self): + return self._path + @path.setter + def path(self, value): + self._path = value + + def unselect(self): + self.obj.selectItem(self.value, False) + return + + def select(self, pos=0): + if isinstance(pos, str): + self.obj.selectItem(pos, True) + else: + self.obj.selectItemPos(pos, True) + return + + def clear(self): + self.model.removeAllItems() + return + + def _set_image_url(self, image): + if _P.exists(image): + return _P.to_url(image) + + path = _P.join(self._path, DIR['images'], image) + return _P.to_url(path) + + def insert(self, value, path='', pos=-1, show=True): + if pos < 0: + pos = self.count + if path: + self.model.insertItem(pos, value, self._set_image_url(path)) + else: + self.model.insertItemText(pos, value) + if show: + self.select(pos) + return + + +class UnoRoadmap(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + self._options = () + + def __setattr__(self, name, value): + if name in ('_options',): + self.__dict__[name] = value + else: + super().__setattr__(name, value) + + @property + def options(self): + return self._options + @options.setter + def options(self, values): + self._options = values + for i, v in enumerate(values): + opt = self.model.createInstance() + opt.ID = i + opt.Label = v + self.model.insertByIndex(i, opt) + return + + @property + def enabled(self): + return True + @enabled.setter + def enabled(self, value): + for m in self.model: + m.Enabled = value + return + + def set_enabled(self, index, value): + self.model.getByIndex(index).Enabled = value + return + + +class UnoTree(UnoBaseObject): + + def __init__(self, obj, ): + super().__init__(obj) + self._tdm = None + self._data = [] + + def __setattr__(self, name, value): + if name in ('_tdm', '_data'): + self.__dict__[name] = value + else: + super().__setattr__(name, value) + + @property + def selection(self): + sel = self.obj.Selection + return sel.DataValue, sel.DisplayValue + + @property + def parent(self): + parent = self.obj.Selection.Parent + if parent is None: + return () + return parent.DataValue, parent.DisplayValue + + def _get_parents(self, node): + value = (node.DisplayValue,) + parent = node.Parent + if parent is None: + return value + return self._get_parents(parent) + value + + @property + def parents(self): + values = self._get_parents(self.obj.Selection) + return values + + @property + def root(self): + if self._tdm is None: + return '' + return self._tdm.Root.DisplayValue + @root.setter + def root(self, value): + self._add_data_model(value) + + def _add_data_model(self, name): + tdm = create_instance('com.sun.star.awt.tree.MutableTreeDataModel') + root = tdm.createNode(name, True) + root.DataValue = 0 + tdm.setRoot(root) + self.model.DataModel = tdm + self._tdm = self.model.DataModel + return + + @property + def path(self): + return self.root + @path.setter + def path(self, value): + self.data = _P.walk_dir(value, True) + + @property + def data(self): + return self._data + @data.setter + def data(self, values): + self._data = list(values) + self._add_data() + + def _add_data(self): + if not self.data: + return + + parents = {} + for node in self.data: + parent = parents.get(node[1], self._tdm.Root) + child = self._tdm.createNode(node[2], False) + child.DataValue = node[0] + parent.appendChild(child) + parents[node[0]] = child + self.obj.expandNode(self._tdm.Root) + return + + +# ~ https://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1awt_1_1grid.html +class UnoGrid(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + self._gdm = self.model.GridDataModel + self._data = [] + self._formats = () + + def __setattr__(self, name, value): + if name in ('_gdm', '_data', '_formats'): + self.__dict__[name] = value + else: + super().__setattr__(name, value) + + def __getitem__(self, key): + value = self._gdm.getCellData(key[0], key[1]) + return value + + def __setitem__(self, key, value): + self._gdm.updateCellData(key[0], key[1], value) + return + + @property + def type(self): + return 'grid' + + @property + def columns(self): + return {} + @columns.setter + def columns(self, values): + # ~ self._columns = values + #~ https://api.libreoffice.org/docs/idl/ref/interfacecom_1_1sun_1_1star_1_1awt_1_1grid_1_1XGridColumn.html + model = create_instance('com.sun.star.awt.grid.DefaultGridColumnModel', True) + for properties in values: + column = create_instance('com.sun.star.awt.grid.GridColumn', True) + for k, v in properties.items(): + setattr(column, k, v) + model.addColumn(column) + self.model.ColumnModel = model + return + + @property + def data(self): + return self._data + @data.setter + def data(self, values): + self._data = values + self.clear() + headings = tuple(range(1, len(values) + 1)) + self._gdm.addRows(headings, values) + # ~ rows = range(grid_dm.RowCount) + # ~ colors = [COLORS['GRAY'] if r % 2 else COLORS['WHITE'] for r in rows] + # ~ grid.Model.RowBackgroundColors = tuple(colors) + return + + @property + def value(self): + if self.column == -1 or self.row == -1: + return '' + return self[self.column, self.row] + @value.setter + def value(self, value): + if self.column > -1 and self.row > -1: + self[self.column, self.row] = value + + @property + def row(self): + return self.obj.CurrentRow + + @property + def row_count(self): + return self._gdm.RowCount + + @property + def column(self): + return self.obj.CurrentColumn + + @property + def column(self): + return self.obj.CurrentColumn + + @property + def is_valid(self): + return not (self.row == -1 or self.column == -1) + + @property + def formats(self): + return self._formats + @formats.setter + def formats(self, values): + self._formats = values + + def clear(self): + self._gdm.removeAllRows() + return + + def _format_columns(self, data): + row = data + if self.formats: + for i, f in enumerate(formats): + if f: + row[i] = f.format(data[i]) + return row + + def add_row(self, data): + self._data.append(data) + row = self._format_columns(data) + self._gdm.addRow(self.row_count + 1, row) + return + + def set_cell_tooltip(self, col, row, value): + self._gdm.updateCellToolTip(col, row, value) + return + + def get_cell_tooltip(self, col, row): + value = self._gdm.getCellToolTip(col, row) + return value + + def sort(self, column, asc=True): + self._gdm.sortByColumn(column, asc) + self.update_row_heading() + return + + def update_row_heading(self): + for i in range(self.row_count): + self._gdm.updateRowHeading(i, i + 1) + return + + def remove_row(self, row): + self._gdm.removeRow(row) + del self._data[row] + self.update_row_heading() + return + + +class UnoPage(object): + + def __init__(self, obj): + self._obj = obj + self._events = None + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + @property + def obj(self): + return self._obj + + @property + def model(self): + return self._obj.Model + + # ~ @property + # ~ def id(self): + # ~ return self.m.TabPageID + + @property + def parent(self): + return self.obj.Context + + def _set_image_url(self, image): + if _P.exists(image): + return _P.to_url(image) + + path = _P.join(self._path, DIR['images'], image) + return _P.to_url(path) + + def _special_properties(self, tipo, args): + if tipo == 'link' and not 'Label' in args: + args['Label'] = args['URL'] + return args + + if tipo == 'button': + if 'ImageURL' in args: + args['ImageURL'] = self._set_image_url(args['ImageURL']) + args['FocusOnClick'] = args.get('FocusOnClick', False) + return args + + if tipo == 'roadmap': + args['Height'] = args.get('Height', self.height) + if 'Title' in args: + args['Text'] = args.pop('Title') + return args + + if tipo == 'tree': + args['SelectionType'] = args.get('SelectionType', SINGLE) + return args + + if tipo == 'grid': + args['ShowRowHeader'] = args.get('ShowRowHeader', True) + return args + + if tipo == 'pages': + args['Width'] = args.get('Width', self.width) + args['Height'] = args.get('Height', self.height) + + return args + + def add_control(self, args): + tipo = args.pop('Type').lower() + root = args.pop('Root', '') + sheets = args.pop('Sheets', ()) + columns = args.pop('Columns', ()) + + args = self._special_properties(tipo, args) + model = self.model.createInstance(UNO_MODELS[tipo]) + _set_properties(model, args) + name = args['Name'] + self.model.insertByName(name, model) + control = self.obj.getControl(name) + _add_listeners(self._events, control, name) + control = UNO_CLASSES[tipo](control) + + if tipo in ('listbox',): + control.path = self.path + + if tipo == 'tree' and root: + control.root = root + elif tipo == 'grid' and columns: + control.columns = columns + elif tipo == 'pages' and sheets: + control.sheets = sheets + control.events = self.events + + setattr(self, name, control) + return control + + +class UnoPages(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + self._sheets = [] + self._events = None + + def __setattr__(self, name, value): + if name in ('_sheets', '_events'): + self.__dict__[name] = value + else: + super().__setattr__(name, value) + + def __getitem__(self, index): + name = index + if isinstance(index, int): + name = f'sheet{index}' + sheet = self.obj.getControl(name) + page = UnoPage(sheet) + page._events = self._events + return page + + @property + def type(self): + return 'pages' + + @property + def current(self): + return self.obj.ActiveTabID + @property + def active(self): + return self.current + + @property + def sheets(self): + return self._sheets + @sheets.setter + def sheets(self, values): + self._sheets = values + for i, title in enumerate(values): + sheet = self.m.createInstance('com.sun.star.awt.UnoPageModel') + sheet.Title = title + self.m.insertByName(f'sheet{i + 1}', sheet) + return + + @property + def events(self): + return self._events + @events.setter + def events(self, controllers): + self._events = controllers + + @property + def visible(self): + return self.obj.Visible + @visible.setter + def visible(self, value): + self.obj.Visible = value + + def insert(self, title): + self._sheets.append(title) + id = len(self._sheets) + sheet = self.m.createInstance('com.sun.star.awt.UnoPageModel') + sheet.Title = title + self.m.insertByName(f'sheet{id}', sheet) + return self[id] + + def remove(self, id): + self.obj.removeTab(id) + return + + def activate(self, id): + self.obj.activateTab(id) + return + + +class UnoSpinButton(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'spinbutton' + + @property + def value(self): + return self.model.Label + @value.setter + def value(self, value): + self.model.Label = value + + +class UnoNumericField(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'numeric' + + @property + def int(self): + return int(self.value) + + @property + def value(self): + return self.model.Value + @value.setter + def value(self, value): + self.model.Value = value + + +UNO_CLASSES = { + 'label': UnoLabel, + 'link': UnoLabelLink, + 'button': UnoButton, + 'radio': UnoRadio, + 'checkbox': UnoCheckBox, + 'text': UnoText, + 'image': UnoImage, + 'listbox': UnoListBox, + 'roadmap': UnoRoadmap, + 'tree': UnoTree, + 'grid': UnoGrid, + 'pages': UnoPages, + 'spinbutton': UnoSpinButton, + 'numeric': UnoNumericField, +} + +UNO_MODELS = { + 'label': 'com.sun.star.awt.UnoControlFixedTextModel', + 'link': 'com.sun.star.awt.UnoControlFixedHyperlinkModel', + 'button': 'com.sun.star.awt.UnoControlButtonModel', + 'radio': 'com.sun.star.awt.UnoControlRadioButtonModel', + 'checkbox': 'com.sun.star.awt.UnoControlCheckBoxModel', + 'text': 'com.sun.star.awt.UnoControlEditModel', + 'image': 'com.sun.star.awt.UnoControlImageControlModel', + 'listbox': 'com.sun.star.awt.UnoControlListBoxModel', + 'roadmap': 'com.sun.star.awt.UnoControlRoadmapModel', + 'tree': 'com.sun.star.awt.tree.TreeControlModel', + 'grid': 'com.sun.star.awt.grid.UnoControlGridModel', + 'pages': 'com.sun.star.awt.UnoMultiPageModel', + 'groupbox': 'com.sun.star.awt.UnoControlGroupBoxModel', + 'combobox': 'com.sun.star.awt.UnoControlComboBoxModel', + 'spinbutton': 'com.sun.star.awt.UnoControlSpinButtonModel', + 'numeric': 'com.sun.star.awt.UnoControlNumericFieldModel', +} +# ~ 'CurrencyField': 'com.sun.star.awt.UnoControlCurrencyFieldModel', +# ~ 'DateField': 'com.sun.star.awt.UnoControlDateFieldModel', +# ~ 'FileControl': 'com.sun.star.awt.UnoControlFileControlModel', +# ~ 'FormattedField': 'com.sun.star.awt.UnoControlFormattedFieldModel', +# ~ 'PatternField': 'com.sun.star.awt.UnoControlPatternFieldModel', +# ~ 'ProgressBar': 'com.sun.star.awt.UnoControlProgressBarModel', +# ~ 'ScrollBar': 'com.sun.star.awt.UnoControlScrollBarModel', +# ~ 'SimpleAnimation': 'com.sun.star.awt.UnoControlSimpleAnimationModel', +# ~ 'Throbber': 'com.sun.star.awt.UnoControlThrobberModel', +# ~ 'TimeField': 'com.sun.star.awt.UnoControlTimeFieldModel', + + +class LODialog(object): + SEPARATION = 5 + MODELS = { + 'label': 'com.sun.star.awt.UnoControlFixedTextModel', + 'link': 'com.sun.star.awt.UnoControlFixedHyperlinkModel', + 'button': 'com.sun.star.awt.UnoControlButtonModel', + 'radio': 'com.sun.star.awt.UnoControlRadioButtonModel', + 'checkbox': 'com.sun.star.awt.UnoControlCheckBoxModel', + 'text': 'com.sun.star.awt.UnoControlEditModel', + 'image': 'com.sun.star.awt.UnoControlImageControlModel', + 'listbox': 'com.sun.star.awt.UnoControlListBoxModel', + 'roadmap': 'com.sun.star.awt.UnoControlRoadmapModel', + 'tree': 'com.sun.star.awt.tree.TreeControlModel', + 'grid': 'com.sun.star.awt.grid.UnoControlGridModel', + 'pages': 'com.sun.star.awt.UnoMultiPageModel', + 'groupbox': 'com.sun.star.awt.UnoControlGroupBoxModel', + 'combobox': 'com.sun.star.awt.UnoControlComboBoxModel', + 'spinbutton': 'com.sun.star.awt.UnoControlSpinButtonModel', + 'numeric': 'com.sun.star.awt.UnoControlNumericFieldModel', + } + + def __init__(self, args): + self._obj = self._create(args) + self._model = self.obj.Model + self._events = None + self._modal = True + self._controls = {} + self._color_on_focus = COLOR_ON_FOCUS + self._id = '' + self._path = '' + self._init_controls() + + def _create(self, args): + service = 'com.sun.star.awt.DialogProvider' + path = args.pop('Path', '') + if path: + dp = create_instance(service, True) + dlg = dp.createDialog(_P.to_url(path)) + return dlg + + if 'Location' in args: + name = args['Name'] + library = args.get('Library', 'Standard') + location = args.get('Location', 'application').lower() + if location == 'user': + location = 'application' + url = f'vnd.sun.star.script:{library}.{name}?location={location}' + if location == 'document': + dp = create_instance(service, args=docs.active.obj) + else: + dp = create_instance(service, True) + # ~ uid = docs.active.uid + # ~ url = f'vnd.sun.star.tdoc:/{uid}/Dialogs/{library}/{name}.xml' + dlg = dp.createDialog(url) + return dlg + + dlg = create_instance('com.sun.star.awt.UnoControlDialog', True) + model = create_instance('com.sun.star.awt.UnoControlDialogModel', True) + toolkit = create_instance('com.sun.star.awt.Toolkit', True) + _set_properties(model, args) + dlg.setModel(model) + dlg.setVisible(False) + dlg.createPeer(toolkit, None) + return dlg + + def _get_type_control(self, name): + name = name.split('.')[2] + types = { + 'UnoFixedTextControl': 'label', + 'UnoEditControl': 'text', + 'UnoButtonControl': 'button', + } + return types[name] + + def _init_controls(self): + for control in self.obj.getControls(): + tipo = self._get_type_control(control.ImplementationName) + name = control.Model.Name + control = UNO_CLASSES[tipo](control) + setattr(self, name, control) + return + + @property + def obj(self): + return self._obj + + @property + def model(self): + return self._model + + @property + def controls(self): + return self._controls + + @property + def path(self): + return self._path + @property + def path_images(self): + return _P.join(self.path, DIR['images']) + @property + def id(self): + return self._id + @id.setter + def id(self, value): + self._id = value + self._path = _P.from_id(value) + + @property + def height(self): + return self.model.Height + @height.setter + def height(self, value): + self.model.Height = value + + @property + def width(self): + return self.model.Width + @width.setter + def width(self, value): + self.model.Width = value + + @property + def visible(self): + return self.obj.Visible + @visible.setter + def visible(self, value): + self.obj.Visible = value + + @property + def step(self): + return self.model.Step + @step.setter + def step(self, value): + self.model.Step = value + + @property + def events(self): + return self._events + @events.setter + def events(self, controllers): + self._events = controllers(self) + self._connect_listeners() + + @property + def color_on_focus(self): + return self._color_on_focus + @color_on_focus.setter + def color_on_focus(self, value): + self._color_on_focus = get_color(value) + + def _connect_listeners(self): + for control in self.obj.Controls: + _add_listeners(self.events, control, control.Model.Name) + return + + def _set_image_url(self, image): + if _P.exists(image): + return _P.to_url(image) + + path = _P.join(self._path, DIR['images'], image) + return _P.to_url(path) + + def _special_properties(self, tipo, args): + if tipo == 'link' and not 'Label' in args: + args['Label'] = args['URL'] + return args + + if tipo == 'button': + if 'ImageURL' in args: + args['ImageURL'] = self._set_image_url(args['ImageURL']) + args['FocusOnClick'] = args.get('FocusOnClick', False) + return args + + if tipo == 'roadmap': + args['Height'] = args.get('Height', self.height) + if 'Title' in args: + args['Text'] = args.pop('Title') + return args + + if tipo == 'tree': + args['SelectionType'] = args.get('SelectionType', SINGLE) + return args + + if tipo == 'grid': + args['ShowRowHeader'] = args.get('ShowRowHeader', True) + return args + + if tipo == 'pages': + args['Width'] = args.get('Width', self.width) + args['Height'] = args.get('Height', self.height) + + return args + + def add_control(self, args): + tipo = args.pop('Type').lower() + root = args.pop('Root', '') + sheets = args.pop('Sheets', ()) + columns = args.pop('Columns', ()) + + args = self._special_properties(tipo, args) + model = self.model.createInstance(self.MODELS[tipo]) + _set_properties(model, args) + name = args['Name'] + self.model.insertByName(name, model) + control = self.obj.getControl(name) + _add_listeners(self.events, control, name) + control = UNO_CLASSES[tipo](control) + + if tipo in ('listbox',): + control.path = self.path + + if tipo == 'tree' and root: + control.root = root + elif tipo == 'grid' and columns: + control.columns = columns + elif tipo == 'pages' and sheets: + control.sheets = sheets + control.events = self.events + + setattr(self, name, control) + self._controls[name] = control + return control + + def center(self, control, x=0, y=0): + w = self.width + h = self.height + + if isinstance(control, tuple): + wt = self.SEPARATION * -1 + for c in control: + wt += c.width + self.SEPARATION + x = w / 2 - wt / 2 + for c in control: + c.x = x + x = c.x + c.width + self.SEPARATION + return + + if x < 0: + x = w + x - control.width + elif x == 0: + x = w / 2 - control.width / 2 + if y < 0: + y = h + y - control.height + elif y == 0: + y = h / 2 - control.height / 2 + control.x = x + control.y = y + return + + def open(self, modal=True): + self._modal = modal + if modal: + return self.obj.execute() + else: + self.visible = True + return + + def close(self, value=0): + if self._modal: + value = self.obj.endDialog(value) + else: + self.visible = False + self.obj.dispose() + return value + + def set_values(self, data): + for k, v in data.items(): + self._controls[k].value = v + return + + +class LOSheets(object): + + def __getitem__(self, index): + return LODocs().active[index] + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + +class LOCells(object): + + def __getitem__(self, index): + return LODocs().active.active[index] + + +class LOShortCut(object): +# ~ getKeyEventsByCommand + + def __init__(self, app): + self._app = app + self._scm = None + self._init_values() + + def _init_values(self): + name = 'com.sun.star.ui.GlobalAcceleratorConfiguration' + instance = 'com.sun.star.ui.ModuleUIConfigurationManagerSupplier' + service = TYPE_DOC[self._app] + manager = create_instance(instance, True) + uicm = manager.getUIConfigurationManager(service) + self._scm = uicm.ShortCutManager + return + + def __contains__(self, item): + cmd = self._get_command(item) + return bool(cmd) + + def _get_key_event(self, command): + events = self._scm.AllKeyEvents + for event in events: + cmd = self._scm.getCommandByKeyEvent(event) + if cmd == command: + break + return event + + def _to_key_event(self, shortcut): + key_event = KeyEvent() + keys = shortcut.split('+') + for v in keys[:-1]: + key_event.Modifiers += MODIFIERS[v.lower()] + key_event.KeyCode = getattr(Key, keys[-1].upper()) + return key_event + + def _get_command(self, shortcut): + command = '' + key_event = self._to_key_event(shortcut) + try: + command = self._scm.getCommandByKeyEvent(key_event) + except NoSuchElementException: + debug(f'No exists: {shortcut}') + return command + + def add(self, shortcut, command): + if isinstance(command, dict): + command = _get_url_script(command) + key_event = self._to_key_event(shortcut) + self._scm.setKeyEvent(key_event, command) + self._scm.store() + return + + def reset(self): + self._scm.reset() + self._scm.store() + return + + def remove(self, shortcut): + key_event = self._to_key_event(shortcut) + try: + self._scm.removeKeyEvent(key_event) + self._scm.store() + except NoSuchElementException: + debug(f'No exists: {shortcut}') + return + + def remove_by_command(self, command): + if isinstance(command, dict): + command = _get_url_script(command) + try: + self._scm.removeCommandFromAllKeyEvents(command) + self._scm.store() + except NoSuchElementException: + debug(f'No exists: {command}') + return + + +class LOShortCuts(object): + + def __getitem__(self, index): + return LOShortCut(index) + + +class LOMenu(object): + + def __init__(self, app): + self._app = app + self._ui = None + self._pymenus = None + self._menu = None + self._menus = self._get_menus() + + def __getitem__(self, index): + if isinstance(index, int): + self._menu = self._menus[index] + else: + for menu in self._menus: + cmd = menu.get('CommandURL', '') + if MENUS[index.lower()] == cmd: + self._menu = menu + break + # ~ line = self._menu.get('CommandURL', '') + # ~ line += self._get_submenus(self._menu['ItemDescriptorContainer']) + return self._menu + + def _get_menus(self): + instance = 'com.sun.star.ui.ModuleUIConfigurationManagerSupplier' + service = TYPE_DOC[self._app] + manager = create_instance(instance, True) + self._ui = manager.getUIConfigurationManager(service) + self._pymenus = self._ui.getSettings(NODE_MENUBAR, True) + data = [] + for menu in self._pymenus: + data.append(data_to_dict(menu)) + return data + + def _get_info(self, menu): + line = menu.get('CommandURL', '') + line += self._get_submenus(menu['ItemDescriptorContainer']) + return line + + def _get_submenus(self, menu, level=1): + line = '' + for i, v in enumerate(menu): + data = data_to_dict(v) + cmd = data.get('CommandURL', '----------') + line += f'\n{" " * level}├─ ({i}) {cmd}' + submenu = data.get('ItemDescriptorContainer', None) + if not submenu is None: + line += self._get_submenus(submenu, level + 1) + return line + + def __str__(self): + info = '\n'.join([self._get_info(m) for m in self._menus]) + return info + + def _get_index_menu(self, menu, command): + index = -1 + for i, v in enumerate(menu): + data = data_to_dict(v) + cmd = data.get('CommandURL', '') + if cmd == command: + index = i + break + return index + + def insert(self, name, args): + idc = None + replace = False + command = args['CommandURL'] + label = args['Label'] + + self[name] + menu = self._menu['ItemDescriptorContainer'] + submenu = args.get('Submenu', False) + if submenu: + idc = self._ui.createSettings() + + index = self._get_index_menu(menu, command) + if index == -1: + if 'Index' in args: + index = args['Index'] + else: + index = self._get_index_menu(menu, args['After']) + 1 + else: + replace = True + + data = dict ( + CommandURL = command, + Label = label, + Style = 0, + Type = 0, + ItemDescriptorContainer = idc, + ) + self._save(menu, data, index, replace) + self._insert_submenu(idc, submenu) + return + + def _get_command(self, args): + shortcut = args.get('ShortCut', '') + cmd = args['CommandURL'] + if isinstance(cmd, dict): + cmd = _get_url_script(cmd) + if shortcut: + LOShortCut(self._app).add(shortcut, cmd) + return cmd + + def _insert_submenu(self, parent, menus): + for i, v in enumerate(menus): + submenu = v.pop('Submenu', False) + if submenu: + idc = self._ui.createSettings() + v['ItemDescriptorContainer'] = idc + v['Type'] = 0 + if v['Label'] == '-': + v['Type'] = 1 + else: + v['CommandURL'] = self._get_command(v) + self._save(parent, v, i) + if submenu: + self._insert_submenu(idc, submenu) + return + + def remove(self, name, command): + self[name] + menu = self._menu['ItemDescriptorContainer'] + index = self._get_index_menu(menu, command) + if index > -1: + uno.invoke(menu, 'removeByIndex', (index,)) + self._ui.replaceSettings(NODE_MENUBAR, self._pymenus) + self._ui.store() + return + + def _save(self, menu, properties, index, replace=False): + properties = dict_to_property(properties, True) + if replace: + uno.invoke(menu, 'replaceByIndex', (index, properties)) + else: + uno.invoke(menu, 'insertByIndex', (index, properties)) + self._ui.replaceSettings(NODE_MENUBAR, self._pymenus) + self._ui.store() + return + + +class LOMenus(object): + + def __getitem__(self, index): + return LOMenu(index) + + +class LOWindow(object): + EMPTY = """ + +""" + MODELS = { + 'label': 'com.sun.star.awt.UnoControlFixedTextModel', + 'link': 'com.sun.star.awt.UnoControlFixedHyperlinkModel', + 'button': 'com.sun.star.awt.UnoControlButtonModel', + 'radio': 'com.sun.star.awt.UnoControlRadioButtonModel', + 'checkbox': 'com.sun.star.awt.UnoControlCheckBoxModel', + 'text': 'com.sun.star.awt.UnoControlEditModel', + 'image': 'com.sun.star.awt.UnoControlImageControlModel', + 'listbox': 'com.sun.star.awt.UnoControlListBoxModel', + 'roadmap': 'com.sun.star.awt.UnoControlRoadmapModel', + 'tree': 'com.sun.star.awt.tree.TreeControlModel', + 'grid': 'com.sun.star.awt.grid.UnoControlGridModel', + 'pages': 'com.sun.star.awt.UnoMultiPageModel', + 'groupbox': 'com.sun.star.awt.UnoControlGroupBoxModel', + 'combobox': 'com.sun.star.awt.UnoControlComboBoxModel', + } + + def __init__(self, args): + self._events = None + self._menu = None + self._container = None + self._model = None + self._id = '' + self._path = '' + self._obj = self._create(args) + + def _create(self, properties): + ps = ( + properties.get('X', 0), + properties.get('Y', 0), + properties.get('Width', 500), + properties.get('Height', 500), + ) + self._title = properties.get('Title', TITLE) + self._create_frame(ps) + self._create_container(ps) + self._create_subcontainer(ps) + # ~ self._create_splitter(ps) + return + + def _create_frame(self, ps): + service = 'com.sun.star.frame.TaskCreator' + tc = create_instance(service, True) + self._frame = tc.createInstanceWithArguments(( + NamedValue('FrameName', 'EasyMacroWin'), + NamedValue('PosSize', Rectangle(*ps)), + )) + self._window = self._frame.getContainerWindow() + self._toolkit = self._window.getToolkit() + desktop = get_desktop() + self._frame.setCreator(desktop) + desktop.getFrames().append(self._frame) + self._frame.Title = self._title + return + + def _create_container(self, ps): + service = 'com.sun.star.awt.UnoControlContainer' + self._container = create_instance(service, True) + service = 'com.sun.star.awt.UnoControlContainerModel' + model = create_instance(service, True) + model.BackgroundColor = get_color((225, 225, 225)) + self._container.setModel(model) + self._container.createPeer(self._toolkit, self._window) + self._container.setPosSize(*ps, POSSIZE) + self._frame.setComponent(self._container, None) + return + + def _create_subcontainer(self, ps): + service = 'com.sun.star.awt.ContainerWindowProvider' + cwp = create_instance(service, True) + + path_tmp = _P.save_tmp(self.EMPTY) + subcont = cwp.createContainerWindow( + _P.to_url(path_tmp), '', self._container.getPeer(), None) + _P.kill(path_tmp) + + subcont.setPosSize(0, 0, 500, 500, POSSIZE) + subcont.setVisible(True) + self._container.addControl('subcont', subcont) + self._subcont = subcont + self._model = subcont.Model + return + + def _create_popupmenu(self, menus): + menu = create_instance('com.sun.star.awt.PopupMenu', True) + for i, m in enumerate(menus): + label = m['label'] + cmd = m.get('event', '') + if not cmd: + cmd = label.lower().replace(' ', '_') + if label == '-': + menu.insertSeparator(i) + else: + menu.insertItem(i, label, m.get('style', 0), i) + menu.setCommand(i, cmd) + # ~ menu.setItemImage(i, path?, True) + menu.addMenuListener(EventsMenu(self.events)) + return menu + + def _create_menu(self, menus): + #~ https://api.libreoffice.org/docs/idl/ref/interfacecom_1_1sun_1_1star_1_1awt_1_1XMenu.html + #~ nItemId specifies the ID of the menu item to be inserted. + #~ aText specifies the label of the menu item. + #~ nItemStyle 0 = Standard, CHECKABLE = 1, RADIOCHECK = 2, AUTOCHECK = 4 + #~ nItemPos specifies the position where the menu item will be inserted. + self._menu = create_instance('com.sun.star.awt.MenuBar', True) + for i, m in enumerate(menus): + self._menu.insertItem(i, m['label'], m.get('style', 0), i) + cmd = m['label'].lower().replace(' ', '_') + self._menu.setCommand(i, cmd) + submenu = self._create_popupmenu(m['submenu']) + self._menu.setPopupMenu(i, submenu) + + self._window.setMenuBar(self._menu) + return + + def _add_listeners(self, control=None): + if self.events is None: + return + controller = EventsWindow(self) + self._window.addTopWindowListener(controller) + self._window.addWindowListener(controller) + # ~ self._container.addKeyListener(EventsKeyWindow(self)) + return + + def _set_image_url(self, image): + if _P.exists(image): + return _P.to_url(image) + + path = _P.join(self._path, DIR['images'], image) + return _P.to_url(path) + + def _special_properties(self, tipo, args): + if tipo == 'link' and not 'Label' in args: + args['Label'] = args['URL'] + return args + + if tipo == 'button': + if 'ImageURL' in args: + args['ImageURL'] = self._set_image_url(args['ImageURL']) + args['FocusOnClick'] = args.get('FocusOnClick', False) + return args + + if tipo == 'roadmap': + args['Height'] = args.get('Height', self.height) + if 'Title' in args: + args['Text'] = args.pop('Title') + return args + + if tipo == 'tree': + args['SelectionType'] = args.get('SelectionType', SINGLE) + return args + + if tipo == 'grid': + args['ShowRowHeader'] = args.get('ShowRowHeader', True) + return args + + if tipo == 'pages': + args['Width'] = args.get('Width', self.width) + args['Height'] = args.get('Height', self.height) + + return args + + def add_control(self, args): + tipo = args.pop('Type').lower() + root = args.pop('Root', '') + sheets = args.pop('Sheets', ()) + columns = args.pop('Columns', ()) + + args = self._special_properties(tipo, args) + model = self.model.createInstance(self.MODELS[tipo]) + _set_properties(model, args) + name = args['Name'] + self.model.insertByName(name, model) + control = self._subcont.getControl(name) + _add_listeners(self.events, control, name) + control = UNO_CLASSES[tipo](control) + + # ~ if tipo in ('listbox',): + # ~ control.path = self.path + + if tipo == 'tree' and root: + control.root = root + elif tipo == 'grid' and columns: + control.columns = columns + elif tipo == 'pages' and sheets: + control.sheets = sheets + control.events = self.events + + setattr(self, name, control) + return control + + @property + def events(self): + return self._events + @events.setter + def events(self, controllers): + self._events = controllers(self) + self._add_listeners() + + @property + def model(self): + return self._model + + @property + def width(self): + return self._container.Size.Width + + @property + def height(self): + return self._container.Size.Height + + @property + def name(self): + return self._title.lower().replace(' ', '_') + + def add_menu(self, menus): + self._create_menu(menus) + return + + def open(self): + self._window.setVisible(True) + return + + def close(self): + self._window.setMenuBar(None) + self._window.dispose() + self._frame.close(True) + return + + +class LODBServer(object): + DRIVERS = { + 'mysql': 'mysqlc', + 'mariadb': 'mysqlc', + 'postgres': 'postgresql:postgresql', + } + PORTS = { + 'mysql': 3306, + 'mariadb': 3306, + 'postgres': 5432, + } + + def __init__(self): + self._conn = None + self._error = 'Not connected' + self._type = '' + self._drivers = [] + + def __str__(self): + return f'DB type {self._type}' + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + self.disconnet() + + @property + def is_connected(self): + return not self._conn is None + + @property + def error(self): + return self._error + + @property + def drivers(self): + return self._drivers + + def disconnet(self): + if not self._conn is None: + if not self._conn.isClosed(): + self._conn.close() + self._conn.dispose() + return + + def connect(self, options={}): + args = options.copy() + self._error = '' + self._type = args.get('type', 'postgres') + driver = self.DRIVERS[self._type] + server = args.get('server', 'localhost') + port = args.get('port', self.PORTS[self._type]) + dbname = args.get('dbname', '') + user = args['user'] + password = args['password'] + + data = {'user': user, 'password': password} + url = f'sdbc:{driver}:{server}:{port}/{dbname}' + + # ~ https://downloads.mariadb.com/Connectors/java/ + # ~ data['JavaDriverClass'] = 'org.mariadb.jdbc.Driver' + # ~ url = f'jdbc:mysql://{server}:{port}/{dbname}' + + args = dict_to_property(data) + manager = create_instance('com.sun.star.sdbc.DriverManager') + self._drivers = [d.ImplementationName for d in manager] + + try: + self._conn = manager.getConnectionWithInfo(url, args) + except Exception as e: + error(e) + self._error = str(e) + + return self + + def execute(self, sql): + query = self._conn.createStatement() + try: + query.execute(sql) + result = True + except Exception as e: + error(e) + self._error = str(e) + result = False + + return result + + +def create_window(args): + return LOWindow(args) + + +class classproperty: + def __init__(self, method=None): + self.fget = method + + def __get__(self, instance, cls=None): + return self.fget(cls) + + def getter(self, method): + self.fget = method + return self + + +class ClipBoard(object): + SERVICE = 'com.sun.star.datatransfer.clipboard.SystemClipboard' + CLIPBOARD_FORMAT_TEXT = 'text/plain;charset=utf-16' + + class TextTransferable(unohelper.Base, XTransferable): + + def __init__(self, text): + df = DataFlavor() + df.MimeType = ClipBoard.CLIPBOARD_FORMAT_TEXT + df.HumanPresentableName = "encoded text utf-16" + self.flavors = (df,) + self._data = text + + def getTransferData(self, flavor): + return self._data + + def getTransferDataFlavors(self): + return self.flavors + + + @classmethod + def set(cls, value): + ts = cls.TextTransferable(value) + sc = create_instance(cls.SERVICE) + sc.setContents(ts, None) + return + + @classproperty + def contents(cls): + df = None + text = '' + sc = create_instance(cls.SERVICE) + transferable = sc.getContents() + data = transferable.getTransferDataFlavors() + for df in data: + if df.MimeType == cls.CLIPBOARD_FORMAT_TEXT: + break + if df: + text = transferable.getTransferData(df) + return text +_CB = ClipBoard + + +class Paths(object): + FILE_PICKER = 'com.sun.star.ui.dialogs.FilePicker' + FOLDER_PICKER = 'com.sun.star.ui.dialogs.FolderPicker' + + def __init__(self, path=''): + if path.startswith('file://'): + path = str(Path(uno.fileUrlToSystemPath(path)).resolve()) + self._path = Path(path) + + @property + def path(self): + return str(self._path.parent) + + @property + def file_name(self): + return self._path.name + + @property + def name(self): + return self._path.stem + + @property + def ext(self): + return self._path.suffix[1:] + + @property + def info(self): + return self.path, self.file_name, self.name, self.ext + + @property + def url(self): + return self._path.as_uri() + + @property + def size(self): + return self._path.stat().st_size + + @classproperty + def home(self): + return str(Path.home()) + + @classproperty + def documents(self): + return self.config() + + @classproperty + def temp_dir(self): + return tempfile.gettempdir() + + @classproperty + def python(self): + if IS_WIN: + path = self.join(self.config('Module'), PYTHON) + elif IS_MAC: + path = self.join(self.config('Module'), '..', 'Resources', PYTHON) + else: + path = sys.executable + return path + + @classproperty + def user_profile(self): + path = self.config('UserConfig') + path = str(Path(path).parent) + return path + + @classproperty + def user_config(self): + path = self.config('UserConfig') + return path + + @classmethod + def dir_tmp(self, only_name=False): + dt = tempfile.TemporaryDirectory() + if only_name: + dt = dt.name + return dt + + @classmethod + def tmp(cls, ext=''): + tmp = tempfile.NamedTemporaryFile(suffix=ext) + return tmp.name + + @classmethod + def save_tmp(cls, data): + path_tmp = cls.tmp() + cls.save(path_tmp, data) + return path_tmp + + @classmethod + def config(cls, name='Work'): + """ + Return path from config + http://api.libreoffice.org/docs/idl/ref/interfacecom_1_1sun_1_1star_1_1util_1_1XPathSettings.html + """ + path = create_instance('com.sun.star.util.PathSettings') + path = cls.to_system(getattr(path, name)) + return path + + @classmethod + def get(cls, init_dir='', filters: str=''): + """ + Get path for save + Options: http://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1ui_1_1dialogs_1_1TemplateDescription.html + filters: 'xml' or 'txt,xml' + """ + if not init_dir: + init_dir = cls.documents + init_dir = cls.to_url(init_dir) + file_picker = create_instance(cls.FILE_PICKER) + file_picker.setTitle(_('Select path')) + file_picker.setDisplayDirectory(init_dir) + file_picker.initialize((2,)) + if filters: + filters = [(f.upper(), f'*.{f.lower()}') for f in filters.split(',')] + file_picker.setCurrentFilter(filters[0][0]) + for f in filters: + file_picker.appendFilter(f[0], f[1]) + + path = '' + if file_picker.execute(): + path = cls.to_system(file_picker.getSelectedFiles()[0]) + return path + + @classmethod + def get_dir(cls, init_dir=''): + folder_picker = create_instance(cls.FOLDER_PICKER) + if not init_dir: + init_dir = cls.documents + init_dir = cls.to_url(init_dir) + folder_picker.setTitle(_('Select directory')) + folder_picker.setDisplayDirectory(init_dir) + + path = '' + if folder_picker.execute(): + path = cls.to_system(folder_picker.getDirectory()) + return path + + @classmethod + def get_file(cls, init_dir: str='', filters: str='', multiple: bool=False): + """ + Get path file + + init_folder: folder default open + filters: 'xml' or 'xml,txt' + multiple: True for multiple selected + """ + if not init_dir: + init_dir = cls.documents + init_dir = cls.to_url(init_dir) + + file_picker = create_instance(cls.FILE_PICKER) + file_picker.setTitle(_('Select file')) + file_picker.setDisplayDirectory(init_dir) + file_picker.setMultiSelectionMode(multiple) + + if filters: + filters = [(f.upper(), f'*.{f.lower()}') for f in filters.split(',')] + file_picker.setCurrentFilter(filters[0][0]) + for f in filters: + file_picker.appendFilter(f[0], f[1]) + + path = '' + if file_picker.execute(): + files = file_picker.getSelectedFiles() + path = [cls.to_system(f) for f in files] + if not multiple: + path = path[0] + return path + + @classmethod + def replace_ext(cls, path, new_ext): + p = Paths(path) + name = f'{p.name}.{new_ext}' + path = cls.join(p.path, name) + return path + + @classmethod + def exists(cls, path): + result = False + if path: + path = cls.to_system(path) + result = Path(path).exists() + return result + + @classmethod + def exists_app(cls, name_app): + return bool(shutil.which(name_app)) + + @classmethod + def open(cls, path): + if IS_WIN: + os.startfile(path) + else: + pid = subprocess.Popen(['xdg-open', path]).pid + return + + @classmethod + def is_dir(cls, path): + return Path(path).is_dir() + + @classmethod + def is_file(cls, path): + return Path(path).is_file() + + @classmethod + def join(cls, *paths): + return str(Path(paths[0]).joinpath(*paths[1:])) + + @classmethod + def save(cls, path, data, encoding='utf-8'): + result = bool(Path(path).write_text(data, encoding=encoding)) + return result + + @classmethod + def save_bin(cls, path, data): + result = bool(Path(path).write_bytes(data)) + return result + + @classmethod + def read(cls, path, get_lines=False, encoding='utf-8'): + if get_lines: + with Path(path).open(encoding=encoding) as f: + data = f.readlines() + else: + data = Path(path).read_text(encoding=encoding) + return data + + @classmethod + def read_bin(cls, path): + data = Path(path).read_bytes() + return data + + @classmethod + def to_url(cls, path): + if not path.startswith('file://'): + path = Path(path).as_uri() + return path + + @classmethod + def to_system(cls, path): + if path.startswith('file://'): + path = str(Path(uno.fileUrlToSystemPath(path)).resolve()) + return path + + @classmethod + def kill(cls, path): + p = Path(path) + try: + if p.is_file(): + p.unlink() + elif p.is_dir(): + shutil.rmtree(path) + result = True + except OSError as e: + log.error(e) + result = False + + return result + + @classmethod + def files(cls, path, pattern='*'): + files = [str(p) for p in Path(path).glob(pattern) if p.is_file()] + return files + + @classmethod + def dirs(cls, path): + dirs = [str(p) for p in Path(path).iterdir() if p.is_dir()] + return dirs + + @classmethod + def walk(cls, path, filters=''): + paths = [] + if filters in ('*', '*.*'): + filters = '' + for folder, _, files in os.walk(path): + if filters: + pattern = re.compile(r'\.(?:{})$'.format(filters), re.IGNORECASE) + paths += [cls.join(folder, f) for f in files if pattern.search(f)] + else: + paths += [cls.join(folder, f) for f in files] + return paths + + @classmethod + def walk_dirs(cls, path, tree=False): + """ + Get directories recursively + path: path source + tree: get info in a tuple (ID_FOLDER, ID_PARENT, NAME) + """ + folders = [] + if tree: + i = 0 + p = 0 + parents = {path: 0} + for root, dirs, _ in os.walk(path): + for name in dirs: + i += 1 + rn = cls.join(root, name) + if not rn in parents: + parents[rn] = i + folders.append((i, parents[root], name)) + else: + for root, dirs, _ in os.walk(path): + folders += [cls.join(root, name) for name in dirs] + return folders + + @classmethod + def from_id(cls, id_ext): + pip = CTX.getValueByName('/singletons/com.sun.star.deployment.PackageInformationProvider') + path = _P.to_system(pip.getPackageLocation(id_ext)) + return path + + @classmethod + def from_json(cls, path): + data = json.loads(cls.read(path)) + return data + + @classmethod + def to_json(cls, path, data): + data = json.dumps(data, indent=4, ensure_ascii=False, sort_keys=True) + return cls.save(path, data) + + @classmethod + def from_csv(cls, path, args={}): + # ~ See https://docs.python.org/3.7/library/csv.html#csv.reader + with open(path) as f: + rows = tuple(csv.reader(f, **args)) + return rows + + @classmethod + def to_csv(cls, path, data, args={}): + with open(path, 'w') as f: + writer = csv.writer(f, **args) + writer.writerows(data) + return + + @classmethod + def zip(cls, source, target=''): + path_zip = target + if not isinstance(source, (tuple, list)): + path, _, name, _ = _P(source).info + start = len(path) + 1 + if not target: + path_zip = f'{path}/{name}.zip' + + if isinstance(source, (tuple, list)): + files = [(f, f[len(_P(f).path)+1:]) for f in source] + elif _P.is_file(source): + files = ((source, source[start:]),) + else: + files = [(f, f[start:]) for f in _P.walk(source)] + + compression = zipfile.ZIP_DEFLATED + with zipfile.ZipFile(path_zip, 'w', compression=compression) as z: + for f in files: + z.write(f[0], f[1]) + return path_zip + + @classmethod + def zip_content(cls, path): + with zipfile.ZipFile(path) as z: + names = z.namelist() + return names + + @classmethod + def unzip(cls, source, target='', members=None, pwd=None): + path = target + if not target: + path = _P(source).path + with zipfile.ZipFile(source) as z: + if not pwd is None: + pwd = pwd.encode() + if isinstance(members, str): + members = (members,) + z.extractall(path, members=members, pwd=pwd) + return + + @classmethod + def merge_zip(cls, target, zips): + try: + with zipfile.ZipFile(target, 'w', compression=zipfile.ZIP_DEFLATED) as t: + for path in zips: + with zipfile.ZipFile(path, compression=zipfile.ZIP_DEFLATED) as s: + for name in s.namelist(): + t.writestr(name, s.open(name).read()) + except Exception as e: + error(e) + return False + + return True + + @classmethod + def image(cls, path): + # ~ sfa = create_instance('com.sun.star.ucb.SimpleFileAccess') + # ~ stream = sfa.openFileRead(cls.to_url(path)) + gp = create_instance('com.sun.star.graphic.GraphicProvider') + if isinstance(path, str): + properties = (PropertyValue(Name='URL', Value=cls.to_url(path)),) + else: + properties = (PropertyValue(Name='InputStream', Value=path),) + image = gp.queryGraphic(properties) + return image + + @classmethod + def copy(cls, source, target='', name=''): + p, f, n, e = _P(source).info + if target: + p = target + e = f'.{e}' + if name: + e = '' + n = name + path_new = cls.join(p, f'{n}{e}') + shutil.copy(source, path_new) + return path_new +_P = Paths + + +class Dates(object): + + @classmethod + def date(cls, year, month, day): + d = datetime.date(year, month, day) + return d + + @classmethod + def str_to_date(cls, str_date, template, to_calc=False): + d = datetime.datetime.strptime(str_date, template).date() + if to_calc: + d = d.toordinal() - DATE_OFFSET + return d + + @classmethod + def calc_to_date(cls, value, frm=''): + d = datetime.date.fromordinal(int(value) + DATE_OFFSET) + if frm: + d = d.strftime(frm) + return d + + +class OutputStream(unohelper.Base, XOutputStream): + + def __init__(self): + self._buffer = b'' + self.closed = 0 + + @property + def buffer(self): + return self._buffer + + def closeOutput(self): + self.closed = 1 + + def writeBytes(self, seq): + if seq.value: + self._buffer = seq.value + + def flush(self): + pass + + +class IOStream(object): + + @classmethod + def buffer(cls): + return io.BytesIO() + + @classmethod + def input(cls, buffer): + instance = 'com.sun.star.io.SequenceInputStream' + stream = create_instance(instance, True) + stream.initialize((uno.ByteSequence(buffer.getvalue()),)) + return stream + + @classmethod + def output(cls): + return OutputStream() + + @classmethod + def qr(cls, data, **kwargs): + import segno + + kwargs['kind'] = kwargs.get('kind', 'svg') + kwargs['scale'] = kwargs.get('scale', 8) + kwargs['border'] = kwargs.get('border', 2) + buffer = cls.buffer() + segno.make(data).save(buffer, **kwargs) + stream = cls.input(buffer) + return stream + + +class SpellChecker(object): + + def __init__(self): + service = 'com.sun.star.linguistic2.SpellChecker' + self._spellchecker = create_instance(service, True) + self._locale = LOCALE + + @property + def locale(self): + slocal = f'{self._locale.Language}-{self._locale.Country}' + return slocale + @locale.setter + def locale(self, value): + lang = value.split('-') + self._locale = Locale(lang[0], lang[1], '') + + def is_valid(self, word): + result = self._spellchecker.isValid(word, self._locale, ()) + return result + + def spell(self, word): + result = self._spellchecker.spell(word, self._locale, ()) + if result: + result = result.getAlternatives() + if not isinstance(result, tuple): + result = () + return result + + +def spell(word, locale=''): + sc = SpellChecker() + if locale: + sc.locale = locale + return sc.spell(word) + + +def __getattr__(name): + if name == 'active': + return LODocs().active + if name == 'active_sheet': + return LODocs().active.active + if name == 'selection': + return LODocs().active.selection + if name == 'current_region': + return LODocs().active.selection.current_region + if name in ('rectangle', 'pos_size'): + return Rectangle() + if name == 'paths': + return Paths + if name == 'docs': + return LODocs() + if name == 'db': + return LODBServer() + if name == 'sheets': + return LOSheets() + if name == 'cells': + return LOCells() + if name == 'menus': + return LOMenus() + if name == 'shortcuts': + return LOShortCuts() + if name == 'clipboard': + return ClipBoard + if name == 'dates': + return Dates + if name == 'ios': + return IOStream() + raise AttributeError(f"module '{__name__}' has no attribute '{name}'") + + +def create_dialog(args): + return LODialog(args) + + +def inputbox(message, default='', title=TITLE, echochar=''): + + class ControllersInput(object): + + def __init__(self, dlg): + self.d = dlg + + def cmd_ok_action(self, event): + self.d.close(1) + return + + args = { + 'Title': title, + 'Width': 200, + 'Height': 80, + } + dlg = LODialog(args) + dlg.events = ControllersInput + + args = { + 'Type': 'Label', + 'Name': 'lbl_msg', + 'Label': message, + 'Width': 140, + 'Height': 50, + 'X': 5, + 'Y': 5, + 'MultiLine': True, + 'Border': 1, + } + dlg.add_control(args) + + args = { + 'Type': 'Text', + 'Name': 'txt_value', + 'Text': default, + 'Width': 190, + 'Height': 15, + } + if echochar: + args['EchoChar'] = ord(echochar[0]) + dlg.add_control(args) + dlg.txt_value.move(dlg.lbl_msg) + + args = { + 'Type': 'button', + 'Name': 'cmd_ok', + 'Label': _('OK'), + 'Width': 40, + 'Height': 15, + 'DefaultButton': True, + 'PushButtonType': 1, + } + dlg.add_control(args) + dlg.cmd_ok.move(dlg.lbl_msg, 10, 0) + + args = { + 'Type': 'button', + 'Name': 'cmd_cancel', + 'Label': _('Cancel'), + 'Width': 40, + 'Height': 15, + 'PushButtonType': 2, + } + dlg.add_control(args) + dlg.cmd_cancel.move(dlg.cmd_ok) + + if dlg.open(): + return dlg.txt_value.value + + return '' + + +def get_fonts(): + toolkit = create_instance('com.sun.star.awt.Toolkit') + device = toolkit.createScreenCompatibleDevice(0, 0) + return device.FontDescriptors + + +def get_filters(): + """ + Get all support filters + https://help.libreoffice.org/latest/en-US/text/shared/guide/convertfilters.html + """ + factory = create_instance('com.sun.star.document.FilterFactory') + rows = [data_to_dict(factory[name]) for name in factory] + for row in rows: + row['UINames'] = data_to_dict(row['UINames']) + return rows + + +# ~ https://en.wikipedia.org/wiki/Web_colors +def get_color(value): + COLORS = { + 'aliceblue': 15792383, + 'antiquewhite': 16444375, + 'aqua': 65535, + 'aquamarine': 8388564, + 'azure': 15794175, + 'beige': 16119260, + 'bisque': 16770244, + 'black': 0, + 'blanchedalmond': 16772045, + 'blue': 255, + 'blueviolet': 9055202, + 'brown': 10824234, + 'burlywood': 14596231, + 'cadetblue': 6266528, + 'chartreuse': 8388352, + 'chocolate': 13789470, + 'coral': 16744272, + 'cornflowerblue': 6591981, + 'cornsilk': 16775388, + 'crimson': 14423100, + 'cyan': 65535, + 'darkblue': 139, + 'darkcyan': 35723, + 'darkgoldenrod': 12092939, + 'darkgray': 11119017, + 'darkgreen': 25600, + 'darkgrey': 11119017, + 'darkkhaki': 12433259, + 'darkmagenta': 9109643, + 'darkolivegreen': 5597999, + 'darkorange': 16747520, + 'darkorchid': 10040012, + 'darkred': 9109504, + 'darksalmon': 15308410, + 'darkseagreen': 9419919, + 'darkslateblue': 4734347, + 'darkslategray': 3100495, + 'darkslategrey': 3100495, + 'darkturquoise': 52945, + 'darkviolet': 9699539, + 'deeppink': 16716947, + 'deepskyblue': 49151, + 'dimgray': 6908265, + 'dimgrey': 6908265, + 'dodgerblue': 2003199, + 'firebrick': 11674146, + 'floralwhite': 16775920, + 'forestgreen': 2263842, + 'fuchsia': 16711935, + 'gainsboro': 14474460, + 'ghostwhite': 16316671, + 'gold': 16766720, + 'goldenrod': 14329120, + 'gray': 8421504, + 'grey': 8421504, + 'green': 32768, + 'greenyellow': 11403055, + 'honeydew': 15794160, + 'hotpink': 16738740, + 'indianred': 13458524, + 'indigo': 4915330, + 'ivory': 16777200, + 'khaki': 15787660, + 'lavender': 15132410, + 'lavenderblush': 16773365, + 'lawngreen': 8190976, + 'lemonchiffon': 16775885, + 'lightblue': 11393254, + 'lightcoral': 15761536, + 'lightcyan': 14745599, + 'lightgoldenrodyellow': 16448210, + 'lightgray': 13882323, + 'lightgreen': 9498256, + 'lightgrey': 13882323, + 'lightpink': 16758465, + 'lightsalmon': 16752762, + 'lightseagreen': 2142890, + 'lightskyblue': 8900346, + 'lightslategray': 7833753, + 'lightslategrey': 7833753, + 'lightsteelblue': 11584734, + 'lightyellow': 16777184, + 'lime': 65280, + 'limegreen': 3329330, + 'linen': 16445670, + 'magenta': 16711935, + 'maroon': 8388608, + 'mediumaquamarine': 6737322, + 'mediumblue': 205, + 'mediumorchid': 12211667, + 'mediumpurple': 9662683, + 'mediumseagreen': 3978097, + 'mediumslateblue': 8087790, + 'mediumspringgreen': 64154, + 'mediumturquoise': 4772300, + 'mediumvioletred': 13047173, + 'midnightblue': 1644912, + 'mintcream': 16121850, + 'mistyrose': 16770273, + 'moccasin': 16770229, + 'navajowhite': 16768685, + 'navy': 128, + 'oldlace': 16643558, + 'olive': 8421376, + 'olivedrab': 7048739, + 'orange': 16753920, + 'orangered': 16729344, + 'orchid': 14315734, + 'palegoldenrod': 15657130, + 'palegreen': 10025880, + 'paleturquoise': 11529966, + 'palevioletred': 14381203, + 'papayawhip': 16773077, + 'peachpuff': 16767673, + 'peru': 13468991, + 'pink': 16761035, + 'plum': 14524637, + 'powderblue': 11591910, + 'purple': 8388736, + 'red': 16711680, + 'rosybrown': 12357519, + 'royalblue': 4286945, + 'saddlebrown': 9127187, + 'salmon': 16416882, + 'sandybrown': 16032864, + 'seagreen': 3050327, + 'seashell': 16774638, + 'sienna': 10506797, + 'silver': 12632256, + 'skyblue': 8900331, + 'slateblue': 6970061, + 'slategray': 7372944, + 'slategrey': 7372944, + 'snow': 16775930, + 'springgreen': 65407, + 'steelblue': 4620980, + 'tan': 13808780, + 'teal': 32896, + 'thistle': 14204888, + 'tomato': 16737095, + 'turquoise': 4251856, + 'violet': 15631086, + 'wheat': 16113331, + 'white': 16777215, + 'whitesmoke': 16119285, + 'yellow': 16776960, + 'yellowgreen': 10145074, + } + + if isinstance(value, tuple): + color = (value[0] << 16) + (value[1] << 8) + value[2] + else: + if value[0] == '#': + r, g, b = bytes.fromhex(value[1:]) + color = (r << 16) + (g << 8) + b + else: + color = COLORS.get(value.lower(), -1) + return color + + +COLOR_ON_FOCUS = get_color('LightYellow') + + +class LOServer(object): + HOST = 'localhost' + PORT = '8100' + ARG = f'socket,host={HOST},port={PORT};urp;StarOffice.ComponentContext' + CMD = ['soffice', + '-env:SingleAppInstance=false', + '-env:UserInstallation=file:///tmp/LO_Process8100', + '--headless', '--norestore', '--invisible', + f'--accept={ARG}'] + + def __init__(self): + self._server = None + self._ctx = None + self._sm = None + self._start_server() + self._init_values() + + def _init_values(self): + global CTX + global SM + + if not self.is_running: + return + + ctx = uno.getComponentContext() + service = 'com.sun.star.bridge.UnoUrlResolver' + resolver = ctx.ServiceManager.createInstanceWithContext(service, ctx) + self._ctx = resolver.resolve('uno:{}'.format(self.ARG)) + self._sm = self._ctx.getServiceManager() + CTX = self._ctx + SM = self._sm + return + + @property + def is_running(self): + try: + s = socket.create_connection((self.HOST, self.PORT), 5.0) + s.close() + debug('LibreOffice is running...') + return True + except ConnectionRefusedError: + return False + + def _start_server(self): + if self.is_running: + return + + for i in range(3): + self._server = subprocess.Popen(self.CMD, + stdout=subprocess.PIPE, stderr=subprocess.PIPE) + time.sleep(3) + if self.is_running: + break + return + + def stop(self): + if self._server is None: + print('Search pgrep soffice') + else: + self._server.terminate() + debug('LibreOffice is stop...') + return + + def create_instance(self, name, with_context=True): + if with_context: + instance = self._sm.createInstanceWithContext(name, self._ctx) + else: + instance = self._sm.createInstance(name) + return instance diff --git a/files/ZAZPass_v0.1.0.oxt b/files/ZAZPass_v0.1.0.oxt new file mode 100644 index 0000000000000000000000000000000000000000..a907536255e3820e6a2acb8831ca0f78219ce911 GIT binary patch literal 62375 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

g~_P%u(ny>kg%g{ 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 literal 0 HcmV?d00001 diff --git a/images/logo.png b/images/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..4e0d53fa22bdba5af0aab3dc7896af161d54932f GIT binary patch literal 9189 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 + + + + + + Zaz Passwords + Zaz Contraseñas + + + _self + + + + + Insert password + Insertar contraseña + + + com.sun.star.sheet.SpreadsheetDocument,com.sun.star.text.TextDocument + + + service:net.elmau.zaz.pass?insert + + + _self + + + %origin%/images/icon + + + + + Copy in clipboard + Copiar al portapapeles + + + com.sun.star.sheet.SpreadsheetDocument,com.sun.star.text.TextDocument + + + service:net.elmau.zaz.pass?copy + + + _self + + + %origin%/images/icon + + + + + Generate password... + Generar contraseña... + + + com.sun.star.sheet.SpreadsheetDocument,com.sun.star.text.TextDocument + + + service:net.elmau.zaz.pass?generate + + + _self + + + %origin%/images/icon + + + + + + + + + + Insert password + Insertar contraseña + + + com.sun.star.sheet.SpreadsheetDocument,com.sun.star.text.TextDocument + + + service:net.elmau.zaz.pass?insert + + + _self + + + %origin%/images/icon + + + + + Copy in clipboard + Copiar al portapapeles + + + com.sun.star.sheet.SpreadsheetDocument,com.sun.star.text.TextDocument + + + service:net.elmau.zaz.pass?copy + + + _self + + + %origin%/images/icon + + + + + Generate password... + Generar contraseña... + + + com.sun.star.sheet.SpreadsheetDocument,com.sun.star.text.TextDocument + + + service:net.elmau.zaz.pass?generate + + + _self + + + %origin%/images/icon + + + + + + diff --git a/source/META-INF/manifest.xml b/source/META-INF/manifest.xml new file mode 100644 index 0000000..ddea409 --- /dev/null +++ b/source/META-INF/manifest.xml @@ -0,0 +1,6 @@ + + + + + + diff --git a/source/Office/Accelerators.xcu b/source/Office/Accelerators.xcu new file mode 100644 index 0000000..9917d4f --- /dev/null +++ b/source/Office/Accelerators.xcu @@ -0,0 +1,49 @@ + + + + + + + + service:net.elmau.zaz.pass?insert + + + + + + + service:net.elmau.zaz.pass?insert + + + + + + + service:net.elmau.zaz.pass?copy + + + + + + + service:net.elmau.zaz.pass?copy + + + + + + + service:net.elmau.zaz.pass?generate + + + + + + + service:net.elmau.zaz.pass?generate + + + + + + diff --git a/source/ZAZPass.py b/source/ZAZPass.py new file mode 100644 index 0000000..688c94b --- /dev/null +++ b/source/ZAZPass.py @@ -0,0 +1,22 @@ +import uno +import unohelper +from com.sun.star.task import XJobExecutor +from zpass import main + + +ID_EXTENSION = 'net.elmau.zaz.pass' +SERVICE = ('com.sun.star.task.Job',) + + +class ZAZPass(unohelper.Base, XJobExecutor): + + def __init__(self, ctx): + self.ctx = ctx + + def trigger(self, args): + main(ID_EXTENSION, args, __file__) + return + + +g_ImplementationHelper = unohelper.ImplementationHelper() +g_ImplementationHelper.addImplementation(ZAZPass, ID_EXTENSION, SERVICE) diff --git a/source/description.xml b/source/description.xml new file mode 100644 index 0000000..a79f4d3 --- /dev/null +++ b/source/description.xml @@ -0,0 +1,26 @@ + + + + + + My first extension + Mi primer extensión + + + + + + + + + + El Mau + El Mau + + + + + + + + diff --git a/source/description/desc_en.txt b/source/description/desc_en.txt new file mode 100644 index 0000000..b667a4b --- /dev/null +++ b/source/description/desc_en.txt @@ -0,0 +1 @@ +My great extension \ No newline at end of file diff --git a/source/description/desc_es.txt b/source/description/desc_es.txt new file mode 100644 index 0000000..d8d8fdc --- /dev/null +++ b/source/description/desc_es.txt @@ -0,0 +1 @@ +Mi gran extensión \ No newline at end of file diff --git a/source/images/close.svg b/source/images/close.svg new file mode 100755 index 0000000..534460e --- /dev/null +++ b/source/images/close.svg @@ -0,0 +1,4 @@ + + + + diff --git a/source/images/eye-close.svg b/source/images/eye-close.svg new file mode 100644 index 0000000..c6455d7 --- /dev/null +++ b/source/images/eye-close.svg @@ -0,0 +1,6 @@ + + + + + + diff --git a/source/images/eye-open.svg b/source/images/eye-open.svg new file mode 100644 index 0000000..0eef411 --- /dev/null +++ b/source/images/eye-open.svg @@ -0,0 +1,4 @@ + + + + diff --git a/source/images/insert.svg b/source/images/insert.svg new file mode 100644 index 0000000..6c98b94 --- /dev/null +++ b/source/images/insert.svg @@ -0,0 +1,4 @@ + + + + diff --git a/source/images/new.svg b/source/images/new.svg new file mode 100644 index 0000000..6d70aae --- /dev/null +++ b/source/images/new.svg @@ -0,0 +1,6 @@ + + + + + + diff --git a/source/images/zazpass.png b/source/images/zazpass.png new file mode 100644 index 0000000000000000000000000000000000000000..4e0d53fa22bdba5af0aab3dc7896af161d54932f GIT binary patch literal 9189 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. + +import base64 +import csv +import ctypes +import datetime +import getpass +import gettext +import hashlib +import io +import json +import logging +import os +import platform +import re +import shlex +import shutil +import socket +import ssl +import subprocess +import sys +import tempfile +import threading +import time +import traceback +import zipfile + +from collections import OrderedDict +from collections.abc import MutableMapping +from decimal import Decimal +from enum import IntEnum +from functools import wraps +from pathlib import Path +from pprint import pprint +from socket import timeout +from string import Template +from typing import Any, Union +from urllib.request import Request, urlopen +from urllib.error import URLError, HTTPError + +import imaplib +import smtplib +from smtplib import SMTPException, SMTPAuthenticationError +from email.mime.multipart import MIMEMultipart +from email.mime.base import MIMEBase +from email.mime.text import MIMEText +from email.utils import formatdate +from email import encoders +import mailbox + +import uno +import unohelper +from com.sun.star.awt import MessageBoxButtons as MSG_BUTTONS +from com.sun.star.awt.MessageBoxResults import YES +from com.sun.star.awt import Rectangle, Size, Point +from com.sun.star.awt.PosSize import POSSIZE, SIZE +from com.sun.star.awt import Key, KeyModifier, KeyEvent +from com.sun.star.container import NoSuchElementException +from com.sun.star.datatransfer import XTransferable, DataFlavor + +from com.sun.star.beans import PropertyValue, NamedValue +from com.sun.star.sheet import TableFilterField +from com.sun.star.table.CellContentType import EMPTY, VALUE, TEXT, FORMULA +from com.sun.star.util import Time, Date, DateTime + +from com.sun.star.text.ControlCharacter import PARAGRAPH_BREAK + +from com.sun.star.lang import Locale +from com.sun.star.lang import XEventListener +from com.sun.star.awt import XActionListener +from com.sun.star.awt import XMenuListener +from com.sun.star.awt import XMouseListener +from com.sun.star.awt import XMouseMotionListener +from com.sun.star.awt import XFocusListener +from com.sun.star.awt import XKeyListener +from com.sun.star.awt import XItemListener +from com.sun.star.awt import XTabListener +from com.sun.star.awt import XSpinListener +from com.sun.star.awt import XWindowListener +from com.sun.star.awt import XTopWindowListener +from com.sun.star.awt.grid import XGridDataListener +from com.sun.star.awt.grid import XGridSelectionListener +from com.sun.star.script import ScriptEventDescriptor + +from com.sun.star.io import IOException, XOutputStream + +# ~ https://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1awt_1_1FontUnderline.html +from com.sun.star.awt import FontUnderline +from com.sun.star.style.VerticalAlignment import TOP, MIDDLE, BOTTOM + +from com.sun.star.view.SelectionType import SINGLE, MULTI, RANGE + +from com.sun.star.sdb.CommandType import TABLE, QUERY, COMMAND + +try: + from peewee import Database, DateTimeField, DateField, TimeField, \ + __exception_wrapper__ +except ImportError as e: + Database = DateField = TimeField = DateTimeField = object + print('You need install peewee, only if you will develop with Base') + + +LOG_FORMAT = '%(asctime)s - %(levelname)s - %(message)s' +LOG_DATE = '%d/%m/%Y %H:%M:%S' +logging.addLevelName(logging.ERROR, '\033[1;41mERROR\033[1;0m') +logging.addLevelName(logging.DEBUG, '\x1b[33mDEBUG\033[1;0m') +logging.addLevelName(logging.INFO, '\x1b[32mINFO\033[1;0m') +logging.basicConfig(level=logging.DEBUG, format=LOG_FORMAT, datefmt=LOG_DATE) +log = logging.getLogger(__name__) + + +# ~ You can get custom salt +# ~ codecs.encode(os.urandom(16), 'hex') +# ~ but, not modify this file, modify in import file +SALT = b'c9548699d4e432dfd2b46adddafbb06d' + +TIMEOUT = 10 +LOG_NAME = 'ZAZ' +FILE_NAME_CONFIG = 'zaz-{}.json' + +LEFT = 0 +CENTER = 1 +RIGHT = 2 + +CALC = 'calc' +WRITER = 'writer' +DRAW = 'draw' +IMPRESS = 'impress' +BASE = 'base' +MATH = 'math' +BASIC = 'basic' +MAIN = 'main' +TYPE_DOC = { + CALC: 'com.sun.star.sheet.SpreadsheetDocument', + WRITER: 'com.sun.star.text.TextDocument', + DRAW: 'com.sun.star.drawing.DrawingDocument', + IMPRESS: 'com.sun.star.presentation.PresentationDocument', + BASE: 'com.sun.star.sdb.DocumentDataSource', + MATH: 'com.sun.star.formula.FormulaProperties', + BASIC: 'com.sun.star.script.BasicIDE', + MAIN: 'com.sun.star.frame.StartModule', +} + +OBJ_CELL = 'ScCellObj' +OBJ_RANGE = 'ScCellRangeObj' +OBJ_RANGES = 'ScCellRangesObj' +TYPE_RANGES = (OBJ_CELL, OBJ_RANGE) + +OBJ_SHAPE = 'com.sun.star.comp.sc.ScShapeObj' +OBJ_SHAPES = 'com.sun.star.drawing.SvxShapeCollection' +OBJ_GRAPHIC = 'SwXTextGraphicObject' + +OBJ_TEXTS = 'SwXTextRanges' +OBJ_TEXT = 'SwXTextRange' + +CLSID = { + 'FORMULA': '078B7ABA-54FC-457F-8551-6147e776a997', +} + +SERVICES = { + 'TEXT_EMBEDDED': 'com.sun.star.text.TextEmbeddedObject', + 'TEXT_TABLE': 'com.sun.star.text.TextTable', + 'GRAPHIC': 'com.sun.star.text.GraphicObject', +} + + +# ~ from com.sun.star.sheet.FilterOperator import EMPTY, NO_EMPTY, EQUAL, NOT_EQUAL +class FilterOperator(IntEnum): + EMPTY = 0 + NO_EMPTY = 1 + EQUAL = 2 + NOT_EQUAL = 3 + +# ~ https://api.libreoffice.org/docs/idl/ref/servicecom_1_1sun_1_1star_1_1awt_1_1UnoControlEditModel.html#a54d3ff280d892218d71e667f81ce99d4 +class Border(IntEnum): + NO_BORDER = 0 + BORDER = 1 + SIMPLE = 2 + + +# ~ https://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1sheet.html#aa5aa6dbecaeb5e18a476b0a58279c57a +class ValidationType(): + from com.sun.star.sheet.ValidationType \ + import ANY, WHOLE, DECIMAL, DATE, TIME, TEXT_LEN, LIST, CUSTOM +VT = ValidationType + + +# ~ https://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1sheet.html#aecf58149730f4c8c5c18c70f3c7c5db7 +class ValidationAlertStyle(): + from com.sun.star.sheet.ValidationAlertStyle \ + import STOP, WARNING, INFO, MACRO +VAS = ValidationAlertStyle + + +# ~ https://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1sheet_1_1ConditionOperator2.html +class ConditionOperator(): + from com.sun.star.sheet.ConditionOperator2 \ + import NONE, EQUAL, NOT_EQUAL, GREATER, GREATER_EQUAL, LESS, \ + LESS_EQUAL, BETWEEN, NOT_BETWEEN, FORMULA, DUPLICATE, NOT_DUPLICATE +CO = ConditionOperator + + +class DataPilotFieldOrientation(): + from com.sun.star.sheet.DataPilotFieldOrientation \ + import HIDDEN, COLUMN, ROW, PAGE, DATA +DPFO = DataPilotFieldOrientation + + +class CellInsertMode(): + from com.sun.star.sheet.CellInsertMode import DOWN, RIGHT, ROWS, COLUMNS +CIM = CellInsertMode + + +class CellDeleteMode(): + from com.sun.star.sheet.CellDeleteMode import UP, LEFT, ROWS, COLUMNS +CDM = CellDeleteMode + + +class FormButtonType(): + from com.sun.star.form.FormButtonType import PUSH, SUBMIT, RESET, URL +FBT = FormButtonType + + +class TextContentAnchorType(): + from com.sun.star.text.TextContentAnchorType \ + import AT_PARAGRAPH, AS_CHARACTER, AT_PAGE, AT_FRAME, AT_CHARACTER +TCAT = TextContentAnchorType + + +OS = platform.system() +IS_WIN = OS == 'Windows' +IS_MAC = OS == 'Darwin' +USER = getpass.getuser() +PC = platform.node() +DESKTOP = os.environ.get('DESKTOP_SESSION', '') +INFO_DEBUG = f"{sys.version}\n\n{platform.platform()}\n\n" + '\n'.join(sys.path) + +PYTHON = 'python' +if IS_WIN: + PYTHON = 'python.exe' + +_MACROS = {} +_start = 0 + +SECONDS_DAY = 60 * 60 * 24 +DIR = { + 'images': 'images', + 'locales': 'locales', +} + +KEY = { + 'enter': 1280, +} + +MODIFIERS = { + 'shift': KeyModifier.SHIFT, + 'ctrl': KeyModifier.MOD1, + 'alt': KeyModifier.MOD2, + 'ctrlmac': KeyModifier.MOD3, +} + +# ~ Menus +NODE_MENUBAR = 'private:resource/menubar/menubar' +MENUS = { + 'file': '.uno:PickList', + 'tools': '.uno:ToolsMenu', + 'help': '.uno:HelpMenu', + 'windows': '.uno:WindowList', + 'edit': '.uno:EditMenu', + 'view': '.uno:ViewMenu', + 'insert': '.uno:InsertMenu', + 'format': '.uno:FormatMenu', + 'styles': '.uno:FormatStylesMenu', + 'sheet': '.uno:SheetMenu', + 'data': '.uno:DataMenu', + 'table': '.uno:TableMenu', + 'form': '.uno:FormatFormMenu', + 'page': '.uno:PageMenu', + 'shape': '.uno:ShapeMenu', + 'slide': '.uno:SlideMenu', + 'show': '.uno:SlideShowMenu', +} + +DEFAULT_MIME_TYPE = 'png' +MIME_TYPE = { + 'png': 'image/png', + 'jpg': 'image/jpeg', +} + +MESSAGES = { + 'es': { + 'OK': 'Aceptar', + 'Cancel': 'Cancelar', + 'Select path': 'Seleccionar ruta', + 'Select directory': 'Seleccionar directorio', + 'Select file': 'Seleccionar archivo', + 'Incorrect user or password': 'Nombre de usuario o contraseña inválidos', + 'Allow less secure apps in GMail': 'Activa: Permitir aplicaciones menos segura en GMail', + } +} + + +CTX = uno.getComponentContext() +SM = CTX.getServiceManager() + + +def create_instance(name: str, with_context: bool=False, args: Any=None) -> Any: + if with_context: + instance = SM.createInstanceWithContext(name, CTX) + elif args: + instance = SM.createInstanceWithArguments(name, (args,)) + else: + instance = SM.createInstance(name) + return instance + + +def get_app_config(node_name: str, key: str=''): + name = 'com.sun.star.configuration.ConfigurationProvider' + service = 'com.sun.star.configuration.ConfigurationAccess' + cp = create_instance(name, True) + node = PropertyValue(Name='nodepath', Value=node_name) + try: + ca = cp.createInstanceWithArguments(service, (node,)) + if ca and not key: + return ca + if ca and ca.hasByName(key): + return ca.getPropertyValue(key) + except Exception as e: + error(e) + return '' + + +LANGUAGE = get_app_config('org.openoffice.Setup/L10N/', 'ooLocale') +LANG = LANGUAGE.split('-')[0] +try: + COUNTRY = LANGUAGE.split('-')[1] +except: + COUNTRY = '' +LOCALE = Locale(LANG, COUNTRY, '') +NAME = TITLE = get_app_config('org.openoffice.Setup/Product', 'ooName') +VERSION = get_app_config('org.openoffice.Setup/Product','ooSetupVersion') + +INFO_DEBUG = f"{NAME} v{VERSION} {LANGUAGE}\n\n{INFO_DEBUG}" + +node = '/org.openoffice.Office.Calc/Calculate/Other/Date' +y = get_app_config(node, 'YY') +m = get_app_config(node, 'MM') +d = get_app_config(node, 'DD') +DATE_OFFSET = datetime.date(y, m, d).toordinal() + + +def error(info): + log.error(info) + return + + +def debug(*args): + data = [str(a) for a in args] + log.debug('\t'.join(data)) + return + + +def info(*args): + data = [str(a) for a in args] + log.info('\t'.join(data)) + return + + +def save_log(path: str, data): + with open(path, 'a') as f: + f.write(f'{str(now())[:19]} -{LOG_NAME}- ') + pprint(data, stream=f) + return + + +def catch_exception(f): + @wraps(f) + def func(*args, **kwargs): + try: + return f(*args, **kwargs) + except Exception as e: + name = f.__name__ + if IS_WIN: + msgbox(traceback.format_exc()) + log.error(name, exc_info=True) + return func + + +def inspect(obj: Any) -> None: + zaz = create_instance('net.elmau.zaz.inspect') + if hasattr(obj, 'obj'): + obj = obj.obj + zaz.inspect(obj) + return + + +def mri(obj: Any) -> None: + m = create_instance('mytools.Mri') + if m is None: + msg = 'Extension MRI not found' + error(msg) + return + + if hasattr(obj, 'obj'): + obj = obj.obj + m.inspect(obj) + return + + +def run_in_thread(fn): + def run(*k, **kw): + t = threading.Thread(target=fn, args=k, kwargs=kw) + t.start() + return t + return run + + +def now(only_time: bool=False): + now = datetime.datetime.now() + if only_time: + now = now.time() + return now + + +def today(): + return datetime.date.today() + + +def _(msg): + if LANG == 'en': + return msg + + if not LANG in MESSAGES: + return msg + + return MESSAGES[LANG][msg] + + +def msgbox(message, title=TITLE, buttons=MSG_BUTTONS.BUTTONS_OK, type_msg='infobox'): + """ Create message box + type_msg: infobox, warningbox, errorbox, querybox, messbox + http://api.libreoffice.org/docs/idl/ref/interfacecom_1_1sun_1_1star_1_1awt_1_1XMessageBoxFactory.html + """ + toolkit = create_instance('com.sun.star.awt.Toolkit') + parent = toolkit.getDesktopWindow() + box = toolkit.createMessageBox(parent, type_msg, buttons, title, str(message)) + return box.execute() + + +def question(message, title=TITLE): + result = msgbox(message, title, MSG_BUTTONS.BUTTONS_YES_NO, 'querybox') + return result == YES + + +def warning(message, title=TITLE): + return msgbox(message, title, type_msg='warningbox') + + +def errorbox(message, title=TITLE): + return msgbox(message, title, type_msg='errorbox') + + +def get_type_doc(obj: Any) -> str: + for k, v in TYPE_DOC.items(): + if obj.supportsService(v): + return k + return '' + + +def _get_class_doc(obj: Any) -> Any: + classes = { + CALC: LOCalc, + WRITER: LOWriter, + DRAW: LODraw, + IMPRESS: LOImpress, + BASE: LOBase, + MATH: LOMath, + BASIC: LOBasic, + } + type_doc = get_type_doc(obj) + return classes[type_doc](obj) + + +def dict_to_property(values: dict, uno_any: bool=False): + ps = tuple([PropertyValue(Name=n, Value=v) for n, v in values.items()]) + if uno_any: + ps = uno.Any('[]com.sun.star.beans.PropertyValue', ps) + return ps + + +def _array_to_dict(values): + d = {v[0]: v[1] for v in values} + return d + + +def _property_to_dict(values): + d = {v.Name: v.Value for v in values} + return d + + +def json_dumps(data): + return json.dumps(data, indent=4, sort_keys=True) + + +def json_loads(data): + return json.loads(data) + + +def data_to_dict(data): + if isinstance(data, (tuple, list)) and isinstance(data[0], (tuple, list)): + return _array_to_dict(data) + + if isinstance(data, (tuple, list)) and isinstance(data[0], (PropertyValue, NamedValue)): + return _property_to_dict(data) + return {} + + +def _get_dispatch() -> Any: + return create_instance('com.sun.star.frame.DispatchHelper') + + +# ~ https://wiki.documentfoundation.org/Development/DispatchCommands +# ~ Used only if not exists in API +def call_dispatch(frame: Any, url: str, args: dict={}) -> None: + dispatch = _get_dispatch() + if hasattr(frame, 'frame'): + frame = frame.frame + opt = dict_to_property(args) + dispatch.executeDispatch(frame, url, '', 0, opt) + return + + +def get_desktop(): + return create_instance('com.sun.star.frame.Desktop', True) + + +def _date_to_struct(value): + if isinstance(value, datetime.datetime): + d = DateTime() + d.Year = value.year + d.Month = value.month + d.Day = value.day + d.Hours = value.hour + d.Minutes = value.minute + d.Seconds = value.second + elif isinstance(value, datetime.date): + d = Date() + d.Day = value.day + d.Month = value.month + d.Year = value.year + elif isinstance(value, datetime.time): + d = Time() + d.Hours = value.hour + d.Minutes = value.minute + d.Seconds = value.second + return d + + +def _struct_to_date(value): + d = None + if isinstance(value, Time): + d = datetime.time(value.Hours, value.Minutes, value.Seconds) + elif isinstance(value, Date): + if value != Date(): + d = datetime.date(value.Year, value.Month, value.Day) + elif isinstance(value, DateTime): + if value.Year > 0: + d = datetime.datetime( + value.Year, value.Month, value.Day, + value.Hours, value.Minutes, value.Seconds) + return d + + +def _get_url_script(args: dict): + library = args['library'] + name = args['name'] + language = args.get('language', 'Python') + location = args.get('location', 'user') + module = args.get('module', '.') + + if language == 'Python': + module = '.py$' + elif language == 'Basic': + module = f".{module}." + if location == 'user': + location = 'application' + + url = 'vnd.sun.star.script' + url = f'{url}:{library}{module}{name}?language={language}&location={location}' + return url + + +def _call_macro(args: dict): + #~ https://wiki.openoffice.org/wiki/Documentation/DevGuide/Scripting/Scripting_Framework_URI_Specification + + url = _get_url_script(args) + args = args.get('args', ()) + + service = 'com.sun.star.script.provider.MasterScriptProviderFactory' + factory = create_instance(service) + script = factory.createScriptProvider('').getScript(url) + result = script.invoke(args, None, None)[0] + + return result + + +def call_macro(args, in_thread=False): + result = None + if in_thread: + t = threading.Thread(target=_call_macro, args=(args,)) + t.start() + else: + result = _call_macro(args) + return result + + +def run(command, capture=False, split=False): + if split: + cmd = shlex.split(command) + result = subprocess.run(cmd, capture_output=capture, text=True, shell=IS_WIN) + if capture: + result = result.stdout + else: + result = result.returncode + else: + if capture: + result = subprocess.check_output(command, shell=True).decode() + else: + result = subprocess.Popen(command) + return result + + +def popen(command): + try: + proc = subprocess.Popen(shlex.split(command), shell=IS_WIN, + stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + for line in proc.stdout: + yield line.decode().rstrip() + except Exception as e: + error(e) + yield (e.errno, e.strerror) + + +def sleep(seconds): + time.sleep(seconds) + return + + +class TimerThread(threading.Thread): + + def __init__(self, event, seconds, macro): + threading.Thread.__init__(self) + self.stopped = event + self.seconds = seconds + self.macro = macro + + def run(self): + info('Timer started... {}'.format(self.macro['name'])) + while not self.stopped.wait(self.seconds): + _call_macro(self.macro) + info('Timer stopped... {}'.format(self.macro['name'])) + return + + +def start_timer(name, seconds, macro): + global _MACROS + _MACROS[name] = threading.Event() + thread = TimerThread(_MACROS[name], seconds, macro) + thread.start() + return + + +def stop_timer(name): + global _MACROS + _MACROS[name].set() + del _MACROS[name] + return + + +def install_locales(path: str, domain: str='base', dir_locales=DIR['locales']): + path_locales = _P.join(_P(path).path, dir_locales) + try: + lang = gettext.translation(domain, path_locales, languages=[LANG]) + lang.install() + _ = lang.gettext + except Exception as e: + from gettext import gettext as _ + error(e) + return _ + + +def _export_image(obj, args): + name = 'com.sun.star.drawing.GraphicExportFilter' + exporter = create_instance(name) + path = _P.to_system(args['URL']) + args = dict_to_property(args) + exporter.setSourceDocument(obj) + exporter.filter(args) + return _P.exists(path) + + +def sha256(data): + result = hashlib.sha256(data.encode()).hexdigest() + return result + + +def sha512(data): + result = hashlib.sha512(data.encode()).hexdigest() + return result + + +def get_config(key='', prefix='conf', default={}): + name_file = FILE_NAME_CONFIG.format(prefix) + values = {} + path = _P.join(_P.user_config, name_file) + if not _P.exists(path): + return default + + values = _P.from_json(path) + if key: + values = values.get(key, default) + + return values + + +def set_config(key, value, prefix='conf'): + name_file = FILE_NAME_CONFIG.format(prefix) + path = _P.join(_P.user_config, name_file) + values = get_config(prefix=prefix, default={}) + values[key] = value + result = _P.to_json(path, values) + return result + + +def start(): + global _start + + _start = now() + info(_start) + return + + +def end(get_seconds: bool=False): + global _start + + e = now() + td = e - _start + result = str(td) + if get_seconds: + result = td.total_seconds() + return result + + +def get_epoch(): + n = now() + return int(time.mktime(n.timetuple())) + + +def render(template, data): + s = Template(template) + return s.safe_substitute(**data) + + +def get_size_screen(): + res = '' + if IS_WIN: + user32 = ctypes.windll.user32 + res = f'{user32.GetSystemMetrics(0)}x{user32.GetSystemMetrics(1)}' + else: + try: + args = 'xrandr | grep "*" | cut -d " " -f4' + res = run(args, split=False) + except Exception as e: + error(e) + return res.strip() + + +def url_open(url, data=None, headers={}, verify=True, get_json=False, timeout=TIMEOUT): + err = '' + req = Request(url) + for k, v in headers.items(): + req.add_header(k, v) + try: + # ~ debug(url) + if verify: + if not data is None and isinstance(data, str): + data = data.encode() + response = urlopen(req, data=data, timeout=timeout) + else: + context = ssl._create_unverified_context() + response = urlopen(req, data=data, timeout=timeout, context=context) + except HTTPError as e: + error(e) + err = str(e) + except URLError as e: + error(e.reason) + err = str(e.reason) + except timeout: + err = 'timeout' + error(err) + else: + headers = dict(response.info()) + result = response.read().decode() + if get_json: + result = json.loads(result) + + return result, headers, err + + +def _get_key(password): + from cryptography.hazmat.primitives import hashes + from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC + + kdf = PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=SALT, + iterations=100000) + key = base64.urlsafe_b64encode(kdf.derive(password.encode())) + return key + + +def encrypt(data, password): + from cryptography.fernet import Fernet + + f = Fernet(_get_key(password)) + if isinstance(data, str): + data = data.encode() + token = f.encrypt(data).decode() + return token + + +def decrypt(token, password): + from cryptography.fernet import Fernet, InvalidToken + + data = '' + f = Fernet(_get_key(password)) + try: + data = f.decrypt(token.encode()).decode() + except InvalidToken as e: + error('Invalid Token') + return data + + +def switch_design_mode(doc): + call_dispatch(doc.frame, '.uno:SwitchControlDesignMode') + return + + +class SmtpServer(object): + + def __init__(self, config): + self._server = None + self._error = '' + self._sender = '' + self._is_connect = self._login(config) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + self.close() + + @property + def is_connect(self): + return self._is_connect + + @property + def error(self): + return self._error + + def _login(self, config): + name = config['server'] + port = config['port'] + is_ssl = config['ssl'] + self._sender = config['user'] + hosts = ('gmail' in name or 'outlook' in name) + try: + if is_ssl and hosts: + self._server = smtplib.SMTP(name, port, timeout=TIMEOUT) + self._server.ehlo() + self._server.starttls() + self._server.ehlo() + elif is_ssl: + self._server = smtplib.SMTP_SSL(name, port, timeout=TIMEOUT) + self._server.ehlo() + else: + self._server = smtplib.SMTP(name, port, timeout=TIMEOUT) + + self._server.login(self._sender, config['password']) + msg = 'Connect to: {}'.format(name) + debug(msg) + return True + except smtplib.SMTPAuthenticationError as e: + if '535' in str(e): + self._error = _('Incorrect user or password') + return False + if '534' in str(e) and 'gmail' in name: + self._error = _('Allow less secure apps in GMail') + return False + except smtplib.SMTPException as e: + self._error = str(e) + return False + except Exception as e: + self._error = str(e) + return False + return False + + def _body(self, msg): + body = msg.replace('\n', '
') + return body + + def send(self, message): + # ~ file_name = 'attachment; filename={}' + email = MIMEMultipart() + email['From'] = self._sender + email['To'] = message['to'] + email['Cc'] = message.get('cc', '') + email['Subject'] = message['subject'] + email['Date'] = formatdate(localtime=True) + if message.get('confirm', False): + email['Disposition-Notification-To'] = email['From'] + email.attach(MIMEText(self._body(message['body']), 'html')) + + paths = message.get('files', ()) + if isinstance(paths, str): + paths = (paths,) + for path in paths: + fn = _P(path).file_name + print('NAME', fn) + part = MIMEBase('application', 'octet-stream') + part.set_payload(_P.read_bin(path)) + encoders.encode_base64(part) + part.add_header('Content-Disposition', f'attachment; filename="{fn}"') + email.attach(part) + + receivers = ( + email['To'].split(',') + + email['CC'].split(',') + + message.get('bcc', '').split(',')) + try: + self._server.sendmail(self._sender, receivers, email.as_string()) + msg = 'Email sent...' + debug(msg) + if message.get('path', ''): + self.save_message(email, message['path']) + return True + except Exception as e: + self._error = str(e) + return False + return False + + def save_message(self, email, path): + mbox = mailbox.mbox(path, create=True) + mbox.lock() + try: + msg = mailbox.mboxMessage(email) + mbox.add(msg) + mbox.flush() + finally: + mbox.unlock() + return + + def close(self): + try: + self._server.quit() + msg = 'Close connection...' + debug(msg) + except: + pass + return + + +def _send_email(server, messages): + with SmtpServer(server) as server: + if server.is_connect: + for msg in messages: + server.send(msg) + else: + error(server.error) + return server.error + + +def send_email(server, message): + messages = message + if isinstance(message, dict): + messages = (message,) + t = threading.Thread(target=_send_email, args=(server, messages)) + t.start() + return + + +class ImapServer(object): + + def __init__(self, config): + self._server = None + self._error = '' + self._is_connect = self._login(config) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + self.close() + + @property + def is_connect(self): + return self._is_connect + + @property + def error(self): + return self._error + + def _login(self, config): + try: + # ~ hosts = 'gmail' in config['server'] + if config['ssl']: + self._server = imaplib.IMAP4_SSL(config['server'], config['port']) + else: + self._server = imaplib.IMAP4(config['server'], config['port']) + self._server.login(config['user'], config['password']) + self._server.select() + return True + except imaplib.IMAP4.error as e: + self._error = str(e) + return False + except Exception as e: + self._error = str(e) + return False + return False + + def get_folders(self, exclude=()): + folders = {} + result, subdir = self._server.list() + for s in subdir: + print(s.decode('utf-8')) + return folders + + def close(self): + try: + self._server.close() + self._server.logout() + msg = 'Close connection...' + debug(msg) + except: + pass + return + + +# ~ Classes + +class LOBaseObject(object): + + def __init__(self, obj): + self._obj = obj + + def __setattr__(self, name, value): + exists = hasattr(self, name) + if not exists and not name in ('_obj', '_index', '_view'): + setattr(self._obj, name, value) + else: + super().__setattr__(name, value) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + @property + def obj(self): + return self._obj + + +class LODocument(object): + + def __init__(self, obj): + self._obj = obj + self._cc = self.obj.getCurrentController() + self._undo = True + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + self.close() + + @property + def obj(self): + return self._obj + + @property + def title(self): + return self.obj.getTitle() + @title.setter + def title(self, value): + self.obj.setTitle(value) + + @property + def type(self): + return self._type + + @property + def uid(self): + return self.obj.RuntimeUID + + @property + def frame(self): + return self._cc.getFrame() + + @property + def is_saved(self): + return self.obj.hasLocation() + + @property + def is_modified(self): + return self.obj.isModified() + + @property + def is_read_only(self): + return self.obj.isReadonly() + + @property + def path(self): + return _P.to_system(self.obj.URL) + + @property + def dir(self): + return _P(self.path).path + + @property + def file_name(self): + return _P(self.path).file_name + + @property + def name(self): + return _P(self.path).name + + @property + def visible(self): + w = self.frame.ContainerWindow + return w.isVisible() + @visible.setter + def visible(self, value): + w = self.frame.ContainerWindow + w.setVisible(value) + + @property + def zoom(self): + return self._cc.ZoomValue + @zoom.setter + def zoom(self, value): + self._cc.ZoomValue = value + + @property + def undo(self): + return self._undo + @undo.setter + def undo(self, value): + self._undo = value + um = self.obj.UndoManager + if value: + try: + um.leaveUndoContext() + except: + pass + else: + um.enterHiddenUndoContext() + + def clear_undo(self): + self.obj.getUndoManager().clear() + return + + @property + def selection(self): + sel = self.obj.CurrentSelection + return sel + + @property + def table_auto_formats(self): + taf = create_instance('com.sun.star.sheet.TableAutoFormats') + return taf.ElementNames + + @property + def status_bar(self): + bar = self._cc.getStatusIndicator() + return bar + + def create_instance(self, name): + obj = self.obj.createInstance(name) + return obj + + def set_focus(self): + w = self.frame.ComponentWindow + w.setFocus() + return + + def copy(self): + call_dispatch(self.frame, '.uno:Copy') + return + + def insert_contents(self, args={}): + call_dispatch(self.frame, '.uno:InsertContents', args) + return + + def paste(self): + sc = create_instance('com.sun.star.datatransfer.clipboard.SystemClipboard') + transferable = sc.getContents() + self._cc.insertTransferable(transferable) + # ~ return self.obj.getCurrentSelection() + return + + # ~ def select(self, obj): + # ~ self._cc.select(obj) + # ~ return + + def to_pdf(self, path: str='', options: dict={}): + """ + https://wiki.documentfoundation.org/Macros/Python_Guide/PDF_export_filter_data + """ + args = options.copy() + stream = None + path_pdf = 'private:stream' + if path: + path_pdf = _P.to_url(path) + + filter_name = '{}_pdf_Export'.format(self.type) + filter_data = dict_to_property(args, True) + args = { + 'FilterName': filter_name, + 'FilterData': filter_data, + } + if not path: + stream = IOStream.output() + args['OutputStream'] = stream + + opt = dict_to_property(args) + try: + self.obj.storeToURL(path_pdf, opt) + except Exception as e: + error(e) + + if not stream is None: + stream = stream.buffer + + return stream + + def export(self, path: str='', filter_name: str='', options: dict={}): + FILTERS = { + 'xlsx': 'Calc MS Excel 2007 XML', + 'xls': 'MS Excel 97', + 'docx': 'MS Word 2007 XML', + 'doc': 'MS Word 97', + 'rtf': 'Rich Text Format', + } + args = options.copy() + stream = None + path_target = 'private:stream' + if path: + path_target = _P.to_url(path) + + filter_name = FILTERS.get(filter_name, filter_name) + filter_data = dict_to_property(args, True) + args = { + 'FilterName': filter_name, + 'FilterData': filter_data, + } + if not path: + stream = IOStream.output() + args['OutputStream'] = stream + + opt = dict_to_property(args) + try: + self.obj.storeToURL(path_target, opt) + except Exception as e: + error(e) + + if not stream is None: + stream = stream.buffer + + return stream + + def save(self, path: str='', options: dict={}): + if not path: + self.obj.store() + return + + args = options.copy() + path_target = _P.to_url(path) + + opt = dict_to_property(args) + try: + self.obj.storeAsURL(path_target, opt) + except Exception as e: + error(e) + + return + + def close(self): + self.obj.close(True) + return + + +class LOCellStyle(LOBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def name(self): + return self.obj.Name + + @property + def properties(self): + properties = self.obj.PropertySetInfo.Properties + data = {p.Name: getattr(self.obj, p.Name) for p in properties} + return data + @properties.setter + def properties(self, values): + _set_properties(self.obj, values) + + +class LOCellStyles(object): + + def __init__(self, obj, doc): + self._obj = obj + self._doc = doc + + def __len__(self): + return len(self.obj) + + def __getitem__(self, index): + return LOCellStyle(self.obj[index]) + + def __setitem__(self, key, value): + self.obj[key] = value + + def __delitem__(self, key): + if not isinstance(key, str): + key = key.Name + del self.obj[key] + + def __contains__(self, item): + return item in self.obj + + @property + def obj(self): + return self._obj + + @property + def names(self): + return self.obj.ElementNames + + def new(self, name: str=''): + obj = self._doc.create_instance('com.sun.star.style.CellStyle') + if name: + self.obj[name] = obj + obj = LOCellStyle(obj) + return obj + + +class LOCalc(LODocument): + + def __init__(self, obj): + super().__init__(obj) + self._type = CALC + self._sheets = obj.Sheets + + def __getitem__(self, index): + return LOCalcSheet(self._sheets[index]) + + def __setitem__(self, key, value): + self._sheets[key] = value + + def __len__(self): + return self._sheets.Count + + def __contains__(self, item): + return item in self._sheets + + @property + def names(self): + names = self.obj.Sheets.ElementNames + return names + + @property + def selection(self): + sel = self.obj.CurrentSelection + if sel.ImplementationName in TYPE_RANGES: + sel = LOCalcRange(sel) + elif sel.ImplementationName in OBJ_RANGES: + sel = LOCalcRanges(sel) + elif sel.ImplementationName == OBJ_SHAPES: + if len(sel) == 1: + sel = LOShape(sel[0]) + else: + debug(sel.ImplementationName) + return sel + + @property + def active(self): + return LOCalcSheet(self._cc.ActiveSheet) + + @property + def headers(self): + return self._cc.ColumnRowHeaders + @headers.setter + def headers(self, value): + self._cc.ColumnRowHeaders = value + + @property + def tabs(self): + return self._cc.SheetTabs + @tabs.setter + def tabs(self, value): + self._cc.SheetTabs = value + + @property + def cs(self): + return self.cell_styles + @property + def cell_styles(self): + obj = self.obj.StyleFamilies['CellStyles'] + return LOCellStyles(obj, self) + + @property + def db_ranges(self): + # ~ return LOCalcDataBaseRanges(self.obj.DataBaseRanges) + return self.obj.DatabaseRanges + + @property + def ranges(self): + obj = self.create_instance('com.sun.star.sheet.SheetCellRanges') + return LOCalcRanges(obj) + + def get_ranges(self, address: str): + ranges = self.ranges + ranges.add([sheet[address] for sheet in self]) + return ranges + + def activate(self, sheet): + obj = sheet + if isinstance(sheet, LOCalcSheet): + obj = sheet.obj + elif isinstance(sheet, str): + obj = self._sheets[sheet] + self._cc.setActiveSheet(obj) + return + + def new_sheet(self): + s = self.create_instance('com.sun.star.sheet.Spreadsheet') + return s + + def insert(self, name): + names = name + if isinstance(name, str): + names = (name,) + for n in names: + self._sheets[n] = self.new_sheet() + return LOCalcSheet(self._sheets[n]) + + def move(self, name, pos=-1): + index = pos + if pos < 0: + index = len(self) + if isinstance(name, LOCalcSheet): + name = name.name + self._sheets.moveByName(name, index) + return + + def remove(self, name): + if isinstance(name, LOCalcSheet): + name = name.name + self._sheets.removeByName(name) + return + + def copy_sheet(self, name, new_name='', pos=-1): + if isinstance(name, LOCalcSheet): + name = name.name + index = pos + if pos < 0: + index = len(self) + self._sheets.copyByName(name, new_name, index) + return LOCalcSheet(self._sheets[new_name]) + + def copy_from(self, doc, source='', target='', pos=-1): + index = pos + if pos < 0: + index = len(self) + + names = source + if not source: + names = doc.names + elif isinstance(source, str): + names = (source,) + + new_names = target + if not target: + new_names = names + elif isinstance(target, str): + new_names = (target,) + + for i, name in enumerate(names): + self._sheets.importSheet(doc.obj, name, index + i) + self[index + i].name = new_names[i] + + return LOCalcSheet(self._sheets[index]) + + def sort(self, reverse=False): + names = sorted(self.names, reverse=reverse) + for i, n in enumerate(names): + self.move(n, i) + return + + def render(self, data, sheet=None, clean=True): + if sheet is None: + sheet = self.active + return sheet.render(data, clean=clean) + + def select(self, rango): + self._cc.select(rango.obj) + return + + +class LOChart(object): + + def __init__(self, name, obj, draw_page): + self._name = name + self._obj = obj + self._eobj = self._obj.EmbeddedObject + self._type = 'Column' + self._cell = None + self._shape = self._get_shape(draw_page) + self._pos = self._shape.Position + + def __getitem__(self, index): + return LOBaseObject(self.diagram.getDataRowProperties(index)) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + @property + def obj(self): + return self._obj + + @property + def name(self): + return self._name + + @property + def diagram(self): + return self._eobj.Diagram + + @property + def type(self): + return self._type + @type.setter + def type(self, value): + self._type = value + if value == 'Bar': + self.diagram.Vertical = True + return + type_chart = f'com.sun.star.chart.{value}Diagram' + self._eobj.setDiagram(self._eobj.createInstance(type_chart)) + + @property + def cell(self): + return self._cell + @cell.setter + def cell(self, value): + self._cell = value + self._shape.Anchor = value.obj + + @property + def position(self): + return self._pos + @position.setter + def position(self, value): + self._pos = value + self._shape.Position = value + + def _get_shape(self, draw_page): + for shape in draw_page: + if shape.PersistName == self.name: + break + return shape + + +class LOSheetCharts(object): + + def __init__(self, obj, sheet): + self._obj = obj + self._sheet = sheet + + def __getitem__(self, index): + return LOChart(index, self.obj[index], self._sheet.draw_page) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + def __contains__(self, item): + return item in self.obj + + def __len__(self): + return len(self.obj) + + @property + def obj(self): + return self._obj + + def new(self, name, pos_size, data): + self.obj.addNewByName(name, pos_size, data, True, True) + return LOChart(name, self.obj[name], self._sheet.draw_page) + + +class LOSheetTableField(object): + + def __init__(self, obj): + self._obj = obj + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + @property + def obj(self): + return self._obj + + @property + def name(self): + return self.obj.Name + + @property + def orientation(self): + return self.obj.Orientation + @orientation.setter + def orientation(self, value): + self.obj.Orientation = value + + +# ~ com.sun.star.sheet.DataPilotFieldOrientation.ROW +class LOSheetTable(object): + + def __init__(self, obj): + self._obj = obj + self._source = None + + def __getitem__(self, index): + field = self.obj.DataPilotFields[index] + return LOSheetTableField(field) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + @property + def obj(self): + return self._obj + + @property + def filter(self): + return self.obj.ShowFilterButton + @filter.setter + def filter(self, value): + self.obj.ShowFilterButton = value + + @property + def source(self): + return self._source + @source.setter + def source(self, value): + self._source = value + self.obj.SourceRange = value.range_address + + @property + def rows(self): + return self.obj.RowFields + @rows.setter + def rows(self, values): + if not isinstance(values, tuple): + values = (values,) + for v in values: + with self[v] as f: + f.orientation = DPFO.ROW + @property + def columns(self): + return self.obj.ColumnFields + @columns.setter + def columns(self, values): + if not isinstance(values, tuple): + values = (values,) + for v in values: + with self[v] as f: + f.orientation = DPFO.COLUMN + + @property + def data(self): + return self.obj.DataFields + @data.setter + def data(self, values): + if not isinstance(values, tuple): + values = (values,) + for v in values: + with self[v] as f: + f.orientation = DPFO.DATA + + +class LOSheetTables(object): + + def __init__(self, obj, sheet): + self._obj = obj + self._sheet = sheet + + def __getitem__(self, index): + return LOSheetTable(self.obj[index]) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + def __contains__(self, item): + return item in self.obj + + @property + def obj(self): + return self._obj + + @property + def count(self): + return self.obj.Count + + @property + def names(self): + return self.obj.ElementNames + + def new(self, name, target): + table = self.obj.createDataPilotDescriptor() + self.obj.insertNewByName(name, target.address, table) + return LOSheetTable(self.obj[name]) + + def remove(self, name): + self.obj.removeByName(name) + return + + +# ~ class LOFormControl(LOBaseObject): +class LOFormControl(): + EVENTS = { + 'action': 'actionPerformed', + 'click': 'mousePressed', + } + TYPES = { + 'actionPerformed': 'XActionListener', + 'mousePressed': 'XMouseListener', + } + + def __init__(self, obj, view, form): + self._obj = obj + self._view = view + self._form = form + self._m = view.Model + self._index = -1 + + # ~ def __setattr__(self, name, value): + # ~ if name in ('_form', '_view', '_m', '_index'): + # ~ self.__dict__[name] = value + # ~ else: + # ~ super().__setattr__(name, value) + + def __str__(self): + return f'{self.name} ({self.type}) {[self.index]}' + + @property + def obj(self): + return self._obj + + @property + def form(self): + return self._form + + @property + def doc(self): + return self.obj.Parent.Forms.Parent + + @property + def name(self): + return self._m.Name + @name.setter + def name(self, value): + self._m.Name = value + + @property + def tag(self): + return self._m.Tag + @tag.setter + def tag(self, value): + self._m.Tag = value + + @property + def index(self): + return self._index + @index.setter + def index(self, value): + self._index = value + + @property + def enabled(self): + return self._m.Enabled + @enabled.setter + def enabled(self, value): + self._m.Enabled = value + + @property + def anchor(self): + return self.obj.Anchor + @anchor.setter + def anchor(self, value): + size = None + if hasattr(value, 'obj'): + size = getattr(value, 'size', None) + value = value.obj + self.obj.Anchor = value + if not size is None: + self.size = size + try: + self.obj.ResizeWithCell = True + except: + pass + + @property + def size(self): + return self.obj.Size + @size.setter + def size(self, value): + self.obj.Size = value + + @property + def events(self): + return self.form.getScriptEvents(self.index) + def add_event(self, name, macro): + if not 'name' in macro: + macro['name'] = '{}_{}'.format(self.name, name) + + event = ScriptEventDescriptor() + event.AddListenerParam = '' + event.EventMethod = self.EVENTS[name] + event.ListenerType = self.TYPES[event.EventMethod] + event.ScriptCode = _get_url_script(macro) + event.ScriptType = 'Script' + + for ev in self.events: + if ev.EventMethod == event.EventMethod and \ + ev.ListenerType == event.ListenerType: + self.form.revokeScriptEvent(self.index, + event.ListenerType, event.EventMethod, event.AddListenerParam) + break + + self.form.registerScriptEvent(self.index, event) + return + + def set_focus(self): + self._view.setFocus() + return + + +class LOFormControlLabel(LOFormControl): + + def __init__(self, obj, view, form): + super().__init__(obj, view, form) + + @property + def type(self): + return 'label' + + @property + def value(self): + return self._m.Label + @value.setter + def value(self, value): + self._m.Label = value + + +class LOFormControlText(LOFormControl): + + def __init__(self, obj, view, form): + super().__init__(obj, view, form) + + @property + def type(self): + return 'text' + + @property + def value(self): + return self._m.Text + @value.setter + def value(self, value): + self._m.Text = value + + +class LOFormControlButton(LOFormControl): + + def __init__(self, obj, view, form): + super().__init__(obj, view, form) + + @property + def type(self): + return 'button' + + @property + def value(self): + return self._m.Label + @value.setter + def value(self, value): + self._m.Text = Label + + @property + def url(self): + return self._m.TargetURL + @url.setter + def url(self, value): + self._m.TargetURL = value + self._m.ButtonType = FormButtonType.URL + + +FORM_CONTROL_CLASS = { + 'label': LOFormControlLabel, + 'text': LOFormControlText, + 'button': LOFormControlButton, +} + + +class LOForm(object): + MODELS = { + 'label': 'com.sun.star.form.component.FixedText', + 'text': 'com.sun.star.form.component.TextField', + 'button': 'com.sun.star.form.component.CommandButton', + } + + def __init__(self, obj, draw_page): + self._obj = obj + self._dp = draw_page + self._controls = {} + self._init_controls() + + def __getitem__(self, index): + control = self.obj[index] + return self._controls[control.Name] + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + def __contains__(self, item): + return item in self.obj + + def __len__(self): + return len(self.obj) + + def __str__(self): + return f'Form: {self.name}' + + def _init_controls(self): + types = { + 'com.sun.star.form.OFixedTextModel': 'label', + 'com.sun.star.form.OEditModel': 'text', + 'com.sun.star.form.OButtonModel': 'button', + } + for i, control in enumerate(self.obj): + name = control.Name + tipo = types[control.ImplementationName] + view = self.doc.CurrentController.getControl(control) + control = FORM_CONTROL_CLASS[tipo](control, view, self._obj) + control.index = i + setattr(self, name, control) + self._controls[name] = control + return + + @property + def obj(self): + return self._obj + + @property + def name(self): + return self.obj.Name + @name.setter + def name(self, value): + self.obj.Name = value + + @property + def source(self): + return self.obj.DataSourceName + @source.setter + def source(self, value): + self.obj.DataSourceName = value + + @property + def type(self): + return self.obj.CommandType + @type.setter + def type(self, value): + self.obj.CommandType = value + + @property + def command(self): + return self.obj.Command + @command.setter + def command(self, value): + self.obj.Command = value + + @property + def doc(self): + return self.obj.Parent.Parent + + def _special_properties(self, tipo, args): + if tipo == 'button': + # ~ if 'ImageURL' in args: + # ~ args['ImageURL'] = self._set_image_url(args['ImageURL']) + args['FocusOnClick'] = args.get('FocusOnClick', False) + return args + return args + + def add(self, args): + name = args['Name'] + tipo = args.pop('Type').lower() + w = args.pop('Width', 1000) + h = args.pop('Height', 200) + x = args.pop('X', 0) + y = args.pop('Y', 0) + control = self.doc.createInstance('com.sun.star.drawing.ControlShape') + control.setSize(Size(w, h)) + control.setPosition(Point(x, y)) + model = self.doc.createInstance(self.MODELS[tipo]) + args = self._special_properties(tipo, args) + _set_properties(model, args) + control.Control = model + index = len(self) + self.obj.insertByIndex(index, model) + self._dp.add(control) + view = self.doc.CurrentController.getControl(self.obj.getByName(name)) + control = FORM_CONTROL_CLASS[tipo](control, view, self.obj) + control.index = index + setattr(self, name, control) + self._controls[name] = control + return control + + +class LOSheetForms(object): + + def __init__(self, draw_page): + self._dp = draw_page + self._obj = draw_page.Forms + + def __getitem__(self, index): + return LOForm(self.obj[index], self._dp) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + def __contains__(self, item): + return item in self.obj + + def __len__(self): + return len(self.obj) + + @property + def obj(self): + return self._obj + + @property + def doc(self): + return self.obj.Parent + + @property + def count(self): + return len(self) + + @property + def names(self): + return self.obj.ElementNames + + def insert(self, name=''): + if not name: + name = f'form{self.count + 1}' + form = self.doc.createInstance('com.sun.star.form.component.Form') + self.obj.insertByName(name, form) + return LOForm(form, self._dp) + + def remove(self, index): + if isinstance(index, int): + self.obj.removeByIndex(index) + else: + self.obj.removeByName(index) + return + + +# ~ IsFiltered, +# ~ IsManualPageBreak, +# ~ IsStartOfNewPage +class LOSheetRows(object): + + def __init__(self, sheet, obj): + self._sheet = sheet + self._obj = obj + + def __getitem__(self, index): + if isinstance(index, int): + rows = LOSheetRows(self._sheet, self.obj[index]) + else: + rango = self._sheet[index.start:index.stop,0:] + rows = LOSheetRows(self._sheet, rango.obj.Rows) + return rows + + def __len__(self): + return self.obj.Count + + @property + def obj(self): + return self._obj + + @property + def visible(self): + return self._obj.IsVisible + @visible.setter + def visible(self, value): + self._obj.IsVisible = value + + @property + def color(self): + return self.obj.CellBackColor + @color.setter + def color(self, value): + self.obj.CellBackColor = value + + @property + def is_transparent(self): + return self.obj.IsCellBackgroundTransparent + @is_transparent.setter + def is_transparent(self, value): + self.obj.IsCellBackgroundTransparent = value + + @property + def height(self): + return self.obj.Height + @height.setter + def height(self, value): + self.obj.Height = value + + def optimal(self): + self.obj.OptimalHeight = True + return + + def insert(self, index, count): + self.obj.insertByIndex(index, count) + return + + def remove(self, index, count): + self.obj.removeByIndex(index, count) + return + + +# ~ IsManualPageBreak, +# ~ IsStartOfNewPage +class LOSheetColumns(object): + + def __init__(self, sheet, obj): + self._sheet = sheet + self._obj = obj + + def __getitem__(self, index): + if isinstance(index, (int, str)): + rows = LOSheetColumns(self._sheet, self.obj[index]) + else: + rango = self._sheet[0,index.start:index.stop] + rows = LOSheetColumns(self._sheet, rango.obj.Columns) + return rows + + def __len__(self): + return self.obj.Count + + @property + def obj(self): + return self._obj + + @property + def visible(self): + return self._obj.IsVisible + @visible.setter + def visible(self, value): + self._obj.IsVisible = value + + @property + def width(self): + return self.obj.Width + @width.setter + def width(self, value): + self.obj.Width = value + + def optimal(self): + self.obj.OptimalWidth = True + return + + def insert(self, index, count): + self.obj.insertByIndex(index, count) + return + + def remove(self, index, count): + self.obj.removeByIndex(index, count) + return + + +class LOCalcSheet(object): + + def __init__(self, obj): + self._obj = obj + + def __getitem__(self, index): + return LOCalcRange(self.obj[index]) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + def __str__(self): + return f'easymacro.LOCalcSheet: {self.name}' + + @property + def obj(self): + return self._obj + + @property + def name(self): + return self._obj.Name + @name.setter + def name(self, value): + self._obj.Name = value + + @property + def code_name(self): + return self._obj.CodeName + @code_name.setter + def code_name(self, value): + self._obj.CodeName = value + + @property + def visible(self): + return self._obj.IsVisible + @visible.setter + def visible(self, value): + self._obj.IsVisible = value + + @property + def is_protected(self): + return self._obj.isProtected() + + @property + def password(self): + return '' + @visible.setter + def password(self, value): + self.obj.protect(value) + + def unprotect(self, value): + try: + self.obj.unprotect(value) + return True + except: + pass + return False + + @property + def color(self): + return self._obj.TabColor + @color.setter + def color(self, value): + self._obj.TabColor = get_color(value) + + @property + def used_area(self): + cursor = self.get_cursor() + cursor.gotoEndOfUsedArea(True) + return LOCalcRange(self[cursor.AbsoluteName].obj) + + @property + def draw_page(self): + return LODrawPage(self.obj.DrawPage) + @property + def dp(self): + return self.draw_page + + @property + def shapes(self): + return self.draw_page + + @property + def doc(self): + return LOCalc(self.obj.DrawPage.Forms.Parent) + + @property + def charts(self): + return LOSheetCharts(self.obj.Charts, self) + + @property + def tables(self): + return LOSheetTables(self.obj.DataPilotTables, self) + + @property + def rows(self): + return LOSheetRows(self, self.obj.Rows) + + @property + def columns(self): + return LOSheetColumns(self, self.obj.Columns) + + @property + def forms(self): + return LOSheetForms(self.obj.DrawPage) + + @property + def events(self): + names = ('OnFocus', 'OnUnfocus', 'OnSelect', 'OnDoubleClick', + 'OnRightClick', 'OnChange', 'OnCalculate') + evs = self.obj.Events + events = {n: _property_to_dict(evs.getByName(n)) for n in names + if evs.getByName(n)} + return events + @events.setter + def events(self, values): + pv = '[]com.sun.star.beans.PropertyValue' + ev = self.obj.Events + for name, v in values.items(): + url = _get_url_script(v) + args = dict_to_property(dict(EventType='Script', Script=url)) + # ~ e.replaceByName(k, args) + uno.invoke(ev, 'replaceByName', (name, uno.Any(pv, args))) + + @property + def search_descriptor(self): + return self.obj.createSearchDescriptor() + + @property + def replace_descriptor(self): + return self.obj.createReplaceDescriptor() + + def activate(self): + self.doc.activate(self.obj) + return + + # ~ ??? + def clean(self): + doc = self.doc + sheet = doc.create_instance('com.sun.star.sheet.Spreadsheet') + doc._sheets.replaceByName(self.name, sheet) + return + + def move(self, pos=-1): + index = pos + if pos < 0: + index = len(self.doc) + self.doc._sheets.moveByName(self.name, index) + return + + def remove(self): + self.doc._sheets.removeByName(self.name) + return + + def copy(self, new_name='', pos=-1): + index = pos + if pos < 0: + index = len(self.doc) + self.doc._sheets.copyByName(self.name, new_name, index) + return LOCalcSheet(self.doc._sheets[new_name]) + + def copy_to(self, doc, target='', pos=-1): + index = pos + if pos < 0: + index = len(doc) + + new_name = target or self.name + new_pos = doc._sheets.importSheet(self.doc.obj, self.name, index) + sheet = doc[new_pos] + sheet.name = new_name + return sheet + + def get_cursor(self, cell=None): + if cell is None: + cursor = self.obj.createCursor() + else: + cursor = self.obj.createCursorByRange(cell) + return cursor + + def render(self, data, rango=None, clean=True): + if rango is None: + rango = self.used_area + return rango.render(data, clean) + + def find(self, search_string, rango=None): + if rango is None: + rango = self.used_area + return rango.find(search_string) + + +class LOCalcRange(object): + + def __init__(self, obj): + self._obj = obj + self._sd = None + self._is_cell = obj.ImplementationName == OBJ_CELL + + def __getitem__(self, index): + return LOCalcRange(self.obj[index]) + + def __iter__(self): + self._r = 0 + self._c = 0 + return self + + def __next__(self): + try: + rango = self[self._r, self._c] + except Exception as e: + raise StopIteration + self._c += 1 + if self._c == self.columns: + self._c = 0 + self._r +=1 + return rango + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + def __contains__(self, item): + return item.in_range(self) + + def __str__(self): + if self.is_none: + s = 'Range: None' + else: + s = f'Range: {self.name}' + return s + + @property + def obj(self): + return self._obj + + @property + def is_none(self): + return self.obj is None + + @property + def is_cell(self): + return self._is_cell + + @property + def back_color(self): + return self._obj.CellBackColor + @back_color.setter + def back_color(self, value): + self._obj.CellBackColor = get_color(value) + + @property + def dp(self): + return self.sheet.dp + + @property + def sheet(self): + return LOCalcSheet(self.obj.Spreadsheet) + + @property + def doc(self): + doc = self.obj.Spreadsheet.DrawPage.Forms.Parent + return LODocument(doc) + + @property + def name(self): + return self.obj.AbsoluteName + + @property + def code_name(self): + name = self.name.replace('$', '').replace('.', '_').replace(':', '') + return name + + @property + def columns(self): + return self.obj.Columns.Count + + @property + def column(self): + c1 = self.address.Column + c2 = c1 + 1 + ra = self.current_region.range_address + r1 = ra.StartRow + r2 = ra.EndRow + 1 + return LOCalcRange(self.sheet[r1:r2, c1:c2].obj) + + @property + def rows(self): + return LOSheetRows(self.sheet, self.obj.Rows) + + @property + def row(self): + r1 = self.address.Row + r2 = r1 + 1 + ra = self.current_region.range_address + c1 = ra.StartColumn + c2 = ra.EndColumn + 1 + return LOCalcRange(self.sheet[r1:r2, c1:c2].obj) + + @property + def type(self): + return self.obj.Type + + @property + def error(self): + return self.obj.getError() + + @property + def value(self): + v = None + if self.type == VALUE: + v = self.obj.getValue() + elif self.type == TEXT: + v = self.obj.getString() + elif self.type == FORMULA: + v = self.obj.getFormula() + return v + @value.setter + def value(self, data): + if isinstance(data, str): + if data[0] in '=': + self.obj.setFormula(data) + else: + self.obj.setString(data) + elif isinstance(data, Decimal): + self.obj.setValue(float(data)) + elif isinstance(data, (int, float, bool)): + self.obj.setValue(data) + elif isinstance(data, datetime.datetime): + d = data.toordinal() + t = (data - datetime.datetime.fromordinal(d)).seconds / SECONDS_DAY + self.obj.setValue(d - DATE_OFFSET + t) + elif isinstance(data, datetime.date): + d = data.toordinal() + self.obj.setValue(d - DATE_OFFSET) + elif isinstance(data, datetime.time): + d = (data.hour * 3600 + data.minute * 60 + data.second) / SECONDS_DAY + self.obj.setValue(d) + + @property + def str(self): + return self.obj.String + @str.setter + def str(self, value): + self.obj.setString(value) + + @property + def date(self): + value = int(self.obj.Value) + date = datetime.date.fromordinal(value + DATE_OFFSET) + return date + + @property + def time(self): + seconds = self.obj.Value * SECONDS_DAY + time_delta = datetime.timedelta(seconds=seconds) + time = (datetime.datetime.min + time_delta).time() + return time + + @property + def datetime(self): + return datetime.datetime.combine(self.date, self.time) + + @property + def data(self): + return self.obj.getDataArray() + @data.setter + def data(self, values): + if self._is_cell: + self.to_size(len(values), len(values[0])).data = values + else: + self.obj.setDataArray(values) + + @property + def dict(self): + rows = self.data + k = rows[0] + data = [dict(zip(k, r)) for r in rows[1:]] + return data + @dict.setter + def dict(self, values): + data = [tuple(values[0].keys())] + data += [tuple(d.values()) for d in values] + self.data = data + + @property + def formula(self): + return self.obj.getFormulaArray() + @formula.setter + def formula(self, values): + self.obj.setFormulaArray(values) + + @property + def array_formula(self): + return self.obj.ArrayFormula + @array_formula.setter + def array_formula(self, value): + self.obj.ArrayFormula = value + + @property + def address(self): + return self.obj.CellAddress + + @property + def range_address(self): + return self.obj.RangeAddress + + @property + def cursor(self): + cursor = self.obj.Spreadsheet.createCursorByRange(self.obj) + return cursor + + @property + def current_region(self): + cursor = self.cursor + cursor.collapseToCurrentRegion() + return LOCalcRange(self.sheet[cursor.AbsoluteName].obj) + + @property + def next_cell(self): + a = self.current_region.range_address + col = a.StartColumn + row = a.EndRow + 1 + return LOCalcRange(self.sheet[row, col].obj) + + @property + def position(self): + return self.obj.Position + + @property + def size(self): + return self.obj.Size + + @property + def possize(self): + data = { + 'Width': self.size.Width, + 'Height': self.size.Height, + 'X': self.position.X, + 'Y': self.position.Y, + } + return data + + @property + def visible(self): + cursor = self.cursor + rangos = cursor.queryVisibleCells() + rangos = LOCalcRanges(rangos) + return rangos + + @property + def merged_area(self): + cursor = self.cursor + cursor.collapseToMergedArea() + rango = LOCalcRange(self.sheet[cursor.AbsoluteName].obj) + return rango + + @property + def empty(self): + cursor = self.sheet.get_cursor(self.obj) + cursor = self.cursor + rangos = cursor.queryEmptyCells() + rangos = [LOCalcRange(self.sheet[r.AbsoluteName].obj) for r in rangos] + return tuple(rangos) + + @property + def merge(self): + return self.obj.IsMerged + @merge.setter + def merge(self, value): + self.obj.merge(value) + + @property + def style(self): + return self.obj.CellStyle + @style.setter + def style(self, value): + self.obj.CellStyle = value + + @property + def auto_format(self): + return '' + @auto_format.setter + def auto_format(self, value): + self.obj.autoFormat(value) + + @property + def validation(self): + return self.obj.Validation + @validation.setter + def validation(self, values): + current = self.validation + if not values: + current.Type = ValidationType.ANY + current.ShowInputMessage = False + else: + is_list = False + for k, v in values.items(): + if k == 'Type' and v == VT.LIST: + is_list = True + if k == 'Formula1' and is_list: + if isinstance(v, (tuple, list)): + v = ';'.join(['"{}"'.format(i) for i in v]) + setattr(current, k, v) + self.obj.Validation = current + + def select(self): + self.doc._cc.select(self.obj) + return + + def search(self, options, find_all=True): + rangos = None + + descriptor = self.sheet.search_descriptor + descriptor.setSearchString(options['Search']) + descriptor.SearchCaseSensitive = options.get('CaseSensitive', False) + descriptor.SearchWords = options.get('Words', False) + if hasattr(descriptor, 'SearchRegularExpression'): + descriptor.SearchRegularExpression = options.get('RegularExpression', False) + if hasattr(descriptor, 'SearchType') and 'Type' in options: + descriptor.SearchType = options['Type'] + + if find_all: + found = self.obj.findAll(descriptor) + else: + found = self.obj.findFirst(descriptor) + + if found: + if found.ImplementationName == OBJ_CELL: + rangos = LOCalcRange(found) + else: + rangos = [LOCalcRange(f) for f in found] + + return rangos + + def replace(self, options): + descriptor = self.sheet.replace_descriptor + descriptor.setSearchString(options['Search']) + descriptor.setReplaceString(options['Replace']) + descriptor.SearchCaseSensitive = options.get('CaseSensitive', False) + descriptor.SearchWords = options.get('Words', False) + if hasattr(descriptor, 'SearchRegularExpression'): + descriptor.SearchRegularExpression = options.get('RegularExpression', False) + if hasattr(descriptor, 'SearchType') and 'Type' in options: + descriptor.SearchType = options['Type'] + count = self.obj.replaceAll(descriptor) + return count + + def in_range(self, rango): + if isinstance(rango, LOCalcRange): + address = rango.range_address + else: + address = rango.RangeAddress + result = self.cursor.queryIntersection(address) + return bool(result.Count) + + def offset(self, rows=0, cols=1): + ra = self.range_address + col = ra.EndColumn + cols + row = ra.EndRow + rows + return LOCalcRange(self.sheet[row, col].obj) + + def to_size(self, rows, cols): + cursor = self.cursor + cursor.collapseToSize(cols, rows) + return LOCalcRange(self.sheet[cursor.AbsoluteName].obj) + + def move(self, target): + sheet = self.sheet.obj + sheet.moveRange(target.address, self.range_address) + return + + def insert(self, insert_mode=CIM.DOWN): + sheet = self.sheet.obj + sheet.insertCells(self.range_address, insert_mode) + return + + def delete(self, delete_mode=CDM.UP): + sheet = self.sheet.obj + sheet.removeRange(self.range_address, delete_mode) + return + + def copy_from(self, source): + self.sheet.obj.copyRange(self.address, source.range_address) + return + + def copy_to(self, target): + self.sheet.obj.copyRange(target.address, self.range_address) + return + + # ~ def copy_to(self, cell, formula=False): + # ~ rango = cell.to_size(self.rows, self.columns) + # ~ if formula: + # ~ rango.formula = self.formula + # ~ else: + # ~ rango.data = self.data + # ~ return + + # ~ def copy_from(self, rango, formula=False): + # ~ data = rango + # ~ if isinstance(rango, LOCalcRange): + # ~ if formula: + # ~ data = rango.formula + # ~ else: + # ~ data = rango.data + # ~ rows = len(data) + # ~ cols = len(data[0]) + # ~ if formula: + # ~ self.to_size(rows, cols).formula = data + # ~ else: + # ~ self.to_size(rows, cols).data = data + # ~ return + + def optimal_width(self): + self.obj.Columns.OptimalWidth = True + return + + def clean_render(self, template='\{(\w.+)\}'): + self._sd.SearchRegularExpression = True + self._sd.setSearchString(template) + self.obj.replaceAll(self._sd) + return + + def render(self, data, clean=True): + self._sd = self.sheet.obj.createSearchDescriptor() + self._sd.SearchCaseSensitive = False + for k, v in data.items(): + cell = self._render_value(k, v) + return cell + + def _render_value(self, key, value, parent=''): + cell = None + if isinstance(value, dict): + for k, v in value.items(): + # ~ print(1, 'RENDER', k, v) + cell = self._render_value(k, v, key) + return cell + elif isinstance(value, (list, tuple)): + self._render_list(key, value) + return + + search = f'{{{key}}}' + if parent: + search = f'{{{parent}.{key}}}' + ranges = self.find_all(search) + + if ranges is None: + return + + # ~ for cell in ranges or range(0): + for cell in ranges: + self._set_new_value(cell, search, value) + return LOCalcRange(cell) + + def _set_new_value(self, cell, search, value): + if not cell.ImplementationName == 'ScCellObj': + return + + if isinstance(value, str): + pattern = re.compile(search, re.IGNORECASE) + new_value = pattern.sub(value, cell.String) + cell.String = new_value + else: + LOCalcRange(cell).value = value + return + + def _render_list(self, key, rows): + for row in rows: + for k, v in row.items(): + self._render_value(k, v) + return + + def find(self, search_string): + if self._sd is None: + self._sd = self.sheet.obj.createSearchDescriptor() + self._sd.SearchCaseSensitive = False + + self._sd.setSearchString(search_string) + cell = self.obj.findFirst(self._sd) + if cell: + cell = LOCalcRange(cell) + return cell + + def find_all(self, search_string): + if self._sd is None: + self._sd = self.sheet.obj.createSearchDescriptor() + self._sd.SearchCaseSensitive = False + + self._sd.setSearchString(search_string) + ranges = self.obj.findAll(self._sd) + return ranges + + def filter(self, args, with_headers=True): + ff = TableFilterField() + ff.Field = args['Field'] + ff.Operator = args['Operator'] + if isinstance(args['Value'], str): + ff.IsNumeric = False + ff.StringValue = args['Value'] + else: + ff.IsNumeric = True + ff.NumericValue = args['Value'] + + fd = self.obj.createFilterDescriptor(True) + fd.ContainsHeader = with_headers + fd.FilterFields = ((ff,)) + # ~ self.obj.AutoFilter = True + self.obj.filter(fd) + return + + def copy_format_from(self, rango): + rango.select() + self.doc.copy() + self.select() + args = { + 'Flags': 'T', + 'MoveMode': 4, + } + url = '.uno:InsertContents' + call_dispatch(self.doc.frame, url, args) + return + + def to_image(self): + self.select() + self.doc.copy() + args = {'SelectedFormat': 141} + url = '.uno:ClipboardFormatItems' + call_dispatch(self.doc.frame, url, args) + return self.sheet.shapes[-1] + + def insert_image(self, path, options={}): + args = options.copy() + ps = self.possize + args['Width'] = args.get('Width', ps['Width']) + args['Height'] = args.get('Height', ps['Height']) + args['X'] = args.get('X', ps['X']) + args['Y'] = args.get('Y', ps['Y']) + # ~ img.ResizeWithCell = True + img = self.sheet.dp.insert_image(path, args) + img.anchor = self.obj + args.clear() + return img + + def insert_shape(self, tipo, args={}): + ps = self.possize + args['Width'] = args.get('Width', ps['Width']) + args['Height'] = args.get('Height', ps['Height']) + args['X'] = args.get('X', ps['X']) + args['Y'] = args.get('Y', ps['Y']) + + shape = self.sheet.dp.add(tipo, args) + shape.anchor = self.obj + args.clear() + return + + def filter_by_color(self, cell): + rangos = cell.column[1:,:].visible + for r in rangos: + for c in r: + if c.back_color != cell.back_color: + c.rows.visible = False + return + + def clear(self, what=1023): + # ~ http://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1sheet_1_1CellFlags.html + self.obj.clearContents(what) + return + + def transpose(self): + # ~ 'Flags': 'A', + # ~ 'FormulaCommand': 0, + # ~ 'SkipEmptyCells': False, + # ~ 'AsLink': False, + # ~ 'MoveMode': 4, + self.select() + self.doc.copy() + self.clear(1023) + self[0,0].select() + self.doc.insert_contents({'Transpose': True}) + _CB.set('') + return + + def transpose_data(self, formula=False): + data = self.data + if formula: + data = self.formula + data = tuple(zip(*data)) + self.clear(1023) + self[0,0].copy_from(data, formula=formula) + return + + def merge_by_row(self): + for r in range(len(self.rows)): + self[r].merge = True + return + + def fill(self, source=1): + self.obj.fillAuto(0, source) + return + + def _cast(self, t, v): + if not t: + return v + + if t == datetime.date: + nv = datetime.date.fromordinal(int(v) + DATE_OFFSET) + else: + nv = t(v) + return nv + + def get_data(self, types): + values = [ + [self._cast(types[i], v) for i, v in enumerate(row)] + for row in self.data + ] + return values + + +class LOCalcRanges(object): + + def __init__(self, obj): + self._obj = obj + self._ranges = {} + self._index = 0 + for r in obj: + sheet = r.Spreadsheet + rango = LOCalcRange(sheet[r.AbsoluteName]) + self._ranges[rango.name] = rango + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + def __len__(self): + return self._obj.Count + + def __contains__(self, item): + return self._obj.hasByName(item.name) + + def __iter__(self): + self._index = 0 + return self + + def __next__(self): + try: + r = self.obj[self._index] + rango = self._ranges[r.AbsoluteName] + except IndexError: + raise StopIteration + + self._index += 1 + return rango + + def __getitem__(self, index): + if isinstance(index, int): + r = self.obj[index] + rango = self._ranges[r.AbsoluteName] + else: + rango = self._ranges[index] + return rango + + @property + def obj(self): + return self._obj + + @property + def names(self): + return self.obj.ElementNames + + @property + def data(self): + return [r.data for r in self._ranges.values()] + + @property + def style(self): + return self.obj + @style.setter + def style(self, value): + self.obj.CellStyle = value + + def add(self, rangos): + if isinstance(rangos, LOCalcRange): + rangos = (rangos,) + for r in rangos: + self._ranges[r.name] = r + self.obj.addRangeAddress(r.range_address, False) + return + + def remove(self, rangos): + if isinstance(rangos, LOCalcRange): + rangos = (rangos,) + for r in rangos: + del self._ranges[r.name] + self.obj.removeRangeAddress(r.range_address) + return + + +class LOWriterStyles(object): + + def __init__(self, styles): + self._styles = styles + + @property + def names(self): + return {s.DisplayName: s.Name for s in self._styles} + + def __str__(self): + return '\n'.join(tuple(self.names.values())) + + +class LOWriterStylesFamilies(object): + + def __init__(self, styles): + self._styles = styles + + def __getitem__(self, index): + styles = { + 'Character': 'CharacterStyles', + 'Paragraph': 'ParagraphStyles', + 'Page': 'PageStyles', + 'Frame': 'FrameStyles', + 'Numbering': 'NumberingStyles', + 'Table': 'TableStyles', + 'Cell': 'CellStyles', + } + name = styles.get(index, index) + return LOWriterStyles(self._styles[name]) + + def __iter__(self): + self._index = 0 + return self + + def __next__(self): + obj = LOWriterStyles(self._styles[self._index]) + self._index += 1 + return obj + # ~ raise StopIteration + + @property + def names(self): + return self._styles.ElementNames + + def __str__(self): + return '\n'.join(self.names) + + +class LOWriterPageStyle(LOBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + def __str__(self): + return f'Page Style: {self.name}' + + @property + def name(self): + return self._obj.Name + + +class LOWriterPageStyles(object): + + def __init__(self, styles): + self._styles = styles + + def __getitem__(self, index): + return LOWriterPageStyle(self._styles[index]) + + @property + def names(self): + return self._styles.ElementNames + + def __str__(self): + return '\n'.join(self.names) + + +class LOWriterTextRange(object): + + def __init__(self, obj, doc): + self._obj = obj + self._doc = doc + self._is_paragraph = self.obj.ImplementationName == 'SwXParagraph' + self._is_table = self.obj.ImplementationName == 'SwXTextTable' + self._is_text = self.obj.ImplementationName == 'SwXTextPortion' + self._is_section = not self.obj.TextSection is None + self._parts = [] + if self._is_paragraph: + self._parts = [LOWriterTextRange(p, doc) for p in obj] + + def __iter__(self): + self._index = 0 + return self + + def __next__(self): + try: + obj = self._parts[self._index] + except IndexError: + raise StopIteration + + self._index += 1 + return obj + + @property + def obj(self): + return self._obj + + @property + def string(self): + s = '' + if not self._is_table: + s = self.obj.String + return s + @string.setter + def string(self, value): + self.obj.String = value + + @property + def value(self): + return self.string + @value.setter + def value(self, value): + self.string = value + + @property + def style(self): + s = '' + if self.is_paragraph: + s = self.obj.ParaStyleName + elif self.is_text: + s = self.obj.CharStyleName + return s + @style.setter + def style(self, value): + if self.is_paragraph: + self.obj.ParaStyleName = value + elif self.is_text: + self.obj.CharStyleName = value + + @property + def is_paragraph(self): + return self._is_paragraph + + @property + def is_table(self): + return self._is_table + + @property + def is_text(self): + return self._is_text + + @property + def is_section(self): + return self._is_section + + @property + def text(self): + return self.obj.Text + + @property + def cursor(self): + return self.text.createTextCursorByRange(self.obj) + + @property + def text_cursor(self): + return self.text.createTextCursor() + + @property + def dp(self): + return self._doc.dp + + @property + def paragraph(self): + cursor = self.cursor + cursor.gotoStartOfParagraph(False) + cursor.gotoNextParagraph(True) + return LOWriterTextRange(cursor, self._doc) + + def goto_start(self): + if self.is_section: + rango = self.obj.TextSection.Anchor.Start + else: + rango = self.obj.Start + return LOWriterTextRange(rango, self._doc) + + def goto_end(self): + if self.is_section: + rango = self.obj.TextSection.Anchor.End + else: + rango = self.obj.End + return LOWriterTextRange(rango, self._doc) + + def goto_previous(self, expand=True): + cursor = self.cursor + cursor.gotoPreviousParagraph(expand) + return LOWriterTextRange(cursor, self._doc) + + def goto_next(self, expand=True): + cursor = self.cursor + cursor.gotoNextParagraph(expand) + return LOWriterTextRange(cursor, self._doc) + + def go_left(self, from_self=True, count=1, expand=False): + cursor = self.cursor + if not from_self: + cursor = self.text_cursor + cursor.gotoRange(self.obj, False) + cursor.goLeft(count, expand) + return LOWriterTextRange(cursor, self._doc) + + def go_right(self, from_self=True, count=1, expand=False): + cursor = self.cursor + if not from_self: + cursor = self.text_cursor + cursor.gotoRange(self.obj, False) + cursor.goRight(count, expand) + return LOWriterTextRange(cursor, self._doc) + + def delete(self): + self.value = '' + return + + def offset(self): + cursor = self.cursor.getEnd() + return LOWriterTextRange(cursor, self._doc) + + def insert_content(self, data, cursor=None, replace=False): + if cursor is None: + cursor = self.cursor + self.text.insertTextContent(cursor, data, replace) + return + + def insert_math(self, formula, + anchor_type=TextContentAnchorType.AS_CHARACTER, + cursor=None, replace=False): + + math = self._doc.create_instance(SERVICES['TEXT_EMBEDDED']) + math.CLSID = CLSID['FORMULA'] + math.AnchorType = anchor_type + self.insert_content(math, cursor, replace) + math.EmbeddedObject.Component.Formula = formula + return math + + def new_line(self, count=1): + cursor = self.cursor + for i in range(count): + self.text.insertControlCharacter(cursor, PARAGRAPH_BREAK, False) + return LOWriterTextRange(cursor, self._doc) + + def insert_table(self, data): + table = self._doc.create_instance(SERVICES['TEXT_TABLE']) + rows = len(data) + cols = len(data[0]) + table.initialize(rows, cols) + self.insert_content(table) + table.DataArray = data + name = table.Name + table = LOWriterTextTable(self._doc.tables[name], self._doc) + return table + + def insert_shape(self, tipo, args={}): + # ~ args['Width'] = args.get('Width', 1000) + # ~ args['Height'] = args.get('Height', 1000) + # ~ args['X'] = args.get('X', 0) + # ~ args['Y'] = args.get('Y', 0) + shape = self._doc.dp.add(tipo, args) + # ~ shape.anchor = self.obj + return shape + + def insert_image(self, path, args={}): + w = args.get('Width', 1000) + h = args.get('Height', 1000) + + image = self._doc.create_instance(SERVICES['GRAPHIC']) + image.GraphicURL = _P.to_url(path) + image.AnchorType = TextContentAnchorType.AS_CHARACTER + image.Width = w + image.Height = h + self.insert_content(image) + return self._doc.dp.last + + +class LOWriterTextRanges(object): + + def __init__(self, obj, doc): + self._obj = obj + self._doc = doc + self._paragraphs = [LOWriterTextRange(p, doc) for p in obj] + + def __len__(self): + return len(self._paragraphs) + + def __getitem__(self, index): + return self._paragraphs[index] + + def __iter__(self): + self._index = 0 + return self + + def __next__(self): + try: + obj = self._paragraphs[self._index] + except IndexError: + raise StopIteration + + self._index += 1 + return obj + + @property + def obj(self): + return self._obj + + +class LOWriterTextTable(object): + + def __init__(self, obj, doc): + self._obj = obj + self._doc = doc + + @property + def obj(self): + return self._obj + + @property + def name(self): + return self._obj.Name + + @property + def data(self): + return self.obj.DataArray + @data.setter + def data(self, values): + self.obj.DataArray = values + + @property + def style(self): + return self.obj.TableTemplateName + @style.setter + def style(self, value): + self.obj.autoFormat(value) + + +class LOWriterTextTables(object): + + def __init__(self, doc): + self._doc = doc + self._obj = doc.obj.TextTables + + def __getitem__(self, key): + return LOWriterTextTable(self._obj[key], self._doc) + + def __len__(self): + return self._obj.Count + + def insert(self, data, text_range=None): + if text_range is None: + text_range = self._doc.selection + text_range.insert_table(data) + return + + +class LOWriter(LODocument): + + def __init__(self, obj): + super().__init__(obj) + self._type = WRITER + + @property + def text(self): + return self.paragraphs + + @property + def paragraphs(self): + return LOWriterTextRanges(self.obj.Text, self) + + @property + def tables(self): + return LOWriterTextTables(self) + + @property + def selection(self): + sel = self.obj.CurrentSelection + if sel.ImplementationName == OBJ_TEXTS: + if len(sel) == 1: + sel = LOWriterTextRanges(sel, self)[0] + else: + sel = LOWriterTextRanges(sel, self) + return sel + + if sel.ImplementationName == OBJ_SHAPES: + if len(sel) == 1: + sel = sel[0] + sel = LODrawPage(sel.Parent)[sel.Name] + return sel + + if sel.ImplementationName == OBJ_GRAPHIC: + sel = self.dp[sel.Name] + else: + debug(sel.ImplementationName) + + return sel + + @property + def dp(self): + return self.draw_page + @property + def shapes(self): + return self.draw_page + @property + def draw_page(self): + return LODrawPage(self.obj.DrawPage) + + @property + def view_cursor(self): + return self._cc.ViewCursor + + @property + def cursor(self): + return self.obj.Text.createTextCursor() + + @property + def view_cursor(self): + return self._cc.ViewCursor + + @property + def page_styles(self): + ps = self.obj.StyleFamilies['PageStyles'] + return LOWriterPageStyles(ps) + + @property + def styles(self): + return LOWriterStylesFamilies(self.obj.StyleFamilies) + + @property + def search_descriptor(self): + return self.obj.createSearchDescriptor() + + @property + def replace_descriptor(self): + return self.obj.createReplaceDescriptor() + + @property + def zoom(self): + return self._cc.ViewSettings.ZoomValue + @zoom.setter + def zoom(self, value): + self._cc.ViewSettings.ZoomValue = value + + def goto_start(self): + self.view_cursor.gotoStart(False) + return self.selection + + def goto_end(self): + self.view_cursor.gotoEnd(False) + return self.selection + + def search(self, options, find_all=True): + descriptor = self.search_descriptor + descriptor.setSearchString(options.get('Search', '')) + descriptor.SearchCaseSensitive = options.get('CaseSensitive', False) + descriptor.SearchWords = options.get('Words', False) + if 'Attributes' in options: + attr = dict_to_property(options['Attributes']) + descriptor.setSearchAttributes(attr) + if hasattr(descriptor, 'SearchRegularExpression'): + descriptor.SearchRegularExpression = options.get('RegularExpression', False) + if hasattr(descriptor, 'SearchType') and 'Type' in options: + descriptor.SearchType = options['Type'] + + result = False + if find_all: + found = self.obj.findAll(descriptor) + if len(found): + result = [LOWriterTextRange(f, self) for f in found] + else: + found = self.obj.findFirst(descriptor) + if found: + result = LOWriterTextRange(found, self) + + return result + + def replace(self, options): + descriptor = self.replace_descriptor + descriptor.setSearchString(options['Search']) + descriptor.setReplaceString(options['Replace']) + descriptor.SearchCaseSensitive = options.get('CaseSensitive', False) + descriptor.SearchWords = options.get('Words', False) + if 'Attributes' in options: + attr = dict_to_property(options['Attributes']) + descriptor.setSearchAttributes(attr) + if hasattr(descriptor, 'SearchRegularExpression'): + descriptor.SearchRegularExpression = options.get('RegularExpression', False) + if hasattr(descriptor, 'SearchType') and 'Type' in options: + descriptor.SearchType = options['Type'] + found = self.obj.replaceAll(descriptor) + return found + + def select(self, text): + if hasattr(text, 'obj'): + text = text.obj + self._cc.select(text) + return + + +class LOShape(LOBaseObject): + IMAGE = 'com.sun.star.drawing.GraphicObjectShape' + + def __init__(self, obj, index=-1): + self._index = index + super().__init__(obj) + + @property + def type(self): + t = self.shape_type[21:] + if self.is_image: + t = 'image' + return t + + @property + def shape_type(self): + return self.obj.ShapeType + + @property + def properties(self): + return {} + @properties.setter + def properties(self, values): + _set_properties(self.obj, values) + + @property + def is_image(self): + return self.shape_type == self.IMAGE + + @property + def name(self): + return self.obj.Name or f'{self.type}{self.index}' + @name.setter + def name(self, value): + self.obj.Name = value + + @property + def index(self): + return self._index + + @property + def size(self): + s = self.obj.Size + a = dict(Width=s.Width, Height=s.Height) + return a + + @property + def position(self): + return self.obj.Position + @property + def x(self): + return self.position.X + @property + def y(self): + return self.position.Y + + @property + def string(self): + return self.obj.String + @string.setter + def string(self, value): + self.obj.String = value + + @property + def description(self): + return self.obj.Description + @description.setter + def description(self, value): + self.obj.Description = value + + @property + def cell(self): + return self.anchor + + @property + def anchor(self): + obj = self.obj.Anchor + if obj.ImplementationName == OBJ_CELL: + obj = LOCalcRange(obj) + elif obj.ImplementationName == OBJ_TEXT: + obj = LOWriterTextRange(obj, LODocs().active) + else: + debug('Anchor', obj.ImplementationName) + return obj + @anchor.setter + def anchor(self, value): + if hasattr(value, 'obj'): + value = value.obj + try: + self.obj.Anchor = value + except Exception as e: + self.obj.AnchorType = value + + @property + def visible(self): + return self.obj.Visible + @visible.setter + def visible(self, value): + self.obj.Visible = value + + @property + def path(self): + return self.url + @property + def url(self): + url = '' + if self.is_image: + url = _P.to_system(self.obj.GraphicURL.OriginURL) + return url + + @property + def mimetype(self): + mt = '' + if self.is_image: + mt = self.obj.GraphicURL.MimeType + return mt + + @property + def linked(self): + l = False + if self.is_image: + l = self.obj.GraphicURL.Linked + return l + + def delete(self): + self.remove() + return + def remove(self): + self.obj.Parent.remove(self.obj) + return + + def save(self, path: str, mimetype=DEFAULT_MIME_TYPE): + if _P.is_dir(path): + name = self.name + ext = mimetype.lower() + else: + p = _P(path) + path = p.path + name = p.name + ext = p.ext.lower() + + path = _P.join(path, f'{name}.{ext}') + args = dict( + URL = _P.to_url(path), + MimeType = MIME_TYPE[ext], + ) + if not _export_image(self.obj, args): + path = '' + return path + + # ~ def save2(self, path: str): + # ~ size = len(self.obj.Bitmap.DIB) + # ~ data = self.obj.GraphicStream.readBytes((), size) + # ~ data = data[-1].value + # ~ path = _P.join(path, f'{self.name}.png') + # ~ _P.save_bin(path, b'') + # ~ return + + +class LODrawPage(LOBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + def __getitem__(self, index): + if isinstance(index, int): + shape = LOShape(self.obj[index], index) + else: + for i, o in enumerate(self.obj): + shape = self.obj[i] + name = shape.Name or f'shape{i}' + if name == index: + shape = LOShape(shape, i) + break + return shape + + def __iter__(self): + self._index = 0 + return self + + def __next__(self): + if self._index == self.count: + raise StopIteration + shape = self[self._index] + self._index += 1 + return shape + + + @property + def name(self): + return self.obj.Name + + @property + def doc(self): + return self.obj.Forms.Parent + + @property + def width(self): + return self.obj.Width + + @property + def height(self): + return self.obj.Height + + @property + def count(self): + return self.obj.Count + + @property + def last(self): + return self[self.count - 1] + + def create_instance(self, name): + return self.doc.createInstance(name) + + def add(self, type_shape, options={}): + args = options.copy() + """Insert a shape in page, type shapes: + Line + Rectangle + Ellipse + Text + Connector + """ + index = self.count + default_height = 3000 + if type_shape == 'Line': + default_height = 0 + w = args.pop('Width', 3000) + h = args.pop('Height', default_height) + x = args.pop('X', 1000) + y = args.pop('Y', 1000) + name = args.pop('Name', f'{type_shape.lower()}{index}') + + service = f'com.sun.star.drawing.{type_shape}Shape' + shape = self.create_instance(service) + shape.Size = Size(w, h) + shape.Position = Point(x, y) + shape.Name = name + self.obj.add(shape) + + if args: + _set_properties(shape, args) + + return LOShape(self.obj[index], index) + + def remove(self, shape): + if hasattr(shape, 'obj'): + shape = shape.obj + return self.obj.remove(shape) + + def remove_all(self): + while self.count: + self.obj.remove(self.obj[0]) + return + + def insert_image(self, path, options={}): + args = options.copy() + index = self.count + w = args.get('Width', 3000) + h = args.get('Height', 3000) + x = args.get('X', 1000) + y = args.get('Y', 1000) + name = args.get('Name', f'image{index}') + + image = self.create_instance('com.sun.star.drawing.GraphicObjectShape') + if isinstance(path, str): + image.GraphicURL = _P.to_url(path) + else: + gp = create_instance('com.sun.star.graphic.GraphicProvider') + properties = dict_to_property({'InputStream': path}) + image.Graphic = gp.queryGraphic(properties) + + self.obj.add(image) + image.Size = Size(w, h) + image.Position = Point(x, y) + image.Name = name + return LOShape(self.obj[index], index) + + +class LODrawImpress(LODocument): + + def __init__(self, obj): + super().__init__(obj) + + def __getitem__(self, index): + if isinstance(index, int): + page = self.obj.DrawPages[index] + else: + page = self.obj.DrawPages.getByName(index) + return LODrawPage(page) + + @property + def selection(self): + sel = self.obj.CurrentSelection[0] + # ~ return _get_class_uno(sel) + return sel + + @property + def current_page(self): + return LODrawPage(self._cc.getCurrentPage()) + + def paste(self): + call_dispatch(self.frame, '.uno:Paste') + return self.current_page[-1] + + def add(self, type_shape, args={}): + return self.current_page.add(type_shape, args) + + def insert_image(self, path, args={}): + self.current_page.insert_image(path, args) + return + + # ~ def export(self, path, mimetype='png'): + # ~ args = dict( + # ~ URL = _P.to_url(path), + # ~ MimeType = MIME_TYPE[mimetype], + # ~ ) + # ~ result = _export_image(self.obj, args) + # ~ return result + + +class LODraw(LODrawImpress): + + def __init__(self, obj): + super().__init__(obj) + self._type = DRAW + + +class LOImpress(LODrawImpress): + + def __init__(self, obj): + super().__init__(obj) + self._type = IMPRESS + + +class BaseDateField(DateField): + + def db_value(self, value): + return _date_to_struct(value) + + def python_value(self, value): + return _struct_to_date(value) + + +class BaseTimeField(TimeField): + + def db_value(self, value): + return _date_to_struct(value) + + def python_value(self, value): + return _struct_to_date(value) + + +class BaseDateTimeField(DateTimeField): + + def db_value(self, value): + return _date_to_struct(value) + + def python_value(self, value): + return _struct_to_date(value) + + +class FirebirdDatabase(Database): + field_types = {'BOOL': 'BOOLEAN', 'DATETIME': 'TIMESTAMP'} + + def __init__(self, database, **kwargs): + super().__init__(database, **kwargs) + self._db = database + + def _connect(self): + return self._db + + def create_tables(self, models, **options): + options['safe'] = False + tables = self._db.tables + models = [m for m in models if not m.__name__.lower() in tables] + super().create_tables(models, **options) + + def execute_sql(self, sql, params=None, commit=True): + with __exception_wrapper__: + cursor = self._db.execute(sql, params) + return cursor + + def last_insert_id(self, cursor, query_type=None): + # ~ debug('LAST_ID', cursor) + return 0 + + def rows_affected(self, cursor): + return self._db.rows_affected + + @property + def path(self): + return self._db.path + + +class BaseRow: + pass + + +class BaseQuery(object): + PY_TYPES = { + 'VARCHAR': 'getString', + 'INTEGER': 'getLong', + 'DATE': 'getDate', + # ~ 'SQL_LONG': 'getLong', + # ~ 'SQL_VARYING': 'getString', + # ~ 'SQL_FLOAT': 'getFloat', + # ~ 'SQL_BOOLEAN': 'getBoolean', + # ~ 'SQL_TYPE_DATE': 'getDate', + # ~ 'SQL_TYPE_TIME': 'getTime', + # ~ 'SQL_TIMESTAMP': 'getTimestamp', + } + # ~ TYPES_DATE = ('SQL_TYPE_DATE', 'SQL_TYPE_TIME', 'SQL_TIMESTAMP') + TYPES_DATE = ('DATE', 'SQL_TYPE_TIME', 'SQL_TIMESTAMP') + + def __init__(self, query): + self._query = query + self._meta = query.MetaData + self._cols = self._meta.ColumnCount + self._names = query.Columns.ElementNames + self._data = self._get_data() + + def __getitem__(self, index): + return self._data[index] + + def __iter__(self): + self._index = 0 + return self + + def __next__(self): + try: + row = self._data[self._index] + except IndexError: + raise StopIteration + self._index += 1 + return row + + def _to_python(self, index): + type_field = self._meta.getColumnTypeName(index) + # ~ print('TF', type_field) + value = getattr(self._query, self.PY_TYPES[type_field])(index) + if type_field in self.TYPES_DATE: + value = _struct_to_date(value) + return value + + def _get_row(self): + row = BaseRow() + for i in range(1, self._cols + 1): + column_name = self._meta.getColumnName(i) + value = self._to_python(i) + setattr(row, column_name, value) + return row + + def _get_data(self): + data = [] + while self._query.next(): + row = self._get_row() + data.append(row) + return data + + @property + def tuples(self): + data = [tuple(r.__dict__.values()) for r in self._data] + return tuple(data) + + @property + def dicts(self): + data = [r.__dict__ for r in self._data] + return tuple(data) + + +class LOBase(object): + DB_TYPES = { + str: 'setString', + int: 'setInt', + float: 'setFloat', + bool: 'setBoolean', + Date: 'setDate', + Time: 'setTime', + DateTime: 'setTimestamp', + } + # ~ setArray + # ~ setBinaryStream + # ~ setBlob + # ~ setByte + # ~ setBytes + # ~ setCharacterStream + # ~ setClob + # ~ setNull + # ~ setObject + # ~ setObjectNull + # ~ setObjectWithInfo + # ~ setPropertyValue + # ~ setRef + + def __init__(self, obj, args={}): + self._obj = obj + self._type = BASE + self._dbc = create_instance('com.sun.star.sdb.DatabaseContext') + self._rows_affected = 0 + path = args.get('path', '') + self._path = _P(path) + self._name = self._path.name + if _P.exists(path): + if not self.is_registered: + self.register() + db = self._dbc.getByName(self.name) + else: + db = self._dbc.createInstance() + db.URL = 'sdbc:embedded:firebird' + db.DatabaseDocument.storeAsURL(self._path.url, ()) + self.register() + self._obj = db + self._con = db.getConnection('', '') + + def __contains__(self, item): + return item in self.tables + + @property + def obj(self): + return self._obj + + @property + def name(self): + return self._name + + @property + def path(self): + return str(self._path) + + @property + def is_registered(self): + return self._dbc.hasRegisteredDatabase(self.name) + + @property + def tables(self): + tables = [t.Name.lower() for t in self._con.getTables()] + return tables + + @property + def rows_affected(self): + return self._rows_affected + + def register(self): + if not self.is_registered: + self._dbc.registerDatabaseLocation(self.name, self._path.url) + return + + def revoke(self, name): + self._dbc.revokeDatabaseLocation(name) + return True + + def save(self): + self.obj.DatabaseDocument.store() + self.refresh() + return + + def close(self): + self._con.close() + return + + def refresh(self): + self._con.getTables().refresh() + return + + def initialize(self, database_proxy, tables=[]): + db = FirebirdDatabase(self) + database_proxy.initialize(db) + if tables: + db.create_tables(tables) + return + + def _validate_sql(self, sql, params): + limit = ' LIMIT ' + for p in params: + sql = sql.replace('?', f"'{p}'", 1) + if limit in sql: + sql = sql.split(limit)[0] + sql = sql.replace('SELECT', f'SELECT FIRST {params[-1]}') + return sql + + def cursor(self, sql, params): + if sql.startswith('SELECT'): + sql = self._validate_sql(sql, params) + cursor = self._con.prepareStatement(sql) + return cursor + + if not params: + cursor = self._con.createStatement() + return cursor + + cursor = self._con.prepareStatement(sql) + for i, v in enumerate(params, 1): + t = type(v) + if not t in self.DB_TYPES: + error('Type not support') + debug((i, t, v, self.DB_TYPES[t])) + getattr(cursor, self.DB_TYPES[t])(i, v) + return cursor + + def execute(self, sql, params): + debug(sql, params) + cursor = self.cursor(sql, params) + + if sql.startswith('SELECT'): + result = cursor.executeQuery() + elif params: + result = cursor.executeUpdate() + self._rows_affected = result + self.save() + else: + result = cursor.execute(sql) + self.save() + + return result + + def select(self, sql): + debug('SELECT', sql) + if not sql.startswith('SELECT'): + return () + + cursor = self._con.prepareStatement(sql) + query = cursor.executeQuery() + return BaseQuery(query) + + def get_query(self, query): + sql, args = query.sql() + sql = self._validate_sql(sql, args) + return self.select(sql) + + +class LOMath(LODocument): + + def __init__(self, obj): + super().__init__(obj) + self._type = MATH + + +class LOBasic(LODocument): + + def __init__(self, obj): + super().__init__(obj) + self._type = BASIC + + +class LODocs(object): + _desktop = None + + def __init__(self): + self._desktop = get_desktop() + LODocs._desktop = self._desktop + + def __getitem__(self, index): + document = None + for i, doc in enumerate(self._desktop.Components): + if isinstance(index, int) and i == index: + document = _get_class_doc(doc) + break + elif isinstance(index, str) and doc.Title == index: + document = _get_class_doc(doc) + break + return document + + def __contains__(self, item): + doc = self[item] + return not doc is None + + def __iter__(self): + self._i = -1 + return self + + def __next__(self): + self._i += 1 + doc = self[self._i] + if doc is None: + raise StopIteration + else: + return doc + + def __len__(self): + # ~ len(self._desktop.Components) + for i, _ in enumerate(self._desktop.Components): + pass + return i + 1 + + @property + def active(self): + return _get_class_doc(self._desktop.getCurrentComponent()) + + @classmethod + def new(cls, type_doc=CALC, args={}): + if type_doc == BASE: + return LOBase(None, args) + + path = f'private:factory/s{type_doc}' + opt = dict_to_property(args) + doc = cls._desktop.loadComponentFromURL(path, '_default', 0, opt) + return _get_class_doc(doc) + + @classmethod + def open(cls, path, args={}): + """ Open document in path + Usually options: + Hidden: True or False + AsTemplate: True or False + ReadOnly: True or False + Password: super_secret + MacroExecutionMode: 4 = Activate macros + Preview: True or False + + http://api.libreoffice.org/docs/idl/ref/interfacecom_1_1sun_1_1star_1_1frame_1_1XComponentLoader.html + http://api.libreoffice.org/docs/idl/ref/servicecom_1_1sun_1_1star_1_1document_1_1MediaDescriptor.html + """ + path = _P.to_url(path) + opt = dict_to_property(args) + doc = cls._desktop.loadComponentFromURL(path, '_default', 0, opt) + if doc is None: + return + + return _get_class_doc(doc) + + def connect(self, path): + db = LOBase(None, {'path': path}) + return db + + +def _add_listeners(events, control, name=''): + listeners = { + 'addActionListener': EventsButton, + 'addMouseListener': EventsMouse, + 'addFocusListener': EventsFocus, + 'addItemListener': EventsItem, + 'addKeyListener': EventsKey, + 'addTabListener': EventsTab, + 'addSpinListener': EventsSpin, + } + if hasattr(control, 'obj'): + control = control.obj + # ~ debug(control.ImplementationName) + is_grid = control.ImplementationName == 'stardiv.Toolkit.GridControl' + is_link = control.ImplementationName == 'stardiv.Toolkit.UnoFixedHyperlinkControl' + is_roadmap = control.ImplementationName == 'stardiv.Toolkit.UnoRoadmapControl' + is_pages = control.ImplementationName == 'stardiv.Toolkit.UnoMultiPageControl' + + for key, value in listeners.items(): + if hasattr(control, key): + if is_grid and key == 'addMouseListener': + control.addMouseListener(EventsMouseGrid(events, name)) + continue + if is_link and key == 'addMouseListener': + control.addMouseListener(EventsMouseLink(events, name)) + continue + if is_roadmap and key == 'addItemListener': + control.addItemListener(EventsItemRoadmap(events, name)) + continue + + getattr(control, key)(listeners[key](events, name)) + + if is_grid: + controllers = EventsGrid(events, name) + control.addSelectionListener(controllers) + control.Model.GridDataModel.addGridDataListener(controllers) + return + + +def _set_properties(model, properties): + if 'X' in properties: + properties['PositionX'] = properties.pop('X') + if 'Y' in properties: + properties['PositionY'] = properties.pop('Y') + keys = tuple(properties.keys()) + values = tuple(properties.values()) + model.setPropertyValues(keys, values) + return + + +class EventsListenerBase(unohelper.Base, XEventListener): + + def __init__(self, controller, name, window=None): + self._controller = controller + self._name = name + self._window = window + + @property + def name(self): + return self._name + + def disposing(self, event): + self._controller = None + if not self._window is None: + self._window.setMenuBar(None) + + +class EventsSpin(EventsListenerBase, XSpinListener): + + def __init__(self, controller, name): + super().__init__(controller, name) + + def up(self, event): + event_name = f'{self.name}_up' + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def down(self, event): + event_name = f'{self.name}_up' + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def first(self, event): + event_name = f'{self.name}_first' + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def last(self, event): + event_name = f'{self.name}_last' + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + +class EventsMouse(EventsListenerBase, XMouseListener, XMouseMotionListener): + + def __init__(self, controller, name): + super().__init__(controller, name) + + def mousePressed(self, event): + event_name = '{}_click'.format(self._name) + if event.ClickCount == 2: + event_name = '{}_double_click'.format(self._name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def mouseReleased(self, event): + event_name = '{}_after_click'.format(self._name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def mouseEntered(self, event): + pass + + def mouseExited(self, event): + pass + + # ~ XMouseMotionListener + def mouseMoved(self, event): + pass + + def mouseDragged(self, event): + pass + + +class EventsMouseLink(EventsMouse): + + def __init__(self, controller, name): + super().__init__(controller, name) + self._text_color = 0 + + def mouseEntered(self, event): + model = event.Source.Model + self._text_color = model.TextColor or 0 + model.TextColor = get_color('blue') + return + + def mouseExited(self, event): + model = event.Source.Model + model.TextColor = self._text_color + return + + +class EventsButton(EventsListenerBase, XActionListener): + + def __init__(self, controller, name): + super().__init__(controller, name) + + def actionPerformed(self, event): + event_name = f'{self.name}_action' + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + +class EventsFocus(EventsListenerBase, XFocusListener): + CONTROLS = ( + 'stardiv.Toolkit.UnoControlEditModel', + ) + + def __init__(self, controller, name): + super().__init__(controller, name) + + def focusGained(self, event): + service = event.Source.Model.ImplementationName + # ~ print('Focus enter', service) + if service in self.CONTROLS: + obj = event.Source.Model + obj.BackgroundColor = COLOR_ON_FOCUS + return + + def focusLost(self, event): + service = event.Source.Model.ImplementationName + if service in self.CONTROLS: + obj = event.Source.Model + obj.BackgroundColor = -1 + return + + +class EventsKey(EventsListenerBase, XKeyListener): + """ + event.KeyChar + event.KeyCode + event.KeyFunc + event.Modifiers + """ + + def __init__(self, controller, name): + super().__init__(controller, name) + + def keyPressed(self, event): + pass + + def keyReleased(self, event): + event_name = '{}_key_released'.format(self._name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + # ~ else: + # ~ if event.KeyFunc == QUIT and hasattr(self._cls, 'close'): + # ~ self._cls.close() + return + + +class EventsItem(EventsListenerBase, XItemListener): + + def __init__(self, controller, name): + super().__init__(controller, name) + + def disposing(self, event): + pass + + def itemStateChanged(self, event): + event_name = '{}_item_changed'.format(self.name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + +class EventsItemRoadmap(EventsItem): + + def itemStateChanged(self, event): + dialog = event.Source.Context.Model + dialog.Step = event.ItemId + 1 + return + + +class EventsGrid(EventsListenerBase, XGridDataListener, XGridSelectionListener): + + def __init__(self, controller, name): + super().__init__(controller, name) + + def dataChanged(self, event): + event_name = '{}_data_changed'.format(self.name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def rowHeadingChanged(self, event): + pass + + def rowsInserted(self, event): + pass + + def rowsRemoved(self, evemt): + pass + + def selectionChanged(self, event): + event_name = '{}_selection_changed'.format(self.name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + +class EventsMouseGrid(EventsMouse): + selected = False + + def mousePressed(self, event): + super().mousePressed(event) + # ~ obj = event.Source + # ~ col = obj.getColumnAtPoint(event.X, event.Y) + # ~ row = obj.getRowAtPoint(event.X, event.Y) + # ~ print(col, row) + # ~ if col == -1 and row == -1: + # ~ if self.selected: + # ~ obj.deselectAllRows() + # ~ else: + # ~ obj.selectAllRows() + # ~ self.selected = not self.selected + return + + def mouseReleased(self, event): + # ~ obj = event.Source + # ~ col = obj.getColumnAtPoint(event.X, event.Y) + # ~ row = obj.getRowAtPoint(event.X, event.Y) + # ~ if row == -1 and col > -1: + # ~ gdm = obj.Model.GridDataModel + # ~ for i in range(gdm.RowCount): + # ~ gdm.updateRowHeading(i, i + 1) + return + + +class EventsTab(EventsListenerBase, XTabListener): + + def __init__(self, controller, name): + super().__init__(controller, name) + + def activated(self, id): + event_name = '{}_activated'.format(self.name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(id) + return + + +class EventsMenu(EventsListenerBase, XMenuListener): + + def __init__(self, controller): + super().__init__(controller, '') + + def itemHighlighted(self, event): + pass + + def itemSelected(self, event): + name = event.Source.getCommand(event.MenuId) + if name.startswith('menu'): + event_name = '{}_selected'.format(name) + else: + event_name = 'menu_{}_selected'.format(name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def itemActivated(self, event): + return + + def itemDeactivated(self, event): + return + + +class EventsWindow(EventsListenerBase, XTopWindowListener, XWindowListener): + + def __init__(self, cls): + self._cls = cls + super().__init__(cls.events, cls.name, cls._window) + + def windowOpened(self, event): + event_name = '{}_opened'.format(self._name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def windowActivated(self, event): + control_name = '{}_activated'.format(event.Source.Model.Name) + if hasattr(self._controller, control_name): + getattr(self._controller, control_name)(event) + return + + def windowDeactivated(self, event): + control_name = '{}_deactivated'.format(event.Source.Model.Name) + if hasattr(self._controller, control_name): + getattr(self._controller, control_name)(event) + return + + def windowMinimized(self, event): + pass + + def windowNormalized(self, event): + pass + + def windowClosing(self, event): + if self._window: + control_name = 'window_closing' + else: + control_name = '{}_closing'.format(event.Source.Model.Name) + + if hasattr(self._controller, control_name): + getattr(self._controller, control_name)(event) + # ~ else: + # ~ if not self._modal and not self._block: + # ~ event.Source.Visible = False + return + + def windowClosed(self, event): + control_name = '{}_closed'.format(event.Source.Model.Name) + if hasattr(self._controller, control_name): + getattr(self._controller, control_name)(event) + return + + # ~ XWindowListener + def windowResized(self, event): + sb = self._cls._subcont + sb.setPosSize(0, 0, event.Width, event.Height, SIZE) + event_name = '{}_resized'.format(self._name) + if hasattr(self._controller, event_name): + getattr(self._controller, event_name)(event) + return + + def windowMoved(self, event): + pass + + def windowShown(self, event): + pass + + def windowHidden(self, event): + pass + + +# ~ BorderColor = ? +# ~ FontStyleName = ? +# ~ HelpURL = ? +class UnoBaseObject(object): + + def __init__(self, obj, path=''): + self._obj = obj + self._model = obj.Model + + def __setattr__(self, name, value): + exists = hasattr(self, name) + if not exists and not name in ('_obj', '_model'): + setattr(self._model, name, value) + else: + super().__setattr__(name, value) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + @property + def obj(self): + return self._obj + + @property + def model(self): + return self._model + @property + def m(self): + return self._model + + @property + def properties(self): + return {} + @properties.setter + def properties(self, values): + _set_properties(self.model, values) + + @property + def name(self): + return self.model.Name + + @property + def parent(self): + return self.obj.Context + + @property + def tag(self): + return self.model.Tag + @tag.setter + def tag(self, value): + self.model.Tag = value + + @property + def visible(self): + return self.obj.Visible + @visible.setter + def visible(self, value): + self.obj.setVisible(value) + + @property + def enabled(self): + return self.model.Enabled + @enabled.setter + def enabled(self, value): + self.model.Enabled = value + + @property + def step(self): + return self.model.Step + @step.setter + def step(self, value): + self.model.Step = value + + @property + def align(self): + return self.model.Align + @align.setter + def align(self, value): + self.model.Align = value + + @property + def valign(self): + return self.model.VerticalAlign + @valign.setter + def valign(self, value): + self.model.VerticalAlign = value + + @property + def font_weight(self): + return self.model.FontWeight + @font_weight.setter + def font_weight(self, value): + self.model.FontWeight = value + + @property + def font_height(self): + return self.model.FontHeight + @font_height.setter + def font_height(self, value): + self.model.FontHeight = value + + @property + def font_name(self): + return self.model.FontName + @font_name.setter + def font_name(self, value): + self.model.FontName = value + + @property + def font_underline(self): + return self.model.FontUnderline + @font_underline.setter + def font_underline(self, value): + self.model.FontUnderline = value + + @property + def text_color(self): + return self.model.TextColor + @text_color.setter + def text_color(self, value): + self.model.TextColor = value + + @property + def back_color(self): + return self.model.BackgroundColor + @back_color.setter + def back_color(self, value): + self.model.BackgroundColor = value + + @property + def multi_line(self): + return self.model.MultiLine + @multi_line.setter + def multi_line(self, value): + self.model.MultiLine = value + + @property + def help_text(self): + return self.model.HelpText + @help_text.setter + def help_text(self, value): + self.model.HelpText = value + + @property + def border(self): + return self.model.Border + @border.setter + def border(self, value): + # ~ Bug for report + self.model.Border = value + + @property + def width(self): + return self._model.Width + @width.setter + def width(self, value): + self.model.Width = value + + @property + def height(self): + return self.model.Height + @height.setter + def height(self, value): + self.model.Height = value + + def _get_possize(self, name): + ps = self.obj.getPosSize() + return getattr(ps, name) + + def _set_possize(self, name, value): + ps = self.obj.getPosSize() + setattr(ps, name, value) + self.obj.setPosSize(ps.X, ps.Y, ps.Width, ps.Height, POSSIZE) + return + + @property + def x(self): + if hasattr(self.model, 'PositionX'): + return self.model.PositionX + return self._get_possize('X') + @x.setter + def x(self, value): + if hasattr(self.model, 'PositionX'): + self.model.PositionX = value + else: + self._set_possize('X', value) + + @property + def y(self): + if hasattr(self.model, 'PositionY'): + return self.model.PositionY + return self._get_possize('Y') + @y.setter + def y(self, value): + if hasattr(self.model, 'PositionY'): + self.model.PositionY = value + else: + self._set_possize('Y', value) + + @property + def tab_index(self): + return self._model.TabIndex + @tab_index.setter + def tab_index(self, value): + self.model.TabIndex = value + + @property + def tab_stop(self): + return self._model.Tabstop + @tab_stop.setter + def tab_stop(self, value): + self.model.Tabstop = value + + @property + def ps(self): + ps = self.obj.getPosSize() + return ps + @ps.setter + def ps(self, ps): + self.obj.setPosSize(ps.X, ps.Y, ps.Width, ps.Height, POSSIZE) + + def set_focus(self): + self.obj.setFocus() + return + + def ps_from(self, source): + self.ps = source.ps + return + + def center(self, horizontal=True, vertical=False): + p = self.parent.Model + w = p.Width + h = p.Height + if horizontal: + x = w / 2 - self.width / 2 + self.x = x + if vertical: + y = h / 2 - self.height / 2 + self.y = y + return + + def move(self, origin, x=0, y=5, center=False): + if x: + self.x = origin.x + origin.width + x + else: + self.x = origin.x + if y: + h = origin.height + if y < 0: + h = 0 + self.y = origin.y + h + y + else: + self.y = origin.y + + if center: + self.center() + return + + +class UnoLabel(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'label' + + @property + def value(self): + return self.model.Label + @value.setter + def value(self, value): + self.model.Label = value + + +class UnoLabelLink(UnoLabel): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'link' + + +class UnoButton(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'button' + + @property + def value(self): + return self.model.Label + @value.setter + def value(self, value): + self.model.Label = value + + @property + def image(self): + return self.model.ImageURL + @image.setter + def image(self, value): + self.model.ImageURL = _P.to_url(value) + + +class UnoRadio(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'radio' + + @property + def value(self): + return self.model.Label + @value.setter + def value(self, value): + self.model.Label = value + + +class UnoCheckBox(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'checkbox' + + @property + def value(self): + return self.model.State + @value.setter + def value(self, value): + self.model.State = value + + @property + def label(self): + return self.model.Label + @label.setter + def label(self, value): + self.model.Label = value + + @property + def tri_state(self): + return self.model.TriState + @tri_state.setter + def tri_state(self, value): + self.model.TriState = value + + +# ~ https://api.libreoffice.org/docs/idl/ref/servicecom_1_1sun_1_1star_1_1awt_1_1UnoControlEditModel.html +class UnoText(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'text' + + @property + def value(self): + return self.model.Text + @value.setter + def value(self, value): + self.model.Text = value + + @property + def echochar(self): + return chr(self.model.EchoChar) + @echochar.setter + def echochar(self, value): + if value: + self.model.EchoChar = ord(value[0]) + else: + self.model.EchoChar = 0 + + def validate(self): + return + + +class UnoImage(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'image' + + @property + def value(self): + return self.url + @value.setter + def value(self, value): + self.url = value + + @property + def url(self): + return self.m.ImageURL + @url.setter + def url(self, value): + self.m.ImageURL = None + self.m.ImageURL = _P.to_url(value) + + +class UnoListBox(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + self._path = '' + + def __setattr__(self, name, value): + if name in ('_path',): + self.__dict__[name] = value + else: + super().__setattr__(name, value) + + @property + def type(self): + return 'listbox' + + @property + def value(self): + return self.obj.getSelectedItem() + + @property + def count(self): + return len(self.data) + + @property + def data(self): + return self.model.StringItemList + @data.setter + def data(self, values): + self.model.StringItemList = list(sorted(values)) + + @property + def path(self): + return self._path + @path.setter + def path(self, value): + self._path = value + + def unselect(self): + self.obj.selectItem(self.value, False) + return + + def select(self, pos=0): + if isinstance(pos, str): + self.obj.selectItem(pos, True) + else: + self.obj.selectItemPos(pos, True) + return + + def clear(self): + self.model.removeAllItems() + return + + def _set_image_url(self, image): + if _P.exists(image): + return _P.to_url(image) + + path = _P.join(self._path, DIR['images'], image) + return _P.to_url(path) + + def insert(self, value, path='', pos=-1, show=True): + if pos < 0: + pos = self.count + if path: + self.model.insertItem(pos, value, self._set_image_url(path)) + else: + self.model.insertItemText(pos, value) + if show: + self.select(pos) + return + + +class UnoRoadmap(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + self._options = () + + def __setattr__(self, name, value): + if name in ('_options',): + self.__dict__[name] = value + else: + super().__setattr__(name, value) + + @property + def options(self): + return self._options + @options.setter + def options(self, values): + self._options = values + for i, v in enumerate(values): + opt = self.model.createInstance() + opt.ID = i + opt.Label = v + self.model.insertByIndex(i, opt) + return + + @property + def enabled(self): + return True + @enabled.setter + def enabled(self, value): + for m in self.model: + m.Enabled = value + return + + def set_enabled(self, index, value): + self.model.getByIndex(index).Enabled = value + return + + +class UnoTree(UnoBaseObject): + + def __init__(self, obj, ): + super().__init__(obj) + self._tdm = None + self._data = [] + + def __setattr__(self, name, value): + if name in ('_tdm', '_data'): + self.__dict__[name] = value + else: + super().__setattr__(name, value) + + @property + def selection(self): + sel = self.obj.Selection + return sel.DataValue, sel.DisplayValue + + @property + def parent(self): + parent = self.obj.Selection.Parent + if parent is None: + return () + return parent.DataValue, parent.DisplayValue + + def _get_parents(self, node): + value = (node.DisplayValue,) + parent = node.Parent + if parent is None: + return value + return self._get_parents(parent) + value + + @property + def parents(self): + values = self._get_parents(self.obj.Selection) + return values + + @property + def root(self): + if self._tdm is None: + return '' + return self._tdm.Root.DisplayValue + @root.setter + def root(self, value): + self._add_data_model(value) + + def _add_data_model(self, name): + tdm = create_instance('com.sun.star.awt.tree.MutableTreeDataModel') + root = tdm.createNode(name, True) + root.DataValue = 0 + tdm.setRoot(root) + self.model.DataModel = tdm + self._tdm = self.model.DataModel + return + + @property + def path(self): + return self.root + @path.setter + def path(self, value): + self.data = _P.walk_dir(value, True) + + @property + def data(self): + return self._data + @data.setter + def data(self, values): + self._data = list(values) + self._add_data() + + def _add_data(self): + if not self.data: + return + + parents = {} + for node in self.data: + parent = parents.get(node[1], self._tdm.Root) + child = self._tdm.createNode(node[2], False) + child.DataValue = node[0] + parent.appendChild(child) + parents[node[0]] = child + self.obj.expandNode(self._tdm.Root) + return + + +# ~ https://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1awt_1_1grid.html +class UnoGrid(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + self._gdm = self.model.GridDataModel + self._data = [] + self._formats = () + + def __setattr__(self, name, value): + if name in ('_gdm', '_data', '_formats'): + self.__dict__[name] = value + else: + super().__setattr__(name, value) + + def __getitem__(self, key): + value = self._gdm.getCellData(key[0], key[1]) + return value + + def __setitem__(self, key, value): + self._gdm.updateCellData(key[0], key[1], value) + return + + @property + def type(self): + return 'grid' + + @property + def columns(self): + return {} + @columns.setter + def columns(self, values): + # ~ self._columns = values + #~ https://api.libreoffice.org/docs/idl/ref/interfacecom_1_1sun_1_1star_1_1awt_1_1grid_1_1XGridColumn.html + model = create_instance('com.sun.star.awt.grid.DefaultGridColumnModel', True) + for properties in values: + column = create_instance('com.sun.star.awt.grid.GridColumn', True) + for k, v in properties.items(): + setattr(column, k, v) + model.addColumn(column) + self.model.ColumnModel = model + return + + @property + def data(self): + return self._data + @data.setter + def data(self, values): + self._data = values + self.clear() + headings = tuple(range(1, len(values) + 1)) + self._gdm.addRows(headings, values) + # ~ rows = range(grid_dm.RowCount) + # ~ colors = [COLORS['GRAY'] if r % 2 else COLORS['WHITE'] for r in rows] + # ~ grid.Model.RowBackgroundColors = tuple(colors) + return + + @property + def value(self): + if self.column == -1 or self.row == -1: + return '' + return self[self.column, self.row] + @value.setter + def value(self, value): + if self.column > -1 and self.row > -1: + self[self.column, self.row] = value + + @property + def row(self): + return self.obj.CurrentRow + + @property + def row_count(self): + return self._gdm.RowCount + + @property + def column(self): + return self.obj.CurrentColumn + + @property + def column(self): + return self.obj.CurrentColumn + + @property + def is_valid(self): + return not (self.row == -1 or self.column == -1) + + @property + def formats(self): + return self._formats + @formats.setter + def formats(self, values): + self._formats = values + + def clear(self): + self._gdm.removeAllRows() + return + + def _format_columns(self, data): + row = data + if self.formats: + for i, f in enumerate(formats): + if f: + row[i] = f.format(data[i]) + return row + + def add_row(self, data): + self._data.append(data) + row = self._format_columns(data) + self._gdm.addRow(self.row_count + 1, row) + return + + def set_cell_tooltip(self, col, row, value): + self._gdm.updateCellToolTip(col, row, value) + return + + def get_cell_tooltip(self, col, row): + value = self._gdm.getCellToolTip(col, row) + return value + + def sort(self, column, asc=True): + self._gdm.sortByColumn(column, asc) + self.update_row_heading() + return + + def update_row_heading(self): + for i in range(self.row_count): + self._gdm.updateRowHeading(i, i + 1) + return + + def remove_row(self, row): + self._gdm.removeRow(row) + del self._data[row] + self.update_row_heading() + return + + +class UnoPage(object): + + def __init__(self, obj): + self._obj = obj + self._events = None + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + @property + def obj(self): + return self._obj + + @property + def model(self): + return self._obj.Model + + # ~ @property + # ~ def id(self): + # ~ return self.m.TabPageID + + @property + def parent(self): + return self.obj.Context + + def _set_image_url(self, image): + if _P.exists(image): + return _P.to_url(image) + + path = _P.join(self._path, DIR['images'], image) + return _P.to_url(path) + + def _special_properties(self, tipo, args): + if tipo == 'link' and not 'Label' in args: + args['Label'] = args['URL'] + return args + + if tipo == 'button': + if 'ImageURL' in args: + args['ImageURL'] = self._set_image_url(args['ImageURL']) + args['FocusOnClick'] = args.get('FocusOnClick', False) + return args + + if tipo == 'roadmap': + args['Height'] = args.get('Height', self.height) + if 'Title' in args: + args['Text'] = args.pop('Title') + return args + + if tipo == 'tree': + args['SelectionType'] = args.get('SelectionType', SINGLE) + return args + + if tipo == 'grid': + args['ShowRowHeader'] = args.get('ShowRowHeader', True) + return args + + if tipo == 'pages': + args['Width'] = args.get('Width', self.width) + args['Height'] = args.get('Height', self.height) + + return args + + def add_control(self, args): + tipo = args.pop('Type').lower() + root = args.pop('Root', '') + sheets = args.pop('Sheets', ()) + columns = args.pop('Columns', ()) + + args = self._special_properties(tipo, args) + model = self.model.createInstance(UNO_MODELS[tipo]) + _set_properties(model, args) + name = args['Name'] + self.model.insertByName(name, model) + control = self.obj.getControl(name) + _add_listeners(self._events, control, name) + control = UNO_CLASSES[tipo](control) + + if tipo in ('listbox',): + control.path = self.path + + if tipo == 'tree' and root: + control.root = root + elif tipo == 'grid' and columns: + control.columns = columns + elif tipo == 'pages' and sheets: + control.sheets = sheets + control.events = self.events + + setattr(self, name, control) + return control + + +class UnoPages(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + self._sheets = [] + self._events = None + + def __setattr__(self, name, value): + if name in ('_sheets', '_events'): + self.__dict__[name] = value + else: + super().__setattr__(name, value) + + def __getitem__(self, index): + name = index + if isinstance(index, int): + name = f'sheet{index}' + sheet = self.obj.getControl(name) + page = UnoPage(sheet) + page._events = self._events + return page + + @property + def type(self): + return 'pages' + + @property + def current(self): + return self.obj.ActiveTabID + @property + def active(self): + return self.current + + @property + def sheets(self): + return self._sheets + @sheets.setter + def sheets(self, values): + self._sheets = values + for i, title in enumerate(values): + sheet = self.m.createInstance('com.sun.star.awt.UnoPageModel') + sheet.Title = title + self.m.insertByName(f'sheet{i + 1}', sheet) + return + + @property + def events(self): + return self._events + @events.setter + def events(self, controllers): + self._events = controllers + + @property + def visible(self): + return self.obj.Visible + @visible.setter + def visible(self, value): + self.obj.Visible = value + + def insert(self, title): + self._sheets.append(title) + id = len(self._sheets) + sheet = self.m.createInstance('com.sun.star.awt.UnoPageModel') + sheet.Title = title + self.m.insertByName(f'sheet{id}', sheet) + return self[id] + + def remove(self, id): + self.obj.removeTab(id) + return + + def activate(self, id): + self.obj.activateTab(id) + return + + +class UnoSpinButton(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'spinbutton' + + @property + def value(self): + return self.model.Label + @value.setter + def value(self, value): + self.model.Label = value + + +class UnoNumericField(UnoBaseObject): + + def __init__(self, obj): + super().__init__(obj) + + @property + def type(self): + return 'numeric' + + @property + def int(self): + return int(self.value) + + @property + def value(self): + return self.model.Value + @value.setter + def value(self, value): + self.model.Value = value + + +UNO_CLASSES = { + 'label': UnoLabel, + 'link': UnoLabelLink, + 'button': UnoButton, + 'radio': UnoRadio, + 'checkbox': UnoCheckBox, + 'text': UnoText, + 'image': UnoImage, + 'listbox': UnoListBox, + 'roadmap': UnoRoadmap, + 'tree': UnoTree, + 'grid': UnoGrid, + 'pages': UnoPages, + 'spinbutton': UnoSpinButton, + 'numeric': UnoNumericField, +} + +UNO_MODELS = { + 'label': 'com.sun.star.awt.UnoControlFixedTextModel', + 'link': 'com.sun.star.awt.UnoControlFixedHyperlinkModel', + 'button': 'com.sun.star.awt.UnoControlButtonModel', + 'radio': 'com.sun.star.awt.UnoControlRadioButtonModel', + 'checkbox': 'com.sun.star.awt.UnoControlCheckBoxModel', + 'text': 'com.sun.star.awt.UnoControlEditModel', + 'image': 'com.sun.star.awt.UnoControlImageControlModel', + 'listbox': 'com.sun.star.awt.UnoControlListBoxModel', + 'roadmap': 'com.sun.star.awt.UnoControlRoadmapModel', + 'tree': 'com.sun.star.awt.tree.TreeControlModel', + 'grid': 'com.sun.star.awt.grid.UnoControlGridModel', + 'pages': 'com.sun.star.awt.UnoMultiPageModel', + 'groupbox': 'com.sun.star.awt.UnoControlGroupBoxModel', + 'combobox': 'com.sun.star.awt.UnoControlComboBoxModel', + 'spinbutton': 'com.sun.star.awt.UnoControlSpinButtonModel', + 'numeric': 'com.sun.star.awt.UnoControlNumericFieldModel', +} +# ~ 'CurrencyField': 'com.sun.star.awt.UnoControlCurrencyFieldModel', +# ~ 'DateField': 'com.sun.star.awt.UnoControlDateFieldModel', +# ~ 'FileControl': 'com.sun.star.awt.UnoControlFileControlModel', +# ~ 'FormattedField': 'com.sun.star.awt.UnoControlFormattedFieldModel', +# ~ 'PatternField': 'com.sun.star.awt.UnoControlPatternFieldModel', +# ~ 'ProgressBar': 'com.sun.star.awt.UnoControlProgressBarModel', +# ~ 'ScrollBar': 'com.sun.star.awt.UnoControlScrollBarModel', +# ~ 'SimpleAnimation': 'com.sun.star.awt.UnoControlSimpleAnimationModel', +# ~ 'Throbber': 'com.sun.star.awt.UnoControlThrobberModel', +# ~ 'TimeField': 'com.sun.star.awt.UnoControlTimeFieldModel', + + +class LODialog(object): + SEPARATION = 5 + MODELS = { + 'label': 'com.sun.star.awt.UnoControlFixedTextModel', + 'link': 'com.sun.star.awt.UnoControlFixedHyperlinkModel', + 'button': 'com.sun.star.awt.UnoControlButtonModel', + 'radio': 'com.sun.star.awt.UnoControlRadioButtonModel', + 'checkbox': 'com.sun.star.awt.UnoControlCheckBoxModel', + 'text': 'com.sun.star.awt.UnoControlEditModel', + 'image': 'com.sun.star.awt.UnoControlImageControlModel', + 'listbox': 'com.sun.star.awt.UnoControlListBoxModel', + 'roadmap': 'com.sun.star.awt.UnoControlRoadmapModel', + 'tree': 'com.sun.star.awt.tree.TreeControlModel', + 'grid': 'com.sun.star.awt.grid.UnoControlGridModel', + 'pages': 'com.sun.star.awt.UnoMultiPageModel', + 'groupbox': 'com.sun.star.awt.UnoControlGroupBoxModel', + 'combobox': 'com.sun.star.awt.UnoControlComboBoxModel', + 'spinbutton': 'com.sun.star.awt.UnoControlSpinButtonModel', + 'numeric': 'com.sun.star.awt.UnoControlNumericFieldModel', + } + + def __init__(self, args): + self._obj = self._create(args) + self._model = self.obj.Model + self._events = None + self._modal = True + self._controls = {} + self._color_on_focus = COLOR_ON_FOCUS + self._id = '' + self._path = '' + self._init_controls() + + def _create(self, args): + service = 'com.sun.star.awt.DialogProvider' + path = args.pop('Path', '') + if path: + dp = create_instance(service, True) + dlg = dp.createDialog(_P.to_url(path)) + return dlg + + if 'Location' in args: + name = args['Name'] + library = args.get('Library', 'Standard') + location = args.get('Location', 'application').lower() + if location == 'user': + location = 'application' + url = f'vnd.sun.star.script:{library}.{name}?location={location}' + if location == 'document': + dp = create_instance(service, args=docs.active.obj) + else: + dp = create_instance(service, True) + # ~ uid = docs.active.uid + # ~ url = f'vnd.sun.star.tdoc:/{uid}/Dialogs/{library}/{name}.xml' + dlg = dp.createDialog(url) + return dlg + + dlg = create_instance('com.sun.star.awt.UnoControlDialog', True) + model = create_instance('com.sun.star.awt.UnoControlDialogModel', True) + toolkit = create_instance('com.sun.star.awt.Toolkit', True) + _set_properties(model, args) + dlg.setModel(model) + dlg.setVisible(False) + dlg.createPeer(toolkit, None) + return dlg + + def _get_type_control(self, name): + name = name.split('.')[2] + types = { + 'UnoFixedTextControl': 'label', + 'UnoEditControl': 'text', + 'UnoButtonControl': 'button', + } + return types[name] + + def _init_controls(self): + for control in self.obj.getControls(): + tipo = self._get_type_control(control.ImplementationName) + name = control.Model.Name + control = UNO_CLASSES[tipo](control) + setattr(self, name, control) + return + + @property + def obj(self): + return self._obj + + @property + def model(self): + return self._model + + @property + def controls(self): + return self._controls + + @property + def path(self): + return self._path + @property + def path_images(self): + return _P.join(self.path, DIR['images']) + @property + def id(self): + return self._id + @id.setter + def id(self, value): + self._id = value + self._path = _P.from_id(value) + + @property + def height(self): + return self.model.Height + @height.setter + def height(self, value): + self.model.Height = value + + @property + def width(self): + return self.model.Width + @width.setter + def width(self, value): + self.model.Width = value + + @property + def visible(self): + return self.obj.Visible + @visible.setter + def visible(self, value): + self.obj.Visible = value + + @property + def step(self): + return self.model.Step + @step.setter + def step(self, value): + self.model.Step = value + + @property + def events(self): + return self._events + @events.setter + def events(self, controllers): + self._events = controllers(self) + self._connect_listeners() + + @property + def color_on_focus(self): + return self._color_on_focus + @color_on_focus.setter + def color_on_focus(self, value): + self._color_on_focus = get_color(value) + + def _connect_listeners(self): + for control in self.obj.Controls: + _add_listeners(self.events, control, control.Model.Name) + return + + def _set_image_url(self, image): + if _P.exists(image): + return _P.to_url(image) + + path = _P.join(self._path, DIR['images'], image) + return _P.to_url(path) + + def _special_properties(self, tipo, args): + if tipo == 'link' and not 'Label' in args: + args['Label'] = args['URL'] + return args + + if tipo == 'button': + if 'ImageURL' in args: + args['ImageURL'] = self._set_image_url(args['ImageURL']) + args['FocusOnClick'] = args.get('FocusOnClick', False) + return args + + if tipo == 'roadmap': + args['Height'] = args.get('Height', self.height) + if 'Title' in args: + args['Text'] = args.pop('Title') + return args + + if tipo == 'tree': + args['SelectionType'] = args.get('SelectionType', SINGLE) + return args + + if tipo == 'grid': + args['ShowRowHeader'] = args.get('ShowRowHeader', True) + return args + + if tipo == 'pages': + args['Width'] = args.get('Width', self.width) + args['Height'] = args.get('Height', self.height) + + return args + + def add_control(self, args): + tipo = args.pop('Type').lower() + root = args.pop('Root', '') + sheets = args.pop('Sheets', ()) + columns = args.pop('Columns', ()) + + args = self._special_properties(tipo, args) + model = self.model.createInstance(self.MODELS[tipo]) + _set_properties(model, args) + name = args['Name'] + self.model.insertByName(name, model) + control = self.obj.getControl(name) + _add_listeners(self.events, control, name) + control = UNO_CLASSES[tipo](control) + + if tipo in ('listbox',): + control.path = self.path + + if tipo == 'tree' and root: + control.root = root + elif tipo == 'grid' and columns: + control.columns = columns + elif tipo == 'pages' and sheets: + control.sheets = sheets + control.events = self.events + + setattr(self, name, control) + self._controls[name] = control + return control + + def center(self, control, x=0, y=0): + w = self.width + h = self.height + + if isinstance(control, tuple): + wt = self.SEPARATION * -1 + for c in control: + wt += c.width + self.SEPARATION + x = w / 2 - wt / 2 + for c in control: + c.x = x + x = c.x + c.width + self.SEPARATION + return + + if x < 0: + x = w + x - control.width + elif x == 0: + x = w / 2 - control.width / 2 + if y < 0: + y = h + y - control.height + elif y == 0: + y = h / 2 - control.height / 2 + control.x = x + control.y = y + return + + def open(self, modal=True): + self._modal = modal + if modal: + return self.obj.execute() + else: + self.visible = True + return + + def close(self, value=0): + if self._modal: + value = self.obj.endDialog(value) + else: + self.visible = False + self.obj.dispose() + return value + + def set_values(self, data): + for k, v in data.items(): + self._controls[k].value = v + return + + +class LOSheets(object): + + def __getitem__(self, index): + return LODocs().active[index] + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + +class LOCells(object): + + def __getitem__(self, index): + return LODocs().active.active[index] + + +class LOShortCut(object): +# ~ getKeyEventsByCommand + + def __init__(self, app): + self._app = app + self._scm = None + self._init_values() + + def _init_values(self): + name = 'com.sun.star.ui.GlobalAcceleratorConfiguration' + instance = 'com.sun.star.ui.ModuleUIConfigurationManagerSupplier' + service = TYPE_DOC[self._app] + manager = create_instance(instance, True) + uicm = manager.getUIConfigurationManager(service) + self._scm = uicm.ShortCutManager + return + + def __contains__(self, item): + cmd = self._get_command(item) + return bool(cmd) + + def _get_key_event(self, command): + events = self._scm.AllKeyEvents + for event in events: + cmd = self._scm.getCommandByKeyEvent(event) + if cmd == command: + break + return event + + def _to_key_event(self, shortcut): + key_event = KeyEvent() + keys = shortcut.split('+') + for v in keys[:-1]: + key_event.Modifiers += MODIFIERS[v.lower()] + key_event.KeyCode = getattr(Key, keys[-1].upper()) + return key_event + + def _get_command(self, shortcut): + command = '' + key_event = self._to_key_event(shortcut) + try: + command = self._scm.getCommandByKeyEvent(key_event) + except NoSuchElementException: + debug(f'No exists: {shortcut}') + return command + + def add(self, shortcut, command): + if isinstance(command, dict): + command = _get_url_script(command) + key_event = self._to_key_event(shortcut) + self._scm.setKeyEvent(key_event, command) + self._scm.store() + return + + def reset(self): + self._scm.reset() + self._scm.store() + return + + def remove(self, shortcut): + key_event = self._to_key_event(shortcut) + try: + self._scm.removeKeyEvent(key_event) + self._scm.store() + except NoSuchElementException: + debug(f'No exists: {shortcut}') + return + + def remove_by_command(self, command): + if isinstance(command, dict): + command = _get_url_script(command) + try: + self._scm.removeCommandFromAllKeyEvents(command) + self._scm.store() + except NoSuchElementException: + debug(f'No exists: {command}') + return + + +class LOShortCuts(object): + + def __getitem__(self, index): + return LOShortCut(index) + + +class LOMenu(object): + + def __init__(self, app): + self._app = app + self._ui = None + self._pymenus = None + self._menu = None + self._menus = self._get_menus() + + def __getitem__(self, index): + if isinstance(index, int): + self._menu = self._menus[index] + else: + for menu in self._menus: + cmd = menu.get('CommandURL', '') + if MENUS[index.lower()] == cmd: + self._menu = menu + break + # ~ line = self._menu.get('CommandURL', '') + # ~ line += self._get_submenus(self._menu['ItemDescriptorContainer']) + return self._menu + + def _get_menus(self): + instance = 'com.sun.star.ui.ModuleUIConfigurationManagerSupplier' + service = TYPE_DOC[self._app] + manager = create_instance(instance, True) + self._ui = manager.getUIConfigurationManager(service) + self._pymenus = self._ui.getSettings(NODE_MENUBAR, True) + data = [] + for menu in self._pymenus: + data.append(data_to_dict(menu)) + return data + + def _get_info(self, menu): + line = menu.get('CommandURL', '') + line += self._get_submenus(menu['ItemDescriptorContainer']) + return line + + def _get_submenus(self, menu, level=1): + line = '' + for i, v in enumerate(menu): + data = data_to_dict(v) + cmd = data.get('CommandURL', '----------') + line += f'\n{" " * level}├─ ({i}) {cmd}' + submenu = data.get('ItemDescriptorContainer', None) + if not submenu is None: + line += self._get_submenus(submenu, level + 1) + return line + + def __str__(self): + info = '\n'.join([self._get_info(m) for m in self._menus]) + return info + + def _get_index_menu(self, menu, command): + index = -1 + for i, v in enumerate(menu): + data = data_to_dict(v) + cmd = data.get('CommandURL', '') + if cmd == command: + index = i + break + return index + + def insert(self, name, args): + idc = None + replace = False + command = args['CommandURL'] + label = args['Label'] + + self[name] + menu = self._menu['ItemDescriptorContainer'] + submenu = args.get('Submenu', False) + if submenu: + idc = self._ui.createSettings() + + index = self._get_index_menu(menu, command) + if index == -1: + if 'Index' in args: + index = args['Index'] + else: + index = self._get_index_menu(menu, args['After']) + 1 + else: + replace = True + + data = dict ( + CommandURL = command, + Label = label, + Style = 0, + Type = 0, + ItemDescriptorContainer = idc, + ) + self._save(menu, data, index, replace) + self._insert_submenu(idc, submenu) + return + + def _get_command(self, args): + shortcut = args.get('ShortCut', '') + cmd = args['CommandURL'] + if isinstance(cmd, dict): + cmd = _get_url_script(cmd) + if shortcut: + LOShortCut(self._app).add(shortcut, cmd) + return cmd + + def _insert_submenu(self, parent, menus): + for i, v in enumerate(menus): + submenu = v.pop('Submenu', False) + if submenu: + idc = self._ui.createSettings() + v['ItemDescriptorContainer'] = idc + v['Type'] = 0 + if v['Label'] == '-': + v['Type'] = 1 + else: + v['CommandURL'] = self._get_command(v) + self._save(parent, v, i) + if submenu: + self._insert_submenu(idc, submenu) + return + + def remove(self, name, command): + self[name] + menu = self._menu['ItemDescriptorContainer'] + index = self._get_index_menu(menu, command) + if index > -1: + uno.invoke(menu, 'removeByIndex', (index,)) + self._ui.replaceSettings(NODE_MENUBAR, self._pymenus) + self._ui.store() + return + + def _save(self, menu, properties, index, replace=False): + properties = dict_to_property(properties, True) + if replace: + uno.invoke(menu, 'replaceByIndex', (index, properties)) + else: + uno.invoke(menu, 'insertByIndex', (index, properties)) + self._ui.replaceSettings(NODE_MENUBAR, self._pymenus) + self._ui.store() + return + + +class LOMenus(object): + + def __getitem__(self, index): + return LOMenu(index) + + +class LOWindow(object): + EMPTY = """ + +""" + MODELS = { + 'label': 'com.sun.star.awt.UnoControlFixedTextModel', + 'link': 'com.sun.star.awt.UnoControlFixedHyperlinkModel', + 'button': 'com.sun.star.awt.UnoControlButtonModel', + 'radio': 'com.sun.star.awt.UnoControlRadioButtonModel', + 'checkbox': 'com.sun.star.awt.UnoControlCheckBoxModel', + 'text': 'com.sun.star.awt.UnoControlEditModel', + 'image': 'com.sun.star.awt.UnoControlImageControlModel', + 'listbox': 'com.sun.star.awt.UnoControlListBoxModel', + 'roadmap': 'com.sun.star.awt.UnoControlRoadmapModel', + 'tree': 'com.sun.star.awt.tree.TreeControlModel', + 'grid': 'com.sun.star.awt.grid.UnoControlGridModel', + 'pages': 'com.sun.star.awt.UnoMultiPageModel', + 'groupbox': 'com.sun.star.awt.UnoControlGroupBoxModel', + 'combobox': 'com.sun.star.awt.UnoControlComboBoxModel', + } + + def __init__(self, args): + self._events = None + self._menu = None + self._container = None + self._model = None + self._id = '' + self._path = '' + self._obj = self._create(args) + + def _create(self, properties): + ps = ( + properties.get('X', 0), + properties.get('Y', 0), + properties.get('Width', 500), + properties.get('Height', 500), + ) + self._title = properties.get('Title', TITLE) + self._create_frame(ps) + self._create_container(ps) + self._create_subcontainer(ps) + # ~ self._create_splitter(ps) + return + + def _create_frame(self, ps): + service = 'com.sun.star.frame.TaskCreator' + tc = create_instance(service, True) + self._frame = tc.createInstanceWithArguments(( + NamedValue('FrameName', 'EasyMacroWin'), + NamedValue('PosSize', Rectangle(*ps)), + )) + self._window = self._frame.getContainerWindow() + self._toolkit = self._window.getToolkit() + desktop = get_desktop() + self._frame.setCreator(desktop) + desktop.getFrames().append(self._frame) + self._frame.Title = self._title + return + + def _create_container(self, ps): + service = 'com.sun.star.awt.UnoControlContainer' + self._container = create_instance(service, True) + service = 'com.sun.star.awt.UnoControlContainerModel' + model = create_instance(service, True) + model.BackgroundColor = get_color((225, 225, 225)) + self._container.setModel(model) + self._container.createPeer(self._toolkit, self._window) + self._container.setPosSize(*ps, POSSIZE) + self._frame.setComponent(self._container, None) + return + + def _create_subcontainer(self, ps): + service = 'com.sun.star.awt.ContainerWindowProvider' + cwp = create_instance(service, True) + + path_tmp = _P.save_tmp(self.EMPTY) + subcont = cwp.createContainerWindow( + _P.to_url(path_tmp), '', self._container.getPeer(), None) + _P.kill(path_tmp) + + subcont.setPosSize(0, 0, 500, 500, POSSIZE) + subcont.setVisible(True) + self._container.addControl('subcont', subcont) + self._subcont = subcont + self._model = subcont.Model + return + + def _create_popupmenu(self, menus): + menu = create_instance('com.sun.star.awt.PopupMenu', True) + for i, m in enumerate(menus): + label = m['label'] + cmd = m.get('event', '') + if not cmd: + cmd = label.lower().replace(' ', '_') + if label == '-': + menu.insertSeparator(i) + else: + menu.insertItem(i, label, m.get('style', 0), i) + menu.setCommand(i, cmd) + # ~ menu.setItemImage(i, path?, True) + menu.addMenuListener(EventsMenu(self.events)) + return menu + + def _create_menu(self, menus): + #~ https://api.libreoffice.org/docs/idl/ref/interfacecom_1_1sun_1_1star_1_1awt_1_1XMenu.html + #~ nItemId specifies the ID of the menu item to be inserted. + #~ aText specifies the label of the menu item. + #~ nItemStyle 0 = Standard, CHECKABLE = 1, RADIOCHECK = 2, AUTOCHECK = 4 + #~ nItemPos specifies the position where the menu item will be inserted. + self._menu = create_instance('com.sun.star.awt.MenuBar', True) + for i, m in enumerate(menus): + self._menu.insertItem(i, m['label'], m.get('style', 0), i) + cmd = m['label'].lower().replace(' ', '_') + self._menu.setCommand(i, cmd) + submenu = self._create_popupmenu(m['submenu']) + self._menu.setPopupMenu(i, submenu) + + self._window.setMenuBar(self._menu) + return + + def _add_listeners(self, control=None): + if self.events is None: + return + controller = EventsWindow(self) + self._window.addTopWindowListener(controller) + self._window.addWindowListener(controller) + # ~ self._container.addKeyListener(EventsKeyWindow(self)) + return + + def _set_image_url(self, image): + if _P.exists(image): + return _P.to_url(image) + + path = _P.join(self._path, DIR['images'], image) + return _P.to_url(path) + + def _special_properties(self, tipo, args): + if tipo == 'link' and not 'Label' in args: + args['Label'] = args['URL'] + return args + + if tipo == 'button': + if 'ImageURL' in args: + args['ImageURL'] = self._set_image_url(args['ImageURL']) + args['FocusOnClick'] = args.get('FocusOnClick', False) + return args + + if tipo == 'roadmap': + args['Height'] = args.get('Height', self.height) + if 'Title' in args: + args['Text'] = args.pop('Title') + return args + + if tipo == 'tree': + args['SelectionType'] = args.get('SelectionType', SINGLE) + return args + + if tipo == 'grid': + args['ShowRowHeader'] = args.get('ShowRowHeader', True) + return args + + if tipo == 'pages': + args['Width'] = args.get('Width', self.width) + args['Height'] = args.get('Height', self.height) + + return args + + def add_control(self, args): + tipo = args.pop('Type').lower() + root = args.pop('Root', '') + sheets = args.pop('Sheets', ()) + columns = args.pop('Columns', ()) + + args = self._special_properties(tipo, args) + model = self.model.createInstance(self.MODELS[tipo]) + _set_properties(model, args) + name = args['Name'] + self.model.insertByName(name, model) + control = self._subcont.getControl(name) + _add_listeners(self.events, control, name) + control = UNO_CLASSES[tipo](control) + + # ~ if tipo in ('listbox',): + # ~ control.path = self.path + + if tipo == 'tree' and root: + control.root = root + elif tipo == 'grid' and columns: + control.columns = columns + elif tipo == 'pages' and sheets: + control.sheets = sheets + control.events = self.events + + setattr(self, name, control) + return control + + @property + def events(self): + return self._events + @events.setter + def events(self, controllers): + self._events = controllers(self) + self._add_listeners() + + @property + def model(self): + return self._model + + @property + def width(self): + return self._container.Size.Width + + @property + def height(self): + return self._container.Size.Height + + @property + def name(self): + return self._title.lower().replace(' ', '_') + + def add_menu(self, menus): + self._create_menu(menus) + return + + def open(self): + self._window.setVisible(True) + return + + def close(self): + self._window.setMenuBar(None) + self._window.dispose() + self._frame.close(True) + return + + +class LODBServer(object): + DRIVERS = { + 'mysql': 'mysqlc', + 'mariadb': 'mysqlc', + 'postgres': 'postgresql:postgresql', + } + PORTS = { + 'mysql': 3306, + 'mariadb': 3306, + 'postgres': 5432, + } + + def __init__(self): + self._conn = None + self._error = 'Not connected' + self._type = '' + self._drivers = [] + + def __str__(self): + return f'DB type {self._type}' + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + self.disconnet() + + @property + def is_connected(self): + return not self._conn is None + + @property + def error(self): + return self._error + + @property + def drivers(self): + return self._drivers + + def disconnet(self): + if not self._conn is None: + if not self._conn.isClosed(): + self._conn.close() + self._conn.dispose() + return + + def connect(self, options={}): + args = options.copy() + self._error = '' + self._type = args.get('type', 'postgres') + driver = self.DRIVERS[self._type] + server = args.get('server', 'localhost') + port = args.get('port', self.PORTS[self._type]) + dbname = args.get('dbname', '') + user = args['user'] + password = args['password'] + + data = {'user': user, 'password': password} + url = f'sdbc:{driver}:{server}:{port}/{dbname}' + + # ~ https://downloads.mariadb.com/Connectors/java/ + # ~ data['JavaDriverClass'] = 'org.mariadb.jdbc.Driver' + # ~ url = f'jdbc:mysql://{server}:{port}/{dbname}' + + args = dict_to_property(data) + manager = create_instance('com.sun.star.sdbc.DriverManager') + self._drivers = [d.ImplementationName for d in manager] + + try: + self._conn = manager.getConnectionWithInfo(url, args) + except Exception as e: + error(e) + self._error = str(e) + + return self + + def execute(self, sql): + query = self._conn.createStatement() + try: + query.execute(sql) + result = True + except Exception as e: + error(e) + self._error = str(e) + result = False + + return result + + +def create_window(args): + return LOWindow(args) + + +class classproperty: + def __init__(self, method=None): + self.fget = method + + def __get__(self, instance, cls=None): + return self.fget(cls) + + def getter(self, method): + self.fget = method + return self + + +class ClipBoard(object): + SERVICE = 'com.sun.star.datatransfer.clipboard.SystemClipboard' + CLIPBOARD_FORMAT_TEXT = 'text/plain;charset=utf-16' + + class TextTransferable(unohelper.Base, XTransferable): + + def __init__(self, text): + df = DataFlavor() + df.MimeType = ClipBoard.CLIPBOARD_FORMAT_TEXT + df.HumanPresentableName = "encoded text utf-16" + self.flavors = (df,) + self._data = text + + def getTransferData(self, flavor): + return self._data + + def getTransferDataFlavors(self): + return self.flavors + + + @classmethod + def set(cls, value): + ts = cls.TextTransferable(value) + sc = create_instance(cls.SERVICE) + sc.setContents(ts, None) + return + + @classproperty + def contents(cls): + df = None + text = '' + sc = create_instance(cls.SERVICE) + transferable = sc.getContents() + data = transferable.getTransferDataFlavors() + for df in data: + if df.MimeType == cls.CLIPBOARD_FORMAT_TEXT: + break + if df: + text = transferable.getTransferData(df) + return text +_CB = ClipBoard + + +class Paths(object): + FILE_PICKER = 'com.sun.star.ui.dialogs.FilePicker' + FOLDER_PICKER = 'com.sun.star.ui.dialogs.FolderPicker' + + def __init__(self, path=''): + if path.startswith('file://'): + path = str(Path(uno.fileUrlToSystemPath(path)).resolve()) + self._path = Path(path) + + @property + def path(self): + return str(self._path.parent) + + @property + def file_name(self): + return self._path.name + + @property + def name(self): + return self._path.stem + + @property + def ext(self): + return self._path.suffix[1:] + + @property + def info(self): + return self.path, self.file_name, self.name, self.ext + + @property + def url(self): + return self._path.as_uri() + + @property + def size(self): + return self._path.stat().st_size + + @classproperty + def home(self): + return str(Path.home()) + + @classproperty + def documents(self): + return self.config() + + @classproperty + def temp_dir(self): + return tempfile.gettempdir() + + @classproperty + def python(self): + if IS_WIN: + path = self.join(self.config('Module'), PYTHON) + elif IS_MAC: + path = self.join(self.config('Module'), '..', 'Resources', PYTHON) + else: + path = sys.executable + return path + + @classproperty + def user_profile(self): + path = self.config('UserConfig') + path = str(Path(path).parent) + return path + + @classproperty + def user_config(self): + path = self.config('UserConfig') + return path + + @classmethod + def dir_tmp(self, only_name=False): + dt = tempfile.TemporaryDirectory() + if only_name: + dt = dt.name + return dt + + @classmethod + def tmp(cls, ext=''): + tmp = tempfile.NamedTemporaryFile(suffix=ext) + return tmp.name + + @classmethod + def save_tmp(cls, data): + path_tmp = cls.tmp() + cls.save(path_tmp, data) + return path_tmp + + @classmethod + def config(cls, name='Work'): + """ + Return path from config + http://api.libreoffice.org/docs/idl/ref/interfacecom_1_1sun_1_1star_1_1util_1_1XPathSettings.html + """ + path = create_instance('com.sun.star.util.PathSettings') + path = cls.to_system(getattr(path, name)) + return path + + @classmethod + def get(cls, init_dir='', filters: str=''): + """ + Get path for save + Options: http://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1ui_1_1dialogs_1_1TemplateDescription.html + filters: 'xml' or 'txt,xml' + """ + if not init_dir: + init_dir = cls.documents + init_dir = cls.to_url(init_dir) + file_picker = create_instance(cls.FILE_PICKER) + file_picker.setTitle(_('Select path')) + file_picker.setDisplayDirectory(init_dir) + file_picker.initialize((2,)) + if filters: + filters = [(f.upper(), f'*.{f.lower()}') for f in filters.split(',')] + file_picker.setCurrentFilter(filters[0][0]) + for f in filters: + file_picker.appendFilter(f[0], f[1]) + + path = '' + if file_picker.execute(): + path = cls.to_system(file_picker.getSelectedFiles()[0]) + return path + + @classmethod + def get_dir(cls, init_dir=''): + folder_picker = create_instance(cls.FOLDER_PICKER) + if not init_dir: + init_dir = cls.documents + init_dir = cls.to_url(init_dir) + folder_picker.setTitle(_('Select directory')) + folder_picker.setDisplayDirectory(init_dir) + + path = '' + if folder_picker.execute(): + path = cls.to_system(folder_picker.getDirectory()) + return path + + @classmethod + def get_file(cls, init_dir: str='', filters: str='', multiple: bool=False): + """ + Get path file + + init_folder: folder default open + filters: 'xml' or 'xml,txt' + multiple: True for multiple selected + """ + if not init_dir: + init_dir = cls.documents + init_dir = cls.to_url(init_dir) + + file_picker = create_instance(cls.FILE_PICKER) + file_picker.setTitle(_('Select file')) + file_picker.setDisplayDirectory(init_dir) + file_picker.setMultiSelectionMode(multiple) + + if filters: + filters = [(f.upper(), f'*.{f.lower()}') for f in filters.split(',')] + file_picker.setCurrentFilter(filters[0][0]) + for f in filters: + file_picker.appendFilter(f[0], f[1]) + + path = '' + if file_picker.execute(): + files = file_picker.getSelectedFiles() + path = [cls.to_system(f) for f in files] + if not multiple: + path = path[0] + return path + + @classmethod + def replace_ext(cls, path, new_ext): + p = Paths(path) + name = f'{p.name}.{new_ext}' + path = cls.join(p.path, name) + return path + + @classmethod + def exists(cls, path): + result = False + if path: + path = cls.to_system(path) + result = Path(path).exists() + return result + + @classmethod + def exists_app(cls, name_app): + return bool(shutil.which(name_app)) + + @classmethod + def open(cls, path): + if IS_WIN: + os.startfile(path) + else: + pid = subprocess.Popen(['xdg-open', path]).pid + return + + @classmethod + def is_dir(cls, path): + return Path(path).is_dir() + + @classmethod + def is_file(cls, path): + return Path(path).is_file() + + @classmethod + def join(cls, *paths): + return str(Path(paths[0]).joinpath(*paths[1:])) + + @classmethod + def save(cls, path, data, encoding='utf-8'): + result = bool(Path(path).write_text(data, encoding=encoding)) + return result + + @classmethod + def save_bin(cls, path, data): + result = bool(Path(path).write_bytes(data)) + return result + + @classmethod + def read(cls, path, get_lines=False, encoding='utf-8'): + if get_lines: + with Path(path).open(encoding=encoding) as f: + data = f.readlines() + else: + data = Path(path).read_text(encoding=encoding) + return data + + @classmethod + def read_bin(cls, path): + data = Path(path).read_bytes() + return data + + @classmethod + def to_url(cls, path): + if not path.startswith('file://'): + path = Path(path).as_uri() + return path + + @classmethod + def to_system(cls, path): + if path.startswith('file://'): + path = str(Path(uno.fileUrlToSystemPath(path)).resolve()) + return path + + @classmethod + def kill(cls, path): + p = Path(path) + try: + if p.is_file(): + p.unlink() + elif p.is_dir(): + shutil.rmtree(path) + result = True + except OSError as e: + log.error(e) + result = False + + return result + + @classmethod + def files(cls, path, pattern='*'): + files = [str(p) for p in Path(path).glob(pattern) if p.is_file()] + return files + + @classmethod + def dirs(cls, path): + dirs = [str(p) for p in Path(path).iterdir() if p.is_dir()] + return dirs + + @classmethod + def walk(cls, path, filters=''): + paths = [] + if filters in ('*', '*.*'): + filters = '' + for folder, _, files in os.walk(path): + if filters: + pattern = re.compile(r'\.(?:{})$'.format(filters), re.IGNORECASE) + paths += [cls.join(folder, f) for f in files if pattern.search(f)] + else: + paths += [cls.join(folder, f) for f in files] + return paths + + @classmethod + def walk_dirs(cls, path, tree=False): + """ + Get directories recursively + path: path source + tree: get info in a tuple (ID_FOLDER, ID_PARENT, NAME) + """ + folders = [] + if tree: + i = 0 + p = 0 + parents = {path: 0} + for root, dirs, _ in os.walk(path): + for name in dirs: + i += 1 + rn = cls.join(root, name) + if not rn in parents: + parents[rn] = i + folders.append((i, parents[root], name)) + else: + for root, dirs, _ in os.walk(path): + folders += [cls.join(root, name) for name in dirs] + return folders + + @classmethod + def from_id(cls, id_ext): + pip = CTX.getValueByName('/singletons/com.sun.star.deployment.PackageInformationProvider') + path = _P.to_system(pip.getPackageLocation(id_ext)) + return path + + @classmethod + def from_json(cls, path): + data = json.loads(cls.read(path)) + return data + + @classmethod + def to_json(cls, path, data): + data = json.dumps(data, indent=4, ensure_ascii=False, sort_keys=True) + return cls.save(path, data) + + @classmethod + def from_csv(cls, path, args={}): + # ~ See https://docs.python.org/3.7/library/csv.html#csv.reader + with open(path) as f: + rows = tuple(csv.reader(f, **args)) + return rows + + @classmethod + def to_csv(cls, path, data, args={}): + with open(path, 'w') as f: + writer = csv.writer(f, **args) + writer.writerows(data) + return + + @classmethod + def zip(cls, source, target=''): + path_zip = target + if not isinstance(source, (tuple, list)): + path, _, name, _ = _P(source).info + start = len(path) + 1 + if not target: + path_zip = f'{path}/{name}.zip' + + if isinstance(source, (tuple, list)): + files = [(f, f[len(_P(f).path)+1:]) for f in source] + elif _P.is_file(source): + files = ((source, source[start:]),) + else: + files = [(f, f[start:]) for f in _P.walk(source)] + + compression = zipfile.ZIP_DEFLATED + with zipfile.ZipFile(path_zip, 'w', compression=compression) as z: + for f in files: + z.write(f[0], f[1]) + return path_zip + + @classmethod + def zip_content(cls, path): + with zipfile.ZipFile(path) as z: + names = z.namelist() + return names + + @classmethod + def unzip(cls, source, target='', members=None, pwd=None): + path = target + if not target: + path = _P(source).path + with zipfile.ZipFile(source) as z: + if not pwd is None: + pwd = pwd.encode() + if isinstance(members, str): + members = (members,) + z.extractall(path, members=members, pwd=pwd) + return + + @classmethod + def merge_zip(cls, target, zips): + try: + with zipfile.ZipFile(target, 'w', compression=zipfile.ZIP_DEFLATED) as t: + for path in zips: + with zipfile.ZipFile(path, compression=zipfile.ZIP_DEFLATED) as s: + for name in s.namelist(): + t.writestr(name, s.open(name).read()) + except Exception as e: + error(e) + return False + + return True + + @classmethod + def image(cls, path): + # ~ sfa = create_instance('com.sun.star.ucb.SimpleFileAccess') + # ~ stream = sfa.openFileRead(cls.to_url(path)) + gp = create_instance('com.sun.star.graphic.GraphicProvider') + if isinstance(path, str): + properties = (PropertyValue(Name='URL', Value=cls.to_url(path)),) + else: + properties = (PropertyValue(Name='InputStream', Value=path),) + image = gp.queryGraphic(properties) + return image + + @classmethod + def copy(cls, source, target='', name=''): + p, f, n, e = _P(source).info + if target: + p = target + e = f'.{e}' + if name: + e = '' + n = name + path_new = cls.join(p, f'{n}{e}') + shutil.copy(source, path_new) + return path_new +_P = Paths + + +class Dates(object): + + @classmethod + def date(cls, year, month, day): + d = datetime.date(year, month, day) + return d + + @classmethod + def str_to_date(cls, str_date, template, to_calc=False): + d = datetime.datetime.strptime(str_date, template).date() + if to_calc: + d = d.toordinal() - DATE_OFFSET + return d + + @classmethod + def calc_to_date(cls, value, frm=''): + d = datetime.date.fromordinal(int(value) + DATE_OFFSET) + if frm: + d = d.strftime(frm) + return d + + +class OutputStream(unohelper.Base, XOutputStream): + + def __init__(self): + self._buffer = b'' + self.closed = 0 + + @property + def buffer(self): + return self._buffer + + def closeOutput(self): + self.closed = 1 + + def writeBytes(self, seq): + if seq.value: + self._buffer = seq.value + + def flush(self): + pass + + +class IOStream(object): + + @classmethod + def buffer(cls): + return io.BytesIO() + + @classmethod + def input(cls, buffer): + instance = 'com.sun.star.io.SequenceInputStream' + stream = create_instance(instance, True) + stream.initialize((uno.ByteSequence(buffer.getvalue()),)) + return stream + + @classmethod + def output(cls): + return OutputStream() + + @classmethod + def qr(cls, data, **kwargs): + import segno + + kwargs['kind'] = kwargs.get('kind', 'svg') + kwargs['scale'] = kwargs.get('scale', 8) + kwargs['border'] = kwargs.get('border', 2) + buffer = cls.buffer() + segno.make(data).save(buffer, **kwargs) + stream = cls.input(buffer) + return stream + + +class SpellChecker(object): + + def __init__(self): + service = 'com.sun.star.linguistic2.SpellChecker' + self._spellchecker = create_instance(service, True) + self._locale = LOCALE + + @property + def locale(self): + slocal = f'{self._locale.Language}-{self._locale.Country}' + return slocale + @locale.setter + def locale(self, value): + lang = value.split('-') + self._locale = Locale(lang[0], lang[1], '') + + def is_valid(self, word): + result = self._spellchecker.isValid(word, self._locale, ()) + return result + + def spell(self, word): + result = self._spellchecker.spell(word, self._locale, ()) + if result: + result = result.getAlternatives() + if not isinstance(result, tuple): + result = () + return result + + +def spell(word, locale=''): + sc = SpellChecker() + if locale: + sc.locale = locale + return sc.spell(word) + + +def __getattr__(name): + if name == 'active': + return LODocs().active + if name == 'active_sheet': + return LODocs().active.active + if name == 'selection': + return LODocs().active.selection + if name == 'current_region': + return LODocs().active.selection.current_region + if name in ('rectangle', 'pos_size'): + return Rectangle() + if name == 'paths': + return Paths + if name == 'docs': + return LODocs() + if name == 'db': + return LODBServer() + if name == 'sheets': + return LOSheets() + if name == 'cells': + return LOCells() + if name == 'menus': + return LOMenus() + if name == 'shortcuts': + return LOShortCuts() + if name == 'clipboard': + return ClipBoard + if name == 'dates': + return Dates + if name == 'ios': + return IOStream() + raise AttributeError(f"module '{__name__}' has no attribute '{name}'") + + +def create_dialog(args): + return LODialog(args) + + +def inputbox(message, default='', title=TITLE, echochar=''): + + class ControllersInput(object): + + def __init__(self, dlg): + self.d = dlg + + def cmd_ok_action(self, event): + self.d.close(1) + return + + args = { + 'Title': title, + 'Width': 200, + 'Height': 80, + } + dlg = LODialog(args) + dlg.events = ControllersInput + + args = { + 'Type': 'Label', + 'Name': 'lbl_msg', + 'Label': message, + 'Width': 140, + 'Height': 50, + 'X': 5, + 'Y': 5, + 'MultiLine': True, + 'Border': 1, + } + dlg.add_control(args) + + args = { + 'Type': 'Text', + 'Name': 'txt_value', + 'Text': default, + 'Width': 190, + 'Height': 15, + } + if echochar: + args['EchoChar'] = ord(echochar[0]) + dlg.add_control(args) + dlg.txt_value.move(dlg.lbl_msg) + + args = { + 'Type': 'button', + 'Name': 'cmd_ok', + 'Label': _('OK'), + 'Width': 40, + 'Height': 15, + 'DefaultButton': True, + 'PushButtonType': 1, + } + dlg.add_control(args) + dlg.cmd_ok.move(dlg.lbl_msg, 10, 0) + + args = { + 'Type': 'button', + 'Name': 'cmd_cancel', + 'Label': _('Cancel'), + 'Width': 40, + 'Height': 15, + 'PushButtonType': 2, + } + dlg.add_control(args) + dlg.cmd_cancel.move(dlg.cmd_ok) + + if dlg.open(): + return dlg.txt_value.value + + return '' + + +def get_fonts(): + toolkit = create_instance('com.sun.star.awt.Toolkit') + device = toolkit.createScreenCompatibleDevice(0, 0) + return device.FontDescriptors + + +def get_filters(): + """ + Get all support filters + https://help.libreoffice.org/latest/en-US/text/shared/guide/convertfilters.html + """ + factory = create_instance('com.sun.star.document.FilterFactory') + rows = [data_to_dict(factory[name]) for name in factory] + for row in rows: + row['UINames'] = data_to_dict(row['UINames']) + return rows + + +# ~ https://en.wikipedia.org/wiki/Web_colors +def get_color(value): + COLORS = { + 'aliceblue': 15792383, + 'antiquewhite': 16444375, + 'aqua': 65535, + 'aquamarine': 8388564, + 'azure': 15794175, + 'beige': 16119260, + 'bisque': 16770244, + 'black': 0, + 'blanchedalmond': 16772045, + 'blue': 255, + 'blueviolet': 9055202, + 'brown': 10824234, + 'burlywood': 14596231, + 'cadetblue': 6266528, + 'chartreuse': 8388352, + 'chocolate': 13789470, + 'coral': 16744272, + 'cornflowerblue': 6591981, + 'cornsilk': 16775388, + 'crimson': 14423100, + 'cyan': 65535, + 'darkblue': 139, + 'darkcyan': 35723, + 'darkgoldenrod': 12092939, + 'darkgray': 11119017, + 'darkgreen': 25600, + 'darkgrey': 11119017, + 'darkkhaki': 12433259, + 'darkmagenta': 9109643, + 'darkolivegreen': 5597999, + 'darkorange': 16747520, + 'darkorchid': 10040012, + 'darkred': 9109504, + 'darksalmon': 15308410, + 'darkseagreen': 9419919, + 'darkslateblue': 4734347, + 'darkslategray': 3100495, + 'darkslategrey': 3100495, + 'darkturquoise': 52945, + 'darkviolet': 9699539, + 'deeppink': 16716947, + 'deepskyblue': 49151, + 'dimgray': 6908265, + 'dimgrey': 6908265, + 'dodgerblue': 2003199, + 'firebrick': 11674146, + 'floralwhite': 16775920, + 'forestgreen': 2263842, + 'fuchsia': 16711935, + 'gainsboro': 14474460, + 'ghostwhite': 16316671, + 'gold': 16766720, + 'goldenrod': 14329120, + 'gray': 8421504, + 'grey': 8421504, + 'green': 32768, + 'greenyellow': 11403055, + 'honeydew': 15794160, + 'hotpink': 16738740, + 'indianred': 13458524, + 'indigo': 4915330, + 'ivory': 16777200, + 'khaki': 15787660, + 'lavender': 15132410, + 'lavenderblush': 16773365, + 'lawngreen': 8190976, + 'lemonchiffon': 16775885, + 'lightblue': 11393254, + 'lightcoral': 15761536, + 'lightcyan': 14745599, + 'lightgoldenrodyellow': 16448210, + 'lightgray': 13882323, + 'lightgreen': 9498256, + 'lightgrey': 13882323, + 'lightpink': 16758465, + 'lightsalmon': 16752762, + 'lightseagreen': 2142890, + 'lightskyblue': 8900346, + 'lightslategray': 7833753, + 'lightslategrey': 7833753, + 'lightsteelblue': 11584734, + 'lightyellow': 16777184, + 'lime': 65280, + 'limegreen': 3329330, + 'linen': 16445670, + 'magenta': 16711935, + 'maroon': 8388608, + 'mediumaquamarine': 6737322, + 'mediumblue': 205, + 'mediumorchid': 12211667, + 'mediumpurple': 9662683, + 'mediumseagreen': 3978097, + 'mediumslateblue': 8087790, + 'mediumspringgreen': 64154, + 'mediumturquoise': 4772300, + 'mediumvioletred': 13047173, + 'midnightblue': 1644912, + 'mintcream': 16121850, + 'mistyrose': 16770273, + 'moccasin': 16770229, + 'navajowhite': 16768685, + 'navy': 128, + 'oldlace': 16643558, + 'olive': 8421376, + 'olivedrab': 7048739, + 'orange': 16753920, + 'orangered': 16729344, + 'orchid': 14315734, + 'palegoldenrod': 15657130, + 'palegreen': 10025880, + 'paleturquoise': 11529966, + 'palevioletred': 14381203, + 'papayawhip': 16773077, + 'peachpuff': 16767673, + 'peru': 13468991, + 'pink': 16761035, + 'plum': 14524637, + 'powderblue': 11591910, + 'purple': 8388736, + 'red': 16711680, + 'rosybrown': 12357519, + 'royalblue': 4286945, + 'saddlebrown': 9127187, + 'salmon': 16416882, + 'sandybrown': 16032864, + 'seagreen': 3050327, + 'seashell': 16774638, + 'sienna': 10506797, + 'silver': 12632256, + 'skyblue': 8900331, + 'slateblue': 6970061, + 'slategray': 7372944, + 'slategrey': 7372944, + 'snow': 16775930, + 'springgreen': 65407, + 'steelblue': 4620980, + 'tan': 13808780, + 'teal': 32896, + 'thistle': 14204888, + 'tomato': 16737095, + 'turquoise': 4251856, + 'violet': 15631086, + 'wheat': 16113331, + 'white': 16777215, + 'whitesmoke': 16119285, + 'yellow': 16776960, + 'yellowgreen': 10145074, + } + + if isinstance(value, tuple): + color = (value[0] << 16) + (value[1] << 8) + value[2] + else: + if value[0] == '#': + r, g, b = bytes.fromhex(value[1:]) + color = (r << 16) + (g << 8) + b + else: + color = COLORS.get(value.lower(), -1) + return color + + +COLOR_ON_FOCUS = get_color('LightYellow') + + +class LOServer(object): + HOST = 'localhost' + PORT = '8100' + ARG = f'socket,host={HOST},port={PORT};urp;StarOffice.ComponentContext' + CMD = ['soffice', + '-env:SingleAppInstance=false', + '-env:UserInstallation=file:///tmp/LO_Process8100', + '--headless', '--norestore', '--invisible', + f'--accept={ARG}'] + + def __init__(self): + self._server = None + self._ctx = None + self._sm = None + self._start_server() + self._init_values() + + def _init_values(self): + global CTX + global SM + + if not self.is_running: + return + + ctx = uno.getComponentContext() + service = 'com.sun.star.bridge.UnoUrlResolver' + resolver = ctx.ServiceManager.createInstanceWithContext(service, ctx) + self._ctx = resolver.resolve('uno:{}'.format(self.ARG)) + self._sm = self._ctx.getServiceManager() + CTX = self._ctx + SM = self._sm + return + + @property + def is_running(self): + try: + s = socket.create_connection((self.HOST, self.PORT), 5.0) + s.close() + debug('LibreOffice is running...') + return True + except ConnectionRefusedError: + return False + + def _start_server(self): + if self.is_running: + return + + for i in range(3): + self._server = subprocess.Popen(self.CMD, + stdout=subprocess.PIPE, stderr=subprocess.PIPE) + time.sleep(3) + if self.is_running: + break + return + + def stop(self): + if self._server is None: + print('Search pgrep soffice') + else: + self._server.terminate() + debug('LibreOffice is stop...') + return + + def create_instance(self, name, with_context=True): + if with_context: + instance = self._sm.createInstanceWithContext(name, self._ctx) + else: + instance = self._sm.createInstance(name) + return instance diff --git a/source/pythonpath/stats.py b/source/pythonpath/stats.py new file mode 100644 index 0000000..a7e4fe6 --- /dev/null +++ b/source/pythonpath/stats.py @@ -0,0 +1,331 @@ +#!/usr/bin/env python3 + +# ~ Thanks: +# ~ https://github.com/kolypto/py-password-strength/blob/master/password_strength/stats.py + + +import re +import unicodedata +from collections import Counter +from functools import wraps +from math import log + + +def cached_property(f): + """ Property that will replace itself with a calculated value """ + name = '__' + f.__name__ + + @wraps(f) + def wrapper(self): + if not hasattr(self, name): + setattr(self, name, f(self)) + return getattr(self, name) + return property(wrapper) + + +class PasswordStats(object): + """ PasswordStats allows to calculate statistics on a password. + + It considers a password as a unicode string, and all statistics are unicode-based. + """ + + def __init__(self, password): + self.password = password + + #region Statistics + + @cached_property + def alphabet(self): + """ Get alphabet: set of used characters + + :rtype: set + """ + return set(self.password) + + @cached_property + def alphabet_cardinality(self): + """ Get alphabet cardinality: alphabet length + + :rtype: int + """ + return len(self.alphabet) + + @cached_property + def char_categories_detailed(self): + """ Character count per unicode category, detailed format. + + See: http://www.unicode.org/reports/tr44/#GC_Values_Table + + :returns: Counter( unicode-character-category: count ) + :rtype: collections.Counter + """ + return Counter(map(unicodedata.category, self.password)) + + @cached_property + def char_categories(self): + """ Character count per top-level category + + The following top-level categories are defined: + + - L: letter + - M: Mark + - N: Number + - P: Punctuation + - S: Symbol + - Z: Separator + - C: Other + + :return: Counter(unicode-character-category: count } + :rtype: collections.Counter + """ + c = Counter() + for cat, n in self.char_categories_detailed.items(): + c[cat[0]] += n + return c + + #endregion + + #region Counters + + @cached_property + def length(self): + """ Get password length + + :rtype: int + """ + return len(self.password) + + @cached_property + def letters(self): + """ Count all letters + + :rtype: int + """ + return self.char_categories['L'] + + @cached_property + def letters_uppercase(self): + """ Count uppercase letters + + :rtype: int + """ + return self.char_categories_detailed['Lu'] + + @cached_property + def letters_lowercase(self): + """ Count lowercase letters + + :rtype: int + """ + return self.char_categories_detailed['Ll'] + + @cached_property + def numbers(self): + """ Count numbers + + :rtype: int + """ + return self.char_categories['N'] + + def count(self, *categories): + """ Count characters of the specified classes only + + :param categories: Character categories to count + :type categories: Iterable + :rtype: int + """ + return sum([int(cat_n[0] in categories) * cat_n[1] for cat_n in list(self.char_categories.items())]) + + def count_except(self, *categories): + """ Count characters of all classes except the specified ones + + :param categories: Character categories to exclude from count + :type categories: Iterable + :rtype: int + """ + return sum([int(cat_n1[0] not in categories) * cat_n1[1] for cat_n1 in list(self.char_categories.items())]) + + @cached_property + def special_characters(self): + """ Count special characters + + Special characters is everything that's not a letter or a number + + :rtype: int + """ + return self.count_except('L', 'N') + + #region Security + + @cached_property + def combinations(self): + """ The number of possible combinations with the current alphabet + + :rtype: long + """ + return self.alphabet_cardinality ** self.length + + @cached_property + def entropy_bits(self): + """ Get information entropy bits: log2 of the number of possible passwords + + https://en.wikipedia.org/wiki/Password_strength + + :rtype: float + """ + return self.length * log(self.alphabet_cardinality, 2) + + @cached_property + def entropy_density(self): + """ Get information entropy density factor, ranged {0 .. 1}. + + This is ratio of entropy_bits() to max bits a password of this length could have. + E.g. if all characters are unique -- then it's 1.0. + If half of the characters are reused once -- then it's 0.5. + + :rtype: float + """ + # Simplifying: + # entropy_bits / (length * log(length, 2)) = + # = log(alphabet_cardinality, 2) / log(length, 2) = + # = log(alphabet_cardinality, length) + return log(self.alphabet_cardinality, self.length) + + def strength(self, weak_bits=30): + """ Get password strength as a number normalized to range {0 .. 1}. + + Normalization is done in the following fashion: + + 1. If entropy_bits <= weak_bits -- linear in range{0.0 .. 0.33} (weak) + 2. If entropy_bits <= weak_bits*2 -- almost linear in range{0.33 .. 0.66} (medium) + 3. If entropy_bits > weak_bits*3 -- asymptotic towards 1.0 (strong) + + :param weak_bits: Minimum entropy bits a medium password should have. + :type weak_bits: int + :return: Normalized password strength: + * <0.33 is WEAK + * <0.66 is MEDIUM + * >0.66 is STRONG + :rtype: float + """ + WEAK_MAX = 0.333333333 + + if self.entropy_bits <= weak_bits: + return WEAK_MAX * self.entropy_bits / weak_bits + + HARD_BITS = weak_bits*3 + HARD_VAL = 0.950 + + # Here, we want a function that: + # 1. f(x)=0.333 at x=weak_bits + # 2. f(x)=0.950 at x=weak_bits*3 (great estimation for a perfect password) + # 3. f(x) is almost linear in range{weak_bits .. weak_bits*2}: doubling the bits should double the strength + # 4. f(x) has an asymptote of 1.0 (normalization) + + # First, the function: + # f(x) = 1 - (1-WEAK_MAX)*2^( -k*x) + + # Now, the equation: + # f(HARD_BITS) = HARD_VAL + # 1 - (1-WEAK_MAX)*2^( -k*HARD_BITS) = HARD_VAL + # 2^( -k*HARD_BITS) = (1 - HARD_VAL) / (1-WEAK_MAX) + # k = -log2((1 - HARD_VAL) / (1-WEAK_MAX)) / HARD_BITS + k = -log((1 - HARD_VAL) / (1-WEAK_MAX), 2) / HARD_BITS + f = lambda x: 1 - (1-WEAK_MAX)*pow(2, -k*x) + + return f(self.entropy_bits - weak_bits) # with offset + + #endregion + + #region Detectors + + _repeated_patterns_rex = re.compile(r'((.+?)\2+)', re.UNICODE | re.DOTALL | re.IGNORECASE) + + @cached_property + def repeated_patterns_length(self): + """ Detect and return the length of repeated patterns. + + You will probably be comparing it with the length of the password itself and ban if it's longer than 10% + + :rtype: int + """ + length = 0 + for substring, pattern in self._repeated_patterns_rex.findall(self.password): + length += len(substring) + return length + + _sequences = ( + 'abcdefghijklmnopqrstuvwxyz' # Alphabet + 'qwertyuiopasdfghjklzxcvbnm' # Keyboard + '~!@#$%^&*()_+-=' # Keyboard special, top row + '01234567890' # Numbers + ) + _sequences = _sequences + _sequences[::-1] # reversed + + @cached_property + def sequences_length(self): + """ Detect and return the length of used sequences: + + - Alphabet letters: abcd... + - Keyboard letters: qwerty, etc + - Keyboard special characters in the top row: ~!@#$%^&*()_+ + - Numbers: 0123456 + + :return: Total length of character sequences that are subsets of the common sequences + :rtype: int + """ + # FIXME: Optimize this. I'm sure there is a better way!... + sequences_length = 0 + + # Iterate through the string, with manual variable (to allow skips) + i = 0 + while i < len(self.password): + # Slice (since we use it often) + password = self.password[i:] + + # Iterate over sequences to find longest common prefix + j = -1 + common_length = 1 + while True: + # Detect the first match with the current character + # A character may appear multiple times + j = self._sequences.find(password[0], j+1) + if j == -1: + break + + # Find the longest common prefix + common_here = '' + for a, b in zip(password, self._sequences[j:]): + if a != b: break + else: common_here += a + + # It it's longer than previous discoveries -- store it + common_length = max(common_length, len(common_here)) + + # Repeated sequence? + if common_length > 2: + sequences_length += common_length + + # Next: skip to the end of the detected sequence + i += common_length + + return sequences_length + + @cached_property + def weakness_factor(self): + """ Get weakness factor as a float in range {0 .. 1} + + This detects the portion of the string that contains: + * repeated patterns + * sequences + + E.g. a value of 1.0 means the whole string is weak, and 0.5 means half of the string is weak. + + Typical usage: + + password_strength = (1 - weakness_factor) * strength + + :return: Weakness factor + :rtype: float + """ + return min(1.0, (self.repeated_patterns_length + self.sequences_length) / self.length) diff --git a/source/pythonpath/zpass.py b/source/pythonpath/zpass.py new file mode 100644 index 0000000..49fc150 --- /dev/null +++ b/source/pythonpath/zpass.py @@ -0,0 +1,348 @@ +#!/usr/bin/env python3 + +import string +import random +import easymacro as app +from stats import PasswordStats + + +_ = None +PREFIX = 'zazpass' +DEFAULT_LENGTH = 25 +DEFAULT_CHARACTERS = ( + string.ascii_uppercase + + string.ascii_lowercase + + string.digits + + string.punctuation) + + +def main(id_extension, args, path_locales): + global _ + + if args == 'insert': + _password_insert() + return + + if args == 'copy': + _password_copy() + return + + _ = app.install_locales(path_locales) + _password_generate(id_extension) + + return + + +def _from_config(): + characters = '' + config = app.get_config('setting', PREFIX) + length = config.get('length', DEFAULT_LENGTH) + if config: + if config['letters']: + characters += string.ascii_uppercase + if config['letters2']: + characters += string.ascii_lowercase + if config['digits']: + characters += string.digits + if config['punctuation']: + characters += string.punctuation + else: + characters = DEFAULT_CHARACTERS + + return list(characters), length + + +def _from_controls(dialog): + characters = '' + + length = int(dialog.txt_length.value) + if dialog.chk_letters.value: + characters += string.ascii_uppercase + if dialog.chk_letters2.value: + characters += string.ascii_lowercase + if dialog.chk_digits.value: + characters += string.digits + if dialog.chk_punctuation.value: + characters += string.punctuation + + if not characters: + dialog.chk_letters.value = True + characters = string.ascii_uppercase + + return list(characters), length + + +def _get_data(dialog): + if dialog is None: + characters, lenght = _from_config() + else: + characters, lenght = _from_controls(dialog) + return characters, lenght + + +def _generate(dialog=None): + characters, length = _get_data(dialog) + random.shuffle(characters) + password = [random.choice(characters) for i in range(length)] + random.shuffle(password) + password = ''.join(password) + return password + + +def _password_insert(): + for cell in app.selection: + cell.str = _generate() + return + + +def _password_copy(): + app.clipboard.set(_generate()) + return + + +def _password_generate(id_extension): + config = app.get_config('setting', prefix=PREFIX) + dialog = _create_dialog(id_extension) + + length = config.get('length', DEFAULT_LENGTH) + letters = True + letters2 = True + digits = True + punctuation = True + if config: + letters = config['letters'] + letters2 = config['letters2'] + digits = config['digits'] + punctuation = config['punctuation'] + + dialog.chk_letters.value = letters + dialog.chk_letters2.value = letters2 + dialog.chk_digits.value = digits + dialog.chk_punctuation.value = punctuation + + dialog.txt_length.value = length + dialog.txt_password.value = _generate(dialog) + dialog.open() + return + + +class Controllers(object): + + def __init__(self, dialog): + self.d = dialog + + def cmd_close_action(self, event): + self.d.close() + return + + def cmd_switch_action(self, event): + char = self.d.txt_password.echochar + name_image = 'eye-close.svg' + if char == '*': + self.d.txt_password.echochar = '' + name_image = 'eye-open.svg' + else: + self.d.txt_password.echochar = '*' + + path_image = app.paths.join(self.d.path_images, name_image) + self.d.cmd_switch.image = path_image + self.d.txt_password.set_focus() + + return + + def cmd_insert_action(self, event): + for cell in app.selection: + cell.str = self.d.txt_password.value + self.d.close() + return + + def _save_config(self): + data = dict( + length = self.d.txt_length.int, + letters = self.d.chk_letters.value, + letters2 = self.d.chk_letters2.value, + digits = self.d.chk_digits.value, + punctuation = self.d.chk_punctuation.value, + ) + app.set_config('setting', data, PREFIX) + return + + + def _new_password(self, save=True): + stats = PasswordStats(_generate(self.d)) + self.d.txt_password.value = stats.password + if save: + self._save_config() + return + + def cmd_new_action(self, event): + self._new_password(False) + return + + def txt_length_after_click(self, event): + self._new_password() + return + + def chk_letters_after_click(self, event): + self._new_password() + return + + def chk_letters2_after_click(self, event): + self._new_password() + return + + def chk_digits_after_click(self, event): + self._new_password() + return + + def chk_punctuation_after_click(self, event): + self._new_password() + return + + +@app.catch_exception +def _create_dialog(id_extension): + BUTTON_WH = 16 + CHK_WIDTH = 25 + + attr = dict( + Name = 'Dialog', + Title = _('Generate Password'), + Width = 200, + Height = 100, + ) + dialog = app.create_dialog(attr) + dialog.id = id_extension + dialog.events = Controllers + + attr = dict( + Type = 'Text', + Name = 'txt_password', + Width = 150, + Height = 12, + X = 5, + Y = 10, + EchoChar = ord('*'), + ) + dialog.add_control(attr) + + attr = dict( + Type = 'Button', + Name = 'cmd_switch', + Width = BUTTON_WH, + Height = BUTTON_WH, + ImageURL = 'eye-close.svg', + FocusOnClick = True, + ) + dialog.add_control(attr) + + attr = dict( + Type = 'Button', + Name = 'cmd_new', + Width = BUTTON_WH, + Height = BUTTON_WH, + ImageURL = 'new.svg', + ) + dialog.add_control(attr) + + attr = dict( + Type = 'Label', + Name = 'lbl_title_length', + Label = _('Length: '), + Width = 50, + Height = BUTTON_WH, + Border = 1, + Align = 2, + VerticalAlign = 1, + ) + dialog.add_control(attr) + + attr = dict( + Type = 'Numeric', + Name = 'txt_length', + Width = 50, + Height = BUTTON_WH, + DecimalAccuracy = 0, + Spin = True, + Value = 25, + ValueStep = 1, + ValueMin = 10, + ValueMax = 100, + ) + dialog.add_control(attr) + + attr = dict( + Type = 'CheckBox', + Name = 'chk_letters', + Label = 'A-Z', + Width = CHK_WIDTH, + Height = BUTTON_WH, + ) + dialog.add_control(attr) + + attr = dict( + Type = 'CheckBox', + Name = 'chk_letters2', + Label = 'a-z', + Width = CHK_WIDTH, + Height = BUTTON_WH, + ) + dialog.add_control(attr) + + attr = dict( + Type = 'CheckBox', + Name = 'chk_digits', + Label = '0-9', + Width = CHK_WIDTH, + Height = BUTTON_WH, + ) + dialog.add_control(attr) + + attr = dict( + Type = 'CheckBox', + Name = 'chk_punctuation', + Label = string.punctuation, + Width = CHK_WIDTH * 4, + Height = BUTTON_WH, + ) + dialog.add_control(attr) + + attr = dict( + Type = 'Button', + Name = 'cmd_insert', + Label = _('~Insert'), + Width = 70, + Height = BUTTON_WH, + ImageURL = 'insert.svg', + ImagePosition = 1, + ) + dialog.add_control(attr) + + attr = dict( + Type = 'Button', + Name = 'cmd_close', + Label = _('~Close'), + Width = 70, + Height = BUTTON_WH, + ImageURL = 'close.svg', + ImagePosition = 1, + ) + dialog.add_control(attr) + + dialog.cmd_switch.move(dialog.txt_password, x=3, y=-2) + dialog.cmd_new.move(dialog.cmd_switch, x=3, y=0) + dialog.lbl_title_length.move(dialog.txt_password) + dialog.txt_length.move(dialog.lbl_title_length, x=3, y=0) + dialog.chk_letters.move(dialog.lbl_title_length) + dialog.chk_letters2.move(dialog.chk_letters, x=3, y=0) + dialog.chk_digits.move(dialog.chk_letters2, x=3, y=0) + dialog.chk_punctuation.move(dialog.chk_digits, x=3, y=0) + + dialog.center(dialog.cmd_insert, y=-5) + dialog.center(dialog.cmd_close, y=-5) + dialog.center((dialog.cmd_close, dialog.cmd_insert)) + + return dialog + + + diff --git a/source/registration/license_en.txt b/source/registration/license_en.txt new file mode 100644 index 0000000..5f68220 --- /dev/null +++ b/source/registration/license_en.txt @@ -0,0 +1,14 @@ +This file is part of ZAZPass. + + ZAZPass is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ZAZPass is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with ZAZPass. If not, see . diff --git a/source/registration/license_es.txt b/source/registration/license_es.txt new file mode 100644 index 0000000..5f68220 --- /dev/null +++ b/source/registration/license_es.txt @@ -0,0 +1,14 @@ +This file is part of ZAZPass. + + ZAZPass is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ZAZPass is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with ZAZPass. If not, see . diff --git a/zaz.py b/zaz.py new file mode 100755 index 0000000..4846605 --- /dev/null +++ b/zaz.py @@ -0,0 +1,823 @@ +#!/usr/bin/env python3 + +# == Rapid Develop Macros in LibreOffice == + +# ~ This file is part of ZAZ. + +# ~ https://git.elmau.net/elmau/zaz + +# ~ ZAZ is free software: you can redistribute it and/or modify +# ~ it under the terms of the GNU General Public License as published by +# ~ the Free Software Foundation, either version 3 of the License, or +# ~ (at your option) any later version. + +# ~ ZAZ is distributed in the hope that it will be useful, +# ~ but WITHOUT ANY WARRANTY; without even the implied warranty of +# ~ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# ~ GNU General Public License for more details. + +# ~ You should have received a copy of the GNU General Public License +# ~ along with ZAZ. If not, see . + +import argparse +import os +import py_compile +import re +import sys +import zipfile +from datetime import datetime +from pathlib import Path +from shutil import copyfile +from subprocess import call +from xml.etree import ElementTree as ET +from xml.dom.minidom import parseString + + +from conf import ( + DATA, + DIRS, + DOMAIN, + EXTENSION, + FILES, + INFO, + PATHS, + TYPE_EXTENSION, + USE_LOCALES, + log) + + +EASYMACRO = 'easymacro.py' + + +class LiboXML(object): + CONTEXT = { + 'calc': 'com.sun.star.sheet.SpreadsheetDocument', + 'writer': 'com.sun.star.text.TextDocument', + 'impress': 'com.sun.star.presentation.PresentationDocument', + 'draw': 'com.sun.star.drawing.DrawingDocument', + 'base': 'com.sun.star.sdb.OfficeDatabaseDocument', + 'math': 'com.sun.star.formula.FormulaProperties', + 'basic': 'com.sun.star.script.BasicIDE', + } + TYPES = { + 'py': 'application/vnd.sun.star.uno-component;type=Python', + 'pyc': 'application/binary', + 'zip': 'application/binary', + 'xcu': 'application/vnd.sun.star.configuration-data', + 'rdb': 'application/vnd.sun.star.uno-typelibrary;type=RDB', + 'xcs': 'application/vnd.sun.star.configuration-schema', + 'help': 'application/vnd.sun.star.help', + 'component': 'application/vnd.sun.star.uno-components', + } + NS_MANIFEST = { + 'manifest_version': '1.2', + 'manifest': 'urn:oasis:names:tc:opendocument:xmlns:manifest:1.0', + 'xmlns:loext': 'urn:org:documentfoundation:names:experimental:office:xmlns:loext:1.0', + } + NS_DESCRIPTION = { + 'xmlns': 'http://openoffice.org/extensions/description/2006', + 'xmlns:xlink': 'http://www.w3.org/1999/xlink', + 'xmlns:d': 'http://openoffice.org/extensions/description/2006', + } + NS_ADDONS = { + 'xmlns:xs': 'http://www.w3.org/2001/XMLSchema', + 'xmlns:oor': 'http://openoffice.org/2001/registry', + } + NS_UPDATE = { + 'xmlns': 'http://openoffice.org/extensions/update/2006', + 'xmlns:d': 'http://openoffice.org/extensions/description/2006', + 'xmlns:xlink': 'http://www.w3.org/1999/xlink', + } + + def __init__(self): + self._manifest = None + self._paths = [] + self._path_images = '' + self._toolbars = [] + + def _save_path(self, attr): + self._paths.append(attr['{{{}}}full-path'.format(self.NS_MANIFEST['manifest'])]) + return + + def _clean(self, name, nodes): + has_words = re.compile('\\w') + + if not re.search(has_words, str(nodes.tail)): + nodes.tail = '' + if not re.search(has_words, str(nodes.text)): + nodes.text = '' + + for node in nodes: + if name == 'manifest': + self._save_path(node.attrib) + if not re.search(has_words, str(node.tail)): + node.tail = '' + if not re.search(has_words, str(node.text)): + node.text = '' + return + + def new_manifest(self, data): + attr = { + 'manifest:version': self.NS_MANIFEST['manifest_version'], + 'xmlns:manifest': self.NS_MANIFEST['manifest'], + 'xmlns:loext': self.NS_MANIFEST['xmlns:loext'], + } + self._manifest = ET.Element('manifest:manifest', attr) + return self.add_data_manifest(data) + + def parse_manifest(self, data): + ET.register_namespace('manifest', self.NS_MANIFEST['manifest']) + self._manifest = ET.fromstring(data) + attr = {'xmlns:loext': self.NS_MANIFEST['xmlns:loext']} + self._manifest.attrib.update(**attr) + self._clean('manifest', self._manifest) + return + + def add_data_manifest(self, data): + node_name = 'manifest:file-entry' + attr = { + 'manifest:full-path': '', + 'manifest:media-type': '', + } + for path in data: + if path in self._paths: + continue + ext = path.split('.')[-1] + attr['manifest:full-path'] = path + attr['manifest:media-type'] = self.TYPES.get(ext, '') + ET.SubElement(self._manifest, node_name, attr) + return self._get_xml(self._manifest) + + def new_description(self, data): + doc = ET.Element('description', self.NS_DESCRIPTION) + + key = 'identifier' + ET.SubElement(doc, key, data[key]) + + key = 'version' + ET.SubElement(doc, key, data[key]) + + key = 'display-name' + node = ET.SubElement(doc, key) + for k, v in data[key].items(): + sn = ET.SubElement(node, 'name', {'lang': k}) + sn.text = v + + node = ET.SubElement(doc, 'extension-description') + for k in data[key].keys(): + attr = { + 'lang': k, + 'xlink:href': f'description/desc_{k}.txt', + } + ET.SubElement(node, 'src', attr) + + key = 'icon' + node = ET.SubElement(doc, key) + attr = {'xlink:href': f"images/{data[key]}"} + ET.SubElement(node, 'default', attr) + + key = 'publisher' + node = ET.SubElement(doc, key) + for k, v in data[key].items(): + attr = { + 'xlink:href': v['link'], + 'lang': k, + } + sn = ET.SubElement(node, 'name', attr) + sn.text = v['text'] + + key = 'display-name' + node = ET.SubElement(doc, 'registration') + attr = { + 'accept-by': 'user', + 'suppress-on-update': 'true', + } + node = ET.SubElement(node, 'simple-license', attr) + for k in data[key].keys(): + attr = { + 'xlink:href': f"{DIRS['registration']}/license_{k}.txt", + 'lang': k + } + ET.SubElement(node, 'license-text', attr) + + if data['update']: + node = ET.SubElement(doc, 'update-information') + ET.SubElement(node, 'src', {'xlink:href': data['update']}) + + return self._get_xml(doc) + + def _get_context(self, args): + if not args: + return '' + context = ','.join([self.CONTEXT[v] for v in args.split(',')]) + return context + + def _add_node_value(self, node, name, value='_self'): + attr = {'oor:name': name, 'oor:type': 'xs:string'} + sn = ET.SubElement(node, 'prop', attr) + sn = ET.SubElement(sn, 'value') + sn.text = value + return + + def _add_menu(self, id_extension, node, index, menu, in_menu_bar=True): + if in_menu_bar: + attr = { + 'oor:name': index, + 'oor:op': 'replace', + } + subnode = ET.SubElement(node, 'node', attr) + else: + subnode = node + + attr = {'oor:name': 'Title', 'oor:type': 'xs:string'} + sn1 = ET.SubElement(subnode, 'prop', attr) + for k, v in menu['title'].items(): + sn2 = ET.SubElement(sn1, 'value', {'xml:lang': k}) + sn2.text = v + value = self._get_context(menu['context']) + self._add_node_value(subnode, 'Context', value) + + if 'submenu' in menu: + sn = ET.SubElement(subnode, 'node', {'oor:name': 'Submenu'}) + for i, m in enumerate(menu['submenu']): + self._add_menu(id_extension, sn, f'{index}.s{i}', m) + if m.get('toolbar', False): + self._toolbars.append(m) + return + + value = f"service:{id_extension}?{menu['argument']}" + self._add_node_value(subnode, 'URL', value) + self._add_node_value(subnode, 'Target') + value = f"%origin%/{self._path_images}/{menu['icon']}" + self._add_node_value(subnode, 'ImageIdentifier', value) + return + + def new_addons(self, id_extension, data): + in_menu_bar = data['parent'] == 'OfficeMenuBar' + self._path_images = data['images'] + attr = { + 'oor:name': 'Addons', + 'oor:package': 'org.openoffice.Office', + } + attr.update(self.NS_ADDONS) + doc = ET.Element('oor:component-data', attr) + parent = ET.SubElement(doc, 'node', {'oor:name': 'AddonUI'}) + node = ET.SubElement(parent, 'node', {'oor:name': data['parent']}) + + op = 'fuse' + if in_menu_bar: + op = 'replace' + + attr = {'oor:name': id_extension, 'oor:op': op} + node = ET.SubElement(node, 'node', attr) + + if in_menu_bar: + attr = {'oor:name': 'Title', 'oor:type': 'xs:string'} + subnode = ET.SubElement(node, 'prop', attr) + for k, v in data['main'].items(): + sn = ET.SubElement(subnode, 'value', {'xml:lang': k}) + sn.text = v + + self._add_node_value(node, 'Target') + node = ET.SubElement(node, 'node', {'oor:name': 'Submenu'}) + + for i, menu in enumerate(data['menus']): + self._add_menu(id_extension, node, f'm{i}', menu, in_menu_bar) + if menu.get('toolbar', False): + self._toolbars.append(menu) + + if self._toolbars: + attr = {'oor:name': 'OfficeToolBar'} + toolbar = ET.SubElement(parent, 'node', attr) + attr = {'oor:name': id_extension, 'oor:op': 'replace'} + toolbar = ET.SubElement(toolbar, 'node', attr) + for t, menu in enumerate(self._toolbars): + self._add_menu(id_extension, toolbar, f't{t}', menu) + + return self._get_xml(doc) + + def _add_shortcut(self, node, key, id_extension, arg): + attr = {'oor:name': key, 'oor:op': 'fuse'} + subnode = ET.SubElement(node, 'node', attr) + subnode = ET.SubElement(subnode, 'prop', {'oor:name': 'Command'}) + subnode = ET.SubElement(subnode, 'value', {'xml:lang': 'en-US'}) + subnode.text = f"service:{id_extension}?{arg}" + return + + def _get_acceleartors(self, menu): + if 'submenu' in menu: + for m in menu['submenu']: + return self._get_acceleartors(m) + + if not menu.get('shortcut', ''): + return '' + + return menu + + def new_accelerators(self, id_extension, menus): + attr = { + 'oor:name': 'Accelerators', + 'oor:package': 'org.openoffice.Office', + } + attr.update(self.NS_ADDONS) + doc = ET.Element('oor:component-data', attr) + parent = ET.SubElement(doc, 'node', {'oor:name': 'PrimaryKeys'}) + + data = [] + for m in menus: + info = self._get_acceleartors(m) + if info: + data.append(info) + + node_global = None + node_modules = None + for m in data: + if m['context']: + if node_modules is None: + node_modules = ET.SubElement( + parent, 'node', {'oor:name': 'Modules'}) + for app in m['context'].split(','): + node = ET.SubElement( + node_modules, 'node', {'oor:name': self.CONTEXT[app]}) + self._add_shortcut( + node, m['shortcut'], id_extension, m['argument']) + else: + if node_global is None: + node_global = ET.SubElement( + parent, 'node', {'oor:name': 'Global'}) + self._add_shortcut( + node_global, m['shortcut'], id_extension, m['argument']) + + return self._get_xml(doc) + + def new_update(self, extension, url_oxt): + doc = ET.Element('description', self.NS_UPDATE) + ET.SubElement(doc, 'identifier', {'value': extension['id']}) + ET.SubElement(doc, 'version', {'value': extension['version']}) + node = ET.SubElement(doc, 'update-download') + ET.SubElement(node, 'src', {'xlink:href': url_oxt}) + node = ET.SubElement(doc, 'release-notes') + return self._get_xml(doc) + + def _get_xml(self, doc): + xml = parseString(ET.tostring(doc, encoding='utf-8')) + return xml.toprettyxml(indent=' ', encoding='utf-8').decode('utf-8') + + +def _exists(path): + return os.path.exists(path) + + +def _join(*paths): + return os.path.join(*paths) + + +def _mkdir(path): + return Path(path).mkdir(parents=True, exist_ok=True) + + +def _save(path, data): + with open(path, 'w') as f: + f.write(data) + return + + +def _get_files(path, filters=''): + paths = [] + if filters in ('*', '*.*'): + filters = '' + for folder, _, files in os.walk(path): + if filters: + pattern = re.compile(r'\.(?:{})$'.format(filters), re.IGNORECASE) + paths += [_join(folder, f) for f in files if pattern.search(f)] + else: + paths += files + return paths + + +def _compress_oxt(): + log.info('Compress OXT extension...') + + path_oxt = _join(DIRS['files'], FILES['oxt']) + + z = zipfile.ZipFile(path_oxt, 'w', compression=zipfile.ZIP_DEFLATED) + root_len = len(os.path.abspath(DIRS['source'])) + for root, dirs, files in os.walk(DIRS['source']): + relative = os.path.abspath(root)[root_len:] + for f in files: + fullpath = _join(root, f) + file_name = _join(relative, f) + if file_name == FILES['idl']: + continue + z.write(fullpath, file_name, zipfile.ZIP_DEFLATED) + z.close() + + log.info('Extension OXT created successfully...') + return + + +def _install_and_test(): + path_oxt = (_join(DIRS['files'], FILES['oxt']),) + call(PATHS['install'] + path_oxt) + log.info('Install extension successfully...') + log.info('Start LibreOffice...') + call(PATHS['soffice']) + return + + +def _validate_new(): + path_source = DIRS['source'] + if not _exists(path_source): + return True + + msg = f'Path: {path_source}, exists, delete first' + log.error(msg) + return False + + +def _create_new_directories(): + path_source = DIRS['source'] + _mkdir(path_source) + path = _join(path_source, DIRS['meta']) + _mkdir(path) + path = _join(path_source, DIRS['description']) + _mkdir(path) + path = _join(path_source, DIRS['images']) + _mkdir(path) + path = _join(path_source, DIRS['registration']) + _mkdir(path) + path = _join(path_source, DIRS['office']) + _mkdir(path) + + if FILES['easymacro'] or DIRS['pythonpath']: + path = _join(path_source, 'pythonpath') + _mkdir(path) + + path = DIRS['files'] + if not _exists(path): + _mkdir(path) + + msg = 'Created directories...' + log.info(msg) + return + + +def _create_new_files(): + path_source = DIRS['source'] + + for k, v in INFO.items(): + file_name = f'license_{k}.txt' + path = _join(path_source, DIRS['registration'], file_name) + _save(path, v['license']) + + if TYPE_EXTENSION > 1: + path = _join(path_source, FILES['idl']) + _save(path, DATA['idl']) + + path = _join(path_source, FILES['py']) + _save(path, DATA['py']) + + + msg = 'Created files...' + log.info(msg) + return + + +def _validate_update(): + if TYPE_EXTENSION == 1: + return True + + if not _exists(PATHS['idlc']): + msg = 'Binary: "idlc" not found' + log.error(msg) + return False + + if not _exists(PATHS['include']): + msg = 'Directory: "include" not found' + log.error(msg) + return False + + if not _exists(PATHS['regmerge']): + msg = 'Binary: "regmerge" not found' + log.error(msg) + return False + + path = _join(DIRS['source'], FILES['idl']) + if not _exists(path): + msg = f'File: "{FILES["idl"]}" not found' + log.error(msg) + return False + + return True + + +def _compile_idl(): + if TYPE_EXTENSION == 1: + return + + log.info('Compilate IDL...') + path_rdb = _join(DIRS['source'], FILES['rdb']) + path_urd = _join(DIRS['source'], FILES['urd']) + + path = _join(DIRS['source'], FILES['idl']) + call([PATHS['idlc'], '-I', PATHS['include'], path]) + call([PATHS['regmerge'], path_rdb, '/UCR', path_urd]) + os.remove(path_urd) + + log.info('Compilate IDL successfully...') + return + + +def _update_files(): + path_files = DIRS['files'] + if not _exists(path_files): + _mkdir(path_files) + + path_source = DIRS['source'] + + for k, v in INFO.items(): + file_name = FILES['ext_desc'].format(k) + path = _join(path_source, DIRS['description'], file_name) + _save(path, v['description']) + + path_logo = EXTENSION['icon'][0] + if _exists(path_logo): + file_name = EXTENSION['icon'][1] + path = _join(path_source, DIRS['images'], file_name) + copyfile(path_logo, path) + + files = os.listdir(DIRS['images']) + for f in files: + if f[-3:].lower() == 'bmp': + source = _join(DIRS['images'], f) + target = _join(path_source, DIRS['images'], f) + copyfile(source, target) + + if FILES['easymacro']: + source = EASYMACRO + target = _join(path_source, 'pythonpath', source) + copyfile(source, target) + + xml = LiboXML() + + path = _join(path_source, DIRS['meta'], FILES['manifest']) + data = xml.new_manifest(DATA['manifest']) + _save(path, data) + + path = _join(path_source, FILES['description']) + data = xml.new_description(DATA['description']) + _save(path, data) + + if TYPE_EXTENSION == 1: + path = _join(path_source, FILES['addons']) + data = xml.new_addons(EXTENSION['id'], DATA['addons']) + _save(path, data) + + path = _join(path_source, DIRS['office']) + _mkdir(path) + path = _join(path_source, DIRS['office'], FILES['shortcut']) + data = xml.new_accelerators(EXTENSION['id'], DATA['addons']['menus']) + _save(path, data) + + + if TYPE_EXTENSION == 3: + path = _join(path_source, FILES['addin']) + _save(path, DATA['addin']) + + if USE_LOCALES: + msg = "Don't forget generate DOMAIN.pot for locales" + for lang in EXTENSION['languages']: + path = _join(path_source, DIRS['locales'], lang, 'LC_MESSAGES') + Path(path).mkdir(parents=True, exist_ok=True) + log.info(msg) + + if DATA['update']: + path_xml = _join(path_files, FILES['update']) + data = xml.new_update(EXTENSION, DATA['update']) + _save(path_xml, data) + + _compile_idl() + return + + +def _create(): + if not _validate_new(): + return + + _create_new_directories() + _create_new_files() + _update_files() + + msg = f"New extension: {EXTENSION['name']} make sucesfully...\n" + msg += '\tNow, you can install and test: zaz.py -i' + log.info(msg) + return + + +def _get_info_path(path): + path, filename = os.path.split(path) + name, extension = os.path.splitext(filename) + return (path, filename, name, extension) + + +def _zip_embed(source, files): + PATH = 'Scripts/python/' + FILE_PYC = 'easymacro.pyc' + + p, f, name, e = _get_info_path(source) + now = datetime.now().strftime('_%Y%m%d_%H%M%S') + path_source = _join(p, name + now + e) + copyfile(source, path_source) + target = source + + py_compile.compile(EASYMACRO, FILE_PYC) + xml = LiboXML() + + path_easymacro = PATH + FILE_PYC + names = [f[1] for f in files] + [path_easymacro] + nodes = [] + with zipfile.ZipFile(target, 'w', compression=zipfile.ZIP_DEFLATED) as zt: + with zipfile.ZipFile(path_source, compression=zipfile.ZIP_DEFLATED) as zs: + for name in zs.namelist(): + if FILES['manifest'] in name: + path_manifest = name + xml_manifest = zs.open(name).read() + elif name in names: + continue + else: + zt.writestr(name, zs.open(name).read()) + + data = [] + for path, name in files: + data.append(name) + zt.write(path, name) + + zt.write(FILE_PYC, path_easymacro) + data.append(path_easymacro) + + xml.parse_manifest(xml_manifest) + xml_manifest = xml.add_data_manifest(data) + zt.writestr(path_manifest, xml_manifest) + + os.unlink(FILE_PYC) + return + + +def _embed(args): + PATH = 'Scripts/python' + PYTHONPATH = 'pythonpath' + + doc = args.document + if not doc: + msg = '-d/--document Path file to embed is mandatory' + log.error(msg) + return + if not _exists(doc): + msg = 'Path file not exists' + log.error(msg) + return + + files = [] + if args.files: + files = args.files.split(',') + source = _join(PATHS['profile'], PATH) + content = os.listdir(source) + if PYTHONPATH in content: + content.remove(PYTHONPATH) + + if files: + files = [(_join(source, f), _join(PATH, f)) for f in files if f in content] + else: + files = [(_join(source, f), _join(PATH, f)) for f in content] + + _zip_embed(doc, files) + + log.info('Embedded macros successfully...') + return + + +def _locales(args): + if args.files: + files = args.files.split(',') + else: + files = _get_files(DIRS['source'], 'py') + paths = ' '.join([f for f in files if not EASYMACRO in f]) + path_pot = _join(DIRS['source'], DIRS['locales'], '{}.pot'.format(DOMAIN)) + call([PATHS['gettext'], '-o', path_pot, paths]) + log.info('POT generate successfully...') + return + + +def _update(): + path_locales = _join(DIRS['source'], DIRS['locales']) + path_pot = _join(DIRS['source'], DIRS['locales'], '{}.pot'.format(DOMAIN)) + if not _exists(path_pot): + log.error('Not exists file POT...') + return + + files = _get_files(path_locales, 'po') + if not files: + log.error('First, generate files PO...') + return + + for f in files: + call([PATHS['msgmerge'], '-U', f, path_pot]) + log.info('\tUpdate: {}'.format(f)) + + log.info('Locales update successfully...') + return + + +def _new(args): + if not args.target: + msg = 'Add argument target: -t PATH_TARGET' + log.error(msg) + return + + if not args.name: + msg = 'Add argument name: -n name-new-extension' + log.error(msg) + return + + path = _join(args.target, args.name) + _mkdir(path) + _mkdir(_join(path, 'files')) + _mkdir(_join(path, 'images')) + path_logo = 'images/pymacros.png' + copyfile(path_logo, _join(path, 'images/logo.png')) + copyfile('zaz.py', _join(path, 'zaz.py')) + copyfile(EASYMACRO, _join(path, 'easymacro.py')) + copyfile('conf.py.example', _join(path, 'conf.py')) + + msg = 'Folders and files copy successfully for new extension.' + log.info(msg) + msg = f'Change to folder: {path}' + log.info(msg) + return + + +def main(args): + if args.new: + _new(args) + return + + if args.update: + _update() + return + + if args.locales: + _locales(args) + return + + if args.embed: + _embed(args) + return + + if args.create: + _create() + return + + if not _validate_update(): + return + + if not args.only_compress: + _update_files() + + _compress_oxt() + + if args.install: + _install_and_test() + + log.info('Extension make successfully...') + return + + +def _process_command_line_arguments(): + parser = argparse.ArgumentParser(description='Make LibreOffice extensions') + + parser.add_argument('-new', '--new', dest='new', action='store_true', + default=False, required=False) + parser.add_argument('-t', '--target', dest='target', default='') + parser.add_argument('-n', '--name', dest='name', default='', required=False) + parser.add_argument('-c', '--create', dest='create', action='store_true', + default=False, required=False) + parser.add_argument('-i', '--install', dest='install', action='store_true', + default=False, required=False) + parser.add_argument('-e', '--embed', dest='embed', action='store_true', + default=False, required=False) + parser.add_argument('-d', '--document', dest='document', default='') + parser.add_argument('-f', '--files', dest='files', default='') + parser.add_argument('-l', '--locales', dest='locales', action='store_true', + default=False, required=False) + parser.add_argument('-u', '--update', dest='update', action='store_true', + default=False, required=False) + parser.add_argument('-oc', '--only_compress', dest='only_compress', + action='store_true', default=False, required=False) + + return parser.parse_args() + + +if __name__ == '__main__': + args = _process_command_line_arguments() + main(args) +