How to hack and modify a predefined date time format of KDE 5 that comes with Debian 9.2.1 Stretch?

Question

I would like to hack and modify a predefined date time format of KDE 5 on Debian 9.2.1 Stretch.

A predefined format can be selected from the list of predefined formats at Kickoff Launcher > Computer > System Settings > Personalization > Regional Settings > Formats.

(For the screen shot of the Formats settings dialog, see https://superuser.com/q/1162283 on the SuperUser site.)

The effect of the format appears on the Formats settings dialog itself, and also appears on the Date field of the Details view of the Dolphin File Manager of the KDE desktop, and also the Properties of any file on Dolphin.

Unfortunately, none of the predefined formats suits me. The date time format of en_US ("United States - American English") is particularly terrible from my viewpoint. On the other hand, the short date time format of en_SE ("Sweden - English") is ISO 8601, and is close to what I want. Nevertheless, even en_SE does not completely satisfy me; especially its long format disappoints me.

This Formats settings dialog never lets you freely create custom formats. It only gives you a choice from predefined formats.

Thus, I would like to hack and modify a predefined format. Please let me know how.

The directory /usr/share/i18n/locales contains format files. The file names are identical to the format names such as en_US, en_GB, fr_FR and so on. However, the KDE that came with Debian 9.2.1 does not care about the format files in /usr/share/i18n/locales. Modification to these format files or even deletion of all of these files never affects the behavior of the KDE on Debian 9.2.1. This directory even lacks en_SE, and nevertheless en_SE appears in the Formats settings dialog.

I wonder if the predefined formats are hard-coded in KDE.

Note that Debian 9.0 Stretch was released on 2017-06-17. The versions of KDE components that came with Debian 9.2.1 follow:

plasmashell --version
# plasmashell 5.8.6

kf5-config --version
# Qt: 5.7.1
# KDE Frameworks: 5.28.0
# kf5-config: 1.0

TheEzekielProject claims in his post (https://www.linuxquestions.org/questions/linuxquestions-org-member-success-stories-23/guide-to-setting-custom-date-format-in-recent-versions-of-kde-4175595458-print/) that he managed to create a custom date time format by modifying a format file in the directory /usr/share/i18n/locales. The systems he tested are Kali Linux 2016.2 rolling with KDE Plasma 5.8.2 and KDE Frameworks 5.27.0, and Kubuntu 16.10 with KDE Plasma 5.7.5 and KDE Frameworks 5.26.0. His systems are older than mine.

I tried his method. In a format file, under LC_TIME, I changed d_t_fmt, d_fmt, t_fmt and t_fmt_ampm, and executed locale-gen, and so on. However, his method has turned out to have no effect on the KDE on Debian 9.2.1. Also a comment to his post complains that his method fails on Neon (plasma 5.10).

By the way, my question is not a duplicate of questions/1162283/use-iso-time-and-date-format-in-kde-5 on the SuperUser site. The question 1162283 asked for ISO date time format, and it has been fulfilled by the answer by Marco Lussetti, that is, by simply selecting en_SE from the list of predefined formats. My question asks for a hack to go beyond predefined formats.

Answer 1

It took me half a day to (almost) fully investigate this, but I think I found how to do it, and you’re not gonna like it …

The Solution:

In a nutshell,

KDE just uses QT’s QLocale. Which itself uses hard-coded data inside qlocale_data_p.h, deep in QT’s core library code.

This data is apparently manually generated from the Unicode Consortium’s “Common Locale Data Repository”, using several Python scripts inside util/local_database/ of the QT source code package. Which itself is not even part of the source code, I am certain. Let alone, using any kind of configuration or data files on your computer.

So the only way to do this, is to …

1. Download the CLDR files, either as a package, at http://unicode.org/Public/cldr/latest/core.zip (or cldr-common-*.zip, they both seem to contain the same), or at https://www.unicode.org/repos/cldr/trunk/, and extract the XML files under common/main/.
   Gentoo also has a package called app-i18n/unicode-cldr btw.
2. Acquire the QT core source code, e.g. from your distribution’s repository, and unpack it.
3. Use the scripts in util/local_database/ (like cldr2qlocalexml.py and qlocalexml2cpp.py), with your language of choice’s XML file, to re-generate the static qlocale_data_p.h.
4. Then compile and install the package as normal.

And don’t forget to recompile all other packages that include qlocale_data_p.h.

Or, on Gentoo, make a lasting patch with:

ebuild $(equery w dev-qt/qtcore:5) prepare
pushd /var/tmp/portage/dev-qt/qtcore-5*/work/ # assuming default Portage build directory
mv qtbase-opensource-src-5.9.3 a
cp -a a b

NOW make the above changes in b, and not in a. Then continue with:

mkdir -p /etc/portage/patches/dev-qt/$(basename $(dirname $(pwd))) # only for this version
#mkdir -p /etc/portage/patches/dev-qt/qtcore # for all versions
diff -ur a b > /etc/portage/patches/dev-qt/qtcore*/my-locale.patch
rm -rf a b
popd
ebuild $(equery w dev-qt/qtcore:5) clean
# Rebuild all packages that depend on it, just to be sure. May be optional.
emerge -1 dev-qt/qtcore:5 $(equery d dev-qt/qtcore:5 | sed 's/^/=/')

Final thoughts

To be perfectly frank, I didn’t check if those Python scripts actually worked by just passing an XML file. As, at that point, I just stopped bothering, and wanted to kill it with fire. :)

If anyone wants to actually do it in practice, please report, and I will update this answer. (Or do it yourself, if you can.)

---

Here’s how I got there:

• I opened KDE’s time formats setting dialog, via right-click on the task bar clock.
• Then, with htop I found the most recently started processes, which included the obvious kcmshell5 formats.
• Using htop’s list open files feature on it, I filtered for “format”, and found /usr/lib64/qt5/plugins/kcm_formats.so.
• With the help of Gentoo’s equery belongs /usr/lib64/qt5/plugins/kcm_formats.so I could identify the package kde-plasma/plasma-desktop.
• After unpacking its source file, I quickly found kcms/formats/kcmformats.cpp, whose addLocaleToCombo used the QLocale, and included <QLocale> too.
• This QLocale could then be found with locate -i QLocale to reside at /usr/include/qt[5]/QtCore/qlocale.h. It included some generated enumerations of the languages, scripts, etc.
• Another equery belongs /usr/include/qt[5]/QtCore/qlocale.h pointing me to dev-qt/qtcore/qtcore, and unpacking the source file later…
• … I already had a gut feeling, that it was all generated with some tool. So I looked into util/ and found util/local_database/README stating “local_database is used to generate qlocale data from the Common Locale Data Repository (The database for localized names (like date formats, country names etc)).”.
• Having never heard of that, I looked it up, and it’s apparently by the Unicode Consortium. The code of cldr2qlocalexml.py was not very useful though, as it is called with the path to a directory containing the CLDR locales. Its result is used for qlocalexml2cpp.py though, which generates the file src/corelib/tools/qlocale_data_p.h, which includes huge hard-coded tables of all the locale data. And that file already existed in the source. So… yep, it’s (partially?) hard-coded.
  
• But the CLDR XML files were nowhere to be found. So I assume it just uses the previously prepared qlocale_data_p.h. Which is not very in the spirit of open source. But at least you can do it yourself, as described above.

Answer 2

If anyone is interested, here are the steps I took to modify and compile the QT Core libraries on Debian 10. This allowed me to set the date and time formats the way I wanted for the KDE PIM (kontact, and in particular korganizer). It is a bit of a kludge, but it works for me. I should have done it years ago. It is unfortunate that changing a date format or time format requires multiple hours to perform.

I used the helpful step-by-step posted by Glen Whitney to get me started with this approach.

Notes: I started with a minimal Debian 10 install. I assume that sudo is installed to allow for commands to be executed as root. The commands below assume that bash is the shell.

1. Install necessary requirements for building source packages in Debian.

   sudo apt install build-essential fakeroot devscripts
   

2. Install other needed dependencies.

   sudo apt install python2
   sudo apt-get build-dep qtbase-opensource-src
   

3. Make a directory in which to work. I'm using QtLocaleFix as the top level directory in which to work.

   mkdir QtLocaleFix
   cd QtLocaleFix
   TOPDIR="${PWD}"
   

4. Create three sub-directories, one for the QtBase source code, one for the CLDR (Common Locale Data Repository), and one for convenience for the scripts needed to convert the CLDR locale information to the format needed by the QtBase libraries.

   QtBaseSrcDIR="${TOPDIR}/QtBaseSrc"
   mkdir "${QtBaseSrcDIR}"
   CLDRDIR="${TOPDIR}/CLDR"
   mkdir "${CLDRDIR}"
   CLDRScriptsDIR="${TOPDIR}/CLDRScripts"
   mkdir "${CLDRScriptsDIR}"
   

5. Get the source code for the QtBase libs (libqt5core5a).

   cd "${QtBaseSrcDIR}"
   apt source qtbase-opensource-src
   

6. The previous step downloaded source files for the QtBase libraries. It also unpacked them. One of the unpacked items is a directory (e.g. qtbase-opensource-src-5.11.3+dfsg1). This is the directory where we will compile the libraries. For convenience, define an environment variable to refer to this directory path. Basically, we want something like QtBaseBuildDIR="${QtBaseSrcDIR}/qtbase-opensource-src-5.11.3+dfsg1", but it is possible the directory will be named differently for different versions of the source. So, the find command below finds the unpacked directory name and sets it to the environment variable. The directory name could also be determined by listing.

   QtBaseBuildDIR="$(find "${QtBaseSrcDIR}" -maxdepth 1 -mindepth 1 -type d -print)" && echo "${QtBaseBuildDIR}"
   

7. Create a dedicated version of the source for this build.

   cd "${QtBaseBuildDIR}"
   dch --local "localver" "Modifications to locale settings for date and time formats"
   

8. Copy the CLDR conversion scripts to "${CLDRScriptsDIR}". This step could be skipped and the scripts could be run directly from the existing "${QtBaseBuildDIR}" sub-directory. However, doing this copy step saves deleting or accounting for the python byte code files that get created when the scripts run.

   cp -pr "${QtBaseBuildDIR}"/util/local_database/* "${CLDRScriptsDIR}"
   

9. In order to modify the date and/or time formats, CLDR data is needed. It can download from the http://cldr.unicode.org/ website's download page (http://cldr.unicode.org/index/downloads). There are several versions available. This step sets an environment variable to the version number to download. I had difficulty when I tried to use the latest version, so I used the same one that was used by the QtBase libraries in the Debian source package. The CLDR data is used to create a header file named "qlocale_data_p.h" and the existing header file specifies which CLDR version was used. The command below extracts the version out of the file. It should be something like "31.0.1". Other versions might or might not work. Any desired version number can be set by setting CLDRversion to the version desired. For example, CLDRversion="31.0.1". There probably is a better way to extract the version number from the file.

   QLocaleDataFile="$(find "${QtBaseBuildDIR}" -name "qlocale_data_p.h" -size +100k)" && echo "${QLocaleDataFile}"
   CLDRversion="$(grep "Common Locale Data Repository" "${QLocaleDataFile}" | awk -F " " '{ print $NF }' | awk '{ sub(/v/,""); print }')" && echo "${CLDRversion}"
   

10. Download the CLDR file archive.

    cd "${CLDRDIR}"
    curl "http://unicode.org/Public/cldr/${CLDRversion}/core.zip" --output "${CLDRDIR}/core.zip"
    

11. Extract the CLDR files

    unzip core.zip
    

12. The next couple steps are where predefined date and time (or other locale formats) can be modified before building the QtBase libraries. The specific changes to make depend on the formats that are desired. Following an approach like the one Glen Whitney gave, has edits being made to a file or files in "${CLDRDIR}/common/main". It is also possible to apply the edits to the intermediate locale file, localesForQt.xml. The intermediate locale file is created in step 14.

    Make a list of desired changes and review documentation before continuing.

    The specifics of what to change and how to change them are beyond scope of these instructions. However, here are a few hints and notes.

    • If editing the CLDR files:

      • For English language modifications, could modify "${CLDRDIR}/comman/main/en.xml", as Glen Whitney did.
      • Look at the settings under //ldml/dates/calendars/calendar[@type="gregorian"]/dateFormats/ or //ldml/dates/calendars/calendar[@type="gregorian"]/timeFormats/
      • References below have links to documentation on how to set the fields. (Note that the way the formats are specified is different for the downloaded CLDR files than for the intermediate locale file. Look at Unicode LDML documentation if modifying the CLDR files.)
      • Some changes to the CLDR files won't propagate to the intermediate locale file. Some items in the CLDR files don't have an analogue in the Qt locales framework.

    • If editing the intermediate file:

      • Each locale in the file has about 55 lines with locale settings.
      • Find the corresponding //localeDatabase/localeList/locale/ section where modifications are desired.
      • Search for a language or a country to find which section to modify. For example, search for "UnitedStates" and find the locale block corresponding to "American English" language and "United States" country. Actually, searching for "United States" or "American English" (with the space between the two words) took me right to the block that I wanted to modify.
      • References below have links to documentation on how to set the fields. (Note that the way the formats are specified is different for the intermediate locale file than for the downloaded CLDR files. Look at QtDate and QtTime documentation if modifying the intermediate locale file.)

    • Editing the intermediate locale file is probably more straightforward for most use cases.

13. Use a text editor to modify any files in "${CLDRDIR}/common/main" where changes are desired. As described above it is not necessary to change any files in this step. The intermediate locale file might be easier to edit.

    sensible-editor "${CLDRDIR}"/common/main/en.xml
    

14. Process the CLDR files to make the intermediate locale file, localesForQt.xml with file placed in "${TOPDIR}". This step will take several minutes and will generate a bunch of "skipping defaultContent" and "skipping file" messages. The messages might even give the impression that files modified in the previous step were skipped. Don't panic. The messages appear to be misleading.

    "${CLDRScriptsDIR}"/cldr2qlocalexml.py "${CLDRDIR}"/common/main > "${TOPDIR}/localesForQt.xml"
    

15. Use a text editor to modify or review the intermediate locale file if desired. If changes were made to the CLDR files before generating the intermediate locale file, this is an opportunity to check that any desired changes made it into the intermediate locale file.

    sensible-editor "${TOPDIR}/localesForQt.xml"
    

    Some example changes (to the "United States" "American English" locale, for example) :

    WAS:

                <longDateFormat>dddd, MMMM d, yyyy</longDateFormat>
                <shortDateFormat>M/d/yy</shortDateFormat>
                <longTimeFormat>h:mm:ss AP t</longTimeFormat>
                <shortTimeFormat>h:mm AP</shortTimeFormat>
    

    NOW:

                <longDateFormat>dddd, MMMM dd, yyyy</longDateFormat>
                <shortDateFormat>yyyy-MM-dd</shortDateFormat>
                <longTimeFormat>HH:mm:ss t</longTimeFormat>
                <shortTimeFormat>HH:mm</shortTimeFormat>
    

16. Use provided script to generate C++ code from the intermediate locale file.

    "${CLDRScriptsDIR}"/qlocalexml2cpp.py "${TOPDIR}/localesForQt.xml" "${QtBaseBuildDIR}" 
    

17. Commit the modifications to a patch file. Name the patch "localver_locale_modification.diff" or something similar. An editor will open where the modifications can be documented.

    cd "${QtBaseBuildDIR}"
    dpkg-source --commit
    

18. Build all of the QtBase libraries. This step will take a long time.

    debuild -us -uc
    

19. Upon completion, the previous step will leave many .deb files in "${QtBaseSrcDIR}". Install them with dpkg. Note that all of the packages have "localver" in the name. This can be useful for determining which packages were installed from source. After the initial install attempt with dpkg, if there are missing dependencies, they can be fixed with sudo dpkg --configure -a and sudo apt-get -f install. Then the installation of the "localver" packages can be repeated.

    find "${QtBaseSrcDIR}" -maxdepth 1 -mindepth 1 -type f -name \*localver\*.deb ! -name \*dbgsym\* -print0 | xargs -0 sudo dpkg -i
    sudo dpkg --configure -a
    sudo apt-get -f install
    find "${QtBaseSrcDIR}" -maxdepth 1 -mindepth 1 -type f -name \*localver\*.deb ! -name \*dbgsym\* -print0 | xargs -0 sudo dpkg -i
    

20. Open "System Settings"/Personalization/Regional Settings/Formats and set the Region to the desired locale(s) (e.g. "en_US"). The setting should match the country and region whose locale was modified. Click on "Detailed Settings" and set the same locale across all of the sub options. (I didn't get all of my updates until I turned on and set explicitly all of the detailed settings.) Logout or reboot for settings to take effect.

References:

kde.org bug report: https://bugs.kde.org/show_bug.cgi?id=340982

Unicode Locale Data Markup Language (LDML) Part 4: Dates # Date Field Symbol Table: https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table

Qt QTime format parameters: https://doc.qt.io/qt-5/qtime.html#toString

Qt QDate format parameters: https://doc.qt.io/qt-5/qdate.html#fromString

References truncated due to having more than the allowed number of links.

Answer 3

Over a year later, AFAICT the situation is exactly the same, and I have just done this process on OpenSUSE Tumbleweed to set the date formats the way I want for en_US. Here's the step-by-step, replace [SOMEPATH] (including the brackets) to your liking, and you may want to update the version number of CLDR if it's bumped from 35.1 since I posted this:

1. sudo zypper si libqt5-qtbase # That installs the source rpm for Qt Core
2. cd /usr/src/packages/SPECS
3. sudo rpmbuild -bp libqt5-qtbase.spec
4. cd [SOMEPATH]
5. curl http://unicode.org/Public/cldr/35.1/core.zip --output core.zip
6. unzip core.zip
7. nano common/main/en.xml # or whichever language/region you want to change -- find the date formats you want to change or whatever other parameters of the local and edit to your heart's content.
8. cd /usr/src/packages/BUILD/qtbase-everywhere-src-5.13.0/util/local_database/
9. ./cldr2qlocalexml.py [SOMEPATH]/common/main > [SOMEPATH]/localesForQt.xml
10. sudo ./qlocalexml2cpp.py [SOMEPATH]/localesForQt.xml /usr/src/packages/BUILD/qtbase-everywhere-src-5.13.0/
11. cd /usr/src/packages/SPECS
12. sudo rpmbuild --noprep --noclean -bb libqt5-qtbase.spec # Go watch a movie, depending on how fast your computer is...
13. When the build is done, there should be many RPMS created in /usr/src/packages/RPMS/[your_architecture]. Change directories into that directory.
14. sudo zypper install *Core*
15. Reboot and log back in and you should see your changes :-)

See, isn't configuring KDE/Qt fun and convenient? ;-)