Writing to a graphic display from an external application

Often a user wants to integrate input from an external application into the graphic display. For example, showing a camera preview or running a Java applet as part of the RapidPLUS application. This feature solves the problem of integrating an external application’s image into the simulation (Prototyper).

This functionality is achieved by implementing a set of API functions in the external DLL that is connected to the graphic display. For details about the new functions, see the User Manual Supplement, Chapter 12: “Graphic Displays” or the Help topic “Connect to an external DLL.”

Code generation

Enhancements to code generation include the following features:

·         In previous RapidPLUS versions, if the Code Generator encountered problems when writing files to the output directory (e.g., the files were locked), an error was reported and the code generation process was stopped. This situation usually occurred because another program temporarily locked the files and prevented them from being manipulated.

Now, the Code Generator attempts to open problematic files more than once, allowing time for the situation to be corrected on the system. If the situation isn’t corrected, the Code Generator will display an error message that explains the problem. The code generation process is paused to enable the user to correct the situation, and then resume code generation.

·         A new bitmap format DLL, tc_fmt_16_24.dll, is provided as an example of a DLL that handles 16-bpp RLE-compressed bitmaps that are drawn on 24-bpp true color graphic displays. The file is located in the RapidPLUS folder.

(Variable) arrays of data arrays

Object arrays can now hold data arrays:

·         Data arrays of type number, string, and integer (excluding integer arrays whose data type has been defined as a primitive type: char, short, or long).

·         Constant data arrays of type number, string, and integer (including primitive data types).

To use this feature, the data array is selected as the default object in the Array dialog box.

For details, see the Help topic “Object array.”

Constant arrays of data arrays

Since version 8.1, constant object arrays can hold objects of type bitmap and font. Now they can also hold constant data arrays. The constant data arrays can be of type number, string, and integer (including primitive data types). Non-constant data arrays cannot be held.

To use this feature, the data array is selected as the default object in the Constant Array dialog box.

For details, see the Help topic “Constant array object.”

Commlink object

There are three addition baud rates: 460800, 512000, and 921600.

Optimizations

·         Generation of C code is faster.

·         Generation of runtime applications (RVR) is faster.

Default application language

The application language can be set to Unicode using the new “Runtime language” setting in the Application Properties dialog box. This setting references the Unicode code page.

Language system object

The Unicode code page is supported. The set: function can be used to change the application language setting to Unicode during runtime.

String arrays and data stores

Unicode text files (UTF-8 encoding) can be imported into string arrays and data stores. The Unicode values can be displayed during runtime if the application language has been set to Unicode.

Displays

Unicode strings can be drawn in graphic displays, text displays, and text windows.

DLL object

A “Unicode string” return type enables communication of Unicode strings between the DLL and the application.

Inspector window

Unicode strings can be displayed.

ASCII object

The object can accept Unicode values. (For backwards compatibility, the ASCII object’s name has not been changed even though its functionality has been extended.)

String object’s getCharCodeAt: function

The function returns the value of a specific character from the string. It accepts Unicode, double-byte, and ASCII characters. It is used by the string object, string property, and string field.

ASCIIValue function

The function can use Unicode values; however, it has been replaced by the getCharCodeAt: function, which is faster for code generation and does not allocate temporary memory. The ASCIIValue function is now hidden, but has not been removed for backwards compatibility.

Interface user objects (IUO) created for configuration

A configuration IUO uses (i) constant set properties to designate the possible configurations, and (ii) constant condition functions to describe the configurations.

The configuration IUO differs from the basic IUO because it is not implemented in other user objects, rather, its constant condition functions are used for:

·         Including and excluding specific user objects. This is done in the Code Generation Preferences dialog box.

·         Excluding logic lines that refer to excluded objects. This is done by writingif <Constant condition function> before the logic.

See the Generating Code for Embedded Systems manual, Chapter 11: “Multiple Configuration Support.”

Constant sets

·         Automatic update.This option, which is located in the Import Constants File dialog box, enables the imported values to be automatically updated when the application is loaded, when the Prototyper starts, and on code generation.

·         Define constant set values externally.This option, which is located in the Constant Set’s Advanced dialog box, lets you choose not to generate the constant set values to C. You can then define the values in compilation time (e.g., using compilation flags or an external header file).

See the Generating Code for Embedded Systems manual, Chapter 11: “Multiple Configuration Support.”

Code Generation Preferences

·         Support Multiple Configurations.This option is located in the Optimize/Config tabbed page. When selected, excluded user objects and excluded logic lines are generated to C with #if macros. This enables sharing of the same generated C source files for all configurations of the application. When not selected, excluded components and logic are not generated. This keeps the generated code clean of modes and objects that are not in use by the current configuration, thus reducing the size of the target code.

·         Condition for User Object Inclusion. This option is located in the Components tabbed page. It is used for conditional inclusion/exclusion of user objects. For every user object, you can select a constant condition function of a configuration IUO. When the condition evaluates to FALSE, the component is excluded.

See the Generating Code for Embedded Systems manual, Chapter 10: “Using the Code Generator.”            

Verification Test tool

·         The Verification Test checks for logic that refers to components which are excluded from the current project configuration.

·         The Options dialog box now includes the configuration management filter. It has also been restructured for ease of use.

See the User Manual Supplement, Chapter 9: “Verification Test.”

Logic Error View window

A warning has been added when an attempt to automatically update constant set values has failed.

See the User Manual Supplement, Chapter 5: “Logic Error View.”

Events dialog box

An event can be defined to contain data. This can be accessed via the User Object dialog box, Events tabbed page.

After an event has been added to the user object interface, and the Edit button is selected, a new dialog box opens. The dialog box contains an option “Event can contain Data,” that defines the event as an “event with data.”

New functions

Three new functions support this event type: triggerWithValue:, getData, and has data. These functions are also supported for C code generation.

C code generation

When a user object event is triggered with data, the event is inserted into the User-generated events queue. The maximum number of events with data can be set in the Code Generation Preferences dialog box, Buffers/Queues tabbed page.

Drawing mirrored bitmaps

Three new functions enable the drawing of mirrored bitmaps:

·          mirroredBitmapsOn

·          mirroredBitmapsOff

·         is mirroredBitmapsOn

These functions are also supported for C code generation. See the Help topics for these functions.

External buffer (for C code generation)

You can use an external buffer for graphic displays in generated code. The external allocation is useful when the buffer must be allocated in a specific memory address. For example, for compilers with structure size limitations or in order to use faster RAM.

See the Generating Code for Embedded Systems manual, Chapter 6: “Integrating Graphic Displays.”

Performance optimizations

There are new optimizations that:

·         Reduce application loading time.

·         Reduce the “Update interface” time.

·         Reduce system memory that RapidPLUS consumes.

·         Reduce CG time.

The effect will be more noticeable on large-scale projects.

Note: When opening an application created in an earlier version of RapidPLUS, the application logic will be reverified. This process may take some time for large projects, but it is a one-time operation.

Generated code optimizations

·         RAM memory.Internal events are generated with a smaller memory footprint. This is achieved by generating them similarly to external events (events of the user object interface).

·         Performance. Array access is faster in generated code.

·         Format driver. A new format driver, fd_gen_f.c, contains speed optimization over the generic fd_gen format driver. It also works with RLE-compressed bitmaps. It should be used for applications with bitmaps of size 8, 16, or 32 bpp. RLE-compressed bitmaps are supported for 16 bpp only.

Prototyper optimization

This optimization improves simulation speed when there are many overlapped graphic objects.

Installation of multiple versions

Multiple versions of the RapidPLUS plug-in/Rapid Reviewer can be installed on the same computer. By default, versions 9.0, 8.1, 8.0, and 7.2 are installed. When an application is opened in the Reviewer or with the RapidPLUS plug-in, the version that best matches the application is used (determined by the application’s database version).

See the Reviewer Readme.wri for details. This file is located in the root folder where the Reviewer is installed.

“Quiet” mode

The Reviewer can run in “Quiet” mode; that is, it will not display messages that require user input (such as OK, OK/Cancel, and Yes/No messages). All such messages will be redirected to a specified file. Quiet mode and the file are specified in the Reviewer’s command line option: /q:fileName where “fileName” is the file that will hold error messages and fatal simulation errors. The file name can have an absolute or relative path. The Reviewer will return an error code <0 if it was terminated because of an error.This feature is useful when running the Reviewer in automatic build scripts and for automatic testing.
See the Reviewer’s Help topic “Command Line Options.”

Breakpoints in generated code

A new generated function, DebugStepFunc, can be used to place breakpoints in the generated code for entry activities, mode activities, exit activities, and transitions. This function provides better monitoring of application behavior during state machine cycles. DebugStepFunc is generated when the “Enable runtime debugging” option is selected in the Code Generation Preferences dialog box.

Improvedtracing

Macros have been added to the cusrdef.h file to enable a more detailed tracing, including an application’s initialization code.

Conditionally included debug information

Debug information (such as mode names), which is generated when the “Enable runtime debugging” option is selected, is conditionally included in the generated code. A conditional define in the cusrdefs.h file determines whether the compilation includes or excludes the debug information. You can exclude most of the debug information in compilation time, and there is no need to regenerate code.

Code generation option

Code is generated from the loaded application to the specified directory.

“Save as” option

The loaded application is saved to a different file name and/or to a different directory. If the application has user objects, they will be saved to the specified directory. This options can also be used to change the extension of the application (RPD to RXD, RXD to RPD, UDO to UXO, UXO to UDO).

Save as runtime application (RVR) option

A runtime application is generated from the loaded application to the specified directory. If the application has user objects, they are generated as RDO files.

CompactAll option

The loaded application and all of its user objects are compacted. When the compact operation ends, the application files are saved.

ReverifyAll option

The logic of the loaded application and all of its user objects is reverified. When the reverify operation ends, the application files are saved.

Code generation of a single user object

In previous RapidPLUS versions, you could generate code for the entire application or for all changed components. Now you can generate code for the user object that is currently being edited. The three code generation scope options are located in the Code Generation Status dialog box.

A menu command has been added to the Code menu in the Application Manager, for generating code for the single user object.

Note: You can now generate code for all components even when editing a user object, and there is no need to move to the main application context.

Text added to empty user code areas

You can have the Code Generator add text to user code areas that are empty. This feature is useful for locating empty user code areas that are required for integration (e.g., user functions with no implementation).

The new option is located in the Code Generation Preferences dialog box, Text tabbed page.

Folder structure maintained

The folder structure of generated component files (C, H) can be maintained. In other words, if a root application (RPD/RXD) has components located in subfolders, the code generation process will create corresponding subfolders for the generated component files.

The option that controls this feature is “Maintain subdirectory structure of generated components,” located in the Code Generation Preferences dialog box, General tabbed page.

Generated backup files structure

When generating code, RapidPLUS creates many backup and information files. These files are now all placed under a new “.Rapid” folder. This folder is located in the same folder as the generated files.

Folder name for generated files can contain spaces

You can generate files into a folder that has spaces in its name.

Bitmap/image objects

The bitmap and image objects have been enhanced:

·         An option in the object’s Advanced dialog box, “User data for format DLL,” enables you to pass a value to format driver DLL (e.g., tc_gen.dll). This integer value is related to the specific object. For example, it can be used to differentiate between bitmaps that require compression (e.g., value of 1) and those that don’t require compression (e.g., value of 0). This value is passed to the method  modifyBitmapFormat.

·         A new method getPixelSizeForBitmap has been added to tc_gen.dll. Its purpose is to optimize generated bitmap data.

See Chapter 6: “Integrating Graphic Displays.”

Early detection of memory problems

When allocating a user object, the memory required for its holders and object arrays is allocated immediately. This immediate memory allocation ensures smooth operation of the user object.

See Readme.wri for details.

Component list in the Application Manager

The Component list was changed so that the user object type is displayed before the object name, and the path was removed. This change is relevant to the “Display components by hierarchy” and “Display components by name” views. This change allows faster access to the required user object and clear identification of dynamically generated components.

Font object enhancements

The font object has been enhanced:

·         A new function has been added: countCharsOfStr: <String> startFrom: <Integer> toFitWidth: <Integer> left-Aligned: <Integer> wordWrap: <Integer>. This function is used when drawing multi-line strings on a graphic display.  

·         Handling of the new-line character (\n) has been modified. Until this version, the new-line character was counted in width calculations. Now, it is considered a separator for substrings and is not counted in width calculations. This enhancement affects these functions:

·          stringWidth:

·          countSubStrOf:toFitWidth:leftAligned:wordWrap:

·          subStrOf:index:toFitWidth:leftAligned:wordWrap:

·          countCharsOfStr:startFrom:toFitWidth:leftAligned:wordWrap:

See the Help topics for these functions.

Automatic singleton

A user object can be designated as an “automatic singleton,” which enables its single instance to become accessible to all the user objects in the project. All of its holders will be initialized with this instance. This feature optimizes application performance and the generated code.

The option that controls this feature is located in the User Object dialog box, Definitions tabbed page.

Find & Replace, User Object Type

In the Find & Replace dialog box, a filter has been added that limits the search to references to a single user object type. The Search operation will be performed on all instances of the specified user object type.

The filter is located in the Advanced tabbed page, in the “Search Only Among References To” group.

Verification Test tool

The Check menu commands have been modified. The “Check” command is now named “Run test.” The “Select” and “Edit” commands have been replaced by the “Go to item” command, which opens the editing tool (Logic Editor, Mode Tree, or Object Layout) for the item selected in the Verification Test window.

Verify before upgrading applications

When opening an application (RPD/RXD) that was created in a previous version, you will be asked if you want to upgrade, and only then, the upgrade operation begins.

Update all externally changed user objects

When multiple user objects are updated externally to RapidPLUS (e.g., by updating from a version control tool), you can now reload all components without verifying each changed user object.

Update JavaBean Objects command was removed

JavaBean objects are now automatically updated, so their interface in the RapidPLUS application always matches their actual interface.

Update Changed User Objects command was removed

This command is no longer necessary because of a faster update process.

XML Management Options dialog box

This dialog box was named the Configuration Management Options dialog box in previous versions. The option for automatically updating changed user objects was removed.

Application Packager utility

The order of the first and second dialog boxes was switched. You now pick the application to be packaged in the first dialog box.

Font object enhancements

The font object has been enhanced:

·         Handling of the new-line character (\n) has been modified. Until this version, the new-line character (\n) was counted in width calculations. Now, it is considered a separator for substrings and is not counted in width calculations.

·         A new function has been added.  countCharsOfStr: <String> startFrom: <Integer> toFitWidth: <Integer> leftAligned: <Integer> wordWrap: <Integer>

See “Notes on the new RapidPLUS 8.11 features” in Readme.wri.

Notes window

The capability to add notes to object and logic elements has been expanded. You can add notes to objects, modes, triggers, object properties, constant set items, data store fields, user object interface elements, actions, and activities.

Notes are now added in the Notes window, which is separate from the Application Manager.

See the User Manual Supplement, Chapter 1: “Managing Projects.”

Interface user objects

A user object can be designated as an  “interface” user object. As such, it defines an interface without containing logic to implement the interface. Interface user objects can be used as templates for other user objects.

When used in object type arrays (see below), they enable user objects of different classes to be held in the same array. When used in holders, they enable user objects of different classes to be sent as parameters in a single function. Interface user objects add consistency in a large project.

See the User Manual Supplement, Chapter 23: “Interface User Objects.”

Arrays of object holders

Until this version, you could define an array of objects, but the default object had to be an object that was added to the application. Now, an array can contain an object type, that is, an object that does not have an instance in the user object. In the Array dialog box, a More button has been added that opens the Holder dialog box for selecting the holder type.

This feature is especially useful for enabling circular reference and holding interface user objects.  

See the User Manual Supplement, Chapter 10: “Nongraphic Objects.”

Circular reference of user objects

Circular reference of user objects is now possible. For example, User Object A can hold User Object B, which holds A. You can achieve circular referencing via user object holders or arrays of object types in holders (see above). This feature can greatly simplify the design of complex applications.

See the User Manual Supplement, Chapter 1: “Managing Projects.”

Reports:

Project Consistency

Component Dependencies Graph

Component Dependencies List

This report presents a list, by component, of incorrect or missing interface elements. This report is particularly useful in a project that uses interface user objects.

This report presents a graph, instead of a list, to depict the hierarchy of a project’s components. The graph is particularly useful in projects that contain circular references.

This report lists the project’s components and, for each component, all the components that it depends on.

For details about these reports, see the User Manual Supplement, Chapter 26: “Generating Reports.”

Explicitly passing parameters by reference

Previously, the RapidPLUS compiler determined how parameters of user function were passed (either by value or by reference). Now this determination is made explicitly in the Logic Editor by adding the “ref” keyword. This keyword can be added manually, or RapidPLUS adds it when the user function is saved.  This feature is particularly useful when implementing interface user objects.

See the User Manual Supplement, Chapter 28: “Additional RapidPLUS Enhancements.”

Registration of user-defined ActiveX objects

In the ActiveX Object Properties dialog box, a new option "Force Registration" ensures that user-defined ActiveX objects, which are bundled with an application, are always called from the application folder. This option should not be used with system ActiveX objects.

Quality Feedback Agent form

This form automatically opens if RapidPLUS crashes. It contains valuable information about what occurred in the application before the crash. The form contains optional fields for your email address and your description of your actions before the crash.

By sending the form to e-SIM, you can assist us with improving RapidPLUS. No personal information is sent.

Pure interface designation

When code is generated for an interface user object, it is generated as “pure interface.” Its generation type cannot be changed. You can see this read-only designation in the Code Generation Preferences dialog box, Components tabbed page.

Optimization report

This report lists—by component—the data objects and properties whose sizes affect the ROM size of the generated code. The report is available from the Application Manager’s Code menu.

See the Generating Code for Embedded Systems manual, Chapter 10: “Using the Code Generator.”

Holder dictionary optimization

The Holder dictionary, an internal RapidPLUS structure that is a list of holders in the application and their held objects, has been further optimized.

See the Generating Code for Embedded Systems manual, Chapter 10: “Using the Code Generator.”

Constant arrays of bitmap or font objects

Until this version, you could define constant arrays of integers, numbers, and strings. Now, you can also define constant arrays of bitmap or font objects, which require less ROM than a regular array of objects.

See the User Manual Supplement, Chapter 11: “Constant Objects.”

Dynamic allocation of temporary memory

When the static temporary memory overflows, RapidPLUS automatically allocates additional temporary memory using the dynamic memory allocation callbacks (if dynamic allocation is enabled). When memory is allocated inside a loop (for or while), the temporary memory is freed after each loop iteration.

See “Notes on new RapidPLUS  8.10 features” in Readme.wri. The functions that require temporary memory are listed in the document
“C-generated Objects, Nongenerated Functions, and Temp Memory.pdf.”

usr_ErrorFunc prototype has changed

The error type was changed from RBOOL to RINT to distinguish between non-fatal errors and warnings.

See the Generating Code for Embedded Systems manual, Chapter 4: “The Application Programming Interface (API).”

Nongraphic Objects icon

The Nongraphic Objects icon is now a button in the Object Layout toolbar. It is enabled when a nongraphic object is added to the layout.

Project Components list

Sorting buttons have been added in the Application Manager to enable alphabetical sorting of the drop-down component list¾by component name or file name.

Indentation of XML code for logic only

In the Configuration Management Options dialog box, a new option “Do not indent XML tags, only logic” provides additional control of indentation in the XML code.

Strings, arrays, and data stores: new functions to check maximum sizes

Three functions have been added: maxLengthInBytes for strings, maxSize for arrays and data stores, and maxStringLengthInBytes for string arrays. These functions return the limits set in each object’s Advanced dialog box.

For details, see the Help topics.

Code Generation Preferences dialog box

In the Components tabbed page, the Project Components list is now sorted alphabetically. Two new options enable you to display the list hierarchically and/or with the full path.

Notes for user object interface elements

Notes can be added for all user object interface elements: properties, events, functions, and messages.

Undo/Redo

The Undo/Redo feature has been expanded. It is:

·         Unlimited, so that you can undo or redo any number of actions. (You can use the Undo Levels dialog box to set a limit. This dialog box is opened via the Application Manager’s Options menu.)

·         Global, so that you can undo or redo your actions from any of the RapidPLUS editing tools, regardless of the tool that you used to perform the action. These tools include the Object Layout, Mode Tree, Logic Editor, State Chart, and Find and Replace.

See the User Manual Supplement, Chapter 28: “Additional RapidPLUS Enhancements.”

Back/Forward buttons

As you select modes and user objects (whether or not you edit them), RapidPLUS logs the selections. You can use the Back and Forward buttons to retrace your selections in the Mode Tree, State Chart, and Logic Editor. This can be helpful when trying to find your place after browsing through a long mode tree or through many user objects.

See the User Manual Supplement, Chapter 28: “Additional RapidPLUS Enhancements.”

XML format

You can save RapidPLUS applications (RPD and UDO) to XML format (RXD and UXO). The XML format offers many development benefits:

·         XML application files can be used by configuration management tools for checking projects in and out, comparing versions, and merging versions (for details, see the next feature, “Version control and team development via XML files”).

·         XML-based or text-based editors can be used for editing object properties and application structure.

·         External tools can be used for tasks such as generating reports and documents.

·         XML application files are readable as text files without the need to open them in RapidPLUS.

·         Corrupted applications can be fixed.

You can configure the XML output in the Configuration Management Options dialog box which is available via the Application Manager’s Options menu.

See the User Manual Supplement, Chapter 2: “RapidPLUS Applications in XML.”

Version control and team development via XML files

With application files in XML format, version control and team development can be improved:

·         Developers can work in parallel on separate project components, while synchronizing changes made by others.

·         Developers can work in parallel on the same project component, merging the changes when the work is done using an external configuration management tool.

·         Developers can check files in and out of a version control system.

·         Different versions of the same component can be compared using an external comparison tool, including the comparison tool of the version control system.

See the User Manual Supplement, Chapter 1: “Managing Projects.”

Logic Error View window

The Logic View’s functionality has been expanded, including notification of errors when opening applications in XML format. The new Logic Error View window can be opened from the Application Manager’s View menu. It also saves information from previous errors.

See the User Manual Supplement, Chapter 5: “Logic Error View.”

Call Stack in the Debugger

The Debugger has an additional utility, the Call Stack, which displays a sequence of stack frames leading up to the current logic statement. The Call Stack is displayed while the Debugger is paused at a point in which logic is executed.

See the User Manual Supplement, Chapter 4: “Debugging Applications.”

Differencing Tool enhancements

The enhancements include:

·         Project components and resources are compared. The comparison is based on component properties, which are taken from the revision comments in each component’s Application Properties dialog box.

·         Mode comparisons include mode type (i.e., exclusive or concurrent and default mode status).

·         Differences reports can be generated for both of the applications that are being compared. These reports are displayed in the Report Viewer.

See the User Manual Supplement, Chapter 3: “Comparing Applications in the Differencing Tool.”

Holders of data stores and arrays

A holder can hold a data store or array. To create such a holder, a Holder check box has been added to the Data Store and Array dialog boxes.

See the User Manual Supplement, Chapter 10: “Nongraphic Objects.”

Graphic displays
(palette-based and true color)

The enhancements include:

·         Connecting to an external DLL: output of a graphic display can also be sent to an external device while the simulation is running in the Prototyper. This connection is achieved by selecting the external DLL in the graphic display’s Advanced dialog and by implementing API functions in the DLL.

·         Clipping rectangles: in previous versions, only the user-defined buffers had clipping rectangles. In RapidPLUS 8.0, the buffer clipping rectangles act as viewports and the intermediate buffer has its own clipping rectangle, which is referred to as the device clipping rectangle. It determines the location that is valid for drawing text and graphics on the graphic display’s intermediate buffer.

·         A project can contain multiple graphic displays.

See the User Manual Supplement, Chapter 12: “Graphic Displays.”

Image objects: alpha channel support

An image object that contains a PNG file can use the PNG file’s alpha channel to make the image transparent or semi-transparent in the Object Layout and Prototyper. The alpha channel enables the PNG image to be blended with any objects placed under it and with the application background.

See the User Manual Supplement, Chapter 13: “Bitmap, Image, and Font Objects.”

New reports

The Application Manager’s Reports menu presents additional reports:

·         Target Graphic Displays: this report presents a list of the graphic displays that are used in the project components.

·         Coverage Test: this report presents a list of modes, transitions, triggers, user functions, and objects that are not referenced in data collected from the Prototyper. Coverage tests can now be run from the Prototyper, and not just from the Document Manager. In the Prototyper, the Coverage Test command is located in the Control menu.

See the User Manual Supplement, Chapter 26: “Generating Reports.”

Easy navigation to user function definitions

In the Logic Palette, when you right-click a user function and select the “Go to definition in Function Editor” command, the Function Editor opens to the user function’s definition.

Conditional code inclusion

If and Else conditional statements that use constant objects (for example, if Constant_Integer < 2) that evaluate to False are not generated and are shown in the Logic Editor in gray.

See the User Manual Supplement, Chapter 7: “Writing Logic Using Loops and Branches.”

ActiveX bridge utility

An external utility, RapidAppReg.exe, wraps a RapidPLUS application as a unique ActiveX control and exposes the exported properties and events as ActiveX properties and events. This file is located in the main RapidPLUS folder.

See the User Manual Supplement, Chapter 17: “Using ActiveX Controls.”

Zoom in/out in the Object Layout

Zoom buttons have been added in order to zoom in and out of the Object Layout work area.

Viewing columns in the Logic Editor

You can zoom in and out of the four columns in the Logic Editor by double-clicking the columns. In previous versions, there were toolbar buttons that controlled zooming.

Missing user objects

A project that is missing one or more user objects can be opened. A crossed-out rectangle appears in place of the user object in the Object Layout.

See the User Manual Supplement, Chapter 1: “Managing Projects.”

Updating components that are affected by interface updates

When the interface of a project component has been changed, the other components that use its interface are affected. RapidPLUS can either mark these components as changed or not.

An option, “Automatically Update Changed User Objects” controls this behavior (located in the new Configuration Management Options dialog box which is available via the Application Manager’s Options menu). When this option is not selected, the update can be initiated using the “Update Changed User Objects” command located in the File|Advanced menu.

See the User Manual Supplement, Chapter 1: “Managing Projects.”

Application Packager

The Application Packager has been redesigned for ease of use and added functionality. It is used for packaging applications with the RPD, UDO, RVR, and RDO extensions.

See the User Manual Supplement, Chapter 29: “Application Packager.”

Integers

The size of the C code that is generated for integers can be changed by selecting a primitive data type in the object’s Advanced dialog box. Primitive data types can be long (32 bit), short (16 bit), or char (8 bit). This feature applies to integer objects, integer arrays, integer properties of active primitive objects, and user object properties of type integer.

See the User Manual Supplement, Chapter 10: “Nongraphic Objects.”

Graphic display objects (palette-based)

An option “Match bitmap to object palette” has been added to the Advanced dialog box. This option ensures that each bitmap drawn on the graphic display is matched to the object’s initial palette, so that the colors of the bitmap shown in the graphic display will look as similar as possible to the colors defined for the bitmap.

See the Generating Code for Embedded Systems manual, Chapter 6: “Integrating Graphic Displays.”

True color graphic display object, including:

Alpha channel transparency

Bitmap compression

The true color graphic display object can be generated to C code:

·         It has advanced settings for determining color depth, including alpha channel transparency.

·         It uses a bitmap format DLL, named tc_fmt.dll, which handles 8 to 32 bits-per-pixel.

·         It supports bitmap compression via a function in the bitmap format DLL that compresses bitmap data using a compression algorithm located in the Zlib library.

See the Generating Code for Embedded Systems manual, Chapter 6: “Integrating Graphic Displays.”

Root object

The name of the root object of every RapidPLUS application is “self.” In previous versions, the root object name was the application name.

The “empty” property for each object

Each object’s functions, conditions, and events are located under an “empty” property that is designated by an ellipsis (…). In previous versions, the object property was named “self.”

View menu in the Application Manager

The View menu presents all of the RapidPLUS windows, and other tools and options. In previous versions, the windows were presented under the Tools menu.

Code Generation Preferences dialog box

The dialog box has been modified to provide more information.

See the Generating Code for Embedded Systems manual, Chapter 10: “Using the Code Generator.”

Calling a user function inside a condition

The return value of a user function can be used in a compound trigger (a trigger that is created from an event and a condition.) For example, Pushbutton1 in & self function1 = 4.