Qbs Manual

Qbs 1.11.1

FileTagger ◦ Module

# Group QML Type

Groups files in a product. More...

Import Statement: | import QbsLanguageItems .

- List of all members, including inherited members

## Properties

- condition : bool
- excludeFiles : list
- fileTags : list
- fileTagsFilter : list
- files : list
- filesAreTargets : bool
- name : string
- overrideTags : bool
- prefix : string

## Detailed Description

This item is attached to a product and used to group files that have something in common.

For example:

      Application {
          Group {
              name: "common files"
              files: ["myclass.h", "myclass_common_impl.cpp"]
          }
          Group {
              name: "Windows files"
              condition: qbs.targetOS.contains("windows")
              files: "myclass_win_impl.cpp"
          }
          Group {
              name: "Unix files"
              condition: qbs.targetOS.contains("unix")
              files: "unixhelper.cpp"
              Group {
                  name: "Linux files"
                  condition: qbs.targetOS.contains("linux")
                  files: "myclass_linux_impl.cpp"
              }
              Group {
                  name: "FreeBSD files"
                  condition: qbs.targetOS.contains("freebsd")
                  files: "myclass_freebsd_impl.cpp"
              }
          }
          Group {
              name: "Files to install"
              qbs.install: true
              qbs.installDir: "share"
              files: "runtime_resource.txt"
          }
      }

When specifying files, you can use the wildcards "*", "?" and "[]", which have their usual meaning. By default, matching files are only picked up directly from the parent directory, but you can tell Qbs to consider the whole directory tree. It is also possible to exclude certain files from the list. The pattern ** used in a pathname expansion context will match all files and zero or more directories and subdirectories. For example:

              Group {
                  name: "Word processing documents"
                  files: ["*.doc", "*.rtf"]
                  prefix: "**/"
                  qbs.install: true
                  qbs.installDir: "share"
                  excludeFiles: "do_not_install_this_file.*"
              }

A group can also be used to attach properties to build artifacts such as executables or libraries. In the following example, an application is installed to "<install root>/bin".

      Application {
          Group {
              fileTagsFilter: "application"
              qbs.install: true
              qbs.installDir: "bin"
          }
      }

Groups may also appear in modules, which causes the respective sources to be added to the products depending on the said module, unless the filesAreTargets property is set.

Groups can be nested. In this case, child groups inherit the module properties and file tags as well as the prefix of their parent group. The condition of a child group gets logically ANDed with the one of its parent group.

## Property Documentation

condition : bool

Determines whether the files in the group are actually considered part of the project.

Default: `true`

excludeFiles : list

A list of files that are subtracted from the files list. Useful when using wildcards.

Default: An empty list

fileTags : list

A list of file tags to attach to the group's files. These can then be matched by a rule.

Note: File taggers are never applied to a file that has this property set.

Default: An empty list

fileTagsFilter : list

List of artifact.fileTags to match. Any properties set in this group will be applied to the product's artifacts whose file tags match the ones listed here.

The file tags that the group's fileTags property specifies will be added to the matching artifacts.

This property is mutually exclusive with files.

Default: An empty list

files : list

The files in the group. Mutually exclusive with fileTagsFilter. Relative paths are resolved using the parent directory of the file that contains the Group item. However, if the prefix property is set to an absolute path, then that one becomes the base directory.

Default: An empty list

filesAreTargets : bool

If this property is `true` and the group is in a Module, the files in the group will not become source artifacts of the product that depends on the module. Instead, they are treated like target artifacts of products. That is, they will be matched against the inputsFromDependencies file tag list of rules in products that depend on the module.

Default: `false`

name : string

The name of the group. Not used internally; mainly useful for IDEs.

Default: "Group x", where x is a unique number among all the groups in the product.

overrideTags : bool

Determines how tags on files that are listed both at the top level of a product (or the parent group, if there is one) and a group are handled. If this property is `true`, then the file tags set via the group replace the ones set via the product or parent group. If it is `false`, the group tags are added to the parent tags.

This property is ignored if fileTagsFilter is set.

Default: `true`

prefix : string

A string to prepend to all files. Slashes are allowed and have directory semantics.

Default: The prefix of the parent group if one exists, otherwise empty.

FileTagger ◦ Module