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.


Saturday
07 February, 2026


face


Z veseljem najavljamo izdajo LibreOffice 26.2, najnovejše različice prostega in odprto-kodnega pisarniškega paketa, ki mu zaupajo milijoni uporabnikov po vsem svetu. Ta izdaja uporabnikom omogoča lažje ustvarjanje kot kdaj koli prej ter urejanje in deljenje dokumentov po lastnih željah. Razvit je bil za posameznike in organizacije ter ostaja zaupanja vredna alternativa lastniški pisarniški programski opremi.

LibreOffice 26.2 se osredotoča na izboljšave, ki pomembno vplivajo na vsakodnevno delo in prinašajo boljšo zmogljivost, bolj tekoče delovanje s kompleksnimi dokumenti in izboljšano združljivost z vsemi datotekami, ustvarjenimi v drugih pisarniških paketih. Ne glede na to, ali pišete poročila, upravljate s preglednicami ali pripravljate predstavitve, je delo bolj odzivno in zanesljivo.

LibreOffice je vedno omogočal uporabnikom nadzor. LibreOffice 26.2 nadaljuje to tradicijo s krepitvijo podpore za odprte standarde za dokumente in zagotavljanjem dolgoročnega dostopa do vaših datotek brez naročnin, licenčnih omejitev ali zbiranja podatkov. Vaši dokumenti ostanejo vaši, za vedno.

Za to izdajo stoji svetovna skupnost sodelavcev. Razvijalci, oblikovalci, prevajalci, preizkuševalci kakovosti in prostovoljci iz vsega sveta so sodelovali pri pripravi več sto popravkov in izboljšav. Rezultat njihovih prizadevanj je paket, ki ne le dodaja nove funkcije, ampak iz izdaje v izdajo izboljšuje tudi kakovost, doslednost in stabilnost.

Kaj je novega v LibreOffice 26.2

  • Izboljšana zmogljivost in odzivnost celotnega paketa, ki omogoča lažje odpiranje, urejanje in shranjevanje velikih dokumentov.
  • Izboljšana združljivost z dokumenti, ustvarjenimi z lastniškimi in odprtimi pisarniškimi paketi, kar zmanjšuje težave z oblikovanjem in neprijetna presenečenja.
  • Izboljšano delovanje uporabniškega vmesnika za bolj pregledno in dosledno uporabniško izkušnjo.
  • Razširjena podpora odprtim standardom, ki krepi dolgoročni dostop do dokumentov.
  • Na stotine popravkov napak in izboljšav stabilnosti, ki jih je prispevala globalna skupnost LibreOffice.
Glejte opombe ob izdaji, kjer se nahaja celoten seznam vseh novosti.

»LibreOffice 26.2 kaže, kaj se zgodi, ko je programska oprema zasnovana na uporabnikih in ne na poslovnih modelih, ter kako lahko odprto-kodna programska oprema ponudi sodoben, izpopolnjen pisarniški paket, ne da bi pri tem ogrožala svobodo uporabnikov,« je dejal Florian Effenberger, izvršni direktor The Document Foundation. »Ta izdaja je namenjena hitrosti, zanesljivosti in omogočanju nadzora uporabnikom nad svojimi dokumenti.«

LibreOffice 26.2 je na voljo za operacijske sisteme Windows, macOS in Linux ter podpira več kot 120 jezikov. Uporabljate ga lahko doma, v podjetjih, šolah in javnih ustanovah, brez licenčnin in vezave na enega ponudnika.

LibreOffice 26.2 lahko prenesete danes z uradne spletne strani LibreOffice. Vabimo uporabnike, da preizkusijo novo različico, delijo svoje mnenje in se pridružijo skupnosti, ki pomaga oblikovati prihodnost LibreOffice. Če so zadovoljni, lahko s svojim prispevkom podprejo neodvisnost in prihodnji razvoj projekta.


O LibreOffice in The Document Foundation



LibreOffice je prost pisarniški paket z odprto-kodno kodo, ki ga uporabljajo milijoni ljudi, podjetij

face

Not too long ago, a change landed, that brought Biff12 clipboard format support in Calc v.26.2 – thanks Laurent!

It was an easyhack that I authored some time ago; and Laurent volunteered to implement that long-standing missing feature. The small detail was, that the feature was Windows-specific (it is trivial to get the wanted clipboard content there, simply copying from Excel), while Laurent developed on another platform.

Laurent had made the majority of work, before he was stuck, without being able to test / debug further changes. Then, he asked me, if there a way to continue on the platform he used.

At that time, I answered, that no, one would need Windows (and Excel) to continue the implementation. So I jumped in, and added the rest, and in the end, we have created the change in co-authorship.

But later, when part of my code turned out problematic, and I needed to fix it and create a unit test for it, I discovered a trick, that could put Biff12 data into system clipboard on any platform, without Excel – allowing then just paste, and debug everything that’s going on there. It relies on UNO API, and can be implemented e.g. in Basic:


function XTransferable_getTransferData(aFlavor as com.sun.star.datatransfer.DataFlavor) as variant
  if (not XTransferable_isDataFlavorSupported(aFlavor)) then exit function
  oUcb = CreateUnoService("com.sun.star.ucb.SimpleFileAccess")
  oFile = oUcb.openFileRead(ConvertToURL("/path/to/biff12.clipboard.xlsb"))
  dim sequence() as byte
  oFile.readBytes(sequence, oFile.available()) ' changes value type of 'sequence' to integer
  XTransferable_getTransferData = CreateUnoValue("[]byte", sequence)
end function

function XTransferable_getTransferDataFlavors() as variant
  aFlavor = new com.sun.star.datatransfer.DataFlavor
  aFlavor.MimeType = "application/x-openoffice-biff-12;windows_formatname=""Biff12"""
  XTransferable_getTransferDataFlavors = array(aFlavor)
end function

function XTransferable_isDataFlavorSupported(aFlavor as com.sun.star.datatransfer.DataFlavor) as boolean
  XTransferable_isDataFlavorSupported = (aFlavor.MimeType = "application/x-openoffice-biff-12;windows_formatname=""Biff12""")
end function

sub setClipboardContent
  oClip = CreateUNOService("com.sun.star.datatransfer.clipboard.SystemClipboard")
  oClip.setContents(CreateUNOListener("XTransferable_", "com.sun.star.datatransfer.XTransferable"), nothing)
end sub

The first three functions are Basic implementation of XTransferable interface.

Running setClipboardContent will prepare the system clipboard on any platform, using a trick of implementing arbitrary UNO interface using CreateUNOListener; and after that, pasting into Calc would allow to see if things work (if content of /path/to/biff12.clipboard.xlsb is pasted, as expected), and make improvements. If I knew this trick back then, I would of course share it with Laurent; but I thought I’d put it here now, so maybe it helps me or someone else in the future. (Note that application/x-openoffice-biff-12;windows_formatname="Biff12" there in the code was the name introduced by Laurent in the discussed commit; indeed, that, and the actual data in the file, would depend on the exact format that you work with.)


Wednesday
04 February, 2026


face

If you have a commented text range, which gets deleted while track changes is on and you later save and load this with Writer's DOCX filter, that works now correctly.

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

Motivation

It was already possible to comment on text ranges. Comments were also supported inside deletes when track changes is enabled. These could be already exported to and imported from DOCX in Writer. But you could not combine these.

With the increasing popularity of commenting text ranges (rather than just inserting a comment with an anchor), not being able to combine these was annoying.

Results so far

Here is how a commented text range inside a delete from DOCX now looks like, note the semi-transparent comment hinting it's deleted:

Commented text range, inside a tracked delete, in DOCX, Collabora Online

As a side effect, this also fixes the behavior in desktop Writer, which crosses out deleted comments:

Commented text range, inside a tracked delete, in DOCX, desktop

In the past, the "is this deleted" property was not visible in the render result:

Commented text range, inside a tracked delete, in DOCX, Collabora Online, old bad state

And it was also bad in desktop Writer:

Commented text range, inside a tracked delete, in DOCX, desktop, old bad state

This required changes to both DOCX import and export: a comment could be deleted or could have an anchor which is a text range, but you couldn't have both.

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. Core side:

Want to start using this?

You can get a development edition of Collabora Online 25.04 and try it out yourself right now: try the development edition. 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 (26.8).


Thursday
22 January, 2026


face

In LibreOffice development, there are many cases where you want to validate some documents against standards: either Open Document Format (ODF) or MS Office Open XML (OOXML). Here I discuss how to do that.

Update: Article updated to reflect that odfvalidator 0.13.0 has just released.

Open Document Format (ODF) Validation

ODF is the native document file format that LibreOffice and many other open source applications use. It is basically set of XML files that are zipped together, and can describe various aspects of the document, from the content itself to the way it should be displayed. These XML files have to conform to ODF standard, which is presented in XML schemas. The latest version of ODF is 1.4, which is yet to be implemented in LibreOffice.

You can find more about ODF in these links:

There are various tools to do the validation, but the preferred one is the ODF Toolkit Validator:

Compiled binaries of ODF Toolkit can be downloaded from the above Github project:

Then, you can use the ODF validator this way:

$ java -jar odfvalidator-0.13.0-jar-with-dependencies.jar test.odt

You may also use the online validator, odfvalidator.org, to do a validation.

odfvalidatorOnline odfvalidator tool

Please read this disclaimer before using:

This service does not cover all conformance criteria of the OpenDocument Format specification. It is not applicable for formal validation proof. Problems reported by this service only indicate that a document may not conform to the specification. It must not be concluded from errors that are reported that the document does not conform to the specification without further investigation of the error report, and it must not be concluded from the absence of error reports that the OpenDocument Format document conforms to the OpenDocument Format specification.

Office Open XML (OOXML) Validation

MS Office Open XML (OOXML) is the native standard for Microsoft documents format. It is also a set of XML files zipped together, and conform to some XML schemas.

You can find out more about OOXML here:

There are tools to do the validation, and the one is used in LibreOffice is Office-o-tron. One can use it with below command to validate an example file, test.docx:

$ java -jar officeotron-0.8.8.jar ~/test.docx

Office-o-tron can be downloaded from dev-www.libreoffice.org server of LibreOffice, and this is currently the latest version:

It is worth noting that Office-o-tron can be also used to validate ODT files.

Extensions to ODF Standard

To go beyond the current ODF standard, new features are sometimes introduced as “ODF extensions”, then are gradually added to the standard. You can read more in TDF Wiki:

In these cases, you may see validation errors for such extensions. For example:

test.odt/styles.xml[2


Tuesday
20 January, 2026


face

LibreOffice 26.2 will be released as final at the beginning of February, 2026 (check the Release Plan). LibreOffice 26.2 Release Candidate 2 (RC2) brings us closer to the final version, which will be preceded by Release Candidate 3 (RC3). Since the previous release, LibreOffice 26.2 RC1, 137 commits have been


Friday
16 January, 2026


face

Happy new year 2026! I hope that this year will be great for you, and the global LibreOffice community, and the software itself! I hereby discuss the past year 2025, and the outlook for 2026 in the development blog.

At The Document Foundation (TDF), our aim is to improve LibreOffice, the leading free/open source office suite that has millions of users around the world. Our work is community-driven, and the software needs your contribution to become better, and work in a way that you like.

My goal here, is to help people understand LibreOffice code easier via EasyHacks and tutorials, and eventually participate in LibreOffice core development to make LibreOffice better for everyone. In 2025, I wrote 14 posts around LibreOffice development in the dev blog (4 of them are unpublished drafts).

Outlook For the New Year

Focus of the development blog for 2026 in this blog will be:

  • Introducing new EasyHacks
    • Using new C++20 constructs
    • Difficulty Interesting EasyHacks
  • Describing user interface creation with VCL
    • VCL weld mechanism
    • Various weld widgets
  • Describing UNO Components

You can provide feedback simply by leaving a comment here, or sending me an email to hossein AT libreoffice DOT org.

We provide mentoring support to the individuals 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. You may also refer to our Getting Involved Wiki page:

Let’s hope a better year for LibreOffice (and the world) in 2026.


Thursday
08 January, 2026


face

General Activities LibreOffice 25.8.4 was announced on December 18 Olivier Hallot (TDF) added a help page for Markdown in Writer, JSON in Calc, updated or improved help for View and Appearance options, accessibility options, sort criteria in Calc, file conversion filters, ODF versions, handling of empty cells in Calc, Data


Monday
05 January, 2026


face

The bullet support in Impress got a couple of improvements recently, some of this is PPTX support and others are general UI improvements.

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

Motivation

Probably the most simple presentations are just a couple of slides, each slide having a title shape and an outliner shape, containing some bullets, perhaps with some additional images. Images are just bitmaps, so let's focus on outliner shapes and their outliner / bullet styles.

What happens if you save these to PPTX and load it back? Can you toggle between a numbering and a bullet? Can you return to an outliner style after you had direct formatting for your bullet?

Results so far

The first case was about bullet editing of this document:

Outliner shape with 3 outliner styles

If you pressed enter at the end of 'First level', then pressed <tab> to promote the current paragraph to the second level, nothing happened. The reason for this was that our PPTX export was missing the list styles of shapes, except for the very first list style. And the same was missing on the import side, too. With this, not only the rendering of the bullets are OK, but also adding new paragraphs and using promoting / demoting to change levels work as expected.

The second case was about this document, where the second level had a numbering, not a bullet:

Outliner shape with a numbering on the second level

We only had UI to first toggle off a numbering to no numbering, then you could toggle on bullets. Now it's possible to do this change in one step.

The last case was about styles. Imagine that you had a master page with an outline shape and some reasonably looking configuration for the first and second levels as outline styles:

Outliner shape with two outline styles

Notice how the last paragraph has a slightly inconsistent formatting, due to direct formatting. Let's fix this.

Go to the end of the last bullet, which is currently not connected to an outline style, toggle bullets off and then toggle it on again. Now we clear direct formatting when we turn off the bullet, so next time you turn bullets on, it'll be again connected to the outline style's bullet configuration and the content will look better.

Note how this even improves consistency: Writer was behaving the same way already, when toggling bullets off and then toggle on again resulted in getting rid of previously applied unwanted direct formatting.

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. Core side:


Friday
19 December, 2025


face

Developers and database administrators often operate under a common assumption: unlocking powerful new software features requires significant, time-consuming, and expensive development work. New capabilities frequently sit on the shelf, waiting for the budget and time to rewrite applications to take advantage of them.This assumption, however, doesn't always hold true. Recent versions of the


Monday
15 December, 2025


face

General Activities LibreOffice 25.8.3 was announced on November 13 Olivier Hallot (TDF) improved the help on sort options and keyboard shortcuts, added help for field variable formats, the Slide Properties Sidebar deck, named Calc formulas and Arabic fonts and right-to-left direction for Math. He also updated help for paragraph alignment


Thursday
11 December, 2025


face

LibreOffice 26.2 will be released as final at the beginning of February, 2026 ( Check the Release Plan ). LibreOffice 26.2 Beta1 is the second pre-release since development of version 26.2 started at the beginning of June, 2025. Since the previous release, LibreOffice 26.2 Alpha1, 419 commits have been submitted


Saturday
06 December, 2025


face

A modern C++ wrapper for the Firebird database API.Documentation | Repositoryfb-cpp provides a clean, modern C++ interface to the Firebird database engine. It wraps the Firebird C++ API with RAII principles, smart pointers, and modern C++ features.Features&nbsp;Modern C++: Uses C++20 features for type safety and performanceRAII: Automatic resource management with smart pointersType Safety:


Thursday
04 December, 2025


face

After submitting a patch to LibreOffice Gerrit, one has to wait for the continuous integration (CI) to build and test the changed source code to make sure that the build is OK and the tests pass successfully. Here we discuss the situation when one or more CI builds fail, and how to handle that.

Why Build and Test on CI?

After you submit code to LibreOffice Gerrit, reviewers have to make sure that it builds, and the tests pass with the new source code. But, it is not possible for the reviewers to test the code on each and every platform that LibreOffice supports. Therefore, Jenkins CI does that job of building and testing LibreOffice on various platforms.

This can take a while, usually 1 hour or so, but sometimes can take longer than that. If everything is OK, then your submission will get     Verified +1    .

CI Platforms for LibreOffice

Currently, these are the platforms used in CI:

  • Linux / GCC:  gerrit_linux_gcc_release
  • Linux / Clang: gerrit_linux_clang_dbgutil
  • Android Viewer: gerrit_android_x86_64 and gerrit_android_arm
  • Windows: gerrit_windows_wsl
  • macOS: gerrit_mac

Some of the tests are more extensive, for example Linux / Clang also performs additional code quality checks with clang compiler plugins. Also, UITests are not run on each and every platform.

Jenkins LibreOffice CILibreOffice CI uses Jenkins

Why Failures Happen and How to Fix?

There can be multiple reasons for why a CI build fails, and give your submission    Verified -1   . These are some of the reasons, and depending on the reason, solution can be different.

1. Your code’s syntax is wrong and compile fails

In this case, you should fix your code, and then submit a new patch set. You have to wait again for a new CI build.

2. The code’s syntax is OK, but it is not properly formatted

You should refer to the below TDF Wiki article and use clang-format tool to format your code properly.

3. Your code’s syntax is OK, but it logically not OK and fails some tests.

In this case, you should try fixing your code logic, and run the tests that fail and make sure they pass. After that, you may send a new patch set and wait for a new CI build.

4. Your code’s syntax and logic is OK, but some machine fails for other reasons like their disk being full or other software/hardware failures or hiccups

In this case, usually resuming the build can be a good option. You may ask on #libreoffice-dev or #tdf-infra IRC rooms for such a resume, or request access, if you submit many patches.

Resume CI buildResume build in LibreOffice CI

5. Your code’s syntax and logic is OK, but there are issues from other patches.

In this case, intervention from other LibreOffice developers is needed. Informing people on #libreoffice-dev can help, and then you have to re-base your submission in case new patches fix the build issue.

Final Notes

The best way to know the reason of the build failure is to look into


face

I fetched the release notes for FirebirdSQL/php-firebird and made a concise summary of the user-visible changes and upgrade impact for versions from PHP Firebird 5.0.2 up through 6.1.1-RC.2.I retrieved the release entries for 5.0.2, 6.1.1-RC.0, 6.1.1-RC.1 and 6.1.1-RC.2 and distilled the highlights and upgrade impact into a short, actionable summary below.Summary of changes (5.0.2 → 6.1.1-RC.2)-


face

The Firebird Book, Second Edition is made publicly available via the IBPhoenix digital store. Everyone can download the complete edition free of charge — no strings attached.If you'd like to support Helen’s legacy and the Firebird community, there is an optional pay‑what‑you‑like contribution. Funds will support the organization of the Helen Borrie Memorial Award, recognizing individuals with


Wednesday
03 December, 2025


face

LibreOffice 26.2 will be released as final at the beginning of February, 2026 ( Check the Release Plan ) being LibreOffice 26.2 Alpha1 the first pre-release since the development of version 26.2 started at the beginning of June, 2025. Since then, 4651 commits have been submitted to the code repository


face

Writer recently got a new markdown import option to take styles from a template, leading to much prettier output when converting markdown to PDF, DOCX or ODT.

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

Motivation

A previous post mentioned recent improvements to the markdown import/export in Writer.

But if you convert some markdown to e.g. PDF, all the headings just have the default look, wouldn't it be nice to take your organization template and add colors and other formatting there, automatically?

Also, wouldn't it be nice if you could paste as markdown in COOL or copy the current selection as markdown? Which would enable all sorts of interesting use-cases, like using an external API to turn the selection into a summary or translating it to a different language.

Results so far

Here is a sample input markdown:

# heading 1

body text

Here is how it looks like if you template it using the core.git sw/qa/filter/md/data/template.docx sample:

PDF result: templated

curl invocation for this:

curl -k -F "data=@/path/to/test.md" -F "template=@/path/to/template.docx" -F "format=pdf" -o out.pdf https://localhost:9980/cool/convert-to

Or example desktop command-line:

soffice --infilter='Markdown:{"TemplateURL":{"type":"string","value":"./template.ott"}}' test.md

While it would look like this by default:

PDF result: default

The other part is the PostMessage API of COOL, if you want to copy and paste as markdown. What's newly possible:

  • Copy the current selection: set MessageId to Action_Copy and the value to {"Mimetype": "text/markdown;charset=utf-8"}
  • Paste at the current cursor position: set MessageId to Action_Paste and the value to something like {"Mimetype": "text/markdown;charset=utf-8", "Data": "foo _bar_ baz"}

You can read more about the PostMessage API in the COOL SDK.

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. Core side:

Online side:

Want to start using this?

You can get a development edition of Collabora Online 25.04 and try it out yourself right now: try the development edition. Collabora intends to continue supporting and contributing to LibreOffice, the code is merged so we expect the core of this


Sunday
16 November, 2025


face

avtor: Italo Vignoli (objavljeno 14. novembra 2025 v LibreOffice, Open Document Format)

Digitalna suverenost ali sposobnost narodov, organizacij in posameznikov, da nadzirajo svojo digitalno usodo je temeljno vprašanje 21. stoletja. V središču tega izziva je na vi dez nepomembno vprašanje: kdo nadzira vrsto zapisa dokumentov, ki vsebujejo našo intelektualno lastnino ali osebne podatke?


V tem kontekstu je standardni in odprti zapis Open Document Format (ODF) – izvorni zapis dokumentov LibreOffice, ki ga podpirajo tudi drugi paketi – temeljna tehnologija za tiste, ki si prizadevajo za resnično digitalno neodvisnost.
Digitalna suverenost vključuje sposobnost nadzora dostopa do lastnih informacij brez odvisnosti od tretjih oseb, neodvisno izbiro tehnologije na podlagi lastnih potreb, zagotavljanje neodvisnega dostopa do strateških podatkov brez odvisnosti od komercialnih interesov velikih tehnoloških podjetij in ohranjanje te tehnološke samoodločbe kljub konsolidaciji trga.
Ko vladne agencije, podjetja ali državljani shranjujejo svoje dokumente v lastniških zapisih, ki jih nadzirajo velika tehnološka podjetja, se odpovedujejo delu svoje suverenosti in so odvisni od teh zunanjih subjektov za dostop do lastnih informacij.

Zakaj so zapisi dokumentov pomembni za suverenost

Oblika zapisa dokumentov je infrastruktura, ki je – podobno kot ceste, električna omrežja ali telekomunikacijska omrežja – temeljna za delovanje sodobnih družb. Premislite, kaj se zgodi, ko strateški dokumenti obstajajo le v zapisih, ki jih nadzira en sam ponudnik:
  • zavezanost ponudniku: organizacije se znajdejo v pasti, saj ne morejo preiti na alternativno programsko opremo brez dragih procesov pretvorbe in morebitne izgube podatkov.
  • izguba nadzora: oblike zapisa se lahko spremenijo brez predhodnega obvestila in brez nadzora uporabnikov, kar poveča učinek zavezanosti ponudniku.
  • ranljivost dostopa: če dobavitelj, ki nadzira obliko zapisa, spremeni zapis ali preneha z njegovo podporo, kot se je zgodilo v primeru Windows 10, dostop do dokumentov postane problematičen ali nemogoč.
  • ekonomska odvisnost: stroški licence, potrebne za izvajanje posodobitev programske opreme, ustvarjajo odnos ekonomske odvisnosti za dostop do lastnih podatkov in dejansko prenašajo lastništvo nad podatki na dobavitelja, ki nadzira obliko zapisa.

Zakaj je ODF edino orodje za digitalno suverenost?

Z ODF upravlja OASIS, mednarodna organizacija za standardizacijo, ki varuje njegov pregleden razvoj. Objavljen je kot standard ISO/IEC 26300-2015 (in kmalu ISO/IEC 26300-2025). Za razliko od lastniških oblik zapisa so specifikacije ODF javne in se lahko prosto izvajajo, razvijajo se v preglednem procesu, v katerem sodelujejo različne zainteresirane strani, ne nadzira jih ena sama vlada ali podjetje in so predmet mednarodnih organov za standardizacijo.
Izvajanje politik, usmerjenih v digitalno suverenost, zahteva jasno zavezo vodstva, ki mora dati prednost dolgoročni neodvisnosti pred kratkoročno udobnostjo.
Vse te izzive je mogoče obvladati in se sčasoma zmanjšujejo, medtem ko omejitve in stroški odvisnosti od lastniških oblik zapisov postajajo vse hujši.
To pomeni, da lahko vlade in podjetja sodelujejo pri opredeljevanju specifikacij oblike zapisa, namesto da so prisiljena pasivno sprejemati spremembe, ki jih vsiljuje en sam prodajalec na podlagi svojih poslovnih strategij.
Tako specifikacije ODF omogočajo komur koli, da

Thursday
06 November, 2025


face

General Activities LibreOffice 25.8.2 was announced on October 9 LibreOffice 25.2.7 was announced on October 30 Olivier Hallot (TDF) added help pages for R1C1 Calc formula syntax and DOI citation recognition and improved and updated help on dimension lines, form properties, master documents, command line operations, online update, text boundaries


Tuesday
04 November, 2025


face

Writer has some support for interdependent (or hierarchical) tracked changes: e.g. the case when you have a delete on top of an insert. See the third post for background.

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

Motivation

Interdependent changes mean that the UI shows one type of change on top of another change, e.g. formatting on top of insert. Writer knows the priority of each type, so in case you have an insert or delete change and on top of that you have a formatting, then the UI will look "through" the formatting and work on the underlying insert or delete when you navigate with your cursor to a position with multiple changes and you press Accept on the Review tab of the notebookbar.

Usually this is what you mean, but what if you want to work on the formatting at the top, directly? You can now open the Manage Changes dialog using the Manage button on the Review tab of the notebookbar and if you go to the formatting change row of the dialog, then pressing Accept there will accept the formatting change, not the insert or delete change. This is possible, because the dialog gives you a way to precisely select which tracked change you want to work with, even if a specific cursor position has multiple tracked changes.

Results so far

Here is a sample ins-then-format.docx document from the core.git testcases, the baseline has an insertion, and part of that is covered by an additional formatting change on top:

Interdependent tracked change: baseline

If you just go in the middle of the document and press Accept, that will work with the more important insert change, so the result looks like this:

Interdependent tracked change: default accept result

But now you can also open the Manage Changes dialog, to be more specific by directly selecting the formatting change:

Interdependent tracked change: direct accept via the dialog

And when you accept the formatting change directly, the result will be just the insert change:

Interdependent tracked change: direct accept result

You can save and load the results in both DOCX and ODT, as usual.

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. Core side:

Want to start using this?

You can get a development edition of Collabora Online 25.04 and try it out yourself right now: try the development edition. 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 (26.2).


Wednesday
22 October, 2025


face

In LibreOffice C++ code, there are many cases where developers want to use string literals in their code. If these are messages in the graphical user interface (GUI), they should add them to the translatable messages. But, there are many cases where the string literals has nothing to do with other languages, and there will not be any further translations. In these cases, enumarray is helpful. Although enumarray can be used beyond string literals, for any kind of data.

Using Symbolic Constants

In old C code, using #define was the preferred way one could give a name to a string literal or other kinds of data. For example, consider this code:

const char[] FRAME_PROPNAME_ASCII_DISPATCHRECORDERSUPPLIER = "DispatchRecorderSupplier";
const char[] FRAME_PROPNAME_ASCII_ISHIDDEN = "IsHidden";
inline constexpr OUString FRAME_PROPNAME_ASCII_LAYOUTMANAGER = "LayoutManager";
const char[] FRAME_PROPNAME_ASCII_TITLE = "Title"_ustr;
const char[] FRAME_PROPNAME_ASCII_INDICATORINTERCEPTION = "IndicatorInterception";
const char[] FRAME_PROPNAME_ASCII_URL = "URL";

And also, the relevant states:

#define FRAME_PROPHANDLE_DISPATCHRECORDERSUPPLIER 0
#define FRAME_PROPHANDLE_ISHIDDEN 1
#define FRAME_PROPHANDLE_LAYOUTMANAGER 2
#define FRAME_PROPHANDLE_TITLE 3
#define FRAME_PROPHANDLE_INDICATORINTERCEPTION 4
#define FRAME_PROPHANDLE_URL 5

Although this C code still works in C++, it is not the desired approach in modern C++.

Using enumarrays

In modern C++ code, you can use enumarry from o3tl library in LibreOffice. The above code becomes:

enum class FramePropNameASCII
{
    DispatcherRecorderSupplier,
    IsHidden,
    LayoutManager,
    Title,
    IndicatorInterception,
    URL,
    LAST=URL
};

And also, the string literal definitions:

constexpr o3tl::enumarray<FramePropNameASCII, OUString> FramePropName = {
    u"DispatchRecorderSupplier"_ustr,
    u"IsHidden"_ustr,
    u"LayoutManager"_ustr,
    u"Title"_ustr,
    u"IndicatorInterception"_ustr,
    u"URL"_ustr
};

Why an enumarray?

The names are much more readable, as they do not have to be ALL_CAPPS, as per convention for symbolic constants in C. Their usage is also quite easy. For example, one can use [] to access the relevant string literal:

- xPropSet->getPropertyValue( FRAME_PROPNAME_ASCII_LAYOUTMANAGER ) >>= xLayoutManager;
+ xPropSet->getPropertyValue( FramePropName[FramePropNameASCII::LayoutManager] ) >>= xLayoutManager;

Final Notes

In LibreOffice, enumarrays are not limited to string literals, and they can be used with other data. This task is tdf#169155, and if you like, you may try finding some instances in the code and modernize it using enumarrays.

To learn more about LibreOffice development, you can refer to TDF Wiki. You may follow this blog to read about EasyHacks, tutorials and announcements related to LibreOffice development.


Tuesday
21 October, 2025


face

General Activities LibreOffice 25.2.6 was announced on September 8 Olivier Hallot (TDF) improved the help for Select Function in Calc’s formula bar, expanded help for the selection of chart data sources, added AutoFilter and Pivot Table/Chart to the help page on sheet protection, added information about summary above/below to the


Thursday
16 October, 2025


face

Since C++11 when enum class (also named scoped enum) is introduced, it is preferred to plain enum which is inherited from C programming languages. The task here is to convert the old enum instances to enum class.

Rationale

enum class has many benefits when compared to plain enum, as it provides better type safety among other things. Implicit conversion to integers, lack of ability to define the underlying data type and compatibility issues were some of the problems with plain enum that enum class solved in C++11. Although since then enum has improved and one can specify underlying type in the scoped enumerations.

Plain enums pollute namespace, and you have to pick names that are too long, and have to carry the context inside their names. For example: INETMSG_RFC822_BEGIN inside enum _ImplINetRFC822MessageHeaderState. With an enum class, it is simply written as HeaderState::BEGIN. When placed inside a file/class/namespace that makes it relevant, it is much easier to use: it is more readable, and causes no issues for other identifiers with possible similar names.,

See this change:

You can read more about that in:

Finding Instances

You may find some of the instances with:

$ git grep -w enum *.cxx *.hxx|grep -v "enum class"

When you count it with wc -l, it shows something more than 2k instances.

Examples Commits

You can see some of the previous conversions here, which is around 1k changes:

$ git log --oneline -i -E --grep="convert enum|scoped enum"

This is a good, but lengthy example of such a conversion:

Implementation

First of all, please choose good names for the new enum class and values. For example, you may convert APPLICATION_WINDOW_TITLE into Application::WindowTitle. Therefore, do not use the old names as they were.

Converting enum to enum class is not always straightforward. You should try to understand the code using the enum, and then try to replace it with enum class. You may need to add extra state/values for situations where 0 or -1 or some default value was used. There are cases where a numerical value is used for different conflicting purposes, and then you have to do some sort of conflict resolution to separate those cases.

You may end up modifying more and more files, and a few static_casts where they are absolutely necessary because you are interpreting some integer value read from input. These are the places where you should check the values yourself in the code. You have to make sure that the numerical value is appropriate before casting it to the enum class.

If you want to do bitwise operations, you should use o3tl::typed_flags, for example:

enum class FileViewFlags
{
    None = 0x00,
    MultiSelection = 0x02,
    ShowType = 0x04,
    ShowNone = 0x20,
};

template<> struct o3tl::typed_flags : o3tl::is_typed_flags<FileViewFlags, 0x26> {}

Then, you may use it like this:

    if (nFlags & FileViewFlags::MULTISELECTION)
        mxTreeView->set_selection_mode(SelectionMode::Multiple 

Tuesday
07 October, 2025


face

Writer recently got a Markdown import & export filter and there were a number of improvements to that.

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

Motivation

Ujjawal Kumar contributed a markdown import to Writer, as part of Google Summer of Code (GSoC) this summer. Mike Kaganski of Collabora also created a minimal markdown export in Writer. I looked at the feature differences between the two, and filled in various gaps in the markdown export. I also added a few general markdown import/export improvements relevant for normal Writer documents, like embedded image support.

Results so far

Here is a sample case of a document using inline code spans:

Code span: baseline

Exporting this to markdown & loading back to Writer, the code span was lost:

Code span: old result

And now it's preserved:

Code span: new result

This also works with code blocks.

Second, here is a document with lists:

Lists: baseline

Exporting this to markdown & loading back to Writer, the lists were lost:

Lists: old result

And now they are preserved:

Lists: new result

This also works with nested lists.

Third, here is a document with an image:

Image: baseline

Exporting this to markdown & loading back to Writer, the image was lost:

Image: old result

And now it's preserved:

Image: new result

This also works with embedded and anchored images.

Fourth, here is a document with a table:

Table: baseline

Exporting this to markdown & loading back to Writer, the table was lost:

Table: old result

And now it's preserved:

Table: new result

This also works with table alignments and nested tables (to the extent the markdown markup allows that).

Fifth, here is a document with a quote block:

Quote: baseline

Exporting this to markdown & loading back to Writer, the quote's paragraph indentation was lost:

Quote: old result

And now it's preserved:

Quote: new result

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. Core side:

Want to start


Thursday
18 September, 2025


face

If you are working with LibreOffice code, trying to understand the code, fix bugs, or implement new features, you will need to debug the code at some point. Here are some general tips for a good debugging experience. Let’s start from the platform

Choose the Right Debug Platform

Choosing a platform to debug usually depends on the nature of the problem. If the problem is Windows-only, you need a Windows environment to build and debug the problem. But, if the problems can be reproduced everywhere, then you can choose the platform of your choice with the debugging tools that you prefer to debug the problem.

On Linux, it matters if you are running X11 or Wayland. Also, as there are multiple graphical back-ends available for LibreOffice, it matters if you are using X11, GTK3/4, or Qt5/6 back-end for your debugging. Some bugs are specific to GTK, then you should use GTK3 UI for testing. In 2025, GTK4 UI of LibreOffice is still experimental, so it is better to work with GTK3. For making the debugging easier, many developers work on X11 (gen) UI for debugging.

Debugging Tools

Various debugging tools can be used to debug the soffice.bin/soffice.exe LibreOffice binary that you have built. For the common debuggers, you can use GDB on Linux, lldb on macOS, and WinDbg or Visual Studio on Windows.

For using the above debuggers, you can use the IDE or front-end that support them. Various IDEs are usable with LibreOffice code. For a detailed explanation, refer to this Wiki article:

Make sure that you can build and debug a simple program before trying to build and debug LibreOffice.

Environment Variables

To have a better debugging experience, or to avoid problems you may have to customize the debugging session with environment variables. A complete article of the TDF Wiki is dedicated to discuss the environment variables that can be used with LibreOffice:

Here is some of the most important ones:

1) Using the X11 user interface:

If you want to use the X11 back-end that is simpler, and usually easier to work with on debug sessions, you have to set SAL_USE_VCLPLUGIN environment variable:

export SAL_USE_VCLPLUGIN=gen
That is specially useful when you are debugging graphical problems. But in some cases, you may need to avoid it or at least customize it. For example, while debugging mouse-related problems you may need to tell LibreOffice to avoid mouse grabbing this way:

export SAL_NO_MOUSEGRABS=1

2) Using GTK user interface

If you are using GTK user interface, then you may use GTK inspector to interactively debug LibreOffice GUI. You can use it this way:

export GTK_DEBUG=interactive

Pretty Printers

In solenv/gdb/ inside LibreOffice source code, you may find pretty printers for GDB. This is helpful when debugging LibreOffice with GDB, to be able to see data in a more readable way.

Dumping Data

Sometimes when you debug a LibreOffice application, it is easier to


Tuesday
16 September, 2025


face

General Activities LibreOffice 25.8.0 and LibreOffice 25.8.1 were announced on August 20 and August 29 respectively Olivier Hallot (TDF) updated help for the option to load printer settings with document, sorting blocks of cells in Calc, hyphenation, statistical functions, number of lines in charts, exponentiation operator in Calc, remote files,


Monday
15 September, 2025


face

Once upon a time, there was a girl, who used WhatsApp in her iPhone. She was rather active there, and collected quite some important data in the app over time. But some things in her iPhone were inconvenient; and the phone was slowly aging. So she wanted to change her phone some day.

For her birthday, a fairy, who learned somehow about the girl’s wish, presented her a new Android phone. That was a nice new phone, and the girl was so happy! She decided to move everything from the old phone to the new one immediately.

She was worrying about how to move the precious data between the devices; but she felt a huge relief, when the phone spoke: “The fairy told me how important your data is to you; and I have magic powers to handle it all. Just connect the old phone to me with a cord”. So she did.

The new phone started its work; and the girl could see how the progress bar was gradually moving to completion; but suddenly it stopped; minutes passed, but the bar was motionless. The girl was impatient to start using her new shiny device, but she knew that she needs to wait. And she waited; and waited; but after an hour passed, she noticed something horrible: the old phone was sucking the life out of the new device through the cable!

The scared girl could only hope that the process would resume, and finish before the new phone is out of power. She searched and learned, that iPhones are known for their insatiable hunger, and whenever they are connected to anything with energy, they start sucking it. She couldn’t even ask the new phone to shine less brightly to save the energy – because it wasn’t ready for such things yet. She used her wireless charger, but its powers were fewer than the hunger of iPhone, combined with the hard work done by Android. The energy level still decreased too fast.

In the end, when the hope almost vanished, the progress resumed moving! But immediately, the new phone said: “When I collected your data from your old phone, something bad happened, and I failed to collect something. I will continue, but please check later, what’s missing!”.

Only a couple of energy drops were remaining in the new phone, when it finished its task, and could be disconnected from the vampire. But the girl was terrified, when she opened WhatsApp, connected to it (using a magic SMS confirmation), only to see that all her data is lost! She tried to open WhatsApp on the old phone to check if something is still there, and saw that the app had disconnected her. So she used the SMS magic again, and – to her great relief – everything was there!

She askes WhatsApp, how to move the data; and it answered, that if she moved from iPhone to iPhone, or from Android to Android, she could use a backup; but from


Thursday
11 September, 2025


face

C++ Standard library, which resides in std:: namespace provides common classes and functions which can be used by developers. Among them, Standard Template Library (STL) provides classes and functions to better manage data through data structures named containers. Here I discuss how to use STL functions for better processing of data, and avoid loops.

Checking Conditions

To iterate over a container to see if some specific condition is valid for all, any, or none of the elements in that container, C/C++ developers traditionally used loops.

On the other hand, since C++11, there are functions that can handle such cases: all_of, any_of and none_of. These functions process STL containers, and can replace loops. If you want to know if a function returns true for all, any, or none of the items of the container, then you can simply use these functions. This is the EasyHack dedicated to such a change:

Here is an example patch which uses any_of instead of a loop:

-    bool bFound = false;
     // convert ASCII apostrophe to the typographic one
     const OUString aText( rOrig.indexOf( '\'' ) > -1 ? rOrig.replace('\'', u'’') : rOrig );
-    size_t nCnt = aVec.size();
-    for (size_t i = 0;  !bFound && i < nCnt;  ++i)
-    {
-        if (aVec[i] == aText)
-            bFound = true;
-    }
+    const bool bFound = std::any_of(aVec.begin(), aVec.end(),
+        [&aText](const OUString& n){ return n == aText; });

As you can see, the new code is more concise, and avoids using loops.

Conditional Copying, Removing and Finding

If you want to copy, remove or simply find a value in a container which conforms to a specific functions, you may use copy_if, remove_if or find_if.

Again, this is an example patch:

-  for ( size_t i = 0; i < SAL_N_ELEMENTS( arrOEMCP ); ++i )
-        if ( arrOEMCP[i] == codepage )
-            return true;
-
-    return false;
+    return std::find(std::begin(arrOEMCP), std::end(arrOEMCP), codepage) != std::end(arrOEMCP);

Final Words

Refactoring code is a good way to improve knowledge on LibreOffice development. The above EasyHacks are among EasyHacks that everyone can try.

More information about EasyHacks, and how to start working on them can be found on TDF Wiki:


Tuesday
09 September, 2025


face

Writer has some support for interdependent (or hierarchical) tracked changes: e.g. the case when you have a delete on top of an insert. See the second post for background.

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

Motivation

With the already mentioned improvements in place, the area of format redlines with character style or direct formatting changes were still lacking: Writer's original model here was just marking a text range as "formatted" and then either accept the format redline as-is, or reject reverting back to the paragraph style (default formatting), losing the old character style or old direct formatting.

Results so far

Here is a sample case of a document where the old character style is Strong (~bold) and the font size is 24pt, while the new character style is Quote (~italic) and the font size is 36pt. The rest of the document uses no specific character styles and has the font size of 12pt:

Interdependent tracked change: improved format, after document load

Rejecting that format redline resulted in just the defaults, i.e. no character style and 12pt font size:

Interdependent tracked change: old reject, lost character style / direct format

But now we track the old character style & direct format:

Interdependent tracked change: new reject, handled character style / direct format

This required changes in the DOCX import, ODF import and ODF export, too.

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. Core side:

Want to start using this?

You can get a development edition of Collabora Online 25.04 and try it out yourself right now: try the development edition. 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 (26.2).


Monday
01 September, 2025


face

LibreOffice 25.8 krepi digitalno suverenost

LibreOffice 25.8: strateška dobrina za vlade in podjetja, usmerjena v digitalno suverenost in zasebnost

Pregled

V času, ko geopolitične napetosti, zakoni o lokalizaciji podatkov in tveganja v zvezi s skladnostjo spreminjajo IT-okolje, se LibreOffice 25.8 (izšel je konec avgusta 2025) izkazuje kot strateška izbira. Gre za popolnoma odprtokodni, krajevno delujoč pisarniški paket, zasnovan za organizacije, ki potrebujejo popoln nadzor nad svojo programsko opremo, podatki in infrastrukturo.

Ta različica neposredno temelji na prednostnih nalogah, ki so jih izrazile javne uprave in velika podjetja po vsem svetu: zaščita podatkov uporabnikov, zmanjšanje odvisnosti od tujih dobaviteljev in krepitev digitalne avtonomije.

Zakaj je digitalna suverenost pomembna?

Za vlade in podjetja digitalna suverenost ni le filozofija. Gre za:

  • nacionalno varnost: zmanjšanje izpostavljenosti ekstrateritorialnemu nadzoru in varnostnim luknjam v programski opremi;
  • skladnost z zakonodajo: izpolnjevanje zakonskih zahtev, kot so GDPR, nacionalni zakoni o javnih naročilih in predpisi o lokalizaciji IT;
  • neodvisnost od dobaviteljev: izogibanje prisilnim migracijam, agresivnim modelom licenciranja ali nepredvidljivim cenam dobaviteljev lastniške opreme;
  • strateško odpornost: ohranjanje delovanja sistemov, ki so ključni za poslovanje, brez odvisnosti od oblaka.

LibreOffice 25.8 je bil razvit posebej za te namene.

Ključne prednosti LibreOffice 25.8 za ustanove

Arhitektura, ki daje prednost zasebnosti

  • Brez telemetrije: brez zbiranja podatkov v ozadju. LibreOffice je popolnoma transparenten in deluje neopazno.
  • Popolna zmogljivost brez internetne povezave: vse funkcije delujejo brez internetne povezave, kar je idealno za varna, izolirana ali kritična okolja.
  • Šifriranje OpenPGP: dokumente je mogoče šifrirati s ključi, ki jih upravlja uporabnik, kar zagotavlja skladnost z notranjimi varnostnimi politikami.

Odprti standardi in medsebojna povezljivost

  • Domorodna podpora za odprti zapis dokumentov (ODF), standard ISO, ki zagotavlja dolgoročen dostop in odpravlja lastniško vezanost.
  • Izboljšana združljivost z zapisi Microsoft Office/365 (.docx, .xlsx, .pptx) in zapisi OpenOffice (.doc, .xls, .ppt).

Prilagodljiva namestitev in integracija

  • Na voljo je za Windows, Linux in macOS: podpira heterogena IT-okolja.
  • Brezhibna integracija z Nextcloud, ownCloud in samostojnimi platformami za sodelovanje.
  • Skalabilen od ene same varne delovne postaje do celovitih namestitev v podjetju s centralizirano konfiguracijo in izvajanjem politik.

Strateške prednosti za javni in podjetniški IT

  • Nadzor stroškov: brez licenčnin. LibreOffice lahko zmanjša IT-stroške in je hkrati skladen z javnimi naročili, ki zahtevajo odprte standarde in pošteno konkurenco.
  • Revizijska sledljivost: popolnoma odprtokoden. Vsaka vrstica kode je vidna in preverljiva, kar podpira revizijske zahteve in zmanjšuje tveganja v dobavni verigi.
  • Lokalna opolnomočenost: spodbuja nacionalne in regionalne IT-ekosisteme z omogočanjem pogodb za lokalno podporo, prilagajanjem in strokovnimi storitvami, kar spodbuja domači tehnološki sektor.

Uporaba v praksi

Vlade in velike institucije po Evropi, Latinski Ameriki in Aziji so LibreOffice sprejele kot del pobud za digitalno suverenost. Vladni organi v Nemčiji, na Danskem in v Franciji ter nacionalna ministrstva v Italiji in Braziliji so se obrnili k LibreOffice, da bi ponovno prevzeli nadzor nad svojo digitalno infrastrukturo. LibreOffice podpira The Document Foundation, nevtralna, neprofitna organizacija z globalno

<- Current blog entries