QPM:PackageManifest

unreleased=”true” (filters out this package from Package Installer)

QPM:PackageDescription

The first block describes the package and it origins. If the manifest is separated from the actual package, this information may be used to find the complete package.

QPM:PackageType: <enum: Application | Library | Development | Documentation | Source code | Other>

Defines the type of package.

Packager uses this tag to determine when invalid files are in the basedir to create this particular type of package.

QPM:PackageName: <string>

The actual name of the package as it would be found in an archive repository.

Example: tast-dev-1.1-x86-qnx

QPM:PackageSize: <#.#M | #.#K | # | #.#Mb | #.#Kb>

The size of the compressed package in megabytes, kilobytes, or bytes. For example, "1.1 M", "1.5Mb", 1.0 Mb", "1024 Kb", "2096K" or even "12896662" (which assumes bytes).

The packager automatically determines the compressed package size and inserts this value into the manifest, as a number of bytes.

QPM:PackageReleaseNumber: <integer>

If the package has been re-released, the release number will have been increased. A package may be re-released when it was found to be corrupted, found to be infected with a virus, or something else (unrelated to the product content) needed changing. Changing the package manifest should result in an increase to the package release number.

This value must be independent of the version number.

When originally releasing a package, this value should be 1.

QPM:PackageReleaseNotes: <text>

When a package is re-released, the maintainer has the option of adding a package release note to describe why the package was changed. Common changes may include “Package was corrupted”, “Package was missing files”, or “Manifest has been updated”. These notes will be presented to a user when they are using an auto-update utility.

QPM:PackageReleaseUrgency: <enum: Low | Medium | High>

A release urgency description allows package browsers to alert users about package updates, to indicate the severity of the re-release.

A low urgency will not alert the user; packages re-released due to manifest changes are a low priority. Low urgency is warranted with changes to descriptions, web pages, and other non-critical manifest changes.

A medium urgency should show the user the package release note and let the user decide if they should reinstall the package. Medium urgency would be indicated due to bugs, missing support files or corrupted files.

A high-priority package release indicates that the user should immediately update to this package; packages released with dangerous errors (such as a virus) should be released with a high urgency.

QPM:PackageReleaseDate: <YYYY/MM/DD>

The date this package is to be released for use.

The Package Installer will not show or install any packages which are to be released in the future, so setting this date forward can ensure that the package will not be installed until the date specified.

The packager uses today’s date as the default date, unless it is overridden by the user.

QPM:PackageRepository: <URL>

This is the URL where the latest information about the package can be found. A home repository does not necessarily have to have the package, just the most up-to-date manifest.  Alternate repositories are mirror locations where this package can be found. Although packages may migrate without their manifests being updated, these alternate repositories represent where the package maintainer regularly places package (and product) updates.

QPM:PackageSignature: <text>

A signed signature may be used to validate the package content.

QPM:PackageSignatureType: <enum: MD5Sum | PGP | SHASum>

The type of validation mechanism to use with the given signature

QPM:PackageModel: <enum: none | dev |  src | so name (ie: libcurl.so.1.0.0)>

Shows the type of package, either development or source, which is reflected in the package filename. None is the default, if this tag is not present.

QPM:PackageDefaultState: <enum: normal | hidden>

If it’s hidden, then the package will not show up in package installer, by default, unless there’s an option to show all packages.

This is used for ‘so’ packages which are simply installed/uninstalled by the contains/requires/provides library tags.

QPM:BundleContains:

This tag is ignored by Package Installer.

QPM:BundleChild: <PackageName or ProductIdentifier> <multiple entries>

One entry for each package which is to be contained in this bundle.

This tag is questionable—currently under development.

QPM:BundleShow <yes>

If this tag is present, the package will be shown in its regular topic hierarchy, even if the package is bundled.

QPM:BundleStrict <yes>

If the package is installed as a result of a dependency coming from another package, this tag forces the package’s entire bundle to be installed, not just the package itself.

QPM:FileVersion: <float (2 decimal places) version number>

The packager inserts this tag to indicate what version of  package installer is required in order to install to this package.

If a package has a <QPM:FileVersion> higher than the VERSION (currently 1.01) of the Package Installer, the package will not be installed until an updated version of package installer is installed.

QPM:ProductDescription

The second block provides a high-level description of the product contained within the package.

QPM:ProductName: <string>

The product name, like “Voyager Web Browser”, “PhotoShop”, or “libChuck”. This is to be a fully readable name that will appear during installation and maintenance. The product name may be any number of letters and characters, but should not indicate a version number.

A package will not be installed if this tag is not found.

QPM:ProductSize: <#.#M | #.#K | # | #.#Mb | #.#Kb>

The size of the product after it has been installed (and expanded) in megabytes, kilobytes, or bytes. For example, "1.1 M", "1.5Mb", 1.0 Mb", "1024 Kb", "2096K" or even "12896662" (which assumes bytes).

If the package needs additional disk space for cache or temporary files, this may be described in the free disk space section of the hardware requirements block.

The packager automatically determines the uncompressed package size and inserts this value into the manifest, as a number of bytes.

QPM:ProductIdentifier: <1-13 character identifier; no whitespace>

The product identifier is a short name used for dependency identification, for example: vger, emacs. This differs from the product name in that it is not necessarily a human-readable string. If a product is a replacement product (newer version), the two products would have the same product identifiers.

The identifier must not include any whitespace characters and must not exceed 13 characters in length (the packager automatically ensures these requirements are met).

Other developers may use this identifier to define dependencies with your product.

If a release is incompatible with a previous release, the product identifier must be different than the old release’s identifier.

The product identifier ensures that your software will not be installed over any other piece of software.

A package will not be installed if this tag is not found.

QPM:ProductHomeURL: <URL>

The product home URL, if provided, will let package browsers launch a full web browser for the given product. Here, they would expect to find further details regarding the product, or other supplemental information.

The Package Installer does not use this tag.

Example: www.qnx.com/photon/ped.html

QPM:ProductEmail: <email address>

If you have an email for feedback about your product, various package utilities can extract this and make it available to users.

Example: myemail@home.com

QPM:VendorName: <string>

Because you are building this product’s package, you represent the maintainer, vendor, or distributor of this product. Your name, the name of your company or the organization you represent should be available to the user.

This name can differ from the software author.

This should be a text string showing the full legal vendor name.

QPM:VendorInstallName: <1-6 character identifier; no whitespace>

Each vendor must have a unique identifier—a word or set of characters without whitespace. Other developers can use this identifier to distinguish your distribution of a particular product.

Your vendor identifier also helps to ensure that your software will not be installed over any other vendor’s software.

For example: QNX may freely distribute a version of a GNU software package. QNX does not want to obscure the ownership of GNU software. Thus QNX can declare themselves the vendor but leave the author untouched. This allows people to clearly understand that a particular package is being released by QNX, but has not been written by QNX.

The packager ensures that the vendor install identifier does not exceed 6 characters, and that it contains no whitespace.

Example: qnx

QPM:VendorURL: <URL>

If you, your company, or organization has a web site, graphical package installers can redirect users to your website for more information about you as a vendor, and perhaps other products that you distribute.

Example: www.qnx.com/company/index.html

QPM:VendorEmbedURL: <URL>

The QNX Package Installer allows you to embed a web page to be displayed when your package is selected by a user, where they have the opportunity to see more information about you, your company, or organization.

QPM:VendorEmail: <email address>

If you have an email for feedback about you, your company, or organization, various package utilities can extract this and make it available to users.

Example: support@home.com

QPM:AuthorName: <string>

The name of the person, company, or organization that authored this product may be different from the vendor or distributor of the package.

This should be a text string showing the author’s full legal name, either a person or a business.

Example: Joe Blow

QPM:AuthorURL: <URL>

If the author has a web site, graphical package installers can redirect users to that website for more information about the author.

Example: www.home.com

QPM:AuthorEmbedURL: <URL>

The QNX Package Installer allows you to embed a web page to be displayed when your package is selected by a user, where they have the opportunity to see more information about the author.

QPM:AuthorEmail: <email address>

If there is an email for feedback relevant to the author, various package utilities can extract this and make it available to users.

Example: support@home.com

QPM:ProductIconSmall: <URL>

A 16x16 image used in the tree view for the product.

If the icon is part of the package itself, you can use the repository URL identifier rep:// to reference the file.

Example: rep://usr/share/ped/icon_small.gif

QPM:ProductIconLarge: <URL>

An arbitrary-sized image (preferably within 48x48) used to represent the product.

If the icon is part of the package itself, you can use the repository URL identifier rep:// to reference the file.

Example: rep://usr/share/ped/icon_large.gif

QPM:ProductDescriptionShort: <string>

A single-line description of the product (preferably less than 80 characters).

A short text description of the product (assume that the name and version information is already displayed). This will likely be the first description the user will see. (Bear in mind that there is a separate place for more in-depth annotations of version changes).

Example: A compact text editor with full text formatting functionality, multiple buffers, and C/C++ developer’s features.

QPM:ProductDescriptionLong: <text>

A full text description of the product (assume that the name and version information is already displayed). This will likely be the first description the user will see; adding a brief feature/overview list might be useful. (Bear in mind that there is a separate place for more in-depth annotations of version changes).

QPM:ProductDescriptionEmbedURL: <URL>

An HTML description of the product. Assume that the name and version information is already displayed. This will likely be the first description the user will see; adding a brief feature/overview list might be useful. (Bear in mind that there is a place for a more in depth annotation of version changes)

This tag is only used if the repository being accessed is on a local disk (fast).

This tag is unused (commented-out of all packages) at the time of RTP-PatchA.

QPM:ProductDescriptionURL: <URL>

An HTML description of the product. Assume that the name and version information is already displayed. This will likely be the first description the user will see; adding a brief feature/overview list might be useful. (Bear in mind that there is a place for a more in depth annotation of version changes).

This tag is only used if the repository is being accessed using ftp or http.

This tag is unused (commented-out of all packages) at the time of RTP-PatchA.

QPM:InstallPath: <relative path>

Shows the directory to follow to find this manifest file, with respect to the root repository.

A package will not be installed if this tag is not found.

QPM:ReleaseDescription

The third standard block defines the version of the product and the importance of the changes that have occurred since the previous release. Auto-updating software may use some of these fields to help the user to track software upgrades.

QPM:ReleaseCopyright: <string>

The type of copyright or distribution license that this product is being released under.

Examples: GNU Public License, Mozilla Public License, Commercial License, Shareware, and Free.

QPM:ReleaseCopyrightURL: <text>

A reference to the actual license, allowing the user to view the terms of usage before downloading the software.

This tag is not used at this time. See QPM:LicenseUrl.

QPM:ReleaseDate: <YYYY/MM/DD>

The date the software was released, not the date the package was built.

QPM:ReleaseVersion: <##.##[a-z]>

The version of the product. The format for versions is presently assumed to be an increasing number separating minor changes by a period, for example: '5.0', '3', '13.22', '.92', '1.1a'

If this tag is not found, 1.0 will be used.

QPM:RelaseUrgency: <enum: Low | Medium | High>

A release importance description allows package browsers to alert users about product updates.

A low urgency should not alert the user; product patches correcting documentation or aesthetics may be a low priority.

A medium urgency should be used in circumstances where the organization that produces the product recommends the upgrade, at the user's discretion.

A highly urgent package release means that the user should immediately update to this version to fix severe bugs.

QPM:ReleaseStability: <enum: Stable | Experimental | Beta>

Stability of the product overall.

QPM:ReleaseNoteMajor: <text>

When a new version of the product is released, the product version notes tell the user what changes have occurred to warrant the upgrade. These notes should be written from the perspective of an advisory notice. Users will likely see these notes if an auto-updater identifies a version update.

QPM:ReleaseNoteMinor: <text>

A minor release note, which will also be shown with the product version notes. It should be written as an addendum, describing the upgrade changes. A release is considered minor if there is no change to the first number within a version number: 1.0 - 1.0a or 1.0 - 1.9.

QPM:ReleaseBuild: <integer>

The build number for this package. Build numbers should always start with 1 being the initial build for a new version.

QPM:ExcludeCountries

QPM:Country <string> <multiple entries>

Countries which will not permit this package to be installed.

QPM:RelationshipDescription

This block defines the relationship that this package has to other packages.

QPM:RelationshipType: <enum: core | component | upgrade>

This defines the type of product release.

core: this package contains the base list of files common to all processors, or there are no processor-specific files (in which case this is the only package required).

component: the package is a component of another package and the QPM:ComponentParent tag should be defined.

upgrade: the package is an upgraded version of another package and the QPM:UpgradeParent tag should be defined.

QPM:CoreSibling: <1-13 character product identifier; no whitespace>

The name of a product to which this package should be associated. This will cause this package to appear in the same topic hierarchies as the specified sibling. This is useful if you are distributing similar products and want to associate one package with another.

QPM:ComponentType:    <enum: Required | Recommended | Optional>

If this is a component, the install type determines if this package must be downloaded as well.

If this is a core package, the install type refers to its presence as an operating system component.

For example, the standard libraries should never be uninstalled and would be marked as required. The package manager would alert the user to prevent them from inadvertently uninstalling any required packages.

QPM:ComponentTypeNotes: <text>

The reason for the install type. This will be displayed when the user tries to go against a recommendation.

In general, the package installer will have a verbosity level to configure exactly when and how many of these notes should be displayed.

QPM:ComponentParent: <1-13 character product identifier; no whitespace>

This defines a product if this package is a component. This will cause it to be logically grouped with the core package. Uninstallation of the core package will remove the this package; this package cannot be installed until the core package is installed.

QPM:ComponentAuthenticationKey: <public key string>

This is a public key used to verify that a child package signature is legitimate. This is only defined for core packages. If this parent package has components and this key defined, no packages will appear as a component unless the component signature is verified correctly.

QPM:ComponentSignature: <signature>

This is the encrypted checksum of this component, generated by a private key, corresponding to a parent public key. These keys are only valid if we enforce their use by not allowing installs that shadow previous installs.

QPM:ComponentFilter:

Used to specify under what circumstances this package will be considered a component of another package.

QPM:FilterType: <Numeric | StringExpression | Date >

Each filter is qualified with a filtering type. Numeric expressions use <, <=, =, , =, !=, |, &, and (). String expression uses regular expressions to filter the string. Date uses the numeric expression operators but parses the tag's field value to make sure it's in the YYYYMMDD format.

Note that there is no way to check the non-existence of a particular tag. String expressions with * will match as long as the tag exists, but there is no way to test the negative of this condition.

- property: <regular pattern>

Each tag in the filter block is checked (AND logic only) against the given tag (without the QPM: portion) throughout the entire manifest. For example, <CPU>x86</CPU> will check for an x86 distribution, <ReleaseDate> "00001222" </ReleaseDate> followed by: <Libraries> libso.1.0.5 </Libraries> will require that a particular package has been installed

QPM:UpgradeParent: <1-13 character product identifier; no whitespace>

If a product is a release type of upgrade, the upgrade parent defines what package it is upgrading. Upgrade packages require that the upgrade parent is installed first.

If the product is a release type of core but it supplies an upgrade parent, this means that the package can be installed without the previous version being installed.

For example, a package maintainer may want to release an upgrade from version 1.0 to version 2.0 which requires 1.0 be installed first; the maintainer may also want to distribute a complete 2.0 version which does not require 1.0. Auto updating software will check the product upgrade parent tag for each package, looking for this corresponding product identifier. It may then offer to uninstall the previous version and install a new core 2.0 version.

QPM:UpgradeFromVersion: <##.##>

If a product is a release type of upgrade, the upgrade version defines what version of package it is upgrading.

QPM:ContentDescription

This block provides fields for searching and filtering packages according to content.

QPM:ContentKeyword: <string list>

A comma-delimited keyword list which a package browser can use to index your package.

QPM:ContentTopic: <hierarchy list> <multiple entries>

A slash-delimited (/) hierarchical description which a package browser can use to place your package in a topic hierarchy. QNX's package system has recommended topic hierarchies but the hierarchy itself is defined by the topic entries of all the packages within a repository.

Packages that only want to be associated with another package need not supply a topic, they need only define a sibling or a component package.

If this tag is not found, “  “ will be used by default.

QPM:ContentLanguage: <two letters>

This is a comma-delimited list of two-letter language codes, representing the this product's language compatibility.

QPM:Contains: <mime-string>  <multiple entries>

A comma-delimited string of single word identifiers, used to identify the generic type of package.

ie: font, compiler, os

QPM:Provides: <string> <multiple entries>

Used in dependencies/relationships to specify what a particular package provides.

QPM:ContainsLibrary: <library name> <multiple entries>

Shows what libraries are made available when this package is installed.

Any .so.* library will go into a base package (with a contains tag), and into a newly created package created solely to give a provides tag. Its product identifier will indicate that the package is for the explicit library indicated.

The package installer will need new rules: If a package requires a library, then it will ensure that the package which ‘contains’ it is available, and it will download a package which ‘provides’ it, but keeps that package disabled until the ‘contains’ package is disabled or upgraded.

If a package which ‘contains’ is disabled or upgraded, then the corresponding ‘provides’ package must be found for each package that ‘requires’ the libraries which it contained. If they cannot be found, then those packages will also be disabled and the user must be notified.

Similarly, when a ‘provides’ package is disabled or upgraded, any package which ‘requires’ its provided libraries must also be disabled.

QPM:RequiresLibrary: <library name> <multiple entries>

Indicates the libraries which are required for this package to work properly.

If no package on the local system has a contains for this library, and no local package has a provides for this library, then a search will commence, looking for any package which has the provides tag (only) because it will be a small package to download, and it will install alongside other (newer) versions.

QPM:ProvidesLibrary: <library name> <multiple entries>

Libraries which are provided in this package, for which the package is intended only.

QPM:Processor: <1-6 character identifier; no whitespace>

This is used to describe the architecture on which the binary content will execute.

QPM:TargetProcessor: <1-6 character identifier; no whitespace>

This is used to describe the architecture for which the binary content was built.

QPM:DisplayEnvironment: <enum: X11R6 | Photon | Console | None> <multiple entries>

Intended environment under which the package is to be used.

QPM:TargetAudience <enum: Developer | Administrator | User | Other> <multiple entries>

Intended audience for which this package was created.

QPM:TopicBox <yes>

<QPM:TopicBox>yes</QPM:TopicBox>

forces  a topic box to appear on the parent package.

QPM:TreeDisplayIndex <integer>

      Forces packages under the same topic to appear in the numerical position specified.

QPM:ReplacesProduct <1-13 character product identifier; no whitespace> <multiple entries>

Marks this package as being a new replacement to the specified product identifier. This package will satisfy any package which is dependent on such a product.

The vendor identifier must match between the old package and this package for the replacement to be valid, with the following exceptions:

You can add an attribute: vendor=”myco” so that this package looks as if it had a vendor identifier of “myco”.

If you put vendor=”any”, then the vendor identifier will always be considered a match.

QPM:LicenseUrl: <URL>

Specifies the URL of the license text to use for this package.

Commonly, this will point to:  rep://license.txt

QPM:Bundle <Stagnant>

Bundles are collections of related packages which do not necessarily have dependencies between them. By listing packages within a bundle, a number of packages can be added or removed at the same time.

This tag is stagnant, since the new method is to have a bundle which lists packages, instead of having packages reference a particular bundle.

QPM:BundleParent <parent identifier> <Stagnant>

Links backwards to the parent bundle.

QPM:QNXLicenseDescription

QNX has a licensing mechanism to build certificate information for secure installations. The following fields are used internally by QNX to assemble the information necessary to lookup a license key and track products you want to purchase.

QPM:QNXProductCode: <number>

This is a number used to track billing/cost of a particular product.

QPM:QNXLicenseClass: <word>

This is a short string to describe the product. This string paired with a version number is used to form a product id.

Warning: Adding this tag to your package without properly encrypting the package will make the package unusable.

QPM:ProductInstallationDependencies

The next block of information describes what is necessary to install this package.

HardwareRequirement

MinimumRAM: <memory>

A core package may specify a minimum memory requirement in megabytes (#.#Mb or #.#M) or kilobytes (####Kb or ####K). If a component defines a minimum memory requirement, this value is added to the core requirement.

RecommendedRAM: <memory>

The amount of ram this software would prefer to work optimally.

MinimumFreeStorage: <memory>

The amount of storage space this software may use up may be specified; this will help the user make sure they can use the package before downloading and installing it.

RecommendedFreeStorage: <memory>

The amount of storage space this software would prefer, to work optimally.

MinimumResolution: <resolution>

The minimum resolution assumed by this software. The default value is "800x600". A portrait display would have a reversed resolution of "600x800".

RecommendedColorDepth: <enum: 8-bit | 16-bit | 24-bit | 32-bit>

The recommended colour depth for the software, the default is 16-bit. There is no actual minimum colour depth; Photon will display the software the best it can with the given display.

AudioSupport: <enum: NotRequired | Required | Recommended>

The necessity of general audio support; this may be expanded to specific audio features.

PhotonDistribution: <distribution name>

In the event that third parties distribute software with a globally unique Photon distribution, a name may be specified and used as a filter for custom package managers.

QPM:Dependency <multiple entries>

A package may have a number of dependencies limiting its installation by enforcing the existence of another package or type of package. A component product is automatically assumed to have a product dependency of the parent product identifier (specified by the ComponentParent). All other dependencies (include which version of parent product) must be explicitly defined.

QPM:DependencyType: <enum: Install | Uninstall| RecommendInstall | RecommendUninstall  | Activate | Deactivate>

Install: This package may require that another product is completely installed before this package is installed. A complete install involves that the product's package has been added to the package repository manifest and has had the proper scripts called in response to the installation.

Uninstall: This package conflicts with another package and requires that it be uninstalled before continuing.

Recommend(Un)install: This package may have recommended compatibility issues with other packages. The auto-updater and package manager can use these dependency recommendations to ask the user if they would like to install/uninstall other packages.

QPM:Notes: <string>

For each dependency the package maintainer may describe why the dependency exists. For recommendations, state a brief reason why it is recommended. When creating dependencies on packages and libraries supply

QPM:Product: <1-13 character product identifier; no whitespace>

The product identifier on which this package depends.

QPM:Vendor: <1-13 character vendor identifier; no whitespace>

The vendor identifier of the package on which this package depends.

If this tag is not present, the vendor identifier of THIS package is used, and must match the QPM:Product package’s vendor identifier.

If this tag is entered as “any” (without the quotes), then the vendor identifier will be ignored in the dependency comparison (vendor will always match).

QPM:ProductHomeRepository: <URL>

A repository where this product might be found (possibly) if it is not already installed.

QPM:Filter  <multiple entries are AND filtered (all must be satisfied for the dependency to be satisfied) >

Each dependency may make further qualifications on the specified package. This lets the maintainer filter on versions, package content, distribution organization or any other package tag. Each filter is ANDed together to form compound queries. The filter patterns may contain ‘OR’ operations.

QPM:FilterType: <Numeric | StringExpression | Date >

tagname: <regular pattern>

Each filter is qualified with a filtering type. Numeric expressions use <, <=, =, , =, !=, |, &. String expression uses regular expressions to filter the string. Date uses the numeric expression operators but parses the tag's field value to make sure it's in the YYYYMMDD format.

<BuildNumber>!=4</BuildNumber>  checks that the QPM:BuildNumber is not equal to 4.

Note that there is no way to check the non-existence of a particular tag. String expressions with * will match as long as the tag exists, but there is no way to test the negative of this condition.

One tag in the filter block is checked against the given tag (without the QPM: portion) throughout the entire manifest. For example, <Processor>x86</Processor> will check for an x86 distribution, <ReleaseDate> "2001/04/20" </ReleaseDate> will require that any package which has the given release date.

QPM:IgnorePreVersion: <version>

This dependency should be ignored for any package installer which have a version number prior to the version specified. (ie: a value of 1.05 will cause this dependency to be ignored by package installer version 1.04 and earlier).

Note that this feature was added in version 1.04

QPM:IgnorePostVersion: <version>

This dependency should be ignored for any package installer which have a version number subsequent to the version specified. (ie: a value of 1.03 will cause this dependency to be ignored by package installer version 1.04 and later).

Note that this feature was added in version 1.04

QPM:ProductInstallationProcedure

The final block of information describes how this package is installed.

QPM:Script <Multiple entries>

A package may react to a series of installation events. These events may be the common situations brought on by a package manager or they may be events cause from an external call to the installation library. The most common events involve installation and uninstallation

Scripts are executed in the following order:

At installation

Pre-install

Pre-use

Post-use

Post-install

At deactivation

Pre-unuse

Post-unuse

At activation

Pre-use

Post-use

At uninstallation

Pre-uninstall

Pre-unuse

Post-unuse

Post-uninstall

QPM:ScriptName

The name of the script to execute.

QPM:ScriptType: <enum: Install | Uninstall | Use | Unuse | Refresh >

There are standard events throughout the lifecycle of a package.

QPM:ScriptTiming: <enum: Pre | Post>

Scripts may be executed in stages. All pre scripts are run before the event and the post event scripts are executed after the event.

QPM:ScriptBlocking: <enum: Yes | No>

Tells package installer to wait until script is complete before continuing.

QPM:ScriptResult: <enum: Ignore>

Flags the script so that the return value of the script should be ignored, and no error message shown in package installer.

QPM:ShortDescription: <string>

Textual description showing the purpose of this script.

QPM:UseBinaries: <enum: Yes | No >

Yes if the script uses processor-specific binaries.

QPM:Priority <enum: Optional | Recommended | Required >

Determines the importance of this script.

QPM:Filter

Each script may respond to other package's events. For example, the help viewer may want to index help files; it defines a script to be called upon the installation of a product with a content description containing "documentation". Multiple filters are legal, each filter is ANDed together to form compound queries. The filter patterns may contain 'OR’ operations. If no filter is specified, it is assumed that the script event refers to this package.

QPM:FilterType: <Numeric | StringExpression | Date >

Each filter is qualified with a filtering type. Numeric expressions use <, <=, =, , =, !=, |, &, and (). String expression uses regular expressions to filter the string. Date uses the numeric expression operators but parses the tag's field value to make sure it's in the YYYYMMDD format.

Note that there is no way to check the non-existence of a particular tag. String expressions with * will match as long as the tag exists, but there is no way to test the negative of this condition.

- property: <regular pattern>

Each tag in the filter block is checked (AND logic only) against the given tag (without the QPM: portion) throughout the entire manifest. For example, <CPU>x86</CPU> will check for an x86 distribution, <ReleaseDate> "2000/12/22" </ReleaseDate> followed by: <Libraries> libso.1.0.5 </Libraries> will require that a particular package has been installed

QPM:OrderDependency

The package file manager behaves like a union filesystem. It overlays one package file tree on top of another, replacing the oldest files. There may be as many order dependencies as the maintainer likes, but conflicting order requirements are handled arbitrarily by the package manager (more than likely the user is alerted and the installation is suspended.)

QPM:Order: <enum: InstallOver, InstallUnder>

A package may be installed over, replacing duplicates, or installed under, having its files replaced. The default is Install Over.

QPM:Product: <1-13 character product identifier; no whitespace>

The name of the product you want to install over. If a product is not supplied, the filters are run to find the packages this package should supersede.

QPM:Filter

The package this order is describing may be further qualified to support upgrading specific packages. Multiple filters are legal, each filter is ANDed together to form compound queries. The filter patterns may contain 'OR' operations. If no filter is specified, it is assumed that the script event refers to this package.

QPM:FilterType: <Numeric | StringExpression | Date >

Each filter is qualified with a filtering type. Numeric expressions use <, <=, =, , =, !=, |, &, and (). String expression uses regular expressions to filter the string. Date uses the numeric expression operators but parses the tag's field value to make sure it's in the YYYYMMDD format.

Note that there is no way to check the non-existence of a particular tag. String expressions with * will match as long as the tag exists, but there is no way to test the negative of this condition.

- property: <regular pattern>

Each tag in the filter block is checked (AND logic only) against the given tag (without the QPM: portion) throughout the entire manifest. For example, <CPU>x86</CPU> will check for an x86 distribution, <ReleaseDate> "2000/12/22" </ReleaseDate> followed by: <Libraries> libso.1.0.5 </Libraries> will require that a particular package has been installed

QPM:FileManifest

QPM:Listing

QPM:Dir

The base repository directory specification, where name=””. All install directories appear under this tag.

QPM:Dir: <Multiple entries>

Wherever sub-directories are used.

name=”directory name”

No text on these tags.

QPM:File: <Multiple entries>

Specifies a file to be overlaid into the package filesystem.

Text shows the file’s name.

QPM:Link: <Multiple entries>

Specifies a symbolic link.

link=”real/file/specification”

Text specifies the virtual file (link) to be created.

QPM:Union: <Multiple entries>

Specifies a directory union to be implemented. Often includes the $PROCESSOR directive to redirect processor-specific files into the correct locations.

link=”../$PROCESSOR/usr/bin”

Text shows the directory location where the specified link should appear.

Example: <QPM:Union link=”../$PROCESSOR/usr/bin”>usr/bin</QPM:Union>

QPM:PkgInclude

QPM:Item

Used in the core package to reference the processor-specific manifest.

Text is always $(PROCESSOR)/MANIFEST

QPM:Launch: <Multiple entries>

This block defines a single menu item that will appear on the Photon Launch menu, and the action to take when it is selected.

name=”launch item name”

QPM:String

The first QPM:String element defines the topic category under which this launch menu item will appear.

name=”Topic”

value=”Applications/Editors”

Can be Editors, Games, Internet, Utilities, Development, or Multimedia.

QPM:String

The second QPM:String element defines the command to execute when the menu item is selected.

name=”Command”

value=”/usr/bin/ped”

Fully-qualified command-line command to be executed when the menu item is selected