Very little actually works, but a working base to start from.
Caolán McNamara
Jean Hollis Weber
LibreOffice Dev Blog
LibreOffice QA Blog
Marius Popa Adrian
Michael Meeks
Miklos Vajna
Official TDF Blog
Roman Kuznetsov
Last updated:
March 22, 2023 07:01 AM
All times are UTC.
Powered by:
Imprint
Privacy Policy
Very little actually works, but a working base to start from.
by Popa Adrian Marius (noreply@blogger.com) at March 20, 2023 11:01 PM
by Popa Adrian Marius (noreply@blogger.com) at March 17, 2023 10:03 PM
In the LibreOffice community, most of our activities take place online: development, design, QA, localisation, marketing and so forth. But we like to meet face-to-face too, at events and conferences – and last weekend we did just that, at the Chemnitzer Linux-Tage 2023 in Germany.
We had a booth with LibreOffice materials (flyers, stickers, pens and books):
As it was a Linux and free software-oriented event, almost all participants already knew about (and used) LibreOffice, but they had lots of interesting questions about our project.
Some visitors to our booth told us about deployments of LibreOffice in their businesses and organisations, while others talked to us about interesting use cases of LibreOffice in education and other areas.
Thanks to the Linux-Tage organisers for a great meetup! Now we’re looking forward to more events this year – and especially the LibreOffice Conference 2023 in September… 
Meet us in Bucharest, and tell us what you’re doing with LibreOffice! The event is now live: https://events.documentfoundation.org/libreoffice-conference-2023/
The Document Foundation invites all members and contributors to submit talks, lectures and workshops for this year’s LibreOffice Conference in Bucharest by filling the Call for Papers form with a short description/bio of yourself as well as your talk/workshop proposal at the following address: https://events.documentfoundation.org/libreoffice-conference-2023/cfp
The event will take place from Thursday, September 21, to Saturday, September 23, 2023. Whether you are a seasoned presenter or have never spoken in public before, if you have something interesting to share about LibreOffice or the Document Liberation Project, we want to hear from you!
Proposals should be filed by June 30, 2023 in order to guarantee that they will be considered for inclusion in the conference program.
The conference program will be based on the following community tracks:
a) Development, APIs, Extensions, Future Technology
b) Quality Assurance
c) Localization, Documentation and Native Language Projects
d) Appealing LibreOffice: Ease of Use, Design and Accessibility
e) Open Document Format, Document Liberation and Interoperability
f) Advocating, Promoting, Marketing LibreOffice
We will also have a “LibreOffice in Business” track:
Presentations, case studies and technical talks will discuss a subject in depth, and will last 30 minutes (including Q&A). Workshops, with discussion on a specific subject or hands-on sessions, will last from 60 to 120 minutes (including Q&A). Lightning talks will cover a specific topic and will last 5 minutes (including Q&A). Sessions will be streamed live and recorded for download.
If you need a VISA, please get in touch with the organization team by sending an email at conference@libreoffice.org as soon as possible, to get an invitation letter.
If you cannot travel to Romania and prefer to present remotely, please add a note to your talk proposal, in order to allow organizers to schedule your talk on Friday (and organize a test session in advance).
If you do not agree to provide the data for the talk under the “Creative Commons Attribution-Share Alike 4.0 License”, please explicitly state your terms. In order to make your presentation available on TDF’s YouTube channel, please do not submit talks containing copyrighted material (music or pictures, etc.).
If you want to give multiple talks, please send a separate proposal for each one.
Thanks a lot for your participation!
You can enter proposals until 2023-07-01 02:55 (Europe/Bucharest), 3 months, 2 weeks from now.
Zdeněk Crhonek (aka “raal”) from the Czech LibreOffice community writes:
The Czech team translated the LibreOffice Base Guide 7.3 – and it’s now available on the documentation page. Our team consists of three translators: Petr Kuběj, Radomír Strnad and Zdeněk Crhonek, along with localized screenshot maker Roman Toman, and Miloš Šrámek, who prepared machine translations.
A second bit of news related to guides and documentation is that Stanislav Horáček created a Czech Bookshelf page. The Bookshelf is a project of LibreOffice’s Documentation team, where the guides are converted to HTML web pages. Stanislav created an automated script, and made the first conversion of the “Getting Started Guide” Czech translation. After polishing the script, he plans to convert all Czech guides.
Many thanks to everyone in the Czech community for their work! Learn more about LibreOffice’s documentation project here.
Berlin, March 9, 2023 – The Document Foundation announces the release of LibreOffice 7.4.6 Community, the sixth minor release of the LibreOffice 7.4 family. The new release is immediately available from https://www.libreoffice.org/download/ for Windows (Intel and Arm processors), macOS (Apple and Intel processors), and Linux.
LibreOffice offers the highest level of compatibility in the office suite market segment, with native support for the OpenDocument Format (ODF) – beating proprietary formats for security and robustness – to superior support for MS Office files, to filters for a large number of legacy document formats, to return ownership and control to users.
LibreOffice Technology Platform
Products based on the LibreOffice Technology platform – the transactional engine shared by all LibreOffice based products, which provides a rock solid solution with a high level of coherence and interoperability – are available for major desktop operating systems (Windows, macOS, Linux and Chrome OS), for mobile platforms (Android and iOS), and for the cloud.
For enterprise-class deployments, TDF strongly recommends the LibreOffice Enterprise family of applications from ecosystem partners – for desktop, mobile and cloud – with a large number of dedicated value-added features and other benefits such as SLA (Service Level Agreements): https://www.libreoffice.org/download/libreoffice-in-business/. All code developed by ecosystem companies for enterprise customers is shared with the community and improves the LibreOffice Technology platform.
Availability of LibreOffice 7.4.6 Community
LibreOffice 7.4.6 Community is available from: https://www.libreoffice.org/download/. Minimum requirements for proprietary operating systems are Microsoft Windows 7 SP1 and Apple macOS 10.12. LibreOffice Technology-based products for Android and iOS are listed here: https://www.libreoffice.org/download/android-and-ios/
The Document Foundation does not provide technical support for users, although they can get it from volunteers on user mailing lists and the Ask LibreOffice website: https://ask.libreoffice.org
LibreOffice users, free software advocates and community members can support The Document Foundation with a donation at https://www.libreoffice.org/donate
Change log pages: https://wiki.documentfoundation.org/Releases/7.4.6/RC1 and https://wiki.documentfoundation.org/Releases/7.4.6/RC2
Love LibreOffice and free software? Want to grow the FOSS community in your region? Help to organise the LibreOffice Conference 2024! Our “Call for Location” is now open – read on to learn more…
Background
Once a year, the LibreOffice Community gathers for a global community event: the LibreOffice Conference, or LibOCon. After a series of successful events – Paris, Berlin, Milan, Bern, Aarhus, Brno, Rome, Tirana, Almeria, two events online and Milan again, the 2023 venue will be in Bucharest, Romania.
To ease organization, The Document Foundation’s Board of Directors has decided to open the Call for Location for 2024 earlier this year, to give the 2024 event organizers the opportunity to attend the conference in Bucharest in September 2023. The LibreOffice Conference takes place between September and November, with a preference for September.
The deadline for sending in proposals is June 30, 2023.
After receiving the applications, we will evaluate if all pre-conditions have been met and the overall content of the proposal, and give all applicants a chance to answer questions and clarify details if needed.
What applicants need to know
Several team members are needed, and as we get closer to the event, it tends to become a time-consuming job, so each member of the team should be able to devote as much time as necessary. Also, dealing with finances and sponsors is a specific responsibility of conference organizers. Although TDF will provide a list of sponsors and ease the process, the team must be able to manage the budget according to the amount of sponsorships, and commit expenses based on the resulting amount of money.
In the past, we have received applications from several third parties, including casinos or professional event managers. Keep in mind that the LibreOffice Conference is a community event, by the community for the community. While we appreciate the interest of people with professional background, proposals not supported and driven by community members (not only TDF members) will not be considered as valid.
What must be covered by the proposal
IMPORTANT: Proposals missing the following information might be considered incomplete. While we try to give every applicant a chance to add or clarify missing information, there is no guarantee that the proposal will be accepted, since we have a rather short time frame. In order to enhance the chances for your proposal to be accepted, please answer as many of the following questions as possible.
The team
Only proposals with a fair amount of team members who are able to dedicate time and are part of the LibreOffice community will be considered as valid. Based on our experience, at least five team members are required, and those team members need to interact and communicate with the community. Please name all the team members, their role in the community, and their availability in term of time (especially during the month prior to the conference).
At least one team member should be working exclusively on sponsor relations, and on managing invitations for visas (as required for many countries). Both of these tasks require a fair amount of time, and are crucial to the organization. Based on our experience, at least a few dozen visa requests, if not more, need to be dealt with, and you need between €10,000 and €20,000 in sponsorship fees. Please let us know if you have at least one team member willing to work on these topics.
The organizing entity
The Document Foundation itself will not be legally or financially responsible for organizing the event. Although it will support the organization of the conference by any possible means, it is necessary to have a local entity, an enterprise or preferably a non-profit, to take care of financial and legal requirements such as insurances and signing contractual obligations.
Another important reason for a local entity is the fact that visa invitation letters can usually be issued only by a local entity from within the country. Please give details on the organization, its type and its leadership.
The main venue
The venue should be easily accessible from other countries, so ideally, an airport and a central train station are nearby. It should also have a good connection to the local public transportation. Please give details on the venue, its location, and its connection to public transportation.
Ideally, there is just one venue for all conference sessions. In case you distribute the conference among two venues, they should be reachable by public transportation or foot in no more than 10 minutes. Please let us know in case you plan for more than one venue (with the exception of parties and receptions).
The main venue should be partially wheelchair-accessible, with at least the opening/closing sessions and main track room fulfilling this requirement. Please let us know how accessible is the venue.
The conference itself is on 3 days, but their is an extra day before the conference dedicated to community meetings, which should be taken into account into the proposal.
Also let us know if there are defibrillators available at the venue and if your team has BLS notions.
Providing canvas, projectors and rooms for two to five parallel tracks, for a total of approximately 300 participants, is also required. Please let us know if your venue fulfils these requirements.
Along with the presentations, there is often the need to have private meetings. For sure, there are a TDF Board of Directors meeting, a Membership Committee meeting and a TDF Team meeting, so at least two additional rooms are required one day before and/or one day after the conference. These meeting rooms can also be in a different location from the main conference venue. Please let us know if you can provide these meeting rooms.
Next to or near conference rooms, there should also be an open space for community gatherings. There should be a place to have lunches which could be the same as the gathering place. Please let us know if you can provide such a space.
A publicly accessible, free wireless internet connection is required. If the venue itself does not provide WiFi, an alternative can be provided by broadband 3G/4G wireless routers.
We should also know in advance if there are firewall restrictions in place that limit or forbid the access to services like SSH, Gerrit, Git and other servicess (including e-mail), and whether we can provide a TDF VPN to overcome such limitations. Please let us know which kind of wireless internet connectivity will be provided to conference attendees.
Having video archives or video live streams is not a must-have, but a nice-to-have. Please let us know if you plan video archives or live streams of the presentations.
Also, if at least one of the social events will be in a wheelchair-accessible location, this will be highly appreciated and will be absolutely wonderful.
Accommodation
Since we expect around 200 visitors, the availability of three/four stars hotel rooms or equivalent accommodations (B&B, or similar) is required. Please elaborate on the hotel offerings near the venue.
Offering couch surfing, motels, youth hostels or other means of free to cheap accommodation is a nice-to-have. Please let us know if such accommodations are available at your venue.
One more thing…
Please describe in your own words why you want to host the next LibreOffice Conference, what motivates you, and what you expect from organizing the event.
Other information
Please write anything else that can support your application, like
Providing child care would be a nice addition to the application, as there are participants with children who might be encouraged to participate if the service is available.
You may find useful information on the dedicated pad for conferences management https://pad.documentfoundation.org/p/conference
How to apply
Please send your proposal as plain text e-mail, or HTML e-mail, or OpenDocument file to info@documentfoundation.org. Please write only in English. We will send a confirmation of your application no later than one week after we have received your proposal. In case that you have not heard back from us by then, please let us know.
Again, the deadline is June, 30 2023 24:00 UTC.
THANK YOU FOR YOUR INTEREST IN HOSTING THE LIBREOFFICE CONFERENCE!
Kudos to Ilmari Lauhakangas for helping to elaborate this list.
589 bugs, 78 of which are enhancements, have been reported by 382 people.
Top 10 Reporters
665 bugs have been triaged by 83 people.
Top 10 Triagers
483 bugs have been set to RESOLVED.
Check the following sections for more information about bugs resolved as FIXED, WORKSFORME and DUPLICATE.
164 bugs have been fixed by 37 people.
Top 10 Fixers
List of critical bugs fixed
List of high severity bugs fixed
List of crashes fixed
List of old bugs ( more than 4 years old ) fixed
73 bugs have been retested by 35 people.
Top 10 testers
125 bugs have been duplicated by 29 people.
Top 10 testers
45 bugs have been verified by 17 people.
Top 10 Verifiers
426 bugs have been categorized with a metabug by 34 people.
Top 10 Categorizers
Recent user guides from the LibreOffice Documentation team are available for free download (PDF, ODT) from the Documentation page on the LibreOffice website, and low-cost printed copies can be purchased from Lulu.com.
LibreOffice 7.4 Draw Guide
LibreOffice 7.5 Writer Guide
LibreOffice 7.5 Calc Guide
LibreOffice uses an internal GUI toolkit, named VCL (Visual Class Library). It creates the GUI widgets for LibreOffice, but it is not generally available for other applications. But there are ways that you can create standalone applications with VCL, at least to learn it better.
If you take a look into the vcl/workben, you will see several workbenches that are actually built during the build process. Previously, we discussed some of them in this post.
Now, I want to discuss the code of the simplest example: minvcl.
It basically creates a simple application with a single window, and that’s all! But even doing that needs several steps. Let’s discuss the code itself.
First come the includes. The include sal/config.h should come with each and every file in LibreOffice, and also VCL. Then, we have several includes from framework, cpppuhelper, comphelper, com/sun/star/lang and com/sun/star/uno, and then language classes from i18nlangtag.
#include <sal/config.h> #include <framework/desktop.hxx> #include <cppuhelper/bootstrap.hxx> #include <comphelper/processfactory.hxx> #include <com/sun/star/lang/XMultiServiceFactory.hpp> #include <com/sun/star/uno/XComponentContext.hpp> #include <i18nlangtag/languagetag.hxx> #include <i18nlangtag/mslangid.hxx>
After that, comes the includes from VCL. We only use two: the one for a VCL application, and another for a VCL window:
#include <vcl/svapp.hxx> #include <vcl/wrkwin.hxx>
Keep in mind that you have to provide the link libraries via the make file. In this case, the make file is vcl/Executable_minvcl.mk:
...
$(eval $(call gb_Executable_use_libraries,minvcl,\
tl \
sal \
vcl \
cppu \
cppuhelper \
comphelper \
i18nlangtag \
fwk \
))...
And at last, the include file for the main function of the VCL application. Every VCL application is supposed to have SAL_IMPLEMENT_MAIN() instead of main(), which is declared in this file.
#include <sal/main.h> #include <iostream>
The class TheApplication should fall into an anonymous namespace. This class inherits the VCL application class with the name of Application. As you can see, we keep a VclPtr to a vcl::Window named mpWin that keeps a pointer to our window.
namespace
{
class TheApplication : public Application
{
public:
virtual int Main();
private:
VclPtr<vcl::Window> mpWin;
};
}
In the main file, we use a method named Create() to create a window. Then, we set the title using SetText(), and then invoke show() to make the window visible on the screen. This is the main file of the VCL application. It is the entry point for the application.
int TheApplication::Main()
{
mpWin = VclPtr<WorkWindow>::Create(nullptr, WB_APP | WB_STDWORK);
mpWin->SetText(u"Minimum VCL application with a window");
mpWin->Show();
Execute();
mpWin.disposeAndClear();
return 0;
}
We use LibreOffice APIs to create a component context and a service manager. The setProcessServiceFactory() function is used to set the service manager for the process. To understand the service manager, you can refer to the DevGuide:
The LanguageTag::setConfiguredSystemLanguage() function sets the language of the application to the system language. Finally, the framework::getDesktop() function terminates the framework and the DeInitVCL() function frees VCL resources.
SAL_IMPLEMENT_MAIN()
{
try
{
TheApplication aApp;
auto xContext = cppu::defaultBootstrap_InitialComponentContext();
css::uno::Reference<css::lang::XMultiServiceFactory> xServiceManager(
xContext->getServiceManager(), css::uno::UNO_QUERY);
comphelper::setProcessServiceFactory(xServiceManager);
LanguageTag::setConfiguredSystemLanguage(MsLangId::getSystemLanguage());
InitVCL();
aApp.Main();
framework::getDesktop(::comphelper::getProcessComponentContext())->terminate();
DeInitVCL();
comphelper::setProcessServiceFactory(nullptr);
}
catch (...)
{
std::cout << "Exception has occurred\n";
return 1;
}
return 0;
}
We should handle the exception in the main function. Here, we just print a simple text to make the user aware that some bad thing has happened.
That’s all! The application is complete now. You can run it via:
./bin/run minvcl
Keep in mind that you have to compile LibreOffice first. 
The minvcl window
There are many complex things that you can do with VCL, but this was the simplest example that you can possibly create! I will discuss creating more complex applications that create user interfaces with things like buttons, text and many other UI things. The nice thing about VCL is that you can even create UI from the widgets created from the .ui files designed with Glade. This makes creating GUIs much easier.
I will discuss more complex examples in the next blog posts.
Writer now has the early steps to handle tables that are both floating and span over multiple pages.
This work is primarily for Collabora Online, but is useful on the desktop as well.
As requested in tdf#61594 10 year ago, the use-case is that you can already have floating tables:
And multi-page tables:
And what we want is a combination of them, like this:
This is a quite complicated feature, since both floating objects and tables are complex, and this combines them to create even more complexity.
However, such constructs are used in existing DOCX files and we're expected to correctly display them.
The feature is enabled by default, but the DOCX import only makes use of it if you set the
SW_FORCE_FLY_SPLIT=1 environment variable. This allows playing with the feature even if there are
lots of known problems still.
On the positive side, core.git sw/qa/core/layout/data/ has 4 files now which are rendered exactly
the way Word does.
A bit of terminology: once a frame is split, the first element of the chain is called master, the remaining frames are called follows.
Here are some screenshots from the journey so far:
This is a fly frame with enough content that it doesn't fit the body frame. It should split, but fly frames could not be split.
First try, just limit the height of the (master) fly frame, so at least it stays inside the body frame. But now some content is not rendered.
Next try. Now have have 2 flys, but the second has zero height and the content of the second fly leaks into the body of the second page.
This one is better, but the position of the follow fly frame is bad, no actual wrapping happens. Also, we assume that there are multiple paragraphs after the table, which will cause problems for floating tables at the end of the document. So I reworked the anchoring code to split the anchor to as many pages as necessary...
Which sounds good, but now the text around the anchor point is duplicated.
Better, now the anchor text is gone in the master anchor, but still there is a misleading paragraph marker.
And now this looks reasonable. Fine, we have some minimal split flys, let's try it with tables instead of just two paragraphs:
With a bit of work, the table's two rows can split, but again the text in the anchor is duplicated.
Next try, now the anchor text is correct, but the horizontal position of the table is still bad, it bleeds out towards the left margin area.
And with more work, now this looks correct.
Let's add some vertical offset! That should be only applied on the first page, and now the follow fly doesn't have that unwanted offset.
Now we have 2 documents that lay out correctly on 2 pages. Let's try 3 pages:
This falls apart, the 2nd and the 3rd row are both on page 2.
After partitioning the fly frames to 3 categories (master, non-last follows, last follow), more than 2 pages also work.
This is a sample where the table has a single cell, so we need to split the (only) row, not just split the table's rows. The first is harder. Currently we don't even try to split it.
Next try, now we split it, but the position of the follow fly is wrong.
Finally split of a single row inside multi-page floating tables also work. That's where we are. Don't try to do anything too custom (like inserting a header or footer), those cases are still known-broken.
If you would like to know a bit more about how this works, continue reading... :-)
As usual, the high-level problem was addressed by a series of small changes:
The design of the layout representation is documented in the SwFormatFlySplit constructor.
You can get a snapshot / demo of Collabora Office 23.05 and try it out yourself right now: try the unstable snapshot. Collabora intends to continue supporting and contributing to LibreOffice, the code is merged so we expect all of this work will be available in TDF's next release too (7.6).
In this article, I will discuss the recent problems with compiling LibreOffice using Microsoft Visual Studio, things that I did to debug and find the root cause, the source of problem itself – which is problems in Microsoft’s telemetry – and how I could fix it.
Recently, I was encountering a problem when configuring LibreOffice’s source code before compilation. Sometimes, random errors appeared without further details on why. The title: “powershell.exe” was also strange, as I wasn’t using PowerShell directly.
Powershell Error
At first, I ignored the message, but then it become more error common, and at some point the configuration was aborted. I ignored that for a while, but after a few days, one of the mentees reported a somehow similar problem.
The error was that the UCRT (which is Microsoft Visual Studio C++’s standard C library), was not found. This is an error log:
$ ./autogen.sh . . . checking for Windows SDK... found Windows SDK 10.0 (/cygdrive/c/PROGRA~2/WI3CF2~1/10) checking for midl.exe... C:\Program Files (x86)\Windows Kits\10\/Bin/10.0.20348.0/x64/midl.exe checking for csc.exe... C:\Windows\Microsoft.NET\Framework\v4.0.30319\/csc.exe checking for al.exe... C:\Program Files (x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.8 Tools\/al.exe checking .NET Framework... found: C:/PROGRA~2/WI3CF2~1/NETFXSDK/4.8/ checking whether jumbo sheets are supported... yes checking whether to enable runtime optimizations... yes checking for valgrind/valgrind.h... no checking for sys/sdt.h... no checking what the C++ library is... configure: error: Could not figure out what C++ library this is Error running configure at ./autogen.sh line 321.
The important log that contains the output of the configuration is the config.log file. In this file, I could see these related lines:
... configure:19511: result: no configure:20052: checking what the C++ library is configure:20078: C:/PROGRA~1/MIB055~1/2022/COMMUN~1/VC/Tools/MSVC/1430~1.307/bin/Hostx64/x64/cl.exe -c -IC:/PROGRA~2/WI3CF2~1/10/Include/ucrt -IC:/PROGRA~2/WI3CF2~1/10/Include/ucrt -IC:/PROGRA~1/MIB055~1/2022/COMMUN~1/VC/Tools/MSVC/1430~1.307/Include conftest.cpp >&5 conftest.cpp C:/PROGRA~1/MIB055~1/2022/COMMUN~1/VC/Tools/MSVC/1430~1.307/Include\cstddef(12): fatal error C1083: Cannot open include file: 'stddef.h': No such file or directory Microsoft (R) C/C++ Optimizing Compiler Version 19.30.30711.2 for x64 Copyright (C) Microsoft Corporation. All rights reserved. ...
The strange thing was that I could configure that compilation with another Cygwin terminal with slightly different settings. To find the differences, I used the command export to see the values of the environment variables in the two configured terminals, and compare them using diff.
Then, I found that I could evade the problem by setting this environment variable. This was the environment variable from one of the terminals:
export CYGWIN="disable_pcon" https://cygwin.com/cygwin-ug-net/using-cygwinenv.html
Unfortunately, this was not the case for our mentee who has the same problem. I also knew that this approach may lead to performance degradation.
I tried to look further into the details of configure.ac, and debug to understand the root cause of the problem. At first, I changed the version manually in configure.ac, and the configuration actually worked! If you take a look into find_ucrt() function, the relevant part is:
PathFormat "$(win_get_env_from_vsdevcmdbat UniversalCRTSdkDir)" UCRTSDKDIR=$formatted_path UCRTVERSION=$(win_get_env_from_vsdevcmdbat UCRTVersion)
Setting the PathFormat and UCRTVERSION to something from a good build fixed the problem: configuration and make went smooth, and finished successfully.
Then, I tried to look into win_get_env_from_vsdevcmdbat() function. As the name implies, it runs the VsDevCmd.bat, and uses the contents of the two environment variables: PathFormat and UCRTVERSION.
This function creates a batch file in the temporary folder, runs it and gets the output, and then removes it. So, removed the removal part, and saved the created batch files.
I was skeptical about the commands that were processing the outputs of the batch files, so I tried to change them a little, but that didn’t help. The nice thing was that each of them were working fine. I ran them several times, but there was no problem! Then I decided to run them exactly one after another, and then I saw that sometimes there was no output.
At the point, I was almost certain that the problem was from the VSDevCMD.bat itself, but I didn’t know why, and how to fix that. So, I took a look into the script, and guess what: the problem was from the telemetry! If the variable VSCMD_SKIP_SENDTELEMETRY is not set, the command line tries to open a PowerShell script, and send data to Microsoft! That was the source of problem. This is the relevant part of the code:
@REM Send Telemetry if user's VS is opted-in
if "%VSCMD_SKIP_SENDTELEMETRY%"=="" (
if "%VSCMD_DEBUG%" NEQ "" (
@echo [DEBUG:%~nx0] Sending telemetry
powershell.exe -NoProfile -Command "& {Import-Module '%~dp0\Microsoft.VisualStudio.DevShell.dll'; Send-VsDevShellTelemetry -NewInstanceType Cmd;}"
) else (
START "" /B powershell.exe -NoProfile -Command "& {if($PSVersionTable.PSVersion.Major -ge 3){Import-Module '%~dp0\Microsoft.VisualStudio.DevShell.dll'; Send-VsDevShellTelemetry -NewInstanceType Cmd; }}" > NUL
)
)
To fix that, I used the value 1 for the variable to opt out of telemetry:
set VSCMD_SKIP_SENDTELEMETRY=1
This change is now merged into the LibreOffice code:
So, the problem should be fixed by now.
It took a lot of time to debug and find the root cause of the problem. I think the best way to avoid causing problems for the users of the Visual Studio would be asking for the users’ consent before activating the telemetry.
I agree that there are legitimate or justifiable reasons to do telemetry, but getting the users’ consent is very important before sending data back to the corporate servers.
In LibreOffice, we consider users the top priority, and we are bound to the best practice of: “Telemetry required? Ask users first”, and we ask others to do the same.
On last Saturday I talked online (using our jitsi) about QA process in LibreOffice for some Russian people who want to be QA engineer in near future. One smart person made the record of my video presentation and now you can watch it on Youtube by link below:
There were around 20 persons there. Some from them now want to try to contribute in LibreOffice project as QA. Let's see =)
by Roman Kuznetsov (noreply@blogger.com) at February 13, 2023 08:31 AM
Kudos to Ilmari Lauhakangas for helping to elaborate this list.
501 bugs, 44 of which are enhancements, have been reported by 302 people.
Top 10 Reporters
717 bugs have been triaged by 77 people.
Top 10 Triagers
541 bugs have been set to RESOLVED.
Check the following sections for more information about bugs resolved as FIXED, WORKSFORME and DUPLICATE.
164 bugs have been fixed by 34 people.
Top 10 Fixers
List of critical bugs fixed
List of high severity bugs fixed
List of crashes fixed
List of old bugs ( more than 4 years old ) fixed
Writer now has a set of new automation commands and APIs that allow clients to build user interface for citation handling that's more advanced than the default in-Writer bibliography support.
This work is primarily for Collabora Online, see the CODE release notes for one possible way to use this.
Users frequently using scientific citations are probably familiar with the limits of Writer's built-in bibliography support, and solutions like Zotero appeared (with a LibreOffice extension included) to improve that situation.
This means that instead of storing all your scientific notes and data locally, you can store them on a Zotero server, then work with that from anywhere, once you provide your credentials.
The trouble comes when you want to combine this with collaborative editing, which is provided by Online, but you can't use the extension made for the desktop.
The above CODE release notes explains how an end user can use this feature, this post is meant to document what new UNO commands and LOK APIs I added that serve as a backend for this. Especially the UNO commands are also useful in other contexts, like in macros or other extensions.
Zotero can store citations using 3 markups in documents: fields (DOCX only), bookmarks (DOCX and ODT) and finally reference marks / sections (ODT only). The added plumbing allows several operations for all 3 cases, to work with existing documents using any of these markups.
The citation and the bibliography is handled the same way for fields (Writer's fieldmarks) and bookmarks. The last case uses reference marks for citations, but sections for the bibliography.
The following operations are supported:
create the citation / bibliography
read the object under the cursor
read all objects of a given type in the document
update the object under the cursor
update all objects of a given type in the document
delete all objects of a given type in the document
Reading is only available to LOK clients, you need to call the getCommandValues() API. The rest is normal UNO commands that you can invoke from document macros or extensions as well.
The added plumbing is the following:
| Operation | Fieldmark | Bookmark | Refmark | Section |
|---|---|---|---|---|
| Create | .uno:TextFormField | .uno:InsertBookmark | .uno:InsertField | .uno:InsertSection |
| Read | getCommandValues(".uno:TextFormField") | getCommandValues(".uno:Bookmark") | getCommandValues(".uno:Field") | None |
| Read all | getCommandValues(".uno:TextFormFields") | getCommandValues(".uno:Bookmarks") | getCommandValues(".uno:Fields") | getCommandValues(".uno:Sections") |
| Update | .uno:UpdateTextFormField | .uno:UpdateBookmark | .uno:UpdateField | None |
| Update all | .uno:TextFormFields | .uno:UpdateBookmarks | .uno:UpdateFields | .uno:UpdateSections |
| Delete all | .uno:DeleteTextFormFields | .uno:DeleteBookmarks | .uno:DeleteFields | .uno:DeleteSections |
If you would like to know a bit more about how this works, continue reading... :-)
As usual, the high-level problem was addressed by a series of small changes:
You can get a snapshot / demo of Collabora Office 22.05 and try it out yourself right now: try the unstable snapshot. Collabora intends to continue supporting and contributing to LibreOffice, the code is merged so we expect all of this work will be available in TDF's next release too (7.6).
A QR code is a type of 2D barcode that is useful for encoding data, such as a URL, contact information and many other data types. One can scan the code via applications on mobile phones to capture a URL or import contact information.
For example, the code below encodes the address of the LibreOffice website:
Encoding LibreOffice website’s URL in a QR code
In LibreOffice, it is possible to create different barcodes, either 1D or 2D, via extensions, or LibreOffice’s internal functionality.
QR code dialog
For QR codes, it is possible to use the internal functionality via Insert > OLE Object > QR and Barcode:
The implementation in LibreOffice is using ZXing QR code library:
If you take a look at the source code in cui/source/dialogs/QrCodeGenDialog.cxx, there is ConvertToSVGFormat() function which creates the SVG output. In the recent versions of ZXing library (we use v1.4 right now), there is a function that does that, ZXing::ToSVG(). The task here is to replace the our function with the one from ZXing library.
Unfortunately, only recent versions of ZXing provide ZXing::ToSVG() functions. It is not available in 1.3, but is added in 1.4. Looking into the packaging of the library in different distributions, it becomes obvious that this package version is not available yet in many distributions:
Therefore, a solution should check the ZXing library version, and use the new function if the library version is >= 1.4. In other words, limiting the change to where the new version of the library is present is necessary. This is possible using compiler conditionals. It is important where one configures the LibreOffice compilation to use system provided ZXing library, using --with-system-zxing while invoking autogen.sh.
EasyHacks are good starting points for someone who wants to get started in LibreOffice development. This specific issue for improving QR code is filed as tdf#153328 in TDF’s Bugzilla. To understand how to get started with LibreOffice development, you can refer to our getting involved page in the TDF Wiki, or our video tutorial for getting started with LibreOffice development.
FOSDEM 2023 is back home in Brussels. Meet the Collabora Productivity team at Europe’s largest gathering of open-source developers and have a chat, some fries or a beer with us (also: make sure to grab some stickers!). As usual, our engineers will be giving talks about the latest developments in Collabora Online, Collabora Office and LibreOffice at the LibreOffice Technology devroom. Here’s the schedule!
16:10 – LibreOffice Technology devroom 
See details Most of the easy tasks are already done. This talk covers several improvements to LibreOffice, that required lots of preparational work and interesting challenges to introduce improvements into a massive (and messy) codebase.
16:20 – LibreOffice Technology devroom See details In the talk, Pranam Lashkari will explain and demonstrate how feature locking and restrictions work in Collabora Online. Using such methods, integrators can control which features to deliver to which user or group.
16:30 – LibreOffice Technology devroom See details Sarper Akdemir tells the story of an interoperability bug fixing adventure where the problem turned out to be deeper than it appeared at first glance, showcasing how there are multiple approaches to a single interoperability problem.
16:40 – LibreOffice Technology devroom See details LibreOffice was capable of handling form filling in Writer for a while already. In the meantime, the competition introduced Structured Document Tags. Writer Content Controls are meant to perform a great handling of this third type of form filling. See Miklos Vajna‘s talk about what we have done to bring themes to LibreOffice, hear what still needs doing and find out how you can help.
17:40 – LibreOffice Technology devroom See details Szymon Klos gives a short introduction into integrating LibreOffice using LibreOfficeKit with external software. He will describe the most important code pieces and show, where to look for information. Furthermore, he’ll demonstrate how to add new features, which API we provide, and what can be done with tiled rendering.
17:50 – LibreOffice Technology devroom See details Come and hear how Collabora Online (COOL) has improved over the COVID-19 era, not only in core feature-function, but also in ease of access and deployment for everyone. See how we can deliver scalable, secure, on-premise editing of your documents with a simple, easy to deploy office for the free world.
18:10 LibreOffice Technology devroom See details Collabora Online is quite flexible in the means that you can alter to your personal taste without the need to change other core components. Pedro Pinto Silva shows how to make Collabora Online yours. Discover all the shining new additions to the user interface and learn how to customize and integrate it everywhere.
18:30 – LibreOffice Technology devroom See details Come hear Tor Lillqvist‘s talk about a new approach to enabling browser deployment of rich office functionality – built on top of allotropia’s investment in enabling the core LibreOffice technology to compile to Web Assembly (WASM) – combined with the Collabora Online front-end. Hear about how this can be used to provide a fall-back (non-collaborative) editing mode for when you lose network connectivity for a while, and about the plans to re-synchronize documents on the return from such a tunnel.
Collabora Online 22.05 is our latest enterprise release. It’s suitable for large-scale deployment, and comes with SLA, enterprise support with signed security updates as well as interaction with product management, helping to direct our development priorities. Collabora Online integrates flawlessly into Nextcloud, ownCloud, Seafile, and many of the major file sync & share, groupware and hosting solutions. It’s ideal for organizations that want to collaborate on documents, without losing control over them or compromising on privacy. With the ability to host it on your own hardware or to integrate it into a trusted environment, Collabora Online is the ideal online office suite for digital sovereignty. Enterprises interested in using Collabora Online can check out our home page for more information on partner integrations and online demos. Hosting and Cloud businesses that wish to add Collabora Online to their product portfolio can become a partner. For any questions or tailored solutions, do not hesitate to contact hello@collaboraoffice.com.
The post Collabora Productivity at FOSDEM 2023 appeared first on Collabora Office and Collabora Online.
You may already know that LibreOffice uses its internal GUI toolkit, named VCL (Visual Class Library). This library is responsible for creating the GUI widgets for LibreOffice, providing abstraction from the operating system including the basic rendering. To see more details, you can read its documentation page:
VCL has the nice feature of being able to work with different GUI libraries on different platforms. For example, if you are on Linux, you can use X11, Gtk3/4, Qt, or KDE back-ends for the VCL applications like LibreOffice. You can easily switch between them by using the environment variable SAL_USE_VCLPLUGIN. For example, you can use the old style X11 GUI in this way:
SAL_USE_VCLPLUGIN=gen instdir/program/soffice
Or, by passing it to the LibreOffice program itself:
instdir/program/soffice -env:SAL_USE_VCLPLUGIN=gen
In addition, there are other GUI backends, or plugins which are as follows:
| UI Plugin | UI Backend |
qt5 |
Qt 5 |
qt6 |
Qt 6 |
kf5 |
KDE KF5 |
gtk3 |
GTK 3 |
gtk4 |
GTK 4 |
gtk3_kde5 |
GTK 3 KDE 5 |
win |
Windows UI (Windows only) |
osx |
macOS X UI (macOS only) |
You can read more about the related environment variables here:
The code for the library is available in the vcl/ folder inside core source code. Also, beside the main source code and tests, there is a folder named workbench. Inside this folder, you can find several standalone VCL applications:
vcldemo: This is a showcase of some of the VCL rendering abilities including the lines, shapes, internationalized text, pictures and more! You can see run this demo by invoking this command, after you could be able to build LibreOffice:
./bin/run vcldemo
vcldemo
minvcl: This is possibly one of the smallest example application that can be created with VCL. Basically, It creates a window and draws a simple text inside it. Likewise, you can run it by invoking:
./bin/run minvcl
minvcl
icontest: This bitmap image testing is used by some of the developers to test VCL bitmap rendering capabilities. It can be invoked this way:
./bin/run icontest <image>
mtfdemo: This is a small application for displaying and dumping the structure of EMF/EMF+/WMF files, which is a vector image format from Microsoft. This is previously discussed in another blog post here:
Similarly, it can be run in this way:
./bin/run mtfdemo <emf|wmf image>
listfonts: This utility lists the current list of fonts installed in the system, and the features of each font. To display the information on the screen, you can invoke it this way:
./bin/run listfonts --
listglyphs: This utility lists the current glyphs in a font that is already installed on the system. You should provide the font name to it, in this way:
./bin/run listglyphs FreeMono --
Beyond the above applications and tools, there are many other platform specific tools that are not available on each and every platform. Also, there are many fuzzers ans testing tools that are helpful for fuzz-testing the library. You can find the complete list of executables using this command:
ls vcl/Executable_*.mk
As can be seen in the output, many of them are fuzzers. To use the fuzzers, first you have to setup the oss-fuzz via ./bin/oss-fuzz-setup.sh script. Then, you may be able to build the fuzzers using ./bin/oss-fuzz-build.sh script. Make sure that you have $OUT, $SRC and $WORK environment variables to set the fuzzer build environment. Be ready for several tarballs and archives downloads at first. You will need curl and svn to continue.
These tools and small applications and their source code are good for testing and getting to understand the VCL library better. As a suggestion, you can start from the minvcl.cxx to understand how to create a GUI application that can work across various platforms with different GUI toolkits. Hopefully, I will discuss the source code of some of these examples in the later blog posts.
LibreOffice 7.5 will be released as final at the beginning of February, 2023 ( Check the Release Plan ) being LibreOffice 7.5 Release Candidate 2 (RC2) the forth and final pre-release since the development of version 7.5 started in mid June, 2022. Since the previous release, LibreOffice 7.5 RC1, 89 commits have been submitted to the code repository and 39 issues got fixed. Check the Release Notes to find the new features included in this version of LibreOffice.
LibreOffice 7.5 RC2 can be downloaded for Linux, macOS and Windows, and it will replace the standard version.
In case you find any problem in this pre-release, please report it in Bugzilla ( You just need a legit email account in order to create a new account ).
For help, you can contact the QA Team directly in the QA IRC channel or via Matrix.
LibreOffice is a volunteer-driven community project, so please help us to test – we appreciate it!
Happy testing!!
…
Strings are very important types of data that are using in LibreOffice. Firstly, they are useful for storing textual data, and is essentially a sequence of characters. As LibreOffice has many modules that depend on various libraries and languages, there are different string types in LibreOffice. Here, we discuss some of them.
In C++, the standard std::string is available alongside the internal LibreOffice data types.
std::string std_str = "ت"; std::cout << "std::string: " << std_str << std::endl;
The standard std::string is not the data type of choice for storing textual values, and passing them between classes and methods, because LibreOffice has its own set of data types for this purpose. See the next sections for more information.
Please note that the usual functions to work with C strings may give unexpected results when user does not account for multi-byte encodings (like utf-8). For example, the length of the utf-8 strings as reported by std::string::length() shows the correct count of bytes (code units), but not the count of Unicode codepoints or “characters”.
In addition to the above C string type, in C++ OString is the 8-bit-string data type in LibreOffice that does not keep information about its encoding. On the other hand, OUString uses UTF-16 encoding, and is more widely used.
Here is a sample code snippet for working with these LibreOffice string classes in C++:
// The text is: "واحِدْ إثٍنين ثلاثةٌ" which means "one two three"
OUString aOneTwoThree(reinterpret_cast
(u"\u0648\u0627\u062d\u0650\u062f\u0652 \u0625\u062b\u064d\u0646\u064a\u0646"
" \u062b\u0644\u0627\u062b\u0629\u064c" ));
std::cout << "" << aOneTwoThree << std::endl;
OUString ouStr = (sal_Unicode*)u"فارسی";
std::cout << ouStr.getLength() << std::endl;
OUString sTestString = (sal_Unicode*)u"The quick brown fox\n jumped over the lazy dog العاشر";
std::cout << sTestString <buffer);
OString oStr2("پ");
std::cout << "Unicode OString: " << oStr2 << std::endl;
Some small (but important) parts of LibreOffice are in C programming language. In this case, the main type is the char[] (which is of type char * with slight difference). Essentially, it is an array of 8-bit (1 byte) characters that end with the NULL byte: '\0' or the character with the code zero. The char data type itself is used to store individual 8-bit characters. It is also possible to store UTF-8 Unicode strings in C strings.
Here is a sample code snippet for working with these data types in C:
// storing ASCII
char c='a';
printf("Non-Unicode C Character: %c\n", c);
char s[] = "عربي";
printf("Unicode UTF-8 String: %s\n", s);
setlocale(LC_ALL, "");
wchar_t w_char = L'ب';
printf("Unicode UTF-16 String: %lc\n", w_char);
The underlying Unicode character data types for LibreOffice is sal_Unicode, and the string types rtl_String / rtl_uString. They are suitable for C source codes.
Here is a sample code snippet for working with these data types in C:
sal_Unicode ouChar = u'ب';
printf("Unicode Character: %lc\n", ouChar);
rtl_String *rtl_str = nullptr;
rtl_string_newFromStr(&rtl_str, "پ");
printf("rtl_String: %s\n", rtl_str->buffer);
rtl_string_release(rtl_str);
rtl_uString *rtl_ustr = nullptr;
rtl_uString_newFromStr(&rtl_ustr, (sal_Unicode*)u"الف");
printf("%s", "rtl_uString: ");
For handling Unicode characters, we use wide characters in Windows. The wide character type wchar_t and wchar_t[] strings are based on it. The C++ versions of this string types is std::wstring.
This code is Windows-specific:
//Windows specific
#ifdef _WIN32
std::wstring w_string = L"الف";
wprintf("std::wstring: %ls\n", w_string.c_str());
printf("%ls\n", rtl_ustr->buffer);
#else
for(int i=0; ibuffer); ++i)
printf("%lc", rtl_ustr->buffer[i]);
#endif
rtl_uString_release(rtl_ustr);
Please note that this code snippet is the continuation of the above code.
As LibreOffice provides Qt UI, there is a need to work with Qt data types. Specifically, QString is the string data type provided by the Qt library. The QString class provides a rich set of functions that are very useful to store and manipulate textual data in C++ applications that use Qt library.
For more information, refer to the QString page in the Qt 6 documentation:
https://doc.qt.io/qt-6/qstring.html
QString q_str = "ABC ا ب پ ت"; qDebug() << "QString: " << q_str; qDebug() << q_str.length();
Additionally, LibreOffice provides GTK UI, thus there is also a need to work with GTK data type in the relevant source files. Specifically, the character data type used in the LibreOffice is the gchar, and the string data type gchar *.
Also, GString (GLib) is the struct suitable for storing and manipulating textual data. You can see its structure and utility functions in the glib manual:
https://docs.gtk.org/glib/struct.String.html
Here is a sample code, gchar.c:
#include
int main(int argc, char *argv[])
{
gchar *string1 = "Test";
g_print("%s\n", string1);
GString *string2 = g_string_new ("Hello");
g_print("%lu\n", string2->len);
g_print("%lu\n", strlen (string2->str));
g_string_free(string2, TRUE);
return 0;
}
You can compile it with:
gcc gchar.c -o gchar `pkg-config --cflags --libs glib-2.0`
Not all the possible string data types are desirable. These are some of the refactoring done:
// This can be replaced with std::string // https://gerrit.libreoffice.org/c/core/+/112980 std::unique_ptr<char[]> m_pFileName;
It is now converted to the std::string:
std::string m_sFileName;
There are situations where you have to pass a C string to a function in order to get some textual data from a C function. In such cases that changing the data is needed, you can use std::vector instead. For example:
std::vector vectorChar(10);
strncpy(vectorChar.data(), "ABCDEFGHIJ", 11);
printf("%s\n", vectorChar.data());
These are the classes for the literals used in LibreOffice:
OStringLiteral OUStringLiteral QStringLiteral
These are the streams and buffers classes useful for creating temporary object for string manipulation:
std::stringstream OStringBuffer OUStringBuffer QStringBuilder
At last, these are some of the stringview types used in the LibreOffice:
std::string_view std::u16string_view
We will discuss about these types in the next blog posts.
Kudos to Ilmari Lauhakangas for helping to elaborate this list.
437 bugs, 53 of which are enhancements, have been reported by 260 people.
Top 10 Reporters
583 bugs have been triaged by 65 people.
Top 10 Triagers
534 bugs have been set to RESOLVED.
Check the following sections for more information about bugs resolved as FIXED, WORKSFORME and DUPLICATE.
146 bugs have been fixed by 31 people.
Top 10 Fixers
List of high severity bugs fixed
List of crashes fixed
List of performance issues fixed
List of old bugs ( more than 4 years old ) fixed
Numbering and bullet list are a core feature of every word processing application, and naturally LibreOffice Writer has gazillion options in that area. Of course, Writer can also handle multilevel lists:
Now, how are these lists stored in ODF? Each level defines a num-prefix (what will be written before numbering), a num-suffix (same as prefix, but appended after the number), and display-levels – determining how many previous levels will be in list:
<text:list-level-style-number
text:level="3"
style:num-prefix=">>"
style:num-suffix="<<"
style:num-format="1"
text:display-levels="3">
In this example, we define a format for the third list level (in a numeric format), with displaying of all 3 levels and >> & << as a prefix/suffix. The output in Writer then looks like this: “>>1.2.3<<”
This is a nice and concise representation for many Western use-cases. But what can we do in this example:
Or in this case (https://bugs.documentfoundation.org/show_bug.cgi?id=116883):
One possible simple solution: we add a configurable number delimiter. In most cases, we would separate level numbers by “.” (and this was hard-coded in LO previously). For other cases, we should use “-” or “/”.
But before getting ahead of ourselves, lets first take a look what Word and DOCX does here:
Hmm, so Word does something completely different here: instead of a prefix/suffix, it uses an elaborate formatting string for numbers, where we can define any random prefix and suffix, plus arbitrary delimiters between different level numbers! We can even omit some numbers or worse, change their order of appearance (it is unclear how much sense that makes, but surely someone is now (mis)using that feature out there in documents).
And this is stored in DOCX in a rather simple xml attribute:
<w:lvlText w:val="%1-%2-%3-%4-"/>
Instead of prefix, suffix, display-levels and some additional separators, this has just one property, which at the same time provides much more flexibility.
Since LibreOffice 7.0, we are now using this lvlText (list format string) as an internal representation for documents (https://git.libreoffice.org/core/+/7459b9ecb54a298f02d19089620149718f8d8d48). This is enough to correctly load and save DOCX/DOC/RTF files, like the one from the screenshot above.
But we need to go further. If we save such DOCX files to ODT, more complex list level formattings will be lost.
Starting with LibreOffice 7.2, and with commit https://gerrit.libreoffice.org/c/core/+/117156/16, LibreOffice now features something quite similar to the DOCX properties: a new loext:num-list-format, which is obsoleting the older, less expressive num-prefix, num-suffix and text:display-levels attributes.
Unlike in DOCX instead of placeholders like “%1”, “%2”, this new ODF property is using “%1%”, “%2%”, etc. So why is that? Well in Word you can define up to 9 levels of list numberings, and %1 – %9 are enough for this representation. In LibreOffice, there are at least 10 levels, but even more ODF strives to be implementation-independent – so any hard limits here are anathema. Since format strings like “%10” are ambiguous (is it the “%1” placeholder with a “0” suffix, or is it the “%10” placeholder?) – the ODF specification uses the “%” delimiter on both sides of the placeholder.
Further improvements here include incorporating also style:num-format, to define numbering types for each level independently, in a way similar to the classical printf() format strings, in use with many programming languages.
The new num-list-format property is proposed for inclusion in ODF 1.4, but while this standard update slowly proceeds towards ratification, LibreOffice is meanwhile using its own namespace for it.
Work in this area is ongoing. Further efforts are needed:
Number portions generated when using lists/numberings/bullets in Writer now can have formatting which is preserved in ODT files as well.
First, thanks Docmosis for funding this work by Collabora.
Word and DOCX files support explicit character properties for the paragraph marker, and these are also used for the formatting of a number portion if the paragraph has one. This was already loaded from / saved to DOCX, but it was lost when saving to ODT.
First, we got a bug document, where the reference rendering and our rendering differed:
In this case, what happened was that part of the heading text was covered by a bookmark, so we first created multiple character ranges (outside the bookmark, inside the bookmark), then as an optimization we even unified them to be a single formatted character range, covering the entire paragraph. This was a document model that is different from the bookmark-free version, where the character formatting was set on the paragraph itself.
This was fixed at render time and at DOCX export time to consider both full-paragraph character ranges and in-paragraph character properties. For a while, this looked like the entire story, since this now looks good in Writer:
A bit later another, related bug was discovered. Given a reference document:
Just opening this DOCX file in Writer, it looked like this:
Note how the first number portion turned into bold! This was expected after the above layout change to consider full-paragraph formatted character ranges, but it also meant that Word can have one set of character formatting for the entire character range of a paragraph, and another for the paragraph marker.
To make the problem worse, this second document was showing that even the ODT export/export feature had problems, still:
The fix to solve all of the above was to undo the previous render / DOCX export change, then teach the ODT export to explicitly save the paragraph marker formatting (as an empty span at the end of the text node) to ODT, and also to load it back.
This means that now Writer can render the second document correctly, without breaking the first document:
If you would like to know a bit more about how this works, continue reading... :-)
As usual, the high-level problem was addressed by a series of small changes:
You can get a snapshot / demo of Collabora Office 22.05 and try it out yourself right now: try the unstable snapshot. Collabora intends to continue supporting and contributing to LibreOffice, the code is merged so we expect all of this work will be available in TDF's next release too (7.6).
LibreOffice 7.5 will be released as final at the beginning of February, 2023 ( Check the Release Plan ) being LibreOffice 7.5 Release Candidate 1 (RC1) the third pre-release since the development of version 7.5 started in mid June, 2022. Since the previous release, LibreOffice 7.5 Beta1, 213 commits have been submitted to the code repository and 70 issues got fixed. Check the Release Notes to find the new features included in this version of LibreOffice.
LibreOffice 7.5 RC1 can be downloaded for Linux, macOS and Windows, and it will replace the standard version.
In case you find any problem in this pre-release, please report it in Bugzilla ( You just need a legit email account in order to create a new account ).
For help, you can contact the QA Team directly in the QA IRC channel or via Matrix.
LibreOffice is a volunteer-driven community project, so please help us to test – we appreciate it!
Happy testing!!
…
by Popa Adrian Marius (noreply@blogger.com) at December 08, 2022 12:15 PM
The PDF export now supports various additional properties for the optional PDF watermark.
First, thanks Docmosis for funding this work by Collabora.
When you hear the word "watermark", you probably have something like the above picture in mind.
Instead, what the PDF export had is more like a proof of concept:
The request was to add new options to control the font size, font name, rotation angle and color of the watermark, so in case an organization already has a given style of watermarks they prefer, our PDF export can be adapted accordingly.
First, now you can specify a custom color, e.g. gray (#7f7f7f), using:
soffice --convert-to pdf:writer_pdf_Export:'{"Watermark":{"type":"string","value":"draft"}, "WatermarkColor":{"type":"long","value":"8355711"}}' test.odt
Then you can also customize the font size, in case the automatic size would not fit your needs, using:
soffice --convert-to pdf:writer_pdf_Export:'{"Watermark":{"type":"string","value":"draft"}, "WatermarkFontHeight":{"type":"long","value":"100"}}' test.odt
Or perhaps you want a serif font, not a sans one:
soffice --convert-to pdf:writer_pdf_Export:'{"Watermark":{"type":"string","value":"draft"}, "WatermarkFontName":{"type":"string","value":"Times"}}' test.odt
Finally you can have a custom rotate angle:
soffice --convert-to pdf:writer_pdf_Export:'{"Watermark":{"type":"string","value":"draft"}, "WatermarkRotateAngle":{"type":"long","value":"450"}}' test.odt
Using these building blocks, you can also build combinations, the first screenshot above was created using:
soffice --convert-to pdf:writer_pdf_Export:'{"Watermark":{"type":"string","value":"draft"}, "WatermarkRotateAngle":{"type":"long","value":"450"}, "WatermarkColor":{"type":"long","value":"8355711"}}' test.odt
i.e. the configuration JSON is:
{
"Watermark": {
"type": "string",
"value": "draft"
},
"WatermarkRotateAngle": {
"type": "long",
"value": "450"
},
"WatermarkColor": {
"type": "long",
"value": "8355711"
}
}
If you would like to know a bit more about how this works, continue reading... :-)
As usual, the high-level problem was addressed by a series of small changes:
You can get a snapshot / demo of Collabora Office 22.05 and try it out yourself right now: try the unstable snapshot. Collabora intends to continue supporting and contributing to LibreOffice, the code is merged so we expect all of this work will be available in TDF's next release too (7.5).
by Popa Adrian Marius (noreply@blogger.com) at December 03, 2022 05:12 PM
Similar to the questionnaires about LibreOffice Draw (see first and second blog post) and LibreOffice Calc (see this post) we now run a survey on LibreOffice Impress to learn how the program is utilized, what features are used most frequently, and what users see as positive and negative and what they expect of the future.…
by Popa Adrian Marius (noreply@blogger.com) at November 25, 2022 02:52 PM
by caolan (noreply@blogger.com) at November 24, 2022 03:39 PM
Bruce Byfield and Jean Hollis Weber announce the second edition of Designing with LibreOffice. The book is available as an .ODT or .PDF file under the Creative Commons Attribution/Sharealike License version 4.0 or later from https://designingwithlibreoffice.com/
The first edition was published in 2016, and was downloaded over thirty-five thousand times. Michael Meeks, one of the co-founders of LibreOffice, described the first edition as “an outstanding contribution to help people bring the full power of LibreOffice into their document.” Similarly, free software author and journalist Carla Schroder wrote, “Designing With LibreOffice teaches everything you need to know about document production…. suitable for beginners to wizened old pros, who will probably discover things about LibreOffice that they didn’t know.”
The second edition updates the original, removing outdated information and adding updated screenshots and new information about topics such as Harfbuzz font shaping codes, export to EPUB formats for ereaders, the Zotero extension for bibliographies, and Angry Reviewer, a Grammarly-like extension for editing diction. In the future, the writers plan to release other editions as necessary to keep Designing with LibreOffice current.
For more information or interviews, contact Bruce Byfield at bbyfield@axion.net.
The LibreOffice Conference 2022 (LibOCon) took place from September 28 to October 1 in Milan. It was the first LibreOffice Conference since the outbreak of the COVID-19 Pandemic that took place as an in-person event. Collabora was one of the sponsors, and a significant number of our developers contributed talks on various aspects of LibreOffice technology. Did you miss any of those? Don’t worry! All our talks are available for you on YouTube inside our LibOCon playlist. Please also feel free to download the slides we included in this blog post.
Michael Meeks, Managing Director of Collabora Productivity, takes a look at the latest developments in LibreOffice from an organisational and ecosystem perspective. See details 
Hear Michael Meeks tell the history of LibreOffice in the browser. From it’s pre-historic past as StarPortal, through gtk-broadway prototypes, to Collabora Online as we know it today. See details
During the Quality Assurance track, Sarper Akdemir explained how to fix an interoperability bug by showcasing the whole process of understanding, fixing, and implementing tests. See details
Sparklines are mini charts, that are drawn into a cell. In his talk, senior software engineer Tomaž Vajngerl presented the features and the challenges during the development. See details
While LibreOffice and Collabora Office were already capable of filling forms via form controls or form fields, they can now also fully represent content controls. In this talk by Senior Software Engineer Miklos Vajna, see how this work was implemented! See details
Collabora Productivity created Collabora Online, a powerful online office suite, which you can integrate into your own infrastructure. It prioritises your digital sovereignty and provides you with all the tools to keep your data secure, without compromising on features. Collabora provides a wide range of products, as well as consulting services for enterprises and governments. Powered by the largest team of certified LibreOffice engineers in the world, Collabora is a leading contributor to the LibreOffice Technology codebase and community. Collabora Office for Desktop and Collabora Online provide a business-hardened office suite with long-term support. Collabora’s multi-platform policy is completed with Collabora Office for iOS, Android, and Chrome OS. Collabora Productivity is a division of Collabora, the global software consultancy dedicated to providing the benefits Open Source to the commercial world, specializing in mobile, automotive and consumer electronics industries. For more information, follow us on Twitter, LinkedIn and YouTube.
The post Collabora’s Contributions to the LibreOffice Conference 2022 in Milan appeared first on Collabora Office and Collabora Online.
Writer now supports titles and tags for content controls, which helps providing context for the filled in text even if the placeholder text is replaced already.
This work is primarily for Collabora Online, see the previous post for background.
Once several content controls are added to a document, it's easy to forget what was the exact purpose of what content control. Think of a press release for example – those regularly start with a location and a date, but once this information is provided, one no longer knows which content control was for which content.
Titles solve this problem for the user: similar to Writer's header/footer buttons, this button appears when you enter the content control and reminds you what content is expected there, even if the placeholder is already replaced.
Tags serve a similar purpose, but they are unique, machine-readable keys or identifiers, so once the form is filled in, an external consumer can easily extract the information from the document, given a specific tag.
Titles (also known as aliases) and tags are now not only preserved, but also we have a UI to create, show, edit and delete them. This is available in the desktop rendering and also in the LOK API.
Somewhat related, in case a content control breaks into multiple lines or has formatting to break into multiple text portions, we now only emit one PDF widget for it, taking the description of the widget from the content control's title.
The last related improvement is that now we handle data binding for date content controls, which means that you can specify a timestamp, a language and a date format, and we'll format that timestamp and update the content control's string value at import time from DOCX.
If you would like to know a bit more about how this works, continue reading... :-)
As usual, the high-level problem was addressed by a series of small changes:
You can get a snapshot / demo of Collabora Office 22.05 and try it out yourself right now: try the unstable snapshot. Collabora intends to continue supporting and contributing to LibreOffice, the code is merged so we expect all of this work will be available in TDF's next release too (7.5).
| Imprint Privacy Policy | |
|
The Document Foundation is not responsible for the content on planet.documentfoundation.org. However - if you have any concerns about content please contact Uwe Altmann for moderation. Copyright information: Unless otherwise specified in the author's blog, all text and images on this website are licensed under the Creative Commons Attribution-Share Alike 3.0 License. This does not include the source code of LibreOffice, which is licensed under the Mozilla Public License (MPLv2). |
|