<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.4"?>
<plugin>
<!-- Diagram declaration -->
<extension point="org.eclipse.papyrus.infra.ui.papyrusDiagram">
	<creationCommand creationCommandClass="org.eclipse.papyrus.sysml.diagram.internalblock.InternalBlockDiagramCreateCommand" creationCondition="org.eclipse.papyrus.sysml.diagram.internalblock.InternalBlockDiagramCondition" icon="icons/obj16/Diagram_InternalBlock.gif" id="org.eclipse.papyrus.sysml.diagram.internalblock.CreateCommand" language="sysml" label="Internal Block Diagram"></creationCommand>
	<editorDiagram actionBarContributorId="org.eclipse.papyrus.uml.diagram.common.part.UMLDiagramActionBarContributor" factoryClass="org.eclipse.papyrus.sysml.diagram.internalblock.InternalBlockDiagramEditorFactory" icon="icons/obj16/Diagram_InternalBlock.gif"></editorDiagram>
</extension>

<!-- Diagram creation command and handler -->
<extension point="org.eclipse.ui.commands">
	<command id="org.eclipse.papyrus.sysml.diagram.internalblock.CreateCommand" name="Create a new Internal Block Diagram" description="Create a new Internal Block Diagram" categoryId="org.eclipse.papyrus.editor.category"></command>
</extension>


<!-- Diagram view providers declaration -->
<extension point="org.eclipse.gmf.runtime.diagram.core.viewProviders">

	<!-- Diagram view provider -->
	<viewProvider class="org.eclipse.papyrus.sysml.diagram.internalblock.provider.InternalBlockDiagramViewProvider">
		<Priority name="Low"></Priority>
		<context viewClass="org.eclipse.gmf.runtime.notation.Diagram" semanticHints="InternalBlock"></context>
	</viewProvider>

	<!-- Custom graphical types view provider -->
	<viewProvider class="org.eclipse.papyrus.sysml.diagram.internalblock.provider.CustomViewProvider">
		<Priority name="Medium"></Priority>
		<context viewClass="org.eclipse.gmf.runtime.notation.Node" semanticHints="UML::Property, SysML::ActorPartProperty, SysML::ValueProperty, SysML::ReferenceProperty, SysML::FlowPort_In, UML::Port, SysML::FlowPort_Out, SysML::PartProperty, SysML::FlowPort_InOut, SysML::FlowPort, SysML::Block, SysML::FlowPort_NA"></context>
		<context viewClass="org.eclipse.gmf.runtime.notation.Node" semanticHints="shape_sysml_flowport_as_affixed, shape_sysml_block_as_composite, shape_uml_port_as_affixed, shape_sysml_blockproperty_as_composite, compartment_sysml_blockproperty_structure"></context>
		<context viewClass="org.eclipse.gmf.runtime.notation.Edge" semanticHints="UML::Dependency, UML::Connector"></context>
		<context viewClass="org.eclipse.gmf.runtime.notation.Edge" semanticHints="link_uml_connector, link_uml_dependency"></context>
		
		<!-- Additional descriptors provided in case the semantic hint is is not provided -->	
		
		<!-- "uml.Class" -->
		<object id="uml.Class" class="org.eclipse.gmf.runtime.emf.core.util.IProxyEObject(org.eclipse.gmf.runtime.emf.core)">
			<method name="getProxyClassID()" value="uml.Class"></method>
		</object>
		<context
        elements="uml.Class"
        viewClass="org.eclipse.gmf.runtime.notation.Node"></context>			
		
		<!-- "uml.Port" -->
		<object id="uml.Port" class="org.eclipse.gmf.runtime.emf.core.util.IProxyEObject(org.eclipse.gmf.runtime.emf.core)">
			<method name="getProxyClassID()" value="uml.Port"></method>
		</object>
		<context viewClass="org.eclipse.gmf.runtime.notation.Node" elements="uml.Port"></context>			
		
		<!-- "uml.Property" -->
		<object id="uml.Property" class="org.eclipse.gmf.runtime.emf.core.util.IProxyEObject(org.eclipse.gmf.runtime.emf.core)">
			<method name="getProxyClassID()" value="uml.Property"></method>
		</object>
		<context viewClass="org.eclipse.gmf.runtime.notation.Node"  elements="uml.Property"></context>			
		
		<!-- "uml.Connector" -->
		<object id="uml.Connector" class="org.eclipse.gmf.runtime.emf.core.util.IProxyEObject(org.eclipse.gmf.runtime.emf.core)">
			<method name="getProxyClassID()" value="uml.Connector"></method>
		</object>
		<context viewClass="org.eclipse.gmf.runtime.notation.Edge" elements="uml.Connector"></context>			
		
		<!-- "uml.Dependency" -->
		<object id="uml.Dependency" class="org.eclipse.gmf.runtime.emf.core.util.IProxyEObject(org.eclipse.gmf.runtime.emf.core)">
			<method name="getProxyClassID()" value="uml.Dependency"></method>
		</object>
		<context viewClass="org.eclipse.gmf.runtime.notation.Edge" elements="uml.Dependency"></context>
 
 
 	 <object id="elementtype.node"
        class="org.eclipse.papyrus.gmf.diagram.common.commands.ISemanticHintAdapter(org.eclipse.papyrus.sysml.diagram.common)">
       
     <method
           name="getSemanticHint()"
           value="UML::Property, SysML::ActorPartProperty, SysML::ValueProperty, SysML::ReferenceProperty, SysML::FlowPort_In, UML::Port, SysML::FlowPort_Out, SysML::PartProperty, SysML::FlowPort_InOut, SysML::FlowPort, SysML::Block, SysML::FlowPort_NA">
     </method>
  </object>
  <context
        elements="elementtype.node"
        viewClass="org.eclipse.gmf.runtime.notation.Node">
  </context>
  <object id="elementtype.edge"
        class="org.eclipse.papyrus.gmf.diagram.common.commands.ISemanticHintAdapter(org.eclipse.papyrus.sysml.diagram.common)">
     <method
           name="getSemanticHint()"
           value="UML::Dependency, UML::Connector">
     </method>
  </object>
  <context
        elements="elementtype.edge"
        viewClass="org.eclipse.gmf.runtime.notation.Edge">
  </context>			
		
	</viewProvider>	

	<!-- ViewProvider for inherited elements (from CompositeDiagram ViewProvider) -->
	<viewProvider class="org.eclipse.papyrus.sysml.diagram.internalblock.provider.InheritedCompositeDiagramViewProvider">
		<Priority name="Low"></Priority>
		
		<!-- Load the ViewProvider on following SemanticHint related to IElementType(s) used in the palette (also used for legacy elements) -->
		<context viewClass="org.eclipse.gmf.runtime.notation.Node" semanticHints="UML::Comment, UML::Constraint"></context>
		
		<context viewClass="org.eclipse.gmf.runtime.notation.Node" semanticHints="Comment_Shape, Comment_Shape_CN, Constraint_Shape, Constraint_Shape_CN"></context>
		
		<context viewClass="org.eclipse.gmf.runtime.notation.Edge" semanticHints="Comment_AnnotatedElementEdge, Constraint_ConstrainedElementEdge"></context>
        
		<!-- Additional descriptors provided in case the semantic hint is is not provided -->	
		
        <!-- "uml.Comment" -->
		<object id="uml.Comment" class="org.eclipse.gmf.runtime.emf.core.util.IProxyEObject(org.eclipse.gmf.runtime.emf.core)">
			<method name="getProxyClassID()" value="uml.Comment"></method>
		</object>

        <!-- "uml.Constraint" -->
		<object id="uml.Constraint" class="org.eclipse.gmf.runtime.emf.core.util.IProxyEObject(org.eclipse.gmf.runtime.emf.core)">
			<method name="getProxyClassID()" value="uml.Constraint"></method>
		</object>

		<!-- Additional activation contexts for nodes semantic objects -->
		<context viewClass="org.eclipse.gmf.runtime.notation.Node" elements="uml.Comment, uml.Constraint"></context>
			
	</viewProvider>
	
</extension>

<!-- Diagram edit part providers declaration -->
<extension point="org.eclipse.gmf.runtime.diagram.ui.editpartProviders">

	<!-- Diagram edit part provider -->
	<editpartProvider class="org.eclipse.papyrus.sysml.diagram.internalblock.provider.InternalBlockDiagramEditPartProvider">
		<Priority name="Low"></Priority>
		<object id="org.eclipse.papyrus.sysml.diagram.internalblock.Diagram" class="org.eclipse.gmf.runtime.notation.Diagram">
			<method name="getType()" value="InternalBlock"></method>
		</object>
		<context views="org.eclipse.papyrus.sysml.diagram.internalblock.Diagram"></context>	
	</editpartProvider>
	
	<!-- Custom graphical types edit part provider -->
	<editpartProvider class="org.eclipse.papyrus.sysml.diagram.internalblock.provider.CustomEditPartProvider">
		<Priority name="Medium"></Priority>
	
		<object class="org.eclipse.gmf.runtime.notation.Node(org.eclipse.gmf.runtime.notation)" id="org.eclipse.papyrus.sysml.diagram.internalblock.CustomNodeGraphicalTypes">
			<method name="getType()" value="shape_sysml_flowport_as_affixed, shape_sysml_block_as_composite, shape_uml_port_as_affixed, shape_sysml_blockproperty_as_composite"></method>
		</object>
		
		<object class="org.eclipse.gmf.runtime.notation.Node(org.eclipse.gmf.runtime.notation)" id="org.eclipse.papyrus.sysml.diagram.internalblock.CustomGraphicalTypes_Decorations">
			<method name="getType()" value="linklabel_uml_connector_target_multiplicity, label_uml_property_label, linklabel_uml_appliedstereotype, label_sysml_block_name, compartment_sysml_structure, affixedlabel_uml_port_label, linklabel_uml_connector_source_multiplicity, linklabel_uml_namedelement_name, linklabel_uml_connector_label, compartment_sysml_blockproperty_structure, affixedlabel_uml_appliedstereotype, affixedlabel_sysml_flowport_label"></method>
		</object>
		
		<context views="org.eclipse.papyrus.sysml.diagram.internalblock.CustomNodeGraphicalTypes"></context>
		<context views="org.eclipse.papyrus.sysml.diagram.internalblock.CustomGraphicalTypes_Decorations"></context>
	
		<object class="org.eclipse.gmf.runtime.notation.Edge(org.eclipse.gmf.runtime.notation)" id="org.eclipse.papyrus.sysml.diagram.internalblock.CustomEdgeGraphicalTypes">
			<method name="getType()" value="link_uml_connector, link_uml_dependency"></method>
		</object>
		
		<context views="org.eclipse.papyrus.sysml.diagram.internalblock.CustomEdgeGraphicalTypes"></context>
		
	</editpartProvider>
	
	<!-- EditPartProvider for inherited elements (from CompositeDiagram) -->
	<editpartProvider class="org.eclipse.papyrus.sysml.diagram.internalblock.provider.InheritedCompositeDiagramEditPartProvider">
		<Priority name="Low"></Priority>
		
		<object id="COMMENT" class="org.eclipse.gmf.runtime.notation.Node">
			<method name="getType()" value="Comment_Shape, Comment_BodyLabel"></method>
		</object>
		<object id="COMMENT_CN" class="org.eclipse.gmf.runtime.notation.Node">
			<method name="getType()" value="Comment_Shape_CN, Comment_BodyLabel_CN"></method>
		</object>
		<object id="CONSTRAINT" class="org.eclipse.gmf.runtime.notation.Node">
			<method name="getType()" value="Constraint_Shape, Constraint_NameLabel, Constraint_BodyLabel"></method>
		</object>
		<object id="CONSTRAINT_CN" class="org.eclipse.gmf.runtime.notation.Node">
			<method name="getType()" value="Constraint_Shape_CN, Constraint_NameLabel_CN, Constraint_BodyLabel_CN"></method>
		</object>

		<object id="COMMENT_ANNOTATED_ELEMENT" class="org.eclipse.gmf.runtime.notation.Edge">
			<method name="getType()" value="Comment_AnnotatedElementEdge"></method>
		</object>
		<object id="CONSTRAINT_CONSTRAINED_ELEMENT" class="org.eclipse.gmf.runtime.notation.Edge">
			<method name="getType()" value="Constraint_ConstrainedElementEdge"></method>
		</object>

		<context views="COMMENT, COMMENT_CN, CONSTRAINT, CONSTRAINT_CN"></context>
		<context views="COMMENT_ANNOTATED_ELEMENT, CONSTRAINT_CONSTRAINED_ELEMENT"></context>
		
	</editpartProvider>
	
</extension>

<!-- Diagram edit policy provider -->	
<extension point="org.eclipse.gmf.runtime.diagram.ui.editpolicyProviders">
	<editpolicyProvider class="org.eclipse.papyrus.sysml.diagram.internalblock.provider.CustomEditPolicyProvider">
		<Priority name="Low"></Priority>
	</editpolicyProvider>
</extension>

<!-- Preference pages declaration -->
<extension point="org.eclipse.ui.preferencePages" id="prefpages">

	<!-- Diagram Preference pages declaration -->
	<page id="org.eclipse.papyrus.sysml.diagram.internalblock.preferences" name="Internal Block Diagram" category="org.eclipse.papyrus.infra.gmfdiag.preferences.diagrams" class="org.eclipse.papyrus.sysml.diagram.internalblock.preferences.InternalBlockDiagramGeneralPreferencePage">
	</page>

</extension>

<!-- // Start of user code custom extensions 
  -->

<!-- Insert custom extensions here. -->



<!-- 
	Handler declaration for the Interface Manager Command. 
	The handler is enabled only if the selected element is a Port (excluding FlowPort) in an InternalBlockDiagram.
  -->
<extension point="org.eclipse.ui.handlers">

	<handler commandId="org.eclipse.papyrus.sysml.diagram.internalblock.command.manage.interfaces" class="org.eclipse.papyrus.sysml.diagram.internalblock.handler.InternalBlockManageInterfacesHandler">
		<activeWhen>
		<and>
			<with variable="selection">
			<iterate>
				<instanceof value="org.eclipse.papyrus.uml.diagram.common.edit.part.PortAffixedNodeEditPart"></instanceof>
			</iterate>
			</with>
			
			<with variable="activeEditor">
			<test property="org.eclipse.papyrus.uml.diagram.common.diagram.tester.diagramType" value="InternalBlock" forcePluginActivation="true"></test>
			</with>
			
			<with variable="selection">
			<test property="org.eclipse.papyrus.sysml.diagram.internalblock.tester.selection.isFlowPort" value="false" forcePluginActivation="true"></test>              
			</with>
		</and>
		</activeWhen>
	</handler>
</extension>

<!-- 
	Add a property tester for this diagram. 
	The tested properties allow to enable/disable handlers for commands .
  -->
<extension point="org.eclipse.core.expressions.propertyTesters">
	<propertyTester id="org.eclipse.papyrus.sysml.diagram.internalblock.tester.selection" type="org.eclipse.jface.viewers.ISelection" namespace="org.eclipse.papyrus.sysml.diagram.internalblock.tester.selection" properties="isFlowPort" class="org.eclipse.papyrus.sysml.diagram.internalblock.utils.InternalBlockDiagramTester">
	</propertyTester>
</extension>

<!-- The Command to manages the Provided and Required Interfaces for a Port-->
<extension point="org.eclipse.ui.commands">
	<command categoryId="org.eclipse.papyrus.editor.category" id="org.eclipse.papyrus.sysml.diagram.internalblock.command.manage.interfaces" name="Manage Provided Interfaces" description="Allows to manage easily provided Interfaces for a Port">
	</command>
</extension>

<!-- Add the Menu to manages the Provided and Required Interfaces for a Port-->
<extension point="org.eclipse.ui.menus">
	<menuContribution locationURI="popup:org.eclipse.gmf.runtime.diagram.ui.DiagramEditorContextMenu?endof=editMenu" allPopups="false">
	<command commandId="org.eclipse.papyrus.sysml.diagram.internalblock.command.manage.interfaces" icon="platform:/plugin/org.eclipse.uml2.uml.edit/icons/full/obj16/Interface.gif" id="org.eclipse.papyrus.sysml.diagram.internalblock.popup.interface.manage.interface" label="Manage Interfaces" mnemonic="&amp;I" style="push" tooltip="The command to manage the interfaces provided and required by a Port">
		<!-- The action is visible only if there is an active handler for it  -->
		<visibleWhen checkEnabled="true"></visibleWhen>
	</command>
	</menuContribution>
</extension>

<!-- Parser provider declaration -->
<extension point="org.eclipse.gmf.runtime.common.ui.services.parserProviders">
	<ParserProvider class="org.eclipse.papyrus.sysml.diagram.internalblock.provider.ParserProvider">
		<Priority name="Low"></Priority>
	</ParserProvider>
</extension>

<!-- Diagram specific advices -->
<extension point="org.eclipse.gmf.runtime.emf.type.core.elementTypes">

	<metamodel nsURI="http://www.eclipse.org/uml2/5.0.0/UML">

	<!-- Property specific advices (remove inconsistent views when a Property type is set) -->		
	<adviceBinding id="org.eclipse.papyrus.sysml.diagram.internalblock.PropertyHelperAdvice" class="org.eclipse.papyrus.sysml.diagram.internalblock.helper.advice.PropertyHelperAdvice" inheritance="all" typeId="org.eclipse.papyrus.uml.Property">
	</adviceBinding>
	
	<!-- Delete moved views advice -->		
	<adviceBinding id="org.eclipse.papyrus.sysml.diagram.internalblock.DeleteViewDuringMoveHelperAdvice" class="org.eclipse.papyrus.sysml.diagram.internalblock.helper.advice.DeleteViewDuringMoveHelperAdvice" inheritance="all" typeId="org.eclipse.papyrus.uml.Element">
	</adviceBinding>
				
	</metamodel>
</extension>

<!-- UML ElementType bindings to Papyrus shared IClientContext -->
<extension point="org.eclipse.gmf.runtime.emf.type.core.elementTypeBindings">

	<!-- Bindings declaration to shared IClientContext -->
	<binding context="org.eclipse.papyrus.infra.services.edit.TypeContext">	
		<elementType ref="org.eclipse.papyrus.sysml.diagram.internalblock.PropertyHelperAdvice"></elementType>
		<elementType ref="org.eclipse.papyrus.sysml.diagram.internalblock.DeleteViewDuringMoveHelperAdvice"></elementType>
	</binding>
		
</extension>

<!-- Service for Show/Hide content on Part or Ref. -->
<extension point="org.eclipse.ui.services">
	<sourceProvider provider="org.eclipse.papyrus.sysml.diagram.internalblock.provider.ActionStateSourceProvider">
		<variable name="showHideRelatedContents" priorityLevel="workbench"></variable>
	</sourceProvider>
</extension>

<!-- Handler for Show/Hide content on Part or Ref. -->
<extension point="org.eclipse.ui.handlers">
	<handler class="org.eclipse.papyrus.sysml.diagram.internalblock.handler.ShowHideRelatedContentsHandler" commandId="org.eclipse.papyrus.uml.diagram.menu.commands.ShowHideContentsCommand">
		<activeWhen>
		<and>
			<with variable="activeEditor">
				<test property="org.eclipse.papyrus.uml.diagram.common.diagram.tester.diagramType" value="InternalBlock" forcePluginActivation="true"></test>
			</with>	
			<with variable="showHideRelatedContents">
				<equals value="enabled"></equals>
			</with>
			<with variable="selection">
				<iterate ifEmpty="false" operator="and">
					<instanceof value="org.eclipse.papyrus.sysml.diagram.parametric.edit.part.CustomBlockCompositeEditPartTN"></instanceof>
				</iterate>
			</with>
		</and>
		</activeWhen>
	</handler>
</extension>

<!-- Validation markers declaration -->
<extension point="org.eclipse.gmf.runtime.common.ui.services.markerNavigationProviders" id="markers-navigation">
	<MarkerNavigationProvider class="org.eclipse.papyrus.gmf.diagram.common.provider.MarkerNavigationProvider">
		<MarkerType name="org.eclipse.papyrus.sysml.diagram.internalblock.diagnostic"></MarkerType>
		<Priority name="Lowest"></Priority>
	</MarkerNavigationProvider>
</extension>

<extension id="diagnostic" name="Internal Block Diagram  problems" point="org.eclipse.core.resources.markers">
	<super type="org.eclipse.core.resources.problemmarker"></super>
	<super type="org.eclipse.gmf.runtime.common.ui.services.marker"></super>
	<persistent value="true"></persistent>
</extension>

<extension id="validationDecoratorProvider" name="ValidationDecorations" point="org.eclipse.gmf.runtime.diagram.ui.decoratorProviders">
	<decoratorProvider class="org.eclipse.papyrus.sysml.diagram.internalblock.provider.ValidationDecoratorProvider">
		<Priority name="Lowest"></Priority>
		<object class="org.eclipse.gmf.runtime.diagram.ui.editparts.IPrimaryEditPart(org.eclipse.gmf.runtime.diagram.ui)" id="PRIMARY_VIEW"></object>
		<context decoratorTargets="PRIMARY_VIEW"></context>
	</decoratorProvider>
</extension>



<!-- // End of user code 
  -->
<extension point="org.eclipse.papyrus.infra.gmfdiag.common.notationTypesMapping">
   <diagramMappings diagramID="InternalBlock">
      <mapping type="InternalBlock" humanReadableType="InternalBlockDiagram"/>
      <!-- Compartments -->
      <mapping
             humanReadableType="structure"
             type="compartment_sysml_structure">
      </mapping>
      
      <mapping
             humanReadableType="structure"
             type="compartment_sysml_blockproperty_structure">
      </mapping>
   
                      <!-- Link labels -->

      <mapping
             humanReadableType="Name"
             type="affixedlabel_sysml_flowport_label">
      </mapping>
      
      <mapping
             humanReadableType="Stereotype"
             type="affixedlabel_uml_appliedstereotype">
      </mapping>
      
      <mapping
             humanReadableType="Label"
             type="affixedlabel_uml_port_label">
      </mapping>
   
      <mapping
             humanReadableType="Stereotype"
             type="linklabel_uml_appliedstereotype">
      </mapping>
      
      <mapping
             humanReadableType="Name"
             type="linklabel_uml_connector_label">
      </mapping>
      
      <mapping
             humanReadableType="SourceMultiplicity"
             type="linklabel_uml_connector_source_multiplicity">
      </mapping>
      
      <mapping
             humanReadableType="TargetMultiplicity"
             type="linklabel_uml_connector_target_multiplicity">
      </mapping>
      
      <mapping
             humanReadableType="Name"
             type="linklabel_uml_namedelement_name">
      </mapping>
   
          </diagramMappings>
   </extension>
 
<extension id="org.eclipse.papyrus.sysml.diagram.internalblock.migration" name="InternalBlockMigration" point="org.eclipse.papyrus.infra.gmfdiag.common.diagramReconciler">
   <diagramReconciler
         diagramType="InternalBlock"
         reconcilerClass="org.eclipse.papyrus.sysml.diagram.internalblock.migration.InternalBlockDiagramReconcilerUndefinedTo100"
         source="undefined"
         target="1.3.0">
   </diagramReconciler>
   <diagramReconciler
         diagramType="InternalBlock"
         reconcilerClass="org.eclipse.papyrus.uml.diagram.composite.custom.migration.CompositeReconciler_1_1_0"
         source="1.0.0"
         target="1.3.0">
   </diagramReconciler>
   <diagramReconciler
         diagramType="InternalBlock"
         reconcilerClass="org.eclipse.papyrus.uml.diagram.composite.custom.migration.CompositeReconcilerForCompartment_1_2_0"
         source="1.1.0"
         target="1.3.0">
   </diagramReconciler>
   <diagramReconciler
         diagramType="InternalBlock"
         reconcilerClass="org.eclipse.papyrus.uml.diagram.composite.custom.migration.CompositeReconciler_1_2_0"
         source="1.1.0"
         target="1.3.0">
   </diagramReconciler>
</extension>

   <extension
         point="org.eclipse.papyrus.infra.gmfdiag.common.visualTypeProviders">
      <visualTypeProvider
            class="org.eclipse.papyrus.sysml.diagram.internalblock.provider.InternalBlockVisualTypeProvider"
            diagramType="InternalBlock">
      </visualTypeProvider>
   </extension>

<extension point="org.eclipse.papyrus.infra.gmfdiag.common.paletteDefinition">
	<paletteDefinition
		ID="org.eclipse.papyrus.sysml.diagram.internalblock.paletteconfiguration"
		class="org.eclipse.papyrus.infra.gmfdiag.common.service.palette.ExtendedPluginPaletteProvider"
		name="Papyrus SysML internalblock editor Plugin Palette" 
		path="palettes/PapyrusSysMLInternalBlockDiagram.paletteconfiguration"
		provider="Eclipse Modeling Project">
		<Priority
			name="Lowest">
		</Priority>
		<!-- Specify diagram this palette tools relate to -->
		<editor
			id="org.eclipse.papyrus.sysml.diagram.internalblock">
		</editor>
	</paletteDefinition>
</extension>
</plugin>
