Release notes: Embedded Wizard 10.00

Version 10.00 contains the following changes and improvements:

New license management system

Originally Embedded Wizard Studio Pro edition was protected by USB security device, so-called dongle. With the new version 10.00 the dongle is over. From now, the use of a license is regulated by a license key and the license data that matches the key and that is stored on our license management servers. This enables us to react faster on user demands and e.g. unlock license features. On the other hand, the users are more flexible and can share the same license across locations. Please note, if you are using the Free edition, you don't need any license key.

When you buy a new or update an existing license to the version 10.00 Tara Systems GmbH or your distributor will provide you an adequate license key. You enter this key in the Activate License dialog as shown in the screenshot below:

Once the license key is known, Embedded Wizard repeatedly verifies the license at runtime. This ensures that floating licenses can be shared correctly. If the license can no longer be verified and the last license lease has expired, Embedded Wizard switches back to Free mode. It remains in this mode until the user has restarted the Embedded Wizard again. Project changes that have not been saved before can then be saved once again regardless of the project size.

Embedded Wizard 10.00 does not use the USB dongle device anymore and it does not support it. Also the restriction preventing the user from being able to use Embedded Wizard Studio via Windows RDS (Remote Desktop Services) has been removed. The restriction remains valid for the Node-Locked variant of the used license only. With Single-User Floating and Multi-User Floating no RDS restriction exists.

Improvements in Composer

Composer has been modified to not limit the displayed Canvas area to the value specified in the ScreenSize attribute. Even if the Profile is configured with small ScreenSize, the Canvas area can be bigger and all contents are shown. The limiting factor is the Graphics Engine with the max. width and height = 4096 pixel. The confusing behavior of the old version is eliminated.

The scrolling of Composer has been enhanced in the negative direction to -8192 pixel vertically and horizontally. Now, the user can now scroll the Composer in the opposite direction and arrange views, bricks etc. on the left and above the Canvas area.

The EXTRAS menu and the associated toolbar have been enhanced by the new item Scroll to origin. The shortcut is CtrlD. Using this command the user can instruct the Composer to scroll to the origin position 0,0.

The selection frame enclosing the actually selected member (or members) in Composer has been enhanced by additional edge grips. By clicking and dragging on the grips, the user can drag the corresponding edge. In case of quad views (e.g. Simple Touch Handler or Warp Image view), the affected edge is moved parallel. Also the old thin dotted line of the selection frame has been changed to be more thick. Following figure demonstrates the new selection frame:

In order to distinguish which views are actually selected, the affected view appears in Canvas area surrounded by an additional grey border. In the following screenshot there is an Image, Warp Image, Text and Line views selected:

Views lying partially or fully outside the Canvas area are visualized now. They appear as gray rectangles, quads or lines depending on the actual shape of the member. Thus the members can be selected, moved and resized similarly to how the members inside the Canvas area are edited. When selected, the members appear slightly blue tinted:

The stacking of annotations (e.g. Annotation legend has been modified. Originally annotations were displayed above Canvas area covering so all views behind them. Now, the borders of selected views are arranged above annotations to always make the actual selection visible.

The EXTRAS menu and the associated toolbar have been enhanced by the new item Outline view mode. The shortcut is CtrlE. Activating this command toggles the mode how views found within the Canvas area are displayed. If the mode is disabled (default setting), the views appear as they are: the Text view displays the text, the Image view displays the image, etc. If the mode is active, the outline of the views is displayed only, similarly to how the views outside the Canvas area are displayed. In this manner the user can better recognize the composition of the views. For example:

The above described Outline view mode can also be toggled by using the key E as long as the Composer is focused. This is even the case during an active interaction in the Composer. For example, while you move or resize a view you can press the key E to toggle the visibility of the views, which can be helpful during the composition.

Composer has been enhanced by a new selection popup menu. When the user clicks with the right mouse button within the Composer area while holding down the Shift key, a local menu is opened with all members found at the clicked position. The menu provides a quick overview of all members found at the position even if the members are arranged in background and not visible. The menu also reveals the actual selection status of all encountered views. By clicking on an item within the menu, the user can toggle its selection individually:

When resizing selected members or the Canvas area the user can press the key Ctrl. Doing this will cause the affected resize operation to be performed by retaining the ratio between the width and height of the affected area.

When resizing selected rectangular members the user can press the key Alt. Doing this will cause the affected resize operation to be performed relative to the center position of the affected area.

When dragging or resizing views in the Composer window, the views were originally aligned at fixed grid (e.g. 10 pixel). Now, the grid alignment does not apply to views anymore so that these can be arranged easily and pixel accurate. The grid alignment anyway exists and affects bricks and annotation members.

The possibility to configure the grid (the old Grid combobox) is not available anymore. The grid affecting the alignment of bricks and annotations is fixed set to 10 pixel. By pressing the key Shift while dragging bricks or annotations the grid alignment can be deactivated temporarily. Additionally, the grid function has been modified to take all edges of the affected bricks and annotations in account and not only their top-left corners.

As replacement for the old grid the Composer implements a function to automatically align views at edges and center positions of adjacent views existing in the GUI component as well as at the edges of the canvas area itself. Accordingly, when you drag a view, the view will snap automatically at potential reasonable positions. This magnetic alignment feature affects views only and has no effect on bricks nor annotation members. By pressing the key Shift while dragging views the magnetic snap can be deactivated temporarily. The potential snap positions and the involved views are highlighted and connected by guide lines as shown in the screenshot below:

The above explained automatic alignment feature applies also when resizing Canvas area. In this case the dragged Canvas edge can align at edges of contained views and other snap positions. These include also the screen size specified in the ScreenSize attribute. By pressing the key Shift while dragging the Canvas edge the magnetic snap can be deactivated temporarily.

The EXTRAS menu and the associated toolbar have been enhanced by the new item Magnetic snap mode. The shortcut is CtrlG. This item controls the above explained automatic alignment feature for views and Canvas. If desired, by using this item you can disable the magnetic snap mode permanently. If disabled, you can press the key Shift to enable it temporarily again. The Magnetic snap mode is stored in users preferences.

The ARRANGE menu and the corresponding toolbar have been enhanced by following 6 new items to explicitly align selected members at the edges or the center of the area surrounding them. This function is not limited to views. It can also be used to align bricks and annotations. If only one view is selected, the new functions arrange the view at the respective edge or the center of the Canvas area. Following is the enhanced menu:

The ARRANGE menu and the corresponding toolbar have been enhanced by following 4 new items to distribute selected members within the area surrounding them. The user has the possibility to distribute the members vertically or horizontally by taking in account equal distances between the member center positions or equal spaces between the members. The function is available if the user has selected at least three members and can be applied to views and/or bricks/annotations:

Interactions in Composer has been enhanced by following hot keys:

Home : scrolls the Composer to 0,0 position.

Page Down and Page Up : scrolls the Composer vertically half screen.

ShiftPage Down and ShiftPage Up : scrolls the Composer horizontally half screen.

Improvements in Code Editor

The Code Editor saves now its current state when switching between methods or inline code members. Specifically: when a method is closed, the caret position, selection and the undo/redo history are saved. When a method is opened again, the associated (if available) status is restored. Please note: if the Code Editor and Inspector are linked together, the status of the editor is not saved. In this case, the Inspector manages own undo/redo history of the edited attribute or property. The saved Code Editor status information is lost when the project is closed.

The in Code Editor per default enabled virtual space can be disabled now. For this purpose the menu EXTRAS and the corresponding toolbar have been enhanced by new item Enable virtual space. The corresponding setting is stored in users preferences (not project).

The setting Show whitespace signs is stored now locally in user preferences instead of in project files.

Improvements in Assistant Windows

The VariantCond assistant has been enhanced to provide the options $composer and $prototyper according to the available macros.

The Scope Assistants used within the Code Editor have been enhanced to also include the super( ... ) item if the actually edited method is derived from a base version. Also all parameters of the actual method are listed in the Assistant window now.

The Inspector Assistant as well as the Scope Assistants have been enhanced to also include all ^ reference data types. In the past it was not intuitive for the user to deduce that there are reference types available. Now, the reference types are listed at the end of the Assistant window after all regular types. In case of the Scope Assistant the reference types are listed after all regular types, and all other data members, methods, etc.

New Scope Assistants added to Code Editor. The Assistants react to keywords var, array and new displaying thereupon the list of possible data types and classes the user can select easily.

Improvements in Chora programming language

New Chora built-in functions added to obtain the corresponding float values for NAN (not a number), +INF (positive infinity) and -INF (negative infinity):

float_nan() --> Returns a float value representing NAN.

float_infp() --> Returns a float value representing +INF.

float_infn() --> Returns a float value representing -INF.

The Chora float datatype has been enhanced by following instant properties permitting the user to query whether the float operand is NAN (not a number), +INF (positive infinity) and -INF (negative infinity):

float.isnan --> Returns true if the operand is NAN.

float.isinfp --> Returns true if the operand is +INF.

float.isinfn --> Returns true if the operand is -INF.

float.isinf --> Returns true if the operand is +INF or -INF.

All Chora signed integer types as well as float, point and rect datatypes have been enhanced be the abs instant property permitting the user to query the absolute value of the operand. If used with point or rect operand, the absolute operation is applied for each component (e.g. x and y coordinates in case of point operand) individually.

All Chora signed integer types have been enhanced be the uabs instant property permitting the user to query the absolute value of the operand. Unlike the above described abs instant property, uabs returns the unsigned version of the original data type. For example, if used in context of an int8 operand, the property uabs returns an uint8 value.

The abs instant property returns the same data type of the operand e.g int8. As such this property is ideal to calculate with the absolute value without needing to type cast the result back to e.g. int8. This, however, may lead to a problem: if the operand has its max. negative value (e.g. -128 in case of int8), there is no corresponding positive value in the same data type (e.g. in int8 the max. positive value is 127). The abs instant property returns in such case the -128 value. This corresponds to the behavior of the abs() function available in C.

To allow the user to handle this conversion, uabs instant property is available. It returns the unsigned version of the original data type, e.g. uint8 in case of int8 operand. When using this property no data is lost. The result, however, may expect an explicit type case depending on the expression it is involved in.

Chora has been enhanced by following new built-in math functions. These functions correspond to the found in STDLIB C or other languages:

math_tan( float aAngle ) --> Calculates the tangent value of the given angle

math_atan( float aValue ) --> Complementary function of math_tan()

math_atan2( float aY, float aX ) --> Complementary function of math_tan()

math_exp( float aValue ) --> Calculates an exponential expression with Euler's number

math_log( float aValue ) --> Calculates natural logarithm

math_log10( float aValue ) --> Calculates base 10 logarithm

math_length( float aX, float aY ) --> calculates the length of the specified vector

math_length( point aPoint ) --> calculates the length of the specified vector

math_trunc( float aValue ) --> calculates the integer part of aValue regardless of its sign

math_fract( float aValue ) --> calculates the fractional part of aValue regardless of its sign

The float data type has been enhanced by the instant properties floor, ceil, round, trunc and fract. These read-only properties return the respective value (floor, ceil, round, trunc and fract) of the original operand. The instant properties work similarly to the existing math functions math_floor(), math_ceil(), math_round(), math_trunc() and math_fract():

float.floor --> Returns the floor value

float.ceil --> Returns the ceil value

float.round --> Returns the round value

float.trunc --> Returns the integer part

float.fract --> Returns the fractional part

Chora rect datatype has been enhanced by new instant properties x and y. These allow the user to evaluate and change the origin of the rectangle. It is a more efficient alias for origin.x and origin.y expressions (see instant property origin). This makes also the rect operands to be more conform to the values shown in Inspector window when rect value are edited:

rect.x --> Corresponds to the x coordinate of the rect

rect.y --> Corresponds to the y coordinate of the rect

The point data type has been enhanced by the instant properties length and area. These are convenience properties and correspond to the built-in function math_length() and the rect.area instant property.

New math_min() built-in function added. The function can be invoked with any number (at least two) of operands and returns the lowest of the given values. The function can be used with signed, unsigned integer (e.g. int32, uint64, etc.), float, char, point, rect or color operands. In such case the datatype of the first operand determines the version of the function. All further operands has to be compatible to the type of the first operand. If used with point, rect or color operands, the function estimates the minimum value for each component (e.g. x and y coordinates in case of point operand) individually.

New math_max() built-in function added. The function can be invoked with any number (at least two) of operands and returns the largest of the given values. The function can be used with signed, unsigned integer (e.g. int32, uint64, etc.), float, char, point, rect or color operands. In such case the datatype of the first operand determines the version of the function. All further operands has to be compatible to the type of the first operand. If used with point, rect or color operands, the function estimates the maximum value for each component (e.g. x and y coordinates in case of point operand) individually.

New versions of the + and - operator added to support the combination of char and signed or unsigned integer (e.g. int32 or uint32) operands. Using this operator returns the char value with the added/subtracted integer value.

The arithmetic operators +, -, * and / have been enhanced to allow direct combination of signed or unsigned integer (e.g. int32 or uint16) with float operands. The result is float in this case. It is not necessary anymore to explicitly cast the operands.

Support for ++ and -- pre/post increment/decrement operators added. The operators can be used with operands of signed or unsigned integer (e.g. int32, uint16, etc.), float and char datatypes. To increment a counter variable you implement following expression: counter++.

Chora has been enhanced to allow multiple expressions in the for loop statement. For this purpose the expressions can be separated by , (comma) sign similarly to how multiple expressions in ANSI C are specified. Unlike ANSI C, however, multiple expressions are allowed in the for statement only. For example:

for ( a = 0, b = 0, c = 0; a < 10; c = b, b = a, a++ )

Support for Compound Assignment operators (e.g. A += B) added. Following operators are available:

A += B --> corresponds to A = A + B

A -= B --> corresponds to A = A - B

A *= B --> corresponds to A = A * B

A /= B --> corresponds to A = A / B

A %= B --> corresponds to A = A % B

A &= B --> corresponds to A = A & B

A |= B --> corresponds to A = A | B

A ^= B --> corresponds to A = A ^ B

A >>= B --> corresponds to A = A >> B

A <<= B --> corresponds to A = A << B

Support for Chained Assignment operators (e.g. A = B = C = D) added. In this operation, the value resulting from the right assignment is used in the left assignment. With this enhancement it is allowed to assign a value within any regular expression. Exception: initialization expressions specified in Inspector window are not allowed to perform nested assignments in order to avoid unexpected side effects. Trying to do this will report a Chora compiler error.

Support for ?: ternary conditional operator. Similarly to its ANSI C and JavaScript pendant, the operator evaluates the boolean expression on the left of the ? sign and depending on whether this expression results in true or false, returns the operand on the left or on the right of the : sign. For example:

View.String = ( temperature > 37.0 )? "FEVER" : "NORMAL";

for loop statement has been adapted to be more similar to ANSI C. This means, that the condition and increment expressions are optional now. The statement for(;;) ... is thus legal and results in an endless loop. To break the loop you have to use e.g. the break statement.

New flow-control statements break and continue added to for, while and do-while loops. The statements allow to break or continue the loop similarly to how ANSI C or JavaScript do. For example, it allows to exit an endless loop:

var int32 counter = 0;

for (;;)
  if ( ++counter > 100 )

Detection of endless (for, while and do-while) loops added. A loop is considered as endless if there is no way to leave the loop or break it. Endless loops are reported as error now. In turn, when the loop code is eliminated additional warnings are reported.

New flow-control statement fallthrough added to switch-case-default statement. fallthrough allows to skip within a switch-case statement from the current case to the next following one (to fall through effectively). The function is similar to other languages like Apple Swift. For example, the following code would output "value 3" and "value 4" if expr == 3:

var int32 expr = 3;

switch ( expr )
  case 1 : trace "value 1";
  case 2 : trace "value 2";
  case 3 : 
    trace "value 3";
  case 4 : trace "value 4";

  default : trace "default";

Local variables and local arrays are now automatically preinitialized with zero-values. The user does not need to initialize the variables explicitly. The warning because of trying to use a non initialized variable is removed. To track the usage/initialization of local variables/arrays, the Chora compiler evaluates recursively all execution paths. Local variables are preinitialized with zero only when there is the possibility to use the variable without a preceding initialization. Following code is thus valid and will not provoke any errors:

var   int32  x;
var   string str;
array object objs[4];

trace x;       // Will output 0
trace str;     // Will output ""
trace objs[0]; // Will output null

Automatic type conversion enhanced to allow more operands to be converted implicitly to the datatype expected in the expression. In such case the explicit typecasts for affected operands can be avoided. Concrete following conversions are automatic now:

Equality operators == and != have been improved to accept operand combination of enum or set and signed or unsigned integer types without explicit type casts applied on one of the operands.

Type conversion between any Chora datatype an bool has been added. The conversion results in true if the operand is not zero otherwise the conversion results in false. To explicitly perform the conversion use the typecast operator, e.g. (bool)SomeNumber. The type conversion to bool is also performed automatically (implicitly). For example, in order to test whether a number is not 0, a variable does refer to an object or a string is not empty, it is not necessary anymore to apply the equality operators:

// Old code:
if (( number != 0 ) && ( object_var != null ) && ( string_var != "" ))

// New code:
if ( number && object_var && string_var )

Chora compiler adapted to detect and report operands with side effects. An operand with side effects is an operand evaluated and modified within the same expression. The result of this operation is not predictable and can depend on the used target system. For example, the operation A = A++ * A will report a warning.

Support for 64-Bit integer

Chora has been adapted to support the new int64 and uint64 data types and all associated arithmetic and bit operations. Prototyping Environment, Runtime Environments and Code Generators enhanced by new functions needed by the 64-bit data operands.

In case of WebGL as target, the Chora compiler will report dedicated warnings if operands exceed the supported integer precision of 53-bit or bitwise operations are used with int64/uint64 operands. JavaScript interpreter limits all bitwise operations to 32-bit. Arithmetic operations with integer precision are limited to 53-bit by JavaScript interpreter. Also when generating code or Prototyping for WebGL all constant numbers larger than 53-bit are reported as warning. Usage of ++ or -- (increment/decrement) operators with 64-bit operand on WebGL is reported as warning.

The declaration of the RTE function EwGetTime() has been changed to return int64 instead of uint32. All target specific ewextrte.c modules containing the implementation of this function have been adapted.

Improvements in Mosaic

Core::Time and Core::TimeSpan classes have been redesigned to use int64 instead of int32 or uint32 values.

In the class Core::Time the algorithm to convert between seconds since 1.1.1970 and the given time has been redesigned based on example found at Now the Time class is more flexible and can handle also with time before 1970. the oldest possible date is 01 March 0000. Older dates are not possible due to algorithm limitations.

The Rotate Touch Handler has been enhanced by new property CenterOffset. This allows the user to specify a displacement for the position around it the rotation gesture is performed. The handler displays the center position as a cross if used in Composer.

The Rotary Knob widget has been corrected to relay the CenterOffset configuration parameter to the Rotate Touch Handler used inside it.

Mosaic class Core::Group (the base class for all GUI components) has been enhanced by new method RemoveAll() permitting the removal of all views existing within a group at once.

Mosaic class Graphics::Canvas has been reworked to be usable as drawing destination in user's own GUI application. New methods BeginDrawing() and EndDrawing() added to signal the beginning and the end of the drawing. To display the contents rendered in a Canvas object, the object can be connected to regular Image views similarly to how Bitmap resources are connected. See also: Canvas object.

Handling with Init, Done, ReInit methods

The methods Init, Done and ReInit are now treated as being inherited from an internal, common base class. Accordingly, all Chora classes do have these 3 members per default. For example, a new added empty class has always the following members:

The consequences:

It is not necessary anymore or even not possible to add new method and rename it to e.g. Init. Instead the user has always to override the existing inherited Init method.

The members Init, Done and ReInit can't be renamed anymore.

No other class members can't be renamed to Init, Done and ReInit.

All Init methods have the argument handle aArg. Originally it was handled inconsequently. Core::Resource had the argument, all other classes not. The argument has to be ignored.

Projects stored with 10.00 are not compatible to older versions. An adaptation is required if you want the project stored with 10.00 version to be used in e.g. version 9.30. Concrete the now inherited methods have to be made non-inherited manually in an external text editor.

Hiding internal Mosaic members

To be less confusing to the user, internal members belonging to the Mosaic framework are better hidden. In the past user tried to use the internal members in own projects. Anyway, the usage of the internal members is still possible. They are simply better hidden. This adaptation means concrete:

A Mosaic member is considered as internal if its Description attribute is empty. This is similar to the approach how members are excluded from the generated HTML documentation.

The Inspector Assistant as well as the Scope Assistants windows have been reworked to not list internal Mosaic members. The lists are shorter now. The user can focus better on the members relevant for his/her project.

The members area of the Inspector has been enhanced to display internal Mosaic members with cursive font and gray color. Additional hint INTERNAL MEMBER is shown in the short info area when the user selects such internal member:

The Browser window has been enhanced to display internal Mosaic members with cursive font and gray color. Please note: gray color is used in Browser also to mark members which do no match the actually specified filter pattern. Therefore, if the user has entered some pattern in the Search ... edit field, the original color scheme is used again.


New Canvas template added to the Gallery folder Resources. This template is intended to create instances of the Graphics::Canvas class which thereupon can be used as drawing destination. For more details see Canvas object.

Enhancement of Font Resources

New attribute Kerning added to font resources. Per default the attribute is true indicating that kerning data (if available) should be taken in account. Setting this attribute to false suppresses the generation of kerning data.

Font resource has been enhanced by new attribute RowDistance. This allows the user to specify another row distances directly at the font resource level. If the value is not specified the distance resulting from the font metrics is used automatically. Also note the Text view property RowDistance.

Font resource has been enhanced by new attribute HeightMode. This allows the user to select the mode how font size should be calculated. Possible options are Compatible (to all preceding Embedded Wizard versions) and Popular as all other popular tools (e.g. Adobe Photoshop) calculate the font size. For all new added font resources, the mode Popular is used per default. This permits the user to enter the same font size (in pixel) as found in e.g. Adobe Photoshop. Please note, with the mode Popular, the specified font Height value does not correspond anymore to the distance between to consecutive text rows. In such case use the attribute RowDistance to specify it.

The storage of Font resources in the target system has been enhanced to contain the original font resource name. This is useful when at the runtime an error message is displayed to make it more clear to the user. Instead of displaying font 0x12345678 can't find glyph 0x1234 the message reports the name of the font resource now.

Font converters have been reworked to be more clear with error messages affecting the Ranges attribute. From technical point of view, in a multi-variant font resource (virtual font) it is always necessary to specify for each language variant the corresponding codes in the Ranges attribute. Therefore, if there is no initialization in Ranges attribute for one of the used languages, a respective error message is reported. This is more intuitive to understand.

External TrueType Font Converter and Loader have been adapted to also take care of alternative, localized font names. The previous version caused the issue of not found fonts if the user has specified the font name in the localized version. Now, if a TTF font file stores multiple font names, all these names are taken in account when searching for a font.

The integration with external TrueType font engine has been reworked to work with the actual version 2.10.4 of FreeType engine.

Modification in font conversion to explicitly address the .notdef glyph by its index 0 instead of the not reliable font metric information provided by Win32 API. The resulting .notdef glyph is stored at Unicode position 0x0001.

Diverse improvements and optimization

The Composer and the Prototyper window have been adapted to appear correctly scaled on HiDPI development PCs. The contents don't appear so tiny anymore. Anyway, the user can control this function by toggling the new menu item Pixel accurate mode in the EXTRAS menu. If the mode is active, the outputs are pixel accurate by ignoring the HiDPI scaling parameters specified in Windows settings. Unlike other configurations, the Pixel accurate mode affects all Composers and Prototyper within the project. The Pixel Accurate Mode setting is stored in users preferences.

The TV key codes tooltip window has been removed. The window appeared when the user pressed the Ctrl key for longer time while working in Prototyper window.

The Prototyper window has been changed to be top-most always. Now, the user can work with Embedded Wizard while the Prototyper window is floating above the IDE.

The Composer is automatically focused after opening a project.

Toolbars have been completed to contain buttons for all relevant commands.

The Log window has been reworked slightly. The tabs at the bottom edge of the Log Window are now colorized according to the kind of collected message. For example, if there is an error message collected, the tab is red. The messages of the category Information do not blink anymore. The Project Complexity messages (if any) are displayed as warnings if the complexity has reached 80 %. The Log window switches to the affected list only when the user starts the code generation or Project Search operation. This should avoid that user's workflow is disrupted by incoming messages.

The Prototyping Environment has been enhanced to detect and report runtime warnings caused by nested Core::Root objects or instances of the derived class created with the new operator. In the past, few customers mixed up the templates for creating an ordinary Component with the for an Application component. This results in strange behavior with dialogs, touch events, modal components, etc. Now warning is reported if such case is detected.

Warning notifying the user about too long font name has been removed. It confused the user. Background: Windows limits font names to 31 characters when selecting the font via Win32 API.

The OpenGL ES 2.0 driver has been enhanced by the TileDriver function. This optimizes the tile operation reducing the number of OpenGL invocations to 1. The operation is used for example by the Wallpaper view.

Assignment operations to instant properties (e.g. GetSomeView().Bounds.size.x = 10) have been optimized to ensure that the expression in scope of which the instant property is applied is evaluated only once. Previously the expression was evaluated multiple times, e.g. the method GetSomeView() from the above example was invoked twice or even 3 times depending on the involved instant properties.

Optimization if sequences of instant properties can be merged together to simplify the resulting code. For example, rect.size.x can be merged together to rect.w. This generates less code.

The storage of project files have been changed from the proprietary ASCII format to UTF-8. Embedded Wizard 9.30 was already able to read UTF-8 files. Now we also store the files in UTF-8. This completes the transition to UTF-8. If you edit or create the project files by using another tools, please ensure that the file starts with correct BOM (Byte Order Mark) 0xEF 0xBB 0xBF to indicate the UTF-8 content. Otherwise Embedded Wizard will fall back in compatibility mode interpreting the file as containing ASCII characters only.

Status Bar has been adapted to provide more details according to the actual operation. For example, when the user drags members in Composer, the Status Bar displays To suppress the magnetic snapping press the key SHIFT, etc..

New function EwRegisterFlashAreaReader() added to RTE. With this function the user can register a callback to be used when decompressing bitmap/font pixel data from not directly accessible Flash memory. The user implemented callback function has to load the Flash memory in blocks/pages into an internal buffer and return a pointer to the loaded memory address.

User own developed Intrinsics Modules are not loaded automatically anymore unless the user confirms this explicitly. When during the Prototyping an Intrinsics Module is found, Embedded Wizard presents a message box asking the user whether to load or not the module. The user can select between Load only once, Load always or Don't load now. This modification should prevent Embedded Wizard from loading and executing foreign code modules and is as such a security aspect. Following is a screenshot demonstrating the box:

When resizing the Canvas area, the area is limited to be at least 1 pixel width/height.

Modification of the vector graphic raster functions (used in Fill Path and Stroke Path) for the fill mode NonZeroWinding to allow more than 127 (or 31 in case of an active anti-aliased mode) edges winding in the same direction and intersecting one and the same sub-pixel within a row. Now the limitation is 32767 edges if anti-aliasing is off and 8191 edges if anti-aliasing is on.


Bug-fix in OpenGL ES 2.0 driver if the frame buffer is scaled/stretched. In this case the Wallpaper view displayed black grid and the Path Views displayed thin lines at the edges of the views.

The additional EW_FONT_PIXEL_PRAGMA definition has been removed from the section containing Kerning-Data in Font Resources. Only pixel data intended to be decompressed can be relocated by using the pragma definition. Other data has to remain accessible by the CPU.

External Font Converter has been adapted to also search for the *.TTF files in the user's AppData/Local/Microsoft/Windows/Fonts folder as this is the new standard location for Windows 10.

Automatic refactoring of the project after the Move between Units operation has not always marked the affected units as modified. The modification was therefore not stored resulting in an incomplete project.

Bug-fix in JavaScript version of the Core::Time class. Originally the class did not take in account the timezone offset. Now it calculates properly.

Bug-fix in Core::TimeSpan with incorrectly formatted string when the property String was evaluated.

Bug-fix in trace statement. trace displayed float values incorrectly on C target if the value was very small. It reduced the value to 0.0. Now the value is displayed in the exponent notation e^n ensuring so that the most significant digits are always visible.

Bug-fix in the trace statement on ANSI C target. char operands were not displayed as char literal (enclosed between a pair of single quote signs '...') if the character was not an ASCII sign 0x20..0x7F).

Endless while ( true ) ... and do .. while ( true ) statements are now generated as for(;;) ... statement to avoid C compiler warnings.

Statements do .. while ( false ) are now generated as for(;;) ... statement to avoid C compiler warnings. Additional break is appended to the code in order to exit the loop.

Bug-fix in vector graphic raster functions if anti-aliased mode is used. This caused the pixel-row rasterization to be shifted by 0.25 pixel vertically. The pixel rows could thereupon appear slightly blur.

Bug-fix to handle the special case of max. neg. signed integer number -2147483648. The C compiler seems to not accept such numbers. The compiler expects an explicit typecast -(int)2147483648.

The Scope Assistants in the Code Editor didn't worked if the expression left to the period sign . was enclosed between a pair of parenthesis and prefixed by a statement (e.g. trace or signal). In such case the statement together with the parenthesis ( was interpreted as method invocation (e.g. trace(...)).

Bug-fix in Log Window. The command to toggle the status of a message was sometimes not available.

Diverse bug-fixes to correct the appearance of Embedded Wizard IDE on Windows 8 and 10.

Bug-fix for incorrectly converted strings in float numbers if the portion after the period sign was longer than 9 digits. This caused an overflow in the calculation. The issue affected the Prototyping environment only.

Bug-fix for missing idlesignal just after starting a Prototyper.

Bug-fix for incorrect naming OnGet and OnSet methods when the respective property is renamed or new property is added.

Bug-fix in Graphics Engine. The EwDrawLine() operation was logged regardless of whether the logging was on or off.

The implementation of Core::Time has been reworked to correct the calculation of 'Day of the Year', 'Day of the Week' and 'Week of the Year'.

Bug-fix in Embedded Wizard Studio for a crash caused by project or image files having invalid MTIME (e.g. year 4500). Now if invalid MTIME is found the respective function falls back and uses CTIME instead.

Wrong PRAGMA in generated code for bitmap resources removed.

Bug-fix in Memory (RAM) usage window. The bar chart was displayed incorrectly if the memory usage was very large (> ~20 MB). The Tool-Tips sensitivity in the Bar Chart has been improved. Even if the bar is very small and the user rests the mouse pointer above the bar, the Tool Tip appears correctly.

Bug-fix in Mosaic: the Retarget operation ignored the actually active modal group. In this way the touch events could reach a handler lying behind the modal group as if there were no modal state.

Workaround added to suppress kerning for characters being mapped to other codes (resulting from a particularly configured Ranges attribute). The resulting codes are not the kerning codes. Kerning may not be applied in this case.

Bug-fix in WebGL font converter. During Prototyping the font name were not initialized correctly causing an access violation if Graphics Engine tried to use the font name in an error message (e.g. 'Glyph X in font ABC not found', etc.).

Bug-fix for a problem in Composer with Canvas area and Annotations being not shown correctly if particular Zoom factors were used. Consequently in some cases the contents appeared clipped or black pixel lines surrounding the annotations were seen.

Disabling a C compiler warning because of non initialized Reserved[] member in the XFntRes data structure.

Drag&Drop operation applied on a member while pressing the Alt key caused the complete member to be copied in the clipboard. Consequently the user was able to create a copy of the member by accident. Now the operation limits to copy the members name as it is documented.

Bug-fix in the Show Whitespace Signs function. When switching the Code Editor between methods etc. the activation for the whitespace mode was lost.

Bug-fix for special case of non-convex polygon. Having two corners in a Warp Image view being equal causes the corresponding W parameters to be 0 (zero). This leads to infinitive numbers and finally to overflows when mapping the images on the screen.

Bug-fix for a crash if during Prototyping the initialization of an autoobject is aborted due to other nested objects not being initialized correctly. This left the original autoobject in an invalid, not correctly initialized state. Anyway the original object was already recorded in the list of all existing objects. When the Prototyper window was closed again the following garbage collection tried to reclaim the incorrectly initialized autoobject. This crashed the Prototyper and consequently Embedded Wizard Studio IDE.

Bug-fix in WebGL JavaScript Code Generator. In case of long text rows ending with the return XYZ statement the expression XYZ was moved to next text row leaving return alone. JavaScript interprets in this case return and XYZ as not belonging together and reports errors.

Bug-fix in code generation report. Files flushed preliminary has been reported with size 0 bytes if the file did not exist in the destination directory before the generation begun.

Bug-fix for Project Search operation to not display the small square signs in front of code lines containing breakpoints.

Bug-fix for bitwise not operator ~ used with int8 int16 or uint8 uint16 operand. In this case the Chora compiler reported an error.

Bug fix in Menu component template. The automatically calculated position for the menu was wrong if the Owner component was not arranged at the 0,0 position.

Warning because of not matching font name has been modified to compare the first 31 characters only as resulting from Windows restrictions.

The limitation to 3-digits in the gutter area of the Code Editor window has been changed to 4-digits. This means the editor shows up to 9999 lines correctly.

The method CreatePathFromSVGString() has been improved to use addition edges when the arc or the Beziér curve are small. This results in small shapes being shown smooth and not sharp.

The method CreatePathFromSVGString() has been enhanced to also support the scientific number notation with exponent (e.g. 123.45e-7) according to the actual SVG specification.

Minor fix to avoid that Composer scrolls quickly just in the moment when the user drags the mouse slightly beyond the borders of the Composer.

The Chora Variables window has been corrected to also display the values of the global variables language and styles if these are used in the actually debugged expression.

Templates for Device Property and Device Interface adapted to not have any default values for the properties similarly to how all other templates for data members are prepared. This modification avoids confusing errors when the user modifies the data type of a property without adapting its initialization value. If not explicitly initialized, the properties contain a zero value.

Disabling diverse C warnings found in ANSI C RTE/GFX and in the code generated from Mosaic when the max. warning level is set in C Compiler.

Bug-fix for incorrectly working multi-frame bitmaps if these are stored in DirectAccess mode and ScreenOrientation is not Normal. This caused the error codes 318, 321 being reported and wrong bitmap frames were displayed.

During prototyping the built-in functions math_rand() returned always the same sequence of numbers.

Bug-fix for a crash in Embedded Wizard Studio when opening the local menu (right mouse button click) in Browser or in the Callstack window and the window was arranged on a monitor with negative virtual screen coordinates. As such the error could arise with PC configurations using more than one monitor.

Minor modifications in the Graphics Engine and Runtime Environment to satisfy the Apple Xcode static analyzer.

Bug-fix for incorrect code location displayed in Chora error or warning messages if the affected expression contained an enumeration or set operand being type-casted explicitly to an integer type.

Bug-fix in function EwStringToUtf8(). Character codes greater that 0x07FF were encoded incorrectly in UTF-8.

Correcting the type declaration for XBool used when implementing intrinsic modules to correspond to the definition found in the code running in the target system.

Bug-fix for unexpectedly eliminated glyphs with fonts configured in Quality values Low or Medium.

Bug-fix for touch events generated twice on Windows PCs controlled via touch screen. The error could occur during Prototyping or in applications generated for Win32 target system.

Known issues

During code generation the names for created files (e.g. *.h and *.c) are derived from the original names of the corresponding project members. While Embedded Wizard is case sensitive, the MS-Windows file systems are not. This may lead to the problem of two different project members being mapped to one and the same file. The resulting code is incomplete. For example, let's assume you have a unit containing two Bitmap resources named Logo and logo. Since Embedded Wizard is case sensitive, it will distinguish the both resources. During code generation, however, both resources are mapped to one and the same file logo.h.

During code generation the names for created files (e.g. *.h and *.c) are derived from the original names of the corresponding project members and the superior unit member. Depending on your project contents, two different unit + project-member combinations can produce one and the same file name. The resulting code is incomplete. For example, the member DeviceClass within the unit Test and the member Class within the unit TestDevice will be mapped to one and the same file name _TestDeviceClass.h.

During code generation the names for created files (e.g. *.h and *.c) are derived from the original names of the corresponding unit members. MS-Windows system, however, has few file names reserved for special system devices. Accordingly, if your project contains a unit with name corresponding to the reserved by MS-Windows, the code generation will fail. Following names should be avoided when naming project members CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, COM0, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, LPT9, LPT0.

Chora preprocessor directives e.g. $if have an effect even if they are commented out. The cause: originally Chora comments were valid syntactical elements. They were evaluated by the Chora compiler in the stage following the preprocessor phase. As such the preprocessor could not remove any comments. If the comment contained a preprocessor directive, the directives were (and actually they are) interpreted. Please avoid the combination of comments with nested preprocessor directives.