move docs

This commit is contained in:
Andrei Yankovich 2020-11-19 10:14:43 +03:00
parent 1a574f6175
commit 904d01372c
42 changed files with 3235 additions and 7 deletions

3
.gitmodules vendored
View File

@ -10,9 +10,6 @@
[submodule "QuasarAppScripts"]
path = QuasarAppScripts
url = https://github.com/QuasarApp/QuasarAppScripts.git
[submodule "doc/wiki"]
path = doc/wiki
url = https://github.com/QuasarApp/CQtDeployer.wiki.git
[submodule "zip"]
path = zip
url = https://github.com/QuasarApp/zip.git

@ -1 +0,0 @@
Subproject commit 75e398cea9737327427e3cdb63ee56bf2504bbc1

View File

@ -1,3 +0,0 @@
OTHER_FILES += \
$$PWD/wiki/* \
$$PWD/wiki/ReleaseReviews/*

420
docs/en/1_4.md Executable file
View File

@ -0,0 +1,420 @@
# Release of C++/Qt and QML application deployment utility CQtDeployer v1.4.0 (Binary Box)
Almost half a year later, a major update of the CQtDeployer deployment utility was released.
This update has many new futures, but the main emphasis is on creating packages.
## CQtDeployer 1.4.0
### Fixes
- Fixed The help output in the console, now the actual size of the console is recounted before the output, which allows you to correctly transfer text.
- Fixed work with the deployment of Qt plugins. Now plug-ins do not extract all system dependencies, but only qt. Extract system dependencies caused applications to crash due to incompatible plugin libraries.
- Minor bug fixes and improvements.
### New features
- Added support for qmake search from the system environment.
- Added the ability to initialize the repository for further packaging, similar to git init.
- Added support for Qt Install Framework packages. Now you can pack the distribution into the installer.
- Added the ability to split the final distribution into several packages.
- Added the ability to unify the creation of packages for the final distribution.
- Added support for adding custom scripts to application launch scripts.
- Added support for extracting system dependencies for Windows.
- Added support for RPATH for Linux. Now cqtdeployer can independently determine the necessary qmake to deploy the application.
- Added support for finding the required dependency by library name.
- Added support for Qt libraries from Linux distributions repositories.
- Added new alias for the run command (cqt and cqtdeployer.cqt) for fast deploy of applications.
- Added support the native name of command for windows. Now you can run a cqtdeployer from cqtdeployer commnad in cmd and powershell.
### New options
- init - will initialize cqtdeployer.json file (configuration file). For example: "cqtdeployer init" - to initialize the configuration of a base package. "cqtdeployer -init multi" - to initialize the configuration of several packages.
- noCheckRPATH - disables the automatic search for paths to qmake in executable files (Linux only).
- noCheckPATH - disables the automatic search for paths to qmake in the system environment.
- extractPlugins - forces to extract all plug-in dependencies.
- qif - creates an installer at the end of the deployment.
- extraLibs - adds a template for an additional library, which should be included in the distribution.
- customScript - adds a custom script to the startup script of the application.
- -targetPackage [package; tar1, package; tar2] - used to form packages, denotes lists of target files for specific packages.
- recOut - indicates in which folder the resources will be added after deployment.
- name - sets the name of the package.
- description - sets the package description
- deployVersion - sets the package version
- releaseDate - sets the release date of the package.
- icon - sets the package icon.
- publisher - sets the publisher of the package.
- qifStyle - Sets the path to the CSS style file or sets the default style. Available styles: quasar
- qifBanner - Sets path to the banner png file.
- qifLogo - Sets path to the logo png file.
## A detailed analysis of the most interesting changes.
The first thing you should pay attention to is that CQtDeployer has learned to work with RPATH (Linux only) and PATH. This means that if your application is built with RPATH support (and RPATH in qt is enabled by default) or your qmake is registered in PATH, then you do not need to specify the path to qmake. CQtDeployer will find qmake for itself.
Let's test it in practice.
I created a simple console application using Qt.
``` cpp
#include <QString>
#include <QDebug>
int main(int, char *[])
{
QString str = "hello CQtDeployer 1.4";
qInfo() << str;
return 0;
}
```
I will use the cmake build system, as it is more relevant than qmake.
``` bash
andrei@HP:~/Hello$ tree
.
├── CMakeLists.txt
├── CMakeLists.txt.user
└── main.cpp
0 directories, 3 files
```
Create a folder for the assembly.
``` bash
andrei@HP:~/Hello$ mkdir build
```
Run the cmake in the created folder.
``` bash
andrei@HP:~/Hello/build$ cmake .. -DCMAKE_PREFIX_PATH=~/Qt/5.14.1/gcc_64
-- Configuring done
-- Generating done
-- Build files have been written to: /home/andrei/Hello/build
```
building a project
``` bash
andrei@HP:~/Hello/build$ make
Scanning dependencies of target Hello_autogen
[ 25%] Automatic MOC and UIC for target Hello
[ 25%] Built target Hello_autogen
Scanning dependencies of target Hello
[ 50%] Building CXX object CMakeFiles/Hello.dir/Hello_autogen/mocs_compilation.cpp.o
[ 75%] Building CXX object CMakeFiles/Hello.dir/main.cpp.o
[100%] Linking CXX executable Hello
[100%] Built target Hello
```
Checking our program.
``` bash
andrei@HP:~/Hello/build$ ls
CMakeCache.txt CMakeFiles cmake_install.cmake Hello Hello_autogen Makefile
```
And we start cqtdeployer passing it the program without qmake.
``` bash
andrei@HP:~/Hello/build$ cqtdeployer -bin Hello
Deploy ...
flag targetDir not used. use default target dir : "/home/andrei/Hello/build/DistributionKit"
target deploy started!!
copy : "/home/andrei/Hello/build/Hello"
extract lib : "/home/andrei/Hello/build/DistributionKit//bin//Hello"
copy : "/home/andrei/Qt/5.14.1/gcc_64/lib/libQt5Core.so.5"
copy : "/home/andrei/Qt/5.14.1/gcc_64/lib/libicuuc.so.56"
copy : "/home/andrei/Qt/5.14.1/gcc_64/lib/libicui18n.so.56"
copy : "/home/andrei/Qt/5.14.1/gcc_64/lib/libicudata.so.56"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_ar.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_bg.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_ca.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_cs.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_da.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_de.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_en.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_es.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_fi.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_fr.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_gd.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_he.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_hu.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_it.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_ja.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_ko.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_lv.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_pl.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_ru.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_sk.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_uk.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_zh_TW.qm"
try deploy msvc
deploy done!
```
Oh miracle, now our application is completely autonomous.
Check it out.
``` bash
andrei@HP:~/Hello/build$ cd DistributionKit/
andrei@HP:~/Hello/build/DistributionKit$ tree
.
├── bin
│   ├── Hello
│   └── qt.conf
├── Hello.sh
├── lib
│   ├── libicudata.so.56
│   ├── libicui18n.so.56
│   ├── libicuuc.so.56
│   └── libQt5Core.so.5
└── translations
├── qtbase_ar.qm
├── qtbase_bg.qm
├── qtbase_ca.qm
├── qtbase_cs.qm
├── qtbase_da.qm
├── qtbase_de.qm
├── qtbase_en.qm
├── qtbase_es.qm
├── qtbase_fi.qm
├── qtbase_fr.qm
├── qtbase_gd.qm
├── qtbase_he.qm
├── qtbase_hu.qm
├── qtbase_it.qm
├── qtbase_ja.qm
├── qtbase_ko.qm
├── qtbase_lv.qm
├── qtbase_pl.qm
├── qtbase_ru.qm
├── qtbase_sk.qm
├── qtbase_uk.qm
└── qtbase_zh_TW.qm
3 directories, 29 files
andrei@HP:~/Hello/build/DistributionKit$
```
The root of the program:
![image](https://user-images.githubusercontent.com/12465465/77245272-619a0280-6c2e-11ea-92f2-447563f72dcc.png)
Libraries needed for the program to work:
![image](https://user-images.githubusercontent.com/12465465/77245274-6363c600-6c2e-11ea-8729-7d494a073b66.png)
As you can see from the example, the application is fully assembled.
## Qt Installer Framework
The second innovation worth knowing is the ability to form QIF installers out of the box. All that is needed for our example is to add the qif option to the packaging command.
Usage example.
```
andrei@HP:~/Hello/build$ cqtdeployer -bin Hello qif
```
Just one simple command and the program gets a presentable look.
![image](https://user-images.githubusercontent.com/12465465/77245315-b3428d00-6c2e-11ea-9326-c23229020eb5.png)
This installer supports minimal integration of Linux distributions and Windows. Namely: creating shortcuts, and registering the application in the OS.
If for some reason you are not satisfied with the appearance of this installer, you can change it using the qifStyle flag. At the time of version 1.4, cqtdeployer supports only 2 styles (native and quasar).
Example quasar style:
![image](https://user-images.githubusercontent.com/12465465/77245334-d2d9b580-6c2e-11ea-9e55-e205499a9219.png)
You can also use your own qss stylesheet. To do this, pass the path to your qss or css file instead of the style name.
For example, consider the following qss stylesheet.
Style.qss:
``` css
QWidget
{
color: white;
background-color: rgb(65, 65, 65);
}
QPushButton
{
background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 rgba(150, 150, 150, 60%), stop:1 rgba(50, 50, 50, 60%));
border-color: rgb(60, 60, 60);
border-style: solid;
border-width: 2px;
border-radius: 9px;
min-height: 20px;
max-height: 20px;
min-width: 60px;
max-width: 60px;
padding-left: 15px;
padding-right: 15px;
}
QPushButton:pressed, QPushButton:checked
{
background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 rgba(50, 50, 50, 60%), stop:1 rgba(150, 150, 150, 60%));
}
```
Let's check what we get in this case.
``` bash
cqtdeployer -bin Hello qif -qifStyle ./../style.qss
```
![image](https://user-images.githubusercontent.com/12465465/77245346-00266380-6c2f-11ea-8426-42bf58038458.png)
Here, in fact, is the dark theme of the installer.
## Splitting into packages
And, probably, the last important update worth knowing is the ability to split a large multi-binar project into subprojects.
This feature is the most difficult of all listed, since it requires a lot of text to use it. So I recommend using the configuration file.
To begin with, we will complicate our project by adding 2 more executable files to it. I did not bother and just made 2 copies of my Hello utility.
To simplify working with packages, you need to initialize the directory.
``` bash
cqtdeployer init
```
This is another new function that creates a CQtDeployer.json file, in which we will write our configurations, instead of passing options to the utility.
``` js
{
"binDir": ".",
"clear": true,
"libDir": "./",
"recursiveDepth": 5
}
```
Now let's make 2 packages of 3 of our programs. To do this, specify:
```js
{
"binDir": ".",
"clear": true,
"libDir": "./",
"recursiveDepth": 5,
"targetPackage": [
["Dstro1", "Hello1"],
["Dstro2", "Hello2"],
["Dstro2", "Hello3"]
]
}
```
Please note that I had to explicitly specify the binding for Dstro2 to Hello2 Hello3. Unfortunately, at the time of version 1.4 cqtdeployer was not able to parse target enumerations. Please note that if I write Hello1 Hello instead, then the selection will be made for all matches and all 3 programs will be selected.
So, let's see what happened.
``` bash
cqtdeployer
.
├── Dstro1
│   ├── bin
│   │   ├── Hello1
│   │   └── qt.conf
│   ├── Hello1.sh
│   ├── lib
│   │   ├── libicudata.so.56
│   │   ├── libicui18n.so.56
│   │   ├── libicuuc.so.56
│   │   └── libQt5Core.so.5
│   └── translations
│   ├── qtbase_ar.qm
│   ├── qtbase_bg.qm
│   ├── qtbase_ca.qm
│   ├── qtbase_cs.qm
│   ├── qtbase_da.qm
│   ├── qtbase_de.qm
│   ├── qtbase_en.qm
│   ├── qtbase_es.qm
│   ├── qtbase_fi.qm
│   ├── qtbase_fr.qm
│   ├── qtbase_gd.qm
│   ├── qtbase_he.qm
│   ├── qtbase_hu.qm
│   ├── qtbase_it.qm
│   ├── qtbase_ja.qm
│   ├── qtbase_ko.qm
│   ├── qtbase_lv.qm
│   ├── qtbase_pl.qm
│   ├── qtbase_ru.qm
│   ├── qtbase_sk.qm
│   ├── qtbase_uk.qm
│   └── qtbase_zh_TW.qm
└── Dstro2
├── bin
│   ├── Hello2
│   ├── Hello3
│   └── qt.conf
├── Hello2.sh
├── Hello3.sh
├── lib
│   ├── libicudata.so.56
│   ├── libicui18n.so.56
│   ├── libicuuc.so.56
│   └── libQt5Core.so.5
└── translations
├── qtbase_ar.qm
├── qtbase_bg.qm
├── qtbase_ca.qm
├── qtbase_cs.qm
├── qtbase_da.qm
├── qtbase_de.qm
├── qtbase_en.qm
├── qtbase_es.qm
├── qtbase_fi.qm
├── qtbase_fr.qm
├── qtbase_gd.qm
├── qtbase_he.qm
├── qtbase_hu.qm
├── qtbase_it.qm
├── qtbase_ja.qm
├── qtbase_ko.qm
├── qtbase_lv.qm
├── qtbase_pl.qm
├── qtbase_ru.qm
├── qtbase_sk.qm
├── qtbase_uk.qm
└── qtbase_zh_TW.qm
8 directories, 60 files
```
As you can see from the result tree, we got 2 distributions.
1. Dstro1 - contains the application Hello1
2. Dstro2 - contains the remaining 2.
Now let's check what happens if all this is packaged by the installer. Add the qif option to true in CQtDeployer.json: ** qif: true, **.
``` js
{
"binDir": ".",
"clear": true,
"qif": true,
"libDir": "./",
"recursiveDepth": 5,
"targetPackage": [
["Dstro1", "Hello1"],
["Dstro2", "Hello2"],
["Dstro2", "Hello3"]
]
```
![image](https://user-images.githubusercontent.com/12465465/77245542-534ce600-6c30-11ea-9323-72ec5e200f39.png)
As can be seen from the screenshot, now we have 2 packages during installation.
## New aliases
And the last small but nice addition: now new commands have been added to cqtdeployer.
* сqt — is a quick way to deploy your application. It simplifies the deployment call.
* Example:
**cqt myApp** — this is the same as **cqtdeployer -bin myApp**.
* cqtdeployer.cqt - same as cqt but for snap package.
* В windows-версии теперь не нужно добовлять знак % для вызова утилиты.
* In the windows version, now there is no need to add the% sign to call the utility.
Now the call looks like in Linux. (cqtdeployer)

22
docs/en/1_5.md Executable file
View File

@ -0,0 +1,22 @@
# Release of the C ++ / Qt and QML application deployment utility CQtDeployer v1.5.0
## Complete list of all changes
## CQtDeployer 1.5.0 Alpha
### Fixes
- bug fixes and improvements.
### New features
- Added new theme for qif installer "quasarDark".
- Added support for work with custom template for qif option.
- Added support for debian packages with.
### New parameters
- zip - create a ZIP archive for deployable programs
- deb - Create the deb package for deployment programm
- homepage - Sets the homepage url for a package
## Detailed analysis of the most interesting changes.
# To be completed

View File

@ -0,0 +1,49 @@
# Build from sources
## Build for Linux
- install qt and qt QtInstallFrameWork from [qt installer](https://www.qt.io/download-qt-installer?hsCtaTracking=9f6a2170-a938-42df-a8e2-a9f0b1d6cdce%7C6cb0de4f9bb77-7bb77-4bb77-4)
- git clone https://github.com/QuasarApp/CQtDeployer.git
- cd CQtDeployer
- git submodule update --init --recursive
- qmake -r
- Here you must definitely call the qmake that was loaded from the 1st item.
- Example: ~/Qt/5.15.0/gcc_64/bin/qmake -r
- make -j$(nproc)
- make deploy
- #this command requires installed [cqtdeployer](https://github.com/QuasarApp/CQtDeployer/releases)
- ./Distro/CQtDeployerInstaller.run
## Build for Windows (CMD)
- install qt and qt QtInstallFrameWork from [qt installer](https://www.qt.io/download-qt-installer?hsCtaTracking=9f6a2170-a938-42df-a8e2-a9f0b1d6cdce%7C6cb0de4f9bb77-7bb77-4bb77-4)
- git clone https://github.com/QuasarApp/CQtDeployer.git
- cd CQtDeployer
- git submodule update --init --recursive
- SET PATH=C:/Qt/Tools/mingw810_64/bin;%PATH%
- It is important to set up the qt environment.
- qmake.exe -r
- Here you must definitely call the qmake that was loaded from the 1st item.
- Example: C:/Qt/5.15.0/mingw81_64/bin/qmake.exe -r
- migw32-make -j8
- migw32-make deploy
- #this command requires installed [cqtdeployer](https://github.com/QuasarApp/CQtDeployer/releases)
- ./Distro/CQtDeployerInstaller.exe
---
# Installation without building
You can download the latest version of the application [here](https://github.com/QuasarApp/CQtDeployer/releases).
### Snap
[![Get it from the Snap Store](https://snapcraft.io/static/images/badges/en/snap-store-black.svg)](https://snapcraft.io/cqtdeployer)
#### Features of the snap version
If you are using the snap version of the application. Enable all permissions for cqtdeployer.
this can be done in the snap-store
Or starting with ubuntu 20.04 in the ubuntu application settings manager.
If you do not have the GUI then you can enable all permissions using next commands:
``` bash
sudo snap connect cqtdeployer:process-control
sudo snap connect cqtdeployer:removable-media
sudo snap connect cqtdeployer:system-backup
```

241
docs/en/Changelog.md Executable file
View File

@ -0,0 +1,241 @@
# Chnage log for all versions of the CQtDeployer.
## CQtDeployer 1.5.0 Alpha
### Corrections
- bug fixes and improvements.
### New Features
- Added a new Theme for qif installer "quasarDark".
### New options
- zip - create the ZIP arhive for deployement programm
## CQtDeployer 1.4.7
### Corrections
- Fixed deploy the qxcb plugin. #438
- Fixed deploy the qtGui module. #446
### New Features
- Added support of Qt6 #437
- Added support of Qt installer Framework 4 (with improved command line interface experience) #436
## CQtDeployer 1.4.6
### Corrections
- Fixed deploy sql drivers #367
- Fixed algorithm of deploy libraryes. #423 #371
- Fixed working with a qt from the linux system repository. (classic instaler only) #422
- Fixed snap version of cqtdeployer, added support for qmake search by RPATH #424 #420
- Fixed help message.
- Minor bug fixes and improvements.
- Removed deprecated option extractPlugins. #371
### New options
- noQt - Ignore the error of initialize of a qmake. Use only if your application does not use the qt framework.
## CQtDeployer 1.4.5
### Corrections
- Optimized project deployment performance. 60% faster.
- Optimized output size of distributions. Size reduced by 25%.
- Fixed display of shortcuts after installing deployed applications.
- Fixed launching applications with spaces in the name. Thanks @ahndee (#384)
- Fixed deployment of the Renderer plugin.
- Minor bug fixes and improvements.
### New Features
- Added a new deployment plugin management system.
### New options
- extraPlugin - sets an additional path to third-party application plug-in
- enablePlugins - enables additional plugins for distribution.
- disablePlugins - disables plugins for distribution.
## CQtDeployer 1.4.4
### New options
- qifFromSystem - force use system binarycreator tool of qif from path or qt.
## CQtDeployer 1.4.3
### Fixes
- Fixed display of the application downloaded from the snap store and installers in the ubuntu 20.04 application settings menu
### New features
- added support recursive ignore for ignoreEnvirement #356
### New options
- noRecursiveiIgnoreEnv - Disables recursive ignore for ignoreEnv option.
## CQtDeployer 1.4.2
### Fixes
- fixed #337 (error generate installer with custom name)
- fixed #338 (windows version collect pdb files)
- fixed #339 (error of show all help messages)
- fixed #340 (cqdeployer don't added a targets dirs into "ignore")
- fixed #341 (The clear option don't delete old installer)
## CQtDeployer 1.4.1
### Fixes
- Fixed Not deploying platformthemes (#324)
- Fixed create shortcuts on windows (#322)
- Minor improvements and fixes
## CQtDeployer 1.4.0
### Fixes
- Fixed The help output in the console, now the actual size of the console is recounted before the output, which allows you to correctly transfer text.
- Fixed work with the deployment of Qt plugins. Now plug-ins do not extract all system dependencies, but only qt. Extract system dependencies caused applications to crash due to incompatible plugin libraries.
- Minor bug fixes and improvements.
### New features
- Added support for qmake search from the system environment.
- Added the ability to initialize the repository for further packaging, similar to git init.
- Added support for Qt Install Framework packages. Now you can pack the distribution into the installer.
- Added the ability to split the final distribution into several packages.
- Added the ability to unify the creation of packages for the final distribution.
- Added support for adding custom scripts to application launch scripts.
- Added support for extracting system dependencies for Windows.
- Added support for RPATH for Linux. Now cqtdeployer can independently determine the necessary qmake to deploy the application.
- Added support for finding the required dependency by library name.
- Added support for Qt libraries from Linux distributions repositories.
- Added new alias for the run command (cqt and cqtdeployer.cqt) for fast deploy of applications.
- Added support the native name of command for windows. Now you can run a cqtdeployer from cqtdeployer commnad in cmd and powershell.
### New options
- init - will initialize cqtdeployer.json file (configuration file). For example: "cqtdeployer init" - to initialize the configuration of a base package. "cqtdeployer -init multi" - to initialize the configuration of several packages.
- noCheckRPATH - disables the automatic search for paths to qmake in executable files (Linux only).
- noCheckPATH - disables the automatic search for paths to qmake in the system environment.
- extractPlugins - forces to extract all plug-in dependencies.
- qif - creates an installer at the end of the deployment.
- extraLibs - adds a template for an additional library, which should be included in the distribution.
- customScript - adds a custom script to the startup script of the application.
- -targetPackage [package; tar1, package; tar2] - used to form packages, denotes lists of target files for specific packages.
- recOut - indicates in which folder the resources will be added after deployment.
- name - sets the name of the package.
- description - sets the package description
- deployVersion - sets the package version
- releaseDate - sets the release date of the package.
- icon - sets the package icon.
- publisher - sets the publisher of the package.
- qifStyle - Sets the path to the CSS style file or sets the default style. Available styles: quasar
- qifBanner - Sets path to the banner png file.
- qifLogo - Sets path to the logo png file.
## CQtDeployer 1.3.2
- Fixed #218 (The CQtDeployer adding sh scripts for target libraries.)
- Fixed #217 (The Qmake option did not work with the configuration file.)
---
## CQtDeployer 1.3.1
- Fixed a task #191 (ignore command for plugins)
- Fixed a task #192 (invalid paths when creating)
- Fixed absalute pathes of deployement file (see [confFile](https://github.com/QuasarApp/CQtDeployer/wiki/DeployConfigFileEn))
---
## CQtDeployer 1.3.0
- Added support of qt.conf for Linux
- Added support of config file for project (deploy.json) with all rules of deployment, for create deploy.json use flag -confFile [./path/to/file.json],
- Added support of output dirs for all deployement files #145,
- Added support of deploy WebEngine #146
- Added support multi package in cqtdeployer installer
- Renamed project from Console-QtDeployer to CQtDeployer #139
- Fixed deployment of system libs in linux #172
- Added new tests of application
- Removed flag noLibC and added flag deploySystem-with-libc. If you need libc in the program, use the deploySystem-with-libc flag, and if not, use deploySystem.
- The always-overwrite flag has been replaced with noOverwrite, now all files are overwritten by default, use noOverwrite to disable overwriting.
---
## CQtDeployer 1.2.3
- Added support of qt.conf for Windows builds #130
- Fixed bug #129 now the 'clear' flag remove only copied files.
- Fixed ignoreEnv flag
- Fixed deploySystem flag
---
## CQtDeployer 1.2.2
- Added new flag noLibc for ignore libc and li-linux libs
- Fixed bug #125 Deployed system lib (working with simple projects, for big projects no recommended)
- Fixed ignoreEnv flag
---
## CQtDeployer 1.2.1
- Added new ignore flag (ignoreEnv). This flag disables unnecessary environment
- Added support QIFW (online installer for windows and Other Linux distributives)
- Added support update for windows and Other Linux distributives (not snap)
- Fixed bug #116 (copy files from removable media)
- Fixed bug #115 (create target in folder with russean name)
- Fixed big size of msvc version
- FIxed crossdeploy Linux >> Windows
- Removeв old build scripts
---
## CQtDeployer 1.2.0
- Added own qml dependecies scaner.
- Moved to used a new [PE-Lib scaner](https://github.com/QuasarApp/pe-parse/tree/7138bb218a05c81d825728ba8a0a6f6a56c4fdbc).
- Moved to used a new [ELF-lib scaner](https://github.com/qt/qttools/blob/b0147a5d79ce7a7e77a24f36aaddfacb1a1517c8/src/shared/winutils/elfreader.h).
- Added a new unit tests.
- Added support of snap version (home dir only).
- Added new flag qmlExtern - for use qt qml import scaner.
- Added support a levels of verbose log (0-3).
- Fixed log of deploy app.
- Fixed deploy the app on snap version.
---
## CQtDeployer 1.1.2
- Added support of translations
- Added a flag for disable deploy translations
- Added the strip flag on linux version
- Added unit tests
- Fixed deploy with shared version
- Fixed bug deploy on current dir with snap and static versions
---
## CQtDeployer 1.1.1
- Fixed qml build in dinomisc version
- Fixed -recursiveDepth flag
- Fixed -libDir flag operation
- The output of the application has been cleaned, a part of the log has been moved to verbose
---
## CQtDeployer 1.1.0
- Added windows support (dynamic linking only)
- Added support for snap (now available in the snapstore)
- Added snap build scripts
- Added flag binDir allowing recursively to capture exe dll and so
- Changed the logic of the bin flag now, if you select a folder in the file location, then all its contents will be captured
- Changed and corrected the logic of the clear flag now it cleans all the expanded content on a specific target.
- Added flag targetDir which defines the place where the expanded project will lie
- The structure of the deployed project has been changed, now all the launch shells are in the root and the binaries are in the bin folder, a launch script of the same name is created for each binary.
- Removed old runScript flag due to change of deployment logic
- Added verbose flag for debugging by
- Fixed performance bugs
---
## CQtDeployer 1.0.2
- Added a script to build (dynamic and static release)
- Added flag -libDir to install additional path for additional libraries of the application
- Added flag -extraPlugin to install an additional path for additional application plugins
- Added build for C libraries only
- Fixed deployment
- Fixed startup script
- Fixed static build
---
## CQtDeployer 1.0.1
- fix qml deploy (redundancy)
- fix run script
---
## CQtDeployer 1.0.0
- Added a flag runScript
- Added a flag allQmlDependes
- Fixed bug of deploy qml
- Fixed bug of deploy plugins
- Added support static build

View File

@ -0,0 +1,15 @@
# Compare Features of Distributions of the CQtDeployer
### snap vs installer vs windows installer
| Feature name | Classic linux version (Installer) | Snap Version | Windows version |
|---|---|---|----|
| Automatic updates | NO | YES | NO |
| Online updates | YES | YES | YES |
| Deploy system libraries | YES | YES | YES |
| Create installers | YES | YES | YES |
| Create archives | YES | YES | YES |
| Search of libraries and cmake from environment | YES | NO | YES |
| Search of the qmake from a RPATH | YES | YES | NO |
| Support of the 'strip' command | YES | NO | NO |
| Support work with the qmake from a system repository of OS| YES| NO| NO |

45
docs/en/DEB.md Normal file
View File

@ -0,0 +1,45 @@
## General rules for using DEB
#### Available from version CQtDeployer 1.5
### How to use deb option
Just add to cqtdeployer option "deb".
#### For example:
``` bash
cqtdeployer ... deb
```
Where:
* **...** - is list of other options.
* **deb** - option for create the deb package.
By default, cqtdeployer will create one deb package.
If you want create multi package destribution, you should use [Controll of packages options](https://github.com/QuasarApp/CQtDeployer/wiki/Options)
To create a new package, use the -targetPackage [package; tar1] option
cqtdeployer create deb package for each packages.
Where:
* **package** - it is package name
* **tar1** - it is name of the target that should be included in this package.
Or you can describe packages in [configuration file](https://github.com/QuasarApp/CQtDeployer/wiki/DeployConfigFileEn)
```json
{
"targetPackage": [
[
"package",
"tar1"
],
],
"deb": true
}
```

223
docs/en/DeployConfigFile.md Normal file
View File

@ -0,0 +1,223 @@
## Deployment file
**Deployment file** - it's a json file containing the parameters for cqtdeployer. This file supports all parameters except confFile, since this parameter is responsible for connecting and initializing the file itself.
### Configuration file structure
```json
{
"Bool option": true/false,
"Option": "Value",
"Enumeration-enabled option": [
"Value 1",
"Value 2",
"Value 3",
],
"Option with support for multilevel enumerations": [
[
"Value A1",
"Value A2"
],
[
"Value B1",
"Value B2"
],
[
"Value C1",
"Value C2"
],
]
}
```
Read more about cqtdeployer options in the [options](Options) section.
Examples of the contents of this file:
File without using enumerated parameters
```json
{
"noOverwrite": false,
"bin": "./",
"binDir": "./",
"qmlDir": "./",
"deploySystem": false,
"deploySystem-with-libc": false,
"qmake": "my/custom/path/to/qmake",
"ignore": "ignoreLib.dll",
"ignoreEnv": "/my/ignore/path",
"clear": true,
"force-clear": false,
"allQmlDependes": false,
"libDir": "./",
"recursiveDepth": 3,
"extraLibs": "myExtraLib (libssl)",
"extraPlugin": "myExtraPulgin (platforms)",
"targetDir": "./Distro",
"targetPackage": "",
"noStrip": false,
"extractPlugins": false,
"noTranslations": false,
"qmlOut": "qml",
"libOut": "lib",
"trOut": "tr",
"pluginOut": "plug",
"binOut": "bin",
"recOut": "rec",
"verbose": 3,
"qif": false,
"noCheckRPATH": false,
"noCheckPATH": false,
"name": "mainApplication",
"description": "this is description for default package",
"deployVersion": "1.0.0",
"releaseDate": "yyyy-MM-dd",
"icon": "/path/main/icon.png",
"publisher": "main team",
"customScript": "echo 'I am use custom script!!!'"
}
```
File Using Enumerated Parameters
``` json
{
"noOverwrite": false,
"bin": "./",
"binDir": "./",
"qmlDir": [
[
"package2",
"./TestQMLWidgets/"
],
[
"./qml/for/All"
]
],
"deploySystem": false,
"deploySystem-with-libc": false,
"qmake": "this parameter should contain the path to your qmake, for Windows this field is required. On Linux, you can remove it, then qmake will be found by rpath.",
"ignore": "ignoreLib.dll",
"ignoreEnv": "/my/ignore/path",
"clear": true,
"force-clear": false,
"allQmlDependes": false,
"libDir": "./",
"recursiveDepth": 3,
"extraLibs": "myExtraLib (libssl)",
"extraPlugin": "myExtraPulgin (platforms)",
"targetDir": "./Distro",
"targetPackage": [
[
"/package1/",
"TestOnlyC"
],
[
"/package2/",
"TestQMLWidgets"
]
],
"noStrip": false,
"extractPlugins": false,
"noTranslations": false,
"qmlOut": "qml",
"libOut": "lib",
"trOut": "tr",
"pluginOut": "plug",
"binOut": "bin",
"recOut": "rec",
"verbose": 3,
"qif": false,
"noCheckRPATH": false,
"noCheckPATH": false,
"name": [
[
"package2",
"package2Application"
],
[
"mainApplication"
]
],
"description": [
[
"package2",
"this is description for package 'package2'"
],
[
"this is description for default package"
]
],
"deployVersion": [
[
"package2",
"1.0.0"
],
[
"1.0.0"
]
],
"releaseDate": [
[
"package2",
"yyyy-MM-dd"
],
[
"yyyy-MM-dd"
]
],
"icon": [
[
"package2",
"/path/icon.png"
],
[
"/path/main/icon.png"
]
],
"publisher": [
[
"package2",
"team of package2"
],
[
"main team"
]
],
"customScript": "echo 'I am use custom script!!!'"
}
```
The purpose of file is to simplify the cqtdeployer's call and move some of the parameters into a file. The parameters specified in the file have a lower priority than the parameters added to the console at the run.
### Creating of the file
#### The first method
1. Call `cqtdeployer init` to initialize the file for a single-package application.
Or `cqtdeployer -init multi` to initialize the file for a project with multiple packages.
2. Open CQtDeployer.json and edit it to fit your needs.
3. Call 'cqtdeployer' in the directory with the file 'CQtDeployer.json', or specify the path to it using the flag '-confFile path/to/my/CQtDeployer.json'
#### The second method
Call the cqtdeployer with a set of parameters you need and specify the path to the file using -confFile flag (the file should be absent). If the file exists, cqtdeployer will start unloading the parameters from it.
An example:
``` bash
cqtdeployer -confFile deploy.json -bin CQtDeployerInstaller -targetDir ./test -qmlOut myqml -binOut mybin -libOut mylib -pluginOut myplugins noStrip noTranslations -recursiveDepth 5 -extraPlugin sqldrivers,audio,mediaservice force-clear deploySystem noOverwrite
```
Where:
* cqtdeployer - the call of cqtdeployer
* -confFile deploy.json - the path to the file,that should be created
* "-bin CQtDeployerInstaller -targetDir ./test -qmlOut myqml -binOut mybin -libOut mylib -pluginOut myplugins noStrip noTranslations -recursiveDepth 5 -extraPlugin sqldrivers,audio,mediaservice force-clear deploySystem noOverwrite" - necessary parameters.
### Using of the deployment file.
Use the flag -confFile [path to the file] to make cqtdeployer start reading the parameters from the file
#### Example:
cqtdeployer -qmake ~/Qt/bin/qmake -confFile ./deploy.json

8
docs/en/Description.md Normal file
View File

@ -0,0 +1,8 @@
## What is CQtDeployer
The CQtDeployer is application for extract all depends library of executable and create launch script for your application.
Key differences of this program:
* Performance: this program deploys the application several times faster (up to 10 seconds)
* Flexibility: this utility got flags that help you to configure the deployment for your or your project's needs
* Crossdeploy: this utility support windows and linux distrebutives, This means that you can use it not only to deploy a project for your platform, but also to deploy a project on Linux for Windows and vice versa.
* Packaging - this utility can create installation files and packages for your application.

2
docs/en/Donate.md Normal file
View File

@ -0,0 +1,2 @@
## Support the project
If you like what we do and it benefits you, you can support the project on the official page [QuasarApp in Patreon](https://www.patreon.com/QuasarApp)

113
docs/en/Guide.md Normal file
View File

@ -0,0 +1,113 @@
### Introduction
In this article we will look at how to properly collect all qt dependencies for your application, which was collected dynamically.
### For a start, a little theory.
### Why is this needed?
There are several ways to build applications, the main ones are:
* Static build
Static assembly involves the creation of a binary, which will be all the necessary links to it. In other words, all that is needed for his work will lie in it. This approach is suitable for small console applications that have few dependencies, otherwise the size of the final binary will be extremely large.
* Dynamic build
It differs from static in that only the source code of your application will be in the binary (the size of the binary will be minimal), but when you run such an application it will need third-party libraries that were used when writing it.
### Now a little description.
The CQtDeployer is application for extract all depends library of executable and create launch script for your application.
### Let's take an example.
For example, I wrote a simple qt application using qml - MyApp.
### MyApp (main.cpp)
```cpp
#include <QGuiApplication>
#include <QQmlApplicationEngine>
int main (int argc, char * argv [])
{
QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
QGuiApplication app (argc, argv);
QQmlApplicationEngine engine;
engine.load (QUrl (QStringLiteral("qrc: /main.qml")));
if (engine.rootObjects ().isEmpty )
return -1;
return app.exec ();
}
```
### MyApp (main.qml)
```qml
import QtQuick 2.9
import QtQuick.Controls 2.2
ApplicationWindow {
visible: true
width: 640
height: 480
title: qsTr ("Scroll")
ScrollView {
anchors.fill: parent
ListView {
width: parent.width
model: 20
delegate: ItemDelegate {
text: "Item" + (index + 1)
width: parent.width
}
}
}
}
```
MyApp is linked dynamically, that is, it needs qt libraries to work.
If we try to start the application, right after the build we get an error:
``` bash
~/build-MyApp-Desktop_Qt_5_11_1_GCC_64bit4-Release $ ./MyApp ./MyApp: /usr/lib/x86_64-linux-gnu/libQt5Qml.so.5: version `Qt_5 'not found (required by ./MyApp)
./MyApp: /usr/lib/x86_64-linux-gnu/libQt5Gui.so.5: version `Qt_5 'not found (required by ./MyApp)
./MyApp: /usr/lib/x86_64-linux-gnu/libQt5Core.so.5: version `Qt_5.11 'not found (required by ./MyApp)
./MyApp: /usr/lib/x86_64-linux-gnu/libQt5Core.so.5: version `Qt_5 'not found (required by ./MyApp)
```
From similar texts, we see that the application depends on the GUI qt libraries and qml libraries. Search and build all resources (libraries and plugins) will take a lot of time.
To save time and effort, we will use the CQtDeployer utility (you can download it [here](https://github.com/QuasarApp/CQtDeployer/releases))
or install in Snap Store
[![Download from the Snap Store](https://snapcraft.io/static/images/badges/ru/snap-store-black.svg)](https://snapcraft.io/cqtdeployer)
``` bash
cqtdeployer -bin myApp -qmake /media/D/Qt/5.12.3/gcc_64/bin/qmake -qmlDir ./
```
After executing this command, you will receive a fully ready application for work with a ready launcher, which will set up all the necessary environments for your application to work on all machines running Linux.
### Total
After running the QtDeployer, the contents of the folder with your application should look like this:
``` bash
drwxr-xr-x 7 andrei andrei 4096 May 24 12:22 ./
drwxrwxr-x 3 andrei andrei 4096 May 24 12:22 ../
drwxr-xr-x 2 andrei andrei 4096 May 24 12:22 bin/
drwxr-xr-x 2 andrei andrei 4096 May 24 12:22 lib/
-rwx---rwx 1 andrei andrei 433 May 24 12:22 myApp.sh*
drwxr-xr-x 6 andrei andrei 4096 May 24 12:22 plugins/
drwxr-xr-x 5 andrei andrei 4096 May 24 12:22 qml/
drwxr-xr-x 2 andrei andrei 4096 May 24 12:22 translations/
```
![cqtdeployer result](https://user-images.githubusercontent.com/12465465/58318590-bdcea300-7e20-11e9-8b45-37a13aeef222.png)
* myApp.sh - your application launch script
* bin - the folder with your binary
* lib - the folder with all necessary dependencies of your application.
* plugins - the qt plugins needed for an application to work
* qml - the folder with qml dependencies.
* translations - the folder with standard qt translations.
So, you can prepare your application for packaging in a deb or snap package, after which you can begin to distribute it. Note that after running cqtdeployer, your application must be launched using the sh script, which will set up the necessary environment for your application.

18
docs/en/Home.md Normal file
View File

@ -0,0 +1,18 @@
# Welcome to the "C Qt Deployer"!
# ![Logo](https://user-images.githubusercontent.com/12465465/84260958-99289480-ab23-11ea-8aab-374368a545dc.png)
***************************
# Main sections
* [Description CQtDeployer](https://github.com/QuasarApp/CQtDeployer/wiki/Description)
* [Options](https://github.com/QuasarApp/CQtDeployer/wiki/Options)
* [Guide](https://github.com/QuasarApp/CQtDeployer/wiki/Guide)
* [Quick guide](./quickguide)
* [Build and Install](https://github.com/QuasarApp/CQtDeployer/wiki/Build-and-Install)
* [Example](https://github.com/QuasarApp/CQtDeployer/tree/master/examples/TestQMLWidgets)
* [Deploy file](https://github.com/QuasarApp/CQtDeployer/wiki/DeployConfigFileEn)
* [Packing](https://github.com/QuasarApp/CQtDeployer/wiki/Packing(en))
* [Change log page](https://github.com/QuasarApp/CQtDeployer/wiki/ChangelogEn)
* [Reviews](https://github.com/QuasarApp/CQtDeployer/wiki/ReleaseReviews.en)
* [Compare Features](https://github.com/QuasarApp/CQtDeployer/wiki/CompareFeatures)

2
docs/en/Languages.md Normal file
View File

@ -0,0 +1,2 @@
* [Рус](https://github.com/QuasarApp/CQtDeployer/wiki/%D0%94%D0%BE%D0%BC%D0%B0%D1%88%D0%BD%D1%8F%D1%8F-%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%BA%D0%B0)
* [Eng](https://github.com/QuasarApp/CQtDeployer/wiki)

117
docs/en/Options.md Normal file
View File

@ -0,0 +1,117 @@
## General rules for using options
```
cqtdeployer -option1 value1 -option2 list, of, values flag1 flag2 flag3
```
* All options must begin with a '-' sign.
* After specifying the desired option, you must specify the value.
* Some options support enumerations (arrays of values). When initializing such options, specify the list of values through ',' without spaces. If you use any programming language and call the cqtdeployer process, then the array of values must be passed as 1 parameter.
* Some options support redistributions with the ability to select the target for which the flag will be applied. Target and values are separated using the ';' sign. Example -libOut target1;value1,target2;value2,defaultValue.
* To include a flag, simply include the flag name in the list of options.
## Description of values in the table
* **-binDir [params]** - option without array support.
* **-bin [params,list]** - option with support for arrays. The delimiter used is ','.
* **-libOut [package;path,path]** - parameter with support for selecting the package for which the flag value is set. As a separator, use ';'. Please note that the rule described above is used to enumerate parameter values. The last parameter does not have a package value, this means that this value will be set for all non-configured packages by default.
* **clear** - boolean option
## Options:
### Boolean options
| Option | Descriptiion |
|-----------------------------|-----------------------------------------------------------|
| init | will initialize cqtdeployer.json file (configuration file)|
| | For example: "cqtdeployer init" - for initialize base package configuration|
| | "cqtdeployer -init multi" - for initialize multi package configuration|
| | "cqtdeployer -init single" - for initialize single package configuration |
| help / h | Shows help. |
| clear | Deletes deployable files of the previous session.
| force-clear | Deletes the destination directory before deployment. |
| noStrip | Skips strip step |
| noTranslations | Skips the translations files. |
| | It doesn't work without qmake and inside a snap package |
| noOverwrite | Prevents replacing existing files. |
| noCheckRPATH | Disables automatic search of paths to qmake in executable files.|
| noCheckPATH | Disables automatic search of paths to qmake in system PATH. |
| noRecursiveiIgnoreEnv | Disables recursive ignore for ignoreEnv option. |
| v / version | Shows compiled version |
| allQmlDependes | Extracts all the qml libraries. |
| | (not recommended, as it takes great amount of computer memory) |
| qif | Create the QIF installer for deployment programm" |
| | Example: cqtdeployer qif" }, |
| | Starting with CQtDeployer 1.5 you can specify the path to your own installer template. |
| | Examples: cqtdeployer -qif path/to/myCustom/qif. More details can be found [here](https://github.com/QuasarApp/CQtDeployer/wiki/QIF(en)) |
| deb | Create the deb package for deployment programm" |
| | Example: cqtdeployer deb" }, |
| | you can specify the path to your own DEBIAN template. |
| | Examples: cqtdeployer -deb path/to/myCustom/DEBIAN. More details can be found [here](https://github.com/QuasarApp/CQtDeployer/wiki/DEB(en)) |
| deploySystem | Deploys all libraries not recomendet because there may be conflicts with system libraries |
| deploySystem-with-libc | Deploy all libs include libc (only linux). Do not use this option for a gui application, for gu use the deploySystem option |
### Deploy options:
| Option | Descriptiion |
|-----------------------------|-----------------------------------------------------------|
| -bin [list, params] | Deployable file or folder. |
| | For example -bin ~/my/project/bin/,~/my/project/bin.exe |
| -binDir [params] | A folder which includes deployable files (recursive search). |
| -confFile [params] | The path to the json file with all deployment configurations.|
| | Using this file, you can add the necessary options, |
| | thereby simplifying in the command invocation the console. |
| | However, the parameters in Kansol have a higher priority than in the file.|
| | For more info about this flag see [wiki](https://github.com/QuasarApp/CQtDeployer/wiki/DeployConfigFileEn) |
| -qmlDir [params] | Qml data dir. For example -qmlDir ~/my/project/qml |
| -qmake [params] | Qmake path. For example |
| | -qmake ~/Qt/5.14.0/gcc_64/bin/qmake |
| -ignore [list,params] | The list of libs to ignore. |
| | For example -ignore libicudata.so.56,libicudata2.so.56 |
| -ignoreEnv [list,params] | The list of the environment to ignore. |
| | For example -ignoreEnv /bad/dir,/my/bad/Dir |
| -libDir [list,params] | Sets additional paths for extra libs of an app. |
| | For example -libDir ~/myLib,~/newLibs |
| -extraLibs [list,params] | Sets the mask of the library name for forced copying. |
| | Example: "-extraLib mySql" - forces to copy all libraries whose |
| |names contain mySql to the project folder. This option is case sensitive. |
| -customScript [scriptCode]| Insert extra code inTo All run script. |
| -extraPlugin [list,params]| Sets an additional path to extraPlugin of an app |
| -recursiveDepth [params] | Sets the Depth of recursive search of libs and ignoreEnv (default 0) |
| -targetDir [params] | Sets target directory(by default it is the path to the first deployable file)|
| -verbose [0-3] | Shows debug log |
## Controll of packages options:
| Option | Descriptiion |
|-----------------------------|-----------------------------------------------------------|
| -targetPackage [package;tar1,package;tar2]| Creates a new package and adds 'tar1 and tar2' to it |
| -qmlOut [package;path,path] | Sets path to qml out directory |
| -libOut [package;path,path] | Sets path to libraries out directory |
| -trOut [package;path,path] | Sets path to translations out directory |
| -pluginOut [package;path,path]| Sets path to plugins out directory |
| -binOut [package;path,path] | Sets path to binary out directory |
| -recOut [package;path,path] | Sets path to recurses out directory |
| -name [package;val,val] | Sets name for package. If this if you do not specify a package, the value will be assigned to the default package ("")|
| -description [package;val,val] | Sets description for package |
| -deployVersion [package;val,val] | Sets version for package |
| -releaseDate [package;val,val] | Sets release date for package |
| -icon [package;val,val] | Sets path to icon for package |
| -publisher [package;val,val]| Sets publisher for package |
| -homepage [package;val,val] | Sets the homepage url for a package |
## Plugins Controll Options
| Option | Descriptiion |
|-----------------------------|-----------------------------------------------------------|
| -extraPlugin [package;val1;val2,SingeleVal]| Sets an additional path to third-party application plug-in |
| -enablePlugins [package;val1;val2,SingeleVal] | Enables additional plugins for distribution. |
| -disablePlugins [package;val1;val2,SingeleVal]| Disables plugins for distribution. |
| |You can disable any plugin of your Qt build, just see the yourQtFolder/plugins forlder for available plugins.|
| |Example: if you want disable qxcb plugin: -disablePlugins qxcb. Note that the name of the plugin is indicated without its extension.|
## QtInstallFramework options:
| Option | Descriptiion |
|-----------------------------|-----------------------------------------------------------|
| -qifStyle [path/to/style.css]| Sets the path to the CSS style file or sets the default style. Available styles: quasar |
| -qifBanner [path/to/banner.png]| Sets path to the banner png file. |
| -qifLogo [path/to/logo.png]| Sets path to the logo png file. |
#### Example: cqtdeployer -bin myApp -qmlDir ~/MyAppProject/qml -qmake ~/Qt/5.14.1/gcc_64/bin/qmake clear

127
docs/en/Packing.md Normal file
View File

@ -0,0 +1,127 @@
# General information on packaging your distributions in packages.
## Packaging Types
* Automatic
* Manual
## Automatic Packages
Packages with this type creates automaticly.
By default the distribution have a one main package. You can configure it using [Controll of packages options](Options.md).
#### Example (Set new name for pacakge)
```
ctdeployer ... -name "MyPackage"
```
If your distribution have a multiple executable files then you can be create a distribution with multiple package.
One package can contain from 1 to infinity of executable files.
For configure a package you must be use the targetPackage option.
Example of using:
```
cqtdeployer ... -targetPackage myPacage;target1,myPacage2;target2
```
Where myPacage is a name of package and target1 is a name of executable file.
so This example create 2 packages from 2 targets.
The Next example create a 2 packages from 3 targets.
```
cqtdeployer ... -targetPackage myPacage;target1,myPacage;target2,myPacage2;target3
```
You can also do the same in the config file
```
{
"targetPackage": [
[
"myPacage",
"target1"
],
[
"myPacage2",
"target2"
]
]
}
```
```
{
"targetPackage": [
[
"myPacage",
"target1"
],
[
"myPacage",
"target2"
],
[
"myPacage2",
"target3"
]
]
}
```
## Manual Packages
Manual packages is packages created by user template.
For example you have a aplication that must be execute a complex script on the debian package or the installer.
So you need to create your template and add tehe path to you template for a package option.
Example
```
cqtdeployer ... -qif /path/to/my/template/installer
```
The /path/to/my/template/installer folder must be contains a folder with the package name.
for example i am deploy application with the "MyExample" name, so my custom template must be locate in the
/path/to/my/template/installer/MyExample path.
For multi-package distributions, the same rules apply.
Your folder with the templates must be contains folders with same names as packages.
Example:
```
{
"targetPackage": [
[
"myPacage",
"target1"
],
[
"myPacage",
"target2"
],
[
"myPacage2",
"target3"
]
]
}
```
```
~/path/to/my/template/installer$ tree
.
├── myPacage
│ └── ...
└── myPacage2
└── ...
```
## Available packages
* [Qt Install Framework](https://github.com/QuasarApp/CQtDeployer/wiki/QIF(en) )
* [ZIP Arhive](https://github.com/QuasarApp/CQtDeployer/wiki/ZIP(en) )
* [DEB Package](https://github.com/QuasarApp/CQtDeployer/wiki/DEB(en) )

82
docs/en/QIF.md Normal file
View File

@ -0,0 +1,82 @@
## General rules for using Qt Installer Framwork
### What is Qt Installer Framwork
The **Qt Installer Framework** (QIF) provides a set of tools and utilities to create installers for the supported desktop Qt platforms: Linux, Microsoft Windows, and OS X.
In **CQtDeployer** QIF availabel in qif option.
### How to use qif option
The qif option invoke with path to custo qt installer template or with default installer template.
#### For example:
``` bash
cqtdeployer ... qif
```
Where:
* **...** - is list of other options.
* **qif** - option for use qt installer framework with default template.
By default, cqtdeployer will create an installation file with one package in which your entire distribution kit will lie.
If you want to configure it, you should use [Controll of packages options](https://github.com/QuasarApp/CQtDeployer/wiki/Options)
To create a new package, use the -targetPackage [package; tar1] option
Where:
* **package** - it is package name
* **tar1** - it is name of the target that should be included in this package.
Or you can describe packages in [configuration file](https://github.com/QuasarApp/CQtDeployer/wiki/DeployConfigFileEn)
```json
{
"targetPackage": [
[
"package",
"tar1"
]
],
}
```
# Custom Template for QIF
Starting with CQtDeployer Version 1.5 you can use your own installer template. To do this, you must pass the path to your template to the qif parameter.
### Template
The qif template should contain 2 folders:
* packages
* config
### Attention
The name of the packages in the packages folder must match the names of the packages during deployment.
For example:
``` json
"targetPackage": [
[
"myCustomInstaller",
"tar1"
]
],
```
``` bash
.
├── config
│ ├── config.xml
│ └── style.qss
└── packages
└── myCustomInstaller
└── meta
├── installscript.qs
└── package.xml
4 directories, 4 files
```
If the folder names do not match the package names then CQtDeployer will use the standard QIF package.

81
docs/en/QuickGuide.md Normal file
View File

@ -0,0 +1,81 @@
How to deploy project with cqtdeployer.
1. First one you need to install cqtdeployer into your platform
* Snap (14 more linux destributions):
```
sudo snap install cqtdeployer
```
Or
Install from snap store and add all requirement permissions.
[![Download from Snap Store](https://snapcraft.io/static/images/badges/ru/snap-store-black.svg)](https://snapcraft.io/cqtdeployer)
* Other linux [LinuxInstaller.run][1].
```
chmod +x LinuxInstaller.run
./LinuxInstaller.run
```
* Windows [installer][1]
2. Build your project on release mode.
3. Deploy yor executable file.
* For Linux systems:
``` bash
cqtdeployer -bin myexecutable
```
* For Windows systems:
``` bash
cqtdeployer -bin myexecutable.exe -qmake C:/Qt/5.15.0/min_gw/bin/qmake.exe
```
* For crossplatform build (Linux -> Windows)
``` bash
cqtdeployer -bin myexecutable.exe -qmake ~/crossbuildet-Qt/5.15.0/min_gw/bin/qmake
```
## Extra options
If you use extra libraries, just add path for cqtdeployer to used libs.
``` bash
cqtdeployer -bin myexecutable -libDir /PathToMyExtraLibs
```
If you want find libraries recursively from libDir path, just add recursive Depth option.
``` bash
cqtdeployer -bin myexecutable -libDir /PathToMyExtraLibs -recursiveDepth 5
```
If you application use qml, just add qmlDir option
``` bash
cqtdeployer -bin myexecutable -libDir /PathToMyExtraLibs -recursiveDepth 5 -qmlDir /path/to/my/qml/sources
```
If you want create simple installer for your application just add gif option.
```
cqtdeployer -bin myexecutable -libDir /PathToMyExtraLibs -recursiveDepth 5 -qmlDir /path/to/my/qml/sources qif
```
If you use system libraries from system PATH, just add deploySystem option.
#### Warning: snap version do not have permision to system files. To deploy system libraries use the cqtdeployer version from the [installer][1]
```
cqtdeployer -bin myexecutable -libDir /PathToMyExtraLibs -recursiveDepth 5 -qmlDir /path/to/my/qml/sources qif deploySystem
```
### If you have any problems with use cqtdeployer then ask you questions on the official github issues [page][2].
### For more options of CQtDeploye see oficial [documentation][3].
[1]: https://github.com/QuasarApp/CQtDeployer/releases
[2]: https://github.com/QuasarApp/CQtDeployer/issues
[3]: https://github.com/QuasarApp/CQtDeployer/wiki/Options

3
docs/en/ReleaseReviews.md Executable file
View File

@ -0,0 +1,3 @@
# Release Reviews
* [Review v1.4 (Binary Box)](https://github.com/QuasarApp/CQtDeployer/wiki/1_4_en)

45
docs/en/ZIP.md Normal file
View File

@ -0,0 +1,45 @@
## General rules for using ZIP
#### Available from version CQtDeployer 1.5
### How to use zip option
Just add to cqtdeployer option "zip".
#### For example:
``` bash
cqtdeployer ... zip
```
Where:
* **...** - is list of other options.
* **zip** - option for use zip arhives.
By default, cqtdeployer will create one zip arhive.
If you want create multi package destribution, you should use [Controll of packages options](https://github.com/QuasarApp/CQtDeployer/wiki/Options)
To create a new package, use the -targetPackage [package; tar1] option
cqtdeployer create zip arhive for each packages.
Where:
* **package** - it is package name
* **tar1** - it is name of the target that should be included in this package.
Or you can describe packages in [configuration file](https://github.com/QuasarApp/CQtDeployer/wiki/DeployConfigFileEn)
```json
{
"targetPackage": [
[
"package",
"tar1"
],
],
"zip": true
}
```

407
docs/ru/1_4.md Executable file
View File

@ -0,0 +1,407 @@
# Релиз утилиты развертывания С++/Qt и QML приложений CQtDeployer v1.4.0 (Binary Box)
Спустя почти полгода, вышло мажорное обновление утилиты развёртывания CQtDeployer.
В данном обновлении множество нововведений, но основной упор в сделан на создание пакетов.
## Полный список всех изменений
### Исправления
- Исправлен вывод справки в консоли, теперь перед выводом пересчитывается реальный размер консоли, что позволяет выполнять переносы текста правильно.
- Исправлена работа с развертыванием плагинов Qt. Теперь плагины не тянут за собой все системные зависимости, а только qt. Захват системных зависимостей приводил к падению приложений из-за несовместимости библиотек плагинов.
- Мелкие исправления и улучшения.
### Нововведения
- Добавлена поддержка поиска qmake из системного окружения.
- Добавлена возможность инициализировать репозиторий для дальнейшей упаковки аналогично git init.
- Добавлена поддержка Qt Install Framework пакетов. Теперь можно запаковать дистрибутив в инсталлятор.
- Добавлена возможность разбивать конечный дистрибутив на несколько пакетов.
- Добавлен механизм, позволяющий унифицировать создание пакетов для конечного дистрибутива.
- Добавлена поддержка добавления пользовательских скриптов в скрипты запуска приложений.
- Добавлена поддержка сборки системных зависимостей для Windows.
- Добавлена поддержка RPATH для Linux. Теперь cqtdeployer может самостоятельно определить нужный qmake для развертывания приложения.
- Добавлена поддержка поиска необходимой зависимости по имени библиотеки.
- Добавлена поддержка Qt библиотек из репозиториев Linux дистрибутивов.
### Новые опции
- init - инициализирует файл cqtdeployer.json (файл конфигурации). Например: «cqtdeployer init» - для инициализации конфигурации одного пакета. "cqtdeployer -init multiPackage" - для инициализации конфигурации нескольких пакетов.
- noCheckRPATH - отключает автоматический поиск путей к qmake в исполняемых файлах (Только Linux).
- noCheckPATH - отключает автоматический поиск путей к qmake в системном окружении.
- extractPlugins - заставляет извлекать все зависимости плагинов.
- qif - создает инсталлятор в конце развертывания.
- extraLibs - добавляет шаблон дополнительной библиотеки, которая должна будет попасть в дистрибутив.
- customScript - добавляет пользовательский скрипт в скрип запуска приложения.
- -targetPackage [package;tar1,package;tar2] - используется для формирования пакетов, обозначает списки целевых файлов для определенных пакетов.
- recOut - указывает в какую папку будут складываться ресурсы после развертывания.
- name - устанавливает имя пакета.
- description - устанавливает описание пакета
- deployVersion - устанавливает версию пакета
- releaseDate - дата релиза пакета.
- icon - иконка пакета.
- publisher - издатель пакета.
- qifStyle - Устанавливает путь к CSS файлу стиля или устанавливает стиль по умолчанию. Доступные стили: quasar
- qifBanner - Устанавливает путь к png-файлу баннера.
- qifLogo - Устанавливает путь к файлу логотипа png.
## Подробный разбор самых интересных изменений.
Первое, на что стоит обратить внимание, это то что CQtDeployer научился работать с RPATH (Только Linux) и PATH. Это значит, что если ваше приложение собранно с поддержкой RPATH (а RPATH в qt включен по молчанию) или ваш qmake прописан в PATH, то вам не нужно указывать путь к qmakе. CQtDeployer сам найдет нужный ему qmake.
Давайте проверим это на практике.
Я написал простое консольное приложение с использованием Qt.
``` cpp
#include <QString>
#include <QDebug>
int main(int, char *[])
{
QString str = "hello CQtDeployer 1.4";
qInfo() << str;
return 0;
}
```
Я буду использовать сборочную систему cmake, так как она более актуальная чем qmake.
``` bash
andrei@HP:~/Hello$ tree
.
├── CMakeLists.txt
├── CMakeLists.txt.user
└── main.cpp
0 directories, 3 files
```
Создадим папку для сборки.
``` bash
andrei@HP:~/Hello$ mkdir build
```
Выполним в созданной папке cmake.
``` bash
andrei@HP:~/Hello/build$ cmake .. -DCMAKE_PREFIX_PATH=~/Qt/5.14.1/gcc_64
-- Configuring done
-- Generating done
-- Build files have been written to: /home/andrei/Hello/build
```
Выполняем сборку.
``` bash
andrei@HP:~/Hello/build$ make
Scanning dependencies of target Hello_autogen
[ 25%] Automatic MOC and UIC for target Hello
[ 25%] Built target Hello_autogen
Scanning dependencies of target Hello
[ 50%] Building CXX object CMakeFiles/Hello.dir/Hello_autogen/mocs_compilation.cpp.o
[ 75%] Building CXX object CMakeFiles/Hello.dir/main.cpp.o
[100%] Linking CXX executable Hello
[100%] Built target Hello
```
Проверяем нашу программу.
``` bash
andrei@HP:~/Hello/build$ ls
CMakeCache.txt CMakeFiles cmake_install.cmake Hello Hello_autogen Makefile
```
И запускаем cqtdeployer передав ему программу без qmake.
``` bash
andrei@HP:~/Hello/build$ cqtdeployer -bin Hello
Deploy ...
flag targetDir not used. use default target dir : "/home/andrei/Hello/build/DistributionKit"
target deploy started!!
copy : "/home/andrei/Hello/build/Hello"
extract lib : "/home/andrei/Hello/build/DistributionKit//bin//Hello"
copy : "/home/andrei/Qt/5.14.1/gcc_64/lib/libQt5Core.so.5"
copy : "/home/andrei/Qt/5.14.1/gcc_64/lib/libicuuc.so.56"
copy : "/home/andrei/Qt/5.14.1/gcc_64/lib/libicui18n.so.56"
copy : "/home/andrei/Qt/5.14.1/gcc_64/lib/libicudata.so.56"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_ar.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_bg.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_ca.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_cs.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_da.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_de.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_en.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_es.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_fi.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_fr.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_gd.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_he.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_hu.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_it.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_ja.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_ko.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_lv.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_pl.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_ru.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_sk.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_uk.qm"
copy : "/home/andrei/Qt/5.14.1/gcc_64/translations/qtbase_zh_TW.qm"
try deploy msvc
deploy done!
```
О чудо, теперь наше приложение полностью автономно.
Проверяем это.
``` bash
andrei@HP:~/Hello/build$ cd DistributionKit/
andrei@HP:~/Hello/build/DistributionKit$ tree
.
├── bin
│   ├── Hello
│   └── qt.conf
├── Hello.sh
├── lib
│   ├── libicudata.so.56
│   ├── libicui18n.so.56
│   ├── libicuuc.so.56
│   └── libQt5Core.so.5
└── translations
├── qtbase_ar.qm
├── qtbase_bg.qm
├── qtbase_ca.qm
├── qtbase_cs.qm
├── qtbase_da.qm
├── qtbase_de.qm
├── qtbase_en.qm
├── qtbase_es.qm
├── qtbase_fi.qm
├── qtbase_fr.qm
├── qtbase_gd.qm
├── qtbase_he.qm
├── qtbase_hu.qm
├── qtbase_it.qm
├── qtbase_ja.qm
├── qtbase_ko.qm
├── qtbase_lv.qm
├── qtbase_pl.qm
├── qtbase_ru.qm
├── qtbase_sk.qm
├── qtbase_uk.qm
└── qtbase_zh_TW.qm
3 directories, 29 files
andrei@HP:~/Hello/build/DistributionKit$
```
Корень программы:
![image](https://user-images.githubusercontent.com/12465465/77245272-619a0280-6c2e-11ea-92f2-447563f72dcc.png)
Библиотеки,нужные для работы программы:
![image](https://user-images.githubusercontent.com/12465465/77245274-6363c600-6c2e-11ea-8729-7d494a073b66.png)
Как видно из примера, приложение полностью собрано.
## Qt Installer Framework
Второе нововведение, о котором стоит знать, это возможность из коробки формировать установщики QIF. Все, что нужно для нашего примера, это добавить в команду на упаковку опцию qif.
Пример использования.
```
andrei@HP:~/Hello/build$ cqtdeployer -bin Hello qif
```
Всего одна простая команда и программа получает презентабельный вид.
![image](https://user-images.githubusercontent.com/12465465/77245315-b3428d00-6c2e-11ea-9326-c23229020eb5.png)
Этот установщик поддерживает минимальную интеграцию Linux дистрибутивами и Windows. А именно: создание ярлыков, и регистрация приложения в OС.
Если по каким то причинам вас не устраивает внешний вид данного установщика, его можно изменить при помощи флага qifStyle . На момент версии 1.4 cqtdeployer поддерживает всего 2 стиля (native и quasar).
Пример стиля quasar:
![image](https://user-images.githubusercontent.com/12465465/77245334-d2d9b580-6c2e-11ea-9e55-e205499a9219.png)
Вы также можете использовать свою собственную таблицу стилей qss. Для этого вместо названия стиля передайте путь к вашему qss или css файлу.
Для примера можно рассмотреть следующую таблицу стилей qss.
Style.qss:
``` css
QWidget
{
color: white;
background-color: rgb(65, 65, 65);
}
QPushButton
{
background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 rgba(150, 150, 150, 60%), stop:1 rgba(50, 50, 50, 60%));
border-color: rgb(60, 60, 60);
border-style: solid;
border-width: 2px;
border-radius: 9px;
min-height: 20px;
max-height: 20px;
min-width: 60px;
max-width: 60px;
padding-left: 15px;
padding-right: 15px;
}
QPushButton:pressed, QPushButton:checked
{
background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 rgba(50, 50, 50, 60%), stop:1 rgba(150, 150, 150, 60%));
}
```
Давайте проверим, что у нас получится в таком случае.
``` bash
cqtdeployer -bin Hello qif -qifStyle ./../style.qss
```
![image](https://user-images.githubusercontent.com/12465465/77245346-00266380-6c2f-11ea-8426-42bf58038458.png)
Вот,собственно, и тёмная тема установщика.
## Разбиение на пакеты
И,наверное, последнее важное обновление, о котором стоит знать — это возможность разделять большой многобинарный проект на подпроекты.
Эта возможность самая сложная из всех перечисленных, так как требует много текста для ее использования. Так что я рекоммендую использовать файл конфигураций.
Для начала усложним наш проект, добавив в него ещё 2 исполняемого файла. Я не стал заморачиваться и просто сделал 2 копии моей Hello утилиты.
Для упрощения работы с пакетами нужно инициализировать директорию.
``` bash
cqtdeployer init
```
Это еще одна новая функция, которая создаёт CQtDeployer.json файл, в котором мы и будем писать наши конфигурации, вместо передачи опций в утилиту.
``` js
{
"binDir": ".",
"clear": true,
"libDir": "./",
"recursiveDepth": 5
}
```
Теперь давайте сделаем 2 пакета из 3х наших программ. Для этого нужно указать:
```js
{
"binDir": ".",
"clear": true,
"libDir": "./",
"recursiveDepth": 5,
"targetPackage": [
["Dstro1", "Hello1"],
["Dstro2", "Hello2"],
["Dstro2", "Hello3"]
]
}
```
Обратите внимание на то, что мне пришлось явно указать привязку для Dstro2 к Hello2 Hello3, К сожалению, на момент версии 1.4 cqtdeployer не умеет парсить перечисления целей. Обратите внимание, что если я напишу вместо Hello1 Hello, то выборка будет сделана по всем совпадениям и будут выбраны все 3 программы.
Итак, смотрим что получилось.
``` bash
cqtdeployer
.
├── Dstro1
│   ├── bin
│   │   ├── Hello1
│   │   └── qt.conf
│   ├── Hello1.sh
│   ├── lib
│   │   ├── libicudata.so.56
│   │   ├── libicui18n.so.56
│   │   ├── libicuuc.so.56
│   │   └── libQt5Core.so.5
│   └── translations
│   ├── qtbase_ar.qm
│   ├── qtbase_bg.qm
│   ├── qtbase_ca.qm
│   ├── qtbase_cs.qm
│   ├── qtbase_da.qm
│   ├── qtbase_de.qm
│   ├── qtbase_en.qm
│   ├── qtbase_es.qm
│   ├── qtbase_fi.qm
│   ├── qtbase_fr.qm
│   ├── qtbase_gd.qm
│   ├── qtbase_he.qm
│   ├── qtbase_hu.qm
│   ├── qtbase_it.qm
│   ├── qtbase_ja.qm
│   ├── qtbase_ko.qm
│   ├── qtbase_lv.qm
│   ├── qtbase_pl.qm
│   ├── qtbase_ru.qm
│   ├── qtbase_sk.qm
│   ├── qtbase_uk.qm
│   └── qtbase_zh_TW.qm
└── Dstro2
├── bin
│   ├── Hello2
│   ├── Hello3
│   └── qt.conf
├── Hello2.sh
├── Hello3.sh
├── lib
│   ├── libicudata.so.56
│   ├── libicui18n.so.56
│   ├── libicuuc.so.56
│   └── libQt5Core.so.5
└── translations
├── qtbase_ar.qm
├── qtbase_bg.qm
├── qtbase_ca.qm
├── qtbase_cs.qm
├── qtbase_da.qm
├── qtbase_de.qm
├── qtbase_en.qm
├── qtbase_es.qm
├── qtbase_fi.qm
├── qtbase_fr.qm
├── qtbase_gd.qm
├── qtbase_he.qm
├── qtbase_hu.qm
├── qtbase_it.qm
├── qtbase_ja.qm
├── qtbase_ko.qm
├── qtbase_lv.qm
├── qtbase_pl.qm
├── qtbase_ru.qm
├── qtbase_sk.qm
├── qtbase_uk.qm
└── qtbase_zh_TW.qm
8 directories, 60 files
```
Как видно из дерева результата, у нас получилось 2 дистрибутива.
1. Dstro1 — содержит в себе приложение Hello1
2. Distro2 — содержит оставшиеся 2.
А теперь давайте проверим, что будет, если все это запаковать а установщик. Добавим в CQtDeployer.json опцию qif **"qif": true,**.
``` js
{
"binDir": ".",
"clear": true,
"qif": true,
"libDir": "./",
"recursiveDepth": 5,
"targetPackage": [
["Dstro1", "Hello1"],
["Dstro2", "Hello2"],
["Dstro2", "Hello3"]
]
```
![image](https://user-images.githubusercontent.com/12465465/77245542-534ce600-6c30-11ea-9323-72ec5e200f39.png)
Кака видно из скриншота, теперь у нас 2 пакета при установке.
## Новые алиасы
И последнее небольшое но приятное дополнение: теперь в cqtdeployer добавлены новые команды.
* сqt — бывстрый способ задеплоить ваше приложение. Он упрощает вызов развертывания.
* Пример:
**cqt myApp** — это тоже самое что и **cqtdeployer -bin myApp**.
* cqtdeployer.cqt — тоже что и cqt но для snap пакета.
* В windows-версии теперь не нужно добовлять знак % для вызова утилиты.
Теперь вызов выглядит так, как и в Linux. (cqtdeployer)

22
docs/ru/1_5.md Executable file
View File

@ -0,0 +1,22 @@
# Релиз утилиты развертывания С++/Qt и QML приложений CQtDeployer v1.5.0
## Полный список всех изменений
## CQtDeployer 1.5.0 Alpha
### Исправления
- исправления ошибок и улучшения.
### Новые особенности
- Добавлена новая тема для установщика qif "quasarDark".
- Добавлена поддержка пользовательских шаблонов для опции qif
- Добавлена поддержка пакетов debian с расширением.
### Новые параметры
- zip - создает ZIP-архив для развертываемых программ
- deb - cоздает пакет deb для программы развертывания
- homepage - Устанавливает URL-адрес домашней страницы для пакета
## Подробный разбор самых интересных изменений.
# Будет дополнено

View File

@ -0,0 +1,50 @@
# Building from source
## Build для Linux
- установите qt и qt QtInstallFrameWork из [Установщик qt](https://www.qt.io/download-qt-installer?hsCtaTracking=9f6a2170-a938-42df-a8e2-a9f0b1d6cdce%7C6cb0de4f-9bb5-4778-ab02-bfb62735f3e5)
- git clone https://github.com/QuasarApp/CQtDeployer.git
- cd CQtDeployer
- git submodule update --init --recursive
- qmake -r
- Здесь нужно обязательно вызвать тот qmake, который был загружен из 1го пункта.
- Пример: ~/Qt/5.15.0/gcc_64/bin/qmake -r
- make -j$(nproc)
- make deploy
- эта команда требует установленный [cqtdeployer](https://github.com/QuasarApp/CQtDeployer/releases)
## Build для Windows (CMD)
- установите qt и qt QtInstallFrameWork из [Установщик qt](https://www.qt.io/download-qt-installer?hsCtaTracking=9f6a2170-a938-42df-a8e2-a9f0b1d6cdce%7C6cb0de4f-9bb5-4778-ab02-bfb62735f3e5)
- git clone https://github.com/QuasarApp/CQtDeployer.git
- cd CQtDeployer
- git submodule update --init --recursive
- SET PATH=C:/Qt/Tools/mingw810_64/bin;%PATH%
- Здесь важно настроить окружение qt.
- qmake.exe -r
- Здесь нужно обязательно вызвать тот qmake, который был загружен из 1го пункта.
- Пример: C:/Qt/5.15.0/mingw81_64/bin/qmake.exe -r
- migw32-make -j8
- migw32-make deploy
- эта команда требует установленный [cqtdeployer](https://github.com/QuasarApp/CQtDeployer/releases)
- ./Distro/CQtDeployerInstaller.exe
---
# Установка без сборки
## Snap
[![Загрузите из Snap Store](https://snapcraft.io/static/images/badges/ru/snap-store-black.svg)](https://snapcraft.io/cqtdeployer)
#### Особенности snap версии
Если вы используете snap версию приложения. Включите все разрешения для cqtdeployer.
это можно сделать в snap-store
Или начиная с ubuntu 20.04 в менеджере настроек приложений ubuntu.
Если у вас нет графического интерфейса, вы можете включить все разрешения, используя следующие команды:
``` bash
sudo snap connect cqtdeployer:process-control
sudo snap connect cqtdeployer:removable-media
sudo snap connect cqtdeployer:system-backup
```
## Установщик
Вы можете загрузить последнюю версию приложения [здесь](https://github.com/QuasarApp/CQtDeployer/releases).

242
docs/ru/Changelog.md Executable file
View File

@ -0,0 +1,242 @@
# Журнал изменений для всех версий CQtDeployer.
## CQtDeployer 1.5.0 Alpha
### Исправления
- исправления ошибок и улучшения.
### Новые особенности
- Добавлена новая тема для установщика qif "quasarDark".
### Новые параметры
- zip - создать ZIP-архив для развертываемых программ
## CQtDeployer 1.4.7
### Исправления
- Исправлено развертывание плагина qxcb. #438
- Исправлено развертывание модуля qtGui. #446
### Новые возможности
- Добавлена поддержка Qt6. #437
- Добавлена поддержка Qt installer Framework 4 (с улучшенным интерфейсом командной строки)ю #436
## CQtDeployer 1.4.6
### Исправления
- Исправлено развертывание драйверов sql #367.
- Исправлен алгоритм развертывания библиотек. #423 #371
- Исправлена работа с qt из системного репозитория linux. (только классический установщик) #422
- Исправлена snap версия cqtdeployer, добавлена поддержка поиска qmake по RPATH #424 #420
- Исправлен хелп.
- Мелкие исправления и улучшения.
- Удалена устаревшая опция extractPlugins. #371
### Новые параметры
- noQt - игнорирует ошибку инициализации qmake. Используйте только в том случае, если ваше приложение не использует платформу qt.
## CQtDeployer 1.4.5
### Исправления
- Оптимизирована производительность развертывания проектов. На 60% быстрее.
- Оптимизирован выходной размер дистрибутивов. Размер уменьшен на 25%.
- Исправлено отображение ярлыков после установки развернутых приложений.
- Исправлен запуск приложений с пробелами в имени. спасибо @ahndee (#384)
- Исправлено развертывание плагина Renderer.
- Незначительные исправления и улучшения.
### Новые особенности
- Добавлена новая система управления плагинами развертывания.
### Новые опции
- extraPlugin - устанавливает дополнительный путь к сторонним плагина приложения
- enablePlugins - включает дополнительные плагины для распространения.
- disablePlugins - отключает плагины для распространения.
## CQtDeployer 1.4.4
### New options
- qifFromSystem - Принудительно использовать системный инструмент binarycreator из path или qt
## CQtDeployer 1.4.3
### Исправления
- Исправленно отображение приложения скаченого из snap store и установщика в меню настроек приложений ubuntu 20.04
### Нововведения
- Добавленна поддержка рекурсивного добовления для флага ignoreEnv #356
### Новые опции
- noRecursiveiIgnoreEnv - Отключает рекурсивное игнорирование переменной среды для флага ignoreEnv.
## CQtDeployer 1.4.2
### Исправления
- исправлено #337 (ошибка генерации установщика с произвольным именем)
- исправлено #338 (версия Windows собирает pdb файлы)
- исправлено #339 (ошибка показа всех справочных сообщений)
- исправлено #340 (cqdeployer не добавлял каталоги целей в "ignore")
- исправлено #341 (опция очистки не удаляет старый установщик)
## CQtDeployer 1.4.1
### Исправления
- Исправлено не развертывание тем платформ (#324)
- Исправлено создание ярлыков на Windows (#322)
- Незначительные улучшения и исправления
## CQtDeployer 1.4.0
### Исправления
- Исправлен вывод справки в консоли, теперь перед выводом пересчитывается реальный размер консоли, что позволяет выполнять правильно переносы текста.
- Исправлена работа с развертыванием плагинов Qt. Теперь плагины не тянут за собой все системные зависимости, а только qt. Захват системных зависимостей приводил к падению приложений из-за несовместимости библиотек плагинов.
- Мелкие исправления и улучшения.
### Нововведения
- Добавлена поддержка поиска qmake из системного окружения.
- Добавлена возможность инициализировать репозиторий для дальнейшей упаковки аналогично git init.
- Добавлена поддержка Qt Install Framework пакетов. Теперь можно запаковать дистрибутив в инсталлятор.
- Добавлена возможность разбивать конечный дистрибутив на несколько пакетов.
- Добавлен механизм позволяющий унифицировать создание пакетов для конечного дистрибутива.
- Добавлена поддержка добавления пользовательских скриптов в скрипты запуска приложений.
- Добавлена поддержка сборки системных зависимостей для Windows.
- Добавлена поддержка RPATH для Linux. Теперь cqtdeployer может самостоятельно определить нужный qmake для развертывания приложения.
- Добавлена поддержка поиска необходимой зависимости по имени библиотеки.
- Добавлена поддержка Qt библиотек из репозиториев Linux дистрибутивов.
- Добавлены новые псевдонимы для команды запуска (cqt и cqtdeployer.cqt) для быстрого развертывания приложений.
- Добавлена поддержка собственного имени команды для windows. Теперь вы можете запустить cqtdeployer написав cqtdeployer в cmd и powershell.
### Новые опции
- init - инициализирует файл cqtdeployer.json (файл конфигурации). Например: «cqtdeployer init» - для инициализации конфигурации одного пакета. "cqtdeployer -init multi" - для инициализации конфигурации нескольких пакетов.
- noCheckRPATH - отключает автоматический поиск путей к qmake в исполняемых файлах (Только Linux).
- noCheckPATH - отключает автоматический поиск путей к qmake в системном окружении.
- extractPlugins - заставляет извлекать все зависимости плагинов.
- qif - создает инсталлятор в конце развертывания.
- extraLibs - добавляет шаблон дополнительной библиотеки, которая должна будет попасть в дистрибутив.
- customScript - добавляет пользовательский скрипт в скрип запуска приложения.
- -targetPackage [package;tar1,package;tar2] - используется для формирования пакетов, обозначает списки целевых файлов для определенных пакетов.
- recOut - указывает в какую папку будут складываться ресурсы после развертывания.
- name - устанавливает имя пакета.
- description - устанавливает описание пакета
- deployVersion - устанавливает версию пакета
- releaseDate - дата релиза пакета.
- icon - иконка пакета.
- publisher - издатель пакета.
- qifStyle - Устанавливает путь к CSS файлу стиля или устанавливает стиль по умолчанию. Доступные стили: quasar
- qifBanner - Устанавливает путь к png-файлу баннера.
- qifLogo - Устанавливает путь к файлу логотипа png.
---
## CQtDeployer 1.3.2
- Исправлено #218 (CQtDeployer добавлял sh-скрипты для целевых библиотек.)
- Исправлено #217 (опция qmake не работала с файлом конфигурации.)
---
## CQtDeployer 1.3.1
- Исправлена задача #191 (команда игнорирования для плагинов)
- Исправлена задача #192 (неверный путь при создании файла развертывания)
- Исправлены абсолютные пути к файлу conf
---
## CQtDeployer 1.3.0
- Добавлена поддержка qt.conf для Linux
- Добавлена поддержка конфигурационного файла для проекта (deploy.json) со всеми правилами развертывания, для создания deploy.json используйте флаг -confFile [./path/to/file.json].
- Добавлена поддержка выходных каталогов для всех файлов развертывания #145,
- Добавлена поддержка развертывания WebEngine #146.
- Добавлена поддержка нескольких пакетов в установщике cqtdeployer.
- Переименован проект из Console-QtDeployer в CQtDeployer #139
- Исправлено развертывание системных библиотек в linux #172
- Добавлены новые тесты приложения
- Удален флаг noLibC и добавлен флаг deploySystem-with-libc. Если вам нужен в программе libc используйте флаг deploySystem-with-libc, а если нет то пользуйтесь deploySystem.
- Заменен флаг always-overwrite на noOverwrite, теперь все файлы по умолчанию перезаписываются, используйте noOverwrite для отключения перезаписи.
---
## CQtDeployer 1.2.3
- Добавлена поддержка qt.conf для сборок Windows #130
- Исправлена ошибка #129, теперь флаг «очистить» удаляет только скопированные файлы.
- Исправлен флаг ignoreEnv
- Исправлен флаг deploySystem
---
## CQtDeployer 1.2.2
- Добавлен новый флаг noLibc для игнорирования библиотек libc и li-linux
- Исправлена #125 ошибка развертывания системных библиотек (работает с простыми проектами, для больших проектов не рекомендуется)
- Исправлен флаг ignoreEnv
---
## CQtDeployer 1.2.1
- Добавлен новый флаг игнорирования (ignoreEnv). Этот флаг отключает ненужную среду
- Добавлена поддержка QIFW (онлайн-установщик для Windows и других дистрибутивов Linux)
- Добавлено обновление утилиты для Windows и других дистрибутивов Linux (не Snap)
- Исправлена ошибка № 116 (копирование файлов со съемного носителя)
- Исправлена ошибка № 115 (создание цели в папке с русским именем)
- Исправлен большой размер версии msvc
- Исправлено кросс-развертывание Linux >> Windows
- Удалены старые скрипты сборки
---
## CQtDeployer 1.2.0
- Добавлен собственный сканер зависимостей qml.
- Перешел на новый [сканер PE-Lib](https://github.com/QuasarApp/pe-parse/tree/7138bb218a05c81d825728ba8a0a6f6a56c4fdbc).
- Перешел на новый [ELF-lib сканер](https://github.com/qt/qttools/blob/b0147a5d79ce7a7e77a24f36aaddfacb1a1517c8/src/shared/winutils/elfreader.h).
- Добавлены новые юнит-тесты.
- Добавлена поддержка версии Snap (только домашний каталог).
- Добавлен новый флаг qmlExtern - для использования сканера импорта qt qml.
- Добавлена поддержка уровней подробного журнала (0-3).
- Исправлен журнал развертывания приложения.
- Исправлено развертывание приложения в версии Snap.
---
## CQtDeployer 1.1.2
- Добавлена поддержка переводов
- Добавлен флаг для отключения развертывания переводов
- Добавлена strip для Linux
- Добавлены юнит-тесты
- Исправлено развертывание в динамической версией
- Исправлена ошибка развертывания на текущем каталоге с привязкой и статической версией.
---
## CQtDeployer 1.1.1
- Исправлена сборка qml в диномисечкой версии
- Исправленна работа флага -recursiveDepth
- Исправленна работа флага -libDir
- Исправленно копирование библиотек по ссылке
- Почищен вывод приложения, часть лога перенесенна в verbose
---
## CQtDeployer 1.1.0
- Добавлена поддержка windows (только динамическая линковка)
- Добавлена поддержка snap (теперь доступно в snapstore)
- Добавлены сборочные скрипты для snap
- Добавлен флаг binDir позволяющий рекурсивно захватывать exe dll и so
- Изменена логика работы флага bin теперь если выбрать в место файла папку то будет захвачено все ее содержимое
- Изменена и исправлена логика работы флага clear теперь он чистит все развернутое содержимое по определенному таргету.
- Добавлен флаг targetDir который определяет место где будет лежать развернутый проект
- Изменена структура развернутого проекта, теперь все оболочки запуска лежат в корне а бинарники в папке bin, для каждого бинарника создается одноименный скрипт запуска.
- Удален старый флаг runScript из-за смены логики развертывания
- Добавлен флаг verbose для отладки по
- Исправлены ошибки производительности
---
## CQtDeployer 1.0.2
- Добавлен скрипт для сборки (динамический и статический выпуск)
- Добавлен флаг -libDir для установки дополнительного пути для дополнительных библиотек приложения
- Добавлен флаг -extraPlugin для установки дополнительного пути для дополнительных плагинов приложения
- Добавлена сборка только для С библиотек
- Исправленно развертывание
- Исправлен сценарий запуска
- Исправлена статическая сборка
---
## CQtDeployer 1.0.1
- Исправлена ошибка развертывания qml (избыточность)
- Исправлен скрипт запуска приложения
---
## CQtDeployer 1.0.0
- Добавлен флаг runScript
- Добавлен флаг allQmlDependes
- Исправлена ошибка развертывания qml
- Исправлена ошибка развертывания плагинов
- Добавлена поддержка статической сборки

View File

@ -0,0 +1,14 @@
# Сравните особенности дистрибутивов CQtDeployer
| Название функции | Классическая версия linux (установщик) | Snap версия | Windows версия |
|---|---|---|----|
| Автоматические обновляется | Нет | Да | Нет |
| Онлайн-обновления | Да | Да | Да |
| Поддержка системных библиотек | Да | Да | Да |
| Поддержка создания установщиков | Да | Да | Да |
| Поддержка создания архивов | Да | Да | Да |
| Поддержка поиска библиотек и cmake из среды | Да | Нет | Да |
| Поддержка поиска qmake из RPATH | Да | Да | Нет
| Поддержка команды 'strip' | Да | Нет | Нет |
| Поддержка работы с qmake из системного репозитория ОС| Да| Нет | Нет |

46
docs/ru/DEB.md Normal file
View File

@ -0,0 +1,46 @@
## Общие правила использования DEB
#### Доступно с версии CQtDeployer 1.5
### Как использовать опцию DEB
Просто добавьте в cqtdeployer опцию «deb».
#### Например:
``` bash
cqtdeployer ... deb
```
Где:
* ** ... ** - список других опций.
* ** deb ** - опция для создания deb пакетов.
По умолчанию cqtdeployer создает один deb пакет .
Если вы хотите создать несколько пакетов, вы должны использовать [Параметры управления пакетами](https://github.com/QuasarApp/CQtDeployer/wiki/Options)
Чтобы создать новый пакет, используйте -targetPackage [package; tar1]
cqtdeployer создает вуи пакет для каждого пакета.
Где:
* **package** - это название пакета
* **tar1** - это имя цели, которая должна быть включена в этот пакет.
Или вы можете описать пакеты в [файле конфигурации](https://github.com/QuasarApp/CQtDeployer/wiki/DeployConfigFileEn)
```JSON
{
"targetPackage": [
[
"package",
"Tar1"
],
],
"deb": true
}
```
# Использование собственных шаблонов для создания деб пакетов

222
docs/ru/DeployConfigFile.md Normal file
View File

@ -0,0 +1,222 @@
## Файл развертывания
**Файл развертывания** - это json файл, содержащий в себе параметры для cqtdeployer. Данный файл поддерживает все параметры кроме confFile, так как данный параметр отвечает за подключение и инициализацию самого файла.
### Структура файла конфигурации
```json
{
"Флаг": true/false,
"Параметр": "Значение",
"Параметер с поддержкой перечислений": [
"Значение 1",
"Значение 2",
"Значение 3",
],
"Параметр с поддержкой многоуровневых перечислений": [
[
"Значение A1",
"Значение A2"
],
[
"Значение B1",
"Значение B2"
],
[
"Значение C1",
"Значение C2"
],
]
}
```
Подробно о параметрах cqtdeployer читайте в разделе [Параметры](Параметры).
Примеры содержимого данного файла:
Файл без использования параметров с перечислениями
```json
{
"noOverwrite": false,
"bin": "./",
"binDir": "./",
"qmlDir": "./",
"deploySystem": false,
"deploySystem-with-libc": false,
"qmake": "my/custom/path/to/qmake",
"ignore": "ignoreLib.dll",
"ignoreEnv": "/my/ignore/path",
"clear": true,
"force-clear": false,
"allQmlDependes": false,
"libDir": "./",
"recursiveDepth": 3,
"extraLibs": "myExtraLib (libssl)",
"extraPlugin": "myExtraPulgin (platforms)",
"targetDir": "./Distro",
"targetPackage": "",
"noStrip": false,
"extractPlugins": false,
"noTranslations": false,
"qmlOut": "qml",
"libOut": "lib",
"trOut": "tr",
"pluginOut": "plug",
"binOut": "bin",
"recOut": "rec",
"verbose": 3,
"qif": false,
"noCheckRPATH": false,
"noCheckPATH": false,
"name": "mainApplication",
"description": "this is description for default package",
"deployVersion": "1.0.0",
"releaseDate": "yyyy-MM-dd",
"icon": "/path/main/icon.png",
"publisher": "main team",
"customScript": "echo 'I am use custom script!!!'"
}
```
Файл с использованием параметров с перечислениями
``` json
{
"noOverwrite": false,
"bin": "./",
"binDir": "./",
"qmlDir": [
[
"package2",
"./TestQMLWidgets/"
],
[
"./qml/for/All"
]
],
"deploySystem": false,
"deploySystem-with-libc": false,
"qmake": "this parameter should contain the path to your qmake, for Windows this field is required. On Linux, you can remove it, then qmake will be found by rpath.",
"ignore": "ignoreLib.dll",
"ignoreEnv": "/my/ignore/path",
"clear": true,
"force-clear": false,
"allQmlDependes": false,
"libDir": "./",
"recursiveDepth": 3,
"extraLibs": "myExtraLib (libssl)",
"extraPlugin": "myExtraPulgin (platforms)",
"targetDir": "./Distro",
"targetPackage": [
[
"/package1/",
"TestOnlyC"
],
[
"/package2/",
"TestQMLWidgets"
]
],
"noStrip": false,
"extractPlugins": false,
"noTranslations": false,
"qmlOut": "qml",
"libOut": "lib",
"trOut": "tr",
"pluginOut": "plug",
"binOut": "bin",
"recOut": "rec",
"verbose": 3,
"qif": false,
"noCheckRPATH": false,
"noCheckPATH": false,
"name": [
[
"package2",
"package2Application"
],
[
"mainApplication"
]
],
"description": [
[
"package2",
"this is description for package 'package2'"
],
[
"this is description for default package"
]
],
"deployVersion": [
[
"package2",
"1.0.0"
],
[
"1.0.0"
]
],
"releaseDate": [
[
"package2",
"yyyy-MM-dd"
],
[
"yyyy-MM-dd"
]
],
"icon": [
[
"package2",
"/path/icon.png"
],
[
"/path/main/icon.png"
]
],
"publisher": [
[
"package2",
"team of package2"
],
[
"main team"
]
],
"customScript": "echo 'I am use custom script!!!'"
}
```
Цель файла- упростить вызов cqtdeployer и переместить часть или все параметры в файл. Все параметры, указанные в файле, имеют более низкий приоритет, чем параметры, добавленные в консоль при запуске.
### Создание файла
#### Способ 1
1. Вызовите `cqtdeployer init` Для инициализации файла для приложения состоящего из одного пакета.
Или `cqtdeployer -init multi` Для инициализации файла для проекта с несколькими пакетами.
2. Откройте CQtDeployer.json и отредактируйте его под свои нужды.
3. Вызовите cqtdeployer в дериктории с файлом CQtDeployer.json, или укажите путь к нему используя флаг -confFile path/to/my/CQtDeployer.json
#### Способ 2
Вызовите cqtdeployer с нужным вам набором параметров и укажите путь к файлу при помощи флага -confFile (файл должен отсутствовать). Если файл будет существовать, то cqtdeployer начнет выгружать из него параметры.
Пример:
``` bash
cqtdeployer -confFile deploy.json -bin CQtDeployerInstaller -targetDir ./test -qmlOut myqml -binOut mybin -libOut mylib -pluginOut myplugins noStrip noTranslations -recursiveDepth 5 -extraPlugin sqldrivers,audio,mediaservice force-clear deploySystem noOverwrite
```
Где:
* cqtdeployer - вызов cqtdeployer
* -confFile deploy.json - путь к файлу, который нужно создать
* "-bin CQtDeployerInstaller -targetDir ./test -qmlOut myqml -binOut mybin -libOut mylib -pluginOut myplugins noStrip noTranslations -recursiveDepth 5 -extraPlugin sqldrivers,audio,mediaservice force-clear deploySystem noOverwrite" - необходимые параметры.
### Использование файла развертывания.
Чтобы cqtdeployer начал читать параметры из файла, используйте флаг -confFile [путь к файлу]
#### Пример:
cqtdeployer -qmake ~/Qt/bin/qmake -confFile ./deploy.json

9
docs/ru/Description.md Normal file
View File

@ -0,0 +1,9 @@
### Что такое CQtDeployer
CQtDeployer - это утилита для извлечения всех зависимых библиотек исполняемых файлов и создания сценария запуска для вашего приложения.
Основные отличия этой программы:
* Производительность - эта программа развертывает приложение в несколько раз быстрее (до 10 секунд)
* Гибкость - эта утилита имеет флаги, которые помогут вам настроить деплоинг под ваши нужды и нужды вашего проекта
* Crossdeploy - приложение поддерживает Windows и дистрибутивы Linux, это означает, что вы можете использовать его не только для развертывания проекта для вашей платформы, но и для развертывания проекта в Linux для Windows и наоборот.
* Упаковка - эта утилита может создавать установочные файлы и пакеты, для вашего приложения.

145
docs/ru/Guide.md Normal file
View File

@ -0,0 +1,145 @@
### Введение
В данной статье мы рассмотрим, как правильно собрать все зависимости qt для вашего приложения, которое было собрано динамически.
### Для начало немного теории
### Зачем это нужно?
Существует несколько способов сборки приложений, основные из них это:
* Статическая сборка
Статическая сборка подразумевает создание бинарника, в котором будут слинковоны все необходимые ему компоненты. Другими словами все что нужно для его работы будет лежать в нем. Такой подход удобен для маленьких консольных приложений, у которых мало зависимостей, в противном случае размер конечного бинарника будет крайне велик.
* Динамическая сборка
Отличается от статической тем, что в бинарнике будут лежать только исходные тексты вашего приложения (размер бинарника будет минимальный), но при выполнении такого приложения ему понадобятся сторонние библиотеки, которые использовались при его написании.
### Теперь немного описания
CQtDeployer — это простая утилита для извлечения всех зависимых библиотек исполняемых файлов и создания сценария запуска для вашего приложения.
### Давайте рассмотрим пример
Для примера я написал простое qt приложение с использованием qml — MyApp.
### MyApp (main.cpp)
``` C++
#include <QGuiApplication>
#include <QQmlApplicationEngine>
int main(int argc, char *argv[])
{
QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
if (engine.rootObjects().isEmpty())
return -1;
return app.exec();
}
```
### MyApp (main.qml)
``` qml
import QtQuick 2.9
import QtQuick.Controls 2.2
ApplicationWindow {
visible: true
width: 640
height: 480
title: qsTr("Scroll")
ScrollView {
anchors.fill: parent
ListView {
width: parent.width
model: 20
delegate: ItemDelegate {
text: "Item " + (index + 1)
width: parent.width
}
}
}
}
```
MyApp слинкована динамически, то есть для работы ему требуются библиотеки qt.
Если попробовать запустить приложение, сразу после сборки мы получим ошибку:
``` bash
~/MyApp$ ./MyApp
./MyApp: /usr/lib/x86_64-linux-gnu/libQt5Qml.so.5: version `Qt_5' not found (required by ./MyApp)
./MyApp: /usr/lib/x86_64-linux-gnu/libQt5Gui.so.5: version `Qt_5' not found (required by ./MyApp)
./MyApp: /usr/lib/x86_64-linux-gnu/libQt5Core.so.5: version `Qt_5.11' not found (required by ./MyApp)
./MyApp: /usr/lib/x86_64-linux-gnu/libQt5Core.so.5: version `Qt_5' not found (required by ./MyApp)
```
Из сходных текстов мы видим, что приложение зависит от GUI библиотек qt и библиотек qml. Поиск и сборка всех ресурсов (библиотек и плагинов) займет очень много времени.
Чтобы сэкономить время и силы, мы воспользуемся утилитой CQtDeployer (скачать можно [здесь](https://github.com/QuasarApp/CQtDeployer/releases))
или установить в Snap Store
[![Загрузите из Snap Store](https://snapcraft.io/static/images/badges/ru/snap-store-black.svg)](https://snapcraft.io/cqtdeployer)
``` bash
cqtdeployer -bin myApp -qmake /media/D/Qt/5.12.3/gcc_64/bin/qmake -qmlDir ./
```
После выполнения данной команды, вы получите полностью готовое для работы приложение с готовым лаунчером, который настроит все необходимое окружение для работы вашего приложения на всех машинах под управлением Linux.
Давайте подробнее рассмотрим некоторые из параметров CQtDeployer:
| Опция | Описание
|-----------------------------|-----------------------------------------------------------|
| help / h | Показывает справку |
| always-overwrite | Копирует файлы с заменой уже существующих |
| -bin [list, params] | Развертываемый файл или папка. пример -bin ~/my/project/bin/,~/my/project/bin.exe|
| -binDir [params] | Папка с развертываемыми файлами (с рекурсивным поиском). ВНИМАНИЕ! Этот флаг поддерживает только файлы 'so', 'dll' и 'exe'. Если вы хотите развернуть бинарный файл Linux, используйте флаг '-bin' |
| -qmlDir [params] | Папка qml. пример -qmlDir ~/my/project/qml |
| deploySystem | Копирует все библиотеки |
| -qmake [params] | Путь к qmake. пример |
| | -qmake ~/Qt/5.11.1/gcc_64/bin/qmake |
| -ignore [list,params] | Список библиотек для игнорирования |
| | Пример -ignore libicudata.so.56,libicudata2.so.56 |
| -ignoreEnv [list,params] | Список путей для игнорирования. |
| | Пример -ignoreEnv /bad/dir,/my/bad/Dir |
| clear | Удаляет все старые файлы (с прошлого запуска) |
| | пример -runScript myApp.sh |
| allQmlDependes | Извлекает все библиотеки qml. |
| | (не рекомендуется, так как занимает много памяти) |
| -libDir [list,params] | Устанавливает дополнительные пути к библиотекам |
| | Пример -libDir ~/myLib,~/newLibs |
| -extraPlugin [list,params] | Устанавливает дополнительный путь для extraPlugin приложения |
| -recursiveDepth [params] | Устанавливает глубину поиска библиотек (по умолчанию 0) |
| -targetDir [params] | Устанавливает целевой каталог (по умолчанию это путь к первому развертываемому файлу)|
| noStrip | Пропускает шаг strip |
| noTranslations | Пропускает файлы переводов |
| qmlExtern | Использует внешний сканер qml (qmlimportscaner) |
| | не работает без qmake и в snap |
| -verbose [0-3] | Показывает дебаг лога |
### Итог
После выполнения cqtdeployer у вас появится папка Distro c уже готовым приложением со всеми его зависимостями содержимое этой папки должно выглядеть примерно следующим образом:
``` bash
drwxr-xr-x 7 andrei andrei 4096 May 24 12:22 ./
drwxrwxr-x 3 andrei andrei 4096 May 24 12:22 ../
drwxr-xr-x 2 andrei andrei 4096 May 24 12:22 bin/
drwxr-xr-x 2 andrei andrei 4096 May 24 12:22 lib/
-rwx---rwx 1 andrei andrei 433 May 24 12:22 myApp.sh*
drwxr-xr-x 6 andrei andrei 4096 May 24 12:22 plugins/
drwxr-xr-x 5 andrei andrei 4096 May 24 12:22 qml/
drwxr-xr-x 2 andrei andrei 4096 May 24 12:22 translations/
```
![cqtdeployer result](https://user-images.githubusercontent.com/12465465/58318590-bdcea300-7e20-11e9-8b45-37a13aeef222.png)
* myApp.sh — скрипт запуска вашего приложения
* bin — папка с вашим бинарником
* lib — папка со всеми необходимыми зависимости вашего приложения
* plugins — qt плагины, необходимые для работы приложения
* qml — зависимости qml.
* translations — стандартные переводы qt.
Таким образом можно подготовить ваше приложения для упаковки в deb или snap пакет, после чего можно приступить к его распространению. Учитывайте, что после выполнения cqtdeployer, ваше приложение необходимо запускать с помощью sh скрипта, который настроит для вашего приложения необходимое окружение.

18
docs/ru/Home.md Normal file
View File

@ -0,0 +1,18 @@
# Добро пожаловать в "C Qt Deployer"!
# ![Логотип](https://user-images.githubusercontent.com/12465465/84260958-99289480-ab23-11ea-8aab-374368a545dc.png)
***************************
# Основные разделы
* [Описание CQtDeployer](https://github.com/QuasarApp/CQtDeployer/wiki/%D0%9E%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D0%B5)
* [Параметры](https://github.com/QuasarApp/CQtDeployer/wiki/%D0%9F%D0%B0%D1%80%D0%B0%D0%BC%D0%B5%D1%82%D1%80%D1%8B)
* [Руководство](https://github.com/QuasarApp/CQtDeployer/wiki/%D0%A0%D1%83%D0%BA%D0%BE%D0%B2%D0%BE%D0%B4%D1%81%D1%82%D0%B2%D0%BE)
* [Краткое Руководство](https://github.com/QuasarApp/CQtDeployer/wiki/%D0%9A%D1%80%D0%B0%D1%82%D0%BA%D0%BE%D0%B5%D0%A0%D1%83%D0%BA%D0%BE%D0%B2%D0%BE%D0%B4%D1%81%D1%82%D0%B2%D0%BE)
* [Сборка и установка](https://github.com/QuasarApp/CQtDeployer/wiki/%D0%A1%D0%B1%D0%BE%D1%80%D0%BA%D0%B0-%D0%B8-%D0%A3%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B0)
* [Пример использования](https://github.com/QuasarApp/CQtDeployer/tree/master/examples/TestQMLWidgets)
* [Файл развертывания](https://github.com/QuasarApp/CQtDeployer/wiki/DeployConfigFileRu)
* [Упаковка](https://github.com/QuasarApp/CQtDeployer/wiki/Packing(ru))
* [Список изменений](https://github.com/QuasarApp/CQtDeployer/wiki/ChangelogRu)
* [Обзоры](https://github.com/QuasarApp/CQtDeployer/wiki/ReleaseReviews.ru)
* [Сравнение возможностей](https://github.com/QuasarApp/CQtDeployer/wiki/CompareFeaturesRu)

111
docs/ru/Options.md Normal file
View File

@ -0,0 +1,111 @@
## Общие правила использования параметров
```
cqtdeployer -option1 value1 -option2 list,of,values flag1 flag2 flag3
```
* Все параметры должны начинается с знака '-' за исключением параметров, из котегории "Флаги".
* После указания нужного параметра нужно в обязательном порядке указать значение
* Некоторые параметры поддерживают перечисления (массивы значений). При инициализации таких параметров укажите список значений через ',' без прабелов. Если вы используете какой либо язык программирования и вызываете процесс cqtdeployer то массив значений должен передаваться как 1 параметр.
* Некоторые параметры поддерживают пересисления с возможностью выбрать цель для которой будет применен флаг. Цель и значения разделяются при помощи знака ';'. Пример -libOut target1;value1,target2;value2,defaultValue.
* Для включения какого либо флага достаточно просто включить в список опций имя флага.
## Обозначения в таблице
* **-binDir [params]** - параметр без поддержки массивов.
* **-bin [params,list]** - параметр c поддержкой массивов. В качестве разделителя используется ','.
* **-libOut [package;path,path]** - параметр c поддержкой выбора пакета для которого бутет установленно значение флага. В качестве разделителя используется ';'. Обратитте внимание что для перечисления значений параметра используется правило описанное выше. Последний параметр не имеет значение пакета, это значит что это значение будет установленно для всех не настроенных пакетов по умолчанию.
* **clear** - флаг
## Параметры:
### Флаги
| Option | Descriptiion |
|-----------------------------|-----------------------------------------------------------|
| init | проинициализирует файл cqtdeployer.json (файл конфигурации)|
| | Например: «cqtdeployer init» - для инициализации базовой конфигурации пакета|
| | "cqtdeployer -init multi" - для инициализации конфигурации нескольких пакетов|
| | "cqtdeployer -init single" - для инициализации конфигурации одного пакета |
| help / h | Показывает справку |
| clear | Удаляет все старые файлы (с прошлого запуска) |
| force-clear | Удаляет целевую директорию перед развертыванием |
| noStrip | Пропускает шаг strip |
| noTranslations | Пропускает файлы переводов |
| noOverwrite | Запрещает замену уже существующих файлов. |
| noCheckRPATH | Отключает автоматический поиск путей к qmake в исполняемых файлах.|
| noCheckPATH | Отключает автоматический поиск путей к qmake в системном окружении.|
| noRecursiveiIgnoreEnv | Отключает рекурсивное игнорирование переменной среды для флага ignoreEnv. |
| v / version | Показывает версию приложения |
| allQmlDependes | Извлекает все библиотеки qml. |
| qif | Создаст установщик QIF для развертываемой программы" |
| | Примеры: cqtdeployer qif |
| | Начиная с версии CQtDeployer 1.5 вы можете указать путь к своему собственному шаблону установщика. |
| | Примеры: cqtdeployer -qif path/to/myCustom/qif. Подробнее можно посмотреть [здесь](https://github.com/QuasarApp/CQtDeployer/wiki/QIF(ru)) |
| deb | Создаст deb пакет для развертываемой программы" |
| | Примеры: cqtdeployer deb |
| | Вы можете указать путь к своему собственному шаблону пакета. |
| | Примеры: cqtdeployer -deb path/to/myCustom/DEBIAN. Подробнее можно посмотреть [здесь](https://github.com/QuasarApp/CQtDeployer/wiki/DEB(ru)) |
| deploySystem | Копирует все библиотеки кроме libc |
| | (не рекомендуется, так как занимает много памяти, возможны конфликты библиотек) |
| deploySystem-with-libc | Копирует все зависимости в том числе и libc, не рекомендуется использовать с gui приложения, в место этого используйте опцию deploySystem |
### Параметры развертывания:
| Option | Descriptiion |
|-----------------------------|-----------------------------------------------------------|
| -bin [list, params] | Развертываемый файл или папка. пример -bin ~/my/project/bin/,~/my/project/bin.exe|
| -binDir [params] | Папка с развертываемыми файлами (с рекурсивным поиском). |
| -confFile [params] | Путь к файлу json со всеми конфигурациями развертывания. С помощью этого файла можно добавить нужные опции, тем самым упрастить вызов комманды в консоле. Однако пораметры в кансоле имеют больший приоритет чем в файле. Для получения дополнительной информации об этом флаге см. [Вики](https://github.com/QuasarApp/CQtDeployer/wiki/DeployConfigFileRu) |
| -qmlDir [params] | Папка qml. пример -qmlDir ~/my/project/qml |
| -qmake [params] | Путь к qmake. пример |
| | -qmake ~/Qt/5.14.0/gcc_64/bin/qmake |
| -ignore [list,params] | Список библиотек для игнорирования |
| | Пример -ignore libicudata.so.56,libicudata2.so.56 |
| -ignoreEnv [list,params] | Список путей для игнорирования. |
| | Пример -ignoreEnv /bad/dir,/my/bad/Dir |
| -libDir [list,params] | Устанавливает дополнительные пути к библиотекам |
| | Пример -libDir ~/myLib,~/newLibs |
| -extraLibs [list,params] | Устанавливает маску имени библиотеки, для принудительного копирования, Пример "-extraLib mySql" - заставит скопировать в папку с проектом все библиотеки чии имена содержат mySql. Данная опция чуствительна к регистру. |
| -customScript [scriptCode] | Установит дополнительный код в скрипты запуска. |
| -extraPlugin [list,params] | Устанавливает дополнительный путь для extraPlugin приложения|
| -recursiveDepth [params] | Устанавливает глубину поиска библиотек и глубину игнорирования окружения для ignoreEnv (по умолчанию 0) |
| -targetDir [params] | Устанавливает целевой каталог (по умолчанию это путь к первому развертываемому файлу)|
| -verbose [0-3] | Показывает дебаг лога |
## Параметры управлениями пакетами:
| Option | Descriptiion |
|-----------------------------|-----------------------------------------------------------|
| -targetPackage [package;tar1,package;tar2]| Создает новый пакет и добавляет в него 'tar1 и tar2'|
| -qmlOut [package;path,path] | Установит путь к папке с qml |
| -libOut [package;path,path] | Установит путь к папке с зависимостями |
| -trOut [package;path,path] | Установит путь к папке с файламми переводов |
| -pluginOut [package;path,path]| Установит путь к папке с плагинами |
| -binOut [package;path,path] | Установит путь к папке с исполняемыми файлами |
| -recOut [package;path,path] | Установит путь к папке с ресурсами |
| -name [package;val,val] | Установит имя префиксу. Если указать значение без префикса, то значение будет установленно префиксу по умолчанию. |
| -description [package;val,val] | Установит описание префиксу |
| -deployVersion [package;val,val]| Установит версию префиксу |
| -releaseDate [package;val,val] | Установит дату выпуска префиксу |
| -icon [package;val,val] | Установит путь к иконке или логотипу префиксу |
| -publisher [package;val,val]| Установит Издательство (автора) префиксу |
| -homepage [package;val,val] | Установит URL-адрес домашней страницы для пакета |
## Параметры управления плагинами
| Option | Descriptiion |
| ----------------------------|---------------------------------------------------------- |
| -extraPlugin [пакет; val1; val2, SingeleVal] | Устанавливает дополнительный путь к стороннему плагину приложения |
| -enablePlugins [пакет; val1; val2, SingeleVal] | Включает дополнительные плагины для распространения. |
| -disablePlugins [пакет; val1; val2, SingeleVal] | Отключает плагины для распространения. |
| | Вы можете отключить любой плагин вашей сборки Qt, просто проверте список доступных плагинов в свой qlFolder/plugins папке.
| | Пример: Если вы хотите отключить плагин qxcb: -disablePlugins qxcb. Обратите внимание, что имя плагина указывается без его расширения.
## Параметры QtInstallFramework:
| Option | Descriptiion |
|-----------------------------|-----------------------------------------------------------|
| -qifStyle [path/to/style.css]| Устанавливает путь к CSS файлу стиля или устанавливает стиль по умолчанию. Доступные стили: quasar |
| -qifBanner [path/to/banner.png]| Устанавливает путь к png-файлу баннера. |
| -qifLogo [path/to/logo.png]| Устанавливает путь к файлу логотипа png. |
#### Пример: cqtdeployer -bin myApp -qmlDir ~/MyAppProject/qml -qmake ~/Qt/5.15.0/gcc_64/bin/qmake clear

127
docs/ru/Packing.md Normal file
View File

@ -0,0 +1,127 @@
# Общая информация об упаковке ваших дистрибутивов в пакеты.
## Типы упаковки
* Автоматически
* Вручную
## Автоматические пакеты
Пакеты с этим типом создаются автоматически.
По умолчанию в дистрибутиве есть один основной пакет. Вы можете настроить его, используя [Параметры управления пакетами](Options.md).
#### Пример (Установить новое имя для pacakge)
```
ctdeployer ... -name "MyPackage"
```
Если в вашем дистрибутиве есть несколько исполняемых файлов, вы можете создать дистрибутив с несколькими пакетами.
Один пакет может содержать от 1 до бесконечности исполняемых файлов.
Для настройки пакета необходимо использовать параметр targetPackage.
Пример использования:
```
cqtdeployer ... -targetPackage myPacage; target1, myPacage2; target2
```
Где myPacage - это имя пакета, а target1 - имя исполняемого файла.
Итак, в этом примере создается 2 пакета из 2 целей.
В следующем примере создается 2 пакета из 3 целей.
```
cqtdeployer ... -targetPackage myPacage; target1, myPacage; target2, myPacage2; target3
```
Вы также можете сделать то же самое в файле конфигурации
```
{
"targetPackage": [
[
"myPacage",
"target1"
],
[
"myPacage2",
"target2"
]
]
}
```
```
{
"targetPackage": [
[
"myPacage",
"target1"
],
[
"myPacage",
"target2"
],
[
"myPacage2",
"target3"
]
]
}
```
## Ручные пакеты
Ручные пакеты - это пакеты, созданные по шаблону пользователя.
Например, у вас есть приложение, которое должно выполнять сложный сценарий в пакете debian или программе установки.
Итак, вам нужно создать свой шаблон и добавить путь к вашему шаблону для варианта пакета.
пример
```
cqtdeployer ... -qif /path/to/my/template/installer
```
Папка /path/to/my/template/installer должна содержать папку с именем пакета.
например, я развертываю приложение с именем "MyExample", поэтому мой настраиваемый шаблон должен быть расположен в
/path/to/my/template/installer/MyExample путь.
Для многопакетных дистрибутивов применяются те же правила.
Ваша папка с шаблонами должна содержать папки с такими же названиями, что и пакеты.
Пример:
```
{
"targetPackage": [
[
"myPacage",
"target1"
],
[
"myPacage",
"target2"
],
[
"myPacage2",
"target3"
]
]
}
```
```
~/path/to/my/template/installer $ tree
.
├── myPacage
│ └── ...
└── myPacage2
└── ...
```
## Доступные пакеты
* [Qt Install Framework](https://github.com/QuasarApp/CQtDeployer/wiki/QIF(en))
* [ZIP-архив](https://github.com/QuasarApp/CQtDeployer/wiki/ZIP(en))
* [Пакет DEB](https://github.com/QuasarApp/CQtDeployer/wiki/DEB(en))

81
docs/ru/QIF.md Normal file
View File

@ -0,0 +1,81 @@
## Общие правила использования Qt Installer Framwork
### Что такое Qt Installer Framwork
**Qt Installer Framework** (QIF) предоставляет набор инструментов и утилит для создания установщиков для поддерживаемых настольных платформ Qt: Linux, Microsoft Windows и OS X.
В **CQtDeployer** QIF доступен в виде опции qif.
### Как использовать опцию qif
Опция qif является булевским параметром для создания Установочного файла.
#### Пример:
``` bash
cqtdeployer ... qif
```
Где:
* **...** - список других опций.
* **qif** - опция для использования qt installer framework с шаблоном по умолчанию.
По умолчанию cqtdeployer создаст установочный файл с одним пакетом в котором будет лежать весь ваш дистрибутив.
Если вы хотите его настроить вы должны использовать [параметр c поддержкой выбора пакета](https://github.com/QuasarApp/CQtDeployer/wiki/Параметры)
Для создание нового пакета используйте флаг -targetPackage [package;tar1]
Где:
* **package** - это имя пакета
* **tar1** - это название таргета который должен попасть в этот пакет.
Или вы можете описать пакеты в [конфигурационном файле](https://github.com/QuasarApp/CQtDeployer/wiki/DeployConfigFileRu)
```json
{
"targetPackage": [
[
"package",
"tar1"
]
],
}
```
# Пользовательский Шаблон для QIF
Начиная с Версии CQtDeployer 1.5 вы можете использовать свой собственный шаблон установщика. Для этого вы должны передать в параметр qif путь к вашему шаблону.
### Шаблон
Шаблон qif долже содержать 2 папки:
* packages
* config
### Внимание
Название пакетов в папке packages должны совподать с названием пакетов при развертывание.
Например:
``` json
"targetPackage": [
[
"myCustomInstaller",
"tar1"
]
],
```
``` bash
.
├── config
│ ├── config.xml
│ └── style.qss
└── packages
└── myCustomInstaller
└── meta
├── installscript.qs
└── package.xml
4 directories, 4 files
```
Если имена папок не совподут с именами пакетов то CQtDeployer будет использовать стандартный пакет для QIF.

81
docs/ru/QuickGuide.md Normal file
View File

@ -0,0 +1,81 @@
Как развернуть приложение с помощью CQtDeployer
1. Прежде всего вам нужно установить CQtDeployer на вашу платформу
* Snap (более 14 дистрибутивов Linux):
```
sudo snap install cqtdeployer
```
или
Установите из магазина snap и включите все необходимые приложению разрешения.
[![Download from Snap Store](https://snapcraft.io/static/images/badges/ru/snap-store-black.svg)](https://snapcraft.io/cqtdeployer)
* Другие Linux дистрибутивы [LinuxInstaller.run][1].
```
chmod +x LinuxInstaller.run
./LinuxInstaller.run
```
* Windows [installer][1]
2. Скомпилируйте ваш проект в режиме релиза.
3. Разверните ваш исполняемый файл:
* Для Linux систем:
``` bash
cqtdeployer -bin myexecutable
```
* Для Windows систем:
``` bash
cqtdeployer -bin myexecutable.exe -qmake C:/Qt/5.15.0/min_gw/bin/qmake.exe
```
* Для кросплатформенной сборки (Linux -> Windows)
``` bash
cqtdeployer -bin myexecutable.exe -qmake ~/crossbuildet-Qt/5.15.0/min_gw/bin/qmake
```
## Дополнительные опции
Если вы используете дополнительные библиотеки, просто добавьте путь к cqtdeployer для используемых библиотек.
``` bash
cqtdeployer -bin myexecutable -libDir /PathToMyExtraLibs
```
Если вы хотите найти библиотеки рекурсивно по пути libDir, просто добавьте рекурсивный параметр Depth.
``` bash
cqtdeployer -bin myexecutable -libDir /PathToMyExtraLibs -recursiveDepth 5
```
Если ваше приложение использует qml, просто добавьте опцию qmlDir
``` bash
cqtdeployer -bin myexecutable -libDir /PathToMyExtraLibs -recursiveDepth 5 -qmlDir /path/to/my/qml/sources
```
Если вы хотите создать простой установщик для вашего приложения, просто добавьте опцию qif.
```
cqtdeployer -bin myexecutable -libDir /PathToMyExtraLibs -recursiveDepth 5 -qmlDir /path/to/my/qml/sources qif
```
Если вы используете системные библиотеки из системного PATH, просто добавьте опцию deploySystem.
#### Предупреждение: версия Snap не имеет прав доступа к системным файлам. Для развертывания системных библиотек используйте версию cqtdeployer из [установщика][1]
```
cqtdeployer -bin myexecutable -libDir /PathToMyExtraLibs -recursiveDepth 5 -qmlDir /path/to/my/qml/sources qif deploySystem
```
### Если у вас есть какие-либо проблемы с использованием cqtdeployer, тогда задавайте вопросы на официальной github [странице][2].
### Дополнительные параметры CQtDeployer см. В официальной [документации][3].
[1]: https://github.com/QuasarApp/CQtDeployer/releases
[2]: https://github.com/QuasarApp/CQtDeployer/issues
[3]: https://github.com/QuasarApp/CQtDeployer/wiki/Options

3
docs/ru/ReleaseReviews.md Executable file
View File

@ -0,0 +1,3 @@
# Обзоры на релизы
* [Обзор v1.4 (Бинарный ящик)](https://github.com/QuasarApp/CQtDeployer/wiki/1_4_ru)

44
docs/ru/ZIP.md Normal file
View File

@ -0,0 +1,44 @@
## Общие правила использования ZIP
#### Доступно с версии CQtDeployer 1.5
### Как использовать опцию zip
Просто добавьте в cqtdeployer опцию «zip».
#### Например:
``` bash
cqtdeployer ... zip
```
Где:
* ** ... ** - список других опций.
* ** zip ** - опция использования zip архивов.
По умолчанию cqtdeployer создает один zip-архив.
Если вы хотите создать рассылку нескольких пакетов, вы должны использовать [Параметры управления пакетами](https://github.com/QuasarApp/CQtDeployer/wiki/Options)
Чтобы создать новый пакет, используйте -targetPackage [package; tar1] вариант
cqtdeployer создает zip-архив для каждого пакета.
Где:
* **package** - это название пакета
* **tar1** - это имя цели, которая должна быть включена в этот пакет.
Или вы можете описать пакеты в [файле конфигурации](https://github.com/QuasarApp/CQtDeployer/wiki/DeployConfigFileEn)
```JSON
{
"targetPackage": [
[
"package",
"Tar1"
],
],
"zip": true
}
```

View File

Before

Width:  |  Height:  |  Size: 26 KiB

After

Width:  |  Height:  |  Size: 26 KiB

View File

Before

Width:  |  Height:  |  Size: 17 KiB

After

Width:  |  Height:  |  Size: 17 KiB

View File

Before

Width:  |  Height:  |  Size: 24 KiB

After

Width:  |  Height:  |  Size: 24 KiB