With a constant variant member you can override another constant member existing in your project. Once overridden, the variant member can retrospectively modify the initialization expressions of the original constant member. Constant variant members are represented in Composer by following bricks. Please note the additional small overlay in the icon of the brick:

The derivation of variants provides the fundamental technique to manage several product and design versions within one and the same GUI application. The selection of the appropriate variant occurs automatically depending on the condition specified in the VariantCond attribute of the variant member. Depending on this condition, Embedded Wizard distinguishes between following two types of a variant:

Type	Short description
Static	The condition for the selection of the respective variant results in a value well known at the code compilation time and immutable at the runtime. If this condition is true, the affected variant overrides the original constant member permanently. If the condition is false, the variant has no effect.
Dynamic	The condition for the variant selection depends on styles. Since styles can be activated and deactivated individually at the runtime, the overriding changes dynamically.

A constant member, which has been overridden by a variant member is considered as being multi-variant. You can derive as many variants of an original member as you want. Moreover, one constant variant can override another constant variant resulting in a hierarchy of variants. With the Browser window you can inspect this hierarchy. Please note, a member overridden by a variant is signed in the Browser with an additional small icon. You can thus recognize multi-variant members easily. Additionally, the corresponding variant condition is shown between a pair of [...] (squared brackets):

The original constant member is overridden by a variant, which, in turn, is overridden by another variant. Both variants specify as condition true and are thus static.

You create a new constant variant by simply deriving it from an existing constant or another constant variant. In the simplest case, if both, the original member and the variant are defined within the same unit, do following:

Deriving a new variant from a constant member existing within the same unit.

If the original member is not defined within the same unit, you can use the Browser window:

Deriving a new variant by using the Browser window.

Alternatively, you can derive a new variant by using the clipboard functions Copy & Paste:

Variant members have a global character - they can be accessed from everywhere within your project. To address a variant member, you must always use its full name, which is composed of the unit name, the member is defined inside, and the name of the member itself, both separated by :: (double colon) signs. For example Examples::LabelColorDarkVariant.

The effect of an overriding depends on the condition you specify in the attribute VariantCond of the respective variant member. Per default newly derived variants are configured with the condition true. They overrides thus statically and permanently the original member. You should therefore always review this attribute after deriving a new variant.

Please note, if two variants override the same original member and both variants are configured with the same condition, Embedded Wizard will report a compilation error because of the ambiguity.

The value of a constant variant is determined by the initialization expression specified in its attribute Values. As long as not modified, the attribute shows the expression inherited from the overridden member. When you modify this attribute, the original value is overridden. Please note, the resulting data type of the expression must match the type declaration of the original constant.

If your project is localized for several languages, you can override the expressions for every language individually. If neither the variant nor the original constant specify a particular language specific value, the value from the fallback language Default is used automatically.

Once overridden values can be removed easily by pressing the keys CtrlR when the affected value is selected in Inspector. Thereupon, the value inherited from the original member is restored again.

You can create any number of copies of an already existing constant variant member.

You can also Drag & Drop a constant variant member from the Browser into the Composer window and create so a duplicate of the affected member:

Duplicating a constant variant by simply Drag & Drop it between the Browser and Composer windows

Embedded Wizard selects the appropriate variant automatically either at the code generation time or just at the moment when the corresponding original constant is evaluated within an expression. Accessing the constant variants individually is not possible. The selection is controlled by the attribute VariantCond.

With the attribute Storage you can selectively specify the location where data belonging to the constant should be stored. The data can be stored directly in the generated code or in a separate so-called Blob file. Unlike the first option, the Blob file can be replaced and so the contents of the constant can be exchanged retrospectively without needing to rebuild the binary.

The following table shows the complete list of attributes provided by the constant variant member:

Attribute name	Short description
Brick	Determines the position and the size of a variant member brick within the Composer window.
ConstantType	Determines the data type of a constant member. Please note, this attribute can't be modified in derived variants.
Description	Contains the description for the variant member.
Storage	Controls the storage location for data belonging to the constant when generating code.
Values	Determines the values for a constant variant member. If not modified, contains the value inherited from the original member.
VariantCond	Determines the condition to activate a particular variant member.
VariantOf	Determines the original constant member to override by the variant member.

This section describes the Chora syntax of how constant variants are stored inside Embedded Wizard project files. The knowledge about the syntax can be helpful when you plan to process the project contents by third party tools. In particular, the general purpose Export and Import functionality introduced in version 14 requires a good understanding of how project members are represented in Chora syntax to correctly interpret the exported members and synthesize the Chora code for members to import. Please note, Embedded Wizard project files (and thus Chora code) are encoded as text in UTF-8 format.

In Chora syntax, constant variant definition is always introduced with the keyword vconst, followed by the name of the variant, the fully qualified name of the original constant member to override by the variant and the value associated to the constant variant. The variant name, the name of the original constant and the value are separated by : colon sign and by an assignment operator =. The complete constant variant definition terminates with ; semicolon sign. Wherever necessary, the tokens are separated by whitespace signs. Being a constant, the specified value has to be immutable and it has to match the data type specified in the original, overridden constant. The name of the original constant member corresponds to the content of the attribute VariantOf. The value corresponds to the content of the attribute Values.

A constant (and thus a constat variant) may be localized for multiple languages. It this case the constant variant contains multiple values, each composed of a language name and the corresponding value. Each language name and the corresponding value are separated by an assignment operator = and terminated with ; semicolon sign. All language specific values are enclosed between a pair or parenthesis (..).

The definition of a constant variant can be initiated by a comment block providing optional description for the variant. The content of this comment corresponds to the value of the variant's attribute Description. Furthermore the directives $rect, $variant and $storage can be specified providing values for the corresponding attributes Brick, VariantCond and Storage. The following examples demonstrate the described syntax:

Each Chora file (or text exchanged with an external Export and/or Import tool) can be (or even should be) prefixed with $version directive. This directive determines the version number of the included Chora code. For details concerning the syntax of the version please see the chapter $version macro. Furthermore, the code can include a $scope directive followed by a path to a project member acting as the original owner of the corresponding code. That means the members described by the Chora code existed inside the member specified in $scope. In case of a constant variant, $scope would specify the name of the unit the variant belongs to.