compilation

Building Procedures

Project depends on Qt5. ~~Minimal Qt version which the project is tested on is Qt-5.2.1. The project relies on functionality that was first implemented in Qt-5.2.~~ Qt version which the project is tested on is Qt-5.3.2. Since Datovka 4.5 we don't recommend using previous version of Qt as these contain a bug causing the application to crash on drag events.

Prerequisites

Qt5 (at least version 5.3.0) -- Qt5 must contain sqlite support.
qmake (Should be part of some Qt5 development package.)
libdatovka (+ development package)
- libisds (+ development package) is required to build Datovka before version 4.16.0.

Datovka-4.16.0 and newer versions of Datovka require libdatovka-0.1.0 in order to compile and function properly.

Datovka-4.14.0 and newer versions of Datovka require libisds-0.11 in order to compile and function properly.

Datovka-4.10.3 and newer versions of Datovka require libisds-0.10.8 in order to compile and function properly.

Datovka-4.9.1 and newer versions of Datovka require libisds-0.10.7 in order to compile and function properly.

We recommend compiling libdatovka and libisds with the OpenSSL back-end option enabled to avoid this problem (#6). (Use ./configure --enable-openssl-backend when configuring libdatovka sources.) If you want to experiment with libdatovka then it is probably best to compile it from sources:

./configure --enable-debug --enable-openssl-backend --disable-fatalwarnings --disable-nls --enable-test
make
sudo make install

Linux/UNIX

We don't currently use Autotools. The project directly relies on libdatovka, OpenSSL and Qt5 which should be installed in the system.

Since Datovka 4.5 you must run the lrelease command manually.

If you want to compile the application from sources running the following commands should do the trick:

lrelease datovka.pro
qmake datovka.pro
make

You may run also:

make install

If you want to build only the command-line application for Linux then use the datovka-cli.pro.noauto as project file:

lrelease datovka.pro
qmake datovka-cli.pro.noauto
make

You may change the prefix by running:

qmake PREFIX="/usr" datovka.pro

If you are a package maintainer you may want to disable the default checking for new version on application start-up. This can be achieved by passing the DISABLE_VERSION_NOTIFICATION configuration option.

qmake DISABLE_VERSION_NOTIFICATION=1 datovka.pro

macOS/OS X

Currently we use:

QT_VER="5.7.1" with SDK_VER="10.12" for 32-bit builds,
QT_VER="5.15.2" with SDK_VER="11.1" for 64-bit builds.

You need Xcode with Command Line Tools in order to compile and build the package. Xcode usually supports two adjacent SDKs (e.g. 10.9 and 10.10). You need to obtain an older Xcode package to achieve older SDKs. Store the SDKs into the directory /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs.

If you get an error similar to clang: warning: no such sysroot directory: '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.12.sdk then go to the directory /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.12.sdk and execute sudo ln -s MacOSX.sdk MacOSX10.12.sdk - this will usually help.

If you get errors similar to /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1/stdlib.h:94:15: fatal error: 'stdlib.h' file not found then:

cd /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs
sudo ln -s MacOSX.sdk MacOSX10.12.sdk
sudo ln -s MacOSX.sdk MacOSX10.13.sdk

Building from Git

Use the scripts/build_git_archive.sh script to build a git archive. Eg.:

> ./scripts/build_git_archive.sh -c 90bd2fb92783468f19852140d0080cc2273fa385
Building archive version '4.15.1' from commit '90bd2fb92783468f19852140d0080cc2273fa385'.
...
File size of 'datovka-4.15.1.9999.20200716.140039.90bd2fb92783468f.tar.xz.sha256' OK.
datovka-4.15.1.9999.20200716.140039.90bd2fb92783468f.tar.xz

Once the source archive is available use the -v parameter to pass the package version (here it is 4.15.1.9999.20200716.140039.90bd2fb92783468f) to build package bundles:

> QT_VER="5.15.0" ./scripts/build_macos_dmgs.sh --x86_64 --shared -s 10.15 -v 4.15.1.9999.20200716.140039.90bd2fb92783468f -d

> QT_VER=5.7.1 ./scripts/build_macos_dmgs.sh -s 10.12 --i386 --shared -v 4.15.1.9999.20200716.140039.90bd2fb92783468f -d

Datovka-4.16.0 and Newer

The building procedure is the same as for Datovka-4.10.2 but libdatovka is required.

In order to build all required libraries (excluding Qt5) you need to run the following command:

cd libs
../scripts/build_libdatovka_osx.sh ${SDK_VER}

This will compile libdatovka (as a static and shared library) and its other dependencies and store them in a directory where it can be read by the script which compiles and builds the package.

Datovka-4.10.2 and Newer

A working Qt5 installation is required (minimal version is 5.2.1). In order to be able to use the building scripts you are required to provide Qt in those paths Qt-${QT_VER}-macx-clang-[32|64]-macosx${SDK_VER}-[shared|static] where:

${QT_VER} - version of the Qt framework (e.g. 5.7.1, 5.9.6, 5.10.1, ...)
[32|64] - target architecture bits (32 or 64)
${SDK_VER} - SDK version (e.g. 10.12, 10.13, 10.14...)
[shared|static] - specifies whether Qt is compiled as static libraries (i.e. static) or as a framework (i.e. shared)

The build system does not support building of fat binaries containing both (32- and 64-bit binaries). Apple is anyway slowly pushing the users and developers towards 64 bits.

Libraries needed by the application can be linked statically or dynamically - depending on the used Qt. If you are linking with statically build Qt then you must use static libraries. If you are using Qt built as a framework then you must use shared libraries. (This is not a restriction of the used tools. Its just a requirement that makes the scripts easier to maintain.) In future we want to bundle the application only with shared libraries.

In order to build all required libraries (excluding Qt5) you need to run the following command:

cd libs
../scripts/build_libdatovka_osx.sh ${SDK_VER}

This will compile libdatovka (as a static and shared library) and its other dependencies and store them in a directory where it can be read by the script which compiles and builds the package.

When you have all libraries (Qt5, libdatovka and dependencies) run the following commands. These must be run from a working desktop session on OS X as the scripts accesses some resources that aren't available on a plain terminal session (e.g. when logged-in via ssh).

QT_VER=5.7.1 ./scripts/build_macos_dmgs.sh -d -s 10.12 --i386 --shared

QT_VER=5.15.2 ./scripts/build_macos_dmgs.sh -d -s 11.1 --x86_64 --shared

or the modification of any of those command to build the desired target.

Occasionally it happens that the target .dmg file fails to build properly (because of some asynchronous actions). In such cases just re-run the command using the -D parameter:

QT_VER=5.7.1 ./scripts/build_macos_dmgs.sh -D -s 10.12 --i386 --shared

This will skip the compilation and will only build the package.

The following script builds the .dmg package if the application has already been compiled. But you are not expected to run the script manually.

./scripts/build_dmg.sh

Datovka-4.10.1 and Older

A working statically compiled Qt5 (minimal is 5.2.1) is required to be installed in the location /usr/local/Qt-${QT_VER}-macx-clang-32-macosx${SDK_VER}-static. Usually, the sources require some patching in order to successfully proceed the compilation process. Also it is recommendable to decrease the pool size in ExecutableAllocatorFixedVMPool.cpp (we use 128Mb instead of 2Gb). So far we haven't been able to compile Qt5 using 10.6 SDK.

All libraries are linked statically into Datovka. In order to build all required libraries (excluding Qt5) you need to run the following command:

cd libs_static
./build_libisds_osx.sh ${SDK_VER}

This will compile libisds and other dependencies and store it to a directory where it can be read by the script which compiles and builds the package.

When you have all static libraries (Qt5, libisds and dependencies) run the following commands. These must be run from a working desktop session on OS X as the scripts accesses some resources that aren't available on a plain terminal session (e.g. when logged-in via ssh).

QT_VER="5.7.1" ./scripts/build_osx_dmgs.sh -d -s ${SDK_VER}

Occasionally it happens that the target .dmg file fails to build properly (because of some asynchronous actions). In such cases just re-run:

QT_VER="5.7.1" ./scripts/build_osx_dmgs.sh -D -s ${SDK_VER}

This will skip the compilation and will only build the package.

The following script builds the .dmg package if the application has already been compiled. But you are not expected to run the script manually.

./scripts/build_dmg.sh

Windows - Building Libraries

The libraries are built using MinGW on Ubuntu Linux. The following packages should be installed:

apt install git curl

Packages like gftp, vim-gtk3 or mc may also become handy.

32-Bit Libraries

Ubuntu 16.04 is used to build the 32-bit libraries. The following packages are needed:

apt install gcc-mingw-w64-i686 g++-mingw-w64-i686 autoconf automake make libtool

To build libdatovka use the command from within the source root:

mkdir libs; cd libs
../scripts/build_libdatovka_mingw.sh --i386

64-Bit Libraries

Ubuntu 20.04 is used to build the 64-bit libraries. The following packages are needed:

apt install gcc-mingw-w64-x86-64 g++-mingw-w64-x86-64 autoconf automake make libtool

To build libdatovka use the command from within the source root:

mkdir libs; cd libs
../scripts/build_libdatovka_mingw.sh --x86_64

Windows - Building the Application

Building procedure of the Datovka application for Windows requires:

Windows 7 or later
Qt5.2.1 or newer
Build of libdatovka and its dependencies compiled with MinGW.

You need to add the Qt tool chain (C:\Qt\{Qtversion}\mingw{Mingwversion}\bin\, C:\Qt\Tools\mingw{Mingwversion}\bin\) into the PATH environment variable. For example if you are using Qt5.4 then you probably must add C:\Qt\5.4\mingw491_32\bin\;C:\Qt\Tools\mingw491_32\bin\.

In order to build the application then run the command:

qmake.exe datovka.pro -r -spec win32-g++
mingw32-make.exe

For building the portable version run:

qmake.exe datovka.pro PORTABLE_APPLICATION=1 -r -spec win32-g++
mingw32-make.exe

Windows - Build Packages and Installer

Since Datovka-4.11.1

We've modified the building procedure of the application since the version 4.11.1.

Building Required Libraries

In order to build all required third-party libraries you need to use a working MinGW toolchain. We are using MinGW on Ubuntu 16.04. Navigate to the application repository and run the following command:

./scripts/build_libdatovka_mingw.sh

This will download and build all required libraries inside the directory libs/shared_built/. It will also create an shared_built_DATE_UTCTIME_.tar.gz archive inside libs/ containing the built libraries.

Copy the archive into a Windows environment where the compilation procedure continues.

Preparing Windows Environment

The compilation continues inside a Windows session. First extract the shared_built_DATE_UTCTIME_.tar.gz archive to the same location as it was created. The built libraries must be located inside the libs\shared_built subdirectory (i.e. You must have libs\shared_built\bin, libs\shared_built\include and libs\shared_built\lib).

You must provide a copy of libgcc_s_sjlj-1.dll as it is required by some libraries. Place it inside the libs\ directory. (i.e. The library must be available at libs\libgcc_s_sjlj-1.dll.)

In order to build the application you must have a working Qt installation. You must set the system or user-profile PATH variable to point to a working Qt profile (e.g. c:\Qt\5.9.3\mingw53_32\bin).

Also you must provide a minimal POSIX-compliant environment in order to run the scripts. We recommend that you use the Git Bash terminal session which is provided by the Git Windows package.

Compile Datovka

Open Git Bash.
Navigate to the datovka source directory.
Run ./scripts/build_windows_bundle.sh in order to compile Datovka. This will create a directory datovka.built which contains all libraries and required files. The content of datovka.built can be used to create an application installer.
Run ./scripts/build_windows_bundle.sh --portable-data in order to compile a portable version. This will create a directory datovka-portable.built.

Don't run ./scripts/build_windows_bundle.sh and ./scripts/build_windows_bundle.sh --portable-data simultaneously as it will probably break the compilation process.

Building from Git

Use the scripts/build_git_archive.sh script to build a git archive. Eg.:

> ./scripts/build_git_archive.sh -c 90bd2fb92783468f19852140d0080cc2273fa385
Building archive version '4.15.1' from commit '90bd2fb92783468f19852140d0080cc2273fa385'.
...
File size of 'datovka-4.15.1.9999.20200716.140039.90bd2fb92783468f.tar.xz.sha256' OK.
datovka-4.15.1.9999.20200716.140039.90bd2fb92783468f.tar.xz

Once the source archive is available use the -v parameter to pass the package version (here it is 4.15.1.9999.20200716.140039.90bd2fb92783468f) to build package bundles:

> ./scripts/build_windows_bundle.sh -v 4.15.1.9999.20200716.140039.90bd2fb92783468f -p

> ./scripts/build_windows_bundle.sh -v 4.15.1.9999.20200716.140039.90bd2fb92783468f -p --portable-data

Create Packages

In order to compile and package the entire application just run (use lowercase -p):

./scripts/build_windows_bundle.sh -p # Build and package the normal version.
./scripts/build_windows_bundle.sh -p --portable-data # Build and package the portable version.

Zip archives, and installers will be placed in the source root directory.

If you've already built the application (you already have datovka.built and/or datovka-portable.built) and you just want to create the packages then run (use capital -P):

./scripts/build_windows_bundle.sh -P # Just package the normal version.
./scripts/build_windows_bundle.sh -P --portable-data # Just package the portable version.

Before Datovka-4.11.1

In order to build the Datovka installer for Windows you require:

Windows 7 or later
Qt-5.3.2 or newer
Build of libisds and its dependencies compiled with MinGW.
(NSIS)[http://nsis.sourceforge.net/Main_Page] (Nullsoft Scriptable Install System)
(7-Zip)[http://www.7-zip.org/] archiver

Follow these steps to build the installer.

Create folder dlls in the root of the project directory and copy all required libraries (libisds.dll, openssl.dll, ...) here. The file notes\libdepends.win contains the list of required files.
Copy additional NSIS libraries (ReplaceInFile.nsh, StrRep.nsh) from nsis\nsis-libs\ to c:\Program Files (x86)\NSIS\Include\.
Edit scripts\make-win.bat batch file and set correct Qt toolchain, NSIS and 7-Zip paths:

set QTPATH="C:\Qt{Qtversion}\mingw{Mingwversion}\bin"
set QTMAKEPATH="C:\Qt\Tools\mingw{Mingwversion}\bin"
set NSISPATH="C:\Program Files (x86)\NSIS\makensis.exe"
set ZIPPATH="C:\Program Files (x86)\7-Zip\7z.exe"

make-win.bat

All built packages and installers can be found in the packages folder.

Available Configuration Options

The command

qmake DISABLE_VERSION_CHECK_BY_DEFAULT=1 datovka.pro

alters the default behaviour which is new version notifications are displayed by default until manually disabled by the user. When this value is set then new version notifications are not displayed until manually enabled by the user.

The option

qmake DISABLE_VERSION_NOTIFICATION=1 datovka.pro

is available since datovka-4.10.2. New version notifications are disabled at compile time. They cannot be enabled by the user from the programme at runtime. Use it when you create Linux distribution package.

The command

qmake PORTABLE_APPLICATION=1 datovka.pro

will configure the sources to build a portable version of Datovka. Portable application searches for the configuration directory in the directory where the executable is located. Also, some parts of the total functionality (e.g. database relocation) are disabled. The option makes really only sense when you compile a Windows target.

The command

qmake PREFIX="/usr" datovka.pro

changes the installation path on Linux/UNIX-like systems.

The command

TEXT_FILES_INST_DIR="/usr/share/datovka/" datovka.pro

changes the path where to search for installed documents. Actual installation of these documents is not handled by the generated Makefile. This option is used for example in the Gentoo Ebuild files.