Welcome to The Document Foundation Planet

This is a feed aggregator that collects what LibreOffice and Document Foundation contributors are writing in their respective blogs.

To have your blog added to this aggregator, please mail the website@global.libreoffice.org mailinglist or file a ticket in Redmine.

18 June, 2024


TDF Annual Report 2023 banner

In 2023, the marketing team continued the deployment of the Strategic Marketing Plan, without overlooking ongoing activities to promote LibreOffice and support the efforts of native language communities

(This is part of The Document Foundation’s Annual Report for 2023 – we’ll post the full version here soon.)

Slide Decks and Videos for Marketing Purposes

We updated presentations on The Document Foundation (project history and digital sovereignty), LibreOffice (technology, including commentary, and sustainability) and Open Document Format (standard format, ODF and interoperability, and OOXML issues) for use by community members. Videos are also available to help tailor a presentation to the audience.

We updated the LibreOffice Technology White Paper, which explains the evolution of LibreOffice from a single desktop product to a product-based technology for personal or enterprise productivity that is the foundation for a series of products optimised for different platforms, such as desktop, mobile and cloud. To emphasise the importance of the LibreOffice technology concept, a specific logo has been created to make it visually easier to associate all products based on this technology platform.

LibreOffice Technology component diagram

We also created a Security Backgrounder that describes – in a language accessible to everyone, even non-security specialists – the impressive work done by the developers and quality control specialists in the security area of LibreOffice.

Finally, the project continues to invest in communicating the sustainability of FOSS. Companies need to consider that focusing on the ‘free as beer’ nature of software can seriously damage the projects they rely on as strategic assets of their infrastructure. It is a short-sighted decision because they can save a lot by not paying a single penny, but they may also have to spend a lot tomorrow if the original project is unable to sustain itself by having to revert to a proprietary solution.

The Importance of Donations

Donations are essential for the current operations and future development of The Document Foundation, as they allow us to keep the organisation alive, fund specific activities, support events and other marketing tasks organised by the native language projects, and maintain a small team working on various aspects of LibreOffice.

Donate to LibreOffice

In 2023, donations were used to fund various activities: the organisation of the LibreOffice conference in Bucharest and the regional LibreOffice conferences in Asia and Latin America, events and other activities of the native language communities, reimbursement of travel expenses to conferences around the world, the supply of merchandise for the Month of LibreOffice, and other small projects.

Ongoing Marketing Activities

Marketing for The Document Foundation and LibreOffice is a large team effort, with contractors paid for their work – thanks to the funds provided by our generous donors – and several volunteers who run activities on both a global and local level to increase visibility and brand awareness.

One of the ongoing projects is the Community Member Monday series, where one or more community members are interviewed about their contribution to the project.

The marketing team, supported by many volunteers, created a series of New Features videos for the announcement of LibreOffice 7

16 June, 2024


The Documentation Team is proud to announce the immediate availability of the Impress Guide 24.2.

The Impress Guide 24.2 update was coordinated by Peter Schofield, with assistance of Olivier Hallot and B. Antonio Fernandez, and is based on the Impress Guide 7.6.

Peter Schofield

Peter Schofield


LibreOffice 24.2 Community also includes many other changes, including improvements in accessibility, change tracking, spell checking, and interoperability with Microsoft’s proprietary file formats. Notably, Impress now allows small caps in text and secured slide show remote control with bluetooth, as well as enhancements to supplied templates.

Release Notes are here: https://wiki.documentfoundation.org/ReleaseNotes/24.2

The guide is available for immediate download in PDF format, and in HTML format for online reading, as well as in source format (OpenDocument Format). Soon it will be available as printed book by LuLu inc.

Download the Impress Guide 24.2 from the documentation websites at: documentation.libreoffice.org and the bookshelf at books.libreoffice.org.

14 June, 2024


LibreOffice 24.8 will be released as final at the end of August, 2024 ( Check the Release Plan ) being LibreOffice 24.8 Beta1 the second pre-release since the development of version 24.8 started at the beginning of December, 2023. Since the previous release, LibreOffice 24.8 Alpha1, 672 commits have been submitted to the code repository and 191 issues got fixed. Check the release notes to find the new features included in this version of LibreOffice.

Internal python version has been upgraded to python 3.9 which no longer supports Windows 7. It’s very important to us to know whether LibreOffice 24.8 still works on Windows 7 or not, as well as its python functionalities. Please, do test this version and give us feedback.

LibreOffice 24.8 Beta1 can be downloaded for Linux, macOS and Windows, and it can be installed alongside 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!!

Download it now!

06 June, 2024


General Activities

  1. LibreOffice 24.2.3 was released on May 2
  2. LibreOffice 7.6.7 was released on May 10
  3. Olivier Hallot (TDF) added help pages for SEQUENCE and UNIQUE Calc functions and finalised help for RANDARRAY, XLOOKUP, XMATCH, FILTER, RANDARRAY, SORT and SORTBY functions. He also improved the help for Calc’s Advanced Filter, added extended tips to Sparklines dialog and improved the descriptions seen in the UI for Calc’s RANDARRAY and UNIQUE functions
  4. Adolfo Jayme Barrientos improved the readability and grammar of Help pages
  5. Stéphane Guillou (TDF) added help content for the new ability to start a presentation from the command line at an arbitrary slide number
  6. Alain Romedenne added unit tests for officehelper.py
  7. Dione Maddern added help content for new bar-of-pie and pie-of-pie chart types, updated help for File Properties, Slide Show Settings, Calc View Options, Summary and Expand Slides, Edit Points Bar, Calc change tracking, Shapes menu, Bullets and Numbering Image tab alongside various fixes and cleanups
  8. Stanislav Horacek did corrections to Calc help content
  9. Bogdan Buzea improved help about object positioning in Writer
  10. Gábor Kelemen (allotropia) did code cleanups in the area of measurement units and snap lines, code simplification and includes
  11. Laurent Balland did cleanups in Impress templates and added handling of xlink:type attributes for embedded charts, so they don’t produce a warning in the console
  12. Miklós Vajna (Collabora) created a better implementation of continuous endnotes for Microsoft Word compatibility, implemented support for DOCX/DOC mirrored object positioning and adapted DOCX paragraph handling for files created with Word 2013 or newer, so the top margin of paragraphs on other pages than the first are collapsed
  13. Áron Budea (Collabora) made it faster to open PPTX files with custom shapes
  14. Gökay Şatır, Pranam Lashkari, Szymon Kłos, Méven Car, Hubert Figuière, Jaume Pujantell, Henry Castro and Michael Meeks (Collabora) worked on LOKit used by Collabora Online
  15. Tomaž Vajngerl (Collabora) refactored the code for Impress annotations and cleaned up the accessibility checker code
  16. Julien Nabet continued polishing gssapi authentication support for the MariaDB/MySQL connector and fixed a crash when exporting spreadsheet as PDF with “whole sheet export” option
  17. Xisco Faulí (TDF) added support for SVG 2 attribute values context-stroke and context-fill, optimised the code for getting selected points and objects, added a couple of unit tests, upgraded many dependencies and started applying the newly-added SAL_RET_MAYBENULL for enforcing null checking
  18. Michael Stahl (allotropia) implemented support for recognising localized paragraph style names in DOCX files, fixed the visibility of shapes in header/footer in DOCX files and fixed an issue with AutoText insertion or pasting overriding Writer paragraph style indentation
  19. Mike Kaganski (Collabora) continued polishing HTML map export for text hyperlinks in frames, made LibreOffice’s own OLE objects obey AddReplacementImages setting, made it so the newly-added Windows version detection also handles architectures other than x86_64 and fixed a Writer undo issue affecting list levels
  20. Caolán McNamara (Collabora) introduced SAL_RET_MAYBENULL which for debug builds and MSVC

05 June, 2024


Shortcuts are a major topic for user experience. Novices are advised to learn basic shortcuts beyond the famous Ctrl+C/X/V like Ctrl+1/2/3.. to quickly change the paragraph style to heading 1/2/3… in Writer. Once you have learned those combinations you never want to unlearn and to change the muscle memory.…

03 June, 2024


Writer now has much better support for continuous / inline endnotes (not on a separate page) in Writer, enabled by default for DOCX files.

This work is primarily for Collabora Online, but the feature is fully available in desktop Writer as well.


As described in a previous post, Writer already had minimal support for not rendering endnotes on a separate endnote page, but it was not mature enough to enable is by default for DOCX files.

Results so far

What changed from the previous "continuous endnotes" approach is that instead of trying to map endnotes to footnotes, we now create a special endnotes section, which only exists at a layout level (no section node is backing this one), and this hosts all endnotes at the end of the document. It turns out this is a much more scalable technique, for example a stress-test with 72 endnotes over several pages is now handled just fine.

Here are some screenshots:

Before: reference is red, Writer result is painted on top of it

After: reference is red, Writer result is rendered on top of it

As you can see, there were various differences for this document, but the most problematic one was that the entire endnote was missing from the (originally) last page, as it was rendered on a separate page.

Now it's not only on the correct page, but also its position is correct: the endnote is after the body text, while the footnote is at the bottom of the page, as expected. The second screenshot shows ~no red, which means there is ~no reference output, where the Writer output would be missing.

How is this implemented?

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 tracking bug was tdf#160984.

Want to start using this?

You can get a development edition of Collabora Online 24.04 and try it out yourself right now

30 May, 2024


In this blog post, I discuss porting Java tests from Java to C++. We have many Java tests, and porting them to C++ is beneficial for LibreOffice. Here I discuss why, and how.

Why Porting Java Tests?

In the past, Java was used extensively in LibreOffice, and many tests where written in Java. They consist of various tests, including JUnit.

Searching for junit in LibreOffice source code gives many results: (Note that this is not the number of tests)

$ git grep -i junit | wc -l


Although these tests are useful, they have drawbacks:

1. They are slower than C++ CppUnitTests

2. They are outside process, which is creates them even more slower, and harder to debug

Porting these tests to C++ can make them faster, more reliable, and easier to debug. Let’s see how we can do it.

Start from Examples

The best way to find out how to do porting is to look into the previous examples. This issue is around porting Java API tests to C++:

There are many commits in the above page, which can be an interesting way to learn how to do that. For example, consider this commit:

In the above commit, Jens has ported qadevOOo/tests/java/ifc/sheet/_XSheetCellRanges.java test to C++ test test/source/sheet/xsheetcellranges.cxx.

I can summarize the changes in this way:

1. An equivalent C++ file, in test/ folder

2. Removal of Java file from qadevOOo/.

3. The Makefiles in test/ and qadevOOo/ folders should reflect the removal of Java test, and addition of C++ test.

4. Some Java tests are adjusted to reflect the deletion of the old Java test.

5. Some C++ tests are adjusted to reflect the addition of new C++ test.

Final Words

To be able to port a test, one should be able to understand the old test. Reading the code is the best way that one can achieve this purpose. By looking into similar ports, you can gain a better understanding of what to do. In Bugzilla page for tdf#45904, you may find similar ports.

27 May, 2024


Writer Again!

After resigning from the Board of Directors of TDF over the weekend, I hope I will again find more time to look into the technical details of LibreOffice Writer. I will also try to do my best to write some good article here about the depth of that application. While a text processor in itself is not that interesting anymore these days, the challenges of migrating that big old legacy code might be fascinating quite often. Hope to have you as a reader for that soon!

Comments? Feedback? Additions? Most welcome here on the fediverse !

21 May, 2024


LibreOffice 24.8 will be released as final at the end of August, 2024 ( Check the Release Plan ) being LibreOffice 24.8 Alpha1 the first pre-release since the development of version 24.8 started at the beginning of December, 2023. Since then, 4448 commits have been submitted to the code repository and more than 667 bugs were set to FIXED in Bugzilla. Check the release notes to find the new features included in this version of LibreOffice.

LibreOffice 24.8 Alpha1 can be downloaded for Linux, macOS and Windows, and it can be installed alongside 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!!

Download it now!

14 May, 2024


In the previous parts of the blog posts series on fixing software crashes, I have written about some crash fixes in LibreOffice around segfaults, aborts, and I discussed how test them. Here I write about fixing assertion failure.

What is Assertion Failure?

Assertion is a mechanism provided to the developers to make sure that things are good in runtime, conforming to what they were assuming. For example, making sure that some pointer is valid, some data elements match expectation, or some similar assumptions that need to be valid in order to get the correct results.

As an example, consider the C++ function basegfx::utils::createAreaGeometryForLineStartEnd(), which creates a geometric representation of an arrow. The code resides here:


This is the line of code which contains assertion:

assert((rCandidate.count() > 1) && "createAreaGeometryForLineStartEnd: Line polygon has too few points");

On top of the actual function implementation, the C++ code asserts many conditions to make sure that they are met. In the above assertion, it checks to make sure that the number of points in the given data structure is more than 1. Otherwise, it leads to an assertion failure.

For various reasons, sometimes these sort of assumption may not be valid. To avoid reaching to incorrect results, it is important to have such assertions in place, to find such issues as soon as possible. If you are developing LibreOffice, you may have already built the code from sources in debug mode. Therefore, you may see software stops working, or simply crashes.

This crash may not happen for the end users, which use the release version of software. Therefore, these type of crashes have lower impact for the end users, and they are usually considered of lower importance compared to the crashes that happen for the end users.


One of the things that can help diagnose the problem is the stack trace, or simply backtrace. The way to obtain a backtrace depends on the platform and/or IDE that you use. If you use an IDE like Qt Creator, Visual Studio, etc., getting a backtrace would be as easy as debugging LibreOffice, making the assert fail, and then copy the backtrace from the UI. To learn more about IDEs, see this Wiki page:

If you want to use gdb on Linux, you may run LibreOffice with this command line:

$ instdir/program/soffice –backtrace

and then make the assert fail, and you will have the backtrace in gdbtrace.log file. You can learn more int this QA Wiki article:

TDF Wiki: QA/BugReport/Debug_Information

One thing to mention is that if you work on a reported bug regarding to assertion failure, then the actual way to reproduce the issue and make the assertion fail is usually described in the relevant TDF Bugzilla issue. In the meta bug related to assertion failure, you may find some of these issues in the last part of this blog post.

Fixing the Problem

To fix the problem

09 May, 2024


General Activities

  1. Olivier Hallot (TDF) added Help content for user interface selection dialog, Calc row recalculation at load time, automatic labeled ranges in Calc and font embedding. He also updated menu item paths in Help
  2. Rafael Lima added support for hidden named expressions in Calc, added Reload command to Notebookbar UIs and made named ranges created by the Solver in Calc hidden by default
  3. Stéphane Guillou (TDF) updated Help content for Navigator’s Navigate By
  4. Alain Romedenne continued improving the officehelper Python script for connecting to LibreOffice processes
  5. Dione Maddern improved Help content for inserting objects from the Gallery and did cleanups in Help
  6. Colton Garrett improved Help content for OpenCL and added a Help page for digital signing of paragraphs
  7. Laurent Balland did style cleanups in Impress templates
  8. Miklós Vajna (Collabora) fixed an issue with shape positioning in DOCX import and did many code cleanups
  9. Áron Budea (Collabora) fixed an issue with unwanted spacing in printed text
  10. Marco Cecchetti, Gökay Şatır, Pranam Lashkari, Szymon Kłos and Michael Meeks (Collabora) worked on LOKit used by Collabora Online
  11. Attila Szűcs (Collabora) continued improving the performance of handling transparent animated GIFs
  12. Tomaž Vajngerl (Collabora) improved the text scaling in Impress text boxes, implemented support for custom cell format of pivot table output found in OOXML and did many code cleanups and restructurings
  13. Julien Nabet added gssapi authentication support for the MariaDB/MySQL connector, fixed UI issues in Writer’s Paragraph dialog related to the “Allow to split paragraph” option, fixed crashes and did code cleanups
  14. Xisco Faulí (TDF) continued the implementation of SVG filters
  15. Michael Stahl (allotropia) changed the handling of paragraph and text attributes in empty lines at the end of paragraphs to match the behaviour seen in Microsoft Word
  16. Mike Kaganski (Collabora) fixed issues with rotated text being partially cut off, made it possible to create DDE links to files with special characters in their names on Windows, made the Basic LIKE operator more robust, fixed an issue preventing Windows users with special characters in their names from importing PDF files into Draw, made the position shifting behaviour more robust for objects anchored As Character in Writer, fixed an issue with chapter titles in headers/footers getting mixed up due to headings in endnote content, fixed handling of em and ex units in the properties of imported SVG files, improved the stability of text part positioning in SVG files, fixed handling of whitespace in SVG text, fixed a Draw issue causing font colour to not be retained in certain situations and restored HTML map export for text hyperlinks in frames. He also did many code cleanups and optimisations
  17. Caolán McNamara (Collabora) continued improving performance of threaded calculation in Calc. He also fixed crashes and many issues found by static analysers and fuzzers
  18. Stephan Bergmann (allotropia) worked on WASM build, added a new Expert Configuration setting to not offer Safe Mode in the UI, fixed the msvc_win32_arm64 UNO bridge and worked on Windows Subsystem

30 April, 2024


LOWA is LibreOffice built with Emscripten as a Wasm executable that runs in the browser. Controlling that LibreOffice through UNO with JavaScript looks like a natural fit. Enter Embind, a mechanism to generate the binding glue between JavaScript and Wasm/C++.

As we will see, the Embind vs. UNO match is not perfect, but it kind-of gets the job done, at least for a first iteration.


To dive straight into technical matters, the UNO type system is mapped to JavaScript as follows. (If you would like to see some example code first, jump ahead to the Starting Points and come back here later for reference.)

  • UNO BOOLEAN, depending on context and somewhat inconsistently maps to JavaScript Boolean and to JavaScript Number values 0 and 1. (The C/C++ representation of UNO BOOLEAN is sal_Bool, which is an alias for unsigned char, which Embind maps to JavaScript Number. So in places where we directly rely on Embind, like for the return value of a UNO interface method invocation, we get the Embind mapping to Number. But in places where we have more control, like for the JavaScript get method for a UNO ANY, we can be a bit more fancy and use a mapping to Boolean.)
  • UNO BYTE, SHORT, UNSIGNED SHORT, LONG, UNSIGNED LONG, FLOAT, and DOUBLE all map to JavaScript Number (with restricted value ranges for everything but UNO DOUBLE).
  • UNO HYPER and UNSIGNED HYPER both map to JavaScript BigInt (with restricted value ranges).
  • UNO CHAR and STRING both map to JavaScript String (with single UTF-16 code unit strings for UNO CHAR).
  • UNO TYPE maps to JavaScript Module.uno_Type objects. There are construction functions Module.uno_Type.Void, Module.uno_Type.Boolean, Module.uno_Type.Byte, Module.uno_Type.Short, Module.uno_Type.UnsignedShort, Module.uno_Type.Long, Module.uno_Type.UnsignedLong, Module.uno_Type.Hyper, Module.uno_Type.UnsignedHyper, Module.uno_Type.Float, Module.uno_Type.Double, Module.uno_Type.Char, Module.uno_Type.String, Module.uno_Type.Type, Module.uno_Type.Any, Module.uno_Type.Sequence, Module.uno_Type.Enum, Module.uno_Type.Struct, Module.uno_Type.Exception, and Module.uno_Type.Interface for representations of all the UNO TYPE values. The Module.uno_Type.Sequence construction function recursively takes a UNO TYPE argument for the component type, while the Module.uno_Type.Enum, Module.uno_Type.Struct, Module.uno_Type.Exception, and Module.uno_Type.Interface construction functions each take a string argument denoting the given type’s name in dotted notation (e.g., Module.uno_Type.Interface('com.sun.star.uno.XInterface')). Those JavaScript objects implement toString, which is also used for equality checks (e.g., type === 'com.sun.star.uno.XInterface').
  • UNO ANY maps to JavaScript Module.uno_Any objects. There is a constructor taking a UNO TYPE argument and a corresponding value (using an undefined value for UNO type VOID). Those JavaScript objects implement a method get that returns the JavaScript representation of the contained UNO value.
  • UNO sequence types map to a pre-canned variety of JavaScript Module.uno_Sequence_... objects. The problem is that Embind does not let us have a generic mapping to the C++ com::sun::star::uno

18 April, 2024


I have previously discussed fixing crashes in 2 parts (segfaults, aborts). Here I discuss testing crashes to avoid creating re-creating regressions.

Why testing crashes?

When you fix a crash, you have to make sure that it does not happen again in the future. The key to achieve such a goal is to write a suitable test. The test should do the exact steps to reproduce the problem on the program in order to detect the known crash before the new code is merged.

This can be done using either UITests, or CppUnitTests. UITests are written in Python. They are easier to write, but they do not run on each and every platform, and they are usually slower. CppUnitTests, on the other hand, are written in C++. They are much faster, and they run on every platform that CI runs to make sure that everything is built and can be run correctly.

An Example Crash Testing

Consider the below issue around footnotes:

This problem was happening when someone created a footnote, deleted the reference, and then hovered the mouse on the removed footnote reference. To reproduce that, one could use keyboard to generate a key sequence that repeats the required steps:

Write something, add footnote, select all the footnotes and remove them, then go back to the text, and hover the footnote reference.

Using keyboard-only is not always enough, but here it was possible. To implement the UITest, you should first find the appropriate place to put the test file, and then write a Python script for that. Here, the test was written in sw/qa/uitest/writer_tests2/deleteFootnotes.py. The UITest test can be found alongside the bug fix, in the class class tdf150457(UITestCase):

If you look into the code, the test_delete_footnotes() function consists of many invocations of postKeyEvent calls, that emulate key input events:

pTextDoc->postKeyEvent(LOK_KEYEVENT_KEYINPUT, 'a', 0);

To insert footnotes, UNO commands are used.

dispatchCommand(mxComponent, ".uno:InsertFootnote", {});

Just doing the same steps would be enough, as if the crash happens with the fix in place, or in a bad commit in the future, the test would fail. This test failure will prevent the same problem in the future.

The nice thing is that it turned out the same test could have been written using C++ and CppUnitTest, which is considered superior.

The new CppUnitTest can be found in the below change:

The new test resides in sw/qa/extras/uiwriter/uiwriter3.cxx, and essentially uses postKeyEvent and dispatchCommand as similar functions.

If you look at the current version of the test, you can see that it was simplified in later commits, but the idea is the same: “repeat the same steps that lead to crash in the code”.

Final Words

It is expected that every bug fix is accompanied with a test, to avoid seeing the same problem in the future

11 April, 2024


General Activities

  1. LibreOffice 7.6.6 and LibreOffice 24.2.2 were released on March 28
  2. Olivier Hallot (TDF) renamed Fontwork to Text along Path in the UI while updating Help, added Help content for ExportAsFixedFormat VBA method and new Calc functions FILTER, SORT and SORTBY and did several cleanups and fixes in Help
  3. Rafael Lima made several improvements to Calc’s Solver dialog, improved the visual consistency of the Tabbed UI and added a warning about the need to reload file after changing macro security level
  4. Stéphane Guillou (TDF) updated Help content after UI changes and improved the Help page for macro security
  5. Alain Romedenne made many improvements to the officehelper Python script for connecting to LibreOffice processes
  6. Dione Maddern rewrote the Help page for Calc’s SUMIF function, updated Help for Writer’s View options and did cleanups in Help
  7. Gábor Kelemen (allotropia) did many cleanups in the area of includes while improving the script for finding unneeded includes. He also made some Help fixes
  8. Pierre F. made many improvements and fixes to Help pages, for example in the areas of regular expressions and Basic
  9. Andras Timar (Collabora) made Help build more robust on Windows and made some cleanups in Help regarding translatable strings
  10. Laurent Balland updated Grey Elegant Impress template
  11. Miklós Vajna (Collabora) improved copying and pasting between Google Sheets and Calc and did many code cleanups and improvements to automated tests
  12. Áron Budea, Marco Cecchetti, Gökay Şatır, Pranam Lashkari, Jaume Pujantell and Michael Meeks (Collabora) worked on LOKit used by Collabora Online
  13. Gülşah Köse (Collabora) made it so pressing Enter in an empty list item ends the list in Impress
  14. Attila Szűcs (Collabora) improved the performance of handling transparent animated GIFs and made it so image placeholders imported from PPTX files do not display text
  15. Tomaž Vajngerl (Collabora) did many code cleanups in graphics code
  16. Julien Nabet fixed incorrect display of custom page numbers in Sidebar, fixed an issue with duplicating a sheet in Calc causing unwanted axis label to appear in charts and fixed some crashes
  17. Andreas Heinisch fixed an issue with saving print ranges to XLS files
  18. Xisco Faulí (TDF) made a dozen additions and changes to automated tests and added a script to replace missing fonts in test documents. He also improved SVG support by implementing overflow:visible, switch element and the filters feMerge, feMergeNode, feBlend and feComposite.
  19. Michael Stahl (allotropia) made the Curl-based WebDAV content provider more robust
  20. Mike Kaganski (Collabora) fixed issues with copying and pasting charts in Calc, fixed an issue causing incorrect closing tags in Writer HTML export, fixed an issue affecting conditional formatting in overlapping cell ranges, made canceling out of Insert Chart dialog more robust in case of multiple views, fixed an issue with picking a connection type in Database Wizard, fixed an issue in the UNO API implementation for text ranges, harmonised the rounding in Calc’s number formatter and ROUND function and made it so index

04 April, 2024


Calc now supports much better copy&paste when you transfer data between Google Sheets and Calc.

This work is primarily for Collabora Online, but the feature is fully available in desktop Calc as well.


First, Collabora Online was using the deprecated document.execCommand() API to paste text, which is problematic, as the "paste" button on the toolbar can't behave the same way as pressing Ctrl-V on the keyboard.

Second, it turns out Google Sheets came up with some additional HTML attributes to represent spreadsheet data in HTML in a much better way, and Calc HTML import/export had no support for this, while this is all fixable.

Results so far

In short, Collabora Online now uses the Clipboard API to read from the system clipboard -- this has to be supported by the integration, and Calc's HTML filter now support the subset of the Google Sheets markup I figured out so far. This subset is also documented.

Note that the default behavior is that the new Clipboard API is available in Chrome/Safari, but not in Firefox.

For the longer version, here are some screenshots:

We used to show a popup when you clicked on the paste button on the notebookbar

The new paste code in action, handling an image

Import from Google Sheets to Calc: text is auto-converted to a number, bad

Import from Google Sheets to Calc: text is no longer auto-converted to a number, good

HTML import into an active cell edit, only RTF was working there previously

Paste from Google Sheets to Calc: text is no longer auto-converted to a number, good

Paste from Google Sheets to Calc: booleans are now also preserved

Paste from Google Sheets to Calc: number formats are now also preserved

Paste from Google Sheets to Calc: formulas are now also preserved

Paste from Google Sheets to Calc: also handling a single cell

Copy from Calc to Google Sheets: text is now handled, no longer auto-converted to a number

Copy from Calc to Google Sheets: booleans are now handled

Cross-origin iframes also block clipboard access, now fixed

Copy from Calc to Google Sheets: number formats are now also preserved

Copy from Calc to Google Sheets: formulas are now also preserved

Copy from COOL Writer to a text editor: much better result, new one on the right hand side

How is this implemented?

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:

18 March, 2024


One of the areas that can help LibreOffice, but may not directly be visible to the users even though it has a big impact is the quality assurance, is automated testing.  Here, I discuss some areas and notes around improving tests for LibreOffice. First, I start with regressions and bug fixes without a test.

Missing Unit Tests

This is the description from the GSoC ideas page:

While there are some automated tests for LibreOffice, there are not nearly enough. Adding more and better tests helps developers who work on the code to be more productive by allowing them to find regressions as early as possible.

To elaborate more, I should say there are many regressions and bugs in general that are fixed, but lack testing. It is important to have tests for those bug fixes, to avoid such problems in the future. You can see a list of those fixed issues that lack tests here:

If you want to add some new tests for the bug fixes, first you should read the bug report very carefully to understand what is it about, and try to test the fix yourself. You can either use git revert command to revert the fix, and see the problem in action, or try changing back the fix in the code, if it is not too big.

That is important, because you have to see that the test fails without the fix in place, but succeeds when it is applied. This is an essential step when writing the test.

To know more about unit tests, you may look into these Wiki pages:

Porting Existing Test to C++ or Python

Some tests are written in the past, but now have issues because of the way they are written. In this case, porting them can provide improvement.

Tests can be written in multiple languages. At least, C++, Python, Java and BASIC are currently in use for different tests across the LibreOffice code base. Again in the GSoC ideas page, you can read:

There is some support in LibreOffice for automated tests, both at the level of unit tests, and at the level of system tests that drive a full LibreOffice instance. Currently tests can be written in C++, Java, or Python. Various new automated tests should be developed to improve the test coverage.

Tests written exclusively for Java (e.g. the JUnit framework) should be ported to C++ so that they can execute much more rapidly. Similarly, tests that do remote control of an existing LibreOffice instance, should be re-factored to run inside that instance to make debugging much easier.

Almost all JUnitTests and UITests, and also some smoke tests, run as an outside process. To verify, the trick is to remove the soffice(.exe) binary, or to remove its execute permission (on Linux). In this way, out-of-process tests should fail, as they need to run the soffice binary. After a

11 March, 2024


General Activities

  1. LibreOffice 7.6.5 was released on February 22
  2. LibreOffice 24.2.1 was released on February 29
  3. Olivier Hallot (TDF) added help content for Calc’s XLOOKUP and XMATCH functions, Navigate By in Find toolbar, Draw’s Shrink text on overflow and did many fixed and cleanups in Help
  4. Rafael Lima made it so selected text in the BASIC editor is automatically inserted into the search bar, added a command for toggling code block commenting in BASIC IDE and fixed an issue where Duplicate Sheet command might create the sheet in the wrong file, if having two open files with the same name
  5. Stanislav Horacek updated command paths in Help
  6. Stéphane Guillou (TDF) updated command paths in Help
  7. Alain Romedenne updated ScriptForge Help pages, updated Python shell script Help for macOS and improved Python example in SDK
  8. Dione Maddern did many fixes and updates to Help pages, mostly fixing links
  9. Gábor Kelemen (allotropia) made some cleanups in Help and in UI and UNO bridges code
  10. Laurent Balland fixed an issue with skip empty cells option not working for the last column in Calc Text Import dialog, made it so custom number formats using the ? character replace trailing zeroes with figure spaces which have a width approximating a digit and removed unneeded thumbnail.png images from Wizard templates
  11. Miklós Vajna (Collabora) added legal numbering support for DOC and RTF files, made Calc HTML import support data-sheets attributes, made Calc’s cell editing accept pasted HTML fragments, made DOCX content control handling more robust and continued polishing floating table support
  12. Szymon Kłos, Gülşah Köse, Marco Cecchetti, Gökay Şatır, Pranam Lashkari, Michael Meeks and Méven Car (Collabora) worked on LOKit used by Collabora Online
  13. Attila Szűcs (Collabora) fixed PPTX issues with multiline field wrapping and stacked text
  14. Henry Castro (Collabora) tweaked Calc’s background colour filter to not extend transparent colours to empty cells and fixed an issue with Sidebar not displaying the full localised currency string for cell properties
  15. Tomaž Vajngerl (Collabora) made it so the currencies used in a spreadsheet are put at the top of the currency pop-up list, made pivot table data cache handling smarter and improved the handling of XLS documents with unknown DRM encryption (mainly due to some Excel addons)
  16. Julien Nabet fixed an issue where Data validation without error check allowed entering incorrect data, fixed LOWER not being supported in Base’s Query-GUI if condition was LIKE and fixed an issue with Calc Macro setting SearchWildcard to False changing SearchRegularExpression value. He also fixed some crashes
  17. Andreas Heinisch made Calc’s Autofilter sorting and removing duplicates more robust and made it so a single click is enough to access options through Calc’s status bar
  18. Xisco Faulí (TDF) made over a dozen additions and changes to automated tests, improved dark mode support of Writer comment UI, fixed an issue with Autofilter empty option, made SVG text baseline handling more intuitive, added support

01 March, 2024


Writer now supports legal numbering for two more formats: DOC and RTF (ODT and DOCX were working already.)

This work is primarily for Collabora Online, done as a HackWeek project, but the feature is fully available in desktop Writer as well.


Legal numbering is a way to influence the number format of values inherited in a multi-level numbering. Say, the outer numbering uses Roman numerals and the inner numbering uses X.Y as the number format, but the inner level wants to display the outer values as Arabic numerals. If this is wanted (and guessing from the name, sometimes lawyers do want this), then the inner number portion will expand to values like "2.01" instead of "II.01", while the outer number portions will remain values like "II".

Mike did 80% of the work, what you can see here is just the RTF/DOC filters.

Picking a smaller feature task like this looked like a good idea, since I wanted to spend some of the time on regression fixing around last year's multi-page floating table project.

Results so far

For (binary) DOC, the relevant detail is the fLegal bit in the LVLF structure. Here is the result:

Improved handling of legal numbering from DOC: old, new and reference rendering

It shows how the outer "II" gets turned into "2", while it remained "II" in the past. This works for both loading and saving.

The same feature is now handled in the RTF filter as well. There the relevant detail is the \levellegal control word, which has an odd 1 default value (the default is usually 0). Here is the result:

Improved handling of legal numbering from RTF: old, new and reference rendering

It shows that the RTF filter is up to speed with the DOC one by now.

As for the multi-page floating tables, I looked at tdf#158986 and tdf#158801.

How is this implemented?

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:

Want to start using this?

You can get a snapshot / demo of Collabora Office 24.04 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 (24.8).

29 February, 2024


If you copy contents from LibreOffice Writer to a plain text editor like gedit or Notepad, you will see that it does a straightforward thing: It copies the text and some basic formatting like converting bullets to ‘•’. For the Writer tables, the conversion is very simple right now: every cell is written in a separate line.

For example, if you have a table like this:

A | B
C | D

When you copy the table from LibreOffice Writer and paste it into a plain text editor, it will become something like this, which is not always desirable.


It is requested that like LibreOffice Calc, or Microsoft Word, and many other programs, the copy/paste mechanism should create a text like this:


The columns are separated by <tab>.

This feature request is filed in Bugzilla as tdf#144576:

Code pointers for Handling Writer tables

There are many steps in copy/pasting, including the data/format conversion and clipboard format handling. Here, you have to know that the document is converted to plain text via “text” filter.

The plaintext (ASCII) filter is located here in the LibreOffice core source code:

Therefore, to change the copy/paste output, you have to fix the ASCII filter. That would also provide the benefit that plain text export will be also fixed as requested here.

In this folder, there are a few files:

$ ls sw/source/filter/ascii/
ascatr.cxx parasc.cxx wrtasc.cxx wrtasc.hxx

To change the output, you have to edit this file:

In this file, there is a loop dedicated to create the output.

// Output all areas of the pam into the ASC file
do {
    bool bTstFly = true;

Inside this loop, the code iterates over the nodes inside the document structure, and extracts text from them. To check for yourself, add the one line below to the code, build LibreOffice, and then test. You will see that a * is appended before each node.

SwTextNode* pNd = m_pCurrentPam->GetPoint()->GetNode().GetTextNode();
if( pNd )
+   Strm().WriteUChar('*');

For example, having this table, with 1 blank paragraph up and down:

A | B
C | D

You will get this after copy/paste into a plain text editor:


To fix the bug, you have to differentiate between table cells and other nodes. Then, you should take care of the table columns and print tab between them.

To go further, you can only add star before table cells:

if( pNd )
    SwTableNode *pTableNd = pNd->FindTableNode();
+   if (pTableNd)
+   {
+       Strm().WriteUChar('*');
+    }

You can look into how other filters handled tables. For example, inside sw/source/filter/html/htmltab.cxx you will see how table is managed, first cell is tracked and appropriate functions to handle HTML table are called.

For the merged cells, the EasyHacker should first checks the behavior in

22 February, 2024


When working with LibreOffice Impress, “Slide Master” is the place where you can change the templates used for different types of the slides used in your presentation. Here we discuss a possible improvement for the “Slide Master” by making the copy from master slides possible.

Copying the Master Page in Impress

To see the problem and the room for enhancement, open LibreOffice Impress, then choose “View->Master->Slide Master” from the menus. Then, try to copy the master page on the left in the slide sorter. Unfortunately, it is not possible.

Impress slide master

Impress slide master

Having this feature is helpful, because different page types have many things in common, and being able to copy/paste helps creating templates much faster.

Impress Code Pointers

Looking into sd/source/core/drawdoc3.cxx, you can see a huge function SdDrawDocument::InsertBookmarkAsPage, which is relevant here. It contains ~600 lines of code. This huge function is in itself a problem. Therefore, to implement the enhancement, on should try to first refactor the function, then add a unit test in sd/qa/unit, find and then separate all the ~6 use cases, and fix the style/name merging.

After the cleanup, the main fix should be implemented. The suggested path to implement this comes from Jean-Francois. He suggest to improve the duplicate() method, which is described in the documentation:

As described in the above documentation, its role is to duplicate a page:

Creates a duplicate of a DrawPage or MasterPage, including the Shapes on that page and inserts it into the same model.

However, the implementation does not work for master slides, as the macros in the attachment file implies. The solution should add the needed implementation for master slides.

The implementation is inside sd/source/ui/unoidl/unomodel.cxx inside duplicate function:

// XDrawPageDuplicator
uno::Reference< drawing::XDrawPage > SAL_CALL SdXImpressDocument::duplicate( const uno::Reference< drawing::XDrawPage >& xPage )



Final Words

The above issue is filed as tdf#45617. If you like to work on it, just follow the Bugzilla link to see more information.

To implement this feature, first you have to build LibreOffice from the sources. If you have not done that yet, please refer to this guide first:

Getting Started (Video Tutorial)

13 February, 2024


General Activities

  1. LibreOffice 24.2 was released on January, 31
  2. Olivier Hallot (TDF) fixed a duplicate Covariance command in Notebookbar UIs, updated menu item paths in Help pages and updated Help pages for conversion filters and style Spotlight
  3. Rafael Lima added a Color Scheme switcher to Basic IDE, added a “Delete Comment” command to the Navigator context menu, fixed drawing comment triangles in Calc at all zoom levels, made it so the visibility of UI components in the Basic IDE is remembered, made Basic IDE highlight the line where the cursor is positioned, made it possible to open the “Go to Line” dialog from the statusbar in Basic IDE, fixed Calc AutoFilter arrow color in dark mode, made it so line numbering and breakpoint in Basic IDE are on the left even in right-to-left UI and fixed a crash in Dialog Editor. He also improved the ScriptForge Help pages
  4. Stanislav Horacek updated menu paths in Help alongside other cleanups and fixes
  5. Ilmari Lauhakangas (TDF) removed unnecessary images from SVG icon themes, saving nearly 5 MB of space. He also changed the Help CSS to account for a quirk in Safari
  6. Stéphane Guillou (TDF) continued linking Sidebar decks to Help
  7. Alain Romedenne updated ScriptForge Help pages
  8. Dione Maddern did many fixes and updates to Draw dialog Help pages
  9. Gábor Kelemen (allotropia) added accessible descriptions to new Dublin Core metadata boxes, updated Help after removal of FTP protocol support and did code cleanups in the area of code simplification and includes
  10. Laurent Balland did cleanups in the metadata of Impress templates
  11. Miklós Vajna (Collabora) fixed the layout handling of empty paragraphs formatted as superscript in Writer, added support for HTML paste to Writer shape text or Calc cell text edit and continued polishing support for multi-page floating tables in Writer
  12. Jean-Pierre Ledure worked on the ScriptForge library
  13. Gabriel Masei (1&1), Paris Oplopoios, Szymon Kłos, Méven Car, Andras Timar, Attila Szűcs and Áron Budea (Collabora) worked on LOKit used by Collabora Online. Andras also fixed some FreeBSD build issues while Attila fixed hyperlink colouring in certain PPTX files and a textbox vertical alignment inversion issue when saving PPTX files
  14. Henry Castro (Collabora) made the status bar in Calc work as expected with language selection
  15. Eike Rathke (Red Hat) made it so the maximum number of hours that can be entered into a Calc cell with time formatting is now a 32-bit integer instead of 65535
  16. Tomaž Vajngerl (Collabora) continued refactoring the EditEngine text editing code
  17. Julien Nabet fixed an issue preventing some position parameters to go beyond 17 mm in Writer, fixed an issue that made ReportBuilder wizards show two different data sources, fixed several crashes and did code cleanups
  18. Andreas Heinisch made it so font, highlight and background colour in toolbar buttons is remembered between sessions, fixed canceling Text Import in Calc locking the document and made it so question mark can be used in autotext shortcuts
  19. László Németh continued polishing support for

11 February, 2024


After a long slog since November when the previous version of coverity was EOLed and we had to start using 2022.6.0 with its new suggestions for std::move etc, LibreOffice is now finally back to a 0 warnings coverity state

06 February, 2024


This post describes some challenges around having multiple views of one opened document in LibreOffice core, when those views belong to LOK views, representing different users, with their own language, locale and other view settings.

This work is primarily for Collabora Online, but is useful for all clients of the LOK API.


LOK views are meant to represent separate users, so we need to make sure that when a user sets their preferences and trigger an action, then the response to that action goes to the correct view, with the correct view settings.

This is different from the desktop LibreOffice use-case, where multiple windows are still meant to share the same user name, language, undo stack and so on.

Results so far

In this post, I would like to present 4 small improvements that recently happened to the LOK API to provide this wanted separation of views.

The first was an issue where two users were editing the same document, one busily typing and the other clicked on a link in Calc. What could happen sometimes is the link popup appeared for the user who typed, not for the user who clicked on the link:

Link popup is actually on the left, should be on the right, now fixed

This specific problem can be fixed by making sure that link click callbacks are invoked synchronously (while the clicking view is still active) and not later, when the current view may or may not be the correct one.

It turns out the same problem (async command dispatch) affects not only hyperlinks, but many other cases as well, where we want to stay async, for example, when one dialog would invoke another dialog, like the Calc conditional format -> add dialog:

Calc conditional format add dialog appearing on the left, should be on the right, now fixed

There you don't want to change async commands into sync commands, because that may mean spinning the main loop inside a dialog, resulting in nested main loops. This can be fixed by making sure that async commands to be dispatched (sfx2 hints in general) are processed in a way that the current view at dispatch & processing is the same, which is now the case.

The third problem was around wrong language & locale in the status bar:

Unexpected English strings in localized statubar UI, now fixed

This is not simply a problem of missing translation, the trouble was that the status bar update is also async and by the time the update happened, the locale of the view on the left was used, for a string that appears on the right.

The way to fix this is to perform the update of toolbars/statusbar/etc (in general: SfxBindings) in a way that the language at job schedule time and at UI string creation time is the same.

The last problem was quite similar, still about bad language on the UI, but this time on the sidebar:

Unexpected English strings in localized sidebar UI, now fixed

04 February, 2024


In this blog post, I discuss gbuild for Java tests. The goal is to write a Makefile to compile and run a JUnit test for LibreOffice. You can also refer to part 1 and part 2 for a brif overiew on gbuild, the LibreOffice build system.

Macro Examples from gbuild for Java Tests

In the first post on gbuild, I have mentioned some macro examples including gb_Output_announce which was used to print nice messages like the ones including “[CXX]”. Now let’s explain some more macros related to Java tests.

Consider that you want to compile and run a JUnitTest. To do that, you need to write the test in a Java file, and create a Makefile to run that.

This is an example for running a test defined in Java file sw/qa/complex/indeterminateState/CheckIndeterminateState.java.

$(eval $(call gb_JunitTest_JunitTest,sw_complex))

$(eval $(call gb_JunitTest_add_sourcefiles,sw_complex,\
sw/qa/complex/indeterminateState/CheckIndeterminateState \

$(eval $(call gb_JunitTest_use_unoapi_jars,sw_complex))

$(eval $(call gb_JunitTest_add_classes,sw_complex,\
complex.indeterminateState.CheckIndeterminateState \

The make file for running this Java test consists of calling multiple macros. It starts with gb_JunitTest_JunitTest macro, which defines the test by its name, sw_complex. This macro is defined in solenv/gbuild/JunitTest.mk. If you grep for define in the same file, you will see this result:

$ grep -w define solenv/gbuild/JunitTest.mk
define gb_JunitTest_JunitTest
define gb_JunitTest_set_defs
define gb_JunitTest_add_classes
define gb_JunitTest_add_class
define gb_JunitTest_add_sourcefile
define gb_JunitTest_add_sourcefiles
define gb_JunitTest_use_jar
define gb_JunitTest_use_jars
define gb_JunitTest_use_jar_classset
define gb_JunitTest_add_classpath
define gb_JunitTest_use_system_jar
define gb_JunitTest_use_system_jars
define gb_JunitTest_use_external
define gb_JunitTest_use_externals
define gb_JunitTest_use_customtarget
define gb_JunitTest_use_customtargets
define gb_JunitTest_use_unoapi_jars
define gb_JunitTest_use_unoapi_test_class
define gb_JunitTest_set_unoapi_test_defaults
define gb_JunitTest_JunitTest

To stick to the macros used in the above example, I describe these macros:

gb_JunitTest_add_sourcefiles: This macro adds a Java source file to the test. It defines the code that adds the sw/qa/complex/indeterminateState/CheckIndeterminateState.java to the test. But please note that you should drop the .java extension:

$(eval $(call gb_JunitTest_add_sourcefiles,sw_complex,\
sw/qa/complex/indeterminateState/CheckIndeterminateState \

The other macro gb_JunitTest_use_unoapi_jars, adds the UNO API JAR files to be used with the test.

And in the end, you need to add the test class name using gb_JunitTest_add_classes macro. The class name is visible in the end.

The result can be quite complex, but it works. 🙂

java.exe -Xmx64M -classpath "$W/JavaClassSet/JunitTest/sw_complex;C:/cygwin64/home/user/lode/opt/share/java/junit.jar;$I/program;$W/Jar/OOoRunner.jar;$I/program/classes/libreoffice.jar;$W/Jar/test.jar" -Dorg.openoffice.test.arg.soffice="path:$I/program/soffice" -Dorg.openoffice.test.arg.env=PATH="$PATH" -Dorg.openoffice.test.arg.user=file:///$W/JunitTest/sw_complex/user org.junit.runner.JUnitCore complex.indeterminateState.CheckIndeterminateState

The above is the actual command that runs the test. Please note that if you forget the gb_JunitTest_add_classes macro to define the class name, the test may compile, but it will not run.

As an example, you can see the below patch. This patch fixes the problem of the JUnit test not running:

Final Words

Many macros are available in gbuild, making easier

25 January, 2024


In the first blog post on LibreOffice build system, gbuild which uses GNU Make, I discussed some of the features of it. Here I discuss more about some gbuild tips and tricks that you may need.

Building a Single Module

In order to build a single module, you need to use its name. For example, to build only “odk”, which contains office development kit, you only have to type:

make odk

On the other hand, there are many other build targets associated with odk. By typing make odk, and then pressing tab, you will see this list, which shows possible targets:

odk odk.buildall odk.perfcheck odk.uicheck odk.all odk.check odk.screenshot odk.unitcheck odk.allbuild odk.checkall odk.showdeliverables odk.allcheck odk.clean odk.slowcheck odk.build odk.coverage odk.subsequentcheck

Each of the above is related to a specific task, in which many of them are common on different modules. Let’s discuss some of them:

make odk -> Builds odk module.

make odk.clean -> Cleans the odk module, removing the generated files.

make odk.check -> Runs test in odk module

make odk.uicheck -> It runs UI tests inside odk module

make odk.perfchek -> Runs performance/callgrind tests inside odk module

make odk.screenshot -> Creates screenshots inside odk module

To get a complete list and detailed description, run make help.

Handling Incomplete Builds

Sometimes because of OS crash or power outage, you may face problems when a build is stopped forcefully. In that case, you may see several zero byte object (*.o) files that exist, and prevent a successful build. In that case, you can find and remove them using this command:

$ rm `find -name *.o -size 0`

After that, you can retry your build without the above problem.

Customizing Build Configuration

The process of creating Makefile starts from configuring LibreOffice for build. This is done by invoking ./autogen.sh. The configuration parameters are read from autogen.input. The build configuration is done via configure.ac, which is an input for GNU autoconf.

There are various steps before the Makefiles are generated. For example, in order to make sure that a library is there when configuring the build, a very small C/C++ file is created, compiled and tested to ensure that the library is ready, and available to use with C/C++ code.

It is also possible to check for some specific version of library, and available functions. As an example, see this patch, which checks for specific version of ZXing library:

In the above example, multiple situations are handled:

1) When there is no ZXing library

2) When system ZXing library is used

And also, it is checked that specific version of ZXing is available:

1) When ZXing::ToSVG is not usable

2) When ZXing::ToSVG is usable

Then, the HAVE_ZXING_TOSVG symbolic constant is used in config_host/config_zxing.h.in, which can be used in C++ code.

Knowing More About gbuild

If you are interested in knowing more about


Firebird Project is happy to announce general availability of Firebird 5.0 — the latest major release of the Firebird relational database for Windows, Linux, MacOS and Android platforms.This release introduces improvements in areas of performance, multithreaded processing (including backup, restore, sweep), SQL queries profiling, with better scalability and numerous enhancements in SQL

16 January, 2024


LibreOffice 24.2 – with a new year.month versioning scheme – will be released as final at the beginning of February, 2024 ( Check the Release Plan ) being LibreOffice 24.2 Release Candidate 2 (RC2) the forth pre-release since the development of version 24.2 started in mid June, 2023. Since the previous release, LibreOffice 24.2 RC1, 113 commits have been submitted to the code repository and 61 issues got fixed. Check the release notes to find the new features included in this version of LibreOffice.

LibreOffice 24.2 RC2 can be downloaded for Linux, macOS and Windows, and it will replace the standard installation.

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!!

Download it now!

12 January, 2024


Using comments is a key feature in text processing. A typical workflow might be to review a document where notes are made by different colleagues. LibreOffice Writer currently shows these comments in the document margin, which is limited to the page height, ending up in the need to scroll long text (even while editing [1]) and eventually in paging-like interactions if the number of comments exceed the total size.…

03 January, 2024


Now that year 2024 has come, I want to briefly discuss the year 2023 around the development blog, and the outlook for 2024 here.

My goal is to help people understand LibreOffice code better, and ultimately get involved in LibreOffice core development to make LibreOffice better for everyone. In 2023, I wrote 23 posts around LibreOffice development in the dev blog (3 of them are unpublished drafts).

At The Document Foundation (TDF), our aim is to improve LibreOffice, the leading free/open source office software that you and many other people around the world use. Our work is community-driven, and we need your help.

LibreOffice conference 2023

LibreOffice conference 2023

Outlook For the New Year

My focus for 2024 in this blog will be:

  1. Introducing new EasyHacks
  2. Discussing how to fix crashes
  3. Explaining LibreOffice architecture
  4. Describing user interface creation with VCL
  5. Explaining LibreOffice extensions

You can give feedback by writing a comment here, or sending an email to hossein AT libreoffice DOT org.

I provide mentoring support to those who want to start LibreOffice development. You are welcome to contact me if you need help to build LibreOffice and do some EasyHacks via the above email address.

I hope the best for you in the new year 2024.


This post is part of a series to describe how Writer now gets a feature 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. See the 10th post for the previous part.


Previous posts described the hardest part of multi-page floating tables: making sure that text can wrap around them and they can split across pages. In this part, we'll look at a case where that content is not just text, but the wrapping content itself is also a table.

Results so far

Regarding testing of the floating table feature in general, the core.git repository has 92 files now which are focusing on correct handling of floating tables (filenames matching floattable-|floating-table-). This doesn't count cases where the document model is built using C++ code in the memory and then we assert the result of some operation.

Here are some screenshots from the improvements this month:

Improved click handling near the first page of a floating table

The first screenshot shows a situation where the mouse cursor is near the right edge of the first page of a floating table. What used to happen is we found this position close to the invisible anchor of the floating table on that page, then corrected this position to be at the real anchor on the last page. In short, the user clicked on one page and we jumped to the last page. This is now fixed, we notice that part of the floating table is close to the click position and we correct the cursor to be at the closest position inside the table's content.

A floating table, wrapped by an inline table: old, new and reference rendering

The next screenshot shows a floating table where the content wrapping around the table happens to be an inline table. You can see how such wrapping didn't happen in the past, and the new rendering is close to the reference now.

How is this implemented?

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:

Want to start using this?

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

<- Current blog entries