Writing Documentation | Extending Qt Creator Manual

- Extending Qt Creator Manual
- Writing Documentation
- Extending Qt Creator Manual 4.12.4

External Tool Specification Files ◦ Qt Creator Coding Rules

# Writing Documentation

When you add plugins or contribute new features to Qt Creator, you probably want other people to know about them and to be able to use them. Therefore, you should also contribute documentation for them. Follow the guidelines in this section to make sure that your documentation fits in well with the rest of the Qt Creator documentation.

When you contribute a plugin, you should write documentation both for the developers who use Qt Creator and for the ones who develop it.

Write the following user documentation for addition to the Qt Creator Manual:

- Overview topic, which describes the purpose of your plugin from the viewpoint of Qt Creator users
- Procedure topics, which describe how to use your plugin as part of Qt Creator
- Reference topics, which contain information that developers occasionally need to look up (optional)

Write the following developer documentation for addition to the Extending Qt Creator Manual:

- Overview topic, which describes the architecture and use cases for your plugin from the viewpoint of Qt Creator developers
- API documentation, which is generated from code comments

## Configuring Documentation Projects

Qt Creator documentation is written by using QDoc. For more information about using QDoc, see the QDoc Manual.

QDoc finds the new topics automatically, when you place them as `.qdoc` files in a doc source folder. However, to make the topics accessible to readers, you must also add them to the table of contents and fix the next page and previous page links to them from other topics.

## Creating Folders and Files

The `qtcreator` repository contains the sources for building the following documents:

- Qt Creator Manual
- Extending Qt Creator Manual
- Qt Design Studio Manual

The sources for each project are stored in the following subfolders of the Qt Creator project folder:

- `\doc\qtcreator\src`
- `\doc\qtcreatordev\src`
- `\doc\qtdesignstudio\src`

The Qt Design Studio Manual is based on the Qt Creator Manual, with additional topics.

The Extending Qt Creator Manual has its own sources. In addition, it pulls in API reference documentation from the Qt Creator source files. Add code documentation directly to the code source files. However, you can write an API overview also as a separate `.qdoc` file.

Create a subfolder for your documentation in the appropriate `src` folder. Create a separate file for each topic.

The easiest way is probably to copy an existing file, save it as a new file, and modify it. This way, you already have samples of the necessary bits and pieces in place, such as topic start and end commands, copyright statement, links to next and previous topics, and topic title.

## Integrating Topics to Documentation

You must integrate your new topics to the manuals by adding links to them to the table of contents and to other relevant topics.

To link to the topic, you can use the topic title. For example:

     \l{Integrating Topics to Documentation}

This does not work if topic titles are not unique. Also, if you change the title, the link breaks. You can avoid this risk by adding the `\target` command to your topic and then linking to the target.

### Showing and Hiding Information

Qt Design Studio uses only a subset of Qt Creator plugins and it has its own special plugins. This means that their manuals have somewhat different structures. Which, in turn breaks the navigation links to previous and next pages.

This also means that some of the Qt Creator Manual source files are not needed at all and some contain information that does not apply to the Qt Design Studio Manual. If QDoc parsed all the Qt Creator Manual sources, it would generate HTML files for each topic and include those files and all the images that they refer to in the Qt Design Studio help compilation files. This would unnecessarily increase the size of the Qt Design Studio help database and pollute the help index with references to files that are not actually listed in the table of contents of the Qt Design Studio Manual. To avoid this, some files are excluded from the Qt Design Studio Manual builds.

#### Excluding Souce Files from Qt Design Studio Manual Builds

The directories to exclude from Qt Design Studio Manual builds are listed as values of the `excludedirs` option in `\doc\qtdesignstudio\config\qtdesignstudio.qdocconf`.

You only need to edit the values of the option if you want to show or hide all the contents of a directory. For example, if you add support for a Qt Creator plugin that was previously not supported by Qt Design Studio, you should remove the directory that contains the documentation for the plugin from the values.

To hide or show individual topics within individual `.qdoc` files, you need to move the files in the Qt Creator Manual source (`\doc\qtcreator\src`) to or from the excluded directories.

For example, if support for iOS were added, you would need to check whether the information about iOS support is applicable to Qt Design Studio Manual. If yes, you would need to remove the following line from the `excludedirs` value:

     ../../src/ios \

You would then use defines to hide any Qt Creator specific information from the source file in the directory.

If a directory contains some files that are needed in both manuals and some that are only needed in the Qt Creator Manual, the latter are located in a subdirectory called `creator-only`, which is excluded from the Qt Design Studio Manual builds.

#### Hiding Text in Qt Creator Manual Sources

The `qtcreator` define is specified as a value of the `defines` option in the Qt Creator QDoc configuration file, `\doc\qtcreator\config\qtcreator-project.qdocconf`. It is mostly used in the Qt Creator Manual sources to hide Qt Creator specific information when the Qt Design Studio Manual is built.

The `\else` command is sometimes used to replace some Qt Creator specific text with text that applies to Qt Design Studio. For example, the following `if-else` statement is needed in the Qt Creator Manual sources, because the project wizards in Qt Design Studio are different from those in Qt Creator, and are therefore described in a new topic that is located in the Qt Design Studio Manual sources:

     For more information, see
     \if defined(qtcreator)
     \l{Creating Qt Quick Projects}.
     \else
     \l{Creating UI Prototype Projects}.
     \endif

Note: Section titles in the two manuals can be identical only if the page is excluded from the Qt Design Studio Manual. In this case, QDoc can correctly determine the link target. If you add a link to a section title that appears twice in the doc source files, QDoc uses the first reference to that title in the `.index` file.

#### Writing About Qt Design Studio Specific Features

Qt Design Studio specific plugins and features are described in a set of doc source files located in the `\doc\qtdesignstudio\src` directory. Some files are used to include subsections in topics in the Qt Creator Manual sources.

Screenshots and other illustrations are stored in the `\qtdesignstudio\images` directory.

If you add new topics to the Qt Design Studio Manual, add links to them to the table of contents in `qtdesignstudio-toc.qdoc` and check the values of the navigation links around them.

#### Including Sections in Qt Creator Manual Sources

Qt Quick Designer is an integral part of both Qt Creator and Qt Design Studio. Therefore, most topics that describe it are needed in the manuals of both tools. You can use the `\include` command in the Qt Creator Manual sources to include `.qdocinc` files from the Qt Design Studio Manual sources when building the Qt Design Studio Manual.

For example, the following lines in the `\doc\qtcreator\src\qtquick\qtquick-components.qdoc` file add information about creating and using Qt Design Studio Components to the Creating Components topic that is pulled from the Qt Creator Manual sources:

     \if defined(qtdesignstudio)
     \include qtdesignstudio-components.qdocinc creating studio components
     \include qtdesignstudio-components.qdocinc studio components
     \endif

Similarly, you can use include files to include subsections in different main level topics in the two manuals.

### Updating Next and Previous Links

When you add new topics to a document, you must also change the navigation links of the topics around them.

The navigation order of the topics in the Qt Creator Manual is specified in `\doc\qtcreator\src\qtcreator-toc.qdoc` and that of the topics in the Qt Design Studio Manual in `\doc\qtdesignstudio\src\qtdesignstudio-toc.qdoc`. If you add topics to or move them around in a TOC file, you must adjust the navigation links accordingly.

The `qtdesignstudio` define is specified as a value of the `defines` option in the Qt Design Studio Manual configuration file, `qtcreator\doc\qtdesignstudio\config\qtdesignstudio.qdocconf`. It is mostly used in the Qt Creator Manual sources to specify values for the `\previouspage` and `\nextpage` commands depending on whether the Qt Design Studio Manual or Qt Creator Manual is being built. For example, the following `if-else` statement is needed, because only the Git version control system is integrated to Qt Design Studio, and information about the other systems integrated to Qt Creator is hidden:

     \page creator-vcs-git.html
     \if defined(qtdesignstudio)
     \previouspage studio-projects.html
     \nextpage studio-importing-designs.html
     \else
     \previouspage creator-vcs-cvs.html
     \nextpage creator-vcs-mercurial.html
     \endif

## Writing Text

Follow the guidelines for writing Qt documentation.

The documentation must be grammatically correct English and use the standard form of written language. Do not use dialect or slang words. Use idiomatic language, that is, expressions that are characteristic for English. If possible, ask a native English speaker for a review.

### Capitalizing Headings

Use the book title capitalization style for all titles and section headings (`\title`, `\section1`, `\section2`, and so on). For more information, see Using Book Style Capitalization.

## Using Images

You can illustrate your documentation by using screen shots, diagrams, and other images.

Use the `\image` and `\inlineimage` QDoc commands to refer to images from the text. You do not need to add paths to image names. For example:

     \image riot.png

### Taking Screen Shots

Qt Creator has the native look and feel on Windows, Linux, and macOS, and therefore, screen shots can end up looking very different, depending on who takes them and which system they use. To try to preserve a consistent look and feel in the Qt Creator Manual, observe the guidelines listed in this section when taking screen shots.

Note: Do not rely on screen shots present reasonable example values to users, but always place example values also in the text.

- Use the screen resolution of 1366x768 (available on the most commonly used screens, as of this writing).
- Use the aspect ratio of 16:9.
- Open the application in the maximum size on full screen.
- Use your favorite tool to take the screen shot.
- Include only the part of the screen that you need (you can crop the image also in the screen capture tool).
- To highlight parts of the screen shot, use the images of numbers that are stored in `doc/images/numbers` in the Qt Creator repository.
- Before you submit the images to the repository, optimize them to save space.

### Hightlighting Parts of the Screen

You can use number icons in screenshots to highlight parts of the screenshot (instead of using red arrows or borders, or something similar). You can then refer to the numbers in text. For and example, see the Development Tools topic in the Qt reference documentation.

This improves the consistency of the look and feel of Qt documentation, and eliminates the need to describe parts of the UI in the text, because you can just insert the number of the element you are referring to in brackets.

You can find a set of images that show the numbers from 1 to 10 in the `doc/images/numbers` directory (or in the `qtdoc` module sources in `doc/images/numbers`).

To use the numbers, copy-paste the number images on the screenshot to the places that you want to refer to from text.

### Optimizing Images

Save images in the PNG format in the Qt Creator project folder in the `doc/images` folder. Binary images can easily add megabytes to the Git history. To keep the history as small as possible, the Git post-commit hooks remind you to try to keep image size below 50 kilobytes. To achieve this goal, crop images so that only relevant information is visible in them. Before committing images, optimize them by using an image optimization tool.

Optimization should not visibly reduce image quality. If it does, do not do it.

You can use a web service, such as https://tinypng.com, or an image optimization tool to shrink the images. For example, you can use the Radical Image Optimization Tool (RIOT) or OptiPNG on Windows, ImageOptim on macOS, or some other tool available on Linux.

With ImageOptim, you simply drag and drop the image files to the application. The following section describes the settings to use for RIOT.

#### Using RIOT

Download and install RIOT.

Open your images in RIOT and use the following settings for them:

- Color reduction: Optimal 256 colors palette
- Reduce colors to: 256
- Best compression (slow)
- Color quantization algorithm: NeuQuant neural-net (slow)
- External optimizers: OptiPNG o3

Compare the initial and optimized images to check that image quality is preserved. If the image quality deteriorates, do not use color reduction (select the True Color option, instead).

You can also see the sizes of the initial and optimized image.

#### Using OptiPNG

Download and install OptiPNG.

OptiPNG is a command-line tool that you can invoke from the Qt Creator project folder (or any folder that contains your project). To optimize a screenshot, enter the following command (here, from the Qt Creator project folder):

     optipng -o 7 -strip all doc/images/<screenshot_name>

## Building Documentation

You use QDoc to build the documentation. Build the documentation before submitting any documentation patches, to check its structure, contents, and the validity of the QDoc commands. The error messages that QDoc issues are generally very useful for troubleshooting.

### Setting Up Documentation Builds

You can run `qmake` from an installed Qt to build documentation.

Note: Since Qt Creator version 4.12, only Qt 5.14.0 or later is supported for building documentation.

For more information about setting up the build environment with a self-built Qt if you do not want to build the whole Qt, see Building Qt Documentation on the Qt wiki.

The content and formatting of documentation are separated in QDoc. The documentation configuration, style sheets, and templates have changed over time, so they differ between Qt and Qt Creator versions.

The templates to use are defined by the `qt5/qtbase/doc/global/qt-html-templates-offline.qdocconf` and `qt5/qtbase/doc/global/qt-html-templates-online.qdocconf` configuration file. They are fetched from Qt sources by adding the following lines to the qdocconf file:

- `include ($QT_INSTALL_DOCS/global/qt-html-templates-offline.qdocconf)` for help files
- `include ($QT_INSTALL_DOCS/global/qt-html-templates-online.qdocconf)` for publishing on the web

Note: To have the correct fonts loaded for the online version, you must be running it on a web server.

Note: If the styles look wrong to you when reading help files in Qt Creator or Qt Assistant, you might be looking at them in the QTextBrowser instead of the Qt WebEngine browser. This happens if you do not have Qt WebEngine installed.

### Documentation Build Commands

To build documentation for the sources from the qtcreator master branch, use build scripts defined in the doc.pri file. To build the docs in the HTML format and to create help files (.qch), enter the following build commands from the project folder (after running qmake):

- `nmake docs` (on Windows)
- `make docs` (on Linux and macOS)

The HTML documentation is generated in the following folders:

- `doc/html/qtcreator`
- `doc/html/qtcreatordev`
- `doc/html/qtdesignstudio`

The help files (`.qch`) are generated in the `share/doc/qtcreator` directory in the Qt Creator build directory on Windows and Linux, and in the `bin/Qt Creator.app/Contents/Resources/app` directory on macOS.

You can view the HTML files in a browser and the help files in the Qt Creator Help mode. For more information about adding the help files to Qt Creator, see Adding External Documentation.

Besides `docs`, you have the following options for building a particular document in a particular format:

- `html_docs_qtcreator` - build Qt Creator Manual in help format, but do not generate a help file
- `html_docs_qtcreator-dev` - build Extending Qt Creator Manual in help format, but do not generate a help file
- `qch_docs_qtcreator` - build Qt Creator Manual in help format and generate a help file (.qch)
- `qch_docs_qtcreator-dev` - build Extending Qt Creator Manual in help format and generate a help file (.qch)

#### Building the Qt Design Studio Manual

To get the correct product name and version, you must run `qmake -r` on `qtcreator.pro` with the `IDE_BRANDING_PRI` option set to the absolute path of `ide_branding.pri` in the Qt Design Studio (private) repository.

For example, on Windows enter (all on one line):

     C:\dev\qtc-super\qtcreator>..\..\..\Qt\5.14.1\msvc2017_64\bin\qmake.exe
         qtcreator.pro -r
         IDE_BRANDING_PRI=C:\dev\tqtc-plugin-qtquickdesigner\studiodata\branding\ide_branding.pri

To build the Qt Design Studio Manual:

1. Run `qmake` from Qt 5.14.0, or later with the path to the branding information as an option (all on one line):

   `<relative_path_to>/qmake.exe qtcreator.pro -r IDE_BRANDING_PRI=<absolute_path_to>ide_branding.pri`

2. Run `make docs` on Linux and macOS or `nmake docs` on Windows.

External Tool Specification Files ◦ Qt Creator Coding Rules