The FileSystem service provides simple
methods to manage compressed zip archives.
As an example, .odf and .oxt files being
formatted as such archives, massive or
punctual changes of file contents
with smart scripts can be facilitated.
New methods:
- IsZipFile(filename)
returns True when filename is a valid
zip file
- FilesInZip(filename, pattern)
returns a list of archive members,
optionally filtered with a Like pattern,
stored in filename
- ExtractFromZip(filename, destination, source)
stores the source file(s) found in the
given ZIP file into a destination folder
- CompressToZip(filename, foldername, rootfolder)
stores the content of folder, including
its subfolders, into a zip archive,
optionally under a root folder
The implementation is based on the python
zipfile standard library.
The methods area available both for Basic and
Python user scripts. For Python scripts, the
user is also free to use the native zipfile
library instead.
The user documentation shouid be updated
according to this commit.
Change-Id: I506a8583dc3fa38c7e05094562ade33f84a24747
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/211891
Tested-by: Jenkins
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Python scripts may run either
(1) inside the LO process, the usual mode
(2) as a client of a LO server
using a pipe or a socket.
The LO command is started with
an "--accept" argument.
The benefit of (2) is the freedom to
choose his/her preferred IDE to edit
and debug the script. The drawback is the
reference to the pipe/socket in the
script source code.
APSO is the best (only ?) choice for debugging (1).
With this commit, when no reference is given
to a pipe or a socket in the user script,
ScriptForge tries a connection through the
default pipe 'PIPE2LIBREOFFICE'.
If the connection fails, mode (1) is assumed.
The benefit is that the same source code
can run without change in both (1) and (2)
modes.
The command to run LO must refer explicitly
to the default pipe when (2) is wanted.
The change has no effect on existing Python
scripts.
Change-Id: I3176f4744ffea5b387280e9364b3563483fd14f0
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/205228
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
Several changes:
- 2 new methods in the Session service:
session.GetPropertyByName(basicobject,
propertyname, [arg])
for read access to properties of ScriptForge
object instances.
Argument is required for some Calc properties.
session.GetUnoProperty(unoobject,
propertyname)
for read access to properties of UNO
object instances.
Those methods complement nicely the
array.Map(), Filter() and Reduce() methods.
- The wording of trapped errors when
session.ExecutePythonScript()
fails has been reviewed to be distinct
to that of
session.ExecuteBasicScript()
- The source code of
session.GetPDFExportOptions() was missplaced.
- A more accurate identification of ScriptForge
object instances has been implemented in
SF_Utils._VarTypeObj()
(internal use only).
- Some fixed typos
The changes are applicable to Basic and Python
user scripts.
The new methods require an update of the user
documentation.
Change-Id: Ibbc0eecfe52a190eece66edadc14710a7fd6a106
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/205033
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
The
ui.EnterValue(...)
method displays a typed input box to the user
and returns the entered value as a scalar
of the requested type, or Empty/None
when the user cancels the box.
=> A single statement to interact with
the user through a complex dialog box
e.g. a listbox field of allowed values.
The box is centered on the active window.
The arguments (all are optional) :
prompt: the message appearing above the input field
Escape chars (\n \t) are interpreted correctly
valuetype: determines the type of the input field
and of the returned value, either
STRING, PASSWORD -> str
BOOL, INTEGER, FLOAT -> bool, int, float
DATE, TIME, DATETIME -> datetime
COMBO, LIST, RADIO -> str
default: the initial value
title: the header of the dialog
choices: the list of valid values
(COMBO, LIST and RADIO only)
format: the format of numeric and date values
Example (Python):
destination = ui.EnterValue(("What is your next destination ?", "LIST",
choices = ("Belgium", "Brazil", "France", "Mexico"),
default = "France",
title = "This text is in the titlebar")
The box is sized based on the arguments.
The function is available both in Basic
and Python user scripts.
The user documentation should be adapted accordingly.
Change-Id: I7c3f02f597ba5990c5f5a8548fb4f07699cda358
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/199194
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
The new "Shape" service is focused on
the description of shapes/images/drawing
objects stored in documents.
In the actual release only shapes
in Calc sheets are considered.
A Shape instance is created from either:
- calc.CreateShapeFromFile(shapename, imagefile,
range, aslink)
=> the shape is loaded in the sheet and
anchored to the given range.
The shape may or not be embedded in the
document.
- calc.Shapes(sheetname, shapename)
Next methods are available:
- shape.Anchor(anchortype, cell)
=> define the anchor type and the cell
to which the shape has to be anchored.
- shape.ExportToFile(filename, imagetype, overwrite)
=> save the shape as an image file
to a specified location.
- shape.Pick()
=> select the shape (NB "Select" is a reserved
word in Basic, hence "Pick")
- shape.Resize(xpos, ypos, width, height)
=> change position and/or size.
- shape.Rotate(angle, pivot)
=> rotate the shape using a given
pivot point (x, y) with a given angle.
The shape.XShape property gives a direct
access to its com.sun.star.drawing.XShape
UNO representation.
The pre-existing SF_Chart service is
functionally unchanged. However it is
now implemented as a subclass of the
new SF_Shape service.
Compatibility with previous releases
is preserved.
The implementation required a few changes
in the error messages. Hence also in
their translations.
All the functions are available for both
Basic and Python user scripts.
The documentation should include:
- a revision of the Calc and Chart help pages
- the creation of an additional Shape page
Change-Id: Ib67f5e755e3112961aadeffc3188b2cdf9aca613
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/193906
Tested-by: Jenkins
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
The ColorizeRange() method accepts next
arguments:
- TargetRange : the cell or the range as a string
in which cells should be re-colorizeed
- Foreground: the foreground color as the output
of the RGB() function
- Background: the background color as the output
of the RGB() function
- FilterFormula: a Calc formula to select
among the given TargetRange which cells,
rows or columns should affected
- FilterScope: "CELL", "ROW" or "COLUMN"
So far, negative values for Foreground and
Background were ignored.
Now, they reset the colors to their default
values.
This is valid for Basic and Python user scripts.
The documentation should be updated
accordingly.
Change-Id: Ie7722365bcacb1ebe82dc1fc226ed047483143dd
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/191969
Tested-by: Jenkins
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Thanks to commit
https://gerrit.libreoffice.org/c/core/+/190931
(Extend Python-Basic gateway for objects)
a signature with an object instance as argument
is allowed in any position, i.o. the 1st only.
This is applicable to
sharedmemory.StoreValue(value, variablename)
Indeed, 'value' may be such an object instance.
The signature becomes now
sharedmemory.StoreValue(variablename, value)
which is more intuitive.
No impact on user scripts <= 25.8
Documentation should take both commits
into account.
Change-Id: I1a07cd740fc9dcba1077932bba0f69735a7bc647
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/190979
Tested-by: Jenkins
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Concerned file:
scriptforge.pyi
(python stub having no impact on script
execution, only on script edition with
advanced IDE's like PyCharm and VSCode).
Guided by
https://typing.python.org/en/latest/guides/modernizing.html#generics-in-the-typing-module
Older typing features are superseded
by more modern alternatives,
which are recommended to use.
Applicable changes:
>= Python 3.9
typing.Dict => dict
typing.List => list - replaced by tuple
typing.Tuple => tuple
typing.Sequence => collections.abc.Sequence
replaced by tuple
>= Python 3.10
typing.Optional => | None
typing.Union => | (pipe operator)
This makes the source more readable
and, also, a bit shorter.
No impact on user scripts.
Documentation unchanged.
Change-Id: I856d01660c5c3e1c3f0a0c2cca756fa0cbfd9a4a
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/190362
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
Singleton class implementing the
"ScriptForge.SharedMemory"
service. Implemented as a usual Basic module.
Contains the mechanisms to manage persistent memory storage
across Basic and/or Python scripts.
When a script stops running, all the variables it uses vanish,
except Basic Global variables, which stay in memory until
the end of the LibreOffice session.
However event-driven scripting can often benefit from having
variables still being available when the next script is
triggered, probably due to a user action.
The SharedMemory service implements interfaces allowing
to store both BASIC and PYTHON variables in persistent storage,
and to retrieve them later from either BASIC or PYTHON scripts
interchangeably.
The use of the Basic Global statement is more efficient
than the actual service and should be preferred when the variables
are created and retrieved in basic scripts only.
The supported variable types are:
* Scalar or tuple combining:
- int, within the bounds of the Basic Long type
- float, within the bounds of the Basic Double type
- str
- bool
- None
* datetime.datetime
* UNO object
* ScriptForge class instance
Example:
Sub CreateDoc()
ui = CreateScriptService("UI")
doc = ui.CreateDocument("Calc")
store = CreateScriptService("SharedMemory")
store.StoreValue(doc, "actualdocument")
...
def UpdateDoc():
store = CreateScriptService("SharedMemory")
doc = store.ReadValue("actualdocument")
...
The service is available both for Basic and Python scripts.
The actual commit requires the creation of an additional
Help page.
Change-Id: Id53994be5105206c16659f769338261b3dde2d3a
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/190174
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
The
GetRangeFromCalc(filename: str, range: str)
method (stored in the Session service)
reads the values contained in the given
range located in the given Calc file.
The file does not need to be open. This
makes this shortcut particularly useful.
The content of the range is returned either
- as a scalar for a single cell
- as a 1D-array or a tuple when the range
is contained in a single row or column
- as a 2D-array or a tuple of tuples for
a rectangular range of adjacent cells.
Clean error management is included in the code.
The method is available for Basic and Python
user scripts.
The user documentation needs to be updated.
Change-Id: I39cd218f0bf3a6a21e3ada42826069eeee451c6e
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/189000
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
Constructions (Python) like
import time
while some_event is False:
time.sleep(1)
watching for some_event becoming True
have the drawback to freeze the LibreOffice
user interface.
While next (Basic) snippet
Do While Not some_event
Wait(1000)
does not.
The Python example prevents for waiting for events
that require user input,f.i. entering a value
in a cell.
The here proposed alternative is (Python):
basic = CreateScriptService('Basic')
while some_event is False:
basic.Wait(1000)
This works smoothly.
The Wait() method executes in the background
a Basic Wait statement.
This impacts only Python user scripts.
The change requires an update of the user
documentation.
Change-Id: Idb73907a5e27cf288310e306fb41c0aba9c8a388
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/185137
Tested-by: Jenkins
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Introduction of
1. the DefinedNames property
Returns the full sorted list of all
named ranges in the document.
The names defined in a single sheet
are qualified with the sheet name.
2. the DefineName() method
calc.DefineName(definedname, value [,sheetname])
Define a new name in the worksheet, at global
or sheet level. If the name existed already,
it is overwritten without warning.
The Value of the new name may be a range,
a scalar value or a formula.
When a range, the top-left cell is set
as reference cell.
After creation, the new name can be used
in formulaes.
The functions are available both for Basic
and Python user scripts.
The documentation will need an update.
Change-Id: I184e97b734a57ecba2e8a8eae583050116f40296
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/184963
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
The
ui.CreateBaseDocument()
method accepted so far to create Base documents
either embedding HSQLDB or FIREBIRD databases
or linked to a Cals spreadsheet.
It is now extended to make the new Base document
finding its datasource in an external Firebird
database file.
The previous signature
ui.CreateBaseDocument(FileName, EmbeddedDatabase,
CalcFileName)
is replaced by
ui.CreateBaseDocument(FileName, EmbeddedDatabase,
DataFileName, CalcFileName)
=> The CalcFileName argument is deprecated. When present,
it is copied to DataFileName.
The EmbeddedDatabase argument may take next values:
HSQLDB (default), FIREBIRD, FIREBIRD_EXTERNAL or CALC.
The change is valid for both Basic and Python scripts.
The documentation should be upgraded.
Change-Id: I5daf418f50739baca6be899eb1444d1b99cf89aa
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/184935
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
Only Windows implements the Description
property of the FolderPicker by displaying
it in the dialog's header. Otherwise it
is ignored.
This commit harmonizes the behaviour
among all environments, including Linux.
The previous signature:
fs.PickFolder(defaultdirectory, freetext)
is replaced by:
fs.PickFolder(defaultdirectory, title, freetext)
The 'freetext' parameter is kept for backward
compatibility. It becomes obsolete. When present,
and 'title' is absent, its content is pushed
to the dialog's title.
The change is valid both for Basic and Python scripts.
The documentation should be updated accordingly.
Change-Id: I888ee4afa5046212081bbdedc849147ebda1a3bf
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/184719
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
So far, an exception raised in a user script
and detected by ScriptForge gave next behaviour:
- an error message was displayed to the user (1)
- the same error message was recorded in the
console (2)
- the execution of the script was stopped (3)
The actual commit introduces 4 new properties
in the SF_Exception service.
Next two boolean properties may optionally
change above behaviour:
exception.ReportScriptErrors (default = True)
exception.StopWhenError (default = True)
They may change resp. behaviours (1) and (3).
Note that behaviour (2) is preserved anyway.
Their values are set until they are set
again or until the LO session expires.
When StopWhenError is set to False, next two
properties allow to test the success of the
last call to the ScriptForge API and to
define an appropriate action, including the
continuation of the process:
exception.ReturnCode
exception.ReturnCodeDescription
Example:
exc = CreateScriptService("Exception")
fs = CreateScriptService("FileSystem")
exc.ReportScriptErrors = False
exc.StopWhenError = False
fs.OpenTextFile("/aaa/bbb")
if exc.ReturnCode = "UNKNOWNFILEERROR":
...
The test on the return code must precede any
next call to any ScriptForge API entry.
The list of the available return codes is
listed in the SF_Exception.xba source code.
These changes are applicable both for Basic
and Python user scripts.
The user documentation should be reviewed.
Change-Id: I6d274e54ee37702f244e729ea5c9d1751b69abec
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/183486
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
Returns the prefix used to name new documents
(in English = "Untitled ").
Improves the portability of scripts by making
them more language-agnostic.
Available for Basic and Python scripts.
The user documentation should be updated.
Change-Id: Ie3c06e25fdc30fc1c3c775ef6ebbcee1d9cd77cd
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/183134
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
The
ImportControl()
method copies a control stored in a dialog
to the actual dialog.
Like in:
dlg1 = CreateScriptService("Dialog", ...)
dlg2 = CreateScriptService("NewDialog", ...)
dlg2.ImportControl(dlg1, "thiscontrol", ...)
The additional arguments contribute to optionally:
- renaming the new control
- storing the new control in a specific page
- repositioning the control (offsetx and offsety args)
- including the OnEventxxx properties
One goal is to help defining individual smaller
dialogs in the IDE and inserting them in a larger
one, keeping them in separate pages.
The function works for Basic and Python user scripts.
The user documentation will have to be updated.
Change-Id: I6155f58d2e8706b73fc5f72c070bb8230cdd17ee
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/182865
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
TabPageContainer-type controls are not supported
by the Basic IDE, while they are visually
attractive.
The current commit proposes the insertion
of such a control by code
dialog.CreateTabPageContainer(..., tabheaders, ...)
where tabheaders is simply an array of strings.
The originality of the approach is here to make
the link with dialog pages very easy:
OnTabSelected: define the script to trigger
when a tab is selected
Value: get or set the actual tab
Additionally, the TabPageContainer control is
associated with the SetPageManager() method.
Example on
https://gitlab.com/LibreOfficiant/scriptforge/-/snippets/4823173
The function is available for Basic and Python user scripts.
The documentation will need to be updated accordingly.
Change-Id: I7a1644344cad5f3739055f7e1eec69310ffa019c
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/182697
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
So far only the SetCellStyle() method
provided means to modify cell formats.
The actual patch introduces next methods
to apply simple and common formats. For
other options use the XCellRange
UNO interface.
- calc.AlignRange(targetrange,alignment,...)
- calc.BorderRange(targetrange,borders,...)
- calc.ColorizeRange(targetrange,foreground,background,...)
- calc.DecorateFont(targetrange,fontname,fontsize,
decoration,...)
- calc.FormatRange(targetrange,numberformat,locale,...)
Extra arguments ("...") are:
FilterFormula: a Calc formula to select cells
FilterScope; CELL, ROW or COLUMN
to allow a kind of static conditional formats.
All methods are applicable to Basic and Python
user scripts.
This change will require an update of the
user documentation.
Change-Id: Ic824aebd763f2b55364c2c0bea17430f32512742
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/181854
Tested-by: Jenkins
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
The %enuHeaders property returns,
as an array/tuple of strings the list
of the menus present in the menubar.
This is a helper for the CreateMenu()
method:
- check if the menu exists already to
avoid duplicates
- ease the choice of the Before argument
The property is applicable to next classes:
- Document, and its subclasses
Base, Calc, Writer, FormDocument
- Datasheet
The property is made available to Basic
and Python user scripts.
This new property will require an update
of the user documentation/help
Change-Id: Ia14daf6c58973e06d576b350e416eb178f70feb3
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/181065
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
The contextmenu service handles the context
menus stored in a document. So far, it
provided only the AddItem() method to add
new items at the bottom of the menu.
The new method allows to forget the preconfigured
menu and to replace it completely.
Example: associate next Sub with the
on-right-click event of sheet 'Sheet1'
=> The custom menu appears when
right-clicking in column C, otherwise
normal behaviour
Sub OnRightClick1(Optional XRange)
' Xrange is a com.sun.star.table.XCellRange
Dim calc, menu, bColumn
Set calc = CreateScriptService("Calc", ThisComponent)
Set menu = calc.ContextMenus("cell")
menu.RemoveAllItems()
bColumn = ( Len(calc.Intersect("Sheet1.$C:$C", _
XRange.AbsoluteName)) > 0 )
If bColumn Then
menu.AddItem("A", Script := "vnd.sun.star.script:...&location=document")
...
End If
menu.Activate(bColumn)
End Sub
The function is available both for Basic and Python user scripts.
The user documentation will have to be reviewed.
Change-Id: I84ee8724bf99c37397a19d729133cc4686a63980
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/180520
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
The
calc.Intersect(range1, range2) method
computes the common area as a string
which is a sub-range of both input ranges.
It returns an empty string when the
sub-range is empty.
Potential use case: customizing a popup
or context menu depending on the presence
of the selected cell in a given area.
In addition, the A1Style() method returns
the sheetname in the output string only
when it is an explicit argument.
Changes are applicable both for Basic and
Python scripts.
They require an update of the user documentation.
Change-Id: I920fc8bee6dace9ceed263a0570b4c0197bc8cb8
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/180479
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
The
XReetangle(rangename)
property returns a com.sun.star.awt.Rectangle
structure describing the coordinates (in pixels)
on the screen where the given range is
located.
This opens the door to effective interactivity
in calc sheets with the use of popup menus.
Example:
r = calc.XRectangle("B2")
menu = CreateScriptService("PopupMenu", , _
X := r.X + r.Width/2, Y := r.Y + r.Height/2)
initializes a popup menu centered on the given
cell.
The property exists in Basic and Python.
The SF_Calc help page should be updated
according to the actual patch.
Change-Id: I2a97c5c7b5bf84d36a2aab5e4b822e30c9d53d8e
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/180140
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
The ExecuteCalcFunction() method is a wrapper
of the
com.sun.star.sheet.FunctionAccess::callFunction()
method.
This method accepts a broad variety of arguments
- scalars: numeric and strings only
- data arrays (= arrays os arrays)
- 2D arrays (1D arrays give errors)
- com.sun.star.table.XCellRange objects
depending on the called function and its
execution or not as an "array function".
The actual commit makes that the arguments passed to
session.ExecuteCalcFunction()
are checked as formally correct: scalars are filtered
as numeric or strings, dates and booleans are converted,
arrays are reshaped to 2D where necessary.
The actual change facilitates, as an example,
the use of complex array functions like XLOOKUP,
a powerful search engine on large data sets.
The implemented functionalities are valid in Basic
and Python.
The help documentation might be completed with
additional examples.
Change-Id: I6bba1e21828ef09c5c6f0463cbcfa1f5df695073
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/177744
Tested-by: Jenkins
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
The
exception.PythonShell()
method opens the APSO console.
It receives 2 additional arguments
background
foreground
which specify the back- and foreground colors
of the window to open as a Python console.
Typical use of the method:
exc.PythonShell({**globals(), **locals()}, \
background = 0x0, foregound = 0xFFFFFF)
opens the shell with all existing variables
loaded and with white characters on a black
background.
The default values are those set in APSO:
background = 0xFDF6E3
foreground = 0x657B83
No impact on existing scripts.
The current change requires to be completed with
the addition of the 2 arguments in the
adequate help page.
Additonal minor changes
- typo in scriptforge.pyi
- 'outsideprocess' replaced by 'remoteprocess'
Change-Id: I9b1be123f049aa39bd0d814b6dd63fcc4f4ea310
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/174897
Tested-by: Jenkins
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Python scripts using ScriptForge start like:
from scriptforge import CreateScriptService, \
ScriptForge
ScriptForge(...) (*)
sv = CreateScriptService(...)
The (*) statement has next syntaxes: either
(1) ScriptForge()
(2) ScriptForge(host: str = ..., port: int = ...)
(3) ScriptForge(pipe: str = ...)
Syntax (1) is implicit at the first invocation of
CreateScriptService() without a former call to
ScriptForge()
Syntax (2) exists in previous versions.
This commit implements syntax (3) to connect a Python
process to a LO process on the same system via a pipe
mechanism.
The change impacts only Python scripts.
The documentation should be upgraded to include
the new functionality.
Change-Id: I50457b6fffc8c9d6a9ad5c5289de1c363c6680e3
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/173252
Tested-by: Jenkins
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
When a document is closed inadvertently
by the user during a macro run, or between
two macros triggered by events, the actual
behaviour is an error message and a stop
of the execution of the macro.
As this can be counter-productive, the macro
may test at any moment if everything is ok
with the
IsAlive As Boolean (True = OK)
property applied on next service instances:
Document
Base
Calc
FormDocument
Writer
Datasheet
Dialog
The functionality is available both for
Basic and Python user scripts.
The user documentation should be completed
accordingly.
Change-Id: I0b055dacc06c9da70c611dbb4e7bf841160168fd
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/172970
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jean-Pierre Ledure <jp@ledure.be>
Python only:
Reset a flag in SF_Database.DMin and DMax methods
to allow dates to be returned.
Review typing hints to accept strings and dates
Integration of remarks from Microsoft/VSCode
about minor syntax issues in scriptforge.pyi
(syntax was accepted by PyCharm).
Now, syntax commonly accepted by both IDE's.
Change-Id: I752d9f1d7a5293222d81748f8fb2e8f46f4317de
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/172912
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
Complete a predefined context menu with new items
placed at its bottom.
A context menu is obtained by a right-click
on several areas of a document. Each area has
its own context menu.
Each component model has its own set of context menus.
A context menu is usually predefined at
LibreOffice installation. Customization is done
statically with the Tools + Customize dialog.
The actual new service provides a mean
to make temporary additions at the bottom of a
context menu. Those changes are lost when
the document is closed.
The name of a context menu is the last component
of the resource URL:
"private:resource/popupmenu/the-name-here"
Context menu items are either usual items or
line separators. Checkboxes or radio buttons
are not supported.
Items run a command or a script when clicked.
The service implements 2 methods:
AddItem() adds an entry in the menu hierarchy
Activate() shows or hides the added entries
A context menu can be defined from both Basic
and Python user scripts.
An update of the documentation is required.
Change-Id: Id77f1f2565d75e36c09b13972330d0f83b3f1db4
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/172355
Reviewed-by: Jean-Pierre Ledure <jp@ledure.be>
Tested-by: Jenkins
Jean-Pierre Ledure