Merge "WIP: [doc] completed feature model"v_2.0.0-RC8

22 files changed, 2056 insertions, 354 deletions

diff --git a/plugins/org.eclipse.etrice.doc/featuremodel/etrice.roomlanguage.featurizer b/plugins/org.eclipse.etrice.doc/featuremodel/etrice.roomlanguage.featurizer
index 411359426..fe310d75e 100644
--- a/plugins/org.eclipse.etrice.doc/featuremodel/etrice.roomlanguage.featurizer
+++ b/plugins/org.eclipse.etrice.doc/featuremodel/etrice.roomlanguage.featurizer
@@ -26,8 +26,8 @@ Package ROOMLanguage
 Feature AnnotationType
 description '''AnnotationTypes can be used to tag ROOM classes for further custom processing'''
 text '''
-	They provide the ability to associate custom properties to ROOM classes, that adjust or toogle features, like generation or the runtime behavior.
-	eTrice has some built-in annotations, which can be found in Annotations.room within the eTrice modellib.
+	They provide the ability to associate custom properties to ROOM classes, that adjust or toggle features, like generation or the runtime behavior.
+	eTrice comes with predefined annotations, which can be found in Annotations.room within the eTrice modellib.
 
 	See section Annotations for further reading.
 ''' 
@@ -44,7 +44,7 @@ stable
 ;
 
 Feature Annotation
-description '''An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType'''
+description '''An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType'''
 text '''
 	It refers to an AnnotationType and may have to pass key value pairs. Its notation is similar to Java:
 
@@ -78,7 +78,7 @@ stable
 ;
 
 Feature Inheritance
-	description '''A class can specify a super class and inherits elements from the super class hierarchy'''
+	description '''A class can specify a single super class and inherits elements from the super class hierarchy'''
 	text '''
 		When a ROOM class specifies a super class, it generally inherits all elements and properties.
 		In several cases, it is possible, to override these inherited elements. Generally, eTrice has two semantics of overriding: refinement and replacement.
@@ -86,28 +86,28 @@ Feature Inheritance
 		In this case, if a sub class overrides a piece of logic from a super class, it will always be executed subsequently to the inherited.
 		Contrary to this, replacement is applied to overridden Operations, similar to programming languages C++ and Java.
 
-		A formal definition of overriding is given below:
+		A formal definition of several variants of overriding is given below:
 		
-		- early or late resolve - if element is overridden, which one should super class use by default - own or override ?
-		- replacing or refinement - ignore inherited code or prepend inherited code automatically ?
-		- (non-)accessible - if element is overridden, is super class' original accessible from sub class ? e.g. super.foo()
-		- implicit or explicit - does it use distinct model element / keyword?
+		- early or late resolve - if element is overridden, which one should the super class use by default - own or override?
+		- replacing or refining - ignore inherited code or prepend inherited code automatically?
+		- (non-)accessible - if element is overridden, is super class' original accessible from sub class? E.g. super.foo()
+		- implicit or explicit - does it use a distinct model element or keyword?
 		
 		
-		Examples programming languages:
-		c++ virtual function and java override  <==> accessible explicit late replacing
-		c++ function redefine <==> accessible implicit early replacing
-		c++ dtor <==> late refinement\\
+		Examples from programming languages:
+		C++ virtual function and Java override  <==> accessible, explicit, late, replacing
+		C++ function redefine <==> accessible, implicit, early, replacing
+		C++ destructor <==> late, refining\\
 		
 		eTrice override of model elements:
-		Operations (C generation)  <==> non\_accessible explicit late replacing
-		Operations (Java generation) <==> accessible explicit late replacing
-		State and Transitions <==> non-accessible explicit late refinement
-		ctor/dtor <==> non\_accessible implicit late refinement
-		StateMachine <==> non-accessible implicit late refinement
-		UserCode <==> non-accessible implicit late refinement
+		Operations (C generation)  <==> non-accessible, explicit, late, replacing
+		Operations (Java generation) <==> accessible, explicit, late, replacing
+		State and Transitions <==> non-accessible, explicit, late, refining
+		ctor/dtor <==> non-accessible, implicit, late, refining
+		StateMachine <==> non-accessible, implicit, late, refining
+		UserCode <==> non-accessible, implicit, late, refining
 	'''
-	example ¦¦¦
+	example |||
 		```room
 		ActorClass ActorSubClass extends ActorBaseClass {
 			// inherits all elements from super type hierarchy
@@ -145,7 +145,7 @@ Feature Inheritance
 			Attribute attribute1 : uint32
 		}
 		```
-		¦¦¦
+		|||
 	prototype	
 ;
 
@@ -353,7 +353,7 @@ Feature ActorClass
 	'''
 	
 	example ''''''
-	help ¦¦¦
+	help |||
 		```room
 		// prefixes: abstract and (eventdriven, datadriven, async, sync)
 		ActorClass ActorName ["An eventdriven ActorClass by default"] {
@@ -382,7 +382,7 @@ Feature ActorClass
 			}
 		}
 		```
-	¦¦¦
+	|||
 	
 	contains ExecutionType
 	contains ActorRef
@@ -430,7 +430,19 @@ Feature SubSystemClass
 Feature StateMachine
 	description '''A StateMachine describes the state based, event driven behavior of an ActorClass'''
 	text '''
-		In ROOM each actor class can implement its behavior using a state machine. Events occurring at the end ports of an actor will be forwarded to and processed by the state machine. Events possibly trigger state transitions.
+		In ROOM each actor class can implement its behavior using a state machine. Events occurring at the end ports of an actor will
+		be forwarded to and processed by the state machine. Events possibly trigger state transitions.
+		
+		ROOM state machines are hierarchical finite state machines. That means that each state in the state graph can contain another state graph.
+		This is possible to arbitrary depth.
+
+		A state graph consists of
+		
+		* states
+		* transitions
+		* transition points
+		* choice points
+		* initial point
 		
 		![PingPongReceiverFSM](images/300-PingPongReceiverFSM.png)
 		
@@ -448,8 +460,297 @@ Feature StateMachine
 		```
 	'''
 	uses Inheritance
+	contains StateGraphNode
+	contains Transition
 	stable
-	;
+;
+
+abstract Feature StateGraphNode
+	description '''A StateGraphNode is an abstract node of the state graph'''
+	text '''
+		A StateGraphNode can be a State, a TransitionPoint, a ChoicePoint or an InitialPoint.
+	'''
+	uses Inheritance
+	stable
+;
+
+abstract Feature State
+	description '''A State can be a plain State or a RefinedState'''
+	text '''
+		A State can be a plain State or a RefinedState.
+	'''
+	uses Inheritance
+	isA StateGraphNode
+	stable
+;
+
+Feature SimpleState
+	description '''A State is a node in the state graph representation of the state machine'''
+	text '''
+		A State has optional 'entry' and 'exit' codes. The entry code is executed when the state is entered, the exit code is executed
+		when it is left. In the case of an data driven (also known as polled) state machine, there also is a 'do' action code.
+		The do code is executed for the active state in each polling cycle.
+		A state can have a sub state machine. Starting at the top level state machine the states with their optional sub state machines
+		form a tree which is called a 'hierarchical state machine'.
+		A state machine always is in exactly one state which can only be a leaf state, i.e. a state which has no sub state machine.
+	'''
+	help keyword "State" |||
+		```room
+		ActorClass Example {
+			//...
+			Behavior {
+				StateMachine {
+					Transition init: initial -> Standby
+					Transition tr0: Standby -> Running {
+						triggers {
+							<timeout: to>
+						}
+					}
+					Transition tr1: Running -> Stopped {
+						triggers {
+							<timeout: to>
+						}
+					}
+					State Standby {
+						entry '''
+							to.startTimeout(200*10);'''
+					}
+					State Running {
+						entry '''
+							controllers.start();
+							to.startTimeout(200*10);'''
+					}
+					State Stopped {
+						entry '''controllers.stop();'''
+					}
+				}
+			}
+		}
+		```
+	|||
+	uses Inheritance
+	uses StateMachine
+	isA State
+	stable
+;
+
+Feature RefinedState
+	description '''A RefinedState refines a State of one of the Actor's base class state machines'''
+	text '''
+		A State can be a plain State or a RefinedState.
+	'''
+	help |||
+		```room
+			RefinedState BaseState {
+				exit '''// this is derived exit code'''
+				subgraph {
+					// add a sub state machine
+					Transition init: initial -> state0 { }
+					State state0
+				}
+			}
+		```
+	|||
+	uses Inheritance
+	uses StateMachine
+	isA State
+	stable
+;
+
+Feature ChoicePoint
+	description '''a choice point is the state machine counterpart of a conditional statement'''
+	text '''
+		A ChoicePoint in ROOM has one incoming transition and an arbitrary number of outgoing transitions.
+		One of the outgoing transitions has no condition (a ContinuationTransition). It is the default branch that is taken
+		if none of the transition conditions evaluated to true. All other transitions going out from the ChoicePoint
+		are CPBranchTransitions which have a mandatory condition (keyword 'cond'). The evaluation order of the conditions
+		is not deterministic.
+	'''
+	help |||
+		```room
+			StateMachine {
+				State state0
+				State state1
+				State state2
+				State state3
+				TransitionPoint tr4
+				ChoicePoint cp0
+				Transition init0: initial -> state0
+				Transition tr0: state0 -> state1 {
+					triggers {
+						<in1: p0>
+					}
+				}
+				Transition tr1: state1 -> cp cp0 {
+					triggers {
+						<in1: p0>
+					}
+				}
+				Transition tr2: cp cp0 -> state3
+				Transition tr3: cp cp0 -> state2 {
+					cond '''true'''
+				}
+				Transition tr5:  my tr4 -> state0 {
+					triggers {
+						<in2: p0>
+					}
+				}
+			}
+		```
+	|||
+	isA StateGraphNode
+	uses ContinuationTransition
+	stable
+;
+
+abstract Feature TrPoint
+	description '''a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint'''
+	text '''text'''
+	help |||a TrPoint is an abstract element|||
+	isA StateGraphNode
+	stable
+;
+
+Feature TransitionPoint
+	description '''a transition point is the starting point of transitions that trigger for any state of this state machine'''
+	text '''text'''
+	help |||
+		```room
+			StateMachine {
+				TransitionPoint tp1
+				Transition tr1: my tp1 -> my tp1 {
+					triggers {
+						<msg: port>
+					}
+				}
+			}
+		```
+	|||
+	isA TrPoint
+	stable
+;
+
+Feature EntryPoint
+	description '''an entry point is an explicit entry point in a sub state machine to which transitions in the parent state graph can connect'''
+	text '''text'''
+	help |||
+		```room
+			StateMachine {
+				State state0 {
+					subgraph {
+						State state0
+						EntryPoint ep0
+						ExitPoint ep1
+						Transition tr0: my ep0 -> state0
+						Transition tr1: state0 -> my ep1 {
+							triggers {
+								<in1: p0>
+							}
+						}
+					}
+				}
+				State state1
+				Transition init0: initial -> ep0 of state0
+				Transition tr0: ep1 of state0 -> state1
+			}
+		```
+	|||
+	isA TrPoint
+	stable
+;
+
+Feature ExitPoint
+	description '''an exit point is an explicit exit point in a sub state machine from which transitions in the parent state graph can start'''
+	text '''text'''
+	help |||help|||
+	isA TrPoint
+	stable
+;
+
+Feature Transition
+	description '''A Transition is an edge in the state graph representation of the state machine'''
+	text '''
+		A transition connects StateGraphNodes in a state graph. A transition is allowed to connect a state or a transition point with itself.
+		Transition points can only be targets of transitions originating from the same transition point.
+		The initial point is the source of exactly one transition. In the textual model it is present only in an implicit way.
+	'''
+	help |||
+		```room
+			Transition init: initial -> Standby
+			Transition tr0: Standby -> Running {
+				triggers {
+					<timeout: to>
+				}
+			}
+		```
+	|||
+	uses Inheritance
+	stable
+;
+
+Feature InitialTransition
+	description '''the initial transition is used to identify the initial state'''
+	text '''The initial transition connects the initial point to a state. There can be at most one initial transition
+		in a state machine. Under special circumstances the initial transition can be omitted.
+	'''
+	help |||Transition init: initial -> state0|||
+	isA Transition
+	stable
+;
+
+Feature GuardedTransition
+	description '''the guarded transition is used by data driven state machines to trigger state transitions'''
+	text '''In data driven state machines guarded transitions fire whenever the guard condition evaluates to true.
+		The evaluation is performed in each polling cycle.
+	'''
+	help |||
+		Transition tr: running -> running {
+			guard '''data_counter_finish.finish == true && data_finish_flag == false'''
+			action '''++counter;'''
+		}
+	|||
+	idea
+;
+
+Feature ContinuationTransition
+	description '''the continuation transition is a transition with just an optional action code'''
+	text '''A continuation transition is used as default branch of a choice point or as outgoing transition of an entry point'''
+	help '''
+		State running {
+			subgraph {
+				EntryPoint ep0
+				State active
+				Transition tr0: my ep0 -> active
+			}
+		}
+	'''
+	isA Transition
+	idea
+;
+
+Feature CPBranchTransition
+	description '''a choice point branch transition is an outgoing transition from a choice point and is traversed if its conditions is evaluated to true'''
+	text '''A choice point together with its outgoing transitions can be thought of as a if, else-if, else cascade in traditional
+		programming languages. The choice point branch transition corresponds to an if clause while the final else is modeled as
+		a continuation transition. Coming from a choice point, a choice point branch transition is traversed whenever its
+		condition evaluates to true. No order of evaluations is guaranteed.
+	'''
+	help |||
+		Transition tr3: cp cp0 -> state1 {
+			cond '''0<=counter && counter<3'''
+		}
+	|||
+	isA Transition
+	idea
+;
+
+Feature TriggeredTransition
+	description '''a triggered transition is used in event driven state machines to trigger state transitions'''
+	text '''text'''
+	help |||help|||
+	isA Transition
+	stable
+;
 
 Feature SubSystemRef
  	description '''A Sub System Reference is an instance of an SubSystemClass'''
@@ -746,7 +1047,7 @@ Feature ProtocolClass
 		}
 		```
 	'''
-	help ¦¦¦
+	help |||
 		```room
 		// prefixes: (eventdriven, datadriven, sync)
 		ProtocolClass ProtocolName ["An eventdriven ProtocolClass by default"] {
@@ -774,7 +1075,7 @@ Feature ProtocolClass
 			// inherits all elements from super class
 		}
 		```
-	¦¦¦
+	|||
 	contains CommunicationType
 	contains Attribute
 	contains Operation
@@ -801,7 +1102,7 @@ Feature PrimitiveType
 	'''
 	help '''
 	```room
-	// java
+	// Java
 	PrimitiveType boolean: ptBoolean -> boolean (Boolean) default "false"
 	PrimitiveType int16: ptInteger -> short (Short) default "0"
 	
@@ -870,7 +1171,7 @@ Feature DataClass
 		}
 		```
 	'''
-	example ¦¦¦
+	example |||
 		```room
 		DataClass SimpleDataClass {
 			Attribute attribute1: uint16
@@ -887,8 +1188,8 @@ Feature DataClass
 			'''
 		}
 		```
-	¦¦¦
-	help ¦¦¦
+	|||
+	help |||
 		```room
 		DataClass DataClassName ["Documentation"] {
 			Attribute ... // nested DataClasses possible
@@ -902,7 +1203,7 @@ Feature DataClass
 			...
 		}
 		```
-	¦¦¦
+	|||
 	isA DataType
 	contains Attribute
 	contains Operation
@@ -912,7 +1213,7 @@ Feature DataClass
 
 Feature ExternalType 
 	description '''An ExternalType is used to make an target language type accessible in ROOM'''
-	example ¦¦¦
+	example |||
 		```room
 		// Include is needed when used (e.g. in ActorClassWithExternalType)
 		ExternalType someStructType -> "struct FILE_HANDLE"
@@ -932,7 +1233,7 @@ Feature ExternalType
 			}
 		}
 		```
-	¦¦¦
+	|||
 	help '''
 		```room
 		ExternalType voidType -> "void" default "NULL"
@@ -1015,7 +1316,7 @@ Feature Operation
 		- 'override' keyword, replaces the logic of the inherited operation having the same signature
 		
 	'''
-	example ¦¦¦
+	example |||
 		```room
 		import room.basic.types.* from "../../../org.eclipse.etrice.modellib.c/model/Types.room"
 		
@@ -1053,8 +1354,8 @@ Feature Operation
 			}
 		}
 		```
-	¦¦¦
-	help ¦¦¦
+	|||
+	help |||
 		```room
 		Operation operationName() ["A void operation"] '''
 			user code here;
@@ -1070,7 +1371,7 @@ Feature Operation
 		// becomes effective in entire inheritance hierarchy
 		override Operation operationName(param: int32) : boolean ''' '''
 		```
-	¦¦¦
+	|||
 	uses DataType
 	property returnType values { "DataType" }
 	property arguments values { "name : DataType" }
diff --git a/plugins/org.eclipse.etrice.doc/online-doc/content/feature-reference.md b/plugins/org.eclipse.etrice.doc/online-doc/content/feature-reference.md
index 6e4a804c4..0d23476ec 100644
--- a/plugins/org.eclipse.etrice.doc/online-doc/content/feature-reference.md
+++ b/plugins/org.eclipse.etrice.doc/online-doc/content/feature-reference.md
@@ -255,13 +255,13 @@ An ActorClass consists of three main parts:
 <tr>
 	<td>[Annotation](#annotation)
 	 </td>
-	<td>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</td>
+	<td>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</td>
 </tr>
 <tr>
 	<td rowspan="1" style="white-space: nowrap;">Uses:</td>
 	<td>[Inheritance](#inheritance)
 	 </td>
-	<td>A class can specify a super class and inherits elements from the super class hierarchy</td>
+	<td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
 </tr>
 </tbody>
 </table>
@@ -418,7 +418,7 @@ Instance hierarchy of ActorRef Example (*System(System)* not shown in code snipp
 
 
 ### Annotation
-An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType
+An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType
 
 It refers to an AnnotationType and may have to pass key value pairs. Its notation is similar to Java:
 
@@ -513,8 +513,8 @@ ActorClass ComponentAbstraction {
 ### AnnotationType
 AnnotationTypes can be used to tag ROOM classes for further custom processing
 
-They provide the ability to associate custom properties to ROOM classes, that adjust or toogle features, like generation or the runtime behavior.
-eTrice has some built-in annotations, which can be found in Annotations.room within the eTrice modellib.
+They provide the ability to associate custom properties to ROOM classes, that adjust or toggle features, like generation or the runtime behavior.
+eTrice comes with predefined annotations, which can be found in Annotations.room within the eTrice modellib.
 
 See section Annotations for further reading.
 
@@ -531,7 +531,7 @@ See section Annotations for further reading.
 	<td rowspan="1" style="white-space: nowrap;">Typecasts:</td>
 	<td>[Annotation](#annotation)
 	 </td>
-	<td>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</td>
+	<td>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</td>
 </tr>
 <tr>
 	<td rowspan="1" style="white-space: nowrap;">Is contained in:</td>
@@ -735,6 +735,73 @@ ActorClass ExampleActorClass {
 ---
 
 
+### CPBranchTransition
+a choice point branch transition is an outgoing transition from a choice point and is traversed if its conditions is evaluated to true
+
+A choice point together with its outgoing transitions can be thought of as a if, else-if, else cascade in traditional
+		programming languages. The choice point branch transition corresponds to an if clause while the final else is modeled as
+		a continuation transition. Coming from a choice point, a choice point branch transition is traversed whenever its
+		condition evaluates to true. No order of evaluations is guaranteed.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Is a:</td>
+	<td>[Transition](#transition)
+	 </td>
+	<td>A Transition is an edge in the state graph representation of the state machine</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
+### ChoicePoint
+a choice point is the state machine counterpart of a conditional statement
+
+A ChoicePoint in ROOM has one incoming transition and an arbitrary number of outgoing transitions.
+One of the outgoing transitions has no condition (a ContinuationTransition). It is the default branch that is taken
+if none of the transition conditions evaluated to true. All other transitions going out from the ChoicePoint
+are CPBranchTransitions which have a mandatory condition (keyword 'cond'). The evaluation order of the conditions
+is not deterministic.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Is a:</td>
+	<td>[StateGraphNode](#stategraphnode)
+	 </td>
+	<td>A StateGraphNode is an abstract node of the state graph</td>
+</tr>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Uses:</td>
+	<td>[ContinuationTransition](#continuationtransition)
+	 </td>
+	<td>the continuation transition is a transition with just an optional action code</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
 ### CommunicationType
 The CommunicationType defines the communication semantics of a ProtocolClass
 
@@ -820,6 +887,48 @@ datadriven ProtocolClass DatadrivenProtocolClass {
 ---
 
 
+### ContinuationTransition
+the continuation transition is a transition with just an optional action code
+
+A continuation transition is used as default branch of a choice point or as outgoing transition of an entry point
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Is a:</td>
+	<td>[Transition](#transition)
+	 </td>
+	<td>A Transition is an edge in the state graph representation of the state machine</td>
+</tr>
+</tbody>
+</table>
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Is used by:</td>
+	<td>[ChoicePoint](#choicepoint)
+	 </td>
+	<td>a choice point is the state machine counterpart of a conditional statement</td>
+</tr>
+</tbody>
+</table>
+
+
+---
+
+
 ### DataClass
 A DataClass is a composition of Attributes
 
@@ -860,13 +969,13 @@ DataClass TCPConnectionData {
 <tr>
 	<td>[Annotation](#annotation)
 	 </td>
-	<td>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</td>
+	<td>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</td>
 </tr>
 <tr>
 	<td rowspan="1" style="white-space: nowrap;">Uses:</td>
 	<td>[Inheritance](#inheritance)
 	 </td>
-	<td>A class can specify a super class and inherits elements from the super class hierarchy</td>
+	<td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
 </tr>
 </tbody>
 </table>
@@ -953,6 +1062,33 @@ A DataType can take 4 forms and types data elements like an Attribute or Operati
 ---
 
 
+### EntryPoint
+an entry point is an explicit entry point in a sub state machine to which transitions in the parent state graph can connect
+
+text
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Is a:</td>
+	<td>[TrPoint](#trpoint)
+	 </td>
+	<td>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
 ### Enumeration
 An EnumerationType declares an enumeration similar to most well-known languages
 
@@ -1100,6 +1236,33 @@ async ActorClass MixedActor{
 ---
 
 
+### ExitPoint
+an exit point is an explicit exit point in a sub state machine from which transitions in the parent state graph can start
+
+text
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Is a:</td>
+	<td>[TrPoint](#trpoint)
+	 </td>
+	<td>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
 ### ExternalEndPort
 A ExternalEndPort is an interface Port, that is made accessible to the internal interface of an ActorClass
 
@@ -1202,7 +1365,7 @@ ActorClass ActorClassWithExternalType{
 
 
 ### Inheritance
-A class can specify a super class and inherits elements from the super class hierarchy
+A class can specify a single super class and inherits elements from the super class hierarchy
 
 When a ROOM class specifies a super class, it generally inherits all elements and properties.
 In several cases, it is possible, to override these inherited elements. Generally, eTrice has two semantics of overriding: refinement and replacement.
@@ -1210,26 +1373,26 @@ Refinement is used in most cases (e.g. StateMachine) and realizes an extension o
 In this case, if a sub class overrides a piece of logic from a super class, it will always be executed subsequently to the inherited.
 Contrary to this, replacement is applied to overridden Operations, similar to programming languages C++ and Java.
 
-A formal definition of overriding is given below:
+A formal definition of several variants of overriding is given below:
 
-- early or late resolve - if element is overridden, which one should super class use by default - own or override ?
-- replacing or refinement - ignore inherited code or prepend inherited code automatically ?
-- (non-)accessible - if element is overridden, is super class' original accessible from sub class ? e.g. super.foo()
-- implicit or explicit - does it use distinct model element / keyword?
+- early or late resolve - if element is overridden, which one should the super class use by default - own or override?
+- replacing or refining - ignore inherited code or prepend inherited code automatically?
+- (non-)accessible - if element is overridden, is super class' original accessible from sub class? E.g. super.foo()
+- implicit or explicit - does it use a distinct model element or keyword?
 
 
-Examples programming languages:
-c++ virtual function and java override  <==> accessible explicit late replacing
-c++ function redefine <==> accessible implicit early replacing
-c++ dtor <==> late refinement\\
+Examples from programming languages:
+C++ virtual function and Java override  <==> accessible, explicit, late, replacing
+C++ function redefine <==> accessible, implicit, early, replacing
+C++ destructor <==> late, refining\\
 
 eTrice override of model elements:
-Operations (C generation)  <==> non\_accessible explicit late replacing
-Operations (Java generation) <==> accessible explicit late replacing
-State and Transitions <==> non-accessible explicit late refinement
-ctor/dtor <==> non\_accessible implicit late refinement
-StateMachine <==> non-accessible implicit late refinement
-UserCode <==> non-accessible implicit late refinement
+Operations (C generation)  <==> non-accessible, explicit, late, replacing
+Operations (Java generation) <==> accessible, explicit, late, replacing
+State and Transitions <==> non-accessible, explicit, late, refining
+ctor/dtor <==> non-accessible, implicit, late, refining
+StateMachine <==> non-accessible, implicit, late, refining
+UserCode <==> non-accessible, implicit, late, refining
 
 
 
@@ -1241,7 +1404,7 @@ UserCode <==> non-accessible implicit late refinement
 </thead>
 <tbody>
 <tr>
-	<td rowspan="4" style="white-space: nowrap;">Is used by:</td>
+	<td rowspan="9" style="white-space: nowrap;">Is used by:</td>
 	<td>[ActorClass](#actorclass)
 	 </td>
 	<td>An actor is the basic structural building block for building systems with ROOM</td>
@@ -1252,6 +1415,31 @@ UserCode <==> non-accessible implicit late refinement
 	<td>A StateMachine describes the state based, event driven behavior of an ActorClass</td>
 </tr>
 <tr>
+	<td>[StateGraphNode](#stategraphnode)
+	 </td>
+	<td>A StateGraphNode is an abstract node of the state graph</td>
+</tr>
+<tr>
+	<td>[State](#state)
+	 </td>
+	<td>A State can be a plain State or a RefinedState</td>
+</tr>
+<tr>
+	<td>[SimpleState](#simplestate)
+	 </td>
+	<td>A State is a node in the state graph representation of the state machine</td>
+</tr>
+<tr>
+	<td>[RefinedState](#refinedstate)
+	 </td>
+	<td>A RefinedState refines a State of one of the Actor's base class state machines</td>
+</tr>
+<tr>
+	<td>[Transition](#transition)
+	 </td>
+	<td>A Transition is an edge in the state graph representation of the state machine</td>
+</tr>
+<tr>
 	<td>[ProtocolClass](#protocolclass)
 	 </td>
 	<td>A ProtocolClass defines messages and is the interface specification for a Port</td>
@@ -1307,6 +1495,34 @@ DataClass DataBaseClass {
 ---
 
 
+### InitialTransition
+the initial transition is used to identify the initial state
+
+The initial transition connects the initial point to a state. There can be at most one initial transition
+		in a state machine. Under special circumstances the initial transition can be omitted.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Is a:</td>
+	<td>[Transition](#transition)
+	 </td>
+	<td>A Transition is an edge in the state graph representation of the state machine</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
 ### InternalEndPort
 A InternalEndPort is an local Port, that is declared in the internal interface of an ActorClass
 
@@ -1433,7 +1649,7 @@ It describes the logical topology of your distributed system and is composed of
 <tr>
 	<td>[Annotation](#annotation)
 	 </td>
-	<td>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</td>
+	<td>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</td>
 </tr>
 </tbody>
 </table>
@@ -1800,13 +2016,13 @@ ProtocolClass SimpleProtocolClass {
 <tr>
 	<td>[Annotation](#annotation)
 	 </td>
-	<td>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</td>
+	<td>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</td>
 </tr>
 <tr>
 	<td rowspan="1" style="white-space: nowrap;">Uses:</td>
 	<td>[Inheritance](#inheritance)
 	 </td>
-	<td>A class can specify a super class and inherits elements from the super class hierarchy</td>
+	<td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
 </tr>
 </tbody>
 </table>
@@ -1886,6 +2102,44 @@ datadriven ProtocolClass ProtocolClassData {
 ---
 
 
+### RefinedState
+A RefinedState refines a State of one of the Actor's base class state machines
+
+A State can be a plain State or a RefinedState.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Is a:</td>
+	<td>[State](#state)
+	 </td>
+	<td>A State can be a plain State or a RefinedState</td>
+</tr>
+<tr>
+	<td rowspan="2" style="white-space: nowrap;">Uses:</td>
+	<td>[Inheritance](#inheritance)
+	 </td>
+	<td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
+</tr>
+<tr>
+	<td>[StateMachine](#statemachine)
+	 </td>
+	<td>A StateMachine describes the state based, event driven behavior of an ActorClass</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
 ### RelayPort
 A RelayPort forwards its messages without exposing them to the internal interface of the ActorClass
 
@@ -2135,10 +2389,176 @@ The implementation of an Service Provision Point (SPP)
 ---
 
 
+### SimpleState
+A State is a node in the state graph representation of the state machine
+
+A State has optional 'entry' and 'exit' codes. The entry code is executed when the state is entered, the exit code is executed
+when it is left. In the case of an data driven (also known as polled) state machine, there also is a 'do' action code.
+The do code is executed for the active state in each polling cycle.
+A state can have a sub state machine. Starting at the top level state machine the states with their optional sub state machines
+form a tree which is called a 'hierarchical state machine'.
+A state machine always is in exactly one state which can only be a leaf state, i.e. a state which has no sub state machine.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Is a:</td>
+	<td>[State](#state)
+	 </td>
+	<td>A State can be a plain State or a RefinedState</td>
+</tr>
+<tr>
+	<td rowspan="2" style="white-space: nowrap;">Uses:</td>
+	<td>[Inheritance](#inheritance)
+	 </td>
+	<td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
+</tr>
+<tr>
+	<td>[StateMachine](#statemachine)
+	 </td>
+	<td>A StateMachine describes the state based, event driven behavior of an ActorClass</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
+### State
+A State can be a plain State or a RefinedState
+
+A State can be a plain State or a RefinedState.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Is a:</td>
+	<td>[StateGraphNode](#stategraphnode)
+	 </td>
+	<td>A StateGraphNode is an abstract node of the state graph</td>
+</tr>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Uses:</td>
+	<td>[Inheritance](#inheritance)
+	 </td>
+	<td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
+</tr>
+</tbody>
+</table>
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="2" style="white-space: nowrap;">Inheriting features:</td>
+	<td>[SimpleState](#simplestate)
+	 </td>
+	<td>A State is a node in the state graph representation of the state machine</td>
+</tr>
+<tr>
+	<td>[RefinedState](#refinedstate)
+	 </td>
+	<td>A RefinedState refines a State of one of the Actor's base class state machines</td>
+</tr>
+</tbody>
+</table>
+
+
+---
+
+
+### StateGraphNode
+A StateGraphNode is an abstract node of the state graph
+
+A StateGraphNode can be a State, a TransitionPoint, a ChoicePoint or an InitialPoint.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Uses:</td>
+	<td>[Inheritance](#inheritance)
+	 </td>
+	<td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
+</tr>
+</tbody>
+</table>
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="3" style="white-space: nowrap;">Inheriting features:</td>
+	<td>[State](#state)
+	 </td>
+	<td>A State can be a plain State or a RefinedState</td>
+</tr>
+<tr>
+	<td>[ChoicePoint](#choicepoint)
+	 </td>
+	<td>a choice point is the state machine counterpart of a conditional statement</td>
+</tr>
+<tr>
+	<td>[TrPoint](#trpoint)
+	 </td>
+	<td>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</td>
+</tr>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Is contained in:</td>
+	<td>[StateMachine](#statemachine)
+	 </td>
+	<td>A StateMachine describes the state based, event driven behavior of an ActorClass</td>
+</tr>
+</tbody>
+</table>
+
+
+---
+
+
 ### StateMachine
 A StateMachine describes the state based, event driven behavior of an ActorClass
 
-In ROOM each actor class can implement its behavior using a state machine. Events occurring at the end ports of an actor will be forwarded to and processed by the state machine. Events possibly trigger state transitions.
+In ROOM each actor class can implement its behavior using a state machine. Events occurring at the end ports of an actor will
+be forwarded to and processed by the state machine. Events possibly trigger state transitions.
+
+ROOM state machines are hierarchical finite state machines. That means that each state in the state graph can contain another state graph.
+This is possible to arbitrary depth.
+
+A state graph consists of
+
+* states
+* transitions
+* transition points
+* choice points
+* initial point
 
 ![PingPongReceiverFSM](images/300-PingPongReceiverFSM.png)
 
@@ -2152,10 +2572,21 @@ In ROOM each actor class can implement its behavior using a state machine. Event
 </thead>
 <tbody>
 <tr>
+	<td rowspan="2" style="white-space: nowrap;">Contains:</td>
+	<td>[StateGraphNode](#stategraphnode)
+	 </td>
+	<td>A StateGraphNode is an abstract node of the state graph</td>
+</tr>
+<tr>
+	<td>[Transition](#transition)
+	 </td>
+	<td>A Transition is an edge in the state graph representation of the state machine</td>
+</tr>
+<tr>
 	<td rowspan="1" style="white-space: nowrap;">Uses:</td>
 	<td>[Inheritance](#inheritance)
 	 </td>
-	<td>A class can specify a super class and inherits elements from the super class hierarchy</td>
+	<td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
 </tr>
 </tbody>
 </table>
@@ -2179,6 +2610,17 @@ In ROOM each actor class can implement its behavior using a state machine. Event
 	 </td>
 	<td>The GraphicalBehaviorEditor allows to edit the ActorClass' StateMachine. It is possible to create (hierarchical) states and transitions to model complex behavior in a convenient way.</td>
 </tr>
+<tr>
+	<td rowspan="2" style="white-space: nowrap;">Is used by:</td>
+	<td>[SimpleState](#simplestate)
+	 </td>
+	<td>A State is a node in the state graph representation of the state machine</td>
+</tr>
+<tr>
+	<td>[RefinedState](#refinedstate)
+	 </td>
+	<td>A RefinedState refines a State of one of the Actor's base class state machines</td>
+</tr>
 </tbody>
 </table>
 
@@ -2219,7 +2661,7 @@ A SubSystemClass is the structural starting point of an ROOM application. Thus i
 <tr>
 	<td>[Annotation](#annotation)
 	 </td>
-	<td>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</td>
+	<td>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</td>
 </tr>
 </tbody>
 </table>
@@ -2302,6 +2744,177 @@ A physical node is denoted by a NodeClass and NodeRef in the PhysicalModel. The
 ---
 
 
+### TrPoint
+a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint
+
+text
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Is a:</td>
+	<td>[StateGraphNode](#stategraphnode)
+	 </td>
+	<td>A StateGraphNode is an abstract node of the state graph</td>
+</tr>
+</tbody>
+</table>
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="3" style="white-space: nowrap;">Inheriting features:</td>
+	<td>[TransitionPoint](#transitionpoint)
+	 </td>
+	<td>a transition point is the starting point of transitions that trigger for any state of this state machine</td>
+</tr>
+<tr>
+	<td>[EntryPoint](#entrypoint)
+	 </td>
+	<td>an entry point is an explicit entry point in a sub state machine to which transitions in the parent state graph can connect</td>
+</tr>
+<tr>
+	<td>[ExitPoint](#exitpoint)
+	 </td>
+	<td>an exit point is an explicit exit point in a sub state machine from which transitions in the parent state graph can start</td>
+</tr>
+</tbody>
+</table>
+
+
+---
+
+
+### Transition
+A Transition is an edge in the state graph representation of the state machine
+
+A transition connects StateGraphNodes in a state graph. A transition is allowed to connect a state or a transition point with itself.
+Transition points can only be targets of transitions originating from the same transition point.
+The initial point is the source of exactly one transition. In the textual model it is present only in an implicit way.
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Uses:</td>
+	<td>[Inheritance](#inheritance)
+	 </td>
+	<td>A class can specify a single super class and inherits elements from the super class hierarchy</td>
+</tr>
+</tbody>
+</table>
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="4" style="white-space: nowrap;">Inheriting features:</td>
+	<td>[InitialTransition](#initialtransition)
+	 </td>
+	<td>the initial transition is used to identify the initial state</td>
+</tr>
+<tr>
+	<td>[ContinuationTransition](#continuationtransition)
+	 </td>
+	<td>the continuation transition is a transition with just an optional action code</td>
+</tr>
+<tr>
+	<td>[CPBranchTransition](#cpbranchtransition)
+	 </td>
+	<td>a choice point branch transition is an outgoing transition from a choice point and is traversed if its conditions is evaluated to true</td>
+</tr>
+<tr>
+	<td>[TriggeredTransition](#triggeredtransition)
+	 </td>
+	<td>a triggered transition is used in event driven state machines to trigger state transitions</td>
+</tr>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Is contained in:</td>
+	<td>[StateMachine](#statemachine)
+	 </td>
+	<td>A StateMachine describes the state based, event driven behavior of an ActorClass</td>
+</tr>
+</tbody>
+</table>
+
+
+---
+
+
+### TransitionPoint
+a transition point is the starting point of transitions that trigger for any state of this state machine
+
+text
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Is a:</td>
+	<td>[TrPoint](#trpoint)
+	 </td>
+	<td>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
+### TriggeredTransition
+a triggered transition is used in event driven state machines to trigger state transitions
+
+text
+
+
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;">Is a:</td>
+	<td>[Transition](#transition)
+	 </td>
+	<td>A Transition is an edge in the state graph representation of the state machine</td>
+</tr>
+</tbody>
+</table>
+
+
+
+---
+
+
 ## MappingModel
 The MappingModel describes the mapping of elements of the LogicalModel to elements of the PhysicalModel
 
@@ -2916,7 +3529,7 @@ The built-in **Gnuplot script generator** provides a convenient way to visualize
 	<td rowspan="1" style="white-space: nowrap;">Uses:</td>
 	<td>[Annotation](#annotation)
 	 </td>
-	<td>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</td>
+	<td>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</td>
 </tr>
 </tbody>
 </table>
@@ -3117,6 +3730,12 @@ The MSCLogging is activated by default, but can be set manually in the [Generati
 [ActorRefPropertyDialog]: #actorrefpropertydialog
 [PortPropertyDialog]: #portpropertydialog
 [SPPPropertyDialog]: #spppropertydialog
+[CCodeGenerator]: #ccodegenerator
+[JavaCodeGenerator]: #javacodegenerator
+[CPPCodeGenerator]: #cppcodegenerator
+[GenerationOptions]: #generationoptions
+[MSCLogging]: #msclogging
+[DataLogging]: #datalogging
 [AnnotationType]: #annotationtype
 [Annotation]: #annotation
 [Inheritance]: #inheritance
@@ -3128,6 +3747,21 @@ The MSCLogging is activated by default, but can be set manually in the [Generati
 [ActorClass]: #actorclass
 [SubSystemClass]: #subsystemclass
 [StateMachine]: #statemachine
+[StateGraphNode]: #stategraphnode
+[State]: #state
+[SimpleState]: #simplestate
+[RefinedState]: #refinedstate
+[ChoicePoint]: #choicepoint
+[TrPoint]: #trpoint
+[TransitionPoint]: #transitionpoint
+[EntryPoint]: #entrypoint
+[ExitPoint]: #exitpoint
+[Transition]: #transition
+[InitialTransition]: #initialtransition
+[GuardedTransition]: #guardedtransition
+[ContinuationTransition]: #continuationtransition
+[CPBranchTransition]: #cpbranchtransition
+[TriggeredTransition]: #triggeredtransition
 [SubSystemRef]: #subsystemref
 [Replication]: #replication
 [ActorRef]: #actorref
@@ -3150,9 +3784,3 @@ The MSCLogging is activated by default, but can be set manually in the [Generati
 [SAP]: #sap
 [ServiceImplementation]: #serviceimplementation
 [SPP]: #spp
-[CCodeGenerator]: #ccodegenerator
-[JavaCodeGenerator]: #javacodegenerator
-[CPPCodeGenerator]: #cppcodegenerator
-[GenerationOptions]: #generationoptions
-[MSCLogging]: #msclogging
-[DataLogging]: #datalogging
diff --git a/plugins/org.eclipse.etrice.doc/targets/contextHelp.xml b/plugins/org.eclipse.etrice.doc/targets/contextHelp.xml
index ad2eb274b..d106a8eea 100644
--- a/plugins/org.eclipse.etrice.doc/targets/contextHelp.xml
+++ b/plugins/org.eclipse.etrice.doc/targets/contextHelp.xml
@@ -57,6 +57,44 @@
 <topic href="targets/eclipse-help/feature-reference.html#spppropertydialog" label="GraphicalStructureEditor"/>
 </context>
 
+<context id="featureContextHelp_CCodeGenerator" title="CCodeGenerator">
+<description></description>
+<topic href="targets/eclipse-help/feature-reference.html#ccodegenerator" label="CCodeGenerator"/>
+</context>
+
+<context id="featureContextHelp_JavaCodeGenerator" title="JavaCodeGenerator">
+<description></description>
+<topic href="targets/eclipse-help/feature-reference.html#javacodegenerator" label="JavaCodeGenerator"/>
+</context>
+
+<context id="featureContextHelp_CPPCodeGenerator" title="CPPCodeGenerator">
+<description></description>
+<topic href="targets/eclipse-help/feature-reference.html#cppcodegenerator" label="CPPCodeGenerator"/>
+</context>
+
+<context id="featureContextHelp_GenerationOptions" title="GenerationOptions">
+<description>Mechanism to adjust the generation.</description>
+<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="GenerationOptions"/>
+<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="CCodeGenerator"/>
+<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="JavaCodeGenerator"/>
+<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="MSCLogging"/>
+</context>
+
+<context id="featureContextHelp_MSCLogging" title="MSCLogging">
+<description>Runtime logger for event-driven Messages, represented as a Message Sequence Chart.</description>
+<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="MSCLogging"/>
+<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="GenerationOptions"/>
+<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="CCodeGenerator"/>
+<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="JavaCodeGenerator"/>
+</context>
+
+<context id="featureContextHelp_DataLogging" title="DataLogging">
+<description>Runtime logger for data-driven Messages with primitive data.</description>
+<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="DataLogging"/>
+<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="Annotation"/>
+<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="CCodeGenerator"/>
+</context>
+
 <context id="featureContextHelp_AnnotationType" title="AnnotationType">
 <description>AnnotationTypes can be used to tag ROOM classes for further custom processing</description>
 <topic href="targets/eclipse-help/feature-reference.html#annotationtype" label="AnnotationType"/>
@@ -65,22 +103,27 @@
 </context>
 
 <context id="featureContextHelp_Annotation" title="Annotation">
-<description>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</description>
+<description>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</description>
 <topic href="targets/eclipse-help/feature-reference.html#annotation" label="Annotation"/>
 <topic href="targets/eclipse-help/feature-reference.html#annotation" label="AnnotationType"/>
+<topic href="targets/eclipse-help/feature-reference.html#annotation" label="DataLogging"/>
 <topic href="targets/eclipse-help/feature-reference.html#annotation" label="LogicalSystem"/>
 <topic href="targets/eclipse-help/feature-reference.html#annotation" label="ActorClass"/>
 <topic href="targets/eclipse-help/feature-reference.html#annotation" label="SubSystemClass"/>
 <topic href="targets/eclipse-help/feature-reference.html#annotation" label="ProtocolClass"/>
 <topic href="targets/eclipse-help/feature-reference.html#annotation" label="DataClass"/>
-<topic href="targets/eclipse-help/feature-reference.html#annotation" label="DataLogging"/>
 </context>
 
 <context id="featureContextHelp_Inheritance" title="Inheritance">
-<description>A class can specify a super class and inherits elements from the super class hierarchy</description>
+<description>A class can specify a single super class and inherits elements from the super class hierarchy</description>
 <topic href="targets/eclipse-help/feature-reference.html#inheritance" label="Inheritance"/>
 <topic href="targets/eclipse-help/feature-reference.html#inheritance" label="ActorClass"/>
 <topic href="targets/eclipse-help/feature-reference.html#inheritance" label="StateMachine"/>
+<topic href="targets/eclipse-help/feature-reference.html#inheritance" label="StateGraphNode"/>
+<topic href="targets/eclipse-help/feature-reference.html#inheritance" label="State"/>
+<topic href="targets/eclipse-help/feature-reference.html#inheritance" label="State"/>
+<topic href="targets/eclipse-help/feature-reference.html#inheritance" label="RefinedState"/>
+<topic href="targets/eclipse-help/feature-reference.html#inheritance" label="Transition"/>
 <topic href="targets/eclipse-help/feature-reference.html#inheritance" label="ProtocolClass"/>
 <topic href="targets/eclipse-help/feature-reference.html#inheritance" label="DataClass"/>
 </context>
@@ -139,6 +182,90 @@
 <topic href="targets/eclipse-help/feature-reference.html#statemachine" label="Inheritance"/>
 <topic href="targets/eclipse-help/feature-reference.html#statemachine" label="GraphicalBehaviorEditor"/>
 <topic href="targets/eclipse-help/feature-reference.html#statemachine" label="ActorClass"/>
+<topic href="targets/eclipse-help/feature-reference.html#statemachine" label="State"/>
+<topic href="targets/eclipse-help/feature-reference.html#statemachine" label="RefinedState"/>
+</context>
+
+<context id="featureContextHelp_State" title="State">
+<description>A State is a node in the state graph representation of the state machine</description>
+<topic href="targets/eclipse-help/feature-reference.html#simplestate" label="State"/>
+<topic href="targets/eclipse-help/feature-reference.html#simplestate" label="Inheritance"/>
+<topic href="targets/eclipse-help/feature-reference.html#simplestate" label="StateMachine"/>
+<topic href="targets/eclipse-help/feature-reference.html#simplestate" label="State"/>
+</context>
+
+<context id="featureContextHelp_RefinedState" title="RefinedState">
+<description>A RefinedState refines a State of one of the Actor's base class state machines</description>
+<topic href="targets/eclipse-help/feature-reference.html#refinedstate" label="RefinedState"/>
+<topic href="targets/eclipse-help/feature-reference.html#refinedstate" label="Inheritance"/>
+<topic href="targets/eclipse-help/feature-reference.html#refinedstate" label="StateMachine"/>
+<topic href="targets/eclipse-help/feature-reference.html#refinedstate" label="State"/>
+</context>
+
+<context id="featureContextHelp_ChoicePoint" title="ChoicePoint">
+<description>a choice point is the state machine counterpart of a conditional statement</description>
+<topic href="targets/eclipse-help/feature-reference.html#choicepoint" label="ChoicePoint"/>
+<topic href="targets/eclipse-help/feature-reference.html#choicepoint" label="StateGraphNode"/>
+<topic href="targets/eclipse-help/feature-reference.html#choicepoint" label="ContinuationTransition"/>
+</context>
+
+<context id="featureContextHelp_TransitionPoint" title="TransitionPoint">
+<description>a transition point is the starting point of transitions that trigger for any state of this state machine</description>
+<topic href="targets/eclipse-help/feature-reference.html#transitionpoint" label="TransitionPoint"/>
+<topic href="targets/eclipse-help/feature-reference.html#transitionpoint" label="TrPoint"/>
+</context>
+
+<context id="featureContextHelp_EntryPoint" title="EntryPoint">
+<description>an entry point is an explicit entry point in a sub state machine to which transitions in the parent state graph can connect</description>
+<topic href="targets/eclipse-help/feature-reference.html#entrypoint" label="EntryPoint"/>
+<topic href="targets/eclipse-help/feature-reference.html#entrypoint" label="TrPoint"/>
+</context>
+
+<context id="featureContextHelp_ExitPoint" title="ExitPoint">
+<description>an exit point is an explicit exit point in a sub state machine from which transitions in the parent state graph can start</description>
+<topic href="targets/eclipse-help/feature-reference.html#exitpoint" label="ExitPoint"/>
+<topic href="targets/eclipse-help/feature-reference.html#exitpoint" label="TrPoint"/>
+</context>
+
+<context id="featureContextHelp_Transition" title="Transition">
+<description>A Transition is an edge in the state graph representation of the state machine</description>
+<topic href="targets/eclipse-help/feature-reference.html#transition" label="Transition"/>
+<topic href="targets/eclipse-help/feature-reference.html#transition" label="Inheritance"/>
+<topic href="targets/eclipse-help/feature-reference.html#transition" label="StateMachine"/>
+<topic href="targets/eclipse-help/feature-reference.html#transition" label="InitialTransition"/>
+<topic href="targets/eclipse-help/feature-reference.html#transition" label="ContinuationTransition"/>
+<topic href="targets/eclipse-help/feature-reference.html#transition" label="CPBranchTransition"/>
+<topic href="targets/eclipse-help/feature-reference.html#transition" label="TriggeredTransition"/>
+</context>
+
+<context id="featureContextHelp_InitialTransition" title="InitialTransition">
+<description>the initial transition is used to identify the initial state</description>
+<topic href="targets/eclipse-help/feature-reference.html#initialtransition" label="InitialTransition"/>
+<topic href="targets/eclipse-help/feature-reference.html#initialtransition" label="Transition"/>
+</context>
+
+<context id="featureContextHelp_GuardedTransition" title="GuardedTransition">
+<description>the guarded transition is used by data driven state machines to trigger state transitions</description>
+<topic href="targets/eclipse-help/feature-reference.html#guardedtransition" label="GuardedTransition"/>
+</context>
+
+<context id="featureContextHelp_ContinuationTransition" title="ContinuationTransition">
+<description>the continuation transition is a transition with just an optional action code</description>
+<topic href="targets/eclipse-help/feature-reference.html#continuationtransition" label="ContinuationTransition"/>
+<topic href="targets/eclipse-help/feature-reference.html#continuationtransition" label="Transition"/>
+<topic href="targets/eclipse-help/feature-reference.html#continuationtransition" label="ChoicePoint"/>
+</context>
+
+<context id="featureContextHelp_CPBranchTransition" title="CPBranchTransition">
+<description>a choice point branch transition is an outgoing transition from a choice point and is traversed if its conditions is evaluated to true</description>
+<topic href="targets/eclipse-help/feature-reference.html#cpbranchtransition" label="CPBranchTransition"/>
+<topic href="targets/eclipse-help/feature-reference.html#cpbranchtransition" label="Transition"/>
+</context>
+
+<context id="featureContextHelp_TriggeredTransition" title="TriggeredTransition">
+<description>a triggered transition is used in event driven state machines to trigger state transitions</description>
+<topic href="targets/eclipse-help/feature-reference.html#triggeredtransition" label="TriggeredTransition"/>
+<topic href="targets/eclipse-help/feature-reference.html#triggeredtransition" label="Transition"/>
 </context>
 
 <context id="featureContextHelp_SubSystemRef" title="SubSystemRef">
@@ -149,13 +276,6 @@
 <topic href="targets/eclipse-help/feature-reference.html#subsystemref" label="LogicalSystem"/>
 </context>
 
-<context id="featureContextHelp_Replication" title="Replication">
-<description>Replication is mechanism for multi-instantiation for ActorRefs and Ports</description>
-<topic href="targets/eclipse-help/feature-reference.html#replication" label="Replication"/>
-<topic href="targets/eclipse-help/feature-reference.html#replication" label="ActorRef"/>
-<topic href="targets/eclipse-help/feature-reference.html#replication" label="Port"/>
-</context>
-
 <context id="featureContextHelp_ActorRef" title="ActorRef">
 <description>An ActorRef is an instance of an ActorClass</description>
 <topic href="targets/eclipse-help/feature-reference.html#actorref" label="ActorRef"/>
@@ -211,18 +331,6 @@
 <topic href="targets/eclipse-help/feature-reference.html#protocolclass" label="SPP"/>
 </context>
 
-<context id="featureContextHelp_DataType" title="DataType">
-<description>A DataType can take 4 forms and types data elements like an Attribute or Operation argument</description>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="DataType"/>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="LogicalModel"/>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="PrimitiveType"/>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="Enumeration"/>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="DataClass"/>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="ExternalType"/>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="Attribute"/>
-<topic href="targets/eclipse-help/feature-reference.html#datatype" label="Operation"/>
-</context>
-
 <context id="featureContextHelp_PrimitiveType" title="PrimitiveType">
 <description>A PrimitiveType is an abstraction of a target language's basic type (e.g. integer or boolean)</description>
 <topic href="targets/eclipse-help/feature-reference.html#primitivetype" label="PrimitiveType"/>
@@ -267,21 +375,6 @@
 <topic href="targets/eclipse-help/feature-reference.html#operation" label="DataClass"/>
 </context>
 
-<context id="featureContextHelp_Port" title="Port">
-<description>A Port is an instance of a ProtocolClass and the interface for an ActorClass</description>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="Port"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="ProtocolClass"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="Replication"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="GraphicalStructureEditor"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="PortPropertyDialog"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="ActorClass"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="Binding"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="Binding"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="RelayPort"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="ExternalEndPort"/>
-<topic href="targets/eclipse-help/feature-reference.html#port" label="InternalEndPort"/>
-</context>
-
 <context id="featureContextHelp_RelayPort" title="RelayPort">
 <description>A RelayPort forwards its messages without exposing them to the internal interface of the ActorClass</description>
 <topic href="targets/eclipse-help/feature-reference.html#relayport" label="RelayPort"/>
@@ -325,42 +418,4 @@
 <topic href="targets/eclipse-help/feature-reference.html#spp" label="LayerConnection"/>
 <topic href="targets/eclipse-help/feature-reference.html#spp" label="ServiceImplementation"/>
 </context>
-
-<context id="featureContextHelp_CCodeGenerator" title="CCodeGenerator">
-<description></description>
-<topic href="targets/eclipse-help/feature-reference.html#ccodegenerator" label="CCodeGenerator"/>
-</context>
-
-<context id="featureContextHelp_JavaCodeGenerator" title="JavaCodeGenerator">
-<description></description>
-<topic href="targets/eclipse-help/feature-reference.html#javacodegenerator" label="JavaCodeGenerator"/>
-</context>
-
-<context id="featureContextHelp_CPPCodeGenerator" title="CPPCodeGenerator">
-<description></description>
-<topic href="targets/eclipse-help/feature-reference.html#cppcodegenerator" label="CPPCodeGenerator"/>
-</context>
-
-<context id="featureContextHelp_GenerationOptions" title="GenerationOptions">
-<description>Mechanism to adjust the generation.</description>
-<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="GenerationOptions"/>
-<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="CCodeGenerator"/>
-<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="JavaCodeGenerator"/>
-<topic href="targets/eclipse-help/feature-reference.html#generationoptions" label="MSCLogging"/>
-</context>
-
-<context id="featureContextHelp_MSCLogging" title="MSCLogging">
-<description>Runtime logger for event-driven Messages, represented as a Message Sequence Chart.</description>
-<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="MSCLogging"/>
-<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="GenerationOptions"/>
-<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="CCodeGenerator"/>
-<topic href="targets/eclipse-help/feature-reference.html#msclogging" label="JavaCodeGenerator"/>
-</context>
-
-<context id="featureContextHelp_DataLogging" title="DataLogging">
-<description>Runtime logger for data-driven Messages with primitive data.</description>
-<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="DataLogging"/>
-<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="Annotation"/>
-<topic href="targets/eclipse-help/feature-reference.html#datalogging" label="CCodeGenerator"/>
-</context>
 </contexts>
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/Dave-Integration.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/Dave-Integration.html
index 3c17cae69..b04dbbfe5 100644
--- a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/Dave-Integration.html
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/Dave-Integration.html
@@ -96,9 +96,9 @@
 <p>Open <em>BlinkyTutorial.room</em> and create a new Actor called AHWAbstraction by adding the following text:</p>
 <pre><code class="room customHighlighted"><span class="keyword">ActorClass</span> AHWAbstraction {
     <span class="keyword">Structure</span> {
-        <span class="keyword">usercode1</span> '''
-            #include <span class="string">"Dave.h"</span>
-        '''
+        <span class="keyword">usercode1</span> <span class="string">'''
+            #include "Dave.h"
+        '''</span>
     }
 }
 </code></pre>
@@ -130,9 +130,9 @@
         <span class="keyword">Port</span> LED1: POnOff
     }
     <span class="keyword">Structure</span> {
-        <span class="keyword">usercode1</span> '''
-            #include <span class="string">"Dave.h"</span>
-        '''
+        <span class="keyword">usercode1</span> <span class="string">'''
+            #include "Dave.h"
+        '''</span>
         <span class="keyword">external</span> <span class="keyword">Port</span> LED1
     }
     <span class="keyword">Behavior</span> {
@@ -143,17 +143,17 @@
                 <span class="keyword">triggers</span> {
                     &lt;on: LED1&gt;
                 }
-                <span class="keyword">action</span> '''
+                <span class="keyword">action</span> <span class="string">'''
                     DIGITAL_IO_SetOutputHigh(&amp;LED1_P5_9);
-                '''
+                '''</span>
             }
             <span class="keyword">Transition</span> tr1: state0 -&gt; state0 {
                 <span class="keyword">triggers</span> {
                     &lt;off: LED1&gt;
                 }
-                <span class="keyword">action</span> '''
+                <span class="keyword">action</span> <span class="string">'''
                     DIGITAL_IO_SetOutputLow(&amp;LED1_P5_9);
-                '''
+                '''</span>
             }
         }
     }
@@ -186,25 +186,25 @@
             <span class="keyword">State</span> state0
             <span class="keyword">State</span> state1
             <span class="keyword">Transition</span> init: <span class="keyword">initial</span> -&gt; state0 {
-                <span class="keyword">action</span> '''
+                <span class="keyword">action</span> <span class="string">'''
                     timer.startTimer(300);
-                '''
+                '''</span>
             }
             <span class="keyword">Transition</span> tr0: state0 -&gt; state1 {
                 <span class="keyword">triggers</span> {
                     &lt;timeout: timer&gt;
                 }
-                <span class="keyword">action</span> '''
+                <span class="keyword">action</span> <span class="string">'''
                     out.on();
-                '''
+                '''</span>
             }
             <span class="keyword">Transition</span> tr1: state1 -&gt; state0 {
                 <span class="keyword">triggers</span> {
                     &lt;timeout: timer&gt;
                 }
-                <span class="keyword">action</span> '''
+                <span class="keyword">action</span> <span class="string">'''
                     out.off();
-                '''
+                '''</span>
             }
         }
     }
@@ -243,25 +243,25 @@
                 <span class="keyword">State</span> state0
                 <span class="keyword">State</span> state1
                 <span class="keyword">Transition</span> init: <span class="keyword">initial</span> -&gt; state0 {
-                    <span class="keyword">action</span> '''
+                    <span class="keyword">action</span> <span class="string">'''
                         timer.startTimer(300);
-                    '''
+                    '''</span>
                 }
                 <span class="keyword">Transition</span> tr0: state0 -&gt; state1 {
                     <span class="keyword">triggers</span> {
                         &lt;timeout: timer&gt;
                     }
-                    <span class="keyword">action</span> '''
+                    <span class="keyword">action</span> <span class="string">'''
                         out.on();
-                    '''
+                    '''</span>
                 }
                 <span class="keyword">Transition</span> tr1: state1 -&gt; state0 {
                     <span class="keyword">triggers</span> {
                         &lt;timeout: timer&gt;
                     }
-                    <span class="keyword">action</span> '''
+                    <span class="keyword">action</span> <span class="string">'''
                         out.off();
-                    '''
+                    '''</span>
                 }
             }
         }
@@ -272,9 +272,9 @@
             <span class="keyword">Port</span> LED1: POnOff
         }
         <span class="keyword">Structure</span> {
-            <span class="keyword">usercode1</span> '''
-                #include <span class="string">"Dave.h"</span>
-            '''
+            <span class="keyword">usercode1</span> <span class="string">'''
+                #include "Dave.h"
+            '''</span>
             <span class="keyword">external</span> <span class="keyword">Port</span> LED1
         }
         <span class="keyword">Behavior</span> {
@@ -285,17 +285,17 @@
                     <span class="keyword">triggers</span> {
                         &lt;on: LED1&gt;
                     }
-                    <span class="keyword">action</span> '''
+                    <span class="keyword">action</span> <span class="string">'''
                         DIGITAL_IO_SetOutputHigh(&amp;LED1_P5_9);
-                    '''
+                    '''</span>
                 }
                 <span class="keyword">Transition</span> tr1: state0 -&gt; state0 {
                     <span class="keyword">triggers</span> {
                         &lt;off: LED1&gt;
                     }
-                    <span class="keyword">action</span> '''
+                    <span class="keyword">action</span> <span class="string">'''
                         DIGITAL_IO_SetOutputLow(&amp;LED1_P5_9);
-                    '''
+                    '''</span>
                 }
             }
         }
@@ -378,14 +378,14 @@
                 <span class="keyword">State</span> blinking {
                     <span class="keyword">subgraph</span> {
                         <span class="keyword">State</span> on {
-                            <span class="keyword">entry</span> '''
+                            <span class="keyword">entry</span> <span class="string">'''
                                 out.on();
-                            '''
+                            '''</span>
                         }
                         <span class="keyword">State</span> off {
-                            <span class="keyword">entry</span> '''
+                            <span class="keyword">entry</span> <span class="string">'''
                                 out.off();
-                            '''
+                            '''</span>
                         }
                         <span class="keyword">EntryPoint</span> tp0
                         <span class="keyword">Transition</span> tr0: on -&gt; off {
@@ -399,9 +399,9 @@
                             }
                         }
                         <span class="keyword">Transition</span> tr2: <span class="keyword">my</span> tp0 -&gt; on {
-                            <span class="keyword">action</span> '''
+                            <span class="keyword">action</span> <span class="string">'''
                                 timer.startTimer(300);
-                            '''
+                            '''</span>
                         }
                     }
                 }
@@ -417,10 +417,10 @@
                     <span class="keyword">triggers</span> {
                         &lt;off: ctrl&gt;
                     }
-                    <span class="keyword">action</span> '''
+                    <span class="keyword">action</span> <span class="string">'''
                         timer.kill();
                         out.off();
-                    '''
+                    '''</span>
                 }
             }
         }
@@ -434,9 +434,9 @@
             <span class="keyword">conjugated</span> <span class="keyword">Port</span> BUTTON2: POnOff
         }
         <span class="keyword">Structure</span> {
-            <span class="keyword">usercode1</span> '''
-                #include <span class="string">"Dave.h"</span>
-            '''
+            <span class="keyword">usercode1</span> <span class="string">'''
+                #include "Dave.h"
+            '''</span>
             <span class="keyword">SAP</span> timer: PTimer
             <span class="keyword">external</span> <span class="keyword">Port</span> LED1
             <span class="keyword">external</span> <span class="keyword">Port</span> LED2
@@ -449,77 +449,77 @@
             <span class="keyword">StateMachine</span> {
                 <span class="keyword">State</span> state0
                 <span class="keyword">Transition</span> init: <span class="keyword">initial</span> -&gt; state0 {
-                    <span class="keyword">action</span> '''
+                    <span class="keyword">action</span> <span class="string">'''
                         timer.startTimer(50);
-                    '''
+                    '''</span>
                 }
                 <span class="keyword">Transition</span> tr0: state0 -&gt; state0 {
                     <span class="keyword">triggers</span> {
                         &lt;on: LED1&gt;
                     }
-                    <span class="keyword">action</span> '''
+                    <span class="keyword">action</span> <span class="string">'''
                         DIGITAL_IO_SetOutputHigh(&amp;LED1_P5_9);
-                    '''
+                    '''</span>
                 }
                 <span class="keyword">Transition</span> tr1: state0 -&gt; state0 {
                     <span class="keyword">triggers</span> {
                         &lt;off: LED1&gt;
                     }
-                    <span class="keyword">action</span> '''
+                    <span class="keyword">action</span> <span class="string">'''
                         DIGITAL_IO_SetOutputLow(&amp;LED1_P5_9);
-                    '''
+                    '''</span>
                 }
                 <span class="keyword">Transition</span> tr2: state0 -&gt; state0 {
                     <span class="keyword">triggers</span> {
                         &lt;on: LED2&gt;
                     }
-                    <span class="keyword">action</span> '''
+                    <span class="keyword">action</span> <span class="string">'''
                         DIGITAL_IO_SetOutputHigh(&amp;LED2_P5_8);
-                    '''
+                    '''</span>
                 }
                 <span class="keyword">Transition</span> tr3: state0 -&gt; state0 {
                     <span class="keyword">triggers</span> {
                         &lt;off: LED2&gt;
                     }
-                    <span class="keyword">action</span> '''
+                    <span class="keyword">action</span> <span class="string">'''
                         DIGITAL_IO_SetOutputLow(&amp;LED2_P5_8);
-                    '''
+                    '''</span>
                 }
                 <span class="keyword">Transition</span> tr4: state0 -&gt; state0 {
                     <span class="keyword">triggers</span> {
                         &lt;timeout: timer&gt;
                     }
-                    <span class="keyword">action</span> '''
+                    <span class="keyword">action</span> <span class="string">'''
                         if (DIGITAL_IO_GetInput(&amp;BUTTON1_P15_13) == 0) {
                             if (b1Status == 0) {
-                                <span class="comment">// input changed
-</span>                                b1Status = 1;
+                                // input changed
+                                b1Status = 1;
                                 BUTTON1.on();
                             }
                         }
                         else {
                             if (b1Status == 1) {
-                                <span class="comment">// input changed
-</span>                                b1Status = 0;
+                                // input changed
+                                b1Status = 0;
                             	BUTTON1.off();
                             }
                         }
                         
                         if (DIGITAL_IO_GetInput(&amp;BUTTON2_P15_12) == 0) {
                                 if (b2Status == 0){
-                                <span class="comment">// input changed
-</span>                                b2Status = 1;
+                                // input changed
+                                b2Status = 1;
                                 BUTTON2.on();
                             }
                         }
                         else {
                             if (b2Status == 1) {
-                                <span class="comment">// input changed
-</span>                                b2Status = 0;
+                                // input changed
+                                b2Status = 0;
                                 BUTTON2.off();
                             }
                         }
-                    '''
+                    '''</span>
                 }
             }
         }
@@ -550,17 +550,17 @@
                     <span class="keyword">triggers</span> {
                         &lt;on: ctrl&gt;
                     }
-                    <span class="keyword">action</span> '''
+                    <span class="keyword">action</span> <span class="string">'''
                         out.on();
-                    '''
+                    '''</span>
                 }
                 <span class="keyword">Transition</span> tr1: on -&gt; off {
                     <span class="keyword">triggers</span> {
                         &lt;on: ctrl&gt;
                     }
-                    <span class="keyword">action</span> '''
+                    <span class="keyword">action</span> <span class="string">'''
                         out.off();
-                    '''
+                    '''</span>
                 }
             }
         }
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/etrice-doc.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/etrice-doc.html
index f9d3225d4..29f4204a4 100644
--- a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/etrice-doc.html
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/etrice-doc.html
@@ -743,6 +743,24 @@
 
 
 
+<li><a href="feature-reference.html#cpbranchtransition">CPBranchTransition</a></li>
+
+
+
+
+
+
+
+
+<li><a href="feature-reference.html#choicepoint">ChoicePoint</a></li>
+
+
+
+
+
+
+
+
 <li><a href="feature-reference.html#communicationtype">CommunicationType</a></li>
 
 
@@ -752,6 +770,15 @@
 
 
 
+<li><a href="feature-reference.html#continuationtransition">ContinuationTransition</a></li>
+
+
+
+
+
+
+
+
 <li><a href="feature-reference.html#dataclass">DataClass</a></li>
 
 
@@ -770,6 +797,15 @@
 
 
 
+<li><a href="feature-reference.html#entrypoint">EntryPoint</a></li>
+
+
+
+
+
+
+
+
 <li><a href="feature-reference.html#enumeration">Enumeration</a></li>
 
 
@@ -788,6 +824,15 @@
 
 
 
+<li><a href="feature-reference.html#exitpoint">ExitPoint</a></li>
+
+
+
+
+
+
+
+
 <li><a href="feature-reference.html#externalendport">ExternalEndPort</a></li>
 
 
@@ -815,6 +860,15 @@
 
 
 
+<li><a href="feature-reference.html#initialtransition">InitialTransition</a></li>
+
+
+
+
+
+
+
+
 <li><a href="feature-reference.html#internalendport">InternalEndPort</a></li>
 
 
@@ -878,6 +932,15 @@
 
 
 
+<li><a href="feature-reference.html#refinedstate">RefinedState</a></li>
+
+
+
+
+
+
+
+
 <li><a href="feature-reference.html#relayport">RelayPort</a></li>
 
 
@@ -923,6 +986,33 @@
 
 
 
+<li><a href="feature-reference.html#simplestate">SimpleState</a></li>
+
+
+
+
+
+
+
+
+<li><a href="feature-reference.html#state">State</a></li>
+
+
+
+
+
+
+
+
+<li><a href="feature-reference.html#stategraphnode">StateGraphNode</a></li>
+
+
+
+
+
+
+
+
 <li><a href="feature-reference.html#statemachine">StateMachine</a></li>
 
 
@@ -950,6 +1040,42 @@
 
 
 
+<li><a href="feature-reference.html#trpoint">TrPoint</a></li>
+
+
+
+
+
+
+
+
+<li><a href="feature-reference.html#transition">Transition</a></li>
+
+
+
+
+
+
+
+
+<li><a href="feature-reference.html#transitionpoint">TransitionPoint</a></li>
+
+
+
+
+
+
+
+
+<li><a href="feature-reference.html#triggeredtransition">TriggeredTransition</a></li>
+
+
+
+
+
+
+
+
 </ul>
 </li>
 
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/feature-reference.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/feature-reference.html
index 57997975a..0aa8fab51 100644
--- a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/feature-reference.html
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/feature-reference.html
@@ -210,12 +210,12 @@
 </tr>
 <tr>
 	<td><p><a href="#annotation">Annotation</a></p></td>
-	<td><p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p></td>
+	<td><p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p></td>
 </tr>
 <tr>
 	<td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
 	<td><p><a href="#inheritance">Inheritance</a></p></td>
-	<td><p>A class can specify a super class and inherits elements from the super class hierarchy</p></td>
+	<td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
 </tr>
 </tbody>
 </table>
@@ -347,7 +347,7 @@
 <p>Instance hierarchy of ActorRef Example (*System(System)* not shown in code snippet)</p>
 <hr>
 <h3><a href="#annotation" name="annotation"></a>Annotation</h3>
-<p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p>
+<p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p>
 <p>It refers to an AnnotationType and may have to pass key value pairs. Its notation is similar to Java:</p>
 <pre><code class="room customHighlighted">@AnnotationType1
 @AnnotationType2(key1=<span class="string">"STRING"</span>, key2=3, ...)
@@ -421,7 +421,7 @@
 <hr>
 <h3><a href="#annotationtype" name="annotationtype"></a>AnnotationType</h3>
 <p>AnnotationTypes can be used to tag ROOM classes for further custom processing</p>
-<p>They provide the ability to associate custom properties to ROOM classes, that adjust or toogle features, like generation or the runtime behavior.<br>eTrice has some built-in annotations, which can be found in Annotations.room within the eTrice modellib.</p>
+<p>They provide the ability to associate custom properties to ROOM classes, that adjust or toggle features, like generation or the runtime behavior.<br>eTrice comes with predefined annotations, which can be found in Annotations.room within the eTrice modellib.</p>
 <p>See section Annotations for further reading.</p>
 <table style="vertical-align: middle;" class="table">
 <thead>
@@ -433,7 +433,7 @@
 <tr>
 	<td rowspan="1" style="white-space: nowrap;"><p>Typecasts:</p></td>
 	<td><p><a href="#annotation">Annotation</a></p></td>
-	<td><p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p></td>
+	<td><p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p></td>
 </tr>
 <tr>
 	<td rowspan="1" style="white-space: nowrap;"><p>Is contained in:</p></td>
@@ -600,6 +600,47 @@
 </tbody>
 </table>
 <hr>
+<h3><a href="#cpbranchtransition" name="cpbranchtransition"></a>CPBranchTransition</h3>
+<p>a choice point branch transition is an outgoing transition from a choice point and is traversed if its conditions is evaluated to true</p>
+<p>A choice point together with its outgoing transitions can be thought of as a if, else-if, else cascade in traditional<br> programming languages. The choice point branch transition corresponds to an if clause while the final else is modeled as<br> a continuation transition. Coming from a choice point, a choice point branch transition is traversed whenever its<br> condition evaluates to true. No order of evaluations is guaranteed.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+	<td><p><a href="#transition">Transition</a></p></td>
+	<td><p>A Transition is an edge in the state graph representation of the state machine</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
+<h3><a href="#choicepoint" name="choicepoint"></a>ChoicePoint</h3>
+<p>a choice point is the state machine counterpart of a conditional statement</p>
+<p>A ChoicePoint in ROOM has one incoming transition and an arbitrary number of outgoing transitions.<br>One of the outgoing transitions has no condition (a ContinuationTransition). It is the default branch that is taken<br>if none of the transition conditions evaluated to true. All other transitions going out from the ChoicePoint<br>are CPBranchTransitions which have a mandatory condition (keyword ‘cond’). The evaluation order of the conditions<br>is not deterministic.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+	<td><p><a href="#stategraphnode">StateGraphNode</a></p></td>
+	<td><p>A StateGraphNode is an abstract node of the state graph</p></td>
+</tr>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
+	<td><p><a href="#continuationtransition">ContinuationTransition</a></p></td>
+	<td><p>the continuation transition is a transition with just an optional action code</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
 <h3><a href="#communicationtype" name="communicationtype"></a>CommunicationType</h3>
 <p>The CommunicationType defines the communication semantics of a ProtocolClass</p>
 <p>Since from ROOM models executable code can be generated, it is important to define the way the actors are executed and communicate with each other.<br>The combination of communication and execution is called the <em>execution model</em>. Therefore the ExecutionType of an actor and the CommunicationType of the ports has to be considered.</p>
@@ -671,6 +712,38 @@
 </span><span class="comment">//	}
 </span></code></pre>
 <hr>
+<h3><a href="#continuationtransition" name="continuationtransition"></a>ContinuationTransition</h3>
+<p>the continuation transition is a transition with just an optional action code</p>
+<p>A continuation transition is used as default branch of a choice point or as outgoing transition of an entry point</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+	<td><p><a href="#transition">Transition</a></p></td>
+	<td><p>A Transition is an edge in the state graph representation of the state machine</p></td>
+</tr>
+</tbody>
+</table>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Is used by:</p></td>
+	<td><p><a href="#choicepoint">ChoicePoint</a></p></td>
+	<td><p>a choice point is the state machine counterpart of a conditional statement</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
 <h3><a href="#dataclass" name="dataclass"></a>DataClass</h3>
 <p>A DataClass is a composition of Attributes</p>
 <p>Intended to model a type that primarily consists of data, which is usually grouped together in some manner. DataClasses roughly translate to Java classes without interaction or C <em>struct</em>s.</p>
@@ -702,30 +775,32 @@
 </tr>
 <tr>
 	<td><p><a href="#annotation">Annotation</a></p></td>
-	<td><p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p></td>
+	<td><p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p></td>
 </tr>
 <tr>
 	<td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
 	<td><p><a href="#inheritance">Inheritance</a></p></td>
-	<td><p>A class can specify a super class and inherits elements from the super class hierarchy</p></td>
+	<td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
 </tr>
 </tbody>
 </table>
 <p><strong>Example</strong>:</p>
-<p>¦¦¦<br> ```room&lt;br/&gt; DataClass SimpleDataClass {&lt;br/&gt; Attribute attribute1: uint16&lt;br/&gt; Attribute attribute2: uint32&lt;br/&gt; }&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt;    DataClass DataClassExample {
-       Attribute attribute1: uint32
-       Attribute attribute2: SimpleDataClass
-       Attribute attribute3: voidType ref
-
-       Operation operation1(param1: uint32, param2: uint16): boolean &amp;#39;&amp;#39;&amp;#39;
-         return true;
-       &amp;#39;&amp;#39;&amp;#39;
-    }
-    ```
-¦¦¦
+<pre><code class="room customHighlighted"><span class="keyword">DataClass</span> SimpleDataClass {
+	<span class="keyword">Attribute</span> attribute1: uint16
+	<span class="keyword">Attribute</span> attribute2: uint32
+}
 
-</p><hr>
+<span class="keyword">DataClass</span> DataClassExample {
+	<span class="keyword">Attribute</span> attribute1: uint32
+	<span class="keyword">Attribute</span> attribute2: SimpleDataClass
+	<span class="keyword">Attribute</span> attribute3: voidType <span class="keyword">ref</span>
+	
+	<span class="keyword">Operation</span> operation1(param1: uint32, param2: uint16): boolean <span class="string">'''
+		return true;
+	'''</span>
+}
+</code></pre>
+<hr>
 <h3><a href="#datatype" name="datatype"></a>DataType</h3>
 <p>A DataType can take 4 forms and types data elements like an Attribute or Operation argument</p>
 <table style="vertical-align: middle;" class="table">
@@ -770,6 +845,24 @@
 </tbody>
 </table>
 <hr>
+<h3><a href="#entrypoint" name="entrypoint"></a>EntryPoint</h3>
+<p>an entry point is an explicit entry point in a sub state machine to which transitions in the parent state graph can connect</p>
+<p>text</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+	<td><p><a href="#trpoint">TrPoint</a></p></td>
+	<td><p>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
 <h3><a href="#enumeration" name="enumeration"></a>Enumeration</h3>
 <p>An EnumerationType declares an enumeration similar to most well-known languages</p>
 <table style="vertical-align: middle;" class="table">
@@ -887,6 +980,24 @@
 </span>}
 </code></pre>
 <hr>
+<h3><a href="#exitpoint" name="exitpoint"></a>ExitPoint</h3>
+<p>an exit point is an explicit exit point in a sub state machine from which transitions in the parent state graph can start</p>
+<p>text</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+	<td><p><a href="#trpoint">TrPoint</a></p></td>
+	<td><p>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
 <h3><a href="#externalendport" name="externalendport"></a>ExternalEndPort</h3>
 <p>A ExternalEndPort is an interface Port, that is made accessible to the internal interface of an ActorClass</p>
 <pre><code class="room customHighlighted"><span class="keyword">ActorClass</span> ExternalEndPortExample {
@@ -948,37 +1059,37 @@
 </tbody>
 </table>
 <p><strong>Example</strong>:</p>
-<p>¦¦¦<br> ```room&lt;br/&gt; // Include is needed when used (e.g. in ActorClassWithExternalType)&lt;br/&gt; ExternalType someStructType -&amp;gt; &amp;ldquo;struct FILE_HANDLE&amp;rdquo;&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt;    ActorClass ActorClassWithExternalType{
-       Structure {
-         usercode1 &amp;#39;&amp;#39;&amp;#39;
-          // #include &amp;lt;___.h&amp;gt; /* User includes here*/
-         &amp;#39;&amp;#39;&amp;#39;
-         Attribute someHandle : someStructType ref // needs include
-       }
-       Behavior {
-         Operation operation1(param1: charPtr) &amp;#39;&amp;#39;&amp;#39;
-          // external calls or casts may need includes
-          write(someHandle, param1);
-         &amp;#39;&amp;#39;&amp;#39;
-       }
-    }
-    ```
-¦¦¦
+<pre><code class="room customHighlighted"><span class="comment">// Include is needed when used (e.g. in ActorClassWithExternalType)
+</span><span class="keyword">ExternalType</span> someStructType -&gt; <span class="string">"struct FILE_HANDLE"</span>
 
-</p><hr>
+<span class="keyword">ActorClass</span> ActorClassWithExternalType{
+	<span class="keyword">Structure</span> {
+		<span class="keyword">usercode1</span> <span class="string">'''
+			// #include &lt;___.h&gt; /* User includes here*/
+		'''</span>
+		<span class="keyword">Attribute</span> someHandle : someStructType <span class="keyword">ref</span> <span class="comment">// needs include
+</span>	}
+	<span class="keyword">Behavior</span> {
+		<span class="keyword">Operation</span> operation1(param1: charPtr) <span class="string">'''
+			// external calls or casts may need includes
+			write(someHandle, param1);
+		'''</span>
+	}
+}
+</code></pre>
+<hr>
 <h3><a href="#inheritance" name="inheritance"></a>Inheritance</h3>
-<p>A class can specify a super class and inherits elements from the super class hierarchy</p>
+<p>A class can specify a single super class and inherits elements from the super class hierarchy</p>
 <p>When a ROOM class specifies a super class, it generally inherits all elements and properties.<br>In several cases, it is possible, to override these inherited elements. Generally, eTrice has two semantics of overriding: refinement and replacement.<br>Refinement is used in most cases (e.g. StateMachine) and realizes an extension of the overridden elements.<br>In this case, if a sub class overrides a piece of logic from a super class, it will always be executed subsequently to the inherited.<br>Contrary to this, replacement is applied to overridden Operations, similar to programming languages C++ and Java.</p>
-<p>A formal definition of overriding is given below:</p>
+<p>A formal definition of several variants of overriding is given below:</p>
 <ul>
-  <li>early or late resolve - if element is overridden, which one should super class use by default - own or override ?</li>
-  <li>replacing or refinement - ignore inherited code or prepend inherited code automatically ?</li>
-  <li>(non-)accessible - if element is overridden, is super class’ original accessible from sub class ? e.g. super.foo()</li>
-  <li>implicit or explicit - does it use distinct model element / keyword?</li>
+  <li>early or late resolve - if element is overridden, which one should the super class use by default - own or override?</li>
+  <li>replacing or refining - ignore inherited code or prepend inherited code automatically?</li>
+  <li>(non-)accessible - if element is overridden, is super class’ original accessible from sub class? E.g. super.foo()</li>
+  <li>implicit or explicit - does it use a distinct model element or keyword?</li>
 </ul>
-<p>Examples programming languages:<br>c++ virtual function and java override &lt;==&gt; accessible explicit late replacing<br>c++ function redefine &lt;==&gt; accessible implicit early replacing<br>c++ dtor &lt;==&gt; late refinement\</p>
-<p>eTrice override of model elements:<br>Operations (C generation) &lt;==&gt; non_accessible explicit late replacing<br>Operations (Java generation) &lt;==&gt; accessible explicit late replacing<br>State and Transitions &lt;==&gt; non-accessible explicit late refinement<br>ctor/dtor &lt;==&gt; non_accessible implicit late refinement<br>StateMachine &lt;==&gt; non-accessible implicit late refinement<br>UserCode &lt;==&gt; non-accessible implicit late refinement</p>
+<p>Examples from programming languages:<br>C++ virtual function and Java override &lt;==&gt; accessible, explicit, late, replacing<br>C++ function redefine &lt;==&gt; accessible, implicit, early, replacing<br>C++ destructor &lt;==&gt; late, refining\</p>
+<p>eTrice override of model elements:<br>Operations (C generation) &lt;==&gt; non-accessible, explicit, late, replacing<br>Operations (Java generation) &lt;==&gt; accessible, explicit, late, replacing<br>State and Transitions &lt;==&gt; non-accessible, explicit, late, refining<br>ctor/dtor &lt;==&gt; non-accessible, implicit, late, refining<br>StateMachine &lt;==&gt; non-accessible, implicit, late, refining<br>UserCode &lt;==&gt; non-accessible, implicit, late, refining</p>
 <table style="vertical-align: middle;" class="table">
 <thead>
 <tr>
@@ -987,7 +1098,7 @@
 </thead>
 <tbody>
 <tr>
-	<td rowspan="4" style="white-space: nowrap;"><p>Is used by:</p></td>
+	<td rowspan="9" style="white-space: nowrap;"><p>Is used by:</p></td>
 	<td><p><a href="#actorclass">ActorClass</a></p></td>
 	<td><p>An actor is the basic structural building block for building systems with ROOM</p></td>
 </tr>
@@ -996,6 +1107,26 @@
 	<td><p>A StateMachine describes the state based, event driven behavior of an ActorClass</p></td>
 </tr>
 <tr>
+	<td><p><a href="#stategraphnode">StateGraphNode</a></p></td>
+	<td><p>A StateGraphNode is an abstract node of the state graph</p></td>
+</tr>
+<tr>
+	<td><p><a href="#state">State</a></p></td>
+	<td><p>A State can be a plain State or a RefinedState</p></td>
+</tr>
+<tr>
+	<td><p><a href="#simplestate">SimpleState</a></p></td>
+	<td><p>A State is a node in the state graph representation of the state machine</p></td>
+</tr>
+<tr>
+	<td><p><a href="#refinedstate">RefinedState</a></p></td>
+	<td><p>A RefinedState refines a State of one of the Actor’s base class state machines</p></td>
+</tr>
+<tr>
+	<td><p><a href="#transition">Transition</a></p></td>
+	<td><p>A Transition is an edge in the state graph representation of the state machine</p></td>
+</tr>
+<tr>
 	<td><p><a href="#protocolclass">ProtocolClass</a></p></td>
 	<td><p>A ProtocolClass defines messages and is the interface specification for a Port</p></td>
 </tr>
@@ -1006,42 +1137,61 @@
 </tbody>
 </table>
 <p><strong>Example</strong>:</p>
-<p>¦¦¦<br> ```room&lt;br/&gt; ActorClass ActorSubClass extends ActorBaseClass {&lt;br/&gt; // inherits all elements from super type hierarchy&lt;br/&gt; }&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt;    ActorClass ActorBaseClass {
-       Interface {
-         Port port1 : ProtocolBaseClass
-       }
-       Structure {
-         Attribute attribute1 : uint32
-       }
-       Behavior {
-         Operation operation1() &amp;#39;&amp;#39;&amp;#39;
-          return;
-         &amp;#39;&amp;#39;&amp;#39;
-       }
-    }
+<pre><code class="room customHighlighted"><span class="keyword">ActorClass</span> ActorSubClass <span class="keyword">extends</span> ActorBaseClass {
+	<span class="comment">// inherits all elements from super type hierarchy
+</span>}
 
-    ProtocolClass ProtocolSubClass extends ProtocolBaseClass {
-       // inherits all elements from super type hierarchy
-    }
+<span class="keyword">ActorClass</span> ActorBaseClass {
+	<span class="keyword">Interface</span> {
+		<span class="keyword">Port</span> port1 : ProtocolBaseClass
+	}
+	<span class="keyword">Structure</span> {
+		<span class="keyword">Attribute</span> attribute1 : uint32
+	}
+	<span class="keyword">Behavior</span> {
+		<span class="keyword">Operation</span> operation1() <span class="string">'''
+			return;
+		'''</span>
+	}
+}
 
-    ProtocolClass ProtocolBaseClass {
-       incoming {
-         Message message1()
-       }
-    }
+<span class="keyword">ProtocolClass</span> ProtocolSubClass <span class="keyword">extends</span> ProtocolBaseClass {
+	<span class="comment">// inherits all elements from super type hierarchy
+</span>}
 
-    DataClass DataSubClass extends DataBaseClass {
-       // inherits all elements from super type hierarchy
-    }
+<span class="keyword">ProtocolClass</span> ProtocolBaseClass {
+	<span class="keyword">incoming</span> {
+		<span class="keyword">Message</span> message1()
+	}
+}
 
-    DataClass DataBaseClass {
-       Attribute attribute1 : uint32
-    }
-    ```
-    ¦¦¦
+<span class="keyword">DataClass</span> DataSubClass <span class="keyword">extends</span> DataBaseClass {
+	<span class="comment">// inherits all elements from super type hierarchy
+</span>}
 
-</p><hr>
+<span class="keyword">DataClass</span> DataBaseClass {
+	<span class="keyword">Attribute</span> attribute1 : uint32
+}
+</code></pre>
+<hr>
+<h3><a href="#initialtransition" name="initialtransition"></a>InitialTransition</h3>
+<p>the initial transition is used to identify the initial state</p>
+<p>The initial transition connects the initial point to a state. There can be at most one initial transition<br> in a state machine. Under special circumstances the initial transition can be omitted.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+	<td><p><a href="#transition">Transition</a></p></td>
+	<td><p>A Transition is an edge in the state graph representation of the state machine</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
 <h3><a href="#internalendport" name="internalendport"></a>InternalEndPort</h3>
 <p>A InternalEndPort is an local Port, that is declared in the internal interface of an ActorClass</p>
 <pre><code class="room customHighlighted"><span class="keyword">ActorClass</span> InternalEndPortExample {
@@ -1140,7 +1290,7 @@
 </tr>
 <tr>
 	<td><p><a href="#annotation">Annotation</a></p></td>
-	<td><p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p></td>
+	<td><p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p></td>
 </tr>
 </tbody>
 </table>
@@ -1228,44 +1378,43 @@
 </tbody>
 </table>
 <p><strong>Example</strong>:</p>
-<p>¦¦¦<br> ```room&lt;br/&gt; import room.basic.types.* from &amp;ldquo;../../../org.eclipse.etrice.modellib.c/model/Types.room&amp;rdquo;&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt;    DataClass DataClassWithOperation {
-       Attribute attribute1 : uint32
-
-       Operation operation1(param1: uint32, param2: int32): boolean &amp;#39;&amp;#39;&amp;#39;
-         return attribute1 &amp;gt; (param1 - param2);
-       &amp;#39;&amp;#39;&amp;#39;
-    }
+<pre><code class="room customHighlighted"><span class="keyword">import</span> room.basic.types.* <span class="keyword">from</span> <span class="string">"../../../org.eclipse.etrice.modellib.c/model/Types.room"</span>
 
-    ActorClass ActorClassWithOperation {
-       Structure {
-         Attribute attribute1 : uint32
-       }
-       Behavior {
-         Operation operation1(param1: uint32, param2: int32): boolean &amp;#39;&amp;#39;&amp;#39;
-          return attribute1 &amp;gt; (param1 - param2);
-         &amp;#39;&amp;#39;&amp;#39;
-       }
-    }
+<span class="keyword">DataClass</span> DataClassWithOperation {
+	<span class="keyword">Attribute</span> attribute1 : uint32
+	
+	<span class="keyword">Operation</span> operation1(param1: uint32, param2: int32): boolean <span class="string">'''
+		return attribute1 &gt; (param1 - param2);
+	'''</span>
+}
 
-    ActorClass ActorClassWithOperation2 {
-       Structure {
-         usercode1 &amp;#39;&amp;#39;&amp;#39;
-          // #include &amp;lt;___.h&amp;gt; /* User includes here */
-         &amp;#39;&amp;#39;&amp;#39;
-         Attribute someHandle : voidType ref
-       }
-       Behavior {
-         Operation operation1(param1: charPtr) &amp;#39;&amp;#39;&amp;#39;
-          // external calls or casts may need includes
-          write(someHandle, param1);
-         &amp;#39;&amp;#39;&amp;#39;
-       }
-    }
-    ```
-¦¦¦
+<span class="keyword">ActorClass</span> ActorClassWithOperation {
+	<span class="keyword">Structure</span> {
+		<span class="keyword">Attribute</span> attribute1 : uint32
+	}
+	<span class="keyword">Behavior</span> {
+		<span class="keyword">Operation</span> operation1(param1: uint32, param2: int32): boolean <span class="string">'''
+			return attribute1 &gt; (param1 - param2);
+		'''</span>
+	}
+}
 
-</p><hr>
+<span class="keyword">ActorClass</span> ActorClassWithOperation2 {
+	<span class="keyword">Structure</span> {
+		<span class="keyword">usercode1</span> <span class="string">'''
+			// #include &lt;___.h&gt; /* User includes here */
+		'''</span>
+		<span class="keyword">Attribute</span> someHandle : voidType <span class="keyword">ref</span>
+	}
+	<span class="keyword">Behavior</span> {
+		<span class="keyword">Operation</span> operation1(param1: charPtr) <span class="string">'''
+			// external calls or casts may need includes
+			write(someHandle, param1);
+		'''</span>
+	}
+}
+</code></pre>
+<hr>
 <h3><a href="#port" name="port"></a>Port</h3>
 <p>A Port is an instance of a ProtocolClass and the interface for an ActorClass</p>
 <p>Once a ProtocolClass has been created, it can be used to define actor interfaces. This is accomplished by means of Ports.<br>A Port is a declaration that the set of messages defined by its ProtocolClass is now part of the actor’s interface.<br>It provides strong decoupling of ActorClasses from each other, thus enabling easy testability, reusability and deployment of actors to different threads or nodes.</p>
@@ -1435,12 +1584,12 @@
 </tr>
 <tr>
 	<td><p><a href="#annotation">Annotation</a></p></td>
-	<td><p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p></td>
+	<td><p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p></td>
 </tr>
 <tr>
 	<td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
 	<td><p><a href="#inheritance">Inheritance</a></p></td>
-	<td><p>A class can specify a super class and inherits elements from the super class hierarchy</p></td>
+	<td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
 </tr>
 </tbody>
 </table>
@@ -1509,6 +1658,33 @@
 </span>}
 </code></pre>
 <hr>
+<h3><a href="#refinedstate" name="refinedstate"></a>RefinedState</h3>
+<p>A RefinedState refines a State of one of the Actor’s base class state machines</p>
+<p>A State can be a plain State or a RefinedState.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+	<td><p><a href="#state">State</a></p></td>
+	<td><p>A State can be a plain State or a RefinedState</p></td>
+</tr>
+<tr>
+	<td rowspan="2" style="white-space: nowrap;"><p>Uses:</p></td>
+	<td><p><a href="#inheritance">Inheritance</a></p></td>
+	<td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
+</tr>
+<tr>
+	<td><p><a href="#statemachine">StateMachine</a></p></td>
+	<td><p>A StateMachine describes the state based, event driven behavior of an ActorClass</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
 <h3><a href="#relayport" name="relayport"></a>RelayPort</h3>
 <p>A RelayPort forwards its messages without exposing them to the internal interface of the ActorClass</p>
 <pre><code class="room customHighlighted"><span class="keyword">ActorClass</span> RelayPortExample{
@@ -1700,9 +1876,131 @@
 </tbody>
 </table>
 <hr>
+<h3><a href="#simplestate" name="simplestate"></a>SimpleState</h3>
+<p>A State is a node in the state graph representation of the state machine</p>
+<p>A State has optional ‘entry’ and ‘exit’ codes. The entry code is executed when the state is entered, the exit code is executed<br>when it is left. In the case of an data driven (also known as polled) state machine, there also is a ‘do’ action code.<br>The do code is executed for the active state in each polling cycle.<br>A state can have a sub state machine. Starting at the top level state machine the states with their optional sub state machines<br>form a tree which is called a ‘hierarchical state machine’.<br>A state machine always is in exactly one state which can only be a leaf state, i.e. a state which has no sub state machine.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+	<td><p><a href="#state">State</a></p></td>
+	<td><p>A State can be a plain State or a RefinedState</p></td>
+</tr>
+<tr>
+	<td rowspan="2" style="white-space: nowrap;"><p>Uses:</p></td>
+	<td><p><a href="#inheritance">Inheritance</a></p></td>
+	<td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
+</tr>
+<tr>
+	<td><p><a href="#statemachine">StateMachine</a></p></td>
+	<td><p>A StateMachine describes the state based, event driven behavior of an ActorClass</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
+<h3><a href="#state" name="state"></a>State</h3>
+<p>A State can be a plain State or a RefinedState</p>
+<p>A State can be a plain State or a RefinedState.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+	<td><p><a href="#stategraphnode">StateGraphNode</a></p></td>
+	<td><p>A StateGraphNode is an abstract node of the state graph</p></td>
+</tr>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
+	<td><p><a href="#inheritance">Inheritance</a></p></td>
+	<td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
+</tr>
+</tbody>
+</table>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="2" style="white-space: nowrap;"><p>Inheriting features:</p></td>
+	<td><p><a href="#simplestate">SimpleState</a></p></td>
+	<td><p>A State is a node in the state graph representation of the state machine</p></td>
+</tr>
+<tr>
+	<td><p><a href="#refinedstate">RefinedState</a></p></td>
+	<td><p>A RefinedState refines a State of one of the Actor’s base class state machines</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
+<h3><a href="#stategraphnode" name="stategraphnode"></a>StateGraphNode</h3>
+<p>A StateGraphNode is an abstract node of the state graph</p>
+<p>A StateGraphNode can be a State, a TransitionPoint, a ChoicePoint or an InitialPoint.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
+	<td><p><a href="#inheritance">Inheritance</a></p></td>
+	<td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
+</tr>
+</tbody>
+</table>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="3" style="white-space: nowrap;"><p>Inheriting features:</p></td>
+	<td><p><a href="#state">State</a></p></td>
+	<td><p>A State can be a plain State or a RefinedState</p></td>
+</tr>
+<tr>
+	<td><p><a href="#choicepoint">ChoicePoint</a></p></td>
+	<td><p>a choice point is the state machine counterpart of a conditional statement</p></td>
+</tr>
+<tr>
+	<td><p><a href="#trpoint">TrPoint</a></p></td>
+	<td><p>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</p></td>
+</tr>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Is contained in:</p></td>
+	<td><p><a href="#statemachine">StateMachine</a></p></td>
+	<td><p>A StateMachine describes the state based, event driven behavior of an ActorClass</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
 <h3><a href="#statemachine" name="statemachine"></a>StateMachine</h3>
 <p>A StateMachine describes the state based, event driven behavior of an ActorClass</p>
-<p>In ROOM each actor class can implement its behavior using a state machine. Events occurring at the end ports of an actor will be forwarded to and processed by the state machine. Events possibly trigger state transitions.</p>
+<p>In ROOM each actor class can implement its behavior using a state machine. Events occurring at the end ports of an actor will<br>be forwarded to and processed by the state machine. Events possibly trigger state transitions.</p>
+<p>ROOM state machines are hierarchical finite state machines. That means that each state in the state graph can contain another state graph.<br>This is possible to arbitrary depth.</p>
+<p>A state graph consists of</p>
+<ul>
+  <li>states</li>
+  <li>transitions</li>
+  <li>transition points</li>
+  <li>choice points</li>
+  <li>initial point</li>
+</ul>
 <p><img src="images/300-PingPongReceiverFSM.png" alt="PingPongReceiverFSM"></p>
 <table style="vertical-align: middle;" class="table">
 <thead>
@@ -1712,9 +2010,18 @@
 </thead>
 <tbody>
 <tr>
+	<td rowspan="2" style="white-space: nowrap;"><p>Contains:</p></td>
+	<td><p><a href="#stategraphnode">StateGraphNode</a></p></td>
+	<td><p>A StateGraphNode is an abstract node of the state graph</p></td>
+</tr>
+<tr>
+	<td><p><a href="#transition">Transition</a></p></td>
+	<td><p>A Transition is an edge in the state graph representation of the state machine</p></td>
+</tr>
+<tr>
 	<td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
 	<td><p><a href="#inheritance">Inheritance</a></p></td>
-	<td><p>A class can specify a super class and inherits elements from the super class hierarchy</p></td>
+	<td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
 </tr>
 </tbody>
 </table>
@@ -1735,6 +2042,15 @@
 	<td><p><a href="#graphicalbehavioreditor">GraphicalBehaviorEditor</a></p></td>
 	<td><p>The GraphicalBehaviorEditor allows to edit the ActorClass’ StateMachine. It is possible to create (hierarchical) states and transitions to model complex behavior in a convenient way.</p></td>
 </tr>
+<tr>
+	<td rowspan="2" style="white-space: nowrap;"><p>Is used by:</p></td>
+	<td><p><a href="#simplestate">SimpleState</a></p></td>
+	<td><p>A State is a node in the state graph representation of the state machine</p></td>
+</tr>
+<tr>
+	<td><p><a href="#refinedstate">RefinedState</a></p></td>
+	<td><p>A RefinedState refines a State of one of the Actor’s base class state machines</p></td>
+</tr>
 </tbody>
 </table>
 <hr>
@@ -1763,7 +2079,7 @@
 </tr>
 <tr>
 	<td><p><a href="#annotation">Annotation</a></p></td>
-	<td><p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p></td>
+	<td><p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p></td>
 </tr>
 </tbody>
 </table>
@@ -1825,6 +2141,131 @@
 </tbody>
 </table>
 <hr>
+<h3><a href="#trpoint" name="trpoint"></a>TrPoint</h3>
+<p>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</p>
+<p>text</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+	<td><p><a href="#stategraphnode">StateGraphNode</a></p></td>
+	<td><p>A StateGraphNode is an abstract node of the state graph</p></td>
+</tr>
+</tbody>
+</table>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="3" style="white-space: nowrap;"><p>Inheriting features:</p></td>
+	<td><p><a href="#transitionpoint">TransitionPoint</a></p></td>
+	<td><p>a transition point is the starting point of transitions that trigger for any state of this state machine</p></td>
+</tr>
+<tr>
+	<td><p><a href="#entrypoint">EntryPoint</a></p></td>
+	<td><p>an entry point is an explicit entry point in a sub state machine to which transitions in the parent state graph can connect</p></td>
+</tr>
+<tr>
+	<td><p><a href="#exitpoint">ExitPoint</a></p></td>
+	<td><p>an exit point is an explicit exit point in a sub state machine from which transitions in the parent state graph can start</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
+<h3><a href="#transition" name="transition"></a>Transition</h3>
+<p>A Transition is an edge in the state graph representation of the state machine</p>
+<p>A transition connects StateGraphNodes in a state graph. A transition is allowed to connect a state or a transition point with itself.<br>Transition points can only be targets of transitions originating from the same transition point.<br>The initial point is the source of exactly one transition. In the textual model it is present only in an implicit way.</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
+	<td><p><a href="#inheritance">Inheritance</a></p></td>
+	<td><p>A class can specify a single super class and inherits elements from the super class hierarchy</p></td>
+</tr>
+</tbody>
+</table>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Feature Usage</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="4" style="white-space: nowrap;"><p>Inheriting features:</p></td>
+	<td><p><a href="#initialtransition">InitialTransition</a></p></td>
+	<td><p>the initial transition is used to identify the initial state</p></td>
+</tr>
+<tr>
+	<td><p><a href="#continuationtransition">ContinuationTransition</a></p></td>
+	<td><p>the continuation transition is a transition with just an optional action code</p></td>
+</tr>
+<tr>
+	<td><p><a href="#cpbranchtransition">CPBranchTransition</a></p></td>
+	<td><p>a choice point branch transition is an outgoing transition from a choice point and is traversed if its conditions is evaluated to true</p></td>
+</tr>
+<tr>
+	<td><p><a href="#triggeredtransition">TriggeredTransition</a></p></td>
+	<td><p>a triggered transition is used in event driven state machines to trigger state transitions</p></td>
+</tr>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Is contained in:</p></td>
+	<td><p><a href="#statemachine">StateMachine</a></p></td>
+	<td><p>A StateMachine describes the state based, event driven behavior of an ActorClass</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
+<h3><a href="#transitionpoint" name="transitionpoint"></a>TransitionPoint</h3>
+<p>a transition point is the starting point of transitions that trigger for any state of this state machine</p>
+<p>text</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+	<td><p><a href="#trpoint">TrPoint</a></p></td>
+	<td><p>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
+<h3><a href="#triggeredtransition" name="triggeredtransition"></a>TriggeredTransition</h3>
+<p>a triggered transition is used in event driven state machines to trigger state transitions</p>
+<p>text</p>
+<table style="vertical-align: middle;" class="table">
+<thead>
+<tr>
+	<th colspan="3">Features</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+	<td rowspan="1" style="white-space: nowrap;"><p>Is a:</p></td>
+	<td><p><a href="#transition">Transition</a></p></td>
+	<td><p>A Transition is an edge in the state graph representation of the state machine</p></td>
+</tr>
+</tbody>
+</table>
+<hr>
 <h2><a href="#mappingmodel" name="mappingmodel"></a>MappingModel</h2>
 <p>The MappingModel describes the mapping of elements of the LogicalModel to elements of the PhysicalModel</p>
 <p>It enables the complete decoupling of the LogicalModel and the PhysicalModel, thus providing a maximum flexibility and reuse for the models.</p>
@@ -2279,7 +2720,7 @@
 <tr>
 	<td rowspan="1" style="white-space: nowrap;"><p>Uses:</p></td>
 	<td><p><a href="#annotation">Annotation</a></p></td>
-	<td><p>An Annotation can be attached to a ROOM classes to apply the properties of its AnnotationType</p></td>
+	<td><p>An Annotation can be attached to a ROOM class to specify the properties of its AnnotationType</p></td>
 </tr>
 </tbody>
 </table>
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/room-concepts.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/room-concepts.html
index 383434f5f..e6ec50cc0 100644
--- a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/room-concepts.html
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/room-concepts.html
@@ -120,21 +120,21 @@
 <pre><code class="room customHighlighted"><span class="keyword">ActorClass</span> ActorClass4 {
 	<span class="keyword">Behavior</span> {
 		<span class="comment">// no arguments, no return value
-</span>		<span class="keyword">Operation</span> operation1(): <span class="keyword">void</span> '''
+</span>		<span class="keyword">Operation</span> operation1(): <span class="keyword">void</span> <span class="string">'''
 			user code
-		'''
+		'''</span>
 		<span class="comment">// argument of primitive type, return value of primitive type
-</span>		<span class="keyword">Operation</span> operation2(Param1: int32, Param2: float64): uint16 '''
+</span>		<span class="keyword">Operation</span> operation2(Param1: int32, Param2: float64): uint16 <span class="string">'''
 			user code
-		'''
+		'''</span>
 		<span class="comment">// arguments and return value by value
-</span>		<span class="keyword">Operation</span> operation3(Param1: int32, Param2: DataClass1): DataClass1 '''
+</span>		<span class="keyword">Operation</span> operation3(Param1: int32, Param2: DataClass1): DataClass1 <span class="string">'''
 			user code
-		'''
+		'''</span>
 		<span class="comment">// arguments and return value by reference except for primitive types
-</span>		<span class="keyword">Operation</span> operation4(Param1: int32, Param2: DataClass1 ref): DataClass1 <span class="keyword">ref</span> '''
+</span>		<span class="keyword">Operation</span> operation4(Param1: int32, Param2: DataClass1 ref): DataClass1 <span class="keyword">ref</span> <span class="string">'''
 			user code
-		'''
+		'''</span>
 	}
 }
 </code></pre>
@@ -376,17 +376,17 @@
 </span>	<span class="keyword">Attribute</span> attribute2: float32  <span class="comment">// attribute of another primitive type
 </span>
 	<span class="comment">// no arguments, no return value
-</span>	<span class="keyword">Operation</span> operation1(): <span class="keyword">void</span> '''
+</span>	<span class="keyword">Operation</span> operation1(): <span class="keyword">void</span> <span class="string">'''
 		user code
-	'''
+	'''</span>
 	<span class="comment">// argument of primitive type, no return value
-</span>	<span class="keyword">Operation</span> operation2(Param1: int32): <span class="keyword">void</span> '''
+</span>	<span class="keyword">Operation</span> operation2(Param1: int32): <span class="keyword">void</span> <span class="string">'''
 		user code
-	'''
+	'''</span>
 	<span class="comment">// argument of primitive type, return value of primitive type
-</span>	<span class="keyword">Operation</span> operation3(Param1: int32): float64 '''
+</span>	<span class="keyword">Operation</span> operation3(Param1: int32): float64 <span class="string">'''
 		user code
-	'''
+	'''</span>
 }
 </code></pre>
 <p>Example: DataClass using other DataClasses:</p>
@@ -395,13 +395,13 @@
 </span>	<span class="keyword">Attribute</span> attribute2: DataClass1 <span class="comment">// attribute of DataClass
 </span>
 	<span class="comment">// arguments and return value by value
-</span>	<span class="keyword">Operation</span> operation1(Param1: int32, Param2: DataClass1): DataClass1 '''
+</span>	<span class="keyword">Operation</span> operation1(Param1: int32, Param2: DataClass1): DataClass1 <span class="string">'''
 		user code
-	'''
+	'''</span>
 	<span class="comment">// arguments and return value by reference except for primitive types
-</span>	<span class="keyword">Operation</span> operation2(Param1: int32, Param2: DataClass1 ref): DataClass1 <span class="keyword">ref</span> '''
+</span>	<span class="keyword">Operation</span> operation2(Param1: int32, Param2: DataClass1 ref): DataClass1 <span class="keyword">ref</span> <span class="string">'''
 		user code
-	'''
+	'''</span>
 }
 </code></pre>
 <h2><a href="#layering" name="layering"></a>Layering</h2>
diff --git a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/toc-topics.xml.html b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/toc-topics.xml.html
index df79d8ddd..57f009c26 100644
--- a/plugins/org.eclipse.etrice.doc/targets/eclipse-help/toc-topics.xml.html
+++ b/plugins/org.eclipse.etrice.doc/targets/eclipse-help/toc-topics.xml.html
@@ -95,14 +95,20 @@
 </topic><topic href="targets/eclipse-help/feature-reference.html#annotationtype" label="AnnotationType">
 </topic><topic href="targets/eclipse-help/feature-reference.html#attribute" label="Attribute">
 </topic><topic href="targets/eclipse-help/feature-reference.html#binding" label="Binding">
+</topic><topic href="targets/eclipse-help/feature-reference.html#cpbranchtransition" label="CPBranchTransition">
+</topic><topic href="targets/eclipse-help/feature-reference.html#choicepoint" label="ChoicePoint">
 </topic><topic href="targets/eclipse-help/feature-reference.html#communicationtype" label="CommunicationType">
+</topic><topic href="targets/eclipse-help/feature-reference.html#continuationtransition" label="ContinuationTransition">
 </topic><topic href="targets/eclipse-help/feature-reference.html#dataclass" label="DataClass">
 </topic><topic href="targets/eclipse-help/feature-reference.html#datatype" label="DataType">
+</topic><topic href="targets/eclipse-help/feature-reference.html#entrypoint" label="EntryPoint">
 </topic><topic href="targets/eclipse-help/feature-reference.html#enumeration" label="Enumeration">
 </topic><topic href="targets/eclipse-help/feature-reference.html#executiontype" label="ExecutionType">
+</topic><topic href="targets/eclipse-help/feature-reference.html#exitpoint" label="ExitPoint">
 </topic><topic href="targets/eclipse-help/feature-reference.html#externalendport" label="ExternalEndPort">
 </topic><topic href="targets/eclipse-help/feature-reference.html#externaltype" label="ExternalType">
 </topic><topic href="targets/eclipse-help/feature-reference.html#inheritance" label="Inheritance">
+</topic><topic href="targets/eclipse-help/feature-reference.html#initialtransition" label="InitialTransition">
 </topic><topic href="targets/eclipse-help/feature-reference.html#internalendport" label="InternalEndPort">
 </topic><topic href="targets/eclipse-help/feature-reference.html#layerconnection" label="LayerConnection">
 </topic><topic href="targets/eclipse-help/feature-reference.html#logicalsystem" label="LogicalSystem">
@@ -110,14 +116,22 @@
 </topic><topic href="targets/eclipse-help/feature-reference.html#port" label="Port">
 </topic><topic href="targets/eclipse-help/feature-reference.html#primitivetype" label="PrimitiveType">
 </topic><topic href="targets/eclipse-help/feature-reference.html#protocolclass" label="ProtocolClass">
+</topic><topic href="targets/eclipse-help/feature-reference.html#refinedstate" label="RefinedState">
 </topic><topic href="targets/eclipse-help/feature-reference.html#relayport" label="RelayPort">
 </topic><topic href="targets/eclipse-help/feature-reference.html#replication" label="Replication">
 </topic><topic href="targets/eclipse-help/feature-reference.html#sap" label="SAP">
 </topic><topic href="targets/eclipse-help/feature-reference.html#spp" label="SPP">
 </topic><topic href="targets/eclipse-help/feature-reference.html#serviceimplementation" label="ServiceImplementation">
+</topic><topic href="targets/eclipse-help/feature-reference.html#simplestate" label="SimpleState">
+</topic><topic href="targets/eclipse-help/feature-reference.html#state" label="State">
+</topic><topic href="targets/eclipse-help/feature-reference.html#stategraphnode" label="StateGraphNode">
 </topic><topic href="targets/eclipse-help/feature-reference.html#statemachine" label="StateMachine">
 </topic><topic href="targets/eclipse-help/feature-reference.html#subsystemclass" label="SubSystemClass">
 </topic><topic href="targets/eclipse-help/feature-reference.html#subsystemref" label="SubSystemRef">
+</topic><topic href="targets/eclipse-help/feature-reference.html#trpoint" label="TrPoint">
+</topic><topic href="targets/eclipse-help/feature-reference.html#transition" label="Transition">
+</topic><topic href="targets/eclipse-help/feature-reference.html#transitionpoint" label="TransitionPoint">
+</topic><topic href="targets/eclipse-help/feature-reference.html#triggeredtransition" label="TriggeredTransition">
 </topic>
 </topic><topic href="targets/eclipse-help/feature-reference.html#mappingmodel" label="MappingModel">
 </topic><topic href="targets/eclipse-help/feature-reference.html#physicalmodel" label="PhysicalModel">
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/CPBranchTransition.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/CPBranchTransition.html
new file mode 100644
index 000000000..c00599a38
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/CPBranchTransition.html
@@ -0,0 +1,3 @@
+<!--  generated by featurizer  -->
+<p>a choice point branch transition is an outgoing transition from a choice point and is traversed if its conditions is evaluated to true</p>
+<p>Transition tr3: cp cp0 -&gt; state1 {<br/> cond &rsquo;&lsquo;&lsquo;0&lt;=counter &amp;&amp; counter&lt;3&rsquo;&rsquo;&rsquo;<br/>}</p>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ChoicePoint.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ChoicePoint.html
new file mode 100644
index 000000000..77265f187
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ChoicePoint.html
@@ -0,0 +1,31 @@
+<!--  generated by featurizer  -->
+<p>a choice point is the state machine counterpart of a conditional statement</p>
+<pre><code class=room customHighlighted>	<span class=keyword>StateMachine</span> {
+		<span class=keyword>State</span> state0
+		<span class=keyword>State</span> state1
+		<span class=keyword>State</span> state2
+		<span class=keyword>State</span> state3
+		<span class=keyword>TransitionPoint</span> tr4
+		<span class=keyword>ChoicePoint</span> cp0
+		<span class=keyword>Transition</span> init0: <span class=keyword>initial</span> -&gt; state0
+		<span class=keyword>Transition</span> tr0: state0 -&gt; state1 {
+			<span class=keyword>triggers</span> {
+				&lt;in1: p0&gt;
+			}
+		}
+		<span class=keyword>Transition</span> tr1: state1 -&gt; <span class=keyword>cp</span> cp0 {
+			<span class=keyword>triggers</span> {
+				&lt;in1: p0&gt;
+			}
+		}
+		<span class=keyword>Transition</span> tr2: <span class=keyword>cp</span> cp0 -&gt; state3
+		<span class=keyword>Transition</span> tr3: <span class=keyword>cp</span> cp0 -&gt; state2 {
+			<span class=keyword>cond</span> <span class=string>&#39;&#39;&#39;true&#39;&#39;&#39;</span>
+		}
+		<span class=keyword>Transition</span> tr5:  <span class=keyword>my</span> tr4 -&gt; state0 {
+			<span class=keyword>triggers</span> {
+				&lt;in2: p0&gt;
+			}
+		}
+	}
+</code></pre>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ContinuationTransition.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ContinuationTransition.html
new file mode 100644
index 000000000..85175b1e3
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ContinuationTransition.html
@@ -0,0 +1,3 @@
+<!--  generated by featurizer  -->
+<p>the continuation transition is a transition with just an optional action code</p>
+<p>State running {<br/> subgraph {<br/> EntryPoint ep0<br/> State active<br/> Transition tr0: my ep0 -&gt; active<br/> }<br/>}</p>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/EntryPoint.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/EntryPoint.html
new file mode 100644
index 000000000..3ab8d464f
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/EntryPoint.html
@@ -0,0 +1,21 @@
+<!--  generated by featurizer  -->
+<p>an entry point is an explicit entry point in a sub state machine to which transitions in the parent state graph can connect</p>
+<pre><code class=room customHighlighted>	<span class=keyword>StateMachine</span> {
+		<span class=keyword>State</span> state0 {
+			<span class=keyword>subgraph</span> {
+				<span class=keyword>State</span> state0
+				<span class=keyword>EntryPoint</span> ep0
+				<span class=keyword>ExitPoint</span> ep1
+				<span class=keyword>Transition</span> tr0: <span class=keyword>my</span> ep0 -&gt; state0
+				<span class=keyword>Transition</span> tr1: state0 -&gt; <span class=keyword>my</span> ep1 {
+					<span class=keyword>triggers</span> {
+						&lt;in1: p0&gt;
+					}
+				}
+			}
+		}
+		<span class=keyword>State</span> state1
+		<span class=keyword>Transition</span> init0: <span class=keyword>initial</span> -&gt; ep0 <span class=keyword>of</span> state0
+		<span class=keyword>Transition</span> tr0: ep1 <span class=keyword>of</span> state0 -&gt; state1
+	}
+</code></pre>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ExitPoint.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ExitPoint.html
new file mode 100644
index 000000000..4b7a6254c
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/ExitPoint.html
@@ -0,0 +1,3 @@
+<!--  generated by featurizer  -->
+<p>an exit point is an explicit exit point in a sub state machine from which transitions in the parent state graph can start</p>
+<p>help</p>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/GuardedTransition.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/GuardedTransition.html
new file mode 100644
index 000000000..6d2f2e7dc
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/GuardedTransition.html
@@ -0,0 +1,3 @@
+<!--  generated by featurizer  -->
+<p>the guarded transition is used by data driven state machines to trigger state transitions</p>
+<p>Transition tr: running -&gt; running {<br/> guard &rsquo;&lsquo;&lsquo;data_counter_finish.finish == true &amp;&amp; data_finish_flag == false&rsquo;&rsquo;&lsquo;<br/> action &rsquo;&rsquo;&lsquo;++counter;&rsquo;&rsquo;&rsquo;<br/>}</p>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/InitialTransition.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/InitialTransition.html
new file mode 100644
index 000000000..192c2443a
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/InitialTransition.html
@@ -0,0 +1,3 @@
+<!--  generated by featurizer  -->
+<p>the initial transition is used to identify the initial state</p>
+<p>Transition init: initial -&gt; state0</p>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/PrimitiveType.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/PrimitiveType.html
index 482f17025..db0a7c739 100644
--- a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/PrimitiveType.html
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/PrimitiveType.html
@@ -1,6 +1,6 @@
 <!--  generated by featurizer  -->
 <p>A PrimitiveType is an abstraction of a target language&rsquo;s basic type (e.g. integer or boolean)</p>
-<pre><code class=room customHighlighted><span class=comment>// java
+<pre><code class=room customHighlighted><span class=comment>// Java
 </span><span class=keyword>PrimitiveType</span> boolean: <span class=keyword>ptBoolean</span> -&gt; boolean (Boolean) <span class=keyword>default</span> <span class=string>&quot;false&quot;</span>
 <span class=keyword>PrimitiveType</span> int16: <span class=keyword>ptInteger</span> -&gt; short (Short) <span class=keyword>default</span> <span class=string>&quot;0&quot;</span>
 
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/RefinedState.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/RefinedState.html
new file mode 100644
index 000000000..c8cd2ce86
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/RefinedState.html
@@ -0,0 +1,11 @@
+<!--  generated by featurizer  -->
+<p>A RefinedState refines a State of one of the Actor&rsquo;s base class state machines</p>
+<pre><code class=room customHighlighted>	<span class=keyword>RefinedState</span> BaseState {
+		<span class=keyword>exit</span> <span class=string>&#39;&#39;&#39;// this is derived exit code&#39;&#39;&#39;</span>
+		<span class=keyword>subgraph</span> {
+			<span class=comment>// add a sub state machine
+</span>			<span class=keyword>Transition</span> init: <span class=keyword>initial</span> -&gt; state0 { }
+			<span class=keyword>State</span> state0
+		}
+	}
+</code></pre>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/SimpleState.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/SimpleState.html
new file mode 100644
index 000000000..d032d034d
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/SimpleState.html
@@ -0,0 +1,33 @@
+<!--  generated by featurizer  -->
+<p>A State is a node in the state graph representation of the state machine</p>
+<pre><code class=room customHighlighted><span class=keyword>ActorClass</span> Example {
+	<span class=comment>//...
+</span>	<span class=keyword>Behavior</span> {
+		<span class=keyword>StateMachine</span> {
+			<span class=keyword>Transition</span> init: <span class=keyword>initial</span> -&gt; Standby
+			<span class=keyword>Transition</span> tr0: Standby -&gt; Running {
+				<span class=keyword>triggers</span> {
+					&lt;timeout: to&gt;
+				}
+			}
+			<span class=keyword>Transition</span> tr1: Running -&gt; Stopped {
+				<span class=keyword>triggers</span> {
+					&lt;timeout: to&gt;
+				}
+			}
+			<span class=keyword>State</span> Standby {
+				<span class=keyword>entry</span> <span class=string>&#39;&#39;&#39;
+					to.startTimeout(200*10);&#39;&#39;&#39;</span>
+			}
+			<span class=keyword>State</span> Running {
+				<span class=keyword>entry</span> <span class=string>&#39;&#39;&#39;
+					controllers.start();
+					to.startTimeout(200*10);&#39;&#39;&#39;</span>
+			}
+			<span class=keyword>State</span> Stopped {
+				<span class=keyword>entry</span> <span class=string>&#39;&#39;&#39;controllers.stop();&#39;&#39;&#39;</span>
+			}
+		}
+	}
+}
+</code></pre>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TrPoint.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TrPoint.html
new file mode 100644
index 000000000..d508117e0
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TrPoint.html
@@ -0,0 +1,3 @@
+<!--  generated by featurizer  -->
+<p>a TrPoint can be an EntryPoint, an ExitPoint or a TransitionPoint</p>
+<p>a TrPoint is an abstract element</p>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/Transition.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/Transition.html
new file mode 100644
index 000000000..dc7ac5abc
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/Transition.html
@@ -0,0 +1,9 @@
+<!--  generated by featurizer  -->
+<p>A Transition is an edge in the state graph representation of the state machine</p>
+<pre><code class=room customHighlighted>	<span class=keyword>Transition</span> init: <span class=keyword>initial</span> -&gt; Standby
+	<span class=keyword>Transition</span> tr0: Standby -&gt; Running {
+		<span class=keyword>triggers</span> {
+			&lt;timeout: to&gt;
+		}
+	}
+</code></pre>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TransitionPoint.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TransitionPoint.html
new file mode 100644
index 000000000..ddcc4f441
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TransitionPoint.html
@@ -0,0 +1,11 @@
+<!--  generated by featurizer  -->
+<p>a transition point is the starting point of transitions that trigger for any state of this state machine</p>
+<pre><code class=room customHighlighted>	<span class=keyword>StateMachine</span> {
+		<span class=keyword>TransitionPoint</span> tp1
+		<span class=keyword>Transition</span> tr1: <span class=keyword>my</span> tp1 -&gt; <span class=keyword>my</span> tp1 {
+			<span class=keyword>triggers</span> {
+				&lt;msg: port&gt;
+			}
+		}
+	}
+</code></pre>
\ No newline at end of file
diff --git a/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TriggeredTransition.html b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TriggeredTransition.html
new file mode 100644
index 000000000..927701086
--- /dev/null
+++ b/plugins/org.eclipse.etrice.doc/targets/keyword-hover/TriggeredTransition.html
@@ -0,0 +1,3 @@
+<!--  generated by featurizer  -->
+<p>a triggered transition is used in event driven state machines to trigger state transitions</p>
+<p>help</p>
\ No newline at end of file