2.0.1 (2024-11-11 07:03)

The C++ code generator now supports trigger guards, both for capsule and class state machines. For a capsule example, see this sample. For a class example, see this sample.
Now you can use the rule_config property on capsule parts, which means it's now possible to disable validation rules for individual parts. This is for example useful for disabling ART_0039_portPartMultiplicityMismatch for ports that are intentionally left unconnected (for example because you plan to send events on them using the Art Debugger). In addition the rule_config property is now also supported on entry and exit points.
There is a new Quick Fix for disabling the validation rule that has reported a problem on an element. It appears at the end of the list of available Quick Fixes and will "fix" a problem by disabling the validation rule on that specific element by inserting the rule_config property. The new Quick Fix is available for all validation rules and elements for which this property is supported.
The code generator now allows unconnected service ports. Normally such ports should be connected (provided they are not unwired of course), but in some cases it can be useful to let them be unconnected and instead inject events on them using the Art Debugger or to do it programmatically.
The translation of outgoing transitions for choices has been improved in the C++ code generator and is now consistent with how other non-triggered transitions are handled.
A new sample TrafficLightWeb is provided. It uses the TCPServer library for implementing a Node.js web application as the user interface of a realtime application. The communication is bidirectional, and the web page is updated using web sockets.
A new sample MoreOrLess is provided. It shows how plugin parts can be used as a way for capsules to share a common resource by importing and deporting a capsule instance that represents the shared resource.
The Art Debugger now supports injecting both incoming and outgoing events on a port. An icon has been added in front of the displayed events that shows if the event will be sent in to, or out from, the port. This feature avoids the need to move the selection from a port to its connected conjugated port when you want to send an event in the other direction.
It's now possible to send events with the Art Debugger, where the event contains a parameter typed by a primitive type whose name contains a space (such as unsigned long). Read more about this change and the potential side-effects it may have to your application here.
A new validation rule ART_0040_boundUnboundTriggerForNonNotifyingPort checks so that triggers that reference the rtBound and rtUnbound events also reference a notifying port.
The C++ code generator now supports internal transitions for class state machines. For an example, see this sample.
The risk for inconsistent C++ code standards being used by the code generator, the compiler and the language server has been mitigated by a new validation rule TC_0018_withoutCodeStandard. It will now report a warning if the cppCodeStandard property has not been set in the TC. In that case a default code standard will be used by the compiler and language server, while generated code will (still) comply with C++ 17.

2.0.0 (2024-09-17 11:33)

A first version of an Art Debugger is now available. It lets you debug your realtime application at the Art abstraction level and is a good complement to using a C++ debugger. The Art Debugger can both launch the application to debug, or attach to an already running application (including remote debugging). In addition to assisting with troubleshooting, the Art Debugger allows you to interact with the application by sending events on ports. For more information, see the documentation.
The C++ code generator now supports trigger operations with parameters. For an example, see this sample.
Two new sample applications are provided for showing how distributed applications can be built using the TCPServer library: DistributedPingPong and TokenRing.
The TargetRTS documentation has been extended with new chapters about logging, the defer queue and unhandled messages. There is also now a page that summarizes all available samples in a single place.
The support for port multiplicity has been completed in the C++ code generator and in the validation rule ART_0039_portPartMultiplicityMismatch. Now the handling of sent and received messages on a specific port index is equivalent to what Model RealTime supports, but with improved static analysis for ensuring correct usage of ports with multiplicity.
Content Assist (ctrl+space) now supports creating triggered transitions in class state machines with the correct trigger operation syntax. This works both from the Art file and from a state diagram.
The sample application TcpRangeCounter has a new sample client application that can be accessed from a web browser. It's implemented as a Node.js Express application.
A new validation rule TC_7017_prerequisitesCyclic now reports a warning if cyclic prerequisites are detected (i.e. a TC has itself as a direct or indirect prerequisite).
It's now possible to use Art files created with Code RealTime when developing realtime applications with Model RealTime. A first EXPERIMENTAL version of this feature is available in Model RealTime starting with version 12.0.3. Note that as part of this feature, a new TC id TCF.ART_TO_CPP has been introduced. All samples and testcases now use this new TC id. For backwards compatibility the old TC id TCF.CPP_TRANSFORM still works in Code RealTime, but not for Art files that you want to access from Model RealTime. See the Model RealTime documentation for more information about the new integration between Code RealTime and Model RealTime.

1.0.5 (2024-08-06 13:21)

Files from the Code RealTime installation are now by default treated as read-only and will appear with a padlock in the editor title when you open them. Examples of such files include RTPredefined.art and all files from the TargetRTS. Having these files read-only helps to avoid accidental modifications, but if you anyway want to edit them you can do so by updating the setting files.readonlyInclude.
Support for port multiplicity has been improved. Now code generation supports connecting the same port to several other ports including local ports and other part's ports. It is also possible to use C++ constant expressions as port multiplicity, for example, macros.
Art compiler now fully supports protocols with symmetrical events, which can be both sent and received by the same port. Check out this test case for an example.
Detection of abstract capsules has been improved to fully analyze parent capsules, their pure virtual methods and overrides.
Navigation options from transformation configuration (TC) text editor have been extended. A user now can Ctrl+click on paths to files and folders specified in values of various attributes such as sources, targetFolder, inclusionPaths, targetRTSlocation and open the file or reveal the folder in Explorer.
A new validation rule TC_7016_prerequisitesWithoutActiveTC now reports a warning if a TC has prerequisites, but the container workspace folder has no TC set as active. This rule is helpful when you work in the IDE, and forgot to set a TC as active. With no active TC, references to source elements of prerequisite TCs become unresolved, and previously it could be difficult to understand why. The validation rule provides a Quick Fix for resolving the problem by setting the TC as active.
A new gRPCServer library is now available which allows to connect your realtime application to other applications with gRPC. The library is provided as a sample that you either can use as is, or customize according to your needs.
A new sample application is provided to show how to use the gRPCServer library. A sample client application written in C++ is also available on GitHub.
New examples have been added including DiningPhils implementing different algorithms to solve classical Dining Philosophers problem, and Ping-Pong with added time measurements.
Code RealTime docker image is available on DockerHub and is based on web version Visual Studio Code provided by openvscode-server.

1.0.4 (2024-06-26 10:50)

It's now possible to use newer JVMs than Java 17 for running Code RealTime. Information about which Java (and version) that will be used is printed in the Art Server output channel at start-up.
A new documentation chapter explaining how message-based communication works inside the TargetRTS is now available here. A new sample application shows how statistics about messages (and more) can be collected and printed at run-time.
A new target configuration for the Clang 15 compiler for MacOs with ARM processor is now available. It's called MacT.AArch64-Clang-15.x.
The JSON parser now provides functions RTJsonResult::keys_begin() and RTJsonResult::keys_end() which make it possible to iterate over the keys of a parsed JSON string. This makes the JSON parser useful also for scenarios where the expected keys are not statically known.
The TargetRTS type RTByteBlock, which represents an arbitrary block of memory, can now be encoded/decoded to/from JSON. The encoding is an array of the byte values contained in the byte block.
The C++ code generator now supports template parameters for classes, both type and non-type template parameters. For an example, see this sample.
The name of the C++ class that is generated from a capsule is now the same as the capsule name. Hence it's no longer necessary to append the suffix _Actor when referencing a capsule from C++ code, for example when defining a capsule member function. This makes the code more readable and less typing is required. Note, however, that this change is not backwards compatible; existing references must be updated to remove the _Actor suffix. Note also that the type descriptor object, which previously had the same name as the capsule, now has the prefix RTType_. This prefix was already used for non-capsule types. If you have existing references to the type descriptor object of a capsule, for example in calls to RTFrame::incarnate(), you therefore need to add the RTType_ prefix in those places.
The Art language now has a new keyword abstract for marking capsules and classes as being abstract. This is an alternative to adding a pure virtual function to the capsule/class, and is better for scenarios where no pure virtual functions are needed, but the capsule/class should still be abstract (i.e. not possible to instantiate). Another benefit is that for an abstract capsule certain validation rules that check the correctness of state machines will not report a problem even if the capsule state machine is not correct. This makes it possible to create an abstract base capsule with an incomplete state machine which derived capsules can inherit from, reuse and specialize.
The C++ code generator now analyzes rt::decl code snippets of a capsule, looking for pure virtual functions. If at least one such function is found, without a matching overridden function, the capsule is implicitly abstract, and treated by the code generator as if it was declared with the abstract keyword.
The C++ code generator now supports the registration_name property for unwired ports.
A new TCPServer library is now available which allows to embed a TCP server in your realtime application. By doing so you can control the application from the "outside" by sending TCP requests to it. You can also detect outgoing events from the application by means of receiving TCP requests from it. The library is provided as a sample that you either can use as is, or customize according to your needs.
A new sample application is provided to show how to use the TCPServer library. It also includes a Node.JS client application that can be used for sending TCP requests to the application.

1.0.3 (2024-05-08 12:45)

The C++ code generator now supports delegation connectors. For an example, see this sample.
The C++ code generator now analyzes rt::decl code snippets of a capsule, looking for a user-defined destructor. If a user-defined destructor is present, the code generator doesn't generate the capsule destructor it otherwise generates. For an example, see this sample.
A new documentation chapter explaining how timers work is now available here. Three new sample applications that show how to use timers are also included (linked from the new documentation chapter).
Content Assist for capsules was extended to allow creation of a destructor, as well as overriding some of the virtual functions from the RTActor base class (such as _predestroy()).
Three more checkboxes are now present in the Properties view of a structure diagram for a selected port. They allow setting the port as notify, publish and subscribe. Another improvement is that checkboxes for properties that are not applicable for a port with a predefined protocol (such as Timing or Frame) will now be hidden.
A new validation rule ART_0038_portWithPredefinedProtocolNotCorrectlyDeclared now reports a warning if a port with a predefined protocol (such as Timing or Frame) is declared with properties that are not applicable for such a port (for example notify or unwired).
It's now possible to use the variable $(CAPSULE_CLASS) in the value for the capsuleFactory TC property. It will be replaced with the name of the C++ class that is generated for the capsule. This can be useful for implementing a generic capsule factory which takes the capsule class as a template parameter.
The C++ code generator now supports state redefinition with regards to entry and exit actions. For an example, see this sample.
It's now possible to access properties from the top TC from a prerequisite TC by means of the TCF.getTopTC() function and the special eval property. This is useful in order to allow the same library to be built as a prerequisite from multiple executables. For more information, see the documentation.
You are now welcome to contribute to the contents of the Code RealTime GitHub repo(samples, test cases and documentation). See this page for information on how to do it.
Two new TC properties are now available for controlling the name of a generated executable or library: executableName and libraryName.
Each connector between two ports yields one or many connections at runtime on which messages can be transported. The number of such connections should for each connected port exactly match its runtime capacity. This capacity is determined by the port's multiplicity, and, if the connector also references a part, also the part's multiplicity. This constraint is now checked by a new validation rule ART_0039_portPartMultiplicityMismatch. If a mismatch is detected, a warning is reported.
You can now build regular, non-generated, C++ source files together with the generated C++ files. It's no longer necessary to place such C++ code into wrapper Art files. The generated make file will automatically include rules for building all .cpp files that are present in the workspace folder (or a subfolder of it), and all folders that contain .h files will be added to the inclusionPath property. The sources TC property can be used to precisely control which C++ source files that should be included into the build. For more information, see the documentation.

1.0.2 (2024-03-27 21:14)

Semantic errors related to the triggers of a transition are now shown in state diagrams.
The C++ code generator now generates the macros SUPERMETHOD and CALLSUPER for redefined transitions. They make it possible to call the effect or guard code of an inherited transition from a redefined transition, without having to place such code in a capsule member function. For an example, see this sample.
The Art Compiler now prints the total number of errors and warnings at the end, before it terminates.
The TargetRTS now contains so called patch-files with all changes made from one version to another. These files make it possible to automatically apply those changes to your own version of the TargetRTS, when you uplift to a newer version of Code RealTime. A shell script which can produce such patch-files are also included, and can help if you instead want to apply your own changes to a new TargetRTS version. For more information, see Patch Files.
A new sample DependencyInjection is now available. It shows how dependency injection can be used together with build variants to build different versions of an application, where capsules behave differently.
The validation rule ART_0018_circularTransitions has been improved so it now also can detect transition cycles caused by incorrect usage of entry/exit points, or cycles introduced because of state machine inheritance.
You can now invoke Content Assist within a C++ code snippet in an Art file, and get the same result as if you would invoke it from the generated C++ code. This significantly increases the productivity when working with C++ in Art files, and reduces the need to navigate to generated code for typing C++ code. This feature works both for the "Microsoft C++" and "clangd" language servers, but with small differences due to the way they are implemented. Common is that the feature may sometimes need to be invoked twice, before it starts to work, when an Art file has been opened for the first time (or the first time in a while).
The TargetRTS now includes a JSON parser, which makes it easier to consume or expose JSON-based APIs from your realtime application. For more information see JSON Parser.
The C++ code generator now analyzes rt::decl code snippets of a capsule, looking for user-defined constructors. If at least one user-defined constructor is present, it doesn't generate the default capsule constructor it otherwise generates. Other parts of generated code were updated accordingly to no longer assume that a capsule has a default constructor. For an example, see this sample.
You can now open Art and TC files specified in the sources and prerequisites TC properties by means of hyperlinks in the TC editor. When specified paths can be resolved to valid Art or TC files, they will become underlined, and can be opened by Ctrl+click.

1.0.1 (2024-02-08 08:40)

A new sample QtTrafficLight is now available. It shows how to integrate the code generated from Code RealTime with a user interface developed with Qt. Note that the Qt part of the sample application is found in another Git repository.
A new validation rule ART_0036_unexpectedTriggers detects if a transition that is supposed to be non-triggered still has at least one trigger. A Quick Fix can then be used for removing the unexpected triggers.
A new validation rule ART_0037_missingTriggers detects if a transition that is supposed to be triggered doesn't have any triggers.
The showing of validation problems in diagrams was improved to be more accurate, for example when expanding or collapsing a composite state. Also, a derived capsule state machine that has an inherited transition that is incorrect in the context of the derived state machine will now cause an error to be shown for the inherited transition in a state diagram for the derived capsule.
The predefined variable ${workspaceFolder} can now be used when specifying the prerequisites of a TC. This is often a better alternative than using a relative path since it allows the prerequisite TC to be located anywhere in the file system and still be found when resolving the prerequisite. As an example you can write ${workspaceFolder:MyLibrary}/lib.tcjs where MyLibrary is the name of the workspace folder where the prerequisite TC is located.
The Art Compiler now has a new option -ws which can be used for specifying the location of the workspace (in the form of a .code-workspace file). It's optional to use this option, but it must be specified if built TCs contain workspace-relative paths.
The validation rule ART_0002_duplicateNamesInScope was improved to find naming conflicts caused by inheritance.
The C++ code generator now supports global capsule factories by means of a new TC property capsuleFactory. This allows to globally control how capsule instances in an application are created and destroyed. One scenario where this is useful is when using the RTInjector class from the TargetRTS to implement dependency injection for capsule creation. For an example, see this sample. Read more about these topics in new documentation chapters Capsule Factory and Dependency Injection.
The Art Compiler now sorts reported messages according to their file position. This means that messages, such as errors and warnings, now are reported in the same order when building from the command-line as when building from the UI.
The TargetRTS now has support for decoding a JSON string into an object (already before it had support for the opposite, i.e. encoding an object into JSON). This is useful when implementing applications that exchange JSON, for example with a web service or some other API. It can also be used for persisting application data in files or object databases. For an example, see this sample.
Rename refactorings have been improved to also update references in art_diagram_settings.json.
The TargetRTS documentation has been extended. For example, it now covers how to build, debug and customize the TargetRTS.

1.0.0 (2023-12-11 08:33)

The product is now renamed to DevOps Code RealTime and in addition to the Community Edition a Commercial Edition is also available. With the Commercial Edition comes support entitlement, the right to use the product and generated applications for commercial purposes, and access to the TargetRTS source files which makes it possible to build applications for any target platform.
The Clang language server clangd is now supported. It is available both for Visual Studio Code and Eclipse Theia.
The C++ code generator now supports "receive-any" events, i.e. the use of an asterisk for specifying a trigger that handles any event received on a port. For an example, see this sample.
The C++ code generator now supports unwired ports. For an example, see this sample.
When a TC property that contains a list of values, for example the sources property, is modified in the form-based TC editor, the TC file is automatically updated accordingly. Now the formatting of such TC properties is improved by placing each list element on a line of its own, and to add a trailing comma after the last element. This makes it easier to merge the TC file, without getting merge conflicts, in case more people are editing it in parallel.
Diagram settings (stored in the file art_diagram_settings.json) now uses an improved JSON format. A benefit with this new format is that it's now possible to move a workspace folder in the file system without invalidating the diagram settings. Another benefit is that each capsule part in a structure diagram can now be independently expanded, even for the case when there are multiple capsule parts typed by the same capsule.
The C++ code generator now supports classes with state machines. For an example, see this sample.

0.0.11 (2023-11-09 10:30)

A new validation rule was implemented in the C++ code generator to detect if there are ambiguous outgoing transitions for a state, i.e. transitions with identical triggers and no guard conditions. Such unreachable transitions are now reported as a problem (with warning severity as default). A comment is also added in generated code to mark the unreachable code where functions of such unreachable transitions are called.
Several new validation rules now check the correctness of the threads property in a TC. For example, an attempt to map the same logical thread to different physical threads are reported as a problem. Previously, such problems were only detected when compiling or linking the application, or even at run-time.
The C++ code generator now supports the deep history pseudostate (history*). For an example, see this sample.
The C++ code generator now supports the const_rtdata property. By setting this property to false on a transition, the rtdata parameter of the transition function will be non-const. This, for example, allows it to be moved instead of copied, which can be more efficient. For an example, see this sample.
The validation rule ART_0001_invalidNameCpp has been extended to now also detect if names chosen for Art elements will clash with names in generated code or the TargetRTS.
The C++ code generator now supports excluded transitions. For an example, see this sample.
It's now possible to delete ports and parts from a structure diagram by selecting them and then pressing the Delete key or using the Delete command in the popup menu that appears when pressing Ctrl+Space.
The C++ code generator now supports junctions and the guards on their outgoing transitions. For an example, see this sample.
A new validation rule CPP_4002_guardedInitialTransition now detects if there are junctions in the initial transition without unguarded outgoing transitions. With such initial transitions there is a risk that no initial state will be entered, which would break the functioning of the state machine.
A new command "Deactivate All" in the Art Build view can be used for quickly making all TCs in the workspace non-active. This makes it faster to switch from building one set of active TCs to another.
Several validation rules have been updated to mark problems more accurately in an Art file. If an element spans multiple lines in the Art file (e.g. a capsule or state machine) then if the whole element would be marked, problems within the element cannot be seen in the Art file. Now smaller parts of such elements are marked such as only the element name or a certain keyword within the element. In addition to a cleaner look this also makes navigation from problems arrive closer to where the problem is located.
The TC property "userLibraries" is now supported (both in TC editor and UI). It can be used for specifying a list of libraries to pass to the linker.
The C++ code generator now supports capsule factories on parts by means of the rt::create and rt::destroy code snippets. For an example, see this sample.
The TargetRTS and C++ code generator now supports the predefined type long long.
A target configuration for the Clang compiler for MacOs is now provided.
The Art Compiler now prints related elements for validation problems. This means that you now get the same amount of details about a validation problem when building from command-line as from the UI.
When building from the UI, TCs are now validated and found problems are reported in the Art Build output channel. Any error found during this validation will stop the build. Previously such errors were only reported when building from the command-line, and the UI build would proceed even in case errors were found, which often lead to other problems later in the build process.
The TC property "userObjectFiles" is now supported (both in TC editor and UI). It can be used for specifying a list of object files to pass to the linker.
The TC property "inclusionPaths" is now supported (both in TC editor and UI). It can be used for specifying a list of include paths for the preprocessor.
Some new code actions ("quick fixes") were implemented for certain validation rules.

0.0.10 (2023-09-13 14:22)

The C++ code generator now supports generation of type descriptors. When you declare a type in an rt::decl code snippet you can tag it with a C++ attribute to tell the code generator how it should generate the type descriptor. Currently two attributes are supported: rt::auto_descriptor (for fully automatic type descriptor generation) and rt::manual_descriptor (when you prefer to write the type descriptor manually). Read more about this feature in the documentation.
The C++ code generator now supports local bindings (i.e. a connector between two behavior ports on the same capsule). This makes it possible for a capsule to send events to itself. Read more about this feature here.
The support for state machine inheritance in the C++ code generator has been much improved. For an example, see this sample.
Two new validation rules were implemented for checks related to ports. See ART_0034_servicePortWithoutEvents and ART_0035_timerServicePort.
The C++ code generator now performs additional validation of an Art file when it's translated to C++. Dedicated validation rules are used for this purpose and they can be enabled/disabled and have their severity customized in the same way as other validation rules. Found problems appear in the Art file, in the Problems view and in diagrams. For more information see the documentation.
You can now use colors on most symbols and lines also in class and structure diagrams.
Use of certain colors have been improved to ensure that diagrams remain readable when custom symbol colors are used. For example, background patterns printed on optional and plugin parts in structure diagrams now use a light color if the background color is dark, and a dark color if the background color is light.
Navigation from code snippets in generated C++ files to the source Art files is now supported. The file URIs in the USR-comments surrounding the code snippets can now be ctrl-clicked in order to perform the navigation.
Structure diagrams can now be edited. You can create ports and parts, and also use the Properties view for viewing and editing some of the properties of these elements.
A new "Art Build" view is now available. It shows all TCs in the workspace and for each TC its prerequisites are shown as a tree structure. Common commands are available on the TCs, such as Clean, Build and Run. A TC that is often built can be selected in the "Art Build" view, so that it's not necessary to find it in the Explorer view each time it should be built. The new view also provides a button for invoking the "Clean All" command that previously only could be invoked through the Command Palette.
It's now possible to specify physical and logical threads in a TC. The C++ code generator uses this information for creating those physical threads and application code can reference the logical threads when a capsule instance is created. For more information see the documentation. Note that currently thread information can only be specified in the TC text editor (the form-based editor doesn't yet support it).
Validation markers for showing problems in diagrams are now also supported on labels within class diagram symbols. Hence, it's now possible to see validation problems on ports, parts and events.

0.0.9 (2023-07-20 07:39)

It's now possible to build multiple variants of an application by means of a feature called Build Variants. You can use JavaScript for dynamically customizing a TC at build-time, in order to implement high-level build variant settings. Build variants are implemented in the Art Compiler by means of two new options: --buildConfig and --buildVariants. For an example, see this sample.
A new command "Clean All" is now available. It will remove all generated code in the workspace and also remove all generated workspace folders. It's equivalent to, but more convenient than, invoking the "Clean" command on each TC individually. Invoke "Clean All" from the command palette (Ctrl+Shift+P).
The C++ code generator now supports multiple inheritance for capsules. A capsule can at most inherit one other capsule, but now it's in addition also possible to inherit any number of C++ types. For an example, see this sample.
The C++ code generator now assigns the correct type for the rtdata parameter in transition functions generated for non-triggered transitions. Previously this only worked for triggered transitions, and rtdata in a non-triggered transition would become untyped (const void *). Now the code generator analyzes the whole transition chain to use the more specific type also for functions generated for non-triggered transitions. For an example, see this sample.
The C++ code generator now supports specifying a guard condition either using a C++ boolean expression, or a C++ return statement that returns a boolean expression. In the former case the code generator will automatically add the return keyword in generated code. Code-to-art synchronization also handles both these cases.
When a TC is built from the UI using the context menu command Build (or Run on a TC that was not built already), the Problems view is now scanned to check if it contains at least one error related to the built TC, or a prerequisite TC. If so, a dialog will appear to ask if you really want to proceed with the build. It's recommended to cancel the build, fix the error, and then redo the build. If you choose to proceed with the build you may get either build or run-time errors in the built application. A new setting rtistic.build.cancelOnError can be used to control this behavior.
Redefined elements are now drawn in diagrams with a different line style ("dashed-dot-dot"), to make them easier to distinguish from inherited elements (that are still drawn with a dashed line style). Labels for redefined elements are still drawn with green color to further emphasize the difference between a redefined and an inherited element in diagrams.
RTist in Code is now available as a Docker image on DockerHub. You can deploy this image to get the latest version of RTist in Code running in Eclipse Theia.
The presence of elements in the global scope with clashing names is now detected across the whole workspace. All source files that will be built by the active TC are checked. Previously such problems were not detected until linking the built application.
Launch configurations are now supported for running an application built by a TC. This is a more flexible way to launch applications than using the Run context menu of a TC. You can set environment variables and command-line arguments for the launched application, as well as its current working directory. You can also easily terminate and relaunch the application using the launch toolbar.
The C++ code generator now supports compound transitions. Each individual transition of the compound transition is translated to a separate C++ function to avoid code duplication. Also, for increased code readability the numbers representing states are now followed by the state name in a comment. For an example, see this sample.
A new sample PiComputer is now available. It contains a few collaborating capsules with hierarchical state machines and implements a computation of Pi.
The C++ code generator now supports choices. For an example, see this sample.

0.0.8 (2023-05-31 06:09)

A new setting rtistic.build.outputFolder is now available. It can be used for setting a common output folder for generated code, and TCs where the targetFolder specifies a relative path will now be resolved against that output folder. This new setting hence plays the same role for a UI build as the --out option does when building with the Art Compiler from the command-line.
Several small sample applications are now available in the RTist in Code GitHub Repo. These are written as tests of the Art Compiler and the TargetRTS, but can also be useful for learning more about the Art language and RTist in Code.
TC prerequisites are now taken into account when generating the c_cpp_properties.json file. This prevents references to definitions in prerequisite libraries to appear as broken in the UI when looking at generated code, and it also enables features such as Content Assist, hover tooltips etc for those definitions.
TC prerequisites and the "sources" TC property are now taken into account when binding references in the UI. It's required to set the TC as active so name lookup can find the correct prerequisites. This means that name binding rules used in the UI now are aligned with how the build works.
It's now possible to redirect a transition in a state diagram. Select the transition to redirect and the new source or target element in the diagram. Then use one of the new commands in the Ctrl+Space popup menu: Set Transition Source or Set Transition Target. Both commands have keybindings so that you don't need to always open the popup menu.
The C++ code generator now supports event inheritance for protocols. For an example, see this sample. Redefined events are also supported. For an example, see this sample.
The C++ code generator now supports part inheritance for capsules. For an example, see this sample.
A new navigation command "Open Inherited State Diagram" is available in state diagrams. You can use it for navigating from the state diagram of a derived capsule to the state diagram of the base capsule. If an inherited, excluded or redefined element is selected in the derived diagram the command will open the state diagram where the element is defined.
The form-based TC editor now provides graphical widgets for editing the "prerequisites" and "sources" properties. It also performs some validations to detect errors in these properties.
When the "Set as Active" command is invoked on a TC, the prerequisites of the TC will also be set as active. This helps to ensure consistency in the UI and when building the TC.
A target configuration for building with Clang (ver. 16) on Windows is now provided.
A target configuration for building with Clang (ver. 15) for the Windows simulator for the VxWorks RTOS (ver. 7) is now provided.

0.0.7 (2023-04-19 11:56)

The popup menu that appears when pressing Ctrl+Space in a state diagram now contains commands for creating elements in the state machine. These commands are the same as appear in the Content Assist menu in the Art text editor. For example, you can create states and pseudo states this way. The created element is added last in the state machine in the Art file. If a state is selected the popup menu contains commands for creating elements inside the state. If required, it will first be converted to a composite state. You can also create transitions using this popup menu. Select first the source and then the target and then invoke a command for creating the transition.
You can now open diagrams for an element by selecting it in a diagram and then open the Ctrl+Space popup menu. For example, if you select a capsule part in a structure diagram, the popup menu contains commands for opening the state, structure or class diagram of the capsule that types the part. Previously it was necessary to first navigate to the capsule part in the Art file, then from there to the capsule, and finally from there the diagram could be opened. Now this navigation can be performed in a single step without involving the Art file at all.
State diagram elements can now be deleted by using a new Delete command in the popup menu that appears when pressing Ctrl+Space in a state diagram.
It's now possible to remove a color from a symbol or line by selecting it in the state diagram and then press the trashcan icon that appears in the Properties view.
When performing a diagram command that modifies the Art file, the cursor is now set at an location in the Art file that corresponds to the changed diagram element. If possible, relevant text is also selected in the Art file. This serves two purposes; it becomes easier to notice the impact of the change in the Art file, and Undo/Redo will work correctly.
Transformation configurations are now validated to detect inconsistent and incorrect property values. For example, you will get a warning if you build a library but a TC property is used that only is applicable when building an executable. And you will get an error if a TC property specifies a value of incorrect type.
A new TC property, "sources", can now be used for controlling which Art files that should be transformed to C++ by the code generator. It is a list of glob-style patterns and anti-patterns. A file will be transformed if it matches at least one pattern (e.g. *.art) and doesn't match any anti-pattern (e.g. !exclude.art). This property is not yet supported by the form-based TC editor, but can be set in the .tcjs file in order to exclude one or several Art files in the workspace folder where the TC is located.
The TC editor description tooltips now have a background color that is dynamically adjusted to make it visible regardless of selected color theme.
The Art text editor now provides a "code lens" for building and running a capsule without first having to create a TC. The code lens appears as a "Run" hyperlink shown just above a capsule. The capsule will be built with default settings into an executable where it runs as the top capsule.
Doxygen generated HTML for the TargetRTS C++ API is now included in the RTist in Code documentation and linked from the Target RunTime System chapter.
A first version of the Art Compiler is now ready and included in the RTist in Code extension. It is a command-line tool which can be used for building a transformation configuration and a set of Art files into a library or executable, in the same way as can be done from the UI. It makes it possible to automate your builds. Read more about the Art Compiler here.
A new TC property, "prerequisites", can now be used for expressing build dependencies between TCs. It is a list of references to other TCs (absolute or relative paths) that need to be built first, before the current TC is built. By setting a library TC as a prerequisite of an executable TC, the library will be built before the executable, and the executable will also automatically link with the library. This property is not yet supported by the form-based TC editor, but can be set in the .tcjs file.

0.0.6 (2023-03-09 18:28)

Java 17 is now required for running the Art language server. Using Java 17 instead of Java 11 gives some performance improvements and enables use of more modern Java. Information about which Java version that is used is printed in the Art Server output channel when the RTist in Code extension is activated.
The popup menu that appears when pressing Ctrl+Space in a diagram now contains commands for navigating to the other kinds of diagram for the same Art element. For example, in a state diagram for capsule "X" there are commands for opening the class or structure diagram of capsule "X".
It's now possible to open more than one diagram in one go. You can select multiple Art files in the Explorer, and then invoke a command for opening diagrams from the context menu. If a file contains multiple root Art elements, the diagram will be opened for the first one.
A diagnostic icon (error, warning or information) that is shown in a diagram now has a tooltip that shows the diagnostic message as well as a hyperlink to the documentation.
RTist in Code now provides a Walkthrough guide on the Welcome page. The Walkthrough guides new users to how to build and run a sample application.
Diagram properties set in the Properties view can now be restored to their default value by means of a "Restore default" trashcan button that appears for properties that have a non-default value. The presence of this button also helps to highlight those properties that have been set to a non-default value.
States, pseudo states and transitions can now be deleted by selecting them in a state diagram and pressing the Delete key. More than one such element can be deleted at the same time by using Ctrl+click for selecting multiple symbols or lines before pressing the Delete key.
The form-based TC editor now shows a TC property name as a hyperlink in case a value is set for that property in the .tcjs file. The hyperlink is useful for navigation and also helps to highlight which TC properties that have non-default values set.
The form-based TC editor now shows a trashcan button for properties that have a value set. The button can be used for deleting the value (i.e. to restore the default value of the property) and also helps to highlight which TC properties that have non-default values set.
The form-based TC editor now updates immediately when a TC property is modified in the .tcjs file. It's no longer necessary to save the .tcjs file for changes to be reflected.
Choices and junctions can now be created with Content Assist in the Art text editor inside a state machine and inside a composite state.
It's now possible to build a library, rather than an executable, from a TC. If the built TC has the topCapsule property set an executable will be built. Otherwise a library will be built.

0.0.5 (2023-01-26 06:59)

Common diagram commands can now be invoked using the keyboard by pressing Ctrl+Space and selecting the command in the popup menu that appears. The following commands are available: Zoom In, Zoom Out, Center, Expand All, Collapse All
The presence of internal transitions on a state is now shown by means of an icon on the state symbol in a state diagram. As before the internal transitions will be shown in the Properties view if such a state symbol is selected.
When navigating to an element in an Art file the text editor will now automatically scroll both vertically and horizontally (if necessary) to make sure the element becomes visible.
TC properties are now validated when edited (both textually and in the UI), and detected problems are reported. For example, it's validated that the specified top capsule exists and that the C++ language standard is set to a valid value.
Custom colors can now be specified for all elements in state diagrams (transitions, states and pseudo states). You can directly change the color from the diagram Properties view (i.e. it's no longer necessary to first navigate to the Art file and change the color there).
Code formatting and content assist was improved to make rt::properties sections foldable in the Art editor.
A new command "Fold All Properties" was added. It collapses all rt::properties sections in an Art file (similar to how "Fold All C++ Code" works for C++ code sections). It can be useful for Art files that contain lots of properties.
The entry and exit actions of a composite state can now be folded in the Art file, like other C++ code snippets. The command "Fold All C++ Code" will therefore be able to fold also these code snippets.
Code generation now supports entry and exit actions for states.
State diagrams now show diagnostics (errors, warnings and informations) using icons on symbols and lines. A new preference (rtistic.diagram.showDiagnostics) controls if they should be shown or not.
More information is now printed in the Art Build output channel during a build. For example, various useful messages emitted by the C++ code generator may now be printed there. Messages emitted by build tools, e.g. the C++ compiler, are still printed in the Terminal view. In case the build fails a hyperlink to open the Terminal will be present in the Art Build output channel.
A target configuration for the latest version of the GCC compiler (ver. 12) on Linux is now provided.

0.0.4 (2022-12-21 13:11)

A target configuration for the latest version of the MinGw compiler (ver. 12.2) is now provided.
Better support for Linux platform.
Improved makefile generation for incremental builds.
More information for internal transitions are now shown in the Properties view. The triggers of the internal transitions are shown in a similar way as in the Outline view. Also, the blue and yellow icons representing the effect and guard code snippets for the internal transitions are shown and can be double-clicked in order to navigate to the code snippets in the Art file.
If a port has multiplicity > 1 it is now shown in structure diagrams.
The form-based TC editor is now automatically refreshed when the underlying .tcjs file is modified and saved.
It's now possible to navigate to the top capsule from a TC file by Ctrl+click on the capsule name.
Content assist (Ctrl+space) is now supported for TC property values. Valid values appear in a popup when typing the = character. If there is not a fixed list of valid values, the expected value type (e.g. string) will be shown.
Cross-references now bind across workspace folders. This makes it possible to split an application into several workspace folders. For example, Art files built into a library can now be placed in its own folder, and be used from Art files outside that folder.
A composite state can now only be expanded if it contains at least one nested state. Previously the Expand button was shown also when the state only contained entry or exit points, which was misleading since expanding such a state didn't reveal anything new that could not already be seen.
Attempting to open a diagram using the Art editor context menu now works even when the cursor is not placed within an Art element that can be shown in the diagram. In this case a "quick pick" will appear where you can choose one of the elements that are present in the Art file. Hence, this behavior is now the same as when you open diagrams from the Explorer context menu.
Protocols now support the rt::header_preface and rt::header_ending code snippets. In particular rt::header_preface is useful for including header files with user-defined types used in the protocol.
A new output channel called Art Server is now available and can be seen in the Output view. It's used by the Art language server for printing diagnostic messages (usually internal errors), and can be useful for troubleshooting problems.
A new output channel called Art Build is now available and can be seen in the Output view. It's used when building a TC. For example, messages are printed when a build starts and finishes.
The editor title for diagrams now contain the name of the Art element. This makes it easier to work with multiple open diagrams at the same time.
Content assist now supports creating non-triggered transitions in a state machine.
Code generation now supports transition guards, events with parameters of predefined types, connectors between local port and inner structure.
It's now possible to set custom colors to be used in diagrams by means of a new color property. Currently this is supported for initial and triggered transitions.

0.0.3 (2022-11-23 12:53)

The graphical appearance of symbols in class diagrams has improved. Now a line separates the name from properties such as ports and events. Also, icons were added for the properties to make it easier to understand the diagram.
The Expand All/Collapse All commands in the Properties view now work also for structure diagrams. Cycles in the composition hierarchy are detected and reported with an error message if found.
It's now possible to build a TC using a context menu command Build. And if it produces an executable it's possible to launch it with another context menu command Run. Of course, it's still possible to manually build and run from the terminal.
The RTist in Code documentation was extended with several new topics and the landing page was improved.
New color themes for better syntax highlighting of Art files (and embedded C++ code) are now available. See this topic for more information.
It's now possible to edit TC properties using a form-based editor, as an alternative to directly editing the .tcjs file. The form-based editor is invoked from a context menu on the TC called Edit Properties (UI).
New TC properties are now supported for specifying which make command to use for building generated code, as well as the make arguments. The new properties are makeCommand and makeArguments.
The existing TC properties targetProject and targetServicesLibrary were renamed to targetFolder and targetRTSLocation respectively.
Fixed several Linux specific problems in the language server.
The GLSP library was uplifted to version 1.0. Read about the improvements it brings to diagrams here.
A problem with automatically expanding symbols when doing a Rename from a diagram was fixed.
When renaming an element, for which one or several diagrams have been opened, the diagrams stay open (previously they were automatically closed as a side-effect of the rename).
Navigation from a C++ code snippet to generated C++ code using the hyperlink in the code snippet tooltip now works even if the cursor is not placed inside the code snippet.
Target configurations for the latest version of the Visual Studio compiler (Visual Studio 2022, ver. 17) are now provided, both for 32 and 64 bit builds.

0.0.2 (2022-10-20)

First public release. Initial support for the Art language, graphical diagrams, transformation configurations and C++ code generation.