Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1474 insertions, 0 deletions

diff --git a/wizards/source/access2base/access2base.py b/wizards/source/access2base/access2base.py
new file mode 100644
index 000000000..d68cd87aa
--- /dev/null
+++ b/wizards/source/access2base/access2base.py
@@ -0,0 +1,1474 @@
+# -*- coding: utf-8 -*-
+
+#     Copyright 2012-2020 Jean-Pierre LEDURE
+
+# =====================================================================================================================
+# ===                   The Access2Base library is a part of the LibreOffice project.                               ===
+# ===                   Full documentation is available on http://www.access2base.com                               ===
+# =====================================================================================================================
+
+# Access2Base 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.
+
+# Access2Base is free software; you can redistribute it and/or modify it under the terms of either (at your option):
+
+# 1) The Mozilla Public License, v. 2.0. If a copy of the MPL was not
+# distributed with this file, you can obtain one at http://mozilla.org/MPL/2.0/ .
+
+# 2) The GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version. If a copy of the LGPL was not
+# distributed with this file, see http://www.gnu.org/licenses/ .
+
+"""
+The access2base.py module implements an interface between Python (user) scripts and the Access2Base Basic library.
+
+Usage:
+    from access2base import *
+Additionally, if Python and LibreOffice are started in separate processes:
+    If LibreOffice started from console ... (example for Linux)
+        ./soffice --accept='socket,host=localhost,port=2019;urp;'
+    then insert next statement
+        A2BConnect(hostname = 'localhost', port = 2019)
+
+Specific documentation about Access2Base and Python:
+    http://www.access2base.com/access2base.html#%5B%5BAccess2Base%20and%20Python%5D%5D
+"""
+
+import uno
+XSCRIPTCONTEXT = uno
+
+from platform import system as _opsys
+import datetime, os, sys, traceback
+
+_LIBRARY = ''               # Should be 'Access2Base' or 'Access2BaseDev'
+_VERSION = '6.4'            # Actual version number
+_WRAPPERMODULE = 'Python'   # Module name in the Access2Base library containing Python interfaces
+
+# CallByName types
+_vbGet, _vbLet, _vbMethod, _vbSet, _vbUNO = 2, 4, 1, 8, 16
+
+
+class _Singleton(type):
+    """
+    A Singleton design pattern
+    Credits: « Python in a Nutshell » by Alex Martelli, O'Reilly
+    """
+    instances = {}
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls.instances:
+            cls.instances[cls] = super(_Singleton, cls).__call__(*args, **kwargs)
+        return cls.instances[cls]
+
+
+class acConstants(object, metaclass = _Singleton):
+    """
+    VBA constants used in the Access2Base API.
+    Values derived from MSAccess, except when conflicts
+    """
+    # Python special constants (used in the protocol between Python and Basic)
+    # -----------------------------------------------------------------
+    Empty = '+++EMPTY+++'
+    Null = '+++NULL+++'
+    Missing = '+++MISSING+++'
+    FromIsoFormat = '%Y-%m-%d %H:%M:%S' # To be used with datetime.datetime.strptime()
+
+    # AcCloseSave
+    # -----------------------------------------------------------------
+    acSaveNo = 2
+    acSavePrompt = 0
+    acSaveYes = 1
+
+    # AcFormView
+    # -----------------------------------------------------------------
+    acDesign = 1
+    acNormal = 0
+    acPreview = 2
+
+    # AcFormOpenDataMode
+    # -----------------------------------------------------------------
+    acFormAdd = 0
+    acFormEdit = 1
+    acFormPropertySettings = -1
+    acFormReadOnly = 2
+
+    # acView
+    # -----------------------------------------------------------------
+    acViewDesign = 1
+    acViewNormal = 0
+    acViewPreview = 2
+
+    # acOpenDataMode
+    # -----------------------------------------------------------------
+    acAdd = 0
+    acEdit = 1
+    acReadOnly = 2
+
+    # AcObjectType
+    # -----------------------------------------------------------------
+    acDefault = -1
+    acDiagram = 8
+    acForm = 2
+    acQuery = 1
+    acReport = 3
+    acTable = 0
+    #   Unexisting in MS/Access
+    acBasicIDE = 101
+    acDatabaseWindow = 102
+    acDocument = 111
+    acWelcome = 112
+    #   Subtype if acDocument
+    docWriter = "Writer"
+    docCalc = "Calc"
+    docImpress = "Impress"
+    docDraw = "Draw"
+    docMath = "Math"
+
+    # AcWindowMode
+    # -----------------------------------------------------------------
+    acDialog = 3
+    acHidden = 1
+    acIcon = 2
+    acWindowNormal = 0
+
+    # VarType constants
+    # -----------------------------------------------------------------
+    vbEmpty = 0
+    vbNull = 1
+    vbInteger = 2
+    vbLong = 3
+    vbSingle = 4
+    vbDouble = 5
+    vbCurrency = 6
+    vbDate = 7
+    vbString = 8
+    vbObject = 9
+    vbBoolean = 11
+    vbVariant = 12
+    vbByte = 17
+    vbUShort = 18
+    vbULong = 19
+    vbBigint = 35
+    vbDecimal = 37
+    vbArray = 8192
+
+    # MsgBox constants
+    # -----------------------------------------------------------------
+    vbOKOnly = 0  # OK button only (default)
+    vbOKCancel = 1  # OK and Cancel buttons
+    vbAbortRetryIgnore = 2  # Abort, Retry, and Ignore buttons
+    vbYesNoCancel = 3  # Yes, No, and Cancel buttons
+    vbYesNo = 4  # Yes and No buttons
+    vbRetryCancel = 5  # Retry and Cancel buttons
+    vbCritical = 16  # Critical message
+    vbQuestion = 32  # Warning query
+    vbExclamation = 48  # Warning message
+    vbInformation = 64  # Information message
+    vbDefaultButton1 = 128  # First button is default (default) (VBA: 0)
+    vbDefaultButton2 = 256  # Second button is default
+    vbDefaultButton3 = 512  # Third button is default
+    vbApplicationModal = 0  # Application modal message box (default)
+    # MsgBox Return Values
+    # -----------------------------------------------------------------
+    vbOK = 1  # OK button pressed
+    vbCancel = 2  # Cancel button pressed
+    vbAbort = 3  # Abort button pressed
+    vbRetry = 4  # Retry button pressed
+    vbIgnore = 5  # Ignore button pressed
+    vbYes = 6  # Yes button pressed
+    vbNo = 7  # No button pressed
+
+    # Dialogs Return Values
+    # ------------------------------------------------------------------
+    dlgOK = 1  # OK button pressed
+    dlgCancel = 0  # Cancel button pressed
+
+    # Control Types
+    # -----------------------------------------------------------------
+    acCheckBox = 5
+    acComboBox = 7
+    acCommandButton = 2
+    acToggleButton = 122
+    acCurrencyField = 18
+    acDateField = 15
+    acFileControl = 12
+    acFixedLine = 24  # FREE ENTRY (USEFUL IN DIALOGS)
+    acFixedText = 10
+    acLabel = 10
+    acFormattedField = 1  # FREE ENTRY TAKEN TO NOT CONFUSE WITH acTextField
+    acGridControl = 11
+    acGroupBox = 8
+    acOptionGroup = 8
+    acHiddenControl = 13
+    acImageButton = 4
+    acImageControl = 14
+    acImage = 14
+    acListBox = 6
+    acNavigationBar = 22
+    acNumericField = 17
+    acPatternField = 19
+    acProgressBar = 23  # FREE ENTRY (USEFUL IN DIALOGS)
+    acRadioButton = 3
+    acOptionButton = 3
+    acScrollBar = 20
+    acSpinButton = 21
+    acSubform = 112
+    acTextField = 9
+    acTextBox = 9
+    acTimeField = 16
+
+    # AcRecord
+    # -----------------------------------------------------------------
+    acFirst = 2
+    acGoTo = 4
+    acLast = 3
+    acNewRec = 5
+    acNext = 1
+    acPrevious = 0
+
+    # FindRecord
+    # -----------------------------------------------------------------
+    acAnywhere = 0
+    acEntire = 1
+    acStart = 2
+    acDown = 1
+    acSearchAll = 2
+    acUp = 0
+    acAll = 0
+    acCurrent = -1
+
+    # AcDataObjectType
+    # -----------------------------------------------------------------
+    acActiveDataObject = -1
+    acDataForm = 2
+    acDataQuery = 1
+    acDataServerView = 7
+    acDataStoredProcedure = 9
+    acDataTable = 0
+
+    # AcQuitOption
+    # -----------------------------------------------------------------
+    acQuitPrompt = 0
+    acQuitSaveAll = 1
+    acQuitSaveNone = 2
+
+    # AcCommand
+    # -----------------------------------------------------------------
+    acCmdAboutMicrosoftAccess = 35
+    acCmdAboutOpenOffice = 35
+    acCmdAboutLibreOffice = 35
+    acCmdVisualBasicEditor = 525
+    acCmdBringToFront = 52
+    acCmdClose = 58
+    acCmdToolbarsCustomize = 165
+    acCmdChangeToCommandButton = 501
+    acCmdChangeToCheckBox = 231
+    acCmdChangeToComboBox = 230
+    acCmdChangeToTextBox = 227
+    acCmdChangeToLabel = 228
+    acCmdChangeToImage = 234
+    acCmdChangeToListBox = 229
+    acCmdChangeToOptionButton = 233
+    acCmdCopy = 190
+    acCmdCut = 189
+    acCmdCreateRelationship = 150
+    acCmdDelete = 337
+    acCmdDatabaseProperties = 256
+    acCmdSQLView = 184
+    acCmdRemove = 366
+    acCmdDesignView = 183
+    acCmdFormView = 281
+    acCmdNewObjectForm = 136
+    acCmdNewObjectTable = 134
+    acCmdNewObjectView = 350
+    acCmdOpenDatabase = 25
+    acCmdNewObjectQuery = 135
+    acCmdShowAllRelationships = 149
+    acCmdNewObjectReport = 137
+    acCmdSelectAll = 333
+    acCmdRemoveTable = 84
+    acCmdOpenTable = 221
+    acCmdRename = 143
+    acCmdDeleteRecord = 223
+    acCmdApplyFilterSort = 93
+    acCmdSnapToGrid = 62
+    acCmdViewGrid = 63
+    acCmdInsertHyperlink = 259
+    acCmdMaximumRecords = 508
+    acCmdObjectBrowser = 200
+    acCmdPaste = 191
+    acCmdPasteSpecial = 64
+    acCmdPrint = 340
+    acCmdPrintPreview = 54
+    acCmdSaveRecord = 97
+    acCmdFind = 30
+    acCmdUndo = 292
+    acCmdRefresh = 18
+    acCmdRemoveFilterSort = 144
+    acCmdRunMacro = 31
+    acCmdSave = 20
+    acCmdSaveAs = 21
+    acCmdSelectAllRecords = 109
+    acCmdSendToBack = 53
+    acCmdSortDescending = 164
+    acCmdSortAscending = 163
+    acCmdTabOrder = 41
+    acCmdDatasheetView = 282
+    acCmdZoomSelection = 371
+
+    # AcSendObjectType
+    # -----------------------------------------------------------------
+    acSendForm = 2
+    acSendNoObject = -1
+    acSendQuery = 1
+    acSendReport = 3
+    acSendTable = 0
+
+    # AcOutputObjectType
+    # -----------------------------------------------------------------
+    acOutputTable = 0
+    acOutputQuery = 1
+    acOutputForm = 2
+    acOutputArray = -1
+
+    # AcEncoding
+    # -----------------------------------------------------------------
+    acUTF8Encoding = 76
+
+    # AcFormat
+    # -----------------------------------------------------------------
+    acFormatPDF = "writer_pdf_Export"
+    acFormatODT = "writer8"
+    acFormatDOC = "MS Word 97"
+    acFormatHTML = "HTML"
+    acFormatODS = "calc8"
+    acFormatXLS = "MS Excel 97"
+    acFormatXLSX = "Calc MS Excel 2007 XML"
+    acFormatTXT = "Text - txt - csv (StarCalc)"
+
+    # AcExportQuality
+    # -----------------------------------------------------------------
+    acExportQualityPrint = 0
+    acExportQualityScreen = 1
+
+    # AcSysCmdAction
+    # -----------------------------------------------------------------
+    acSysCmdAccessDir = 9
+    acSysCmdAccessVer = 7
+    acSysCmdClearHelpTopic = 11
+    acSysCmdClearStatus = 5
+    acSysCmdGetObjectState = 10
+    acSysCmdGetWorkgroupFile = 13
+    acSysCmdIniFile = 8
+    acSysCmdInitMeter = 1
+    acSysCmdProfile = 12
+    acSysCmdRemoveMeter = 3
+    acSysCmdRuntime = 6
+    acSysCmdSetStatus = 4
+    acSysCmdUpdateMeter = 2
+
+    # Type property
+    # -----------------------------------------------------------------
+    dbBigInt = 16
+    dbBinary = 9
+    dbBoolean = 1
+    dbByte = 2
+    dbChar = 18
+    dbCurrency = 5
+    dbDate = 8
+    dbDecimal = 20
+    dbDouble = 7
+    dbFloat = 21
+    dbGUID = 15
+    dbInteger = 3
+    dbLong = 4
+    dbLongBinary = 11  # (OLE Object)
+    dbMemo = 12
+    dbNumeric = 19
+    dbSingle = 6
+    dbText = 10
+    dbTime = 22
+    dbTimeStamp = 23
+    dbVarBinary = 17
+    dbUndefined = -1
+
+    # Attributes property
+    # -----------------------------------------------------------------
+    dbAutoIncrField = 16
+    dbDescending = 1
+    dbFixedField = 1
+    dbHyperlinkField = 32768
+    dbSystemField = 8192
+    dbUpdatableField = 32
+    dbVariableField = 2
+
+    # OpenRecordset
+    # -----------------------------------------------------------------
+    dbOpenForwardOnly = 8
+    dbSQLPassThrough = 64
+    dbReadOnly = 4
+
+    # Query types
+    # -----------------------------------------------------------------
+    dbQAction = 240
+    dbQAppend = 64
+    dbQDDL = 4  # 96
+    dbQDelete = 32
+    dbQMakeTable = 128  # 80
+    dbQSelect = 0
+    dbQSetOperation = 8  # 128
+    dbQSQLPassThrough = 1  # 112
+    dbQUpdate = 16  # 48
+
+    # Edit mode
+    # -----------------------------------------------------------------
+    dbEditNone = 0
+    dbEditInProgress = 1
+    dbEditAdd = 2
+
+    # Toolbars
+    # -----------------------------------------------------------------
+    msoBarTypeNormal = 0  # Usual toolbar
+    msoBarTypeMenuBar = 1  # Menu bar
+    msoBarTypePopup = 2  # Shortcut menu
+    msoBarTypeStatusBar = 11  # Status bar
+    msoBarTypeFloater = 12  # Floating window
+
+    msoControlButton = 1  # Command button
+    msoControlPopup = 10  # Popup, submenu
+
+    # New Lines
+    # -----------------------------------------------------------------
+    vbCr = chr(13)
+    vbLf = chr(10)
+
+    def _NewLine():
+        if _opsys == 'Windows': return chr(13) + chr(10)
+        return chr(10)
+
+    vbNewLine = _NewLine()
+    vbTab = chr(9)
+
+    # Module types
+    # -----------------------------------------------------------------
+    acClassModule = 1
+    acStandardModule = 0
+
+    # (Module) procedure types
+    # -----------------------------------------------------------------
+    vbext_pk_Get = 1  # A Property Get procedure
+    vbext_pk_Let = 2  # A Property Let procedure
+    vbext_pk_Proc = 0  # A Sub or Function procedure
+    vbext_pk_Set = 3  # A Property Set procedure
+
+
+COMPONENTCONTEXT, DESKTOP, SCRIPTPROVIDER, THISDATABASEDOCUMENT = None, None, None, None
+
+def _ErrorHandler(type, value, tb):
+    '''
+    Is the function to be set as new sys.excepthook to bypass the standard error handler
+        Derived from https://stackoverflow.com/questions/31949760/how-to-limit-python-traceback-to-specific-files
+    Handler removes traces pointing to methods located in access2base.py when error is due to a user programming error
+        sys.excepthook = _ErrorHandler
+    NOT APPLIED YET
+    '''
+
+    def check_file(name):
+        return 'access2base.py' not in name
+
+    show = (fs for fs in traceback.extract_tb(tb) if check_file(fs.filename))
+    fmt = traceback.format_list(show) + traceback.format_exception_only(type, value)
+    print(''.join(fmt), end = '', file = sys.stderr)
+    # Reset to standard handler
+    sys.excepthook = sys.__excepthook__
+
+
+def A2BConnect(hostname = '', port = 0):
+    """
+    To be called explicitly by user scripts when Python process runs outside the LibreOffice process.
+        LibreOffice started as (Linux):
+            ./soffice --accept='socket,host=localhost,port=xxxx;urp;'
+    Otherwise called implicitly by the current module without arguments
+    Initializes COMPONENTCONTEXT, SCRIPTPROVIDER and DESKTOP
+    :param hostname: probably 'localhost' or ''
+    :param port: port number or 0
+    :return: None
+    """
+    global XSCRIPTCONTEXT, COMPONENTCONTEXT, DESKTOP, SCRIPTPROVIDER
+    # Determine COMPONENTCONTEXT, via socket or inside LibreOffice
+    if len(hostname) > 0 and port > 0:      # Explicit connection request via socket
+        # Code derived from Bridge.py by Alain H. Romedenne
+        local_context = XSCRIPTCONTEXT.getComponentContext()
+        resolver = local_context.ServiceManager.createInstanceWithContext(
+            'com.sun.star.bridge.UnoUrlResolver', local_context)
+        try:
+            conn = 'socket,host=%s,port=%d' % (hostname, port)
+            connection_url = 'uno:%s;urp;StarOffice.ComponentContext' % conn
+            established_context = resolver.resolve(connection_url)
+        except Exception:  # thrown when LibreOffice specified instance isn't started
+            raise ConnectionError('Connection to LibreOffice failed (host = ' + hostname + ', port = ' + str(port) + ')')
+        COMPONENTCONTEXT = established_context
+        DESKTOP = None
+    elif len(hostname) == 0 and port == 0:       # Usual interactive mode
+        COMPONENTCONTEXT = XSCRIPTCONTEXT.getComponentContext()
+        DESKTOP = COMPONENTCONTEXT.ServiceManager.createInstanceWithContext( 'com.sun.star.frame.Desktop', COMPONENTCONTEXT)
+    else:
+        raise SystemExit('The invocation of A2BConnect() has invalid arguments')
+    # Determine SCRIPTPROVIDER
+    servicemanager = COMPONENTCONTEXT.ServiceManager
+    masterscript = servicemanager.createInstanceWithContext("com.sun.star.script.provider.MasterScriptProviderFactory", COMPONENTCONTEXT)
+    SCRIPTPROVIDER = masterscript.createScriptProvider("")
+    Script = _A2B.xScript('TraceLog', 'Trace')  # Don't use invokeMethod() to force reset of error stack
+    Script.invoke(('===>', 'Python wrapper loaded V.' + _VERSION, False), (), ())
+    return None
+
+
+class _A2B(object, metaclass = _Singleton):
+    """
+    Collection of helper functions implementing the protocol between Python and Basic
+        Read comments in PythonWrapper Basic function
+    """
+
+    @classmethod
+    def BasicObject(cls, objectname):
+        objs = {'COLLECTION': _Collection
+            , 'COMMANDBAR': _CommandBar
+            , 'COMMANDBARCONTROL': _CommandBarControl
+            , 'CONTROL': _Control
+            , 'DATABASE': _Database
+            , 'DIALOG': _Dialog
+            , 'EVENT': _Event
+            , 'FIELD': _Field
+            , 'FORM': _Form
+            , 'MODULE': _Module
+            , 'OPTIONGROUP': _OptionGroup
+            , 'PROPERTY': _Property
+            , 'QUERYDEF': _QueryDef
+            , 'RECORDSET': _Recordset
+            , 'SUBFORM': _SubForm
+            , 'TABLEDEF': _TableDef
+            , 'TEMPVAR': _TempVar
+                }
+        return objs[objectname]
+
+    @classmethod
+    def xScript(cls, script, module):
+        """
+        At first call checks the existence of the Access2Base library
+        Initializes _LIBRARY with the found library name
+        First and next calls execute the given script in the given module of the _LIBRARY library
+        The script and module are presumed to exist
+        :param script: name of script
+        :param module: name of module
+        :return: the script object. NB: the execution is done with the invoke() method applied on the returned object
+        """
+        global _LIBRARY
+        Script = None
+        def sScript(lib):
+            return 'vnd.sun.star.script:' + lib + '.' + module + '.' + script + '?language=Basic&location=application'
+        if _LIBRARY == '':
+            # Check the availability of the Access2Base library
+            for lib in ('Access2BaseDev', 'Access2Base'):
+                try:
+                    if Script == None:
+                        Script = SCRIPTPROVIDER.getScript(sScript(lib))
+                        _LIBRARY = lib
+                except Exception:
+                    pass
+            if Script == None:
+                raise SystemExit('Access2Base basic library not found')
+        else:
+            Script = SCRIPTPROVIDER.getScript(sScript(_LIBRARY))
+        return Script
+
+    @classmethod
+    def A2BErrorCode(cls):
+        """
+        Return the Access2Base error stack as a tuple
+            0 => error code
+            1 => severity level
+            2 => short error message
+            3 => long error message
+        """
+        Script = cls.xScript('TraceErrorCode', 'Trace')
+        return Script.invoke((), (), ())[0]
+
+    @classmethod
+    def invokeMethod(cls, script, module, *args):
+        """
+        Direct call to a named script/module pair with their arguments
+        If the arguments do not match their definition at the Basic side, a TypeError is raised
+        :param script: name of script
+        :param module: name of module
+        :param args: list of arguments to be passed to the script
+        :return: the value returned by the script execution
+        """
+        if COMPONENTCONTEXT == None: A2BConnect()     #   Connection from inside LibreOffice is done at first API invocation
+        Script = cls.xScript(script, module)
+        try:
+            Returned = Script.invoke((args), (), ())[0]
+        except:
+            raise TypeError("Access2Base error: method '" + script + "' in Basic module '" + module + "' call error. Check its arguments.")
+        else:
+            if Returned == None:
+                if cls.VerifyNoError(): return None
+            return Returned
+
+    @classmethod
+    def invokeWrapper(cls, action, basic, script, *args):
+        """
+        Call the Basic wrapper to invite it to execute the proposed action on a Basic object
+        If the arguments do not match their definition at the Basic side, a TypeError is raised
+        After execution, a check is done if the execution has raised an error within Basic
+            If yes, a TypeError is raised
+        :param action: Property Get, Property Let, Property Set, invoke Method or return UNO object
+        :param basic: the reference of the Basic object, i.e. the index in the array caching the addresses of the objects
+                        conventionally Application = -1 and DoCmd = -2
+        :param script: the property or method name
+        :param args: the arguments of the method, if any
+        :return: the value returned by the execution of the Basic routine
+        """
+        if COMPONENTCONTEXT == None: A2BConnect()     #   Connection from inside LibreOffice is done at first API invocation
+        # Intercept special call to Application.Events()
+        if basic == Application.basicmodule and script == 'Events':
+            Script = cls.xScript('PythonEventsWrapper', _WRAPPERMODULE)
+            Returned = Script.invoke((args[0],), (), ())
+        else:
+            Script = cls.xScript('PythonWrapper', _WRAPPERMODULE)
+            NoArgs = '+++NOARGS+++'     # Conventional notation for properties/methods without arguments
+            if len(args) == 0:
+                args = (action,) + (basic,) + (script,) + (NoArgs,)
+            else:
+                args = (action,) + (basic,) + (script,) + args
+            try:
+                Returned = Script.invoke((args), (), ())
+            except:
+                raise TypeError("Access2Base error: method '" + script + "' call error. Check its arguments.")
+
+        if isinstance(Returned[0], tuple):
+            # Is returned value a reference to a basic object, a scalar or a UNO object ?
+            if len(Returned[0]) in (3, 4):
+                if Returned[0][0] == 0:         # scalar
+                    return Returned[0][1]
+                elif Returned[0][0] == 1:       # reference to objects cache
+                    basicobject = cls.BasicObject(Returned[0][2])
+                    if len(Returned[0]) == 3:
+                        return basicobject(Returned[0][1], Returned[0][2])
+                    else:
+                        return basicobject(Returned[0][1], Returned[0][2], Returned[0][3])
+                elif Returned[0][0] == 2:       # Null value
+                    return None
+                else:       # Should not happen
+                    return None
+            else:                               # UNO object
+                return Returned[0]
+        elif Returned[0] == None:
+            if cls.VerifyNoError(): return None
+        else: # Should not happen
+            return Returned[0]
+
+    @classmethod
+    def VerifyNoError(cls):
+        # has Access2Base generated an error ?
+        errorstack = cls.A2BErrorCode()  # 0 = code, 1 = severity, 2 = short text, 3 = long text
+        if errorstack[1] in ('ERROR', 'FATAL', 'ABORT'):
+            raise TypeError('Access2Base error: ' + errorstack[3])
+        return True
+
+
+class Application(object, metaclass = _Singleton):
+    """ Collection of methods located in the Application (Basic) module """
+    W = _A2B.invokeWrapper
+    basicmodule = -1
+
+    @classmethod
+    def AllDialogs(cls, dialog = acConstants.Missing):
+        return cls.W(_vbMethod, cls.basicmodule, 'AllDialogs', dialog)
+    @classmethod
+    def AllForms(cls, form = acConstants.Missing):
+        return cls.W(_vbMethod, cls.basicmodule, 'AllForms', form)
+    @classmethod
+    def AllModules(cls, module = acConstants.Missing):
+        return cls.W(_vbMethod, cls.basicmodule, 'AllModules', module)
+    @classmethod
+    def CloseConnection(cls):
+        return cls.W(_vbMethod, cls.basicmodule, 'CloseConnection')
+    @classmethod
+    def CommandBars(cls, bar = acConstants.Missing):
+        return cls.W(_vbMethod, cls.basicmodule, 'CommandBars', bar)
+    @classmethod
+    def CurrentDb(cls):
+        return cls.W(_vbMethod, cls.basicmodule, 'CurrentDb')
+    @classmethod
+    def CurrentUser(cls):
+        return cls.W(_vbMethod, cls.basicmodule, 'CurrentUser')
+    @classmethod
+    def DAvg(cls, expression, domain, criteria = ''):
+        return cls.W(_vbMethod, cls.basicmodule, 'DAvg', expression, domain, criteria)
+    @classmethod
+    def DCount(cls, expression, domain, criteria = ''):
+        return cls.W(_vbMethod, cls.basicmodule, 'DCount', expression, domain, criteria)
+    @classmethod
+    def DLookup(cls, expression, domain, criteria = '', orderclause = ''):
+        return cls.W(_vbMethod, cls.basicmodule, 'DLookup', expression, domain, criteria, orderclause)
+    @classmethod
+    def DMax(cls, expression, domain, criteria = ''):
+        return cls.W(_vbMethod, cls.basicmodule, 'DMax', expression, domain, criteria)
+    @classmethod
+    def DMin(cls, expression, domain, criteria = ''):
+        return cls.W(_vbMethod, cls.basicmodule, 'DMin', expression, domain, criteria)
+    @classmethod
+    def DStDev(cls, expression, domain, criteria = ''):
+        return cls.W(_vbMethod, cls.basicmodule, 'DStDev', expression, domain, criteria)
+    @classmethod
+    def DStDevP(cls, expression, domain, criteria = ''):
+        return cls.W(_vbMethod, cls.basicmodule, 'DStDevP', expression, domain, criteria)
+    @classmethod
+    def DSum(cls, expression, domain, criteria = ''):
+        return cls.W(_vbMethod, cls.basicmodule, 'DSum', expression, domain, criteria)
+    @classmethod
+    def DVar(cls, expression, domain, criteria = ''):
+        return cls.W(_vbMethod, cls.basicmodule, 'DVar', expression, domain, criteria)
+    @classmethod
+    def DVarP(cls, expression, domain, criteria = ''):
+        return cls.W(_vbMethod, cls.basicmodule, 'DVarP', expression, domain, criteria)
+    @classmethod
+    def Events(cls, event):
+        return cls.W(_vbMethod, cls.basicmodule, 'Events', event)
+    @classmethod
+    def Forms(cls, form = acConstants.Missing):
+        return cls.W(_vbMethod, cls.basicmodule, 'Forms', form)
+    @classmethod
+    def getObject(cls, shortcut):
+        return cls.W(_vbMethod, cls.basicmodule, 'getObject', shortcut)
+    GetObject = getObject
+    @classmethod
+    def getValue(cls, shortcut):
+        return cls.W(_vbMethod, cls.basicmodule, 'getValue', shortcut)
+    GetValue = getValue
+    @classmethod
+    def HtmlEncode(cls, string, length = 0):
+        return cls.W(_vbMethod, cls.basicmodule, 'HtmlEncode', string, length)
+    @classmethod
+    def OpenConnection(cls, thisdatabasedocument = acConstants.Missing):
+        global THISDATABASEDOCUMENT
+        if COMPONENTCONTEXT == None: A2BConnect()     #   Connection from inside LibreOffice is done at first API invocation
+        if DESKTOP != None:
+            THISDATABASEDOCUMENT = DESKTOP.getCurrentComponent()
+            return _A2B.invokeMethod('OpenConnection', 'Application', THISDATABASEDOCUMENT)
+    @classmethod
+    def OpenDatabase(cls, connectionstring, username = '', password = '', readonly = False):
+        return cls.W(_vbMethod, cls.basicmodule, 'OpenDatabase', connectionstring, username
+                           , password, readonly)
+    @classmethod
+    def ProductCode(cls):
+        return cls.W(_vbMethod, cls.basicmodule, 'ProductCode')
+    @classmethod
+    def setValue(cls, shortcut, value):
+        return cls.W(_vbMethod, cls.basicmodule, 'setValue', shortcut, value)
+    SetValue = setValue
+    @classmethod
+    def SysCmd(cls, action, text = '', value = -1):
+        return cls.W(_vbMethod, cls.basicmodule, 'SysCmd', action, text, value)
+    @classmethod
+    def TempVars(cls, var = acConstants.Missing):
+        return cls.W(_vbMethod, cls.basicmodule, 'TempVars', var)
+    @classmethod
+    def Version(cls):
+        return cls.W(_vbMethod, cls.basicmodule, 'Version')
+
+
+class DoCmd(object, metaclass = _Singleton):
+    """ Collection of methods located in the DoCmd (Basic) module """
+    W = _A2B.invokeWrapper
+    basicmodule = -2
+
+    @classmethod
+    def ApplyFilter(cls, filter = '', sqlwhere = '', controlname = ''):
+        return cls.W(_vbMethod, cls.basicmodule, 'ApplyFilter', filter, sqlwhere, controlname)
+    @classmethod
+    def Close(cls, objecttype, objectname, save = acConstants.acSavePrompt):
+        return cls.W(_vbMethod, cls.basicmodule, 'Close', objecttype, objectname, save)
+    @classmethod
+    def CopyObject(cls, sourcedatabase, newname, sourceobjecttype, sourceobjectname):    # 1st argument must be set
+        return cls.W(_vbMethod, cls.basicmodule, 'CopyObject', sourcedatabase, newname, sourceobjecttype
+                           , sourceobjectname)
+    @classmethod
+    def FindNext(cls):
+        return cls.W(_vbMethod, cls.basicmodule, 'FindNext')
+    @classmethod
+    def FindRecord(cls, findwhat, match = acConstants.acEntire, matchcase = False, search = acConstants.acSearchAll
+        , searchasformatted = False, onlycurrentfield = acConstants.acCurrent, findfirst = True):
+        return cls.W(_vbMethod, cls.basicmodule, 'FindRecord', findwhat, match, matchcase, search
+        , searchasformatted, onlycurrentfield, findfirst)
+    @classmethod
+    def GetHiddenAttribute(cls, objecttype, objectname = ''):
+        return cls.W(_vbMethod, cls.basicmodule, 'GetHiddenAttribute', objecttype, objectname)
+    @classmethod
+    def GoToControl(cls, controlname):
+        return cls.W(_vbMethod, cls.basicmodule, 'GoToControl', controlname)
+    @classmethod
+    def GoToRecord(cls, objecttype = acConstants.acActiveDataObject, objectname = '', record = acConstants.acNext
+                   , offset = 1):
+        return cls.W(_vbMethod, cls.basicmodule, 'GoToRecord', objecttype, objectname, record, offset)
+    @classmethod
+    def Maximize(cls):
+        return cls.W(_vbMethod, cls.basicmodule, 'Maximize')
+    @classmethod
+    def Minimize(cls):
+        return cls.W(_vbMethod, cls.basicmodule, 'Minimize')
+    @classmethod
+    def MoveSize(cls, left = -1, top = -1, width = -1, height = -1):
+        return cls.W(_vbMethod, cls.basicmodule, 'MoveSize', left, top, width, height)
+    @classmethod
+    def OpenForm(cls, formname, view = acConstants.acNormal, filter = '', wherecondition = ''
+        , datamode = acConstants.acFormEdit, windowmode = acConstants.acWindowNormal, openargs = ''):
+        return cls.W(_vbMethod, cls.basicmodule, 'OpenForm', formname, view, filter, wherecondition
+        , datamode, windowmode, openargs)
+    @classmethod
+    def OpenQuery(cls, queryname, view = acConstants.acNormal, datamode = acConstants.acEdit):
+        return cls.W(_vbMethod, cls.basicmodule, 'OpenQuery', queryname, view, datamode)
+    @classmethod
+    def OpenReport(cls, queryname, view = acConstants.acNormal):
+        return cls.W(_vbMethod, cls.basicmodule, 'OpenReport', queryname, view)
+    @classmethod
+    def OpenSQL(cls, sql, option = -1):
+        return cls.W(_vbMethod, cls.basicmodule, 'OpenSQL', sql, option)
+    @classmethod
+    def OpenTable(cls, tablename, view = acConstants.acNormal, datamode = acConstants.acEdit):
+        return cls.W(_vbMethod, cls.basicmodule, 'OpenTable', tablename, view, datamode)
+    @classmethod
+    def OutputTo(cls, objecttype, objectname = '', outputformat = '', outputfile = '', autostart = False, templatefile = ''
+        , encoding = acConstants.acUTF8Encoding, quality = acConstants.acExportQualityPrint):
+        if objecttype == acConstants.acOutputForm: encoding = 0
+        return cls.W(_vbMethod, cls.basicmodule, 'OutputTo', objecttype, objectname, outputformat
+                           , outputfile, autostart, templatefile, encoding, quality)
+    @classmethod
+    def Quit(cls):
+        return cls.W(_vbMethod, cls.basicmodule, 'Quit')
+    @classmethod
+    def RunApp(cls, commandline):
+        return cls.W(_vbMethod, cls.basicmodule, 'RunApp', commandline)
+    @classmethod
+    def RunCommand(cls, command):
+        return cls.W(_vbMethod, cls.basicmodule, 'RunCommand', command)
+    @classmethod
+    def RunSQL(cls, SQL, option = -1):
+        return cls.W(_vbMethod, cls.basicmodule, 'RunSQL', SQL, option)
+    @classmethod
+    def SelectObject(cls, objecttype, objectname = '', indatabasewindow = False):
+        return cls.W(_vbMethod, cls.basicmodule, 'SelectObject', objecttype, objectname, indatabasewindow)
+    @classmethod
+    def SendObject(cls, objecttype = acConstants.acSendNoObject, objectname = '', outputformat = '', to = '', cc = ''
+        , bcc = '', subject = '', messagetext = '', editmessage = True, templatefile = ''):
+        return cls.W(_vbMethod, cls.basicmodule, 'SendObject', objecttype, objectname, outputformat, to, cc
+        , bcc, subject, messagetext, editmessage, templatefile)
+    @classmethod
+    def SetHiddenAttribute(cls, objecttype, objectname = '', hidden = True):
+        return cls.W(_vbMethod, cls.basicmodule, 'SetHiddenAttribute', objecttype, objectname, hidden)
+    @classmethod
+    def SetOrderBy(cls, orderby = '', controlname = ''):
+        return cls.W(_vbMethod, cls.basicmodule, 'SetOrderBy', orderby, controlname)
+    @classmethod
+    def ShowAllRecords(cls):
+        return cls.W(_vbMethod, cls.basicmodule, 'ShowAllRecords')
+
+
+class Basic(object, metaclass = _Singleton):
+    """ Collection of helper functions having the same behaviour as their Basic counterparts """
+    M = _A2B.invokeMethod
+
+    @classmethod
+    def ConvertFromUrl(cls, url):
+        return cls.M('PyConvertFromUrl', _WRAPPERMODULE, url)
+
+    @classmethod
+    def ConvertToUrl(cls, file):
+        return cls.M('PyConvertToUrl', _WRAPPERMODULE, file)
+
+    @classmethod
+    def CreateUnoService(cls, servicename):
+        return cls.M('PyCreateUnoService', _WRAPPERMODULE, servicename)
+
+    @classmethod
+    def DateAdd(cls, add, count, datearg):
+        if isinstance(datearg, datetime.datetime): datearg = datearg.isoformat()
+        dateadd = cls.M('PyDateAdd', _WRAPPERMODULE, add, count, datearg)
+        return datetime.datetime.strptime(dateadd, acConstants.FromIsoFormat)
+
+    @classmethod
+    def DateDiff(cls, add, date1, date2, weekstart = 1, yearstart = 1):
+        if isinstance(date1, datetime.datetime): date1 = date1.isoformat()
+        if isinstance(date2, datetime.datetime): date2 = date2.isoformat()
+        return cls.M('PyDateDiff', _WRAPPERMODULE, add, date1, date2, weekstart, yearstart)
+
+    @classmethod
+    def DatePart(cls, add, datearg, weekstart = 1, yearstart = 1):
+        if isinstance(datearg, datetime.datetime): datearg = datearg.isoformat()
+        return cls.M('PyDatePart', _WRAPPERMODULE, add, datearg, weekstart, yearstart)
+
+    @classmethod
+    def DateValue(cls, datestring):
+        datevalue = cls.M('PyDateValue', _WRAPPERMODULE, datestring)
+        return datetime.datetime.strptime(datevalue, acConstants.FromIsoFormat)
+
+    @classmethod
+    def Format(cls, value, format = None):
+        if isinstance(value, (datetime.datetime, datetime.date, datetime.time, )):
+            value = value.isoformat()
+        return cls.M('PyFormat', _WRAPPERMODULE, value, format)
+
+    @classmethod
+    def GetGUIType(cls):
+        return cls.M('PyGetGUIType', _WRAPPERMODULE)
+
+    @staticmethod
+    def GetPathSeparator():
+        return os.sep
+
+    @classmethod
+    def GetSystemTicks(cls):
+        return cls.M('PyGetSystemTicks', _WRAPPERMODULE)
+
+    @classmethod
+    def MsgBox(cls, text, type = None, dialogtitle = None):
+        return cls.M('PyMsgBox', _WRAPPERMODULE, text, type, dialogtitle)
+
+    class GlobalScope(object, metaclass = _Singleton):
+        @classmethod
+        def BasicLibraries(cls):
+            return Basic.M('PyGlobalScope', _WRAPPERMODULE, 'Basic')
+        @classmethod
+        def DialogLibraries(self):
+            return Basic.M('PyGlobalScope', _WRAPPERMODULE, 'Dialog')
+
+    @classmethod
+    def InputBox(cls, text, title = None, default = None, xpos = None, ypos = None):
+        return cls.M('PyInputBox', _WRAPPERMODULE, text, title, default, xpos, ypos)
+
+    @staticmethod
+    def Now():
+        return datetime.datetime.now()
+
+    @staticmethod
+    def RGB(red, green, blue):
+        return int('%02x%02x%02x' % (red, green, blue), 16)
+
+    @classmethod
+    def Timer(cls):
+        return cls.M('PyTimer', _WRAPPERMODULE)
+
+    @staticmethod
+    def Xray(myObject):
+        xrayscript = 'vnd.sun.star.script:XrayTool._Main.Xray?language=Basic&location=application'
+        xScript = SCRIPTPROVIDER.getScript(xrayscript)
+        xScript.invoke((myObject,), (), ())
+        return
+
+
+class _BasicObject(object):
+    """
+    Parent class of Basic objects
+    Each subclass is identified by its classProperties:
+         dictionary with keys = allowed properties, value = True if editable or False
+    Each instance is identified by its
+        - reference in the cache managed by Basic
+        - type ('DATABASE', 'COLLECTION', ...)
+        - name (form, control, ... name) - may be blank
+    Properties are got and set following next strategy:
+        1. Property names are controlled strictly ('Value' and not 'value')
+        2. Getting a property value for the first time is always done via a Basic call
+        3. Next occurrences are fetched from the Python dictionary of the instance if the property is read-only, otherwise via a Basic call
+        4. Methods output might force the deletion of a property from the dictionary ('MoveNext' changes 'BOF' and 'EOF' properties)
+        5. Setting a property value is done via a Basic call, except if self.internal == True
+    """
+    W = _A2B.invokeWrapper
+    internal_attributes = ('objectreference', 'objecttype', 'name', 'internal')
+
+    def __init__(self, reference = -1, objtype = None, name = ''):
+        self.objectreference = reference    # reference in the cache managed by Basic
+        self.objecttype = objtype           # ('DATABASE', 'COLLECTION', ...)
+        self.name = name                    # '' when no name
+        self.internal = False               # True to exceptionally allow assigning a new value to a read-only property
+        self.localProperties = ()
+
+    def __getattr__(self, name):
+        if name in ('classProperties', 'localProperties'):
+            pass
+        elif name in self.classProperties:
+            # Get Property from Basic
+            return self.W(_vbGet, self.objectreference, name)
+        # Usual attributes getter
+        return super(_BasicObject, self).__getattribute__(name)
+
+    def __setattr__(self, name, value):
+        if name in ('classProperties', 'localProperties'):
+            pass
+        elif name in self.classProperties:
+            if self.internal:       # internal = True forces property setting even if property is read-only
+                pass
+            elif self.classProperties[name] == True: # True == Editable
+                self.W(_vbLet, self.objectreference, name, value)
+            else:
+                raise AttributeError("type object '" + self.objecttype + "' has no editable attribute '" + name + "'")
+        elif name[0:2] == '__' or name in self.internal_attributes or name in self.localProperties:
+            pass
+        else:
+            raise AttributeError("type object '" + self.objecttype + "' has no attribute '" + name + "'")
+        object.__setattr__(self, name, value)
+        return
+
+    def __repr__(self):
+        repr = "Basic object (type='" + self.objecttype + "', index=" + str(self.objectreference)
+        if len(self.name) > 0: repr += ", name='" + self.name + "'"
+        return repr + ")"
+
+    def _Reset(self, propertyname, basicreturn = None):
+        """ force new value or erase properties from dictionary (done to optimize calls to Basic scripts) """
+        if propertyname in ('BOF', 'EOF'):
+            # After a Move method invocation on a Recordset object, BOF or EOF likely to be got soon
+            if isinstance(basicreturn, int):
+                self.internal = True
+                # f.i. basicreturn = 0b10 means: BOF = True, EOF = False
+                self.BOF = basicreturn in (2, 3, -2, -3)
+                self.EOF = basicreturn in (1, 3, -1, -3)
+                self.internal = False
+                return ( basicreturn >= 0 )
+        else:
+            # Suppress possibly invalid property values: e.g. RecordCount after Delete applied on Recordset object
+            if property in self.__dict__:
+                del(self.propertyname)
+        return basicreturn
+
+    @property
+    def Name(self): return self.name
+    @property
+    def ObjectType(self): return self.objecttype
+
+    def Dispose(self):
+        return self.W(_vbMethod, self.objectreference, 'Dispose')
+    def getProperty(self, propertyname, index = acConstants.Missing):
+        return self.W(_vbMethod, self.objectreference, 'getProperty', propertyname, index)
+    GetProperty = getProperty
+    def hasProperty(self, propertyname):
+        return propertyname in tuple(self.classProperties.keys())
+    HasProperty = hasProperty
+    def Properties(self, index = acConstants.Missing):
+        return self.W(_vbMethod, self.objectreference, 'Properties', index)
+    def setProperty(self, propertyname, value, index = acConstants.Missing):
+        if self.hasProperty(propertyname):
+            if self.W(_vbMethod, self.objectreference, 'setProperty', propertyname, value, index):
+                return self.__setattr__(propertyname, value)
+        raise AttributeError("type object '" + self.objecttype + "' has no editable attribute '" + propertyname + "'")
+    SetProperty = setProperty
+
+
+class _Collection(_BasicObject):
+    """ Collection object built as a Python iterator """
+    classProperties = dict(Count = False)
+    def __init__(self, reference = -1, objtype = None):
+        super().__init__(reference, objtype)
+        self.localProperties = ('count', 'index')
+        self.count = self.Count
+        self.index = 0
+    def __iter__(self):
+        self.index = 0
+        return self
+    def __next__(self):
+        if self.index >= self.count:
+            raise StopIteration
+        next = self.Item(self.index)
+        self.index = self.index + 1
+        return next
+    def __len__(self):
+        return self.count
+
+    def Add(self, table, value = acConstants.Missing):
+        if isinstance(table, _BasicObject):     # Add method applied to a TABLEDEFS collection
+            return self.W(_vbMethod, self.objectreference, 'Add', table.objectreference)
+        else:                                   # Add method applied to a TEMPVARS collection
+            add = self.W(_vbMethod, self.objectreference, 'Add', table, value)
+            self.count = self.Count
+            return add
+    def Delete(self, name):
+        return self.W(_vbMethod, self.objectreference, 'Delete', name)
+    def Item(self, index):
+        return self.W(_vbMethod, self.objectreference, 'Item', index)
+    def Remove(self, tempvarname):
+        remove = self.W(_vbMethod, self.objectreference, 'Remove', tempvarname)
+        self.count = self.Count
+        return remove
+    def RemoveAll(self):
+        remove = self.W(_vbMethod, self.objectreference, 'RemoveAll')
+        self.count = self.Count
+        return remove
+
+
+class _CommandBar(_BasicObject):
+    classProperties = dict(BuiltIn = False, Parent = False, Visible = True)
+
+    def CommandBarControls(self, index = acConstants.Missing):
+        return self.W(_vbMethod, self.objectreference, 'CommandBarControls', index)
+    def Reset(self):
+        return self.W(_vbMethod, self.objectreference, 'Reset')
+
+
+class _CommandBarControl(_BasicObject):
+    classProperties = dict(BeginGroup = False, BuiltIn = False, Caption = True, Index = False, OnAction = True
+                        , Parent = False, TooltipText = True, Type = False, Visible = True)
+
+    def Execute(self):
+        return self.W(_vbMethod, self.objectreference, 'Execute')
+
+
+class _Control(_BasicObject):
+    classProperties = dict(BackColor = True, BorderColor = True, BorderStyle = True, Cancel = True, Caption = True
+                        , ControlSource = False, ControlTipText = True, ControlType = False, Default = True
+                        , DefaultValue = True, Enabled = True, FontBold = True, FontItalic = True, FontName = True
+                        , FontSize = True, FontUnderline = True, FontWeight = True, ForeColor = True, Form = False
+                        , Format = True, ItemData = False, ListCount = False, ListIndex = True, Locked = True, MultiSelect = True
+                        , OnActionPerformed = True, OnAdjustmentValueChanged = True, OnApproveAction = True
+                        , OnApproveReset = True, OnApproveUpdate = True, OnChanged = True, OnErrorOccurred = True
+                        , OnFocusGained = True, OnFocusLost = True, OnItemStateChanged = True, OnKeyPressed = True
+                        , OnKeyReleased = True, OnMouseDragged = True, OnMouseEntered = True, OnMouseExited = True
+                        , OnMouseMoved = True, OnMousePressed = True, OnMouseReleased = True, OnResetted = True, OnTextChanged = True
+                        , OnUpdated = True, OptionValue = False, Page = False, Parent = False, Picture = True, Required = True
+                        , RowSource = True, RowSourceType = True, Selected = True, SelLength = True, SelStart = True, SelText = True
+                        , SubType = False, TabIndex = True, TabStop = True, Tag = True, Text = False, TextAlign = True
+                        , TripleState = True, Value = True, Visible = True
+                        )
+
+    @property
+    def BoundField(self): return self.W(_vbUNO, self.objectreference, 'BoundField')
+    @property
+    def ControlModel(self): return self.W(_vbUNO, self.objectreference, 'ControlModel')
+    @property
+    def ControlView(self): return self.W(_vbUNO, self.objectreference, 'ControlView')
+    @property
+    def LabelControl(self): return self.W(_vbUNO, self.objectreference, 'LabelControl')
+
+    def AddItem(self, value, index = -1):
+        basicreturn = self.W(_vbMethod, self.objectreference, 'AddItem', value, index)
+        self._Reset('ItemData')
+        self._Reset('ListCount')
+        return basicreturn
+    def Controls(self, index = acConstants.Missing):
+        return self.W(_vbMethod, self.objectreference, 'Controls', index)
+    # Overrides method in parent class: list of properties is strongly control type dependent
+    def hasProperty(self, propertyname):
+        return self.W(_vbMethod, self.objectreference, 'hasProperty', propertyname)
+    HasProperty = hasProperty
+    def RemoveItem(self, index):
+        basicreturn = self.W(_vbMethod, self.objectreference, 'RemoveItem', index)
+        self._Reset('ItemData')
+        self._Reset('ListCount')
+        return basicreturn
+    def Requery(self):
+        return self.W(_vbMethod, self.objectreference, 'Requery')
+    def SetSelected(self, value, index):
+        return self.W(_vbMethod, self.objectreference, 'SetSelected', value, index)
+    def SetFocus(self):
+        return self.W(_vbMethod, self.objectreference, 'SetFocus')
+
+
+class _Database(_BasicObject):
+    classProperties = dict(Connect = False, OnCreate = True
+                        , OnFocus = True, OnLoad = True, OnLoadFinished = True, OnModifyChanged = True, OnNew = True
+                        , OnPrepareUnload = True, OnPrepareViewClosing = True, OnSave = True, OnSaveAs = True
+                        , OnSaveAsDone = True, OnSaveAsFailed = True, OnSaveDone = True, OnSaveFailed = True
+                        , OnSubComponentClosed = True, OnSubComponentOpened = True, OnTitleChanged = True, OnUnfocus = True
+                        , OnUnload = True, OnViewClosed = True, OnViewCreated = True, Version = False
+                        )
+
+    @property
+    def Connection(self): return self.W(_vbUNO, self.objectreference, 'Connection')
+    @property
+    def Document(self): return self.W(_vbUNO, self.objectreference, 'Document')
+    @property
+    def MetaData(self): return self.W(_vbUNO, self.objectreference, 'MetaData')
+
+    def Close(self):
+        return self.W(_vbMethod, self.objectreference, 'Close')
+    def CloseAllRecordsets(self):
+        return self.W(_vbMethod, self.objectreference, 'CloseAllRecordsets')
+    def CreateQueryDef(self, name, sqltext, option = -1):
+        return self.W(_vbMethod, self.objectreference, 'CreateQueryDef', name, sqltext, option)
+    def CreateTableDef(self, name):
+        return self.W(_vbMethod, self.objectreference, 'CreateTableDef', name)
+    def DAvg(self, expression, domain, criteria = ''):
+        return self.W(_vbMethod, self.objectreference, 'DAvg', expression, domain, criteria)
+    def DCount(self, expression, domain, criteria = ''):
+        return self.W(_vbMethod, self.objectreference, 'DCount', expression, domain, criteria)
+    def DLookup(self, expression, domain, criteria = '', orderclause = ''):
+        return self.W(_vbMethod, self.objectreference, 'DLookup', expression, domain, criteria, orderclause)
+    def DMax(self, expression, domain, criteria = ''):
+        return self.W(_vbMethod, self.objectreference, 'DMax', expression, domain, criteria)
+    def DMin(self, expression, domain, criteria = ''):
+        return self.W(_vbMethod, self.objectreference, 'DMin', expression, domain, criteria)
+    def DStDev(self, expression, domain, criteria = ''):
+        return self.W(_vbMethod, self.objectreference, 'DStDev', expression, domain, criteria)
+    def DStDevP(self, expression, domain, criteria = ''):
+        return self.W(_vbMethod, self.objectreference, 'DStDevP', expression, domain, criteria)
+    def DVar(self, expression, domain, criteria = ''):
+        return self.W(_vbMethod, self.objectreference, 'DVar', expression, domain, criteria)
+    def DVarP(self, expression, domain, criteria = ''):
+        return self.W(_vbMethod, self.objectreference, 'DVarP', expression, domain, criteria)
+    def OpenRecordset(self, source, type = -1, option = -1, lockedit = -1):
+        return self.W(_vbMethod, self.objectreference, 'OpenRecordset', source, type, option, lockedit)
+    def OpenSQL(self, SQL, option = -1):
+        return self.W(_vbMethod, self.objectreference, 'OpenSQL', SQL, option)
+    def OutputTo(self, objecttype, objectname = '', outputformat = '', outputfile = '', autostart = False, templatefile = ''
+        , encoding = acConstants.acUTF8Encoding, quality = acConstants.acExportQualityPrint):
+        if objecttype == acConstants.acOutputForm: encoding = 0
+        return self.W(_vbMethod, self.objectreference, 'OutputTo', objecttype, objectname, outputformat, outputfile
+                      , autostart, templatefile, encoding, quality)
+    def QueryDefs(self, index = acConstants.Missing):
+        return self.W(_vbMethod, self.objectreference, 'QueryDefs', index)
+    def Recordsets(self, index = acConstants.Missing):
+        return self.W(_vbMethod, self.objectreference, 'Recordsets', index)
+    def RunSQL(self, SQL, option = -1):
+        return self.W(_vbMethod, self.objectreference, 'RunSQL', SQL, option)
+    def TableDefs(self, index = acConstants.Missing):
+        return self.W(_vbMethod, self.objectreference, 'TableDefs', index)
+
+
+class _Dialog(_BasicObject):
+    classProperties = dict(Caption = True, Height = True, IsLoaded = False, OnFocusGained = True
+                        , OnFocusLost = True, OnKeyPressed = True, OnKeyReleased = True, OnMouseDragged = True
+                        , OnMouseEntered = True, OnMouseExited = True, OnMouseMoved = True, OnMousePressed = True
+                        , OnMouseReleased = True, Page = True, Parent = False, Visible = True, Width = True
+                        )
+
+    @property
+    def UnoDialog(self): return self.W(_vbUNO, self.objectreference, 'UnoDialog')
+
+    def EndExecute(self, returnvalue):
+        return self.W(_vbMethod, self.objectreference, 'EndExecute', returnvalue)
+    def Execute(self):
+        return self.W(_vbMethod, self.objectreference, 'Execute')
+    def Move(self, left = -1, top = -1, width = -1, height = -1):
+        return self.W(_vbMethod, self.objectreference, 'Move', left, top, width, height)
+    def OptionGroup(self, groupname):
+        return self.W(_vbMethod, self.objectreference, 'OptionGroup', groupname)
+    def Start(self):
+        return self.W(_vbMethod, self.objectreference, 'Start')
+    def Terminate(self):
+        return self.W(_vbMethod, self.objectreference, 'Terminate')
+
+class _Event(_BasicObject):
+    classProperties = dict(ButtonLeft = False, ButtonMiddle = False, ButtonRight = False, ClickCount = False
+                    , ContextShortcut = False, EventName = False, EventType = False, FocusChangeTemporary = False
+                    , KeyAlt = False, KeyChar = False, KeyCode = False, KeyCtrl = False, KeyFunction = False, KeyShift = False
+                    , Recommendation = False, RowChangeAction = False, Source = False, SubComponentName = False
+                    , SubComponentType = False, XPos = False, YPos = False
+                    )
+
+
+class _Field(_BasicObject):
+    classProperties = dict(DataType = False, DataUpdatable = False, DbType = False, DefaultValue = True
+                        , Description = True, FieldSize = False, Size = False, Source = False
+                        , SourceField = False, SourceTable = False, TypeName = False, Value = True
+                        )
+
+    @property
+    def Column(self): return self.W(_vbUNO, self.objectreference, 'Column')
+
+    def AppendChunk(self, value):
+        return self.W(_vbMethod, self.objectreference, 'AppendChunk', value)
+    def GetChunk(self, offset, numbytes):
+        return self.W(_vbMethod, self.objectreference, 'GetChunk', offset, numbytes)
+    def ReadAllBytes(self, file):
+        return self.W(_vbMethod, self.objectreference, 'ReadAllBytes', file)
+    def ReadAllText(self, file):
+        return self.W(_vbMethod, self.objectreference, 'ReadAllText', file)
+    def WriteAllBytes(self, file):
+        return self.W(_vbMethod, self.objectreference, 'WriteAllBytes', file)
+    def WriteAllText(self, file):
+        return self.W(_vbMethod, self.objectreference, 'WriteAllText', file)
+
+
+class _Form(_BasicObject):
+    classProperties = dict(AllowAdditions = True, AllowDeletions = True, AllowEdits = True, Bookmark = True
+                        , Caption = True, CurrentRecord = True, Filter = True, FilterOn = True, Height = True
+                        , IsLoaded = False, OnApproveCursorMove = True, OnApproveParameter = True, OnApproveReset = True
+                        , OnApproveRowChange = True, OnApproveSubmit = True, OnConfirmDelete = True, OnCursorMoved = True
+                        , OnErrorOccurred = True, OnLoaded = True, OnReloaded = True, OnReloading = True, OnResetted = True
+                        , OnRowChanged = True, OnUnloaded = True, OnUnloading = True, OpenArgs = False, OrderBy = True
+                        , OrderByOn = True, Parent = False, Recordset = False, RecordSource = True, Visible = True
+                        , Width = True
+                        )
+
+    @property
+    def Component(self): return self.W(_vbUNO, self.objectreference, 'Component')
+    @property
+    def ContainerWindow(self): return self.W(_vbUNO, self.objectreference, 'ContainerWindow')
+    @property
+    def DatabaseForm(self): return self.W(_vbUNO, self.objectreference, 'DatabaseForm')
+
+    def Close(self):
+        return self.W(_vbMethod, self.objectreference, 'Close')
+    def Controls(self, index = acConstants.Missing):
+        return self.W(_vbMethod, self.objectreference, 'Controls', index)
+    def Move(self, left = -1, top = -1, width = -1, height = -1):
+        return self.W(_vbMethod, self.objectreference, 'Move', left, top, width, height)
+    def OptionGroup(self, groupname):
+        return self.W(_vbMethod, self.objectreference, 'OptionGroup', groupname)
+    def Refresh(self):
+        return self.W(_vbMethod, self.objectreference, 'Refresh')
+    def Requery(self):
+        return self.W(_vbMethod, self.objectreference, 'Requery')
+    def SetFocus(self):
+        return self.W(_vbMethod, self.objectreference, 'SetFocus')
+
+
+class _Module(_BasicObject):
+    classProperties = dict(CountOfDeclarationLines = False, CountOfLines = False
+                        , ProcStartLine = False, Type = False
+                        )
+    def __init__(self, reference = -1, objtype = None, name = ''):
+        super().__init__(reference, objtype, name)
+        self.localProperties = ('startline', 'startcolumn', 'endline', 'endcolumn', 'prockind')
+
+    def Find(self, target, startline, startcolumn, endline, endcolumn, wholeword = False
+        , matchcase = False, patternsearch = False):
+        Returned = self.W(_vbMethod, self.objectreference, 'Find', target, startline, startcolumn, endline
+                      , endcolumn, wholeword, matchcase, patternsearch)
+        if isinstance(Returned, tuple):
+            if Returned[0] == True and len(Returned) == 5:
+                self.startline = Returned[1]
+                self.startcolumn = Returned[2]
+                self.endline = Returned[3]
+                self.endcolumn = Returned[4]
+            return Returned[0]
+        return Returned
+    def Lines(self, line, numlines):
+        return self.W(_vbMethod, self.objectreference, 'Lines', line, numlines)
+    def ProcBodyLine(self, procname, prockind):
+        return self.W(_vbMethod, self.objectreference, 'ProcBodyLine', procname, prockind)
+    def ProcCountLines(self, procname, prockind):
+        return self.W(_vbMethod, self.objectreference, 'ProcCountLines', procname, prockind)
+    def ProcOfLine(self, line, prockind):
+        Returned = self.W(_vbMethod, self.objectreference, 'ProcOfLine', line, prockind)
+        if isinstance(Returned, tuple):
+            if len(Returned) == 2:
+                self.prockind = Returned[1]
+                return Returned[0]
+        return Returned
+    def ProcStartLine(self, procname, prockind):
+        return self.W(_vbMethod, self.objectreference, 'ProcStartLine', procname, prockind)
+
+
+class _OptionGroup(_BasicObject):
+    classProperties = dict(Count = False, Value = True)
+
+    def Controls(self, index = acConstants.Missing):
+        return self.W(_vbMethod, self.objectreference, 'Controls', index)
+
+
+class _Property(_BasicObject):
+    classProperties = dict(Value = True)
+
+
+class _QueryDef(_BasicObject):
+    classProperties = dict(SQL = True, Type = False)
+
+    @property
+    def Query(self): return self.W(_vbUNO, self.objectreference, 'Query')
+
+    def Execute(self, options = acConstants.Missing):
+        return self.W(_vbMethod, self.objectreference, 'Execute', options)
+    def Fields(self, index = acConstants.Missing):
+        return self.W(_vbMethod, self.objectreference, 'Fields', index)
+    def OpenRecordset(self, type = -1, option = -1, lockedit = -1):
+        return self.W(_vbMethod, self.objectreference, 'OpenRecordset', type, option, lockedit)
+
+
+class _Recordset(_BasicObject):
+    classProperties = dict(AbsolutePosition = True, BOF = False, Bookmark = True, Bookmarkable = False
+                        , EditMode = False, EOF = False, Filter = True, RecordCount = False
+                        )
+
+    @property
+    def RowSet(self): return self.W(_vbUNO, self.objectreference, 'RowSet')
+
+    def AddNew(self):
+        return self.W(_vbMethod, self.objectreference, 'AddNew')
+    def CancelUpdate(self):
+        return self.W(_vbMethod, self.objectreference, 'CancelUpdate')
+    def Clone(self):
+        return self.W(_vbMethod, self.objectreference, 'Clone')
+    def Close(self):
+        return self.W(_vbMethod, self.objectreference, 'Close')
+    def Delete(self):
+        return self._Reset('RecordCount',self.W(_vbMethod, self.objectreference, 'Delete'))
+    def Edit(self):
+        return self.W(_vbMethod, self.objectreference, 'Edit')
+    def Fields(self, index = acConstants.Missing):
+        return self.W(_vbMethod, self.objectreference, 'Fields', index)
+    def GetRows(self, numrows):
+        return self.W(_vbMethod, self.objectreference, 'GetRows', numrows)
+    def Move(self, rows, startbookmark = acConstants.Missing):
+        return self._Reset('BOF', self.W(_vbMethod, self.objectreference, 'Move', rows, startbookmark))
+    def MoveFirst(self):
+        return self._Reset('BOF', self.W(_vbMethod, self.objectreference, 'MoveFirst'))
+    def MoveLast(self):
+        return self._Reset('BOF', self.W(_vbMethod, self.objectreference, 'MoveLast'))
+    def MoveNext(self):
+        return self._Reset('BOF', self.W(_vbMethod, self.objectreference, 'MoveNext'))
+    def MovePrevious(self):
+        return self._Reset('BOF', self.W(_vbMethod, self.objectreference, 'MovePrevious'))
+    def OpenRecordset(self, type = -1, option = -1, lockedit = -1):
+        return self.W(_vbMethod, self.objectreference, 'OpenRecordset', type, option, lockedit)
+    def Update(self):
+        return self._Reset('RecordCount',self.W(_vbMethod, self.objectreference, 'Update'))
+
+
+class _SubForm(_Form):
+    classProperties = dict(AllowAdditions = True, AllowDeletions = True, AllowEdits = True, CurrentRecord = True
+                        , Filter = True, FilterOn = True, LinkChildFields = False, LinkMasterFields = False
+                        , OnApproveCursorMove = True, OnApproveParameter = True, OnApproveReset = True
+                        , OnApproveRowChange = True, OnApproveSubmit = True, OnConfirmDelete = True, OnCursorMoved = True
+                        , OnErrorOccurred = True, OnLoaded = True, OnReloaded = True, OnReloading = True, OnResetted = True
+                        , OnRowChanged = True, OnUnloaded = True, OnUnloading = True, OrderBy = True
+                        , OrderByOn = True, Parent = False, Recordset = False, RecordSource = True, Visible = True
+                        )
+
+    def SetFocus(self):
+        raise AttributeError("type object 'SubForm' has no method 'SetFocus'")
+
+
+class _TableDef(_BasicObject):
+    classProperties = dict()
+
+    @property
+    def Table(self): return self.W(_vbUNO, self.objectreference, 'Table')
+
+    def CreateField(self, name, type, size = 0, attributes = 0):
+        return self.W(_vbMethod, self.objectreference, 'CreateField', name, type, size, attributes)
+    def Fields(self, index = acConstants.Missing):
+        return self.W(_vbMethod, self.objectreference, 'Fields', index)
+    def OpenRecordset(self, type = -1, option = -1, lockedit = -1):
+        return self.W(_vbMethod, self.objectreference, 'OpenRecordset', type, option, lockedit)
+
+
+class _TempVar(_BasicObject):
+    classProperties = dict(Value = True)
+
+"""
+Set of directly callable error handling methods
+"""
+def DebugPrint(*args):
+    dargs = ()
+    for arg in args:
+        if isinstance(arg, _BasicObject):
+            arg = ('[' + arg.objecttype + '] ' + arg.name).rstrip()
+        dargs = dargs + (arg,)
+    return _A2B.invokeMethod('DebugPrint', _WRAPPERMODULE, *dargs)
+def TraceConsole(): return _A2B.invokeMethod('TraceConsole', 'Trace')
+def TraceError(tracelevel, errorcode, errorprocedure, errorline):
+    return _A2B.invokeMethod('TraceError', 'Trace', tracelevel, errorcode, errorprocedure, errorline)
+def TraceLevel(newtracelevel = 'ERROR'): return _A2B.invokeMethod('TraceLevel', 'Trace', newtracelevel)
+def TraceLog(tracelevel, text, messagebox = True):
+    return _A2B.invokeMethod('TraceLog', 'Trace', tracelevel, text, messagebox)
+