<?xml version="1.0" encoding="UTF-8"?>
<Composite xmlns:j="clr-namespace:java.lang" xmlns="http://www.eclipse.org/xwt/presentation"
	xmlns:ppel="clr-namespace:org.eclipse.papyrus.infra.properties.ui.widgets.layout"
	xmlns:x="http://www.eclipse.org/xwt" xmlns:ppe="clr-namespace:org.eclipse.papyrus.infra.properties.ui.widgets">
	<Composite.layout>
		<ppel:PropertiesLayout></ppel:PropertiesLayout>
	</Composite.layout>
	<Composite>
		<Composite.layout>
			<ppel:PropertiesLayout numColumns="1"></ppel:PropertiesLayout>
		</Composite.layout>
		<ppe:StringMultiline input="{Binding}"
			property="layers:RegExpLayer:expr"></ppe:StringMultiline>
		<ppe:StringEditor input="{Binding}" property="layers:RegExpLayer:language"></ppe:StringEditor>
		<ppe:StringEditor input="{Binding}" property="layers:LayerExpression:name"></ppe:StringEditor>
		<ppe:StringMultiline input="{Binding}"
			property="layers:LayerExpression:description"></ppe:StringMultiline>
	</Composite>
	<Composite>
		<Composite.layout>
			<ppel:PropertiesLayout numColumns="2"></ppel:PropertiesLayout>
		</Composite.layout>
		<ppe:BooleanCheckbox input="{Binding}"
			property="layers:LayerExpression:isLayerEnabled"></ppe:BooleanCheckbox>
		<ppe:BooleanRadio input="{Binding}"
			property="layers:RegExpLayer:isDomainChangedEventDependant"></ppe:BooleanRadio>
		<ppe:BooleanRadio input="{Binding}"
			property="layers:RegExpLayer:isDiagramChangedEventDependant"></ppe:BooleanRadio>
	</Composite>
	<Composite>
		<Composite.layout>
			<ppel:PropertiesLayout numColumns="1"></ppel:PropertiesLayout>
		</Composite.layout>
		<ppe:EnumCombo input="{Binding}"
			property="layers:RegExpLayer:domainChangedEventLevel"></ppe:EnumCombo>
		<ppe:EnumCombo input="{Binding}"
			property="layers:RegExpLayer:diagramChangedEventLevel"></ppe:EnumCombo>
	</Composite>
	<Composite>
		<Composite.layout>
			<ppel:PropertiesLayout numColumns="1"></ppel:PropertiesLayout>
		</Composite.layout>
		<ppe:ReferenceLabel input="{Binding}"
			property="layers:AbstractLayer:layerDescriptor" readOnly="true"></ppe:ReferenceLabel>
		<ppe:ReferenceLabel input="{Binding}"
			property="layers:ApplicationDependantElement:application" readOnly="true"></ppe:ReferenceLabel>
	</Composite>
	<Composite>
		<Composite.layout>
			<ppel:PropertiesLayout numColumns="1"></ppel:PropertiesLayout>
		</Composite.layout>
		<ppe:MultiReference input="{Binding}"
			property="layers:AbstractLayer:propertyValues" readOnly="true"></ppe:MultiReference>
		<ppe:MultiReference input="{Binding}"
			property="layers:AbstractLayer:views"></ppe:MultiReference>
	</Composite>
</Composite>