QM  6.1.2
Model-Based Design Tool
No Matches
Revision History

QM Compiler (qmc)QM™ License

Version 6.1.2, 2024-06-04

Fixed bug:

Version 6.1.1, 2024-01-10

This release adjusts the handling of text encodings that have changed between Qt5 and Qt6. Consequently, only the following encodings are supported for file-items in QM:

  • UTF-8
  • UTF-16
  • UTF-16BE
  • UTF-16LE
  • UTF-32
  • UTF-32BE
  • UTF-32LE
  • ISO-8859-1 (Latin-1)
  • System
Model files prepared with earlier versions of QM (before version 6.x) might use file encodings that are not longer supported. In that case, QM 6.x will apply the default encoding UTF-8.

Fixed bug:

Version 6.1.0, 2024-01-09

This release adds the XML Schema (qm.xsd) to the QM File XML Format

This release adds new XML element extern_package for encoding external packages. This change improves the XML data model. The change preserves backwards compatibility, so that external packages saved as the package data elements will still be read correctly. However, QM 6.1.0 will use the new extern_package for encoding external packages in the models.

Version 6.0.0, 2023-10-01

This milestone release migrates QM from Qt5 to the latest Qt6 (Qt 6.5.2 at this point). This QM version is a pure Qt6 application, without the "Qt5 compatibility layer".

In terms of functionality, this QM release 6.0.0 strives to be equivalent to the previous QM 5.3.0. The only significant changes are in the improved styling and the native dark/light theme support (as introduced in Qt6). Please also see: Light and Dark Color Schemes.


  • Windows: 64-bit Windows 10/11 (32-bit Windows no longer supported)
  • Linux: 64-bit Linux
  • macOS: not supported yet; support planned in the future.

Version 5.3.0, 2023-08-01

This release adapts QM code generator for the matching QP/C/C++ 7.3.0 release.

Code Generation:

  • The C code generator now generates C++ style comments in C. This matches the transition to C99 and MISRA-C:2012/2023, which accepts C++ style comments in C.
  • The C code generator applies the macros Q_HSM_UPCAST() and Q_MSM_UPCAST() in the transitions to history for QHsm and QMsm state machines, respectively.
  • The internal qpc and qpcpp models have been updated to reflect the new QP 7.3.0 class hierarchy with the QAsm base class.
  • Because of the dependencies on the new QP features and structure, the QM code generator now requires minimum QP version of 7.3.0.

Feature Requests:

Version 5.2.5, 2023-01-18

Fixed Bugs:

Version 5.2.4, 2023-01-04

Code Generation:

  • This release removes code generation for the QP-nano framework, which has been discontinued.
  • The generated code requires QP/C/C++ 7.0.0 or newer.
  • Comments for all conditionally declared attributes are now included inside the conditional compilation (after #if).

Fixed Bugs:

The full fix of bug#316 requires QP/C/C++ 7.2.0

Version 5.2.3, 2022-11-18

Code Generation:

Fixed Bugs:

Version 5.2.2, 2022-09-30

Code Generation:

  • extended the free operation model item to also support function templates in C++
  • removed spurious spaces generated in operations after the parameter list.

Version 5.2.1, 2022-07-31

Code Generation:

  • corrected handling of "namespaces" in C

Version 5.2.0, 2022-06-30

Code Generation:

  • added new "visibility==type" for free attributes and class attributes. This allows models to specify types (e.g., typedef ... in C and using xxx=... in C++)
  • added the $declare1 code generation directive for generating of non-recursive declarations (useful for packages)
  • removed the legacy "me->" pointer state machine implementation for C++
  • the comments are generated from documentation after the model link comments
  • the declaration comment is no longer used in the definition in case a definition comment is missing
  • added empty line right before every divider comment
  • operation parameters are generated one per line when the number of parameters is greater than 2. This is to avoid extra long lines exceeding the line limit of 80 characters.
  • corrected handling of nested namespaces
  • modified the top-level file comment and the licensing language.

Fixed Bugs:

User Interface:

  • Relaxed the order of items inside packages. Now, the items of different types (e.g., class, free-attribute, free-operation, etc.) can be rearranged in any order suitable for code generation.
  • Added support for the "block-indent" (TAB) and "block-unindent" (Shift-TAB) operations in the documentation editor (in property sheets).
  • The statechart property sheet no longer has "use me->" checkbox.
  • The C++ state machine implementation with the "me-> pointer" is considered now obsolete and has been removed from QM.


  • Updated the documentation for the introduced/changed elements
  • Updated styling of the documentation to the new "QL-awesome" look.

Version 5.1.4, 2022-04-30

Fixed Bugs:

Version 5.1.3, 2021-06-17

Corrections in Property Sheets:

This release corrects the property sheets for attributes (both class and free attributes), to remove "pseudocode" fields for "initializer". Similarly, the property sheets for operations have been corrected to remove the "pseudocode" for "operation".

Code Generation:

Additionally, this release adds code generation for "initializer" of static class attributes.

Preparation for Qt 6:

The internal code structure has been scrutinized for future migration to the new Qt6. Specifically some deprecated APIs have been replaced with the new, recommended versions.

Version 5.1.1, 2021-04-12

More Complete Documentation:

This release adds missing sections in the online and offline QM documentation. Specifically, the new sections in "Basic Modeling" include: "Class Operations", "Free Operations", "Explicit Constructor in C++", and "Working with Events".

Improved Icons:

Some icons have been improved to look better, especially with the "Dark Theme".

Version 5.1.0, 2020-11-01

Improved Out-of-Box Experience:

This release improves the "out-of-box experience" for first-time QM users by opening the New Mosdel Dialog Box when there are no "Recent Models" in the File Menu. This allows the first-time users to immediately create and work with a QM model based on the provided examples. The provided examples have been improved and now come with session files, so that a chosen QM model opens up immediately showing the diagrams and files. Also, the Manage Tools Dialog Box is populated, so that the generated code from the models can be immediately built directly from QM.

Implemented Feature Requests:

This feature request slightly changes the QM model file format by adding a new <documentation> element for statecharts. This meant the QM minor-version number needed to be incremented so that older versions of QM will reject the newer models (because older QM versions might not be able to parse the new models.)

Additional Enhancements:

Additionally, this release improves the vertical layout of property sheets with the collapsible "documentation" section. Also, some problems in registering and changing code-generation licenses have been fixed.

Version 5.0.4, 2020-09-10

This release adds back the QMC model compiler, for generating code from QM models in automated "headless" builds on servers without GUI libraries.

Additionally, this release adds class-prefix to the auto-generated dictionaries for submachine states in QP/C++. This prefix was already added for regular states in QM 5.0.3, but the submachines' states were not included in the change. Now, all auto-generated dictionaries should be consistent in having the class prefix.

Finally, this release on Windows switches to the newer Qt version 5.15.1 (LTS). (The QM releases on Linux and MacOS continue to use Qt 5.6.2.)

Fixed Bugs:

Version 5.0.3, 2020-08-14

This release changes the auto-generated dictionaries in QP/C++. Specifically, the function dictionaries for state handlers in C++ now contain the class-name prefix (e.g., Philo::thinking). This is to make the states unique within the application, which in turn helps in creating monitoring solutions with QView.

Fixed Bugs:

Version 5.0.2, 2020-07-17

Fixed bugs:

Version 5.0.1, 2020-04-22

Fixed Bugs:

Implemented Feature Requests:

Version 5.0.0, 2020-03-31

The main purpose of this release is to improve the support for high-resolution and high-DPI displays, such as 4K monitors. Specifically, this QM release brings a new, modern set of high-resolution icons.

Fixed Bugs:

Additionally, this release improves support for the modern C++ (C++11 and newer standards). Here, specifically, the operation property sheet now provides an additional field called "specifiers", which allows the modeler to add C++ function specifiers, such as: override, noexcept, const, =delete, =0, etc. The C++ code generator has also been updated such that declaration-only specifiers are removed in the definition of the C++ operation.

At the same time the "specifiers" field was added to the operation property sheet, the check boxes for "const" and "abstract" were removed. This is because both these properties can be now provided in the "specifiers" field as const and =0, respectively. (This is supported even in C for qpc and qpn frameworks, although only the const specifier has implications for code gradation in C.)

Version 4.6.0, 2019-12-30

Fixed Bugs:

Implemented Feature Requests:

Removed EMF (Enhanced Windows Metafile) diagram export in QM for Windows. This feature is superseded by SVG diagram export, which works on all platforms. Removed "copy diagram to clipboard" command.

Version 4.5.1, 2019-05-06

Fixed Bugs:

Version 4.5.0, 2019-03-30

This QM release matches the new state machine implementation style in QP/C++. Specifically, the models based on QP/C++ now can choose to generate code with the no me-> pointer style, where state-handler functions are true member functions of the state machine class. Because of this, they can conveniently and naturally access all members of their class via the implicit this pointer, and without the need to use the "me->" pointer.

The new feature is available for both QHsm-style and QMsm-style implementation strategies and is selectable via the Statechart Property Sheet:

This QM release 4.5.0 requires QP/C/C++/nano version 6.5.0 or newer. This is because QM 4.5.0 assumes the "no me-> pointer" state machine implementation style support from the QP frameworks.

Version 4.4.0, 2019-02-22

Fixed Bugs:

Implemented Feature Requests:

Version 4.3.1, 2018-09-10

Fixed bugs:

Added support for Python files in QM (recognized file type with syntax coloring).

Version 4.3.0, 2018-06-24

This release introduces several improvements to code generation.

Implemented Feature Requests:

Fixed Bugs:

For compatibility with the MISRA-C Rule 10.1, the generated code requires QP_VERSION to be defined as an unsigned constant (e.g, 633U), which is the case in QP 6.3.3 and higher.

The following example shows the code that is now generated:

/* Check for the minimum required QP version */
#if (QP_VERSION < 630U) || (QP_VERSION != ((QP_RELEASE^4294967295U) % 0x3E8U))
#error qpc version 6.3.0 or higher required

Version 4.2.1, 2018-05-20

This release partially implements the following feature:

"Partially" means that the QS_FUN_DICTIONARY() macros are generated for a given state machine in the top-most initial transition (if selected in the Statechart property sheet). The QS_SIG_DICTIONARY() macros are not generated at this point, because it might be repetitious (for signals shared with other state machines).

Additionally, this release improves the output from running external tools in that the output sent to stderr is shown in magenta to distinguish it from the output to stdout, which is shown in black.

Version 4.2.0, 2018-05-04

This release fixes several issues with submachines, especially when used in the Spy build configuration.

Fixed Bugs:

The fix for bug#213 required changes in the QP/C/C++ code. Therefore, this version of QM requires QP/C/C++ 6.3.0 or newer.

Also, this release adds an additional check in code generators for QP/C (qpc) and QP/C++ (qpcpp) for eXit-Point Segments. Specifically, any choice segments attached to an eXit-Point Segment must be complementary, meaning that you must use the else guard to complement any other choices attached to the end of an eXit-Point Segment. A non-complementary set of choice segments results in the code generation ERROR C113 "exit-point with non-complementary guards".

Implemented Feature Requests:

This means that qm called from command-line will return non-zero code when code generation fails (-c option) or when diagram generation fails (-d option).

Finally, this release removes the extra new-lines from the log output for external tools. Specifically, the output for long-running tools (e.g., avrdude), which update the log frequently to report progress no longer contains superfluous new-lines.

Version 4.1.2, 2018-03-05

Implemented Feature Requests:

Specifically, the QM application has been re-architectured to support the console-mode, in which it does not launch the GUI but instead it processes the command-line arguments, prints the results to the console and exits. The following command-line options have been added:

  • -h prints help to the console and exits
  • -c [item] generates code for the given model [item] and exits
  • -d [item][.png|.emf] generates diagram from the given model [item] and exits
The qmc command-line utility is still provided for background compatibility, but it will be phased out in the future as the qm application now supports code generation in command-line mode.

Version 4.1.1, 2018-01-10

Fixed Bugs:

Version 4.1.0, 2017-11-10

Implemented Feature Requests:

This frequently requested feature allows developers to designate files as external files and to edit such files with an editor/IDE of choice. Still such external files participate in the code generation process.

Second, this release fixes bugs still found in the sub-machine support. Specifically, this release fixes bugs in transitions out of eXit-Point Segments (to Entry-Points and to History):

Fixed Bugs:

Additionally, this release disallows attaching History connectors to sub-states nested within a sub-machine. (Sub-machines support History only on the boundary, but not inside sub-machines). This is a resolution of the bug#187:

Finally, version 4.1.0a fixes the bug#192:

This QM release 4.1.0 requires QP/C/C++/nano version 6.0.1 or newer. This is because QM 4.1.0 assumes the modified QMsm-state machine implementation strategy in order to properly handle the various transitions out of eXit-Points in sub-machine states

Version 4.0.3, 2017-05-30

This release fixes the following bug:

  • bug#173 Exiting submachine state through an eXit-Point Segment fails to execute exit action from submachine

Also, this release implements the following feature request:

  • feature#122 Code generation from External QM Packages should be relative to the Package File

Version 4.0.2, 2017-05-26

This release fixes the following bugs:

  • bug#168 Submachine with substates nested deeper than 2 levels generates code that does not compile
  • bug#170 Incorrect behavior for an eXit Point with a Choice Segment in a sub-machine
  • bug#172 Resizing a submachine state causes misalignment of eXit Point Segments
bug#172 was introduced in QM 4.0.1 in the process of fixing bug#164 "Self-transitions become zero-sized during resizing". The adapted solution for bug#172 was to remove the fix for bug#164, which means that self-transition can become zero-size when a state is squeezed in size. Such zero-size self-transitions can still be selected from the Model Explorer and after this the attachment points can be dragged out, so that it is indeed possible to recover such transitions.

Additionally, this release implements the following feature requests:

  • feature#124 Initial transitions should be able to target Entry Points in submachine states

Version 4.0.1, 2017-04-05

This release fixes the following bugs:

#164 "Self-transitions become zero-sized during resizing" ( https://sourceforge.net/p/qpc/bugs/164/ )

#165 "Exit point segment displays action code rather than pseudocode" ( https://sourceforge.net/p/qpc/bugs/165/ )

#161 "Assertion failed in QM version 4.0.0, module propsheet:367" ( https://sourceforge.net/p/qpc/bugs/161/ )

Specifically for Bug#164, the policy of resizing states has changed. Previously, QM allowed making states smaller, even if some attachment points for transitions needed to be moved along the edges of the state. Now, QM will not allow a state to get smaller, if this would require shifting any attachment points along the edges. The user must first move the attachment point explicitly.

Version 4.0.0, 2016-12-07

This milestone release introduces reusable Submachine Diagrams and Submachine States along with all the necessary "plumbing gear", as specified in the UML. These mechanisms are important, because they allow you to capture any common behavior of composite states as "submachines", and subsequent reuse by instantiating them possibly multiple times in the context of a single state machine. The implementation of this feature is quite elaborate and practically doubles the number of state machine elements that QM must support. The following elements have been added:

The Submachine Diagrams and Submachine States are only supported in the QMsm-style state machine implementation strategy and require QP/C or QP/C++ 5.8.0 or later.

Additionally, the History Transition was extended to also work for Submachines.

Additionally, QM 4.0.0 adds the following new features and improvements:

  • Added option to specify relative path name to license file (feature request #108). The chosen setting for this option is stored in the session file associated with the model.
  • Added option to save model links as comments inside XML model files (selectable in model property sheet, option "save links"). This feature can be very helpful to quickly locate model elements (by copying the adjacent XML comment and pasting them into QM as "Paste Link" F5)
  • Added Shallow History option so that both Shallow and Deep History transitions are now supported
  • Added styling options in QM Style Sheet for selected items in Model Explorer and Search
  • Fixed text-sizing problems in diagrams on hi-resolution displays. The QM Style Sheet now accepts diagram fonts specified in pixels. The pixel-sized fonts work also correctly in exporting diagrams to EMF vector format.
  • Fixed bugs in exporting diagrams to EMF (Windows only)
  • Improved the "External Tools" feature (specifically, the "working directory" for the tool is now applied correctly)
  • Added option to store the QM License certificate relative to model file (stored in the model file) or absolute (stored in the session file). This option is selectable with a checkbox added to the "Code Generation License" dialog box.
  • Refactored several features to improve consistency and stability (failures due to hitting internal assertions).
  • Updated the internal models of QP frameworks (qpc, qpcpp and qpn) to reflect the class structure for QP 5.8.0.
    NOTE: The QFsm base class is no longer present in the internal QP models. Consequently older QM 3.x models that reference the QFsm superclass will cause error Corrupted references in the model file
  • Upgraded to Qt 5.6.2
  • Added QM for 32-bit Windows that runs on 64-bit Windows as well.
  • Changed code generation policy for the QMsm-style state machine implementation strategy, which now requires QM license certificate.
Starting from this version, a valid QM license certificate is required to generate code with the QMsm-style state machine implementation strategy. Evaluation licenses are included in QP/C and QP/C++ 5.8.0. Extensions of these evaluation licenses will be granted liberally after filling out the no-obligation License Request Form.

Version 3.3.0, 2015-05-15

This QM release updates the internal models of the QP frameworks to match the recent QP 5.4.x. Specific changes include:

  1. Updated class hierarchy such that QMActive is the superclass of QActive.
  2. The QFsm class and state machine implementation strategy is now deprecated. Any existing models that use QFsm will still load correctly, but the code generated will be in QHsm-style.

Implemented the following feature requests:

#93 "Display full path of recent projects in File menu". QM 3.3.0 adds the "Recent Model" sub-menu to the File menu. This "Recent Models" sub-menu contains a list of up to 16 most recently used models with full paths. Also, the "Recent Models" list can be cleared by the "Clear Menu" action.

#101 "extend Conditional Compilation to class attributes". In fact, QM 3.3.0 recognizes conditional compilation for attributes (class attributes and free attributes) as well as for operations (class operations and free operations).

Finally, this version moves the location of the QM online help to:


Version 3.2.2, 2014-10-16

This QM release fixes the following bugs:

#108 "Corrupted references reported in models with long class names"

Version 3.2.1, 2014-10-09

This release implements the feature request #100 "Conditional compilation for state machine elements" (see https://sourceforge.net/p/qpc/feature-requests/100/ ) The feature description and usage are available in the QM Help at the following URL:


This release also improves generation of the comments with model links (to navigate from the code to the model). The links now consistently use abbreviated names (significant to 16 first characters).

Finally, this QM release fixes the following bugs:

#107 "multiline guard conditions indented incorrectly" ( https://sourceforge.net/p/qpc/bugs/107/ )

#100 "QM 3.1.3 multiple sigs on one transition no longer generates compilable code" ( https://sourceforge.net/p/qpc/bugs/100/ )

#99 "Pastelink function does not work" ( https://sourceforge.net/p/qpc/bugs/99/ )

#84 "Export to EMF bug" ( https://sourceforge.net/p/qpc/bugs/84/ )

#69 Search can lose pending changes ( https://sourceforge.net/p/qpc/bugs/69/ )

Version 3.2.0, 2014-08-02

This release is only for 64-bit desktop operating systems, such as Windows 7/8 64-bit, Linux 64-bit, and Mac OS X 64-bit.

Moving forward, the QM tool will be offered only on the 64-bit desktop operating systems and the 32-bit operating systems will no longer be supported.

Also, this release switches from using Qt4 to the latest Qt5 toolkit.

The Qt5 toolkit is now used under the terms of the LGPL 2.1 license, where previously the Qt4 toolkit was used under a commercial Nokia license.

For compliance with LGPL 2.1, the QM distributions contain the LGPL Compliance Package, which provides information on how to obtain, install, and build the Qt toolkit from sources.

Version 3.1.3, 2014-04-30

This release fixes the following bugs, all related to the history connector (see https://sourceforge.net/p/qpc/bugs):

#95 "Resizing of state with history generates "Assertion failed" error."

#96 "Incoming transitions to a history connector stretch incorrectly when the state is moved"

#97 "Newly added history connector not moving when the state is resized."

This release does not change the QM code generation in any way.

Version 3.1.3, 2014-04-25

This release fixes the following bugs (see https://sourceforge.net/p/qpc/bugs):

#93 "CATCH_ALL: code for action is generated twice"

#94 "Transition to history from a choice segment generates incorrect code"

Also, this release changes the C++ code generation for QP/C++. Only short names, not qualified by the class name, are used inside the state-handler functions and action-state tables. For example Q_TRAN(&state1) is used instead of Q_TRAN(&Foo::state1).

Version 3.1.1, 2014-04-15

This release fixes the inconsistency in copying model links into the clipboard (bug #92). The model links are now generated in the format ${name::name::name}, which is the same as links inserted into the generated code.

Also, this removes the decoration of the names of superclasses displayed in the Class Property Sheet. The superclass names were displayed in the combo box in the form ${name::name::name}, whereas they should be shown as name::name::name.

Version 3.1.0, 2014-03-31

This release adds the "transition to history" (deep history) to QHsm and QMsm state machine classes and their subclasses, such as QActive and QMActive.

To build the code generated for the "transition to history" feature in QM 3.1.0, you need QP 5.3.0 or newer.
QM 3.1.0 remains backwards compatible with models generated by the earlier QM versions (2.x) for QP 4.x, but you need to re-generate the code to build it for the QP 5.3.0 frameworks.

The "transition to history" feature is implemented by adding a new "transition to history" icon to the state diagram drawing toolbar. This new connector can be added to states, but it binds only to the border of a state, as opposed to the interior of a state. This is intentional to make transitions to history also available to submachine states, which will be supported in the future.

Once the "transition to history" connector is attached to a state border, its other end with an arrow needs to point to a substate, which will be the initial value of the state history, before the state is visited and the actual history is recorded. The 'H' circle of the "transition to history" connector can be a target for regular transitions and for choice segments. There can be only one "transition to history" connector attached to a given state.

For each "transition to history" connector, the code generator in QM generates a history attribute in the state machine. This history attribute is set in the exit action of the corresponding state to store the history of the composite state.

This release also brings several improvements to the QM code generator. First, the model reference comments are now generated for user-specified names rather than for the internal model references. This makes the references human-readable, but more importantly, the references don't change after adding/deleting/reordering model elements. This prevents many instances of re-generating code where only the references in the comments changed, while in fact the actual code was the same.

Other improvements to the code generator include removal of unused tags in declarations of structures. This is to achieve compliance with the new MISRA-C:2012 Rule 2.4.

Also, the code generator now detects unused 'me' arguments, and generates code "(void)me;" to prevent compiler warnings about unused arguments.

This release makes slight improvements in the rendering of diagrams. The border of selected diagram items (e.g., states, transitions, etc.) is now thinner (2 pixels) as opposed to heavy-looking 3 pixels before. Also, to save precious space, the entry/exit labels for state actions have been abbreviated to e/x.

This release fixes the following bugs (see https://sourceforge.net/p/qpc/bugs/):

#88 "Problem with QM model encoding"

#87 "QM 3.0.1 crashes with Assert after undo"

#84 "Export to EMF bug"

#70 "Property change not sensed as pending change"

#67 "Constructor code not always generated"

Finally, this release implements the following feature requests (see https://sourceforge.net/p/qpc/feature-requests/):

#17 "Deep history feature support"

#67 "Implement history pattern in QM"

#61 "Compiler rises warning when modeling a transition to history"

#90 "Enlarge default transition text box": the initial size of the transition box has been increased from 6 to 10 grid units.

Version 3.0.1, 2014-01-07

This release fixes a bug in generating the default case in state machines based on QFsm. Also the code generation for the special case of the CATCH_ALL trigger for QHsm/QFsm has been improved.

Version 3.0.0, 2014-01-01

The main purpose of this milestone release is the new code generation for the new state machine implementation added in QP5. This new type of state machine implementation in QP5 is based on the new QMsm class, which takes advantage of the QM tool as an advanced "state machine compiler". QM can perform optimizations that were not possible with the C pre-processor alone. Specifically, the QM can easily determine the LCA (Least-Common-Ancestor) state for every transition and it can generate the complete transition-action-tables (sequences of exit/entry/initial actions) at code-generation time. The resulting code is still highly human-readable, but it is no longer human-maintainable, because generating transition-action-tables by humans is too error-prone. The lab tests indicate that the new "housekeeping" code for executing hierarchical state machines is about twice as fast as the code based on the QHsm class. Additionally, the new code requires less run-time support (smaller event processor) and uses 70% less stack space in the call to the QMsm::dispatch() operation than QHsm::dispatch().

This release also fixes several bugs related to the Cut-and-Paste feature, saving the model with the shortcut Ctrl-S, and editing the actions while searching the model.

QM 3.0.0 remains backwards compatible with models generated by the earlier QM versions (2.x) for QP 4.x. In other words, you don't necessarily need to upgrade to QP5 to use QM 3.x, but you won't be able to use the QMsm and QMActive base classes, as they are not provided in QP 4.x.

Version 2.3.2, 2013-05-20

This is a quick update release to fix the bug introduced in 2.3.1, which caused a crash when adding a class item to a package. Additionally, this release brings the following minor improvements:

  1. The TAB key in the code editor does not always indent the line. When no selection is present, a TAB key inserts 4 spaces at the cursor position instead of indenting the whole line.
  2. The log has a new option to clear the log via the "Clear All" popup menu. The log is also cleared when (re)opening a new model file.
  3. Fixes for an occasional inconsistency in the "Replace Mode" option setting and the state of the Search Options button.

Version 2.3.1, 2013-05-16

This is a quick update release that fixes the following problems found in 2.3.0:

  1. The copy/paste feature didn't reliably detect the element type in the Clipboard. The formatting of the Clipboard MIME data has been slightly changed, which fixed the problem.
  2. The code generation and external tools actions were not properly enabled after creating a new model.
  3. The window title of a state diagram didn't change after changing the class name.
  4. The CATCH_ALL trigger was not implemented for FSMs.

Thank you to all reviewers who immediately contacted Quantum Leaps. This is "massive parallel testing" at its best!

Version 2.3.0, 2013-05-15

This release introduces a number of features and fixes most of the reported bugs in QM (see feature requests and bug reports on sourceforge.net/p/qpc/_list/tickets ).

QM 2.3.0 remains compatible with models generated by the earlier QM versions (2.x).

New GUI Features:

  1. Model-wide search and replace (feature request #49). The QM GUI now includes a search dock-widget with a search box and model tree-view similar to the Model Explorer. The tree-view allows the user to select the model element for search, which can be recursive. A number of usual search options are provided, such as case-sensitivity, match whole word, etc. The search elements can be finely controlled by provided options, e.g., search in names, code, pseudocode (abbreviations), documentation, etc. The replace feature allows the user to replace strings one at a time, or replace all in the given model element. Just like the search, replace can be recursive.
  2. Storing/restoring the current QM session (feature request #41). QM now stores the current session, including the open windows and their arrangement, external tool settings, locked items, etc. The session is associated with a given model and is stored in this model's directory. The session is restored when this model is (re)opened.
  3. License management for QM code generator. QM now displays the license information of the underlying QP framework, which is licensed separately either under the GPL open source license, or commercially. The QP license information is now also embedded in the generated code. This feature is designed to educate and inform about open source licensing obligations without being intrusive. The feature also offers a commercial QP license registration to all commercial QP licensees.
  4. Fine-granularity locking/unlocking model items (feature requests #56/#52). QM now allows you to lock individual packages, directories, and files from editing, whereas previously you could lock only the entire model. This version also fixes a number of "holes" in the protection of the locked items.
  5. Improved MDI (multiple document interface), which now supports movable tabs (feature request #5). Also, the window-state (normal/maximized) is now independent of the use of tabs. For example, you can have tabs and normal re-sizable windows at the same time.
  6. Added new grid options for diagrams and added grid selection button to the View toolbar. The grid can be displayed as fine-dot fine-line, and dot-line. This feature helps in aligning states/transitions and indirectly addresses feature request #35.
  7. Added listing of triggers for states. The feature is available in the popup-menu for state items. QM performs the non-trivial analysis of triggers with guards, and lists triggers that can "bubble up" to higher level states.
  8. Added toolbar buttons to quickly hide/show all dock-panels of the GUI, such as Property Editor, Bird's Eye View, Log, etc. (feature request #39).
  9. Added exporting diagrams to the .png raster format for all platforms. The EMF vector format (Enhanced Windows Meta-File) is available only on Windows.
  10. Improved importing/exporting packages to external files. Now, the extension .qmp (QM Package) is enforced and any non-existing directories for exporting package files are created correctly.
  11. Added read-only protection to the model files and package files.
  12. Improved the status bar display of current (x,y) cursor position in the diagram. Allowed negative (x,y) values.
  13. Improved the status bar display of the current (Line/Column) cursor position in the file(s). The column position starts with 1, consistently with other editors.

New QM Code Editor Features:

  1. Added Quick search in the current editor (F3-search), which is independent of model-wide search (but is integrated with the search view). The quick F3-search can be initiated by selecting text and pressing Ctrl-F3. Next, you can search forward (F3) or backward (Shift-F3).
  2. Improved code indenting/un-indenting with TAB/Shft-TAB.
  3. Added brace/parenthesis matching (brace "kiss") with Ctrl+K
  4. Added "delete till end-of-line" with Ctrl+Del
  5. Added new file type and syntax highlighter for TCL/TK scripts (extension .tcl)
  6. Improved syntax highlighter for C/C++ by adding all missing keywords.

New Code Generation Features:

  1. Added generation of comments from QM documentation properties (feature requests #26/#23/#24/#37). The documentation for states, operations, and attributes can contain embedded comments, which are emitted to the generated source code (separate comments can be applied to declarations and definitions). This allows users to generate doxygen-type comments for automatic generation of HTML documentation. Also users can generate "comment boxes" for compliance with their coding standards.
  2. Changed the local variable returned from states from 'status' to 'status_' to avoid name conflicts with user-defined variables.
  3. Introduced the special CATCH_ALL trigger to catch processing of all events in a given state (feature requested from a commercial customer). This feature is NOT generally recommended.
  4. Improved code generation and fixed inconsistent "static" linking for file-scope functions and attributes. Added missing new-lines in several cases (bugs #34/#40).

New External Tools Features

  1. Added environment variables for the external tools. For example, you can modify the PATH variable locally or specify any variable consistently for all tools. The environment variables can be also used in the arguments of external tools and are substituted before invocation of the external tool. Fixed problems with parameters surrounded by double quotes (bug #50). The output from external tools to the QM Log has been improved, so that the output is identical as it would be on a console. Finally, external tools can also be detached from the QM GUI, which can be useful for launching external serial terminals, QSPY, or other such tools.

Other Bug Fixes:

  1. Added toolbar buttons for moving model items up and down in the Explorer (bugs #36/#37/#45/#47, feature request #54). This fixes the problems with the shortcuts for these commands (Ctrl+UP/Ctrl+DOWN) and allows re-arranging the order quickly and easily.
  2. Fixed the problem with copy/paste statechart items (bugs #53/#57).
  3. Fixed problems with Property Editor switching current item when losing keyboard focus to other applications (bug #38). Now switching between applications on your desktop no longer changes the current item when you get back to QM.

Version 2.2.03, 2012-09-10

This release fixes two bugs introduced in 2.2.02 and brings a few improvements to the code generation.

  1. Restored saving the model before generating code, which was not happening in version 2.2.02.
  2. Fixed the bug #34 (inconsistent linkage error), in which a free operation with 'file' visibility had a declaration without 'static' and definition with the 'static' keyword. The fix for this bug also improves the consistency of checking whether an item is declared and defined in the same file scope (so that 'static' can be generated automatically).
  3. Fixed the bug #35 (assertion in QM 2.2.02, module statesheet:140), which fired after editing the exit abbreviation in the state property sheet.
  4. Added code generation for packages. A package item in the Explorer window now has the "Generate Code" option in the popup-menu and a package item can be specified in the code generating directives $declare and $define.
  5. Added 5th external tool to the Tools menu with the keyboard shortcut F12, so now the Tools menu uses the following shortcuts: F7 for code generation and F8-F12 for tool1-tool5, respectively.

Version 2.2.02, 2012-09-02

The main focus of this release is the External Tools feature, which allows users to execute their own command-line tools, such as make, lint, qspy, etc. directly from the QM IDE. This release also fixes all known bugs and implements a few feature requests. The detailed changes are as follows:

  1. Implemented the new Tools menu and customizable toolbar. Please refer to the QM help file https://www.state-machine.com/qm/ui_tools-dlg.html for the description of how to use the new feature.
  2. Implemented block-indenting of code with the TAB key and un-indenting with Shift+TAB.
  3. Moved the "Generate Code" action from the File menu/toolbar to the Tools menu/toolbar.
  4. Fixed bug #29 (assertion when dragging a component and dropping it on itself).
  5. Fixed other drag-and-drop issues.
  6. Added documentation panel to the state item (feature request #37) and generation of the doxygen comment from this documentation.
  7. Fixed the problem with black diagram background in the EMF export (feature request #36).
  8. Added keyboard shortcuts to hide/show docking windows (Property Editor, Explorer, Log, Bird's Eye View) for feature request #39.
  9. Code Generation: raised the state nesting limit to 10 (including the top state) and the choice segment nesting limit to 10.
  10. Improved the precision of syntax highlighting for pre-processor symbols and for C/C++ keywords.

Version 2.2.01, 2012-08-14

This minor release fixes bug #33 (assertion in module item, line 383), which popped up when new attribute or operation was added to a package.

Version 2.2.00, 2012-08-06

The main focus of this release is MISRA compliance of the generated code. This release also brings several feature improvements, new features, and bug fixes. This release also removes the separate project examples that used to ship with QM. This release is compatible with QP 4.5.02 or later, all of which include QM models in the example projects. The detailed changes are as follows:

Code Generation:

  • Changed code generators for QP/C, QP/C++, and QP-nano to use the MISRA switch statement syntax rather than "return" statements in each case.
  • Changed code generators for QP/C and QP-nano to generate "static" class methods if the class declaration and definition is made in the same file scope (MISRA-C:2004 Rule 8.11-required).
  • Changed code generators for QP/C and QP-nano to use "ClassType - const me" instead of just "ClassType * me" for class methods, including state handlers.
  • Updated all internal QP models to QP 4.5.xx (e.g., use QEvt instead of QEvent, etc.)
  • Changed code generators for QP/C, QP/C++, and QP-nano to use QEvt instead of QEvent for state machines.
For backwards-compatibility, the base class name "QEvent" is recognized and replaced with "QEvt".
  • Changed code generator for QP/C++ to generate the QP namespace prefix for all QP elements (e.g., QP::QEvt, QP::QState, etc.), which is required by MISRA-C++:2008.
  • Added code generation errors for too many levels of state nesting (greater than 6) and choice-segment nesting (greater than 5).

Explorer View:

  • Eliminated the file-system item and replaced it with directory item.
  • Allowed Directory items in Package items, so that directories and files can be exported to external packages.
  • Removed the little toolbar from the top of the Explorer View and added the "Move Up" and "Move Down" actions to the pop-up menus for items.

Property Sheets:

  • Added "namespace" attribute to the Package property sheet. Using namespaces is required for MISRA-C++:2008 compliance (feature request #3527678).
  • Added abbreviation to the Choice-segment guard specification (feature request #3527678).
  • Added property sheets for Framework, Directory, and File items.
  • Added "encoding" property to the File item property sheet.


  • Allowed the diagram viewport to expand to enclose all items, including items moved outside the drawing canvas above the top edge or left of the left-edge.
  • Changed the default position for pasting state shapes to the diagram to be outside the drawing canvas (just right of the right edge of the canvas.) This was done to reduce the interference of the pasted state shapes with already existing states.

Bug fixes:

  • Bug # 3505266: Fixed the bug with copying-and-pasting classes, which disconnected all transitions in the statechart of the pasted class.
The copy-and-paste feature has been re-designed for this release.
  • Bug # 3447488: Fixed occasional QM crash after clicking "File|Close Model" menu.
  • Bug # 3472949: Fixed the problem of drag-and-dropping a component onto its child.
  • Bug # 3553912: Fixed the incorrect handling of the Ctrl+W shortcut (close window) in the Tabbed mode. Now, the shortcut Ctrl+W is implemented explicitly (whereas before it was showing as Ctrl+F4).


  • Added wait cursor when loading/re-loading the model file.
  • Added drag-and-drop for directories into packages.

Version 2.1.02, 2011-12-28

  • Fixed a problem with the keyboard focus being removed from the Property Editor when the mouse pointer is moved over a diagram. Now editing text properties can continue regardless of the position of the mouse pointer.
  • Modified the behavior of the main window to eliminate annoying context switches when the user moves the keyboard focus to another desktop application. Now the Bird's Eye View, the Toolbox, and the Property Editor will not be deactivated when the user clicks outside the QM application.
  • Added menu command and toolbar button for copying model links to the Clipboard. This is useful for quickly finding the corresponding model elements in the generated code (through the standard text find feature available in virtually all code editors and IDEs).
  • Changed code generation to consistently generate the @()-style model links to match the copy-link feature.
  • Fixed the bug with model name not appearing in the Model Explorer when a new model is first created.
  • Fixed the unexpected switching of the Current Model Item when the user double-clicked text or code in the Property Editor.
  • Improved model checking to disallow creating circular dependencies of choice segments, which was possible when the begin of the parent choice segment was moved to the free-end of a child choice segment.
  • Changed displaying text in the diagrams to show only complete lines rather than cutting the text horizontally and showing only top slice of the last line.
  • Added the standard file extension ".ino" for the Arduino sketches, to recognize this file type and apply the correct (C++) syntax highlighting. The extension ".ino" has been added in the latest release of the Arduino IDE (Arduino 1.0).

Version 2.1.01, 2011-11-04

  • This release allows specifying comma-separated trigger lists for transitions as opposed to just single triggers. The code generator converts the trigger list into fall-through case statements.
  • Updated all examples for compatibility with QP 4.3.00.
  • Fixed a bug which caused a crash when a model file failed to open (due to version incompatibility or a missing imported package) and the user would double-click on the Log message to inspect the failure cause.
  • Fixed a bug causing assertion on Mac OS X in module nodeglyph, line 289.

Version 2.1.00, 2011-10-20

  • This release provides support for breaking up model files into separate package files, which can be imported (included) in any number of models. This feature allows teams to work on different parts of a large model by breaking it up into independently managed and version-controlled packages.
  • Fixed the inconsistency between reading and writing the file items, which for empty files led to "WARNING F802> ...parsing the model template file failed". Specifically, this warning occurred for the model templates provided in the QM distribution.
  • Fixed a bug in resizing the diagram canvas, which could lead to breaking an assertion on Mac OS X (when the mouse cursor would momentarily leave and re-enter the diagram area).
  • Fixed the inconsistency in enabling and disabling of copy/cut/paste/delete actions, which could lead to breaking an assertion in explorerview, line 321.

Version 2.0.00, 2011-09-21

  • This release provides support for Cut/Copy/Paste of model items within one model and across different models opened in separate instances of QM.
  • The model file format has changed compared to QM 1.x (to reuse the model serialization for Cut/Copy/Paste). This means that models created with QM 1.x are incompatible with QM 2.x.

    the <qm>/bin/ directory contains the utility qmconv-1-2 for converting models created with QM 1.x to QM 2.x.
  • Added panning of the current viewport to the Bird's Eye View.
  • Added Cut/Copy/Paste/Delete actions to the popup menus inside the Model Explorer.
  • Fixed several bugs and inconsistencies.

Version 1.1.08, 2011-08-11

  • This release is the first one available for all three platforms: Windows, Linux, and Mac OS X.
  • The directory structure of the QM installation has been modified to accommodate Mac OS X and to make it common for all platforms.
  • Changed the behavior of the "Generate Code" command to save the model to disk before generating code.
  • Changed the keys for panning and zooming of diagrams with the mouse to make it consistent with popular programs such as GIMP or Google Maps (bug #3381122). Now SHIFT activates panning and horizontal scrolling with the mouse wheel. When SHIFT is depressed, rotating the mouse wheel towards the back of the mouse will scroll horizontally right (i.e., the horizontal scroll bar will move right). This is exactly as in GIMP. CTRL activates selecting and zooming with the mouse wheel. When CTRL is depressed, rotating the mouse wheel towards the back of the mouse will zoom out.
  • Fixed a problem with C-style comments at the end of a file (bug #3355437).
  • Fixed the problem with print crashing QM on Linux (bug #3325130).
  • Added drag-and-drop of model elements inside the Model Explorer. Now you can drag packages, classes, attributes, operations, and parameters as well as directories and files (feature request #3116849). The drag-and drop feature verifies the types of the elements and allows only meaningful operations, for example, dragging a class operation to another class, but not allowing dragging a state to a directory.
  • Added drag-and-drop of model elements from the Model Explorer to files. This allows quick generation of code directives without manually typing the element paths.
  • Added drag-and-drop of model files from the File Explorer (File Finder on the Mac) to the QM main window, to open the model file.
  • Added "Close Model" command to the File menu.

Version 1.1.07, 2011-06-23

  • Fixed a bug causing a crash for the sequence: open an existing model, create new model, checking class properties.
  • Modified code generation to include generating Doxygen comments from the documentation for classes, class attributes, class operations, free attributes, and free operations.
  • Fixed a bug related to incorrect updating of free attribute documentation from the property sheet.
  • Added collapse/expand button for documentation box in the operation property sheet. This is to allow more space for the code box.
  • Added toggle buttons to the View toolbar to allow easily toggling the view of the docking windows (Explorer, Property Editor, Bird's Eye View, and the Log).
  • Improved/corrected the locked/unlocked button behavior and added the locked/unlocked status to the status bar.
  • Improved/corrected the Grid view button behavior and added grid status to the status bar.
  • Updated ARM Cortex examples for EK-LM3S811 to use the latest IAR EWARM 6.20.

Version 1.1.06, 2011-04-27

  • This release adds the "locked" mode for exploring or reviewing the model without the risk of inadvertently modifying the model.
  • Fixed the EMF (Enhanced Windows Metafile) generation issue with the bounding box. When shapes in a diagram are selected, only the selected shapes are rendered to EMF and the bounding box is adjusted so that it contains only the selected shapes. Previously, the EMF bounding box was always the size of the diagram canvas, regardless if only a tiny fragment of the diagram was selected and rendered to EMF.
  • Fixed a bug with keyboard focus, in which occasionally a diagram would ignore the Ctrl or Shift keys (for going into Selecting and Panning modes, respectively).
  • Added the Show/Hide Grid menu option and toolbar button.

Version 1.1.05, 2011-04-22

  • This release changes the permissions of the generated files to READ-ONLY, to prevent users from editing these files. This is to reinforce the policy that all changes really need to be made to the QM MODELS, not the generated files.
  • Fixed a bug in creating new models which led to code generation errors: "ERROR F031 state machine not allowed in this class"
  • Fixed an EMF (Enhanced Windows Metafile) generation bug in which all single ampersands ('&') were dropped and double ampersands ('&&') were replaced with a single ampersand.
  • Fixed a problem with closing a minimized window which would lead to problems in opening the window again.
  • Fixed a problem of not adding newly created models to the list of most-recently used models.
  • Improved error message reporting from XML parsing of the model file.
  • Added Help button to the "New Model" dialog box.
  • Added .pde file stereotype for Arduino sketches

Version 1.1.04, 2011-03-18

  • This release adds the QMC (QP Model Compiler) command line utility for automated builds.
  • Several minor improvements and bug fixes related to abrupt interrupting the QM session by popus (such as system update notifications).

Version 1.1.03, 2011-03-02

  • This release includes examples of QM models and projects for Windows, Linux, and ARM Cortex.
  • The default locations of the help and model templates have been modified.

Version 1.1.02, 2011-01-05

  • Made the code compatible with the Linux build (this is the first QM version offered for Windows and Linux).
  • Added the View|Styles menu.

Version 1.1.01, 2011-01-01

  • Fixed internal framework models of QP/C++ and QP-nano to correctly inherit QActive from QHsm.
  • Fixed a bug in the MDI (multiple document interface) related to deleting a item with an active open MDI window (such as file item or statechart item).

Version 1.1.00, 2010-12-30

  • Added consistent support for Unicode, from the model file through all model elements, to generated code. Now, you can use Unicode characters (e.g., Chinese, Japanese, etc.) in your documentation and code (e.g., comments) and they will be preserved and propagated to the generated code.
  • Added options for specifying text encoding for the generated code and the model file explicitly for most encodings used in the world.
  • Added customizability of look and feel via a style sheet (file qm.qss, stored in the QM directory). Now you can customize fonts and colors of editors and diagrams.
  • Improved log file by adding double-click functionality for quickly selecting model elements corresponding to errors or warnings. Now you can double-click on any warning or error and the related item gets highlighted.
  • Added similar double-click functionality to documentation. This allows you to build hyper-links for cross-referencing items within the model.
  • Added documentation entry in property sheets to several model items, such as model, class attribute, class operation, free attribute, free operation.
  • Changed the way of storing documentation in the model file from HTML to plain text.
  • Added tons of documentation for the QP framework models. Now, when you expand the QP framework model item, you can find detailed documentation and code examples for all classes, operations, and macros provided in the QP frameworks.
  • Added support for QFsm (flat, not-hierarchical state machines), including code generation for classes derived from QFsm.
  • Improved selecting of diagram items (with Ctrl key) and panning of diagrams (with Shift key).
  • Fixed bug related to moving complex selections of states and transitions, in which transitions could occasionally get detached from states.
  • Fixed bugs and inconsistencies in the tabbed view (this was really an issue of the underlying Qt framework).
  • Improved syntax coloring for C/C++. The syntax coloring now highlights QM-specific elements, such as code generation directives, QP services, etc.
  • Added support for Makefiles (syntax coloring and proper generation of makefiles).
  • Eliminated any dependencies of the QM Windows executable on the Visual Studio runtime library redistributable (such as msvcr90.dll). The runtime libraries are now linked statically.
  • Many other cosmetic improvements.

Version 1.0.08, 2010-12-12

  • Fixed a bug related to undo/redo of moving transitions with choice segments attached. The bug occurred when the user moved the choice-end of a transition, which had some choice segments attached. After executing undo (Ctrl-Z) the attached choice segments would not be moved, so they would become detached from the transition end.
  • Fixed a bug related to invalid initial transitions. The bug occurred when the target state of an initial transition was deleted (at which point the initial transition changed to dashed line) and the user tried to move the ball-end of the initial transition.
  • Changed the top-level comment placed in the generated code. Now, the top-level comment contains only the model file name without* the full path name of the model file. This change was to make sure that a given QM model generates exactly the same code regardless of the directory in which the model file resides. Teams working with VCSs (version control systems) often check out the master model in various working directories, but they rightly expect that the generated code be identical.
  • Changed the code generator so that every generated file is terminated with the new-line character. Some C/C++ compilers require all files to be terminated with new line. Also improved parsing of the files and error reporting.
  • Added context-sensitive help, which is activated by 'Ctrl+F1'. The context-sensitive help checks the position of the mouse cursor and displays the help for the specific window under the cursor.
The actual help pages are under development, so currently only a placeholder page is displayed in your browser. The online help will be gradually added and you will not need to upgrade the QM tool to get the new help.
  • Other cosmetic improvements.

Version 1.0.07, 2010-11-27

  • Fixed bug related to adding connectors without dragging them out of the attachment point, which results in zero-sized connectors. Such connectors are illegal and were deleted, but the property sheet was not cleaned up. Now adding a zero-sized connector removes the connector and cleans up all views.
  • Added a proactive fix to an unreproducible bug (assertion in diagramview, line 214).
  • Changed how code editors resize in the Property Editor window. Previously the code editor grew only to about 20 lines of code in vertical direction. Now the code editor always fills the whole available vertical space of the Property Editor docking widget.
  • Made the same change for text (documentation) editors in the Property Editor window.
  • Added version number reporting in the Assertion message box. Most users never reported the QM version number when they encountered an assertion failure.
  • Implemented editing of a new directory name and a new file name immediately after these elements have been added to the model.
  • Added close button (x) to the subwindow tabs in the tabbed view.
  • Fixed inconsistent behavior of the tabbed view after closing a subwindow.
  • Other cosmetic improvements.

Version 1.0.06, 2010-11-20

  • added docking widget with the zoomed-out view of the current diagram ("Bird's Eye View"). The "Bird's Eye View" is designed to improve orientation in large diagrams by showing the position of the current viewport in the relation to the diagram.
  • improved consistency of the diagram panning mode and fixed bugs related to entering the panning mode while in the middle of moving/resizing nodes or dragging connectors. Now, the panning mode can be activated only when there is no dragging in progress.
  • added vertical scrolling of diagrams with the mouse-wheel
  • added horizontal scrolling of diagrams with Shift mouse-wheel
  • changed zooming of the diagram to Ctrl-mouse-wheel
  • fixed bug related to pressing right or middle mouse buttons in the middle of moving node(s) or connectors.
  • fixed incorrect behavior of connectors when dragged to zero-size (when the begin overlapped with the end).
  • other cosmetic improvements.

Version 1.0.05, 2010-11-17

  • this release fixes the bug in C-code generation in definition of free operations.
  • there are some cosmetic improvements as well.

Version 1.0.04, 2010-11-17

  • bug fix in adding and deleting a class to a package
  • added diagram zoom slider and buttons in the status bar
  • added panning of the diagrams. Panning is activated by pressing Shift in an active diagram.

Version 1.0.03, 2010-10-29

  • bug fix in editing of class documentation that can break assertion in classheet, line 148 (this turned out to be an undo/redo issue of incorrect unwinding of the undo stack.)
  • improved consistency of line-wrapping between screen output and EMF output.
  • allowed using backslash characters ('\') in guard conditions to enforce line breaks in displaying the guard in the diagram. The backslashes are removed in the generated code.
  • used lighter background colors for states in the EMF output
  • added cleanup of the generated code, so that it contains no superfluous white space (extra spaces could be present in the user-defined action code.)

Version 1.0.00, 2010-10-20

The first official QM™ release contains the following features:

  • Graphical modeling tool based on the UML state machine subset
  • Automatic generation of production-quality C or C++ code
  • Automatic model verification during the code generation
  • Built-in support for QP/C, QP/C++, and QP-nano frameworks
  • 100% traceability from design to code
  • Ultimate flexibility in generated code design
  • Friendly to version control systems (VCS)
  • Intuitive diagramming environment for making clean, good-looking diagrams
  • Export of diagrams to EMF vector format for direct pasting into MS-Office and Open Office applications
  • Modern user interface with docking windows with the layout saved across sessions
  • State of the art editors for action code with syntax highlighting
  • Undo/redo of all model edits
  • Quick Clipboard-based navigation between the model and third-party tools
  • Support for user-generated model templates
  • Ready-made project examples and online tutorials
  • Completely free to download and free to use

QM Compiler (qmc)QM™ License