diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/.classpath b/common/plugins/org.eclipse.papyrus.interoperability.common/.classpath
new file mode 100644
index 0000000..f0c5549
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="src-gen"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/.gitignore b/common/plugins/org.eclipse.papyrus.interoperability.common/.gitignore
new file mode 100755
index 0000000..ae3c172
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/.project b/common/plugins/org.eclipse.papyrus.interoperability.common/.project
new file mode 100644
index 0000000..eb7bcd9
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.papyrus.interoperability.common</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/.settings/org.eclipse.jdt.core.prefs b/common/plugins/org.eclipse.papyrus.interoperability.common/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..b3aa6d6
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,291 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
+org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_assignment=0
+org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
+org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0
+org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
+org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0
+org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=80
+org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16
+org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_after_package=1
+org.eclipse.jdt.core.formatter.blank_lines_before_field=0
+org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0
+org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
+org.eclipse.jdt.core.formatter.blank_lines_before_method=1
+org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
+org.eclipse.jdt.core.formatter.blank_lines_before_package=0
+org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1
+org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
+org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_lambda_body=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false
+org.eclipse.jdt.core.formatter.comment.format_block_comments=true
+org.eclipse.jdt.core.formatter.comment.format_header=false
+org.eclipse.jdt.core.formatter.comment.format_html=true
+org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true
+org.eclipse.jdt.core.formatter.comment.format_line_comments=true
+org.eclipse.jdt.core.formatter.comment.format_source_code=true
+org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
+org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
+org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
+org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert
+org.eclipse.jdt.core.formatter.comment.line_length=260
+org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true
+org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true
+org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments=false
+org.eclipse.jdt.core.formatter.compact_else_if=true
+org.eclipse.jdt.core.formatter.continuation_indentation=2
+org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
+org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off
+org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on
+org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false
+org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
+org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_empty_lines=false
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=false
+org.eclipse.jdt.core.formatter.indentation.size=4
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
+org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources=insert
+org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert
+org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.join_lines_in_comments=false
+org.eclipse.jdt.core.formatter.join_wrapped_lines=false
+org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.lineSplit=260
+org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
+org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=5
+org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
+org.eclipse.jdt.core.formatter.tabulation.char=tab
+org.eclipse.jdt.core.formatter.tabulation.size=4
+org.eclipse.jdt.core.formatter.use_on_off_tags=false
+org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
+org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true
+org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/.settings/org.eclipse.jdt.ui.prefs b/common/plugins/org.eclipse.papyrus.interoperability.common/.settings/org.eclipse.jdt.ui.prefs
new file mode 100644
index 0000000..954281d
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/.settings/org.eclipse.jdt.ui.prefs
@@ -0,0 +1,68 @@
+cleanup.add_default_serial_version_id=true
+cleanup.add_generated_serial_version_id=false
+cleanup.add_missing_annotations=true
+cleanup.add_missing_deprecated_annotations=true
+cleanup.add_missing_methods=false
+cleanup.add_missing_nls_tags=false
+cleanup.add_missing_override_annotations=true
+cleanup.add_missing_override_annotations_interface_methods=true
+cleanup.add_serial_version_id=false
+cleanup.always_use_blocks=true
+cleanup.always_use_parentheses_in_expressions=false
+cleanup.always_use_this_for_non_static_field_access=false
+cleanup.always_use_this_for_non_static_method_access=false
+cleanup.convert_functional_interfaces=false
+cleanup.convert_to_enhanced_for_loop=false
+cleanup.correct_indentation=false
+cleanup.format_source_code=false
+cleanup.format_source_code_changes_only=false
+cleanup.insert_inferred_type_arguments=false
+cleanup.make_local_variable_final=true
+cleanup.make_parameters_final=false
+cleanup.make_private_fields_final=true
+cleanup.make_type_abstract_if_missing_method=false
+cleanup.make_variable_declarations_final=false
+cleanup.never_use_blocks=false
+cleanup.never_use_parentheses_in_expressions=true
+cleanup.organize_imports=false
+cleanup.qualify_static_field_accesses_with_declaring_class=false
+cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true
+cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true
+cleanup.qualify_static_member_accesses_with_declaring_class=true
+cleanup.qualify_static_method_accesses_with_declaring_class=false
+cleanup.remove_private_constructors=true
+cleanup.remove_redundant_type_arguments=true
+cleanup.remove_trailing_whitespaces=true
+cleanup.remove_trailing_whitespaces_all=true
+cleanup.remove_trailing_whitespaces_ignore_empty=false
+cleanup.remove_unnecessary_casts=true
+cleanup.remove_unnecessary_nls_tags=true
+cleanup.remove_unused_imports=true
+cleanup.remove_unused_local_variables=false
+cleanup.remove_unused_private_fields=true
+cleanup.remove_unused_private_members=false
+cleanup.remove_unused_private_methods=true
+cleanup.remove_unused_private_types=true
+cleanup.sort_members=false
+cleanup.sort_members_all=false
+cleanup.use_anonymous_class_creation=false
+cleanup.use_blocks=true
+cleanup.use_blocks_only_for_return_and_throw=false
+cleanup.use_lambda=true
+cleanup.use_parentheses_in_expressions=false
+cleanup.use_this_for_non_static_field_access=false
+cleanup.use_this_for_non_static_field_access_only_if_necessary=true
+cleanup.use_this_for_non_static_method_access=false
+cleanup.use_this_for_non_static_method_access_only_if_necessary=true
+cleanup.use_type_arguments=false
+cleanup_profile=_Papyrus
+cleanup_settings_version=2
+eclipse.preferences.version=1
+formatter_profile=_Papyrus
+formatter_settings_version=12
+org.eclipse.jdt.ui.ignorelowercasenames=true
+org.eclipse.jdt.ui.importorder=java;javax;org;com;
+org.eclipse.jdt.ui.javadoc=true
+org.eclipse.jdt.ui.ondemandthreshold=99
+org.eclipse.jdt.ui.staticondemandthreshold=99
+org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8" standalone\="no"?><templates><template autoinsert\="true" context\="gettercomment_context" deleted\="false" description\="Comment for getter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.gettercomment" name\="gettercomment">/**\n * @return the ${bare_field_name}\n */</template><template autoinsert\="true" context\="settercomment_context" deleted\="false" description\="Comment for setter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.settercomment" name\="settercomment">/**\n * @param ${param} the ${bare_field_name} to set\n */</template><template autoinsert\="false" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/**\n * Constructor.\n *\n * ${tags}\n */</template><template autoinsert\="false" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/*****************************************************************************\n * Copyright (c) ${year} CEA LIST and others.\n * \n * All rights reserved. This program and the accompanying materials\n * are made available under the terms of the Eclipse Public License v1.0\n * which accompanies this distribution, and is available at\n * http\://www.eclipse.org/legal/epl-v10.html\n *\n * Contributors\:\n *   CEA LIST - Initial API and implementation\n *   \n *****************************************************************************/\n</template><template autoinsert\="true" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/**\n * @author ${user}\n *\n * ${tags}\n */</template><template autoinsert\="true" context\="fieldcomment_context" deleted\="false" description\="Comment for fields" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.fieldcomment" name\="fieldcomment">/**\n * \n */</template><template autoinsert\="true" context\="methodcomment_context" deleted\="false" description\="Comment for non-overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodcomment" name\="methodcomment">/**\n * ${tags}\n */</template><template autoinsert\="false" context\="overridecomment_context" deleted\="false" description\="Comment for overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.overridecomment" name\="overridecomment">/**\n * ${see_to_overridden}\n *\n * ${tags}\n */</template><template autoinsert\="false" context\="delegatecomment_context" deleted\="false" description\="Comment for delegate methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.delegatecomment" name\="delegatecomment">/**\n * ${see_to_target}\n *\n * ${tags}\n */</template><template autoinsert\="true" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">${filecomment}\n${package_declaration}\n\n${typecomment}\n${type_declaration}</template><template autoinsert\="true" context\="classbody_context" deleted\="false" description\="Code in new class type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.classbody" name\="classbody">\n</template><template autoinsert\="true" context\="interfacebody_context" deleted\="false" description\="Code in new interface type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.interfacebody" name\="interfacebody">\n</template><template autoinsert\="true" context\="enumbody_context" deleted\="false" description\="Code in new enum type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.enumbody" name\="enumbody">\n</template><template autoinsert\="true" context\="annotationbody_context" deleted\="false" description\="Code in new annotation type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.annotationbody" name\="annotationbody">\n</template><template autoinsert\="true" context\="catchblock_context" deleted\="false" description\="Code in new catch blocks" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.catchblock" name\="catchblock">// ${todo} Auto-generated catch block\n${exception_var}.printStackTrace();</template><template autoinsert\="true" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ${todo} Auto-generated method stub\n${body_statement}</template><template autoinsert\="true" context\="constructorbody_context" deleted\="false" description\="Code in created constructor stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorbody" name\="constructorbody">${body_statement}\n// ${todo} Auto-generated constructor stub</template><template autoinsert\="true" context\="getterbody_context" deleted\="false" description\="Code in created getters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.getterbody" name\="getterbody">return ${field};</template><template autoinsert\="true" context\="setterbody_context" deleted\="false" description\="Code in created setters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.setterbody" name\="setterbody">${field} \= ${param};</template></templates>
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/META-INF/MANIFEST.MF b/common/plugins/org.eclipse.papyrus.interoperability.common/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..db7e41d
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/META-INF/MANIFEST.MF
@@ -0,0 +1,38 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %pluginName
+Bundle-SymbolicName: org.eclipse.papyrus.interoperability.common;singleton:=true
+Bundle-Version: 0.7.0.qualifier
+Bundle-ClassPath: .
+Bundle-Activator: org.eclipse.papyrus.interoperability.common.Activator
+Bundle-Vendor: %providerName
+Bundle-Localization: plugin
+Require-Bundle: org.eclipse.ui,
+ org.eclipse.core.runtime;resolution:=optional;x-installation:=greedy,
+ org.eclipse.emf.ecore;bundle-version="2.13.0";visibility:=reexport,
+ org.eclipse.uml2.types;bundle-version="2.0.0";visibility:=reexport,
+ org.eclipse.papyrus.infra.emf;bundle-version="2.2.0",
+ org.eclipse.papyrus.infra.core.log;bundle-version="1.2.0",
+ org.eclipse.papyrus.infra.widgets;bundle-version="3.0.0",
+ org.eclipse.papyrus.infra.properties.ui;bundle-version="2.0.0",
+ org.eclipse.ui.console;bundle-version="3.6.200",
+ org.eclipse.uml2.uml;bundle-version="5.2.0",
+ org.eclipse.papyrus.uml.tools;bundle-version="3.0.0",
+ org.eclipse.gmf.runtime.notation;bundle-version="1.8.0",
+ org.eclipse.m2m.qvt.oml;bundle-version="3.7.0",
+ org.eclipse.papyrus.uml.extensionpoints;bundle-version="1.2.0",
+ org.eclipse.papyrus.m2m.qvto;bundle-version="1.4.0",
+ org.eclipse.papyrus.uml.modelrepair;bundle-version="2.0.0"
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Bundle-ActivationPolicy: lazy
+Export-Package: org.eclipse.papyrus.interoperability.common,
+ org.eclipse.papyrus.interoperability.common.MigrationParameters,
+ org.eclipse.papyrus.interoperability.common.MigrationParameters.impl,
+ org.eclipse.papyrus.interoperability.common.MigrationParameters.util,
+ org.eclipse.papyrus.interoperability.common.concurrent,
+ org.eclipse.papyrus.interoperability.common.handler,
+ org.eclipse.papyrus.interoperability.common.internal.extension,
+ org.eclipse.papyrus.interoperability.common.transformation,
+ org.eclipse.papyrus.interoperability.common.transformation.ui,
+ org.eclipse.papyrus.interoperability.common.wizard,
+ org.eclipse.papyrus.interoperability.common.wizard.pages
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/OSGI-INF/l10n/bundle.properties b/common/plugins/org.eclipse.papyrus.interoperability.common/OSGI-INF/l10n/bundle.properties
new file mode 100644
index 0000000..7160fb0
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/OSGI-INF/l10n/bundle.properties
@@ -0,0 +1,3 @@
+#Properties file for org.eclipse.papyrus.interoperability.common
+Bundle-Vendor = Eclipse Modeling Project
+Bundle-Name = Papyrus Migration Common
\ No newline at end of file
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/about.html b/common/plugins/org.eclipse.papyrus.interoperability.common/about.html
new file mode 100644
index 0000000..dd3c089
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/about.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<title>About</title>
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+ 
+<p>November 14, 2008</p>	
+<h3>License</h3>
+
+<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
+indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
+being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was 
+provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content
+and such source code may be obtained at <a href="http://www.eclipse.org">http://www.eclipse.org</a>.</p>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/build.properties b/common/plugins/org.eclipse.papyrus.interoperability.common/build.properties
new file mode 100644
index 0000000..7d5cfaa
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/build.properties
@@ -0,0 +1,27 @@
+# Copyright (c) 2014 CEA LIST.
+# 
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+#   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+#  *****************************************************************************/
+
+bin.includes = .,\
+               META-INF/,\
+               plugin.xml,\
+               plugin.properties,\
+               OSGI-INF/,\
+               icons/,\
+               ui/,\
+               about.html,\
+               dialog/
+jars.compile.order = .
+source.. = src-gen/,\
+           src/
+output.. = bin/
+src.includes = about.html
+
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/MigrationParameters.ctx b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/MigrationParameters.ctx
new file mode 100755
index 0000000..a1ac60d
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/MigrationParameters.ctx
@@ -0,0 +1,108 @@
+<?xml version="1.0" encoding="ASCII"?>
+<contexts:Context xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:constraints="http://www.eclipse.org/papyrus/constraints/0.9" xmlns:contexts="http://www.eclipse.org/papyrus/properties/contexts/0.9" xmi:id="_hcC08Lr9EeapppGB0acXuA" name="MigrationParameters">
+  <tabs xmi:id="_uXpIsLr9EeapppGB0acXuA" label="MigrationParameters" id="migrationparameters" priority="100">
+    <sections xmi:id="_uXpvwLr9EeapppGB0acXuA" name="Single AdvancedConfig" sectionFile="ui/SingleAdvancedConfig.xwt">
+      <widget href="ui/SingleAdvancedConfig.xwt#/"/>
+    </sections>
+    <sections xmi:id="_uXqW0Lr9EeapppGB0acXuA" name="Single ThreadConfig" sectionFile="ui/SingleThreadConfig.xwt">
+      <widget href="ui/SingleThreadConfig.xwt#/"/>
+    </sections>
+    <sections xmi:id="_uXqW0br9EeapppGB0acXuA" name="Single MappingParameters" sectionFile="ui/SingleMappingParameters.xwt">
+      <widget href="ui/SingleMappingParameters.xwt#/"/>
+    </sections>
+    <sections xmi:id="_uXq94Lr9EeapppGB0acXuA" name="Single URIMapping" sectionFile="ui/SingleURIMapping.xwt">
+      <widget href="ui/SingleURIMapping.xwt#/"/>
+    </sections>
+    <sections xmi:id="_uXq94br9EeapppGB0acXuA" name="Multiple AdvancedConfig" sectionFile="ui/MultipleAdvancedConfig.xwt">
+      <widget href="ui/MultipleAdvancedConfig.xwt#/"/>
+    </sections>
+    <sections xmi:id="_uXrk8Lr9EeapppGB0acXuA" name="Multiple ThreadConfig" sectionFile="ui/MultipleThreadConfig.xwt">
+      <widget href="ui/MultipleThreadConfig.xwt#/"/>
+    </sections>
+    <sections xmi:id="_uXrk8br9EeapppGB0acXuA" name="Multiple MappingParameters" sectionFile="ui/MultipleMappingParameters.xwt">
+      <widget href="ui/MultipleMappingParameters.xwt#/"/>
+    </sections>
+    <sections xmi:id="_uXrk8rr9EeapppGB0acXuA" name="Multiple URIMapping" sectionFile="ui/MultipleURIMapping.xwt">
+      <widget href="ui/MultipleURIMapping.xwt#/"/>
+    </sections>
+  </tabs>
+  <views xmi:id="_hcC08br9EeapppGB0acXuA" name="Single AdvancedConfig" sections="_uXpvwLr9EeapppGB0acXuA" automaticContext="true" datacontexts="_hcC1Err9EeapppGB0acXuA">
+    <constraints xsi:type="constraints:SimpleConstraint" xmi:id="_hcC08rr9EeapppGB0acXuA" name="isSingleAdvancedConfig">
+      <constraintType href="ppe:/environment/org.eclipse.papyrus.infra.properties.ui/model/Environment.xmi#//@constraintTypes.0"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC087r9EeapppGB0acXuA" name="nsUri" value="http:///MigrationParameters.ecore"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC09Lr9EeapppGB0acXuA" name="className" value="AdvancedConfig"/>
+    </constraints>
+  </views>
+  <views xmi:id="_hcC09br9EeapppGB0acXuA" name="Single ThreadConfig" sections="_uXqW0Lr9EeapppGB0acXuA" automaticContext="true" datacontexts="_hcC1Gbr9EeapppGB0acXuA">
+    <constraints xsi:type="constraints:SimpleConstraint" xmi:id="_hcC09rr9EeapppGB0acXuA" name="isSingleThreadConfig">
+      <constraintType href="ppe:/environment/org.eclipse.papyrus.infra.properties.ui/model/Environment.xmi#//@constraintTypes.0"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC097r9EeapppGB0acXuA" name="className" value="ThreadConfig"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC0-Lr9EeapppGB0acXuA" name="nsUri" value="http:///MigrationParameters.ecore"/>
+    </constraints>
+  </views>
+  <views xmi:id="_hcC0-br9EeapppGB0acXuA" name="Single MappingParameters" sections="_uXqW0br9EeapppGB0acXuA" automaticContext="true" datacontexts="_hcC1HLr9EeapppGB0acXuA">
+    <constraints xsi:type="constraints:SimpleConstraint" xmi:id="_hcC0-rr9EeapppGB0acXuA" name="isSingleMappingParameters">
+      <constraintType href="ppe:/environment/org.eclipse.papyrus.infra.properties.ui/model/Environment.xmi#//@constraintTypes.0"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC0-7r9EeapppGB0acXuA" name="className" value="MappingParameters"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC0_Lr9EeapppGB0acXuA" name="nsUri" value="http:///MigrationParameters.ecore"/>
+    </constraints>
+  </views>
+  <views xmi:id="_hcC0_br9EeapppGB0acXuA" name="Single URIMapping" sections="_uXq94Lr9EeapppGB0acXuA" automaticContext="true" datacontexts="_hcC1H7r9EeapppGB0acXuA">
+    <constraints xsi:type="constraints:SimpleConstraint" xmi:id="_hcC0_rr9EeapppGB0acXuA" name="isSingleURIMapping">
+      <constraintType href="ppe:/environment/org.eclipse.papyrus.infra.properties.ui/model/Environment.xmi#//@constraintTypes.0"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC0_7r9EeapppGB0acXuA" name="className" value="URIMapping"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC1ALr9EeapppGB0acXuA" name="nsUri" value="http:///MigrationParameters.ecore"/>
+    </constraints>
+  </views>
+  <views xmi:id="_hcC1Abr9EeapppGB0acXuA" elementMultiplicity="-1" name="Multiple AdvancedConfig" sections="_uXq94br9EeapppGB0acXuA" automaticContext="true" datacontexts="_hcC1Err9EeapppGB0acXuA">
+    <constraints xsi:type="constraints:SimpleConstraint" xmi:id="_hcC1Arr9EeapppGB0acXuA" name="isMultipleAdvancedConfig">
+      <constraintType href="ppe:/environment/org.eclipse.papyrus.infra.properties.ui/model/Environment.xmi#//@constraintTypes.0"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC1A7r9EeapppGB0acXuA" name="className" value="AdvancedConfig"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC1BLr9EeapppGB0acXuA" name="nsUri" value="http:///MigrationParameters.ecore"/>
+    </constraints>
+  </views>
+  <views xmi:id="_hcC1Bbr9EeapppGB0acXuA" elementMultiplicity="-1" name="Multiple ThreadConfig" sections="_uXrk8Lr9EeapppGB0acXuA" automaticContext="true" datacontexts="_hcC1Gbr9EeapppGB0acXuA">
+    <constraints xsi:type="constraints:SimpleConstraint" xmi:id="_hcC1Brr9EeapppGB0acXuA" name="isMultipleThreadConfig">
+      <constraintType href="ppe:/environment/org.eclipse.papyrus.infra.properties.ui/model/Environment.xmi#//@constraintTypes.0"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC1B7r9EeapppGB0acXuA" name="className" value="ThreadConfig"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC1CLr9EeapppGB0acXuA" name="nsUri" value="http:///MigrationParameters.ecore"/>
+    </constraints>
+  </views>
+  <views xmi:id="_hcC1Cbr9EeapppGB0acXuA" elementMultiplicity="-1" name="Multiple MappingParameters" sections="_uXrk8br9EeapppGB0acXuA" automaticContext="true" datacontexts="_hcC1HLr9EeapppGB0acXuA">
+    <constraints xsi:type="constraints:SimpleConstraint" xmi:id="_hcC1Crr9EeapppGB0acXuA" name="isMultipleMappingParameters">
+      <constraintType href="ppe:/environment/org.eclipse.papyrus.infra.properties.ui/model/Environment.xmi#//@constraintTypes.0"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC1C7r9EeapppGB0acXuA" name="nsUri" value="http:///MigrationParameters.ecore"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC1DLr9EeapppGB0acXuA" name="className" value="MappingParameters"/>
+    </constraints>
+  </views>
+  <views xmi:id="_hcC1Dbr9EeapppGB0acXuA" elementMultiplicity="-1" name="Multiple URIMapping" sections="_uXrk8rr9EeapppGB0acXuA" automaticContext="true" datacontexts="_hcC1H7r9EeapppGB0acXuA">
+    <constraints xsi:type="constraints:SimpleConstraint" xmi:id="_hcC1Drr9EeapppGB0acXuA" name="isMultipleURIMapping">
+      <constraintType href="ppe:/environment/org.eclipse.papyrus.infra.properties.ui/model/Environment.xmi#//@constraintTypes.0"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC1D7r9EeapppGB0acXuA" name="nsUri" value="http:///MigrationParameters.ecore"/>
+      <properties xsi:type="constraints:ValueProperty" xmi:id="_hcC1ELr9EeapppGB0acXuA" name="className" value="URIMapping"/>
+    </constraints>
+  </views>
+  <dataContexts xmi:id="_hcC1Ebr9EeapppGB0acXuA" name="MigrationParameters" label="MigrationParameters">
+    <elements xmi:id="_hcC1Err9EeapppGB0acXuA" name="AdvancedConfig" supertypes="_hcC1Gbr9EeapppGB0acXuA">
+      <properties xmi:id="_hcC1E7r9EeapppGB0acXuA" name="mappingParameters" type="Reference"/>
+      <properties xmi:id="_hcC1FLr9EeapppGB0acXuA" name="removeUnmappedDiagrams" description="If true, the diagrams which were not migrated will be removed. Otherwise, only the successfully imported diagrams will be removed"/>
+      <properties xmi:id="_hcC1Fbr9EeapppGB0acXuA" name="convertOpaqueExpressionToLiteralString" description="If true, the Opaque Expressions with a single body and no language (or a single empty language) will be converted to LiteralString"/>
+      <properties xmi:id="_hcC1Frr9EeapppGB0acXuA" name="removeUnmappedProfilesAndStereotypes" description="If true, all unsupported RSA profiles and stereotypes will be deleted at the end of the transformation"/>
+      <properties xmi:id="_hcC1F7r9EeapppGB0acXuA" name="removeUnmappedAnnotations" description="If true, the unmapped RSA EAnnotations will be deleted from the imported model"/>
+      <properties xmi:id="_hcC1GLr9EeapppGB0acXuA" name="alwaysAcceptSuggestedMappings" description="If true, the Transformation will not open a dialog to ask user-confirmation for the dependency mappings. The tool will automatically keep going by &quot;guessing&quot; the proper mapping"/>
+    </elements>
+    <elements xmi:id="_hcC1Gbr9EeapppGB0acXuA" name="ThreadConfig">
+      <properties xmi:id="_hcC1Grr9EeapppGB0acXuA" name="name"/>
+      <properties xmi:id="_hcC1G7r9EeapppGB0acXuA" name="maxThreads" description="The maximum number of threads to use during the migration.&#xD;&#xA;More threads will provide faster results, at the cost of memory consumption."/>
+    </elements>
+    <elements xmi:id="_hcC1HLr9EeapppGB0acXuA" name="MappingParameters">
+      <properties xmi:id="_hcC1Hbr9EeapppGB0acXuA" name="uriMappings" label="URI Mappings" type="Reference" multiplicity="-1" description="When models/libraries have been migrated separately, maps the libraries imported from RSA to their Papyrus equivalent"/>
+      <properties xmi:id="_hcC1Hrr9EeapppGB0acXuA" name="profileUriMappings" label="Profile URI Mappings" type="Reference" multiplicity="-1" description="When profiles have been migrated separately, maps the profiles imported from RSA to their Papyrus equivalent"/>
+    </elements>
+    <elements xmi:id="_hcC1H7r9EeapppGB0acXuA" name="URIMapping">
+      <properties xmi:id="_hcC1ILr9EeapppGB0acXuA" name="sourceURI"/>
+      <properties xmi:id="_hcC1Ibr9EeapppGB0acXuA" name="targetURI"/>
+    </elements>
+    <modelElementFactory href="ppe:/environment/org.eclipse.papyrus.infra.properties.ui/model/Environment.xmi#//@modelElementFactories.0"/>
+  </dataContexts>
+</contexts:Context>
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/MultipleAdvancedConfig.xwt b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/MultipleAdvancedConfig.xwt
new file mode 100755
index 0000000..6f693be
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/MultipleAdvancedConfig.xwt
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Composite xmlns="http://www.eclipse.org/xwt/presentation"
+	xmlns:x="http://www.eclipse.org/xwt"
+	xmlns:ppel="clr-namespace:org.eclipse.papyrus.infra.properties.ui.widgets.layout"
+	xmlns:j="clr-namespace:java.lang">
+	<Composite.layout>
+		<ppel:PropertiesLayout></ppel:PropertiesLayout>
+	</Composite.layout>
+</Composite>
\ No newline at end of file
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/MultipleMappingParameters.xwt b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/MultipleMappingParameters.xwt
new file mode 100755
index 0000000..71e2f0b
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/MultipleMappingParameters.xwt
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Composite
+	xmlns:ppel="clr-namespace:org.eclipse.papyrus.infra.properties.ui.widgets.layout"
+	xmlns:x="http://www.eclipse.org/xwt" xmlns="http://www.eclipse.org/xwt/presentation"
+	xmlns:j="clr-namespace:java.lang">
+	<Composite.layout>
+		<ppel:PropertiesLayout></ppel:PropertiesLayout>
+	</Composite.layout>
+</Composite>
\ No newline at end of file
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/MultipleThreadConfig.xwt b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/MultipleThreadConfig.xwt
new file mode 100755
index 0000000..58a4712
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/MultipleThreadConfig.xwt
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Composite xmlns:x="http://www.eclipse.org/xwt" xmlns="http://www.eclipse.org/xwt/presentation"
+	xmlns:j="clr-namespace:java.lang"
+	xmlns:ppel="clr-namespace:org.eclipse.papyrus.infra.properties.ui.widgets.layout">
+	<Composite.layout>
+		<ppel:PropertiesLayout></ppel:PropertiesLayout>
+	</Composite.layout>
+</Composite>
\ No newline at end of file
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/MultipleURIMapping.xwt b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/MultipleURIMapping.xwt
new file mode 100755
index 0000000..a3915a0
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/MultipleURIMapping.xwt
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Composite xmlns:j="clr-namespace:java.lang"
+	xmlns:ppe="clr-namespace:org.eclipse.papyrus.infra.properties.ui.widgets"
+	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">
+	<Composite.layout>
+		<ppel:PropertiesLayout></ppel:PropertiesLayout>
+	</Composite.layout>
+	<Composite>
+		<Composite.layout>
+			<ppel:PropertiesLayout numColumns="1"></ppel:PropertiesLayout>
+		</Composite.layout>
+		<ppe:StringEditor input="{Binding}"
+			property="MigrationParameters:URIMapping:targetURI"></ppe:StringEditor>
+	</Composite>
+</Composite>
\ No newline at end of file
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/SingleAdvancedConfig.xwt b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/SingleAdvancedConfig.xwt
new file mode 100755
index 0000000..b4460ad
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/SingleAdvancedConfig.xwt
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Composite xmlns:j="clr-namespace:java.lang"
+	xmlns:ppel="clr-namespace:org.eclipse.papyrus.infra.properties.ui.widgets.layout"
+	xmlns:ppe="clr-namespace:org.eclipse.papyrus.infra.properties.ui.widgets"
+	xmlns:x="http://www.eclipse.org/xwt" xmlns="http://www.eclipse.org/xwt/presentation">
+	<Composite.layout>
+		<ppel:PropertiesLayout></ppel:PropertiesLayout>
+	</Composite.layout>
+	<Composite>
+		<Composite.layout>
+			<ppel:PropertiesLayout numColumns="1"></ppel:PropertiesLayout>
+		</Composite.layout>
+		<ppe:BooleanCheckbox input="{Binding}"
+			property="MigrationParameters:AdvancedConfig:convertOpaqueExpressionToLiteralString"></ppe:BooleanCheckbox>
+		<ppe:BooleanCheckbox input="{Binding}"
+			property="MigrationParameters:AdvancedConfig:removeUnmappedProfilesAndStereotypes"></ppe:BooleanCheckbox>
+		<ppe:BooleanCheckbox input="{Binding}"
+			property="MigrationParameters:AdvancedConfig:alwaysAcceptSuggestedMappings"></ppe:BooleanCheckbox>
+		<ppe:IntegerEditor input="{Binding}"
+			property="MigrationParameters:ThreadConfig:maxThreads"></ppe:IntegerEditor>
+	</Composite>
+</Composite>
\ No newline at end of file
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/SingleMappingParameters.xwt b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/SingleMappingParameters.xwt
new file mode 100755
index 0000000..66541b8
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/SingleMappingParameters.xwt
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Composite xmlns:j="clr-namespace:java.lang"
+	xmlns:ppel="clr-namespace:org.eclipse.papyrus.infra.properties.ui.widgets.layout"
+	xmlns:x="http://www.eclipse.org/xwt" xmlns="http://www.eclipse.org/xwt/presentation"
+	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:MultiReference input="{Binding}"
+			property="MigrationParameters:MappingParameters:uriMappings"></ppe:MultiReference>
+		<ppe:MultiReference input="{Binding}"
+			property="MigrationParameters:MappingParameters:profileUriMappings"></ppe:MultiReference>
+	</Composite>
+</Composite>
\ No newline at end of file
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/SingleThreadConfig.xwt b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/SingleThreadConfig.xwt
new file mode 100755
index 0000000..22240cb
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/SingleThreadConfig.xwt
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Composite xmlns="http://www.eclipse.org/xwt/presentation"
+	xmlns:j="clr-namespace:java.lang" xmlns:ppe="clr-namespace:org.eclipse.papyrus.infra.properties.ui.widgets"
+	xmlns:x="http://www.eclipse.org/xwt"
+	xmlns:ppel="clr-namespace:org.eclipse.papyrus.infra.properties.ui.widgets.layout">
+	<Composite.layout>
+		<ppel:PropertiesLayout></ppel:PropertiesLayout>
+	</Composite.layout>
+	<Composite>
+		<Composite.layout>
+			<ppel:PropertiesLayout numColumns="1"></ppel:PropertiesLayout>
+		</Composite.layout>
+		<ppe:IntegerEditor input="{Binding}"
+			property="MigrationParameters:ThreadConfig:maxThreads"></ppe:IntegerEditor>
+	</Composite>
+</Composite>
\ No newline at end of file
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/SingleURIMapping.xwt b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/SingleURIMapping.xwt
new file mode 100755
index 0000000..0b01b70
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/dialog/ui/SingleURIMapping.xwt
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Composite xmlns:j="clr-namespace:java.lang"
+	xmlns:ppe="clr-namespace:org.eclipse.papyrus.infra.properties.ui.widgets"
+	xmlns="http://www.eclipse.org/xwt/presentation" xmlns:x="http://www.eclipse.org/xwt"
+	xmlns:ppel="clr-namespace:org.eclipse.papyrus.infra.properties.ui.widgets.layout">
+	<Composite.layout>
+		<ppel:PropertiesLayout></ppel:PropertiesLayout>
+	</Composite.layout>
+	<Composite>
+		<Composite.layout>
+			<ppel:PropertiesLayout numColumns="1"></ppel:PropertiesLayout>
+		</Composite.layout>
+		<ppe:StringEditor input="{Binding}"
+			property="MigrationParameters:URIMapping:sourceURI"></ppe:StringEditor>
+		<ppe:StringEditor input="{Binding}"
+			property="MigrationParameters:URIMapping:targetURI"></ppe:StringEditor>
+	</Composite>
+</Composite>
\ No newline at end of file
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/icons/import_wiz_16x16.gif b/common/plugins/org.eclipse.papyrus.interoperability.common/icons/import_wiz_16x16.gif
new file mode 100644
index 0000000..c7be463
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/icons/import_wiz_16x16.gif
Binary files differ
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/plugin.properties b/common/plugins/org.eclipse.papyrus.interoperability.common/plugin.properties
new file mode 100644
index 0000000..51cbf84
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/plugin.properties
@@ -0,0 +1,14 @@
+# Copyright (c) 2014 CEA LIST.
+# 
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+#   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+#  *****************************************************************************/
+
+pluginName = Papyrus Interoperability Common Plugin
+providerName = Eclipse Modeling Project
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/plugin.xml b/common/plugins/org.eclipse.papyrus.interoperability.common/plugin.xml
new file mode 100644
index 0000000..ee24097
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/plugin.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+
+<!--
+ Copyright (c) 2014 CEA LIST.
+ 
+ All rights reserved. This program and the accompanying materials
+ are made available under the terms of the Eclipse Public License v1.0
+ which accompanies this distribution, and is available at
+ http://www.eclipse.org/legal/epl-v10.html
+ 
+ Contributors:
+   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+  *****************************************************************************/
+-->
+
+<plugin>
+
+   <extension point="org.eclipse.emf.ecore.generated_package">
+      <!-- @generated migrationParameters -->
+      <package
+            uri="http:///MigrationParameters.ecore"
+            class="org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage"
+            genModel="ui/migrationParameters.genmodel"/>
+   </extension>
+   <extension
+         point="org.eclipse.papyrus.infra.properties.contexts">
+           <context
+            contextModel="dialog/MigrationParameters.ctx"
+            isCustomizable="false">
+      </context>
+   </extension>
+</plugin>
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/AdvancedConfig.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/AdvancedConfig.java
new file mode 100755
index 0000000..2e0b527
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/AdvancedConfig.java
@@ -0,0 +1,195 @@
+/**
+ * Copyright (c) 2014 CEA LIST.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+ * 
+ */
+package org.eclipse.papyrus.interoperability.common.MigrationParameters;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Advanced Config</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#getMappingParameters <em>Mapping Parameters</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isRemoveUnmappedDiagrams <em>Remove Unmapped Diagrams</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isConvertOpaqueExpressionToLiteralString <em>Convert Opaque Expression To Literal String</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isRemoveUnmappedProfilesAndStereotypes <em>Remove Unmapped Profiles And Stereotypes</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isRemoveUnmappedAnnotations <em>Remove Unmapped Annotations</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isAlwaysAcceptSuggestedMappings <em>Always Accept Suggested Mappings</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getAdvancedConfig()
+ * @model
+ * @generated
+ */
+public interface AdvancedConfig extends ThreadConfig {
+	/**
+	 * Returns the value of the '<em><b>Mapping Parameters</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Mapping Parameters</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Mapping Parameters</em>' containment reference.
+	 * @see #setMappingParameters(MappingParameters)
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getAdvancedConfig_MappingParameters()
+	 * @model containment="true" required="true" ordered="false"
+	 * @generated
+	 */
+	MappingParameters getMappingParameters();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#getMappingParameters <em>Mapping Parameters</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Mapping Parameters</em>' containment reference.
+	 * @see #getMappingParameters()
+	 * @generated
+	 */
+	void setMappingParameters(MappingParameters value);
+
+	/**
+	 * Returns the value of the '<em><b>Remove Unmapped Diagrams</b></em>' attribute.
+	 * The default value is <code>"false"</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * If true, the diagrams which were not migrated will be removed. Otherwise, only the successfully imported diagrams will be removed
+	 * <!-- end-model-doc -->
+	 * @return the value of the '<em>Remove Unmapped Diagrams</em>' attribute.
+	 * @see #setRemoveUnmappedDiagrams(boolean)
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getAdvancedConfig_RemoveUnmappedDiagrams()
+	 * @model default="false" unique="false" dataType="org.eclipse.uml2.types.Boolean" required="true" ordered="false"
+	 * @generated
+	 */
+	boolean isRemoveUnmappedDiagrams();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isRemoveUnmappedDiagrams <em>Remove Unmapped Diagrams</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Remove Unmapped Diagrams</em>' attribute.
+	 * @see #isRemoveUnmappedDiagrams()
+	 * @generated
+	 */
+	void setRemoveUnmappedDiagrams(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Convert Opaque Expression To Literal String</b></em>' attribute.
+	 * The default value is <code>"true"</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * If true, the Opaque Expressions with a single body and no language (or a single empty language) will be converted to LiteralString
+	 * <!-- end-model-doc -->
+	 * @return the value of the '<em>Convert Opaque Expression To Literal String</em>' attribute.
+	 * @see #setConvertOpaqueExpressionToLiteralString(boolean)
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getAdvancedConfig_ConvertOpaqueExpressionToLiteralString()
+	 * @model default="true" unique="false" dataType="org.eclipse.uml2.types.Boolean" required="true" ordered="false"
+	 * @generated
+	 */
+	boolean isConvertOpaqueExpressionToLiteralString();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isConvertOpaqueExpressionToLiteralString <em>Convert Opaque Expression To Literal String</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Convert Opaque Expression To Literal String</em>' attribute.
+	 * @see #isConvertOpaqueExpressionToLiteralString()
+	 * @generated
+	 */
+	void setConvertOpaqueExpressionToLiteralString(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Remove Unmapped Profiles And Stereotypes</b></em>' attribute.
+	 * The default value is <code>"false"</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * If true, all unsupported RSA profiles and stereotypes will be deleted at the end of the transformation
+	 * <!-- end-model-doc -->
+	 * @return the value of the '<em>Remove Unmapped Profiles And Stereotypes</em>' attribute.
+	 * @see #setRemoveUnmappedProfilesAndStereotypes(boolean)
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getAdvancedConfig_RemoveUnmappedProfilesAndStereotypes()
+	 * @model default="false" unique="false" dataType="org.eclipse.uml2.types.Boolean" required="true" ordered="false"
+	 * @generated
+	 */
+	boolean isRemoveUnmappedProfilesAndStereotypes();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isRemoveUnmappedProfilesAndStereotypes <em>Remove Unmapped Profiles And Stereotypes</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Remove Unmapped Profiles And Stereotypes</em>' attribute.
+	 * @see #isRemoveUnmappedProfilesAndStereotypes()
+	 * @generated
+	 */
+	void setRemoveUnmappedProfilesAndStereotypes(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Remove Unmapped Annotations</b></em>' attribute.
+	 * The default value is <code>"false"</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * If true, the unmapped RSA EAnnotations will be deleted from the imported model
+	 * <!-- end-model-doc -->
+	 * @return the value of the '<em>Remove Unmapped Annotations</em>' attribute.
+	 * @see #setRemoveUnmappedAnnotations(boolean)
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getAdvancedConfig_RemoveUnmappedAnnotations()
+	 * @model default="false" unique="false" dataType="org.eclipse.uml2.types.Boolean" required="true" ordered="false"
+	 * @generated
+	 */
+	boolean isRemoveUnmappedAnnotations();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isRemoveUnmappedAnnotations <em>Remove Unmapped Annotations</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Remove Unmapped Annotations</em>' attribute.
+	 * @see #isRemoveUnmappedAnnotations()
+	 * @generated
+	 */
+	void setRemoveUnmappedAnnotations(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Always Accept Suggested Mappings</b></em>' attribute.
+	 * The default value is <code>"false"</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * If true, the Transformation will not open a dialog to ask user-confirmation for the dependency mappings. The tool will automatically keep going by "guessing" the proper mapping
+	 * <!-- end-model-doc -->
+	 * @return the value of the '<em>Always Accept Suggested Mappings</em>' attribute.
+	 * @see #setAlwaysAcceptSuggestedMappings(boolean)
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getAdvancedConfig_AlwaysAcceptSuggestedMappings()
+	 * @model default="false" dataType="org.eclipse.uml2.types.Boolean" required="true" ordered="false"
+	 * @generated
+	 */
+	boolean isAlwaysAcceptSuggestedMappings();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isAlwaysAcceptSuggestedMappings <em>Always Accept Suggested Mappings</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Always Accept Suggested Mappings</em>' attribute.
+	 * @see #isAlwaysAcceptSuggestedMappings()
+	 * @generated
+	 */
+	void setAlwaysAcceptSuggestedMappings(boolean value);
+
+} // AdvancedConfig
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/MappingParameters.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/MappingParameters.java
new file mode 100755
index 0000000..389b389
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/MappingParameters.java
@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2014 CEA LIST.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+ * 
+ */
+package org.eclipse.papyrus.interoperability.common.MigrationParameters;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Mapping Parameters</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters#getUriMappings <em>Uri Mappings</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters#getProfileUriMappings <em>Profile Uri Mappings</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getMappingParameters()
+ * @model
+ * @generated
+ */
+public interface MappingParameters extends EObject {
+	/**
+	 * Returns the value of the '<em><b>Uri Mappings</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * When models/libraries have been migrated separately, maps the libraries imported from RSA to their Papyrus equivalent
+	 * <!-- end-model-doc -->
+	 * @return the value of the '<em>Uri Mappings</em>' containment reference list.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getMappingParameters_UriMappings()
+	 * @model containment="true" ordered="false"
+	 * @generated
+	 */
+	EList<URIMapping> getUriMappings();
+
+	/**
+	 * Returns the value of the '<em><b>Profile Uri Mappings</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * When profiles have been migrated separately, maps the profiles imported from RSA to their Papyrus equivalent
+	 * <!-- end-model-doc -->
+	 * @return the value of the '<em>Profile Uri Mappings</em>' containment reference list.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getMappingParameters_ProfileUriMappings()
+	 * @model containment="true" ordered="false"
+	 * @generated
+	 */
+	EList<URIMapping> getProfileUriMappings();
+
+} // MappingParameters
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/MigrationParametersFactory.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/MigrationParametersFactory.java
new file mode 100755
index 0000000..e0e0167
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/MigrationParametersFactory.java
@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2014 CEA LIST.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+ * 
+ */
+package org.eclipse.papyrus.interoperability.common.MigrationParameters;
+
+import org.eclipse.emf.ecore.EFactory;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Factory</b> for the model.
+ * It provides a create method for each non-abstract class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage
+ * @generated
+ */
+public interface MigrationParametersFactory extends EFactory {
+	/**
+	 * The singleton instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	MigrationParametersFactory eINSTANCE = org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MigrationParametersFactoryImpl.init();
+
+	/**
+	 * Returns a new object of class '<em>Advanced Config</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Advanced Config</em>'.
+	 * @generated
+	 */
+	AdvancedConfig createAdvancedConfig();
+
+	/**
+	 * Returns a new object of class '<em>Thread Config</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Thread Config</em>'.
+	 * @generated
+	 */
+	ThreadConfig createThreadConfig();
+
+	/**
+	 * Returns a new object of class '<em>Mapping Parameters</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Mapping Parameters</em>'.
+	 * @generated
+	 */
+	MappingParameters createMappingParameters();
+
+	/**
+	 * Returns a new object of class '<em>URI Mapping</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>URI Mapping</em>'.
+	 * @generated
+	 */
+	URIMapping createURIMapping();
+
+	/**
+	 * Returns the package supported by this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the package supported by this factory.
+	 * @generated
+	 */
+	MigrationParametersPackage getMigrationParametersPackage();
+
+} //MigrationParametersFactory
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/MigrationParametersPackage.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/MigrationParametersPackage.java
new file mode 100755
index 0000000..89478fd
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/MigrationParametersPackage.java
@@ -0,0 +1,642 @@
+/**
+ * Copyright (c) 2014 CEA LIST.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+ * 
+ */
+package org.eclipse.papyrus.interoperability.common.MigrationParameters;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Package</b> for the model.
+ * It contains accessors for the meta objects to represent
+ * <ul>
+ *   <li>each class,</li>
+ *   <li>each feature of each class,</li>
+ *   <li>each operation of each class,</li>
+ *   <li>each enum,</li>
+ *   <li>and each data type</li>
+ * </ul>
+ * <!-- end-user-doc -->
+ * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersFactory
+ * @model kind="package"
+ * @generated
+ */
+public interface MigrationParametersPackage extends EPackage {
+	/**
+	 * The package name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNAME = "MigrationParameters"; //$NON-NLS-1$
+
+	/**
+	 * The package namespace URI.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_URI = "http:///MigrationParameters.ecore"; //$NON-NLS-1$
+
+	/**
+	 * The package namespace name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_PREFIX = "MigrationParameters"; //$NON-NLS-1$
+
+	/**
+	 * The singleton instance of the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	MigrationParametersPackage eINSTANCE = org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MigrationParametersPackageImpl.init();
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.ThreadConfigImpl <em>Thread Config</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.ThreadConfigImpl
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MigrationParametersPackageImpl#getThreadConfig()
+	 * @generated
+	 */
+	int THREAD_CONFIG = 1;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int THREAD_CONFIG__NAME = 0;
+
+	/**
+	 * The feature id for the '<em><b>Max Threads</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int THREAD_CONFIG__MAX_THREADS = 1;
+
+	/**
+	 * The number of structural features of the '<em>Thread Config</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int THREAD_CONFIG_FEATURE_COUNT = 2;
+
+	/**
+	 * The number of operations of the '<em>Thread Config</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int THREAD_CONFIG_OPERATION_COUNT = 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.AdvancedConfigImpl <em>Advanced Config</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.AdvancedConfigImpl
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MigrationParametersPackageImpl#getAdvancedConfig()
+	 * @generated
+	 */
+	int ADVANCED_CONFIG = 0;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int ADVANCED_CONFIG__NAME = THREAD_CONFIG__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Max Threads</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int ADVANCED_CONFIG__MAX_THREADS = THREAD_CONFIG__MAX_THREADS;
+
+	/**
+	 * The feature id for the '<em><b>Mapping Parameters</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int ADVANCED_CONFIG__MAPPING_PARAMETERS = THREAD_CONFIG_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Remove Unmapped Diagrams</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int ADVANCED_CONFIG__REMOVE_UNMAPPED_DIAGRAMS = THREAD_CONFIG_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Convert Opaque Expression To Literal String</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int ADVANCED_CONFIG__CONVERT_OPAQUE_EXPRESSION_TO_LITERAL_STRING = THREAD_CONFIG_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Remove Unmapped Profiles And Stereotypes</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int ADVANCED_CONFIG__REMOVE_UNMAPPED_PROFILES_AND_STEREOTYPES = THREAD_CONFIG_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Remove Unmapped Annotations</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int ADVANCED_CONFIG__REMOVE_UNMAPPED_ANNOTATIONS = THREAD_CONFIG_FEATURE_COUNT + 4;
+
+	/**
+	 * The feature id for the '<em><b>Always Accept Suggested Mappings</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int ADVANCED_CONFIG__ALWAYS_ACCEPT_SUGGESTED_MAPPINGS = THREAD_CONFIG_FEATURE_COUNT + 5;
+
+	/**
+	 * The number of structural features of the '<em>Advanced Config</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int ADVANCED_CONFIG_FEATURE_COUNT = THREAD_CONFIG_FEATURE_COUNT + 6;
+
+	/**
+	 * The number of operations of the '<em>Advanced Config</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int ADVANCED_CONFIG_OPERATION_COUNT = THREAD_CONFIG_OPERATION_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MappingParametersImpl <em>Mapping Parameters</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MappingParametersImpl
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MigrationParametersPackageImpl#getMappingParameters()
+	 * @generated
+	 */
+	int MAPPING_PARAMETERS = 2;
+
+	/**
+	 * The feature id for the '<em><b>Uri Mappings</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int MAPPING_PARAMETERS__URI_MAPPINGS = 0;
+
+	/**
+	 * The feature id for the '<em><b>Profile Uri Mappings</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int MAPPING_PARAMETERS__PROFILE_URI_MAPPINGS = 1;
+
+	/**
+	 * The number of structural features of the '<em>Mapping Parameters</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int MAPPING_PARAMETERS_FEATURE_COUNT = 2;
+
+	/**
+	 * The number of operations of the '<em>Mapping Parameters</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int MAPPING_PARAMETERS_OPERATION_COUNT = 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.URIMappingImpl <em>URI Mapping</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.URIMappingImpl
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MigrationParametersPackageImpl#getURIMapping()
+	 * @generated
+	 */
+	int URI_MAPPING = 3;
+
+	/**
+	 * The feature id for the '<em><b>Source URI</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int URI_MAPPING__SOURCE_URI = 0;
+
+	/**
+	 * The feature id for the '<em><b>Target URI</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int URI_MAPPING__TARGET_URI = 1;
+
+	/**
+	 * The number of structural features of the '<em>URI Mapping</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int URI_MAPPING_FEATURE_COUNT = 2;
+
+	/**
+	 * The number of operations of the '<em>URI Mapping</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int URI_MAPPING_OPERATION_COUNT = 0;
+
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig <em>Advanced Config</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Advanced Config</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig
+	 * @generated
+	 */
+	EClass getAdvancedConfig();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#getMappingParameters <em>Mapping Parameters</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Mapping Parameters</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#getMappingParameters()
+	 * @see #getAdvancedConfig()
+	 * @generated
+	 */
+	EReference getAdvancedConfig_MappingParameters();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isRemoveUnmappedDiagrams <em>Remove Unmapped Diagrams</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Remove Unmapped Diagrams</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isRemoveUnmappedDiagrams()
+	 * @see #getAdvancedConfig()
+	 * @generated
+	 */
+	EAttribute getAdvancedConfig_RemoveUnmappedDiagrams();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isConvertOpaqueExpressionToLiteralString <em>Convert Opaque Expression To Literal String</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Convert Opaque Expression To Literal String</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isConvertOpaqueExpressionToLiteralString()
+	 * @see #getAdvancedConfig()
+	 * @generated
+	 */
+	EAttribute getAdvancedConfig_ConvertOpaqueExpressionToLiteralString();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isRemoveUnmappedProfilesAndStereotypes <em>Remove Unmapped Profiles And Stereotypes</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Remove Unmapped Profiles And Stereotypes</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isRemoveUnmappedProfilesAndStereotypes()
+	 * @see #getAdvancedConfig()
+	 * @generated
+	 */
+	EAttribute getAdvancedConfig_RemoveUnmappedProfilesAndStereotypes();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isRemoveUnmappedAnnotations <em>Remove Unmapped Annotations</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Remove Unmapped Annotations</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isRemoveUnmappedAnnotations()
+	 * @see #getAdvancedConfig()
+	 * @generated
+	 */
+	EAttribute getAdvancedConfig_RemoveUnmappedAnnotations();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isAlwaysAcceptSuggestedMappings <em>Always Accept Suggested Mappings</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Always Accept Suggested Mappings</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig#isAlwaysAcceptSuggestedMappings()
+	 * @see #getAdvancedConfig()
+	 * @generated
+	 */
+	EAttribute getAdvancedConfig_AlwaysAcceptSuggestedMappings();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig <em>Thread Config</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Thread Config</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig
+	 * @generated
+	 */
+	EClass getThreadConfig();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig#getName <em>Name</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Name</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig#getName()
+	 * @see #getThreadConfig()
+	 * @generated
+	 */
+	EAttribute getThreadConfig_Name();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig#getMaxThreads <em>Max Threads</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Max Threads</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig#getMaxThreads()
+	 * @see #getThreadConfig()
+	 * @generated
+	 */
+	EAttribute getThreadConfig_MaxThreads();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters <em>Mapping Parameters</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Mapping Parameters</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters
+	 * @generated
+	 */
+	EClass getMappingParameters();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters#getUriMappings <em>Uri Mappings</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Uri Mappings</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters#getUriMappings()
+	 * @see #getMappingParameters()
+	 * @generated
+	 */
+	EReference getMappingParameters_UriMappings();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters#getProfileUriMappings <em>Profile Uri Mappings</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Profile Uri Mappings</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters#getProfileUriMappings()
+	 * @see #getMappingParameters()
+	 * @generated
+	 */
+	EReference getMappingParameters_ProfileUriMappings();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping <em>URI Mapping</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>URI Mapping</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping
+	 * @generated
+	 */
+	EClass getURIMapping();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping#getSourceURI <em>Source URI</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Source URI</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping#getSourceURI()
+	 * @see #getURIMapping()
+	 * @generated
+	 */
+	EAttribute getURIMapping_SourceURI();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping#getTargetURI <em>Target URI</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Target URI</em>'.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping#getTargetURI()
+	 * @see #getURIMapping()
+	 * @generated
+	 */
+	EAttribute getURIMapping_TargetURI();
+
+	/**
+	 * Returns the factory that creates the instances of the model.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the factory that creates the instances of the model.
+	 * @generated
+	 */
+	MigrationParametersFactory getMigrationParametersFactory();
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * Defines literals for the meta objects that represent
+	 * <ul>
+	 *   <li>each class,</li>
+	 *   <li>each feature of each class,</li>
+	 *   <li>each operation of each class,</li>
+	 *   <li>each enum,</li>
+	 *   <li>and each data type</li>
+	 * </ul>
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	interface Literals {
+		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.AdvancedConfigImpl <em>Advanced Config</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.AdvancedConfigImpl
+		 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MigrationParametersPackageImpl#getAdvancedConfig()
+		 * @generated
+		 */
+		EClass ADVANCED_CONFIG = eINSTANCE.getAdvancedConfig();
+
+		/**
+		 * The meta object literal for the '<em><b>Mapping Parameters</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference ADVANCED_CONFIG__MAPPING_PARAMETERS = eINSTANCE.getAdvancedConfig_MappingParameters();
+
+		/**
+		 * The meta object literal for the '<em><b>Remove Unmapped Diagrams</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute ADVANCED_CONFIG__REMOVE_UNMAPPED_DIAGRAMS = eINSTANCE.getAdvancedConfig_RemoveUnmappedDiagrams();
+
+		/**
+		 * The meta object literal for the '<em><b>Convert Opaque Expression To Literal String</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute ADVANCED_CONFIG__CONVERT_OPAQUE_EXPRESSION_TO_LITERAL_STRING = eINSTANCE.getAdvancedConfig_ConvertOpaqueExpressionToLiteralString();
+
+		/**
+		 * The meta object literal for the '<em><b>Remove Unmapped Profiles And Stereotypes</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute ADVANCED_CONFIG__REMOVE_UNMAPPED_PROFILES_AND_STEREOTYPES = eINSTANCE.getAdvancedConfig_RemoveUnmappedProfilesAndStereotypes();
+
+		/**
+		 * The meta object literal for the '<em><b>Remove Unmapped Annotations</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute ADVANCED_CONFIG__REMOVE_UNMAPPED_ANNOTATIONS = eINSTANCE.getAdvancedConfig_RemoveUnmappedAnnotations();
+
+		/**
+		 * The meta object literal for the '<em><b>Always Accept Suggested Mappings</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute ADVANCED_CONFIG__ALWAYS_ACCEPT_SUGGESTED_MAPPINGS = eINSTANCE.getAdvancedConfig_AlwaysAcceptSuggestedMappings();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.ThreadConfigImpl <em>Thread Config</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.ThreadConfigImpl
+		 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MigrationParametersPackageImpl#getThreadConfig()
+		 * @generated
+		 */
+		EClass THREAD_CONFIG = eINSTANCE.getThreadConfig();
+
+		/**
+		 * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute THREAD_CONFIG__NAME = eINSTANCE.getThreadConfig_Name();
+
+		/**
+		 * The meta object literal for the '<em><b>Max Threads</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute THREAD_CONFIG__MAX_THREADS = eINSTANCE.getThreadConfig_MaxThreads();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MappingParametersImpl <em>Mapping Parameters</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MappingParametersImpl
+		 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MigrationParametersPackageImpl#getMappingParameters()
+		 * @generated
+		 */
+		EClass MAPPING_PARAMETERS = eINSTANCE.getMappingParameters();
+
+		/**
+		 * The meta object literal for the '<em><b>Uri Mappings</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference MAPPING_PARAMETERS__URI_MAPPINGS = eINSTANCE.getMappingParameters_UriMappings();
+
+		/**
+		 * The meta object literal for the '<em><b>Profile Uri Mappings</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference MAPPING_PARAMETERS__PROFILE_URI_MAPPINGS = eINSTANCE.getMappingParameters_ProfileUriMappings();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.URIMappingImpl <em>URI Mapping</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.URIMappingImpl
+		 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MigrationParametersPackageImpl#getURIMapping()
+		 * @generated
+		 */
+		EClass URI_MAPPING = eINSTANCE.getURIMapping();
+
+		/**
+		 * The meta object literal for the '<em><b>Source URI</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute URI_MAPPING__SOURCE_URI = eINSTANCE.getURIMapping_SourceURI();
+
+		/**
+		 * The meta object literal for the '<em><b>Target URI</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute URI_MAPPING__TARGET_URI = eINSTANCE.getURIMapping_TargetURI();
+
+	}
+
+} //MigrationParametersPackage
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/ThreadConfig.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/ThreadConfig.java
new file mode 100755
index 0000000..4ecfb88
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/ThreadConfig.java
@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) 2014 CEA LIST.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+ * 
+ */
+package org.eclipse.papyrus.interoperability.common.MigrationParameters;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Thread Config</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig#getMaxThreads <em>Max Threads</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getThreadConfig()
+ * @model
+ * @generated
+ */
+public interface ThreadConfig extends EObject {
+	/**
+	 * Returns the value of the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Name</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Name</em>' attribute.
+	 * @see #setName(String)
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getThreadConfig_Name()
+	 * @model dataType="org.eclipse.uml2.types.String" required="true" ordered="false"
+	 * @generated
+	 */
+	String getName();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig#getName <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Name</em>' attribute.
+	 * @see #getName()
+	 * @generated
+	 */
+	void setName(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Max Threads</b></em>' attribute.
+	 * The default value is <code>"2"</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * The maximum number of threads to use during the migration.
+	 * More threads will provide faster results, at the cost of memory consumption.
+	 * <!-- end-model-doc -->
+	 * @return the value of the '<em>Max Threads</em>' attribute.
+	 * @see #setMaxThreads(int)
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getThreadConfig_MaxThreads()
+	 * @model default="2" unique="false" dataType="org.eclipse.uml2.types.Integer" required="true" ordered="false"
+	 * @generated
+	 */
+	int getMaxThreads();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig#getMaxThreads <em>Max Threads</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Max Threads</em>' attribute.
+	 * @see #getMaxThreads()
+	 * @generated
+	 */
+	void setMaxThreads(int value);
+
+} // ThreadConfig
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/URIMapping.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/URIMapping.java
new file mode 100755
index 0000000..191933f
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/URIMapping.java
@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) 2014 CEA LIST.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+ * 
+ */
+package org.eclipse.papyrus.interoperability.common.MigrationParameters;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>URI Mapping</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping#getSourceURI <em>Source URI</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping#getTargetURI <em>Target URI</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getURIMapping()
+ * @model
+ * @generated
+ */
+public interface URIMapping extends EObject {
+	/**
+	 * Returns the value of the '<em><b>Source URI</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Source URI</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Source URI</em>' attribute.
+	 * @see #setSourceURI(String)
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getURIMapping_SourceURI()
+	 * @model unique="false" dataType="org.eclipse.uml2.types.String" required="true" ordered="false"
+	 * @generated
+	 */
+	String getSourceURI();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping#getSourceURI <em>Source URI</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Source URI</em>' attribute.
+	 * @see #getSourceURI()
+	 * @generated
+	 */
+	void setSourceURI(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Target URI</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Target URI</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Target URI</em>' attribute.
+	 * @see #setTargetURI(String)
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#getURIMapping_TargetURI()
+	 * @model unique="false" dataType="org.eclipse.uml2.types.String" required="true" ordered="false"
+	 * @generated
+	 */
+	String getTargetURI();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping#getTargetURI <em>Target URI</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Target URI</em>' attribute.
+	 * @see #getTargetURI()
+	 * @generated
+	 */
+	void setTargetURI(String value);
+
+} // URIMapping
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/AdvancedConfigImpl.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/AdvancedConfigImpl.java
new file mode 100755
index 0000000..bb62731
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/AdvancedConfigImpl.java
@@ -0,0 +1,469 @@
+/**
+ * Copyright (c) 2014 CEA LIST.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+ * 
+ */
+package org.eclipse.papyrus.interoperability.common.MigrationParameters.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Advanced Config</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.AdvancedConfigImpl#getMappingParameters <em>Mapping Parameters</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.AdvancedConfigImpl#isRemoveUnmappedDiagrams <em>Remove Unmapped Diagrams</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.AdvancedConfigImpl#isConvertOpaqueExpressionToLiteralString <em>Convert Opaque Expression To Literal String</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.AdvancedConfigImpl#isRemoveUnmappedProfilesAndStereotypes <em>Remove Unmapped Profiles And Stereotypes</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.AdvancedConfigImpl#isRemoveUnmappedAnnotations <em>Remove Unmapped Annotations</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.AdvancedConfigImpl#isAlwaysAcceptSuggestedMappings <em>Always Accept Suggested Mappings</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class AdvancedConfigImpl extends ThreadConfigImpl implements AdvancedConfig {
+	/**
+	 * The cached value of the '{@link #getMappingParameters() <em>Mapping Parameters</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getMappingParameters()
+	 * @generated
+	 * @ordered
+	 */
+	protected MappingParameters mappingParameters;
+
+	/**
+	 * The default value of the '{@link #isRemoveUnmappedDiagrams() <em>Remove Unmapped Diagrams</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isRemoveUnmappedDiagrams()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean REMOVE_UNMAPPED_DIAGRAMS_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isRemoveUnmappedDiagrams() <em>Remove Unmapped Diagrams</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isRemoveUnmappedDiagrams()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean removeUnmappedDiagrams = REMOVE_UNMAPPED_DIAGRAMS_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isConvertOpaqueExpressionToLiteralString() <em>Convert Opaque Expression To Literal String</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isConvertOpaqueExpressionToLiteralString()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean CONVERT_OPAQUE_EXPRESSION_TO_LITERAL_STRING_EDEFAULT = true;
+
+	/**
+	 * The cached value of the '{@link #isConvertOpaqueExpressionToLiteralString() <em>Convert Opaque Expression To Literal String</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isConvertOpaqueExpressionToLiteralString()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean convertOpaqueExpressionToLiteralString = CONVERT_OPAQUE_EXPRESSION_TO_LITERAL_STRING_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isRemoveUnmappedProfilesAndStereotypes() <em>Remove Unmapped Profiles And Stereotypes</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isRemoveUnmappedProfilesAndStereotypes()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean REMOVE_UNMAPPED_PROFILES_AND_STEREOTYPES_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isRemoveUnmappedProfilesAndStereotypes() <em>Remove Unmapped Profiles And Stereotypes</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isRemoveUnmappedProfilesAndStereotypes()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean removeUnmappedProfilesAndStereotypes = REMOVE_UNMAPPED_PROFILES_AND_STEREOTYPES_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isRemoveUnmappedAnnotations() <em>Remove Unmapped Annotations</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isRemoveUnmappedAnnotations()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean REMOVE_UNMAPPED_ANNOTATIONS_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isRemoveUnmappedAnnotations() <em>Remove Unmapped Annotations</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isRemoveUnmappedAnnotations()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean removeUnmappedAnnotations = REMOVE_UNMAPPED_ANNOTATIONS_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isAlwaysAcceptSuggestedMappings() <em>Always Accept Suggested Mappings</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isAlwaysAcceptSuggestedMappings()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean ALWAYS_ACCEPT_SUGGESTED_MAPPINGS_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isAlwaysAcceptSuggestedMappings() <em>Always Accept Suggested Mappings</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isAlwaysAcceptSuggestedMappings()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean alwaysAcceptSuggestedMappings = ALWAYS_ACCEPT_SUGGESTED_MAPPINGS_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected AdvancedConfigImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return MigrationParametersPackage.Literals.ADVANCED_CONFIG;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public MappingParameters getMappingParameters() {
+		return mappingParameters;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetMappingParameters(MappingParameters newMappingParameters, NotificationChain msgs) {
+		MappingParameters oldMappingParameters = mappingParameters;
+		mappingParameters = newMappingParameters;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, MigrationParametersPackage.ADVANCED_CONFIG__MAPPING_PARAMETERS, oldMappingParameters, newMappingParameters);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setMappingParameters(MappingParameters newMappingParameters) {
+		if (newMappingParameters != mappingParameters) {
+			NotificationChain msgs = null;
+			if (mappingParameters != null)
+				msgs = ((InternalEObject)mappingParameters).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - MigrationParametersPackage.ADVANCED_CONFIG__MAPPING_PARAMETERS, null, msgs);
+			if (newMappingParameters != null)
+				msgs = ((InternalEObject)newMappingParameters).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - MigrationParametersPackage.ADVANCED_CONFIG__MAPPING_PARAMETERS, null, msgs);
+			msgs = basicSetMappingParameters(newMappingParameters, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, MigrationParametersPackage.ADVANCED_CONFIG__MAPPING_PARAMETERS, newMappingParameters, newMappingParameters));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isRemoveUnmappedDiagrams() {
+		return removeUnmappedDiagrams;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setRemoveUnmappedDiagrams(boolean newRemoveUnmappedDiagrams) {
+		boolean oldRemoveUnmappedDiagrams = removeUnmappedDiagrams;
+		removeUnmappedDiagrams = newRemoveUnmappedDiagrams;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, MigrationParametersPackage.ADVANCED_CONFIG__REMOVE_UNMAPPED_DIAGRAMS, oldRemoveUnmappedDiagrams, removeUnmappedDiagrams));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isConvertOpaqueExpressionToLiteralString() {
+		return convertOpaqueExpressionToLiteralString;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setConvertOpaqueExpressionToLiteralString(boolean newConvertOpaqueExpressionToLiteralString) {
+		boolean oldConvertOpaqueExpressionToLiteralString = convertOpaqueExpressionToLiteralString;
+		convertOpaqueExpressionToLiteralString = newConvertOpaqueExpressionToLiteralString;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, MigrationParametersPackage.ADVANCED_CONFIG__CONVERT_OPAQUE_EXPRESSION_TO_LITERAL_STRING, oldConvertOpaqueExpressionToLiteralString, convertOpaqueExpressionToLiteralString));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isRemoveUnmappedProfilesAndStereotypes() {
+		return removeUnmappedProfilesAndStereotypes;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setRemoveUnmappedProfilesAndStereotypes(boolean newRemoveUnmappedProfilesAndStereotypes) {
+		boolean oldRemoveUnmappedProfilesAndStereotypes = removeUnmappedProfilesAndStereotypes;
+		removeUnmappedProfilesAndStereotypes = newRemoveUnmappedProfilesAndStereotypes;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, MigrationParametersPackage.ADVANCED_CONFIG__REMOVE_UNMAPPED_PROFILES_AND_STEREOTYPES, oldRemoveUnmappedProfilesAndStereotypes, removeUnmappedProfilesAndStereotypes));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isRemoveUnmappedAnnotations() {
+		return removeUnmappedAnnotations;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setRemoveUnmappedAnnotations(boolean newRemoveUnmappedAnnotations) {
+		boolean oldRemoveUnmappedAnnotations = removeUnmappedAnnotations;
+		removeUnmappedAnnotations = newRemoveUnmappedAnnotations;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, MigrationParametersPackage.ADVANCED_CONFIG__REMOVE_UNMAPPED_ANNOTATIONS, oldRemoveUnmappedAnnotations, removeUnmappedAnnotations));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isAlwaysAcceptSuggestedMappings() {
+		return alwaysAcceptSuggestedMappings;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setAlwaysAcceptSuggestedMappings(boolean newAlwaysAcceptSuggestedMappings) {
+		boolean oldAlwaysAcceptSuggestedMappings = alwaysAcceptSuggestedMappings;
+		alwaysAcceptSuggestedMappings = newAlwaysAcceptSuggestedMappings;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, MigrationParametersPackage.ADVANCED_CONFIG__ALWAYS_ACCEPT_SUGGESTED_MAPPINGS, oldAlwaysAcceptSuggestedMappings, alwaysAcceptSuggestedMappings));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case MigrationParametersPackage.ADVANCED_CONFIG__MAPPING_PARAMETERS:
+				return basicSetMappingParameters(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case MigrationParametersPackage.ADVANCED_CONFIG__MAPPING_PARAMETERS:
+				return getMappingParameters();
+			case MigrationParametersPackage.ADVANCED_CONFIG__REMOVE_UNMAPPED_DIAGRAMS:
+				return isRemoveUnmappedDiagrams();
+			case MigrationParametersPackage.ADVANCED_CONFIG__CONVERT_OPAQUE_EXPRESSION_TO_LITERAL_STRING:
+				return isConvertOpaqueExpressionToLiteralString();
+			case MigrationParametersPackage.ADVANCED_CONFIG__REMOVE_UNMAPPED_PROFILES_AND_STEREOTYPES:
+				return isRemoveUnmappedProfilesAndStereotypes();
+			case MigrationParametersPackage.ADVANCED_CONFIG__REMOVE_UNMAPPED_ANNOTATIONS:
+				return isRemoveUnmappedAnnotations();
+			case MigrationParametersPackage.ADVANCED_CONFIG__ALWAYS_ACCEPT_SUGGESTED_MAPPINGS:
+				return isAlwaysAcceptSuggestedMappings();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case MigrationParametersPackage.ADVANCED_CONFIG__MAPPING_PARAMETERS:
+				setMappingParameters((MappingParameters)newValue);
+				return;
+			case MigrationParametersPackage.ADVANCED_CONFIG__REMOVE_UNMAPPED_DIAGRAMS:
+				setRemoveUnmappedDiagrams((Boolean)newValue);
+				return;
+			case MigrationParametersPackage.ADVANCED_CONFIG__CONVERT_OPAQUE_EXPRESSION_TO_LITERAL_STRING:
+				setConvertOpaqueExpressionToLiteralString((Boolean)newValue);
+				return;
+			case MigrationParametersPackage.ADVANCED_CONFIG__REMOVE_UNMAPPED_PROFILES_AND_STEREOTYPES:
+				setRemoveUnmappedProfilesAndStereotypes((Boolean)newValue);
+				return;
+			case MigrationParametersPackage.ADVANCED_CONFIG__REMOVE_UNMAPPED_ANNOTATIONS:
+				setRemoveUnmappedAnnotations((Boolean)newValue);
+				return;
+			case MigrationParametersPackage.ADVANCED_CONFIG__ALWAYS_ACCEPT_SUGGESTED_MAPPINGS:
+				setAlwaysAcceptSuggestedMappings((Boolean)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case MigrationParametersPackage.ADVANCED_CONFIG__MAPPING_PARAMETERS:
+				setMappingParameters((MappingParameters)null);
+				return;
+			case MigrationParametersPackage.ADVANCED_CONFIG__REMOVE_UNMAPPED_DIAGRAMS:
+				setRemoveUnmappedDiagrams(REMOVE_UNMAPPED_DIAGRAMS_EDEFAULT);
+				return;
+			case MigrationParametersPackage.ADVANCED_CONFIG__CONVERT_OPAQUE_EXPRESSION_TO_LITERAL_STRING:
+				setConvertOpaqueExpressionToLiteralString(CONVERT_OPAQUE_EXPRESSION_TO_LITERAL_STRING_EDEFAULT);
+				return;
+			case MigrationParametersPackage.ADVANCED_CONFIG__REMOVE_UNMAPPED_PROFILES_AND_STEREOTYPES:
+				setRemoveUnmappedProfilesAndStereotypes(REMOVE_UNMAPPED_PROFILES_AND_STEREOTYPES_EDEFAULT);
+				return;
+			case MigrationParametersPackage.ADVANCED_CONFIG__REMOVE_UNMAPPED_ANNOTATIONS:
+				setRemoveUnmappedAnnotations(REMOVE_UNMAPPED_ANNOTATIONS_EDEFAULT);
+				return;
+			case MigrationParametersPackage.ADVANCED_CONFIG__ALWAYS_ACCEPT_SUGGESTED_MAPPINGS:
+				setAlwaysAcceptSuggestedMappings(ALWAYS_ACCEPT_SUGGESTED_MAPPINGS_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case MigrationParametersPackage.ADVANCED_CONFIG__MAPPING_PARAMETERS:
+				return mappingParameters != null;
+			case MigrationParametersPackage.ADVANCED_CONFIG__REMOVE_UNMAPPED_DIAGRAMS:
+				return removeUnmappedDiagrams != REMOVE_UNMAPPED_DIAGRAMS_EDEFAULT;
+			case MigrationParametersPackage.ADVANCED_CONFIG__CONVERT_OPAQUE_EXPRESSION_TO_LITERAL_STRING:
+				return convertOpaqueExpressionToLiteralString != CONVERT_OPAQUE_EXPRESSION_TO_LITERAL_STRING_EDEFAULT;
+			case MigrationParametersPackage.ADVANCED_CONFIG__REMOVE_UNMAPPED_PROFILES_AND_STEREOTYPES:
+				return removeUnmappedProfilesAndStereotypes != REMOVE_UNMAPPED_PROFILES_AND_STEREOTYPES_EDEFAULT;
+			case MigrationParametersPackage.ADVANCED_CONFIG__REMOVE_UNMAPPED_ANNOTATIONS:
+				return removeUnmappedAnnotations != REMOVE_UNMAPPED_ANNOTATIONS_EDEFAULT;
+			case MigrationParametersPackage.ADVANCED_CONFIG__ALWAYS_ACCEPT_SUGGESTED_MAPPINGS:
+				return alwaysAcceptSuggestedMappings != ALWAYS_ACCEPT_SUGGESTED_MAPPINGS_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (removeUnmappedDiagrams: "); //$NON-NLS-1$
+		result.append(removeUnmappedDiagrams);
+		result.append(", convertOpaqueExpressionToLiteralString: "); //$NON-NLS-1$
+		result.append(convertOpaqueExpressionToLiteralString);
+		result.append(", removeUnmappedProfilesAndStereotypes: "); //$NON-NLS-1$
+		result.append(removeUnmappedProfilesAndStereotypes);
+		result.append(", removeUnmappedAnnotations: "); //$NON-NLS-1$
+		result.append(removeUnmappedAnnotations);
+		result.append(", alwaysAcceptSuggestedMappings: "); //$NON-NLS-1$
+		result.append(alwaysAcceptSuggestedMappings);
+		result.append(')');
+		return result.toString();
+	}
+
+} //AdvancedConfigImpl
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/MappingParametersImpl.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/MappingParametersImpl.java
new file mode 100755
index 0000000..90a1d5b
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/MappingParametersImpl.java
@@ -0,0 +1,198 @@
+/**
+ * Copyright (c) 2014 CEA LIST.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+ * 
+ */
+package org.eclipse.papyrus.interoperability.common.MigrationParameters.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Mapping Parameters</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MappingParametersImpl#getUriMappings <em>Uri Mappings</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.MappingParametersImpl#getProfileUriMappings <em>Profile Uri Mappings</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class MappingParametersImpl extends MinimalEObjectImpl.Container implements MappingParameters {
+	/**
+	 * The cached value of the '{@link #getUriMappings() <em>Uri Mappings</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getUriMappings()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<URIMapping> uriMappings;
+
+	/**
+	 * The cached value of the '{@link #getProfileUriMappings() <em>Profile Uri Mappings</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProfileUriMappings()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<URIMapping> profileUriMappings;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected MappingParametersImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return MigrationParametersPackage.Literals.MAPPING_PARAMETERS;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EList<URIMapping> getUriMappings() {
+		if (uriMappings == null) {
+			uriMappings = new EObjectContainmentEList<URIMapping>(URIMapping.class, this, MigrationParametersPackage.MAPPING_PARAMETERS__URI_MAPPINGS);
+		}
+		return uriMappings;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EList<URIMapping> getProfileUriMappings() {
+		if (profileUriMappings == null) {
+			profileUriMappings = new EObjectContainmentEList<URIMapping>(URIMapping.class, this, MigrationParametersPackage.MAPPING_PARAMETERS__PROFILE_URI_MAPPINGS);
+		}
+		return profileUriMappings;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case MigrationParametersPackage.MAPPING_PARAMETERS__URI_MAPPINGS:
+				return ((InternalEList<?>)getUriMappings()).basicRemove(otherEnd, msgs);
+			case MigrationParametersPackage.MAPPING_PARAMETERS__PROFILE_URI_MAPPINGS:
+				return ((InternalEList<?>)getProfileUriMappings()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case MigrationParametersPackage.MAPPING_PARAMETERS__URI_MAPPINGS:
+				return getUriMappings();
+			case MigrationParametersPackage.MAPPING_PARAMETERS__PROFILE_URI_MAPPINGS:
+				return getProfileUriMappings();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case MigrationParametersPackage.MAPPING_PARAMETERS__URI_MAPPINGS:
+				getUriMappings().clear();
+				getUriMappings().addAll((Collection<? extends URIMapping>)newValue);
+				return;
+			case MigrationParametersPackage.MAPPING_PARAMETERS__PROFILE_URI_MAPPINGS:
+				getProfileUriMappings().clear();
+				getProfileUriMappings().addAll((Collection<? extends URIMapping>)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case MigrationParametersPackage.MAPPING_PARAMETERS__URI_MAPPINGS:
+				getUriMappings().clear();
+				return;
+			case MigrationParametersPackage.MAPPING_PARAMETERS__PROFILE_URI_MAPPINGS:
+				getProfileUriMappings().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case MigrationParametersPackage.MAPPING_PARAMETERS__URI_MAPPINGS:
+				return uriMappings != null && !uriMappings.isEmpty();
+			case MigrationParametersPackage.MAPPING_PARAMETERS__PROFILE_URI_MAPPINGS:
+				return profileUriMappings != null && !profileUriMappings.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+} //MappingParametersImpl
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/MigrationParametersFactoryImpl.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/MigrationParametersFactoryImpl.java
new file mode 100755
index 0000000..2137ff1
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/MigrationParametersFactoryImpl.java
@@ -0,0 +1,138 @@
+/**
+ * Copyright (c) 2014 CEA LIST.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+ * 
+ */
+package org.eclipse.papyrus.interoperability.common.MigrationParameters.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.*;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Factory</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class MigrationParametersFactoryImpl extends EFactoryImpl implements MigrationParametersFactory {
+	/**
+	 * Creates the default factory implementation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static MigrationParametersFactory init() {
+		try {
+			MigrationParametersFactory theMigrationParametersFactory = (MigrationParametersFactory)EPackage.Registry.INSTANCE.getEFactory(MigrationParametersPackage.eNS_URI);
+			if (theMigrationParametersFactory != null) {
+				return theMigrationParametersFactory;
+			}
+		}
+		catch (Exception exception) {
+			EcorePlugin.INSTANCE.log(exception);
+		}
+		return new MigrationParametersFactoryImpl();
+	}
+
+	/**
+	 * Creates an instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public MigrationParametersFactoryImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EObject create(EClass eClass) {
+		switch (eClass.getClassifierID()) {
+			case MigrationParametersPackage.ADVANCED_CONFIG: return createAdvancedConfig();
+			case MigrationParametersPackage.THREAD_CONFIG: return createThreadConfig();
+			case MigrationParametersPackage.MAPPING_PARAMETERS: return createMappingParameters();
+			case MigrationParametersPackage.URI_MAPPING: return createURIMapping();
+			default:
+				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier"); //$NON-NLS-1$ //$NON-NLS-2$
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public AdvancedConfig createAdvancedConfig() {
+		AdvancedConfigImpl advancedConfig = new AdvancedConfigImpl();
+		return advancedConfig;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public ThreadConfig createThreadConfig() {
+		ThreadConfigImpl threadConfig = new ThreadConfigImpl();
+		return threadConfig;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public MappingParameters createMappingParameters() {
+		MappingParametersImpl mappingParameters = new MappingParametersImpl();
+		return mappingParameters;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public URIMapping createURIMapping() {
+		URIMappingImpl uriMapping = new URIMappingImpl();
+		return uriMapping;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public MigrationParametersPackage getMigrationParametersPackage() {
+		return (MigrationParametersPackage)getEPackage();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @deprecated
+	 * @generated
+	 */
+	@Deprecated
+	public static MigrationParametersPackage getPackage() {
+		return MigrationParametersPackage.eINSTANCE;
+	}
+
+} //MigrationParametersFactoryImpl
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/MigrationParametersPackageImpl.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/MigrationParametersPackageImpl.java
new file mode 100755
index 0000000..2dc388a
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/MigrationParametersPackageImpl.java
@@ -0,0 +1,380 @@
+/**
+ * Copyright (c) 2014 CEA LIST.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+ * 
+ */
+package org.eclipse.papyrus.interoperability.common.MigrationParameters.impl;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersFactory;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping;
+import org.eclipse.uml2.types.TypesPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Package</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class MigrationParametersPackageImpl extends EPackageImpl implements MigrationParametersPackage {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass advancedConfigEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass threadConfigEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass mappingParametersEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass uriMappingEClass = null;
+
+	/**
+	 * Creates an instance of the model <b>Package</b>, registered with
+	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+	 * package URI value.
+	 * <p>Note: the correct way to create the package is via the static
+	 * factory method {@link #init init()}, which also performs
+	 * initialization of the package, or returns the registered package,
+	 * if one already exists.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.emf.ecore.EPackage.Registry
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage#eNS_URI
+	 * @see #init()
+	 * @generated
+	 */
+	private MigrationParametersPackageImpl() {
+		super(eNS_URI, MigrationParametersFactory.eINSTANCE);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private static boolean isInited = false;
+
+	/**
+	 * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
+	 * 
+	 * <p>This method is used to initialize {@link MigrationParametersPackage#eINSTANCE} when that field is accessed.
+	 * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #eNS_URI
+	 * @see #createPackageContents()
+	 * @see #initializePackageContents()
+	 * @generated
+	 */
+	public static MigrationParametersPackage init() {
+		if (isInited) return (MigrationParametersPackage)EPackage.Registry.INSTANCE.getEPackage(MigrationParametersPackage.eNS_URI);
+
+		// Obtain or create and register package
+		MigrationParametersPackageImpl theMigrationParametersPackage = (MigrationParametersPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof MigrationParametersPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new MigrationParametersPackageImpl());
+
+		isInited = true;
+
+		// Initialize simple dependencies
+		TypesPackage.eINSTANCE.eClass();
+
+		// Create package meta-data objects
+		theMigrationParametersPackage.createPackageContents();
+
+		// Initialize created meta-data
+		theMigrationParametersPackage.initializePackageContents();
+
+		// Mark meta-data to indicate it can't be changed
+		theMigrationParametersPackage.freeze();
+
+  
+		// Update the registry and return the package
+		EPackage.Registry.INSTANCE.put(MigrationParametersPackage.eNS_URI, theMigrationParametersPackage);
+		return theMigrationParametersPackage;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getAdvancedConfig() {
+		return advancedConfigEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getAdvancedConfig_MappingParameters() {
+		return (EReference)advancedConfigEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getAdvancedConfig_RemoveUnmappedDiagrams() {
+		return (EAttribute)advancedConfigEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getAdvancedConfig_ConvertOpaqueExpressionToLiteralString() {
+		return (EAttribute)advancedConfigEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getAdvancedConfig_RemoveUnmappedProfilesAndStereotypes() {
+		return (EAttribute)advancedConfigEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getAdvancedConfig_RemoveUnmappedAnnotations() {
+		return (EAttribute)advancedConfigEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getAdvancedConfig_AlwaysAcceptSuggestedMappings() {
+		return (EAttribute)advancedConfigEClass.getEStructuralFeatures().get(5);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getThreadConfig() {
+		return threadConfigEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getThreadConfig_Name() {
+		return (EAttribute)threadConfigEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getThreadConfig_MaxThreads() {
+		return (EAttribute)threadConfigEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getMappingParameters() {
+		return mappingParametersEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getMappingParameters_UriMappings() {
+		return (EReference)mappingParametersEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getMappingParameters_ProfileUriMappings() {
+		return (EReference)mappingParametersEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getURIMapping() {
+		return uriMappingEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getURIMapping_SourceURI() {
+		return (EAttribute)uriMappingEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getURIMapping_TargetURI() {
+		return (EAttribute)uriMappingEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public MigrationParametersFactory getMigrationParametersFactory() {
+		return (MigrationParametersFactory)getEFactoryInstance();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private boolean isCreated = false;
+
+	/**
+	 * Creates the meta-model objects for the package.  This method is
+	 * guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void createPackageContents() {
+		if (isCreated) return;
+		isCreated = true;
+
+		// Create classes and their features
+		advancedConfigEClass = createEClass(ADVANCED_CONFIG);
+		createEReference(advancedConfigEClass, ADVANCED_CONFIG__MAPPING_PARAMETERS);
+		createEAttribute(advancedConfigEClass, ADVANCED_CONFIG__REMOVE_UNMAPPED_DIAGRAMS);
+		createEAttribute(advancedConfigEClass, ADVANCED_CONFIG__CONVERT_OPAQUE_EXPRESSION_TO_LITERAL_STRING);
+		createEAttribute(advancedConfigEClass, ADVANCED_CONFIG__REMOVE_UNMAPPED_PROFILES_AND_STEREOTYPES);
+		createEAttribute(advancedConfigEClass, ADVANCED_CONFIG__REMOVE_UNMAPPED_ANNOTATIONS);
+		createEAttribute(advancedConfigEClass, ADVANCED_CONFIG__ALWAYS_ACCEPT_SUGGESTED_MAPPINGS);
+
+		threadConfigEClass = createEClass(THREAD_CONFIG);
+		createEAttribute(threadConfigEClass, THREAD_CONFIG__NAME);
+		createEAttribute(threadConfigEClass, THREAD_CONFIG__MAX_THREADS);
+
+		mappingParametersEClass = createEClass(MAPPING_PARAMETERS);
+		createEReference(mappingParametersEClass, MAPPING_PARAMETERS__URI_MAPPINGS);
+		createEReference(mappingParametersEClass, MAPPING_PARAMETERS__PROFILE_URI_MAPPINGS);
+
+		uriMappingEClass = createEClass(URI_MAPPING);
+		createEAttribute(uriMappingEClass, URI_MAPPING__SOURCE_URI);
+		createEAttribute(uriMappingEClass, URI_MAPPING__TARGET_URI);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private boolean isInitialized = false;
+
+	/**
+	 * Complete the initialization of the package and its meta-model.  This
+	 * method is guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void initializePackageContents() {
+		if (isInitialized) return;
+		isInitialized = true;
+
+		// Initialize package
+		setName(eNAME);
+		setNsPrefix(eNS_PREFIX);
+		setNsURI(eNS_URI);
+
+		// Obtain other dependent packages
+		TypesPackage theTypesPackage = (TypesPackage)EPackage.Registry.INSTANCE.getEPackage(TypesPackage.eNS_URI);
+
+		// Create type parameters
+
+		// Set bounds for type parameters
+
+		// Add supertypes to classes
+		advancedConfigEClass.getESuperTypes().add(this.getThreadConfig());
+
+		// Initialize classes, features, and operations; add parameters
+		initEClass(advancedConfigEClass, AdvancedConfig.class, "AdvancedConfig", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEReference(getAdvancedConfig_MappingParameters(), this.getMappingParameters(), null, "mappingParameters", null, 1, 1, AdvancedConfig.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+		initEAttribute(getAdvancedConfig_RemoveUnmappedDiagrams(), theTypesPackage.getBoolean(), "removeUnmappedDiagrams", "false", 1, 1, AdvancedConfig.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$ //$NON-NLS-2$
+		initEAttribute(getAdvancedConfig_ConvertOpaqueExpressionToLiteralString(), theTypesPackage.getBoolean(), "convertOpaqueExpressionToLiteralString", "true", 1, 1, AdvancedConfig.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$ //$NON-NLS-2$
+		initEAttribute(getAdvancedConfig_RemoveUnmappedProfilesAndStereotypes(), theTypesPackage.getBoolean(), "removeUnmappedProfilesAndStereotypes", "false", 1, 1, AdvancedConfig.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$ //$NON-NLS-2$
+		initEAttribute(getAdvancedConfig_RemoveUnmappedAnnotations(), theTypesPackage.getBoolean(), "removeUnmappedAnnotations", "false", 1, 1, AdvancedConfig.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$ //$NON-NLS-2$
+		initEAttribute(getAdvancedConfig_AlwaysAcceptSuggestedMappings(), theTypesPackage.getBoolean(), "alwaysAcceptSuggestedMappings", "false", 1, 1, AdvancedConfig.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$ //$NON-NLS-2$
+
+		initEClass(threadConfigEClass, ThreadConfig.class, "ThreadConfig", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEAttribute(getThreadConfig_Name(), theTypesPackage.getString(), "name", null, 1, 1, ThreadConfig.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+		initEAttribute(getThreadConfig_MaxThreads(), theTypesPackage.getInteger(), "maxThreads", "2", 1, 1, ThreadConfig.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$ //$NON-NLS-2$
+
+		initEClass(mappingParametersEClass, MappingParameters.class, "MappingParameters", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEReference(getMappingParameters_UriMappings(), this.getURIMapping(), null, "uriMappings", null, 0, -1, MappingParameters.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+		initEReference(getMappingParameters_ProfileUriMappings(), this.getURIMapping(), null, "profileUriMappings", null, 0, -1, MappingParameters.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(uriMappingEClass, URIMapping.class, "URIMapping", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEAttribute(getURIMapping_SourceURI(), theTypesPackage.getString(), "sourceURI", null, 1, 1, URIMapping.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+		initEAttribute(getURIMapping_TargetURI(), theTypesPackage.getString(), "targetURI", null, 1, 1, URIMapping.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+
+		// Create resource
+		createResource(eNS_URI);
+	}
+
+} //MigrationParametersPackageImpl
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/ThreadConfigImpl.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/ThreadConfigImpl.java
new file mode 100755
index 0000000..791e983
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/ThreadConfigImpl.java
@@ -0,0 +1,227 @@
+/**
+ * Copyright (c) 2014 CEA LIST.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+ * 
+ */
+package org.eclipse.papyrus.interoperability.common.MigrationParameters.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Thread Config</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.ThreadConfigImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.ThreadConfigImpl#getMaxThreads <em>Max Threads</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class ThreadConfigImpl extends MinimalEObjectImpl.Container implements ThreadConfig {
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getMaxThreads() <em>Max Threads</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getMaxThreads()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final int MAX_THREADS_EDEFAULT = 2;
+
+	/**
+	 * The cached value of the '{@link #getMaxThreads() <em>Max Threads</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getMaxThreads()
+	 * @generated
+	 * @ordered
+	 */
+	protected int maxThreads = MAX_THREADS_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ThreadConfigImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return MigrationParametersPackage.Literals.THREAD_CONFIG;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, MigrationParametersPackage.THREAD_CONFIG__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public int getMaxThreads() {
+		return maxThreads;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setMaxThreads(int newMaxThreads) {
+		int oldMaxThreads = maxThreads;
+		maxThreads = newMaxThreads;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, MigrationParametersPackage.THREAD_CONFIG__MAX_THREADS, oldMaxThreads, maxThreads));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case MigrationParametersPackage.THREAD_CONFIG__NAME:
+				return getName();
+			case MigrationParametersPackage.THREAD_CONFIG__MAX_THREADS:
+				return getMaxThreads();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case MigrationParametersPackage.THREAD_CONFIG__NAME:
+				setName((String)newValue);
+				return;
+			case MigrationParametersPackage.THREAD_CONFIG__MAX_THREADS:
+				setMaxThreads((Integer)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case MigrationParametersPackage.THREAD_CONFIG__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case MigrationParametersPackage.THREAD_CONFIG__MAX_THREADS:
+				setMaxThreads(MAX_THREADS_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case MigrationParametersPackage.THREAD_CONFIG__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case MigrationParametersPackage.THREAD_CONFIG__MAX_THREADS:
+				return maxThreads != MAX_THREADS_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (name: "); //$NON-NLS-1$
+		result.append(name);
+		result.append(", maxThreads: "); //$NON-NLS-1$
+		result.append(maxThreads);
+		result.append(')');
+		return result.toString();
+	}
+
+} //ThreadConfigImpl
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/URIMappingImpl.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/URIMappingImpl.java
new file mode 100755
index 0000000..b1a78e0
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/impl/URIMappingImpl.java
@@ -0,0 +1,227 @@
+/**
+ * Copyright (c) 2014 CEA LIST.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+ * 
+ */
+package org.eclipse.papyrus.interoperability.common.MigrationParameters.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>URI Mapping</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.URIMappingImpl#getSourceURI <em>Source URI</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.impl.URIMappingImpl#getTargetURI <em>Target URI</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class URIMappingImpl extends MinimalEObjectImpl.Container implements URIMapping {
+	/**
+	 * The default value of the '{@link #getSourceURI() <em>Source URI</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getSourceURI()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String SOURCE_URI_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getSourceURI() <em>Source URI</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getSourceURI()
+	 * @generated
+	 * @ordered
+	 */
+	protected String sourceURI = SOURCE_URI_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getTargetURI() <em>Target URI</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTargetURI()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String TARGET_URI_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getTargetURI() <em>Target URI</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTargetURI()
+	 * @generated
+	 * @ordered
+	 */
+	protected String targetURI = TARGET_URI_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected URIMappingImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return MigrationParametersPackage.Literals.URI_MAPPING;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String getSourceURI() {
+		return sourceURI;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setSourceURI(String newSourceURI) {
+		String oldSourceURI = sourceURI;
+		sourceURI = newSourceURI;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, MigrationParametersPackage.URI_MAPPING__SOURCE_URI, oldSourceURI, sourceURI));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String getTargetURI() {
+		return targetURI;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setTargetURI(String newTargetURI) {
+		String oldTargetURI = targetURI;
+		targetURI = newTargetURI;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, MigrationParametersPackage.URI_MAPPING__TARGET_URI, oldTargetURI, targetURI));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case MigrationParametersPackage.URI_MAPPING__SOURCE_URI:
+				return getSourceURI();
+			case MigrationParametersPackage.URI_MAPPING__TARGET_URI:
+				return getTargetURI();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case MigrationParametersPackage.URI_MAPPING__SOURCE_URI:
+				setSourceURI((String)newValue);
+				return;
+			case MigrationParametersPackage.URI_MAPPING__TARGET_URI:
+				setTargetURI((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case MigrationParametersPackage.URI_MAPPING__SOURCE_URI:
+				setSourceURI(SOURCE_URI_EDEFAULT);
+				return;
+			case MigrationParametersPackage.URI_MAPPING__TARGET_URI:
+				setTargetURI(TARGET_URI_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case MigrationParametersPackage.URI_MAPPING__SOURCE_URI:
+				return SOURCE_URI_EDEFAULT == null ? sourceURI != null : !SOURCE_URI_EDEFAULT.equals(sourceURI);
+			case MigrationParametersPackage.URI_MAPPING__TARGET_URI:
+				return TARGET_URI_EDEFAULT == null ? targetURI != null : !TARGET_URI_EDEFAULT.equals(targetURI);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (sourceURI: "); //$NON-NLS-1$
+		result.append(sourceURI);
+		result.append(", targetURI: "); //$NON-NLS-1$
+		result.append(targetURI);
+		result.append(')');
+		return result.toString();
+	}
+
+} //URIMappingImpl
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/util/MigrationParametersAdapterFactory.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/util/MigrationParametersAdapterFactory.java
new file mode 100755
index 0000000..27f7270
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/util/MigrationParametersAdapterFactory.java
@@ -0,0 +1,184 @@
+/**
+ * Copyright (c) 2014 CEA LIST.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+ * 
+ */
+package org.eclipse.papyrus.interoperability.common.MigrationParameters.util;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.*;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Adapter Factory</b> for the model.
+ * It provides an adapter <code>createXXX</code> method for each class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage
+ * @generated
+ */
+public class MigrationParametersAdapterFactory extends AdapterFactoryImpl {
+	/**
+	 * The cached model package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected static MigrationParametersPackage modelPackage;
+
+	/**
+	 * Creates an instance of the adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public MigrationParametersAdapterFactory() {
+		if (modelPackage == null) {
+			modelPackage = MigrationParametersPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Returns whether this factory is applicable for the type of the object.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
+	 * <!-- end-user-doc -->
+	 * @return whether this factory is applicable for the type of the object.
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object object) {
+		if (object == modelPackage) {
+			return true;
+		}
+		if (object instanceof EObject) {
+			return ((EObject)object).eClass().getEPackage() == modelPackage;
+		}
+		return false;
+	}
+
+	/**
+	 * The switch that delegates to the <code>createXXX</code> methods.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected MigrationParametersSwitch<Adapter> modelSwitch =
+		new MigrationParametersSwitch<Adapter>() {
+			@Override
+			public Adapter caseAdvancedConfig(AdvancedConfig object) {
+				return createAdvancedConfigAdapter();
+			}
+			@Override
+			public Adapter caseThreadConfig(ThreadConfig object) {
+				return createThreadConfigAdapter();
+			}
+			@Override
+			public Adapter caseMappingParameters(MappingParameters object) {
+				return createMappingParametersAdapter();
+			}
+			@Override
+			public Adapter caseURIMapping(URIMapping object) {
+				return createURIMappingAdapter();
+			}
+			@Override
+			public Adapter defaultCase(EObject object) {
+				return createEObjectAdapter();
+			}
+		};
+
+	/**
+	 * Creates an adapter for the <code>target</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param target the object to adapt.
+	 * @return the adapter for the <code>target</code>.
+	 * @generated
+	 */
+	@Override
+	public Adapter createAdapter(Notifier target) {
+		return modelSwitch.doSwitch((EObject)target);
+	}
+
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig <em>Advanced Config</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig
+	 * @generated
+	 */
+	public Adapter createAdvancedConfigAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig <em>Thread Config</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig
+	 * @generated
+	 */
+	public Adapter createThreadConfigAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters <em>Mapping Parameters</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters
+	 * @generated
+	 */
+	public Adapter createMappingParametersAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping <em>URI Mapping</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping
+	 * @generated
+	 */
+	public Adapter createURIMappingAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for the default case.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @generated
+	 */
+	public Adapter createEObjectAdapter() {
+		return null;
+	}
+
+} //MigrationParametersAdapterFactory
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/util/MigrationParametersSwitch.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/util/MigrationParametersSwitch.java
new file mode 100755
index 0000000..a39b580
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src-gen/org/eclipse/papyrus/interoperability/common/MigrationParameters/util/MigrationParametersSwitch.java
@@ -0,0 +1,184 @@
+/**
+ * Copyright (c) 2014 CEA LIST.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *   Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *   Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176
+ * 
+ */
+package org.eclipse.papyrus.interoperability.common.MigrationParameters.util;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.util.Switch;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.*;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Switch</b> for the model's inheritance hierarchy.
+ * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object
+ * and proceeding up the inheritance hierarchy
+ * until a non-null result is returned,
+ * which is the result of the switch.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersPackage
+ * @generated
+ */
+public class MigrationParametersSwitch<T> extends Switch<T> {
+	/**
+	 * The cached model package
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected static MigrationParametersPackage modelPackage;
+
+	/**
+	 * Creates an instance of the switch.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public MigrationParametersSwitch() {
+		if (modelPackage == null) {
+			modelPackage = MigrationParametersPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Checks whether this is a switch for the given package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param ePackage the package in question.
+	 * @return whether this is a switch for the given package.
+	 * @generated
+	 */
+	@Override
+	protected boolean isSwitchFor(EPackage ePackage) {
+		return ePackage == modelPackage;
+	}
+
+	/**
+	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the first non-null result returned by a <code>caseXXX</code> call.
+	 * @generated
+	 */
+	@Override
+	protected T doSwitch(int classifierID, EObject theEObject) {
+		switch (classifierID) {
+			case MigrationParametersPackage.ADVANCED_CONFIG: {
+				AdvancedConfig advancedConfig = (AdvancedConfig)theEObject;
+				T result = caseAdvancedConfig(advancedConfig);
+				if (result == null) result = caseThreadConfig(advancedConfig);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case MigrationParametersPackage.THREAD_CONFIG: {
+				ThreadConfig threadConfig = (ThreadConfig)theEObject;
+				T result = caseThreadConfig(threadConfig);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case MigrationParametersPackage.MAPPING_PARAMETERS: {
+				MappingParameters mappingParameters = (MappingParameters)theEObject;
+				T result = caseMappingParameters(mappingParameters);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case MigrationParametersPackage.URI_MAPPING: {
+				URIMapping uriMapping = (URIMapping)theEObject;
+				T result = caseURIMapping(uriMapping);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			default: return defaultCase(theEObject);
+		}
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Advanced Config</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Advanced Config</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseAdvancedConfig(AdvancedConfig object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Thread Config</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Thread Config</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseThreadConfig(ThreadConfig object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Mapping Parameters</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Mapping Parameters</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseMappingParameters(MappingParameters object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>URI Mapping</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>URI Mapping</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseURIMapping(URIMapping object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch, but this is the last case anyway.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+	 * @generated
+	 */
+	@Override
+	public T defaultCase(EObject object) {
+		return null;
+	}
+
+} //MigrationParametersSwitch
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/Activator.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/Activator.java
new file mode 100644
index 0000000..bf03480
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/Activator.java
@@ -0,0 +1,54 @@
+package org.eclipse.papyrus.interoperability.common;
+
+import org.eclipse.papyrus.infra.core.log.LogHelper;
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+import org.osgi.framework.BundleContext;
+
+/**
+ * The activator class controls the plug-in life cycle
+ */
+public class Activator extends AbstractUIPlugin {
+
+	// The plug-in ID
+	public static final String PLUGIN_ID = "org.eclipse.papyrus.interoperability.common"; //$NON-NLS-1$
+
+	// The shared instance
+	private static Activator plugin;
+	
+	public static LogHelper log;
+	
+	/**
+	 * The constructor
+	 */
+	public Activator() {
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
+	 */
+	public void start(BundleContext context) throws Exception {
+		super.start(context);
+		plugin = this;
+		log = new LogHelper(this);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
+	 */
+	public void stop(BundleContext context) throws Exception {
+		plugin = null;
+		super.stop(context);
+	}
+
+	/**
+	 * Returns the shared instance
+	 *
+	 * @return the shared instance
+	 */
+	public static Activator getDefault() {
+		return plugin;
+	}
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/concurrent/ExecutorsPool.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/concurrent/ExecutorsPool.java
new file mode 100644
index 0000000..9934bca
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/concurrent/ExecutorsPool.java
@@ -0,0 +1,173 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.concurrent;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.m2m.qvt.oml.TransformationExecutor;
+import org.eclipse.papyrus.interoperability.common.Activator;
+
+
+/**
+ * Thread safe pool of Transformation Executors
+ *
+ * @author Camille Letavernier
+ *
+ */
+public class ExecutorsPool {
+
+	// The cache can be used to increase performances (For small and medium sized models, most of the execution time is spent in loading the transformation)
+	// Warning: using the cache prevents dynamic transformations (i.e. it should not be used in Debug Mode)
+	protected boolean cacheTransformations = true;
+
+	private final int poolSize;
+
+	public ExecutorsPool(int size) {
+		this.poolSize = size;
+	}
+
+	private final Map<URI, Pool> executors = new HashMap<URI, Pool>();
+
+	private final Map<TransformationExecutor, URI> executorsURIs = new HashMap<TransformationExecutor, URI>();
+
+	/**
+	 * Gets an available executor for the given transformation URI. Creates it if needed,
+	 * and we haven't reached the poolSize for this transformationURI
+	 *
+	 * Transformation executor needs to be released after usage
+	 *
+	 * @param transformationURI
+	 * @return
+	 */
+	public TransformationExecutor getExecutor(URI transformationURI) {
+		if (!cacheTransformations) {
+			return new Pool(transformationURI).createExecutor();
+		}
+
+		synchronized (executors) {
+			if (!executors.containsKey(transformationURI)) {
+				executors.put(transformationURI, new Pool(transformationURI));
+			}
+		}
+
+		Pool pool = executors.get(transformationURI);
+		return pool.getExecutor();
+	}
+
+	/**
+	 * Preloads all instances for the given URI
+	 *
+	 * @param transformationURI
+	 * @return
+	 */
+	public synchronized IStatus preLoad(URI transformationURI) {
+		// Don't preload if there is no cache
+		if (!cacheTransformations) {
+			return Status.OK_STATUS;
+		}
+
+		synchronized (this) {
+			if (!executors.containsKey(transformationURI)) {
+				Pool pool = new Pool(transformationURI);
+				executors.put(transformationURI, pool);
+				pool.preload();
+			}
+		}
+
+		return Status.OK_STATUS;
+	}
+
+	/**
+	 * Releases a transformation executor after usage
+	 *
+	 * @param executor
+	 */
+	public void releaseExecutor(TransformationExecutor executor) {
+		if (!cacheTransformations) {
+			return;
+		}
+		URI transformationURI = executorsURIs.get(executor);
+		Pool pool = executors.get(transformationURI);
+		pool.release(executor);
+	}
+
+	private class Pool {
+		private List<TransformationExecutor> allExecutors = new LinkedList<TransformationExecutor>();
+
+		private List<TransformationExecutor> busyExecutors = new LinkedList<TransformationExecutor>();
+
+		private final URI transformationURI;
+
+		public Pool(URI transformationURI) {
+			this.transformationURI = transformationURI;
+		}
+
+		public void preload() {
+			for (int i = 0; i < poolSize; i++) {
+				createExecutor();
+			}
+			busyExecutors.clear();
+		}
+
+		public synchronized void release(TransformationExecutor executor) {
+			busyExecutors.remove(executor);
+		}
+
+		public TransformationExecutor getExecutor() {
+			while (true) {
+				synchronized (this) {
+					for (TransformationExecutor executor : allExecutors) {
+						if (isAvailable(executor)) {
+							return getExecutor(executor);
+						}
+					}
+
+					if (allExecutors.size() < poolSize) {
+						return createExecutor();
+					}
+				}
+
+				try {
+					Thread.sleep(25);
+				} catch (InterruptedException ex) {
+					Activator.log.error(ex);
+					return null;
+				}
+			}
+		}
+
+		private boolean isAvailable(TransformationExecutor executor) {
+			return !busyExecutors.contains(executor);
+		}
+
+		private TransformationExecutor getExecutor(TransformationExecutor executor) {
+			busyExecutors.add(executor);
+			return executor;
+		}
+
+		private TransformationExecutor createExecutor() {
+			TransformationExecutor executor = new TransformationExecutor(transformationURI);
+			executor.loadTransformation();
+			allExecutors.add(executor);
+			executorsURIs.put(executor, transformationURI);
+			return getExecutor(executor);
+		}
+
+	}
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/concurrent/ResourceAccessHelper.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/concurrent/ResourceAccessHelper.java
new file mode 100644
index 0000000..af8089e
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/concurrent/ResourceAccessHelper.java
@@ -0,0 +1,104 @@
+/*****************************************************************************
+ * Copyright (c) 2015 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.concurrent;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.resource.Resource;
+
+/**
+ * This class is used to synchronize access to physical EMF Resources (Load/Save)
+ * 
+ * @author Camille Letavernier
+ *
+ */
+public class ResourceAccessHelper {
+	public static ResourceAccessHelper INSTANCE = new ResourceAccessHelper();
+
+	private final Map<URI, ReadWriteLock> locks = new HashMap<URI, ReadWriteLock>();
+
+	private ResourceAccessHelper() {
+		// Singleton
+	}
+
+	private Lock getSaveLock(Resource resource) {
+		ReadWriteLock lock = getLock(resource);
+		return lock.writeLock();
+	}
+
+	private Lock getLoadLoack(Resource resource) {
+		ReadWriteLock lock = getLock(resource);
+		return lock.readLock();
+	}
+
+	/**
+	 * Saves a resource in a thread-safe way. Ensures that the underlying physical
+	 * resource is not being read during the save action
+	 * 
+	 * @param resource
+	 * @param options
+	 * @throws IOException
+	 */
+	public void saveResource(Resource resource, Map<?, ?> options) throws IOException {
+		Lock lock = getSaveLock(resource);
+		lock.lock();
+		try {
+			resource.save(options);
+		} finally {
+			lock.unlock();
+		}
+	}
+
+	/**
+	 * Loads a resource in a thread-safe way. Ensures that the underlying physical
+	 * resource is not being saved during the load action. Concurrent read operations
+	 * may still happen
+	 * 
+	 * @param resource
+	 * @param options
+	 * @throws IOException
+	 */
+	public void loadResource(Resource resource, Map<?, ?> options) throws IOException {
+		Lock lock = getLoadLoack(resource);
+		lock.lock();
+		try {
+			resource.load(options);
+		} finally {
+			lock.unlock();
+		}
+	}
+
+	
+
+	private ReadWriteLock getLock(Resource resource) {
+		URI uri = resource.getURI();
+		if (uri == null) {
+			return null;
+		}
+
+		synchronized (this) {
+			if (!locks.containsKey(uri)) {
+				locks.put(uri, new ReentrantReadWriteLock());
+			}
+
+			return locks.get(uri);
+		}
+	}
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/concurrent/ThreadSafeModelSet.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/concurrent/ThreadSafeModelSet.java
new file mode 100644
index 0000000..18a56dc
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/concurrent/ThreadSafeModelSet.java
@@ -0,0 +1,34 @@
+/*****************************************************************************
+ * Copyright (c) 2015 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.concurrent;
+
+import java.io.IOException;
+
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.papyrus.infra.core.utils.DiResourceSet;
+
+/**
+ * A ModelSet with thread-safe load operations
+ * 
+ * Note: since Save operations are delegated to IModels, save operations are <strong>thread-safe</strong>.
+ * Resources of this ResourceSet should be saved by delegating to {@link ResourceAccessHelper#saveResource(Resource, Map<?, ?>)}
+ * 
+ * @see {@link ResourceAccessHelper}
+ */
+public class ThreadSafeModelSet extends DiResourceSet {
+	@Override
+	protected void demandLoad(Resource resource) throws IOException {
+		Resource resourceWithOptions = setResourceOptions(resource);
+		ResourceAccessHelper.INSTANCE.loadResource(resourceWithOptions, getLoadOptions());
+	}
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/concurrent/ThreadSafeResourceSet.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/concurrent/ThreadSafeResourceSet.java
new file mode 100644
index 0000000..1d26fe8
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/concurrent/ThreadSafeResourceSet.java
@@ -0,0 +1,34 @@
+/*****************************************************************************
+ * Copyright (c) 2015 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.concurrent;
+
+import java.io.IOException;
+
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
+
+/**
+ * A ResourceSet with thread-safe Load operations
+ * 
+ * Resources should be saved using {@link ResourceAccessHelper#saveResource(Resource, java.util.Map)}
+ * 
+ * @author Camille Letavernier
+ *
+ * @see {@link ResourceAccessHelper}
+ */
+public class ThreadSafeResourceSet extends ResourceSetImpl {
+	@Override
+	protected void demandLoad(Resource resource) throws IOException {
+		ResourceAccessHelper.INSTANCE.loadResource(resource, getLoadOptions());
+	}
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/handler/AbstractMigrationHandler.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/handler/AbstractMigrationHandler.java
new file mode 100644
index 0000000..dc86dd3
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/handler/AbstractMigrationHandler.java
@@ -0,0 +1,212 @@
+/*****************************************************************************
+ * Copyright (c) 2016 CEA LIST and others.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *   CEA LIST - Initial API and implementation
+ *   
+ *****************************************************************************/
+
+package org.eclipse.papyrus.interoperability.common.handler;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.eclipse.core.commands.AbstractHandler;
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.osgi.util.NLS;
+import org.eclipse.papyrus.infra.properties.ui.creation.PropertyEditorFactory;
+import org.eclipse.papyrus.interoperability.common.Activator;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersFactory;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig;
+import org.eclipse.papyrus.interoperability.common.transformation.IImportTransformationLauncher;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.handlers.HandlerUtil;
+
+/**
+ * @author VL222926
+ *         Abstract handler for Migration action
+ */
+public abstract class AbstractMigrationHandler extends AbstractHandler {
+
+	/**
+	 * the extensions of the files to import
+	 */
+	private Set<String> extensionOfFilesToImport;
+
+	/**
+	 * 
+	 * Constructor.
+	 *
+	 * @param acceptedFileExtension
+	 *            the extension of the files to import
+	 */
+	protected AbstractMigrationHandler(final Set<String> acceptedFileExtension) {
+		this.extensionOfFilesToImport = acceptedFileExtension;
+	}
+
+	/**
+	 * 
+	 * @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)
+	 *
+	 * @param event
+	 * @return
+	 * @throws ExecutionException
+	 */
+	@Override
+	public Object execute(ExecutionEvent event) throws ExecutionException {
+		ISelection selection = HandlerUtil.getCurrentSelection(event);
+		if (selection == null || selection.isEmpty()) {
+			return null;
+		}
+
+		Set<IFile> filesToImport = new HashSet<IFile>();
+
+		if (selection instanceof IStructuredSelection) {
+			IStructuredSelection structuredSelection = (IStructuredSelection) selection;
+			Iterator<?> selectionIterator = structuredSelection.iterator();
+			while (selectionIterator.hasNext()) {
+				Object selectedElement = selectionIterator.next();
+				if (selectedElement instanceof IAdaptable) {
+					IFile selectedFile = (IFile) ((IAdaptable) selectedElement).getAdapter(IFile.class);
+					if (selectedFile == null) {
+						continue;
+					}
+
+					String fileExtension = selectedFile.getFileExtension();
+					if (extensionOfFilesToImport.contains(fileExtension)) {
+						filesToImport.add(selectedFile);
+					}
+				}
+			}
+		}
+
+		if (filesToImport.isEmpty()) {
+			StringBuilder builder = new StringBuilder();
+			Iterator<String> iter = extensionOfFilesToImport.iterator();
+			while (iter.hasNext()) {
+				builder.append("*.");
+				builder.append(iter.next());
+				if (iter.hasNext()) {
+					builder.append(", ");
+				}
+			}
+			Activator.log.warn(NLS.bind("The selection doesn't contain any file with one of these extensions: {0}", builder.toString()));
+		} else {
+			importFiles(filesToImport, event);
+		}
+
+		return null;
+	}
+
+
+	public void importFiles(Set<IFile> selectedFiles, ExecutionEvent event) {
+		ThreadConfig config = getTransformationParameters(event);
+
+		if (config == null) {
+			return;
+		}
+
+
+		// The Event's control is (or may be) a Context Menu, which will be disposed soon: retrieve its own parent instead (The main Window), if it has one.
+		Control baseControl = HandlerUtil.getActiveShell(event);
+		if (baseControl != null && !baseControl.isDisposed() && baseControl.getParent() != null) {
+			baseControl = baseControl.getParent();
+		}
+
+		// On some platforms, it seems that the ActiveShell (Context Menu) may already be disposed (Bug 455011). Use the Active Workbench Window directly
+		if (baseControl == null || baseControl.isDisposed()) {
+			baseControl = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
+		}
+
+		runTransformation(config, baseControl, selectedFiles);
+
+	}
+
+	protected void runTransformation(final ThreadConfig config, final Control baseControl, final Set<IFile> selectedFiles) {
+		List<URI> urisToImport = new LinkedList<URI>();
+
+		for (IFile selectedFile : selectedFiles) {
+			URI uri = URI.createPlatformResourceURI(selectedFile.getFullPath().toString(), true);
+			urisToImport.add(uri);
+		}
+		runTransformation(config, baseControl, urisToImport);
+	}
+
+	protected void runTransformation(final ThreadConfig config, final Control baseControl, final List<URI> urisToImport) {
+		IImportTransformationLauncher launcher = createImportTransformationLauncher(config, baseControl);
+		launcher.run(urisToImport);
+	}
+
+
+	/**
+	 * 
+	 * @param config
+	 *            the configuration used to launch the import
+	 * @param baseControl
+	 * 
+	 * @return
+	 * 		the launcher of the import transformation
+	 */
+	protected abstract IImportTransformationLauncher createImportTransformationLauncher(final ThreadConfig config, final Control baseControl);
+
+	public ThreadConfig getTransformationParameters(ExecutionEvent event) {
+		ThreadConfig config = createConfigParameters();
+
+		Shell activeShell = HandlerUtil.getActiveShell(event);
+
+		final AtomicBoolean okPressed = new AtomicBoolean(true);
+		PropertyEditorFactory factory = new PropertyEditorFactory() {
+			@Override
+			public String getEditionDialogTitle(Object objectToEdit) {
+				return "Transformation parameters";
+			}
+
+			@Override
+			protected void handleEditCancelled(Control widget, Object source) {
+				okPressed.set(false);
+				super.handleEditCancelled(widget, source);
+			}
+		};
+
+		Object result = factory.edit(activeShell, config);
+
+		if (!okPressed.get()) {
+			return null;
+		}
+
+		// Result can be null, the source config, or a new config
+		if (result instanceof ThreadConfig) {
+			config = (ThreadConfig) result;
+		}
+
+		return config;
+	}
+
+	/**
+	 * 
+	 * @return
+	 * 		This method return a new instance of the configuration to use for the migration
+	 */
+	protected ThreadConfig createConfigParameters() {
+		return MigrationParametersFactory.eINSTANCE.createThreadConfig();
+	}
+
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/JobWrapper.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/JobWrapper.java
new file mode 100644
index 0000000..1a1354e
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/JobWrapper.java
@@ -0,0 +1,45 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.internal;
+
+import org.eclipse.core.runtime.jobs.Job;
+
+public class JobWrapper implements Schedulable {
+
+	protected final Job job;
+
+	public JobWrapper(Job job) {
+		this.job = job;
+	}
+
+	@Override
+	public void start() {
+		job.schedule();
+	}
+
+	@Override
+	public boolean isComplete() {
+		return job.getResult() != null;
+	}
+
+	@Override
+	public String getName() {
+		return job.getName();
+	}
+
+	@Override
+	public void cancel() {
+		job.cancel();
+	}
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/Schedulable.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/Schedulable.java
new file mode 100644
index 0000000..4c08b80
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/Schedulable.java
@@ -0,0 +1,45 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.internal;
+
+/**
+ * Minimal API for schedulable tasks
+ *
+ * @author Camille Letavernier
+ *
+ */
+public interface Schedulable {
+	/**
+	 *
+	 * @return true if the task is complete
+	 */
+	public boolean isComplete();
+
+	/**
+	 *
+	 * @return the label of the tasks
+	 */
+	public String getName();
+
+	/**
+	 * Starts the task. The implementation should start in a separate thread (e.g. via a Job)
+	 */
+	public void start();
+
+	/**
+	 * Requests the task to cancel. The task may not be canceled immediately; invoker should wait
+	 * for isComplete() to return true after invoking this method
+	 */
+	public void cancel();
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/Scheduler.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/Scheduler.java
new file mode 100644
index 0000000..3367d92
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/Scheduler.java
@@ -0,0 +1,128 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.internal;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.papyrus.interoperability.common.Activator;
+
+
+/**
+ * Executes a number of parallel tasks on the specified (maximum) amount of threads
+ *
+ * @author Camille Letavernier
+ *
+ */
+public class Scheduler {
+
+	protected int maxThreads;
+
+	public Scheduler(int maxThreads) {
+		this.maxThreads = Math.max(1, maxThreads);
+	}
+
+	public void schedule(IProgressMonitor monitor, List<? extends Schedulable> tasks) {
+
+		List<Schedulable> remainingTasks = new LinkedList<Schedulable>(tasks);
+		List<Schedulable> runningTasks = new LinkedList<Schedulable>();
+
+		while (!remainingTasks.isEmpty()) {
+			if (monitor.isCanceled()) {
+				monitor.subTask("Canceling remaining jobs...");
+				for (Schedulable task : runningTasks) {
+					task.cancel();
+				}
+				remainingTasks.clear(); // Don't start these transformations at all
+				// Keep waiting: the cancel operation is asynchronous, we still need to wait for the jobs to complete
+			}
+
+			// Schedule transformations if we have enough threads and they have not all been scheduled
+			while (runningTasks.size() < maxThreads && !remainingTasks.isEmpty()) {
+				final Schedulable task = remainingTasks.remove(0); // Get and remove
+				task.start();
+				runningTasks.add(task);
+			}
+
+			if (!runningTasks.isEmpty()) {
+				String waitFor = runningTasks.get(0).getName();
+				monitor.subTask("Waiting for Import " + waitFor + " to complete...");
+			}
+
+			// We can continue if at least one transformation is complete (Leaving a free Thread)
+			boolean canContinue = false;
+
+			Iterator<Schedulable> iterator = runningTasks.iterator();
+			while (iterator.hasNext()) {
+				Schedulable runningTask = iterator.next();
+				if (runningTask.isComplete()) {
+					canContinue = true;
+					iterator.remove();
+					monitor.worked(1);
+				}
+			}
+
+			if (!canContinue) {
+				try {
+					Thread.sleep(100);
+				} catch (InterruptedException ex) {
+					Activator.log.error(ex);
+				}
+			}
+		}
+
+		// All transformations have been scheduled (But not necessarily completed): wait for all of them to complete
+		wait(runningTasks, monitor);
+	}
+
+
+	// Wait for all (remaining) import transformations to complete
+	protected void wait(List<Schedulable> tasks, IProgressMonitor monitor) {
+
+		// Transformations still running
+		List<Schedulable> runningTasks = new LinkedList<Schedulable>(tasks);
+
+		while (!runningTasks.isEmpty()) {
+			if (monitor.isCanceled()) {
+				monitor.subTask("Canceling remaining jobs...");
+				for (Schedulable task : runningTasks) {
+					task.cancel();
+				}
+				// Keep waiting: the cancel operation is asynchronous, we still need to wait for the jobs to complete
+			}
+
+			Iterator<Schedulable> iterator = runningTasks.iterator();
+			while (iterator.hasNext()) {
+				Schedulable task = iterator.next();
+				if (task.isComplete()) {
+					iterator.remove();
+					monitor.worked(1);
+				}
+			}
+
+			if (!runningTasks.isEmpty()) {
+				String waitFor = runningTasks.get(0).getName();
+				monitor.subTask("Waiting for " + waitFor + " to complete...");
+
+				try {
+					Thread.sleep(100);
+				} catch (InterruptedException ex) {
+					Activator.log.error(ex);
+					return;
+				}
+			}
+		}
+	}
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/TransformationWrapper.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/TransformationWrapper.java
new file mode 100644
index 0000000..4e536ef
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/TransformationWrapper.java
@@ -0,0 +1,45 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.internal;
+
+import org.eclipse.papyrus.interoperability.common.transformation.IImportTransformation;
+
+public class TransformationWrapper implements Schedulable {
+
+	protected IImportTransformation transformation;
+
+	public TransformationWrapper(IImportTransformation transformation) {
+		this.transformation = transformation;
+	}
+
+	@Override
+	public boolean isComplete() {
+		return transformation.isComplete();
+	}
+
+	@Override
+	public String getName() {
+		return transformation.getModelName();
+	}
+
+	@Override
+	public void start() {
+		transformation.run(false);
+	}
+
+	@Override
+	public void cancel() {
+		transformation.cancel();
+	}
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/extension/TransformationExtension.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/extension/TransformationExtension.java
new file mode 100644
index 0000000..04d1a22
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/extension/TransformationExtension.java
@@ -0,0 +1,91 @@
+/*****************************************************************************
+ * Copyright (c) 2015 CEA LIST and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.internal.extension;
+
+import java.util.Set;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.m2m.qvt.oml.ExecutionContext;
+import org.eclipse.papyrus.interoperability.common.concurrent.ExecutorsPool;
+import org.eclipse.papyrus.interoperability.common.transformation.IImportTransformation;
+
+
+/**
+ * Extension to the RSA-to-Papyrus model transformation
+ *
+ * Provisional API
+ *
+ * @author Camille Letavernier
+ *
+ */
+public interface TransformationExtension {
+	/**
+	 * Invoked only once when the extension is loaded for the first time (Before any execution)
+	 *
+	 * @return
+	 * 		The source EPackages required by this transformation (Typically source profile definitions)
+	 */
+	public Set<EPackage> getAdditionalSourceEPackages();
+
+	/**
+	 * The resource set used by the main transformation. Contains the source and target resources
+	 *
+	 * @param resourceSet
+	 */
+	public void setResourceSet(ResourceSet resourceSet);
+
+	/**
+	 * The ExecutorsPool used for manipulating parallel QVTo transformations
+	 *
+	 * @param executorsPool
+	 */
+	public void setExecutorsPool(ExecutorsPool executorsPool);
+
+	/**
+	 *
+	 * @param importTransformation
+	 */
+	public void setTransformation(IImportTransformation importTransformation);
+
+	/**
+	 * Part of the transformation that is executed before the main transformation's semantics and graphics import
+	 *
+	 * @param context
+	 *            The QVTo execution context
+	 * @param monitor
+	 *            The current progress monitor. The monitor is reused from the main transformation; only use subtask/worked methods
+	 * @return
+	 */
+	public IStatus executeBefore(ExecutionContext context, IProgressMonitor monitor);
+
+	/**
+	 * Part of the transformation that is executed after both the semantics and graphics have been imported
+	 *
+	 * @param context
+	 *            The QVTo execution context
+	 * @param monitor
+	 *            The current progress monitor. The monitor is reused from the main transformation; only use subtask/worked methods
+	 * @return
+	 */
+	public IStatus executeAfter(ExecutionContext context, IProgressMonitor monitor);
+
+	/**
+	 * The number of work steps required by this transformation. Corresponds to the total number of worked() you can invoke in executeBefore/executeAfter
+	 *
+	 * @return
+	 */
+	public int getNumberOfSteps();
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/utils/CreateFile.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/utils/CreateFile.java
new file mode 100644
index 0000000..87b562c
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/utils/CreateFile.java
@@ -0,0 +1,176 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Quentin Le Menez (CEA LIST) quentin.lemenez@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+
+package org.eclipse.papyrus.interoperability.common.internal.utils;
+
+import java.io.BufferedReader;
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.URL;
+import java.security.CodeSource;
+import java.security.ProtectionDomain;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import org.eclipse.core.resources.IContainer;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.NullProgressMonitor;
+
+//TODO : must be moved into org.eclipse.papyrus.eclipse.project.editors refactored
+public class CreateFile {
+
+	public static IFile createFile(String filePath, IContainer container, String content)
+			throws Exception
+	{
+		IFile file = null;
+		if ((container instanceof IProject)) {
+			file = ((IProject) container).getFile(filePath);
+		} else if ((container instanceof IFolder)) {
+			file = ((IFolder) container).getFile(filePath);
+		} else {
+			throw new Exception("Cannot find the file " +
+					filePath +
+					" under " +
+					container.getName());
+		}
+		IContainer parent = file.getParent();
+		if ((parent instanceof IFolder)) {
+			mkdirs((IFolder) parent);
+		}
+		InputStream stream = new ByteArrayInputStream(content.getBytes(file.getCharset()));
+		if (file.exists()) {
+			file.setContents(stream, true, true, null);
+		} else {
+			file.create(stream, true, null);
+		}
+		stream.close();
+
+		return file;
+	}
+
+	public static void mkdirs(IFolder folder)
+			throws CoreException
+	{
+		if (!folder.exists())
+		{
+			if ((folder.getParent() instanceof IFolder)) {
+				mkdirs((IFolder) folder.getParent());
+			}
+			folder.create(true, true, null);
+		}
+	}
+
+	public static String getContents(String relativePath, String resource, Class clazz)
+			throws IOException
+	{
+		String resourcePath = relativePath + '/' + resource;
+		File sourcePrj = getSourceProject(clazz);
+
+
+		JarFile jar = null;
+		InputStream resourceStream;
+		if (sourcePrj.isFile())
+		{
+			jar = new JarFile(sourcePrj);
+			JarEntry resEntry = jar.getJarEntry(resourcePath);
+			resourceStream = jar.getInputStream(resEntry);
+		}
+		else
+		{
+			resourceStream = new FileInputStream(sourcePrj.getAbsolutePath() +
+					"/" +
+					resourcePath);
+		}
+		byte[] buffer = new byte[4096];
+		ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+		for (;;)
+		{
+			int read = resourceStream.read(buffer);
+			if (read == -1) {
+				break;
+			}
+			outputStream.write(buffer, 0, read);
+		}
+		outputStream.close();
+		resourceStream.close();
+		if (jar != null) {
+			jar.close();
+		}
+		return outputStream.toString("iso-8859-1");
+	}
+
+	private static File getSourceProject(Class clazz)
+	{
+		ProtectionDomain protectionDomain = clazz.getProtectionDomain();
+		CodeSource codeSource = protectionDomain.getCodeSource();
+		URL location = codeSource.getLocation();
+		File sourcePrj = new File(location.getFile());
+		return sourcePrj;
+	}
+
+	public static void appendContents(IFile pagesFile, String data)
+			throws IOException
+	{
+		File file = pagesFile.getLocation().toFile();
+		if (!file.exists()) {
+			file.createNewFile();
+		}
+		FileWriter fileWriter = new FileWriter(file, true);
+		BufferedWriter buffWriter = new BufferedWriter(fileWriter);
+		PrintWriter writer = new PrintWriter(buffWriter);
+		writer.println(data);
+		writer.close();
+		buffWriter.close();
+		fileWriter.close();
+	}
+
+	public static void replaceContents(IFile file, String template, String newContent)
+			throws CoreException, IOException
+	{
+		String content = getContents(file).replace(template, newContent);
+		InputStream stream = new ByteArrayInputStream(content.getBytes(file.getCharset()));
+		if (file.exists()) {
+			file.setContents(stream, true, true, new NullProgressMonitor());
+		}
+		stream.close();
+	}
+
+	public static String getContents(IFile iFile)
+			throws IOException
+	{
+		File file = iFile.getLocation().toFile();
+		FileInputStream stream = new FileInputStream(file);
+		StringBuffer contents = new StringBuffer();
+		BufferedReader br = new BufferedReader(new InputStreamReader(stream));
+		String line;
+		while ((line = br.readLine()) != null)
+		{
+			contents.append(line).append("\n");
+		}
+		br.close();
+		stream.close();
+		return contents.toString();
+	}
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/utils/CreateProject.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/utils/CreateProject.java
new file mode 100644
index 0000000..402b486
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/internal/utils/CreateProject.java
@@ -0,0 +1,146 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Quentin Le Menez (CEA LIST) quentin.lemenez@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.internal.utils;
+
+import java.io.File;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IWorkspace;
+import org.eclipse.core.resources.IWorkspaceRoot;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.jface.dialogs.IInputValidator;
+import org.eclipse.jface.dialogs.InputDialog;
+import org.eclipse.jface.window.Window;
+import org.eclipse.papyrus.interoperability.common.Activator;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.ui.PlatformUI;
+
+
+//TODO : must be moved into org.eclipse.papyrus.eclipse.project.editors and probably refactored
+public class CreateProject {
+
+	protected String projectName;
+
+	protected IProject createdProject;
+
+	protected Collection<Object> inputFiles;
+
+	public CreateProject(Collection<Object> inputFiles) {
+		this.projectName = getProjectName();
+		this.inputFiles = inputFiles;
+
+		if (projectName != null) {
+			try {
+				this.createdProject = createProject();
+			} catch (Exception e) {
+				Activator.log.error(e);
+			}
+		}
+	}
+
+
+	protected IProject createProject() throws Exception {
+		IWorkspace workspace = ResourcesPlugin.getWorkspace();
+		IProject project = workspace.getRoot().getProject(projectName);
+
+		if (! project.exists()){
+			project.create(new NullProgressMonitor());
+		}
+
+		if (! project.isOpen()){
+			project.open(new NullProgressMonitor());
+		}
+
+		if (inputFiles != null && !inputFiles.isEmpty()) {
+			// create resource folder
+			createFolder("resources", project, inputFiles);
+		}
+
+		return project;
+	}
+
+	protected void createFolder(String folderName, IProject project, Collection<Object> inputFiles) throws Exception {
+		IFolder folder = project.getFolder(folderName);
+		folder.create(false, true, null);
+
+		List<Object> inputList = new ArrayList<Object>(inputFiles);
+		for (Object object : inputList) {
+			File file = ((File) object);
+			IFile linkedFile = folder.getFile(file.getName());
+			URI fileURI = file.toURI();
+			linkedFile.createLink(fileURI, IResource.NONE, null);
+		}
+
+	}
+
+	protected void createBuildProps(IProject project, List<String> srcFolders) throws Exception {
+		StringBuilder bpContent = new StringBuilder("source.. = ");
+
+		if (srcFolders != null && !srcFolders.isEmpty()) {
+			for (Iterator<String> iterator = srcFolders.iterator(); iterator.hasNext();)
+			{
+				bpContent.append(iterator.next()).append(File.separatorChar);
+				if (iterator.hasNext()) {
+					bpContent.append(",");
+				}
+			}
+		}
+
+		bpContent.append("\n");
+		bpContent.append("bin.includes = META-INF/,.\n");
+		CreateFile.createFile("build.properties", project, bpContent.toString());
+	}
+
+
+	public IProject getCreatedProject() {
+		return this.createdProject;
+	}
+
+	protected String getProjectName() {
+		String init_value = "project_" + System.currentTimeMillis();
+
+		Shell activeShell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
+
+		InputDialog dialog = new InputDialog(activeShell, "Create Project", "Provide project name...", init_value, new IInputValidator() {
+			@Override
+			public String isValid(String newText)
+			{
+				IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
+				IProject[] projs = root.getProjects();
+				for (int i = 0; i < projs.length; i++) {
+					if (projs[i].getName().equalsIgnoreCase(newText)) {
+						return "This project already exists";
+					}
+				}
+
+				return null;
+			}
+		});
+
+		if (dialog.open() == Window.CANCEL) {
+			return null;
+		}
+
+		return dialog.getValue();
+	}
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/AbstractDependencyAnalysisHelper.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/AbstractDependencyAnalysisHelper.java
new file mode 100644
index 0000000..59f012d
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/AbstractDependencyAnalysisHelper.java
@@ -0,0 +1,345 @@
+/*****************************************************************************
+ * Copyright (c) 2015 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST)  - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.transformation;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+
+import org.eclipse.emf.common.util.TreeIterator;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.xmi.XMLResource;
+import org.eclipse.papyrus.infra.emf.utils.EMFHelper;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.AdvancedConfig;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersFactory;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping;
+
+
+
+public abstract class AbstractDependencyAnalysisHelper implements IDependencyAnalysisHelper {
+
+	protected final ThreadConfig config;
+
+	protected final Set<String> softwareExtensions;
+
+	protected final String softwareProfileExtension;
+
+	// ResourceSet used to load and explore Static Libraries
+	// protected final ResourceSet localResourceSet = new ThreadSafeResourceSet();
+	protected final ResourceSet localResourceSet = new ResourceSetImpl();
+
+	// Store the broken URIs without trying to resolve them. We don't have enough information to resolve them during the first phase of the model import
+	// The Key is the resource URI, the value is the Set of each individual EObject Fragment (We need the EObject fragments to find potential matches)
+	protected final Map<URI, Set<String>> brokenUris = new HashMap<URI, Set<String>>();
+
+	protected final Set<URI> brokenProfiles = new HashSet<URI>();
+
+	public AbstractDependencyAnalysisHelper(ThreadConfig config, Set<String> softwareExtensions, String softwareProfileExtension) {
+		this.config = config;
+		this.softwareExtensions = softwareExtensions;
+		this.softwareProfileExtension = softwareProfileExtension;
+
+		configureResourceSet();
+	}
+
+	protected void configureResourceSet() {
+		localResourceSet.getLoadOptions().put(XMLResource.OPTION_DEFER_ATTACHMENT, true);
+		localResourceSet.getLoadOptions().put(XMLResource.OPTION_DEFER_IDREF_RESOLUTION, true);
+		localResourceSet.getLoadOptions().put(XMLResource.OPTION_RECORD_UNKNOWN_FEATURE, Boolean.TRUE);
+		localResourceSet.getLoadOptions().put(XMLResource.OPTION_USE_PACKAGE_NS_URI_AS_LOCATION, Boolean.FALSE);
+	}
+
+	protected void unloadResourceSet() {
+		EMFHelper.unload(localResourceSet);
+	}
+
+	public void computeURIMappings(Collection<Resource> sourceModels) {
+		for (Resource sourceModel : sourceModels) {
+			doComputeURIMappings(sourceModel);
+		}
+	}
+
+	public synchronized void resolveAllMappings(Map<URI, URI> urisToReplace, Map<URI, URI> profileUrisToReplace) {
+		if (config instanceof AdvancedConfig) {
+			if (((AdvancedConfig) config).getMappingParameters() == null) {
+				((AdvancedConfig) config).setMappingParameters(MigrationParametersFactory.eINSTANCE.createMappingParameters());
+			}
+
+			try {
+				for (Entry<URI, Set<String>> resourceToRepair : brokenUris.entrySet()) {
+
+					// Already known mapping
+					if (urisToReplace.containsKey(resourceToRepair.getKey())) {
+						continue;
+					}
+					findMatch(resourceToRepair.getKey(), resourceToRepair.getValue());
+				}
+
+				for (URI profileDefinition : brokenProfiles) {
+
+					// Already known mapping
+					if (profileUrisToReplace.containsKey(profileDefinition.trimFragment().trimQuery())) {
+						continue;
+					}
+					findMatch(profileDefinition);
+				}
+			} finally {
+				unloadResourceSet();
+				brokenUris.clear();
+				brokenProfiles.clear();
+			}
+		}
+	}
+
+	protected void findMatch(URI resourceURI, Set<String> fragments) {
+		if (config instanceof AdvancedConfig) {
+			URIMapping mapping = null;
+
+			for (String fragment : fragments) {
+				URI eObjectURI = resourceURI.appendFragment(fragment);
+				mapping = findExistingMapping(eObjectURI, localResourceSet);
+
+				if (mapping != null) {
+					break;
+				}
+			}
+
+			if (mapping == null) {
+				mapping = MigrationParametersFactory.eINSTANCE.createURIMapping();
+				mapping.setSourceURI(resourceURI.toString());
+				mapping.setTargetURI(mapping.getSourceURI());
+			}
+
+			((AdvancedConfig) config).getMappingParameters().getUriMappings().add(mapping);
+		}
+	}
+
+	protected void findMatch(URI profileDefinitionURI) {
+		if (this.config instanceof AdvancedConfig) {
+			URIMapping match = findExistingProfileMapping(profileDefinitionURI, localResourceSet);
+
+			if (match == null) {
+				match = MigrationParametersFactory.eINSTANCE.createURIMapping();
+				match.setSourceURI(profileDefinitionURI.trimFragment().trimQuery().toString());
+				match.setTargetURI(match.getSourceURI());
+			}
+
+			((AdvancedConfig) config).getMappingParameters().getProfileUriMappings().add(match);
+		}
+	}
+
+	protected void doComputeURIMappings(Resource sourceModel) {
+		doComputeProfileURIMappings(sourceModel);
+
+		TreeIterator<EObject> resourceContents = sourceModel.getAllContents();
+		ResourceSet resourceSet = sourceModel.getResourceSet();
+
+		while (resourceContents.hasNext()) {
+			EObject next = resourceContents.next();
+			for (EReference reference : next.eClass().getEAllReferences()) {
+				if (reference.isContainer() || reference.isContainment() || reference.isDerived() || reference.isTransient()) {
+					continue;
+				}
+
+				Object value = next.eGet(reference, false);
+				if (value instanceof EObject) {
+					handleURIMapping((EObject) value, resourceSet);
+				} else if (value instanceof Collection<?>) {
+					for (Object element : (Collection<?>) value) {
+						if (element instanceof EObject) {
+							handleURIMapping((EObject) element, resourceSet);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	protected void doComputeProfileURIMappings(Resource sourceModel) {
+		ResourceSet resourceSet = sourceModel.getResourceSet();
+
+		for (EObject rootObject : sourceModel.getContents()) {
+			if (isInvalidStereotypeApplication(rootObject)) {
+				handleProfileURIMapping(rootObject, resourceSet);
+			}
+		}
+	}
+
+	protected abstract boolean isInvalidStereotypeApplication(EObject eObject);
+
+	protected boolean isSoftwareModelElement(EObject eObject) {
+		return isSoftwareModelElement(EcoreUtil.getURI(eObject));
+	}
+
+	protected boolean isSoftwareModelElement(URI objectURI) {
+		String fileExtension = objectURI.fileExtension();
+		return softwareExtensions.contains(fileExtension) || softwareProfileExtension.equals(fileExtension);
+	}
+
+
+	protected synchronized Set<String> getFragments(URI resourceURI) {
+		if (!brokenUris.containsKey(resourceURI)) {
+			brokenUris.put(resourceURI, new HashSet<String>());
+		}
+
+		return brokenUris.get(resourceURI);
+	}
+
+	protected synchronized void handleBrokenReference(EObject proxy) {
+		URI proxyURI = EcoreUtil.getURI(proxy);
+		URI resourceURI = proxyURI.trimFragment().trimQuery();
+
+		String fragment = proxyURI.fragment();
+		Set<String> fragments = getFragments(resourceURI);
+		fragments.add(fragment);
+	}
+
+	protected synchronized void addBrokenProfileDefinition(URI packageURI) {
+		brokenProfiles.add(packageURI);
+	}
+
+
+	protected void handleProfileURIMapping(EObject stereotypeApplication, ResourceSet resourceSet) {
+
+		EPackage profileDefinition = stereotypeApplication.eClass().getEPackage();
+		URI packageURI = EcoreUtil.getURI(profileDefinition);
+		if (packageURI.trimFragment().isEmpty()) {
+			packageURI = URI.createURI(profileDefinition.getNsURI());
+		}
+		addBrokenProfileDefinition(packageURI);
+
+	}
+
+	protected void handleURIMapping(EObject eObject, ResourceSet resourceSet) {
+
+		if (isSoftwareModelElement(eObject)) {
+			handleBrokenReference(eObject);
+			return;
+		}
+
+		if (eObject.eIsProxy()) {
+			eObject = EcoreUtil.resolve(eObject, resourceSet);
+			if (eObject.eIsProxy()) {
+				handleBrokenReference(eObject);
+				return;
+			}
+		}
+
+	}
+
+	protected URIMapping findExistingProfileMapping(URI profileDefinitionURI, ResourceSet resourceSet) {
+		throw new UnsupportedOperationException(); // TODO I don't know how to implements it for Rpy Import
+	}
+
+	protected boolean isPathFragment(URI proxyURI) {
+		String uriFragment = proxyURI.fragment();
+
+		return uriFragment != null && uriFragment.charAt(0) == '/';
+	}
+
+	protected URIMapping findExistingMapping(URI proxyURI, ResourceSet resourceSet) {
+		throw new UnsupportedOperationException();// TODO required for RSA, but I don't know yet how to implements if for Rpy Import
+	}
+
+	/** Propagates the URI Mappings to all duplicates */
+	public void propagateURIMappings(List<URIMapping> allMappings, MappingParameters result) {
+		for (URIMapping mapping : allMappings) {
+			for (URIMapping uriMapping : result.getUriMappings()) {
+				if (uriMapping.getSourceURI().equals(mapping.getSourceURI())) {
+					uriMapping.setTargetURI(mapping.getTargetURI());
+				}
+			}
+
+			for (URIMapping profileURIMapping : result.getProfileUriMappings()) {
+				if (profileURIMapping.getSourceURI().equals(mapping.getSourceURI())) {
+					profileURIMapping.setTargetURI(mapping.getTargetURI());
+				}
+			}
+		}
+	}
+
+	public List<URIMapping> flattenURIMappings(MappingParameters result) {
+		List<URIMapping> allMappings = new LinkedList<URIMapping>();
+		allMappings.addAll(result.getUriMappings());
+		allMappings.addAll(result.getProfileUriMappings());
+
+		removeDuplicates(allMappings);
+
+		return allMappings;
+	}
+
+	/**
+	 * Remove duplicate mappings. Mappings are duplicate if they have the same SourceURI.
+	 * Less specific mappings will be discarded (Usually, the ones with the same Source and Target URI)
+	 */
+	protected void removeDuplicates(List<URIMapping> allMappings) {
+		List<URIMapping> mappingsCopy = new LinkedList<URIMapping>(allMappings);
+
+		for (URIMapping mapping : mappingsCopy) {
+			for (URIMapping m : allMappings) {
+				if (m == mapping) {
+					continue;
+				}
+
+				// This is a duplicate
+				if (mapping.getSourceURI().equals(m.getSourceURI())) {
+					// If both mappings are still present, remove one of them
+					if (allMappings.contains(mapping) && allMappings.contains(m)) {
+						URIMapping mappingToRemove = findLessSpecificMapping(mapping, m);
+
+						allMappings.remove(mappingToRemove);
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * If 2 mappings have the same sourceURI but different targetURI, returns the less pertinent one
+	 * (Usually, the one with the same Source and Target)
+	 *
+	 * @param mapping1
+	 * @param mapping2
+	 * @return
+	 */
+	protected URIMapping findLessSpecificMapping(URIMapping mapping1, URIMapping mapping2) {
+		if (!isUsefulMapping(mapping1)) {
+			return mapping1;
+		}
+
+		return mapping2;
+	}
+
+	protected boolean isUsefulMapping(URIMapping mapping) {
+		if (mapping.getTargetURI() == null || "".equals(mapping.getTargetURI()) || mapping.getTargetURI().equals(mapping.getSourceURI())) {
+			return false;
+		}
+
+		return true;
+	}
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/AbstractImportTransformation.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/AbstractImportTransformation.java
new file mode 100644
index 0000000..332b6a4
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/AbstractImportTransformation.java
@@ -0,0 +1,821 @@
+/*****************************************************************************
+ * Copyright (c) 2013, 2016 CEA LIST, Christian W. Damus, and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *  Christian W. Damus - bugs 496439, 496299
+ *  Vincent Lorenzo - bug 496176
+ *****************************************************************************/
+
+package org.eclipse.papyrus.interoperability.common.transformation;
+
+import java.io.OutputStreamWriter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.core.runtime.Assert;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.MultiStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.jobs.IJobChangeEvent;
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.core.runtime.jobs.JobChangeAdapter;
+import org.eclipse.emf.common.util.Diagnostic;
+import org.eclipse.emf.common.util.DiagnosticException;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EAnnotation;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.util.ExtendedMetaData;
+import org.eclipse.emf.ecore.xmi.XMIResource;
+import org.eclipse.emf.ecore.xmi.XMLResource;
+import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl;
+import org.eclipse.gmf.runtime.emf.core.resources.GMFResource;
+import org.eclipse.gmf.runtime.notation.Diagram;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.m2m.qvt.oml.BasicModelExtent;
+import org.eclipse.m2m.qvt.oml.ExecutionContext;
+import org.eclipse.m2m.qvt.oml.ExecutionContextImpl;
+import org.eclipse.m2m.qvt.oml.ExecutionDiagnostic;
+import org.eclipse.m2m.qvt.oml.ModelExtent;
+import org.eclipse.m2m.qvt.oml.TransformationExecutor;
+import org.eclipse.m2m.qvt.oml.util.ISessionData;
+import org.eclipse.m2m.qvt.oml.util.Trace;
+import org.eclipse.m2m.qvt.oml.util.WriterLog;
+import org.eclipse.papyrus.infra.emf.resource.ShardResourceHelper;
+import org.eclipse.papyrus.infra.emf.utils.EMFHelper;
+import org.eclipse.papyrus.interoperability.common.Activator;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersFactory;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig;
+import org.eclipse.papyrus.interoperability.common.concurrent.ExecutorsPool;
+import org.eclipse.papyrus.interoperability.common.internal.extension.TransformationExtension;
+import org.eclipse.papyrus.m2m.qvto.TraceHelper;
+import org.eclipse.papyrus.m2m.qvto.TransformationUI;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.statushandlers.StatusManager;
+import org.eclipse.uml2.common.util.CacheAdapter;
+import org.eclipse.uml2.uml.Element;
+import org.eclipse.uml2.uml.Extension;
+import org.eclipse.uml2.uml.resource.UMLResource;
+import org.eclipse.uml2.uml.util.UMLUtil;
+
+/**
+ * Executes a single import-to-Papyrus transformation
+ *
+ * @author Vincent Lorenzo
+ *
+ */
+public abstract class AbstractImportTransformation implements IImportTransformation {
+	/** For debug purpose */
+	protected static boolean DEBUG = true;
+
+	// SourceURI is the input
+	protected final URI sourceURI;
+
+	// targetURI is computed during the transformation
+	protected URI targetURI;
+
+	protected ModelExtent outUML, outNotation, outSashModel, inParameters, inPapyrusProfiles, sysML11Profile;
+
+	protected MigrationResourceSet resourceSet;
+
+	protected Job job;
+
+	protected Resource umlResource;
+
+	protected ThreadConfig parameters;
+
+	protected boolean complete = false;
+
+	// For logging purpose (Bug 455001)
+	// Starts when the job starts; ends when the job returns
+	/** Execution time, in nano-seconds */
+	protected long executionTime = 0L;
+
+	/** Execution time of the initial model loading / ns */
+	protected long loadingTime = 0L;
+
+	/** Execution time for handling dangling references / ns */
+	protected long danglingRefTime = 0L;
+
+	/** Execution time for executing the UML-RT transformation / ns */
+	protected long importExtensionsTime = 0L;
+
+	/** Source URI to Target URI map (For Models/Libraries/Fragments) */
+	protected final Map<URI, URI> uriMappings = new HashMap<>();
+
+	/** Source URI to Target URI map (For Profiles) */
+	protected final Map<URI, URI> profileURIMappings = new HashMap<>();
+
+	protected List<Diagram> diagramsToDelete = new LinkedList<>();
+
+	protected static final ExecutorsPool executorsPool = new ExecutorsPool(2);
+
+	// TODO : check if sourceEPackages is required for Rpy and common tranfo
+	/** EPackages corresponding to source native profiles with specific support in the transformation */
+	protected static final Set<EPackage> sourceEPackages = new HashSet<>();
+
+	protected final IDependencyAnalysisHelper analysisHelper;
+
+
+	/** Extensions contributed via other plug-ins */
+	protected final List<TransformationExtension> extensions;
+
+	/** Accumulation of incremental update traces from each transformation. */
+	private Trace trace = Trace.createEmptyTrace();
+
+	/** Transformation execution context used for all transformation runs. */
+	protected ExecutionContext context;
+
+	public AbstractImportTransformation(URI sourceURI) {
+		this(sourceURI, MigrationParametersFactory.eINSTANCE.createThreadConfig(), null);
+	}
+
+	public AbstractImportTransformation(URI sourceURI, ThreadConfig config, IDependencyAnalysisHelper analysisHelper) {
+		Assert.isNotNull(sourceURI);
+		this.sourceURI = sourceURI;
+		this.parameters = config;
+		this.analysisHelper = analysisHelper;
+		this.extensions = getAllExtensions();
+	}
+
+	/**
+	 * Instantiate all the extensions for a specific transformation
+	 *
+	 * @return
+	 * 		A non-null (potentially empty) list of extensions
+	 */
+	protected static List<TransformationExtension> getAllExtensions() {
+		// TODO probably RSA only or the extension point must be rewritten
+		return Collections.emptyList();
+	}
+
+
+
+
+
+	/**
+	 * Executes the transformation
+	 *
+	 * The transformation will be executed asynchronously in a Job
+	 */
+	public void run(final boolean isUserJob) {
+
+		job = new Job("Import " + getModelName()) {
+
+			@Override
+			protected IStatus run(IProgressMonitor monitor) {
+				long begin = System.nanoTime();
+				IStatus result = AbstractImportTransformation.this.run(monitor);
+				long end = System.nanoTime();
+				executionTime = end - begin;
+				return result;
+			}
+		};
+
+		job.setUser(isUserJob);
+
+		job.addJobChangeListener(new JobChangeAdapter() {
+
+			@Override
+			public void done(IJobChangeEvent event) {
+				complete = true;
+				if (isUserJob) {
+					if (event.getResult().getSeverity() == IStatus.OK) {
+						Display.getDefault().asyncExec(new Runnable() {
+
+							@Override
+							public void run() {
+								MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), job.getName(), String.format("Model %s has been successfully imported", getModelName()));
+							}
+						});
+
+					} else if (event.getResult().getSeverity() == IStatus.CANCEL) {
+						Display.getDefault().asyncExec(new Runnable() {
+
+							@Override
+							public void run() {
+								MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), job.getName(), String.format("Operation canceled: %s", getModelName()));
+							}
+						});
+					} else {
+						StatusManager.getManager().handle(event.getResult(), StatusManager.BLOCK);
+					}
+				}
+			}
+
+		});
+
+		job.schedule();
+	}
+
+	public void waitForCompletion() {
+		try {
+			job.join();
+		} catch (InterruptedException ex) {
+			Activator.log.error(ex);
+		}
+	}
+
+	public boolean isComplete() {
+		return complete;
+	}
+
+	public IStatus getStatus() {
+		if (job == null) { // If job hasn't been created, the operation has probably been canceled before the transformation is ran
+			return new Status(IStatus.CANCEL, Activator.PLUGIN_ID, "Operation canceled");
+		}
+		return job.getResult();
+	}
+
+	public long getExecutionTime() {
+		return executionTime;
+	}
+
+	public long getLoadingTime() {
+		return loadingTime;
+	}
+
+	public long getHandleDanglingRefTime() {
+		return danglingRefTime;
+	}
+
+	public long getImportExtensionsTime() {
+		// TODO maybe only for RSa!
+		return importExtensionsTime;
+	}
+
+	public URI getTargetURI() {
+		return targetURI;
+	}
+
+
+	/**
+	 * Initializes the resource set, and resolve all dependencies
+	 */
+	protected void initResourceSet(IProgressMonitor monitor) {
+		resourceSet = new MigrationResourceSetImpl();
+		synchronized (UMLUtil.class) {
+			UMLUtil.init(resourceSet);
+		}
+		resourceSet.getLoadOptions().put(XMLResource.OPTION_DEFER_ATTACHMENT, true);
+		resourceSet.getLoadOptions().put(XMLResource.OPTION_DEFER_IDREF_RESOLUTION, true);
+		resourceSet.getLoadOptions().put(XMLResource.OPTION_RECORD_UNKNOWN_FEATURE, Boolean.TRUE);
+		resourceSet.getLoadOptions().put(XMLResource.OPTION_USE_PACKAGE_NS_URI_AS_LOCATION, Boolean.FALSE);
+
+		monitor.subTask("Loading source model " + getModelName());
+
+		try {
+			resourceSet.getResource(sourceURI, true);
+			loadInPapyrusProfiles();
+		} catch (Exception ex) {
+			Activator.log.error("An error occurred while loading " + getModelName(), ex);
+		}
+	}
+
+	protected abstract int countSupportedElements(); // TODO
+
+
+	protected IStatus loadTransformations(IProgressMonitor monitor) {
+		for (URI transformationURI : getAllTransformationURIs()) {
+			executorsPool.preLoad(transformationURI);
+			monitor.worked(1);
+		}
+
+		return Status.OK_STATUS;
+	}
+
+	// MemoryLeak: Don't rely on BasicDiagnostic.toIStatus
+	// The source Diagnostic contains references to the QVTo ModelExtents, referencing the Model elements (used in #extractPapyrusProfiles())
+	// When using the standard conversion, these references are not discarded
+	protected static IStatus createStatusFromDiagnostic(Diagnostic diagnostic) {
+		return new Status(diagnostic.getSeverity(),
+				diagnostic.getSource(),
+				diagnostic.getMessage(),
+				diagnostic.getException());
+	}
+
+
+
+
+	/**
+	 * Actually runs the transformation (in the current thread)
+	 *
+	 * @param monitor
+	 * @return The transformation IStatus
+	 */
+	// TODO maybe more common stuff with RSA import here
+	// TODO : maybe in the interface if we keep it!
+	protected abstract IStatus run(final IProgressMonitor monitor);
+
+	/**
+	 * Functional interface to abstract {@link TransformationExtension#executeBefore(ExecutionContext, IProgressMonitor)}
+	 * and {@link TransformationExtension#executeAfter(ExecutionContext, IProgressMonitor)}
+	 *
+	 * @author Camille Letavernier
+	 *
+	 */
+	@FunctionalInterface
+	protected static interface ExtensionFunction {
+		public IStatus apply(TransformationExtension extension, ExecutionContext context, IProgressMonitor monitor);
+
+		/**
+		 * Implements ExtensionFunction
+		 *
+		 * Delegates to {@link TransformationExtension#executeBefore(ExecutionContext, IProgressMonitor)}
+		 */
+		public static IStatus executeBefore(TransformationExtension extension, ExecutionContext context, IProgressMonitor monitor) {
+			return extension.executeBefore(context, monitor);
+		}
+
+		/**
+		 * Implements ExtensionFunction
+		 *
+		 * Delegates to {@link TransformationExtension#executeAfter(ExecutionContext, IProgressMonitor)}
+		 */
+		public static IStatus executeAfter(TransformationExtension extension, ExecutionContext context, IProgressMonitor monitor) {
+			return extension.executeAfter(context, monitor);
+		}
+	}
+
+	protected void prepareExtensions() {
+		for (TransformationExtension extension : extensions) {
+			extension.setResourceSet(resourceSet);
+			extension.setExecutorsPool(executorsPool);
+			extension.setTransformation(this);
+		}
+	}
+
+	protected IStatus importExtensions(ExecutionContext context, IProgressMonitor monitor, ExtensionFunction function) {
+		List<IStatus> allResults = new ArrayList<>(extensions.size());
+		for (TransformationExtension extension : extensions) {
+			IStatus result = function.apply(extension, context, monitor);
+			allResults.add(result);
+		}
+
+		if (allResults.isEmpty()) {
+			return Status.OK_STATUS;
+		} else if (allResults.size() == 1) {
+			return allResults.get(0);
+		} else {
+			return aggregateStatus(allResults);
+		}
+	}
+
+	// FIXME implement properly
+	public static MultiStatus aggregateStatus(List<IStatus> statuses) {
+		return new MultiStatus(Activator.PLUGIN_ID, IStatus.OK, statuses.toArray(new IStatus[statuses.size()]), "", null);
+	}
+
+	/**
+	 * @param resource
+	 */
+	protected void cleanMetadataAnnotations(Resource resource) {
+		// Bug 471684: UML2.x to UML2.5 creates (invalid) Ecore Metadata EAnnotations, which then cause OCL validation to fail
+		// Remove these EAnnotations from the model to avoid side effects
+		Iterator<EObject> rootElementsIterator = resource.getContents().iterator();
+		while (rootElementsIterator.hasNext()) {
+			EObject root = rootElementsIterator.next();
+			if (root instanceof EAnnotation) {
+				EAnnotation annotation = (EAnnotation) root;
+				if (ExtendedMetaData.ANNOTATION_URI.equals(annotation.getSource())) {
+					rootElementsIterator.remove();
+				}
+			}
+		}
+	}
+
+	protected void handleDanglingURIs(Collection<Resource> resourcesToSave) {
+		if (analysisHelper != null) {
+			resourceSet.freeze();
+			try {
+				analysisHelper.computeURIMappings(resourcesToSave);
+			} finally {
+				resourceSet.unfreeze();
+			}
+		}
+	}
+
+	protected void unloadResourceSet(ResourceSet resourceSet) {
+		EMFHelper.unload(resourceSet);
+	}
+	
+
+	protected TransformationExecutor getTransformation(URI transformationURI, IProgressMonitor monitor) throws DiagnosticException {
+		return executorsPool.getExecutor(transformationURI);
+	}
+
+	protected ModelExtent getInProfileDefinitions() {
+		//TODO : not used, useful for common and Rpy import 
+		return null;
+	}
+	
+	protected ModelExtent getInPapyrusProfiles() {
+		if (inPapyrusProfiles == null) {
+			loadInPapyrusProfiles();
+		}
+
+		return inPapyrusProfiles;
+	}
+	
+
+	protected abstract Diagnostic loadInPapyrusProfiles(); // TODO : add path of profile are parameters ?
+	
+	protected void checkResource(Resource resource) {
+		Assert.isNotNull(resource);
+		Assert.isTrue(!resource.getContents().isEmpty(), "The resource " + resource.getURI() + " is empty");
+		for (EObject rootElement : resource.getContents()) {
+			Assert.isTrue(!rootElement.eIsProxy());
+		}
+	}
+	
+	protected abstract Resource createUMLResource(ResourceSet resourceSet, URI sourceResourceURI, URI targetResourceURI);
+
+	protected ModelExtent getInConfig() {
+		if (inParameters == null) {
+			inParameters = new BasicModelExtent(Collections.singletonList(parameters));
+		}
+		return inParameters;
+	}
+	
+	protected Collection<Resource> handleFragments(Resource umlResource, Resource notationResource, Resource sashResource) {
+		Collection<Resource> result = new HashSet<>();
+		result.add(umlResource);
+		result.add(notationResource);
+		result.add(sashResource);
+
+		ResourceSet resourceSet = umlResource.getResourceSet();
+
+		Iterator<EObject> elementIterator = umlResource.getAllContents();
+
+		Set<Resource> fragmentResources = new HashSet<>();
+		List<EAnnotation> rsaAnnotations = new ArrayList<>();
+
+		while (elementIterator.hasNext()) {
+			EObject element = elementIterator.next();
+			Resource possibleFragment = element.eResource();
+			if ((possibleFragment != umlResource) && possibleFragment.getContents().contains(element)) { // Controlled/Fragment root
+				fragmentResources.add(possibleFragment);
+			}
+			// TODO commented because it is RSA import only
+			// collectRSAAnnotations(element, rsaAnnotations);
+		}
+
+		// Strip all RSA fragment annotations
+		rsaAnnotations.forEach(EcoreUtil::remove);
+
+		List<Resource> fragmentUMLResources = new LinkedList<>();
+
+		for (Resource fragmentResource : fragmentResources) {
+			URI papyrusFragmentURI = convertToPapyrus(fragmentResource.getURI(), UMLResource.FILE_EXTENSION);
+
+			uriMappings.put(fragmentResource.getURI(), papyrusFragmentURI);
+
+			Resource newResource = resourceSet.getResource(papyrusFragmentURI, false);
+			if (newResource == null) {
+				newResource = createUMLResource(resourceSet, fragmentResource.getURI(), papyrusFragmentURI);
+
+				fragmentUMLResources.add(newResource);
+
+				Resource fragmentNotationResource = new GMFResource(convertToPapyrus(papyrusFragmentURI, "notation"));
+				Resource fragmentDiResource = new XMIResourceImpl(convertToPapyrus(papyrusFragmentURI, "di"));
+
+				result.add(fragmentNotationResource);
+				result.add(fragmentDiResource);
+
+				resourceSet.getResources().add(fragmentNotationResource);
+				resourceSet.getResources().add(fragmentDiResource);
+			}
+
+			newResource.getContents().addAll(fragmentResource.getContents());
+
+			// Make it a Papyrus controlled unit of the "shard" variety
+			try (ShardResourceHelper shard = new ShardResourceHelper(newResource)) {
+				shard.setShard(true);
+			}
+
+			result.add(newResource);
+		}
+
+		deleteSourceStereotypes(fragmentResources);
+
+		List<EObject> importedElements = new LinkedList<>(notationResource.getContents());
+		for (EObject notationElement : importedElements) {
+			if (notationElement instanceof Diagram) {
+				EObject semanticElement = ((Diagram) notationElement).getElement();
+				if (semanticElement.eResource() != umlResource && semanticElement.eResource() != null) {
+
+					URI notationFragmentURI = convertToPapyrus(semanticElement.eResource().getURI(), "notation");
+
+					Resource newNotationResource = resourceSet.getResource(notationFragmentURI, false);
+					if (newNotationResource == null) {
+						newNotationResource = new GMFResource(notationFragmentURI);
+						resourceSet.getResources().add(newNotationResource);
+					}
+					newNotationResource.getContents().add(notationElement);
+					result.add(newNotationResource);
+				}
+			}
+		}
+
+		handleFragmentStereotypes(umlResource, fragmentUMLResources);
+
+		for (Resource resource : result) {
+			if (resource instanceof XMIResource) {
+				configureResource((XMIResource) resource);
+			}
+		}
+
+		return result;
+	}
+
+	/*
+	 * Bug 447097: [Model Import] Importing a fragmented model causes stereotype applications to be lost in resulting submodel
+	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=447097
+	 *
+	 * Before the transformation, We moved all root elements from the fragment resources to the main
+	 * resource, then we transformed some of them to Papyrus Stereotype Applications. We need to move
+	 * these stereotype applications back to the proper fragment resource
+	 */
+	protected void handleFragmentStereotypes(Resource mainUMLResource, List<Resource> umlResources) {
+		Iterator<EObject> rootElementIterator = mainUMLResource.getContents().iterator();
+		while (rootElementIterator.hasNext()) {
+			EObject rootElement = rootElementIterator.next();
+			if (rootElement instanceof Element) {
+				continue;
+			}
+
+			Resource targetStereotypeResource = getTargetStereotypeResource(rootElement, umlResources);
+			if (targetStereotypeResource != null && targetStereotypeResource != mainUMLResource) {
+				rootElementIterator.remove(); // To avoid ConcurrentModificationException when moving to the other resource
+				targetStereotypeResource.getContents().add(rootElement);
+			}
+		}
+	}
+
+	protected Resource getTargetStereotypeResource(EObject rootElement, List<Resource> umlResources) {
+		for (EReference eReference : rootElement.eClass().getEAllReferences()) {
+			if (eReference.getName().startsWith(Extension.METACLASS_ROLE_PREFIX)) {
+				Object value = rootElement.eGet(eReference);
+				if (value instanceof Element) {
+					return ((Element) value).eResource();
+				}
+			}
+		}
+
+		return null;
+	}
+
+	protected void deleteSourceStereotypes(Collection<Resource> fragmentResources) {
+		Set<Resource> allResources = new HashSet<>(fragmentResources);
+		allResources.add(umlResource);
+
+		for (Resource resource : allResources) {
+
+			// For performance reasons, RSA RT Stereotypes have not been deleted during the QVTo transformation (Bug 444379)
+			// Delete them as a post-action. Iterate on all controlled models and delete the RealTime stereotypes at the root of each resource
+			List<EObject> resourceContents = new LinkedList<>(resource.getContents());
+			for (EObject rootElement : resourceContents) {
+				if (sourceEPackages.contains(rootElement.eClass().getEPackage())) {
+					delete(rootElement);
+				}
+			}
+		}
+	}
+
+	protected abstract URI convertToPapyrus(URI rsaURI, String extension);
+	
+	/**
+	 * Runs a transformation using the context shared by all transformations.
+	 * 
+	 * @param transformationURI
+	 *            the transformation to run
+	 * @param extents
+	 *            the extents on which to apply the transformation
+	 * @param monitor
+	 *            progress monitor
+	 * 
+	 * @return the result of the transformation execution
+	 */
+	public IStatus runTransformation(URI transformationURI, List<ModelExtent> extents, IProgressMonitor monitor) {
+		return runTransformation(transformationURI, context, monitor, extents);
+	}
+
+	protected IStatus runTransformation(URI transformationURI, ExecutionContext context, IProgressMonitor monitor, List<ModelExtent> extents) {
+		if (monitor.isCanceled()) {
+			return new Status(IStatus.CANCEL, Activator.PLUGIN_ID, "Operation canceled");
+		}
+
+		TransformationExecutor executor;
+		try {
+			executor = getTransformation(transformationURI, monitor);
+		} catch (DiagnosticException ex) {
+			Diagnostic diagnostic = ex.getDiagnostic();
+
+			Activator.log.warn(String.format("Cannot load the transformation : %s. Diagnostic: %s", transformationURI, diagnostic.getMessage()));
+			return createStatusFromDiagnostic(diagnostic);
+		}
+
+		ExecutionDiagnostic result;
+		synchronized (executor) {
+			try {
+				// Gather the new execution traces
+				Trace newTraces = Trace.createEmptyTrace();
+				@SuppressWarnings("restriction")
+				ISessionData.SimpleEntry<Trace> traceKey = org.eclipse.m2m.internal.qvt.oml.evaluator.QVTEvaluationOptions.INCREMENTAL_UPDATE_TRACE;
+				context.getSessionData().setValue(traceKey, newTraces);
+
+				result = executor.execute(context, extents.toArray(new ModelExtent[0]));
+
+				// Append to our history
+				List<EObject> history = new ArrayList<>(trace.getTraceContent());
+				history.addAll(newTraces.getTraceContent());
+				trace.setTraceContent(history);
+			} finally {
+				executor.cleanup();
+				executorsPool.releaseExecutor(executor);
+			}
+		}
+
+		return createStatusFromDiagnostic(result);
+	}
+
+	protected ExecutionContext createExecutionContext(final IProgressMonitor monitor, final MultiStatus generationStatus) {
+		ExecutionContextImpl context = new ExecutionContextImpl();
+		context.setConfigProperty("keepModeling", true); //$NON-NLS-1$ o
+		context.setConfigProperty(TransformationUI.MONITOR, monitor);
+
+		// context.setProgressMonitor(monitor);
+
+		context.setLog(new WriterLog(new OutputStreamWriter(System.out)) {
+
+			@Override
+			public void log(String message) {
+				super.log(message);
+			}
+
+			@Override
+			public void log(String message, Object param) {
+				super.log(message, param);
+			}
+
+			@Override
+			public void log(int level, String message) {
+				super.log(level, message);
+				if (level >= 1) {
+					generationStatus.merge(new Status(level, Activator.PLUGIN_ID, message));
+				}
+
+			}
+
+			@Override
+			public void log(int level, String message, Object param) {
+				super.log(level, message, param);
+				if (level >= 1) {
+					generationStatus.merge(new Status(level, Activator.PLUGIN_ID, message + ", data:" + param));
+				}
+			}
+		});
+
+		initTransformationProperties(context);
+
+		// Invoke extensions as incremental transformations
+
+		context.getSessionData().setValue(TraceHelper.TRACE_HISTORY, trace);
+
+		return context;
+	}
+	
+	/**
+	 * Initializes the ExecutionContext with configuration properties required by transformations
+	 *
+	 * This is a lightweight mechanism to avoid initializing ModelExtents for a single EObject reference, or for non-EMF values
+	 *
+	 * Typically used by blackbox methods
+	 *
+	 * @param context
+	 */
+	protected abstract void initTransformationProperties(ExecutionContextImpl context);
+	
+
+	protected void configureResource(XMIResource resource) {
+		Map<Object, Object> saveOptions = new HashMap<>();
+
+		// default save options.
+		saveOptions.put(XMLResource.OPTION_DECLARE_XML, Boolean.TRUE);
+		saveOptions.put(XMLResource.OPTION_PROCESS_DANGLING_HREF, XMLResource.OPTION_PROCESS_DANGLING_HREF_DISCARD);
+		saveOptions.put(XMLResource.OPTION_SCHEMA_LOCATION, Boolean.TRUE);
+		saveOptions.put(XMIResource.OPTION_USE_XMI_TYPE, Boolean.TRUE);
+		saveOptions.put(XMLResource.OPTION_SAVE_TYPE_INFORMATION, Boolean.TRUE);
+		saveOptions.put(XMLResource.OPTION_SKIP_ESCAPE_URI, Boolean.FALSE);
+		saveOptions.put(XMLResource.OPTION_ENCODING, "UTF-8");
+
+		// see bug 397987: [Core][Save] The referenced plugin models are saved using relative path
+		saveOptions.put(XMLResource.OPTION_URI_HANDLER, new org.eclipse.emf.ecore.xmi.impl.URIHandlerImpl.PlatformSchemeAware());
+
+		resource.setEncoding("UTF-8");
+		resource.getDefaultSaveOptions().putAll(saveOptions);
+	}
+
+	protected abstract List<ModelExtent> getModelExtents();
+
+	public abstract ModelExtent getInOutUMLModel();
+
+	/* Notation model is initially empty, but will be filled successively by each transformation */
+	public ModelExtent getInoutNotationModel() {
+		if (outNotation == null) {
+			outNotation = new BasicModelExtent();
+		}
+
+		return outNotation;
+	}
+
+	protected ModelExtent getOutSashModel() {
+		if (outSashModel == null) {
+			outSashModel = new BasicModelExtent();
+		}
+
+		return outSashModel;
+	}
+
+
+	protected abstract Collection<URI> getDiagramTransformationURIs();
+	
+	//TODO : warning, the RSA code will probably be changed and this method will not used for RSA, because it is called after diagrams transformation for RSA.
+	protected abstract URI getSemanticTransformationURI();
+
+	protected abstract Collection<URI> getProfilesTransformationURI();
+
+	protected Collection<URI> getAdditionalTransformationURIs() {
+		return Collections.emptyList();
+	}
+
+	//currently abstract because We probably doesn't apply the transformation in the same order for Rpy than for  RSA
+	protected abstract Collection<URI> getAllTransformationURIs();
+
+	protected URI getTransformationURI(String transformationName, String pluginID) {
+		return URI.createPlatformPluginURI(String.format("%s/transform/%s.qvto", pluginID, transformationName), true); //$NON-NLS-1$
+	}
+
+	public String getModelName() {
+		return URI.decode(sourceURI.lastSegment());
+	}
+
+
+	public void cancel() {
+		job.cancel();
+	}
+
+	/** Lightweight delete operation, which only removes the object from its parent. Incoming references are not deleted */
+	public void delete(EObject elementToDelete) {
+		CacheAdapter adapter = CacheAdapter.getCacheAdapter(elementToDelete);
+		if (adapter == null) {
+			adapter = CacheAdapter.getInstance();
+		}
+		adapter.unsetTarget(elementToDelete);
+		if (elementToDelete.eResource() != null) {
+			elementToDelete.eResource().getContents().remove(elementToDelete);
+		}
+
+		EObject parent = elementToDelete.eContainer();
+		if (parent == null) {
+			return;
+		}
+		EReference containmentFeature = elementToDelete.eContainmentFeature();
+
+		if (containmentFeature.getUpperBound() == 1) {
+			parent.eUnset(containmentFeature);
+		} else {
+			List<?> values = (List<?>) parent.eGet(containmentFeature);
+			values.remove(elementToDelete);
+		}
+	}
+	
+	/**
+	 * 
+	 * @return
+	 * 		the trace of the transformation
+	 */
+	protected Trace getTrace() {
+		return this.trace;
+	}
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/AbstractImportTransformationLauncher.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/AbstractImportTransformationLauncher.java
new file mode 100644
index 0000000..e668261
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/AbstractImportTransformationLauncher.java
@@ -0,0 +1,383 @@
+/*****************************************************************************
+ * Copyright (c) 2014, 2016 CEA LIST, Christian W. Damus, and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *  Christian W. Damus - bug 496439
+ *  Vincent Lorenzo - bug 496176
+ *****************************************************************************/
+
+package org.eclipse.papyrus.interoperability.common.transformation;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.MultiStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.jobs.IJobChangeEvent;
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.core.runtime.jobs.JobChangeAdapter;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.papyrus.interoperability.common.Activator;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig;
+import org.eclipse.papyrus.interoperability.common.internal.Schedulable;
+import org.eclipse.papyrus.interoperability.common.internal.Scheduler;
+import org.eclipse.papyrus.interoperability.common.internal.TransformationWrapper;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.ui.console.ConsolePlugin;
+import org.eclipse.ui.console.IConsole;
+import org.eclipse.ui.console.IConsoleManager;
+import org.eclipse.ui.console.MessageConsole;
+import org.eclipse.ui.console.MessageConsoleStream;
+import org.eclipse.ui.statushandlers.StatusManager;
+
+/**
+ * Executes a batch of {@link ImportTransformation}s, then restores the dependencies (References)
+ * between each other
+ * 
+ * @author Vincent Lorenzo
+ *
+ */
+public abstract class AbstractImportTransformationLauncher implements IImportTransformationLauncher {
+
+	// Nano to Second
+	protected final static long SECOND = 1000 * 1000 * 1000;
+
+	// Nano to Milliseconds
+	protected final static long MILLIS = 1000 * 1000;
+
+	protected final ThreadConfig config;
+
+	protected final Control baseControl;
+
+	/**
+	 * Own execution time, in nano-seconds. Doesn't take individual transformation's exec
+	 * time into account. Also ignores the time when Blocking user Dialogs are opened
+	 */
+	protected long ownExecutionTime;
+
+	/**
+	 * Own loading time (For initial model loading)
+	 */
+	protected long ownLoadingTime;
+
+	/**
+	 * Own cumulated execution time for repairing stereotypes
+	 */
+	protected long ownRepairStereotypesTime;
+
+	/**
+	 * Own cumulated execution time for repairing libraries
+	 */
+	protected long ownRepairLibrariesTime;
+
+	/**
+	 * Own execution time for resolving all matches for broken profiles/libraries
+	 */
+	protected long resolveAllDependencies;
+
+	/**
+	 * The top-level job for this transformation
+	 */
+	protected Job importDependenciesJob;
+
+	/**
+	 * Total time for all invidivual transformations to complete. Since they are executed in parallel,
+	 * this may be different from their cumulated execution time (Unless a single thread is used)
+	 */
+	protected long transformationsExecutionTime = 0L;
+
+	protected IDependencyAnalysisHelper analysisHelper;
+
+	public AbstractImportTransformationLauncher(ThreadConfig config) {
+		this(config, null);
+	}
+
+	public AbstractImportTransformationLauncher(ThreadConfig config, Control baseControl) {
+		this.config = config;
+		this.baseControl = baseControl;
+	}
+
+	/**
+	 * Executes the transformation (Asynchronous)
+	 *
+	 * @param urisToImport
+	 */
+	public void run(List<URI> urisToImport) {
+		List<IImportTransformation> transformations = new LinkedList<IImportTransformation>();
+
+		analysisHelper = createDependencyAnalysisHelper(config);
+
+		for (URI uri : urisToImport) {
+			IImportTransformation transformation = createTransformation(uri, config, analysisHelper);
+			transformations.add(transformation);
+		}
+
+		// Always use the batch launcher, even if there is only 1 transformation (Bug 455012)
+		importModels(transformations);
+	}
+
+	protected abstract IDependencyAnalysisHelper createDependencyAnalysisHelper(final ThreadConfig config);
+
+	protected abstract IImportTransformation createTransformation(URI transformationURI, final ThreadConfig config, final IDependencyAnalysisHelper analysisHelper);
+
+	public static final String IMPORT_MODELS_JOB_NAME = "Import Models"; // $NON-NLS-0$
+
+	/**
+	 * Start a Job and delegate to {@link #importModels(IProgressMonitor, List)}
+	 *
+	 * @param transformations
+	 */
+	protected void importModels(final List<IImportTransformation> transformations) {
+		importDependenciesJob = new Job(IMPORT_MODELS_JOB_NAME) {
+
+			@Override
+			protected IStatus run(IProgressMonitor monitor) {
+				IStatus result = AbstractImportTransformationLauncher.this.importModels(monitor, transformations);
+
+				if (monitor.isCanceled()) {
+					return new Status(IStatus.CANCEL, Activator.PLUGIN_ID, "Operation Canceled");
+				}
+
+				long cumulatedLoadingTime = 0L;
+				long cumulatedTransformationTime = 0L;
+				long cumulatedHandleDanglingTime = 0L;
+				long cumulatedImportExtensionsTime = 0L;
+				for (IImportTransformation transformation : transformations) {
+					cumulatedLoadingTime += transformation.getLoadingTime();
+					cumulatedImportExtensionsTime += transformation.getImportExtensionsTime();
+					cumulatedHandleDanglingTime += transformation.getHandleDanglingRefTime();
+
+					cumulatedTransformationTime += transformation.getExecutionTime();
+
+					log("Import " + transformation.getModelName());
+					log("First phase (0-50%):");
+					log("\tTotal loading time: " + timeFormat(transformation.getLoadingTime()));
+					log("\tTotal Import Extensions time: " + timeFormat(transformation.getImportExtensionsTime()));
+					log("\tTotal Handle Dangling References time: " + timeFormat(transformation.getHandleDanglingRefTime()));
+					log("\tTotal execution time: " + timeFormat(transformation.getExecutionTime()));
+
+					Long loadingTime = loadingTimeV2.get(transformation);
+					Long repairProxiesTime = proxiesTime.get(transformation);
+					Long repairStereoTime = stereoTime.get(transformation);
+					Long totalPhase2 = totalTimeV2.get(transformation);
+
+					log("Second phase (50-100%):");
+					log("\tTotal loading time: " + timeFormat(loadingTime));
+					log("\tTotal fix proxies time: " + timeFormat(repairProxiesTime));
+					log("\tTotal fix stereotypes time: " + timeFormat(repairStereoTime));
+					log("\tTotal execution time: " + timeFormat(totalPhase2));
+
+					log("Total");
+					log("\tTotal execution time: " + timeFormat(transformation.getExecutionTime() + (totalPhase2 == null ? 0 : totalPhase2)));
+					log("\n");
+				}
+
+				int nbThreads = Math.max(1, config.getMaxThreads());
+				log("First phase (0-50%) / " + nbThreads + " Threads");
+				log("\tCumulated Transformation Time: " + timeFormat(cumulatedTransformationTime));
+				log("\tCumulated Loading Time: " + timeFormat(cumulatedLoadingTime));
+				log("\tCumulated Handle Dangling Refs Time: " + timeFormat(cumulatedHandleDanglingTime));
+				log("\tCumulated Import Extensions Time: " + timeFormat(cumulatedImportExtensionsTime));
+				log("\tTotal Transformation Time: " + timeFormat(transformationsExecutionTime));
+
+				log("Second phase (50-100%) / " + nbThreads + " Threads");
+				log("\tTotal Handle all Dangling References: " + timeFormat(resolveAllDependencies));
+				log("\tCumulated Loading Time: " + timeFormat(ownLoadingTime));
+				log("\tCumulated Fix Libraries Time: " + timeFormat(ownRepairLibrariesTime));
+				log("\tCumulated Fix Stereotypes Time: " + timeFormat(ownRepairStereotypesTime));
+				log("\tTotal Fix Dependencies Time: " + timeFormat(ownExecutionTime));
+
+				log("Total");
+				log("\tCumulated Total time: " + timeFormat(ownExecutionTime + cumulatedTransformationTime));
+				log("\tTotal time: " + timeFormat(ownExecutionTime + transformationsExecutionTime));
+
+				log("Import Complete");
+				log("");
+
+				return result;
+			}
+
+		};
+
+		importDependenciesJob.addJobChangeListener(new JobChangeAdapter() {
+			@Override
+			public void done(IJobChangeEvent event) {
+
+				MultiStatus multiStatus = new MultiStatus(Activator.PLUGIN_ID, IStatus.OK, "", null);
+
+				multiStatus.merge(event.getResult());
+
+				for (IImportTransformation transformation : transformations) {
+					multiStatus.merge(transformation.getStatus());
+				}
+
+				int severity = multiStatus.getSeverity();
+				String message;
+
+				switch (severity) {
+				case IStatus.OK:
+					message = "The selected models have been successfully imported";
+					break;
+				case IStatus.CANCEL:
+					message = "Operation canceled";
+					break;
+				case IStatus.WARNING:
+					message = "The selected models have been imported; some warnings have been reported";
+					break;
+				default:
+					message = "Some errors occurred during model import";
+					break;
+				}
+
+
+				handle(new MultiStatus(Activator.PLUGIN_ID, severity, multiStatus.getChildren(), message, null));
+			}
+
+			protected void handle(final IStatus status) {
+				if (baseControl == null) {
+					int severity = status.getSeverity();
+					if (severity == IStatus.OK || severity == IStatus.CANCEL) {
+						return;
+					}
+
+					StatusManager.getManager().handle(status, StatusManager.LOG);
+					return;
+				}
+
+				Display display = baseControl.getDisplay();
+
+				if (status.getSeverity() == IStatus.OK) {
+					display.asyncExec(new Runnable() {
+
+						@Override
+						public void run() {
+							MessageDialog.openInformation(baseControl.getShell(), "Import models", status.getMessage());
+						}
+					});
+
+				} else if (status.getSeverity() == IStatus.CANCEL) {
+					display.asyncExec(new Runnable() {
+
+						@Override
+						public void run() {
+							MessageDialog.openInformation(baseControl.getShell(), "Import models", status.getMessage());
+						}
+					});
+				} else {
+					StatusManager.getManager().handle(status, StatusManager.BLOCK);
+				}
+			}
+		});
+
+		importDependenciesJob.setUser(true);
+		importDependenciesJob.schedule();
+	}
+
+	protected void log(String message) {
+		System.out.println(message);
+
+		MessageConsole console = getConsole();
+		MessageConsoleStream out = console.newMessageStream();
+		out.println(message);
+	}
+
+	protected static final String CONSOLE_NAME = "Model Import Results"; // The name is both the ID and the Label
+
+	protected MessageConsole getConsole() {
+		ConsolePlugin plugin = ConsolePlugin.getDefault();
+		IConsoleManager consoleManager = plugin.getConsoleManager();
+		IConsole[] existing = consoleManager.getConsoles();
+		for (int i = 0; i < existing.length; i++) {
+			if (CONSOLE_NAME.equals(existing[i].getName())) {
+				return (MessageConsole) existing[i];
+			}
+		}
+		// no console found, so create a new one
+		MessageConsole rsaConsole = new MessageConsole(CONSOLE_NAME, null);
+		consoleManager.addConsoles(new IConsole[] { rsaConsole });
+		return rsaConsole;
+	}
+
+	protected String timeFormat(Long nano) {
+		if (nano == null) {
+			return "?"; // FIXME: crash?
+		}
+		long seconds = nano / SECOND;
+		if (seconds < 1) {
+			long millis = nano / MILLIS;
+			return String.format("%s ms", millis);
+		}
+		return String.format("%d:%02d:%02d", seconds / 3600, (seconds % 3600) / 60, (seconds % 60));
+	}
+
+	/**
+	 * Schedules all the individual transformations, wait for completion, then
+	 * call {@link #handleModelDependencies(List, IProgressMonitor)}
+	 *
+	 * @param monitor
+	 * @param transformations
+	 * @return
+	 */
+	protected IStatus importModels(IProgressMonitor monitor, List<IImportTransformation> transformations) {
+
+		long begin = System.nanoTime();
+
+		monitor.setTaskName("Waiting for import tasks to complete...");
+		int numTasks = transformations.size() * 2; // For each transformation: wait for completion, then handle dependencies
+		monitor.beginTask("Importing Models...", numTasks);
+
+		List<Schedulable> tasks = new LinkedList<Schedulable>();
+
+		for (IImportTransformation transformation : transformations) {
+			tasks.add(new TransformationWrapper(transformation));
+		}
+
+		Scheduler scheduler = new Scheduler(config.getMaxThreads());
+		scheduler.schedule(monitor, tasks);
+
+		long end = System.nanoTime();
+		transformationsExecutionTime = end - begin;
+
+		if (monitor.isCanceled()) {
+			return new Status(IStatus.CANCEL, Activator.PLUGIN_ID, "Operation canceled");
+		}
+
+		handleModelDependencies(transformations, monitor);
+
+		return Status.OK_STATUS;
+	}
+
+	protected void handleModelDependencies(List<IImportTransformation> transformations, IProgressMonitor monitor) {
+		// TODO, seem not required for Rpy import
+	}
+
+	final protected Map<IImportTransformation, Long> loadingTimeV2 = new HashMap<IImportTransformation, Long>();
+
+	final protected Map<IImportTransformation, Long> proxiesTime = new HashMap<IImportTransformation, Long>();
+
+	final protected Map<IImportTransformation, Long> stereoTime = new HashMap<IImportTransformation, Long>();
+
+	final protected Map<IImportTransformation, Long> totalTimeV2 = new HashMap<IImportTransformation, Long>();
+
+	/** Mainly for test purpose */
+	public void waitForCompletion() throws Exception {
+		importDependenciesJob.join();
+	}
+
+	/** Mainly for test purpose */
+	public IStatus getResult() {
+		return importDependenciesJob.getResult();
+	}
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/IDependencyAnalysisHelper.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/IDependencyAnalysisHelper.java
new file mode 100644
index 0000000..d6c43a1
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/IDependencyAnalysisHelper.java
@@ -0,0 +1,40 @@
+/*****************************************************************************
+ * Copyright (c) 2014, 2016 CEA LIST, Christian W. Damus, and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - Initial API and implementation
+ *****************************************************************************/
+
+package org.eclipse.papyrus.interoperability.common.transformation;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping;
+
+
+/**
+ * @author Vincent Lorenzo
+ *
+ */
+public interface IDependencyAnalysisHelper {
+
+	void computeURIMappings(Collection<Resource> sourceModels);
+
+	/** Propagates the URI Mappings to all duplicates */
+	void propagateURIMappings(List<URIMapping> allMappings, MappingParameters result);
+
+	void resolveAllMappings(Map<URI, URI> urisToReplace, Map<URI, URI> profileUrisToReplace);
+
+	List<URIMapping> flattenURIMappings(MappingParameters result);
+
+}
\ No newline at end of file
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/IImportTransformation.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/IImportTransformation.java
new file mode 100644
index 0000000..f38da75
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/IImportTransformation.java
@@ -0,0 +1,68 @@
+/*****************************************************************************
+ * Copyright (c) 2014, 2016 CEA LIST, Christian W. Damus, and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - Initial API and implementation
+ *****************************************************************************/
+
+package org.eclipse.papyrus.interoperability.common.transformation;
+
+import org.eclipse.core.runtime.IStatus;
+
+/**
+ * @author Vincent Lorenzo
+ *
+ */
+public interface IImportTransformation {
+
+	/**
+	 * @return
+	 */
+	long getLoadingTime();
+
+	/**
+	 * @return
+	 */
+	long getHandleDanglingRefTime();
+
+	/**
+	 * @return
+	 */
+	long getImportExtensionsTime();
+
+	/**
+	 * @return
+	 */
+	long getExecutionTime();
+
+	/**
+	 * @return
+	 */
+	String getModelName();
+
+	/**
+	 * @return
+	 */
+	IStatus getStatus();
+
+	/**
+	 * @return
+	 */
+	boolean isComplete();
+
+	/**
+	 * @param b
+	 */
+	void run(boolean b);
+
+	/**
+	 * 
+	 */
+	void cancel();
+
+}
\ No newline at end of file
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/IImportTransformationLauncher.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/IImportTransformationLauncher.java
new file mode 100644
index 0000000..3549b46
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/IImportTransformationLauncher.java
@@ -0,0 +1,39 @@
+/*****************************************************************************
+ * Copyright (c) 2014, 2016 CEA LIST, Christian W. Damus, and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - Initial API and implementation
+ *****************************************************************************/
+
+package org.eclipse.papyrus.interoperability.common.transformation;
+
+import java.util.List;
+
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.emf.common.util.URI;
+
+/**
+ * @author Vincent Lorenzo
+ *
+ */
+public interface IImportTransformationLauncher {
+
+	/**
+	 * Executes the transformation (Asynchronous)
+	 *
+	 * @param urisToImport
+	 */
+	public void run(List<URI> urisToImport);
+	
+	/** Mainly for test purpose */
+	public void waitForCompletion() throws Exception;
+	
+	/** Mainly for test purpose */
+	public IStatus getResult();
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/MigrationModelSet.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/MigrationModelSet.java
new file mode 100644
index 0000000..e856ba4
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/MigrationModelSet.java
@@ -0,0 +1,58 @@
+/*****************************************************************************
+ * Copyright (c) 2015 CEA LIST and others.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *   CEA LIST - Initial API and implementation
+ *   Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.transformation;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.papyrus.interoperability.common.concurrent.ThreadSafeModelSet;
+
+
+/**
+ * @author Camille Letavernier
+ *
+ */
+public class MigrationModelSet extends ThreadSafeModelSet implements MigrationResourceSet {
+
+	private boolean frozen = false;
+	
+	/**
+	 * @see org.eclipse.papyrus.migration.rsa.transformation.MigrationResourceSet#freeze()
+	 *
+	 */
+	@Override
+	public void freeze() {
+		this.frozen = true;
+	}
+
+	/**
+	 * @see org.eclipse.papyrus.migration.rsa.transformation.MigrationResourceSet#unfreeze()
+	 *
+	 */
+	@Override
+	public void unfreeze() {
+		this.frozen = false;
+	}
+	
+	/**
+	 * @see org.eclipse.emf.ecore.resource.impl.ResourceSetImpl#getResource(org.eclipse.emf.common.util.URI, boolean)
+	 *
+	 * @param uri
+	 * @param loadOnDemand
+	 * @return
+	 */
+	@Override
+	public Resource getResource(URI uri, boolean loadOnDemand) {
+		return super.getResource(uri, frozen ? false : loadOnDemand);
+	}
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/MigrationResourceSet.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/MigrationResourceSet.java
new file mode 100644
index 0000000..c14c293
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/MigrationResourceSet.java
@@ -0,0 +1,43 @@
+/*****************************************************************************
+ * Copyright (c) 2015 CEA LIST and others.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *   CEA LIST - Initial API and implementation
+ *   Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.transformation;
+
+import org.eclipse.emf.ecore.resource.ResourceSet;
+
+/**
+ * A ResourceSet which can optionally be "frozen". In frozen state,
+ * it won't load any additional resource, until {@link #unfreeze()} is called
+ * 
+ * Freezing the ResourceSet may violate the EMF Contract of getResource() and should be used carefully.
+ * 
+ * Use this when using eGet(EStructuralFeature, resolve = false) is not sufficient (Bug 457341 / Comment 17)
+ * 
+ * @author Camille Letavernier
+ *
+ */
+public interface MigrationResourceSet extends ResourceSet {
+
+	/**
+	 * Freeze this resource set: resources will not be demand-loaded anymore
+	 * Resources which are already present in the workspace will still be accessible
+	 * 
+	 * Frozen ResourceSets may violate the API Contract for {@link #getResource(org.eclipse.emf.common.util.URI, boolean)} ; use with care
+	 */
+	public void freeze();
+
+	/**
+	 * Unfreeze this resource set: come back to a normal state
+	 */
+	public void unfreeze();
+	
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/MigrationResourceSetImpl.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/MigrationResourceSetImpl.java
new file mode 100644
index 0000000..4e4bf37
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/MigrationResourceSetImpl.java
@@ -0,0 +1,60 @@
+/*****************************************************************************
+ * Copyright (c) 2015 CEA LIST and others.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *   CEA LIST - Initial API and implementation
+ *   Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+
+package org.eclipse.papyrus.interoperability.common.transformation;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.papyrus.interoperability.common.concurrent.ThreadSafeResourceSet;
+
+
+/**
+ * @author Camille Letavernier
+ *
+ */
+public class MigrationResourceSetImpl extends ThreadSafeResourceSet implements MigrationResourceSet {
+
+	private boolean frozen = false;
+
+	/**
+	 * @see org.eclipse.papyrus.migration.rsa.transformation.MigrationResourceSet#freeze()
+	 *
+	 */
+	@Override
+	public void freeze() {
+		this.frozen = true;
+	}
+
+	/**
+	 * @see org.eclipse.papyrus.migration.rsa.transformation.MigrationResourceSet#unfreeze()
+	 *
+	 */
+	@Override
+	public void unfreeze() {
+		this.frozen = false;
+	}
+	
+	/**
+	 * @see org.eclipse.emf.ecore.resource.impl.ResourceSetImpl#getResource(org.eclipse.emf.common.util.URI, boolean)
+	 *
+	 * @param uri
+	 * @param loadOnDemand
+	 * @return
+	 */
+	@Override
+	public Resource getResource(URI uri, boolean loadOnDemand) {
+		return super.getResource(uri, frozen ? false : loadOnDemand);
+	}
+	
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/RepairStereotypes.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/RepairStereotypes.java
new file mode 100644
index 0000000..b68880e
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/RepairStereotypes.java
@@ -0,0 +1,225 @@
+/*****************************************************************************
+ * Copyright (c) 2014, 2015 CEA LIST, Christian W. Damus, and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *  Christian W. Damus - bug 436666
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.transformation;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.emf.common.util.BasicDiagnostic;
+import org.eclipse.emf.common.util.TreeIterator;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.transaction.RollbackException;
+import org.eclipse.emf.transaction.Transaction;
+import org.eclipse.emf.transaction.TransactionalEditingDomain;
+import org.eclipse.emf.transaction.impl.InternalTransactionalEditingDomain;
+import org.eclipse.papyrus.infra.core.resource.ModelSet;
+import org.eclipse.papyrus.infra.core.services.ServiceException;
+import org.eclipse.papyrus.infra.emf.utils.EMFHelper;
+import org.eclipse.papyrus.infra.services.labelprovider.service.LabelProviderService;
+import org.eclipse.papyrus.infra.services.labelprovider.service.impl.LabelProviderServiceImpl;
+import org.eclipse.papyrus.interoperability.common.Activator;
+import org.eclipse.papyrus.uml.modelrepair.internal.stereotypes.IRepairAction;
+import org.eclipse.papyrus.uml.modelrepair.internal.stereotypes.ZombieStereotypesDescriptor;
+import org.eclipse.uml2.uml.Component;
+import org.eclipse.uml2.uml.Element;
+import org.eclipse.uml2.uml.Package;
+import org.eclipse.uml2.uml.Profile;
+import org.eclipse.uml2.uml.ProfileApplication;
+import org.eclipse.uml2.uml.UMLPackage;
+
+import com.google.common.base.Function;
+import com.google.common.base.Predicates;
+import com.google.common.collect.Iterators;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+
+/**
+ * Repairs stereotype applications in the specified model set, using the default action for each
+ *
+ * The given URI Map is used when the proper profile can't be found automatically
+ *
+ * @author Camille Letavernier
+ *
+ */
+public class RepairStereotypes {
+
+	private final ModelSet modelSet;
+
+	private final Collection<Resource> resourcesToRepair;
+
+	private final Map<URI, URI> profileMappings;
+
+	public RepairStereotypes(ModelSet modelSet, Collection<Resource> resourcesToRepair, Map<URI, URI> profileMappings) {
+		this.modelSet = modelSet;
+		this.resourcesToRepair = resourcesToRepair;
+		this.profileMappings = profileMappings;
+	}
+
+	/**
+	 * Finds all zombie stereotypes, and repair them with the default action.
+	 *
+	 * If the profile can't be found automatically, the profileMappings map is used
+	 *
+	 * @throws InterruptedException
+	 * @throws RollbackException
+	 */
+	public void execute() throws InterruptedException, RollbackException {
+		ZombieStereotypesDescriptor result = null;
+
+		LabelProviderService labelProvider = new LabelProviderServiceImpl();
+		try {
+			labelProvider.startService();
+		} catch (Exception ex) {
+			Activator.log.error(ex);
+			return;
+		}
+
+		Function<? super EPackage, Profile> profileSupplier = getProfileSupplier();
+
+		for (Resource resource : resourcesToRepair) {
+			Element rootElement = (Element) EcoreUtil.getObjectByType(resource.getContents(), UMLPackage.Literals.ELEMENT);
+
+			if (rootElement == null || rootElement.getNearestPackage() == null) {
+				continue;
+			}
+
+			Package rootPackage = rootElement.getNearestPackage();
+
+			Collection<ProfileApplication> profileApplications = Lists.newArrayList();
+			for (TreeIterator<EObject> iter = EcoreUtil.getAllProperContents(Collections.singleton(rootPackage), false); iter.hasNext();) {
+				EObject next = iter.next();
+				if (next instanceof ProfileApplication) {
+					profileApplications.add((ProfileApplication) next);
+					iter.prune();
+				} else if (!(next instanceof Package) && !(next instanceof Component)) {
+					// No sense looking for packages except in the things that can contain packages
+					iter.prune();
+				}
+			}
+
+			Set<EPackage> appliedDefinitions = getAppliedDefinitions(profileApplications);
+
+			ZombieStereotypesDescriptor zombies = new ZombieStereotypesDescriptor(resource, rootPackage, appliedDefinitions, profileSupplier, labelProvider);
+
+			for (EObject next : resource.getContents()) {
+				if (!(next instanceof Element)) {
+					zombies.analyze(next);
+				}
+			}
+
+			if (zombies.hasZombies()) {
+				result = zombies;
+			}
+
+			if (result == null) {
+				continue;
+			}
+
+			final ZombieStereotypesDescriptor descriptor = result;
+
+			final TransactionalEditingDomain domain = modelSet.getTransactionalEditingDomain();
+
+
+			InternalTransactionalEditingDomain internalDomain = (InternalTransactionalEditingDomain) domain;
+
+			Map<String, Object> options = new HashMap<String, Object>();
+			options.put(Transaction.OPTION_NO_UNDO, true);
+			options.put(Transaction.OPTION_NO_VALIDATION, true);
+			options.put(Transaction.OPTION_NO_TRIGGERS, true);
+			options.put(Transaction.OPTION_UNPROTECTED, true);
+
+			// We're in a batch environment, with no undo/redo support. Run a vanilla transaction to improve performances
+			Transaction fastTransaction = internalDomain.startTransaction(false, options);
+			try {
+				final BasicDiagnostic diagnostics = new BasicDiagnostic(Activator.PLUGIN_ID, 0, "Problems in repairing stereotypes", null);
+
+				for (IAdaptable packageToRepair : descriptor.getZombieSchemas()) {
+					IRepairAction action = descriptor.getRepairAction(packageToRepair, IRepairAction.Kind.APPLY_LATEST_PROFILE_DEFINITION);
+					descriptor.repair(packageToRepair, action, diagnostics, new NullProgressMonitor());
+				}
+			} finally {
+				fastTransaction.commit();
+			}
+
+		}
+
+		try {
+			labelProvider.disposeService();
+		} catch (ServiceException ex) {
+			Activator.log.error(ex);
+		}
+	}
+
+	/**
+	 * Maps a zombie EPackage with an existing Profile. Called only if the Profile can't be resolved automatically
+	 *
+	 * @return
+	 */
+	protected Function<? super EPackage, Profile> getProfileSupplier() {
+		return new Function<EPackage, Profile>() {
+
+			// If we're here, we didn't find a perfect match for the profile. We need to make some guesses
+			@Override
+			public Profile apply(EPackage input) {
+				if (input.eResource() == null || input.eResource().getURI() == null) {
+					return null;
+				}
+
+				URI packageResourceURI = input.eResource().getURI();
+				URI targetResourceURI = profileMappings.get(packageResourceURI);
+
+				Profile result = null;
+				URI selectedProfileURI = targetResourceURI;
+				if (selectedProfileURI != null) {
+					result = EMFHelper.load(modelSet, selectedProfileURI, Profile.class);
+
+					// If there is a single Profile, there is no ambiguity. Just return it
+					if ((result != null) && !hasNestedProfiles(result)) {
+						return result;
+					}
+
+					// TODO: handle the case with nested profiles (We already opened a popup dialog earlier; wouldn't be a good idea to pop another dialog here)
+				}
+
+				return null;
+			}
+
+			boolean hasNestedProfiles(Profile profile) {
+				return Iterators.any(profile.eAllContents(), Predicates.instanceOf(Profile.class));
+			}
+		};
+	}
+
+	protected Set<EPackage> getAppliedDefinitions(Iterable<? extends ProfileApplication> profileApplications) {
+		Set<EPackage> result = Sets.newHashSet();
+
+		for (ProfileApplication next : profileApplications) {
+			EPackage definition = next.getAppliedDefinition();
+			if ((definition != null) && !definition.eIsProxy()) {
+				result.add(definition);
+			}
+		}
+
+		return result;
+	}
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/ui/RegisteredItemLabelProvider.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/ui/RegisteredItemLabelProvider.java
new file mode 100644
index 0000000..56868ce
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/ui/RegisteredItemLabelProvider.java
@@ -0,0 +1,44 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.transformation.ui;
+
+import org.eclipse.jface.viewers.LabelProvider;
+import org.eclipse.papyrus.uml.extensionpoints.IRegisteredItem;
+import org.eclipse.swt.graphics.Image;
+
+/**
+ * Label Provider for RegisteredItems (Libraries & Profiles)
+ *
+ * @author Camille Letavernier
+ *
+ */
+public class RegisteredItemLabelProvider extends LabelProvider {
+	@Override
+	public Image getImage(Object element) {
+		if (element instanceof IRegisteredItem) {
+			IRegisteredItem library = (IRegisteredItem) element;
+			return library.getImage();
+		}
+		return super.getImage(element);
+	}
+
+	@Override
+	public String getText(Object element) {
+		if (element instanceof IRegisteredItem) {
+			IRegisteredItem library = (IRegisteredItem) element;
+			return library.getName();
+		}
+
+		return super.getText(element);
+	}
+}
\ No newline at end of file
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/ui/URIMappingDialog.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/ui/URIMappingDialog.java
new file mode 100644
index 0000000..39bdfec
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/transformation/ui/URIMappingDialog.java
@@ -0,0 +1,367 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.transformation.ui;
+
+import java.text.Collator;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.jface.dialogs.IDialogConstants;
+import org.eclipse.jface.viewers.ColumnLabelProvider;
+import org.eclipse.jface.viewers.ColumnWeightData;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.TableLayout;
+import org.eclipse.jface.viewers.TableViewer;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.jface.viewers.ViewerCell;
+import org.eclipse.jface.viewers.ViewerComparator;
+import org.eclipse.jface.window.Window;
+import org.eclipse.papyrus.infra.core.services.ServiceException;
+import org.eclipse.papyrus.infra.services.labelprovider.service.LabelProviderService;
+import org.eclipse.papyrus.infra.services.labelprovider.service.impl.LabelProviderServiceImpl;
+import org.eclipse.papyrus.infra.widgets.editors.TreeSelectorDialog;
+import org.eclipse.papyrus.infra.widgets.providers.CollectionContentProvider;
+import org.eclipse.papyrus.infra.widgets.providers.EncapsulatedContentProvider;
+import org.eclipse.papyrus.infra.widgets.providers.StaticContentProvider;
+import org.eclipse.papyrus.infra.widgets.providers.WorkspaceContentProvider;
+import org.eclipse.papyrus.interoperability.common.Activator;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MappingParameters;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.URIMapping;
+import org.eclipse.papyrus.interoperability.common.transformation.IDependencyAnalysisHelper;
+import org.eclipse.papyrus.uml.extensionpoints.IRegisteredItem;
+import org.eclipse.papyrus.uml.extensionpoints.Registry;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.swt.widgets.Table;
+import org.eclipse.swt.widgets.TableColumn;
+import org.eclipse.ui.dialogs.SelectionDialog;
+
+/**
+ * Opens a dialog allowing the user to manipulate/change the URIMappings of the transformation
+ * (Dependency repair)
+ *
+ * @author Camille Letavernier
+ *
+ */
+public class URIMappingDialog extends SelectionDialog {
+
+	MappingParameters mappingParameters, result;
+
+	TableViewer viewer;
+
+	LabelProviderService labelProviderService;
+
+	private static final int BROWSE_WORKSPACE_ID = IDialogConstants.CLIENT_ID + 1;
+
+	private static final int BROWSE_REGISTERED_ID = IDialogConstants.CLIENT_ID + 2;
+
+	private static final int BROWSE_PROFILES_ID = IDialogConstants.CLIENT_ID + 3;
+
+	List<URIMapping> allMappings;
+	
+	final IDependencyAnalysisHelper dependencyHelper;
+
+	public URIMappingDialog(Shell shell, MappingParameters mappingParameters, IDependencyAnalysisHelper dependencyHelper) {
+		super(shell);
+		this.dependencyHelper = dependencyHelper;
+		this.mappingParameters = mappingParameters;
+	}
+
+	@Override
+	protected void configureShell(Shell shell) {
+		setTitle("Some dependencies are missing");
+		super.configureShell(shell);
+	}
+
+	@Override
+	protected Control createDialogArea(Composite parent) {
+		Composite area = (Composite) super.createDialogArea(parent);
+
+		labelProviderService = new LabelProviderServiceImpl();
+		try {
+			labelProviderService.startService();
+		} catch (ServiceException e) {
+			Activator.log.error(e);
+		}
+
+		Label description = new Label(area, SWT.WRAP);
+		description.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, true, false));
+		description.setText("Some elements in the following resources can't be resolved. Please choose the resources to replace them.");
+
+		Composite self = new Composite(area, SWT.NONE);
+		self.setLayout(new GridLayout(1, true));
+		self.setLayoutData(new GridData(GridData.FILL_BOTH));
+
+		// Do a copy: if Cancel is pressed, it can be discarded
+		result = EcoreUtil.copy(mappingParameters);
+		setResult(Collections.singletonList(mappingParameters)); // Default result (If Cancel is pressed)
+
+		Composite buttonsBarComposite = new Composite(self, SWT.NONE);
+
+		GridLayout buttonsLayout = new GridLayout(0, false);
+		buttonsLayout.marginWidth = 0;
+
+		buttonsBarComposite.setLayout(buttonsLayout);
+		buttonsBarComposite.setLayoutData(new GridData(SWT.END, SWT.CENTER, false, false));
+
+		Button browseWorkspace = createButton(buttonsBarComposite, BROWSE_WORKSPACE_ID, "", false);
+		browseWorkspace.setImage(org.eclipse.papyrus.infra.widgets.Activator.getDefault().getImage("icons/browse_12x12.gif"));
+		browseWorkspace.setToolTipText("Browse Workspace");
+		Button browseRegistered = createButton(buttonsBarComposite, BROWSE_REGISTERED_ID, "", false);
+		browseRegistered.setImage(org.eclipse.papyrus.infra.widgets.Activator.getDefault().getImage("icons/Add_12x12.gif"));
+		browseRegistered.setToolTipText("Browse Registered Libraries");
+		Button browseProfiles = createButton(buttonsBarComposite, BROWSE_PROFILES_ID, "", false);
+		browseProfiles.setImage(org.eclipse.papyrus.infra.widgets.Activator.getDefault().getImage("icons/AddReg.gif"));
+		browseProfiles.setToolTipText("Browse Registered Profiles");
+
+		viewer = new TableViewer(self, SWT.FULL_SELECTION | SWT.BORDER);
+		Table table = viewer.getTable();
+		TableLayout layout = new TableLayout();
+		table.setLayout(layout);
+		GridData tableData = new GridData(SWT.FILL, SWT.FILL, true, true);
+
+		tableData.minimumHeight = 120;
+		table.setLayoutData(tableData);
+		table.setHeaderVisible(true);
+
+		TableColumn locationColumn = new TableColumn(table, SWT.NONE);
+		locationColumn.setText("Location");
+		layout.addColumnData(new ColumnWeightData(50, 250, true));
+
+		TableColumn newLocationColumn = new TableColumn(table, SWT.NONE);
+		newLocationColumn.setText("New Location");
+		layout.addColumnData(new ColumnWeightData(50, 250, true));
+
+		viewer.setContentProvider(CollectionContentProvider.instance);
+
+		viewer.setLabelProvider(new URIColumnsLabelProvider());
+		viewer.setComparator(new ViewerComparator() {
+			@Override
+			public int compare(Viewer viewer, Object e1, Object e2) {
+				if (e1 instanceof URIMapping && e2 instanceof URIMapping) {
+					URIMapping map1 = (URIMapping) e1;
+					URIMapping map2 = (URIMapping) e2;
+
+					return Collator.getInstance().compare(map1.getSourceURI(), map2.getSourceURI());
+				}
+				return 0;
+			}
+		});
+
+		allMappings = dependencyHelper.flattenURIMappings(result);
+
+		viewer.setInput(allMappings);
+
+		viewer.addSelectionChangedListener(new ISelectionChangedListener() {
+
+			@Override
+			public void selectionChanged(SelectionChangedEvent event) {
+				updateControls();
+			}
+		});
+
+		updateControls();
+
+		return self;
+	}
+
+	@Override
+	public boolean close() {
+		try {
+			labelProviderService.disposeService();
+		} catch (Exception e) {
+			Activator.log.error(e);
+		}
+		return super.close();
+	}
+
+	protected void updateControls() {
+		boolean enableBrowse = !viewer.getSelection().isEmpty();
+
+		getButton(BROWSE_REGISTERED_ID).setEnabled(enableBrowse);
+		getButton(BROWSE_WORKSPACE_ID).setEnabled(enableBrowse);
+		getButton(BROWSE_PROFILES_ID).setEnabled(enableBrowse);
+
+		viewer.refresh();
+	}
+
+	@Override
+	protected void buttonPressed(int buttonId) {
+		switch (buttonId) {
+		case BROWSE_REGISTERED_ID:
+			browseRegisteredLibraries();
+			return;
+		case BROWSE_WORKSPACE_ID:
+			browseWorkspaceLibraries();
+			return;
+		case BROWSE_PROFILES_ID:
+			browseRegisteredProfiles();
+			return;
+		}
+
+		super.buttonPressed(buttonId);
+	}
+
+	protected URIMapping getSelectedMapping() {
+		ISelection selection = viewer.getSelection();
+		if (selection.isEmpty()) {
+			return null;
+		}
+
+		if (selection instanceof IStructuredSelection) {
+			Object selectedElement = ((IStructuredSelection) selection).getFirstElement();
+			if (selectedElement instanceof URIMapping) {
+				return (URIMapping) selectedElement;
+			}
+		}
+
+		return null;
+	}
+
+	protected void browseWorkspaceLibraries() {
+		if (getSelectedMapping() == null) {
+			return;
+		}
+
+		Map<String, String> extensionFilters = new LinkedHashMap<String, String>();
+		extensionFilters.put("*.uml", "UML (*.uml)");
+		extensionFilters.put("*", "All (*)");
+
+		TreeSelectorDialog dialog = new TreeSelectorDialog(getShell());
+		dialog.setTitle("Browse Workspace");
+		dialog.setDescription("Select a library in the workspace.");
+		WorkspaceContentProvider workspaceContentProvider = new WorkspaceContentProvider();
+		workspaceContentProvider.setExtensionFilters(extensionFilters);
+		dialog.setContentProvider(workspaceContentProvider);
+
+		dialog.setLabelProvider(labelProviderService.getLabelProvider());
+
+
+		if (dialog.open() == Window.OK) {
+			Object[] result = dialog.getResult();
+			if (result == null || result.length == 0) {
+				return;
+			}
+
+			Object selectedFile = result[0];
+
+			if (selectedFile instanceof IFile) {
+				IPath filePath = ((IFile) selectedFile).getFullPath();
+				URI workspaceURI = URI.createPlatformResourceURI(filePath.toString(), true);
+
+				replaceSelectionWith(workspaceURI);
+			}
+		}
+	}
+
+	protected void replaceSelectionWith(URI targetURI) {
+		URIMapping mapping = getSelectedMapping();
+		mapping.setTargetURI(targetURI.toString());
+		updateControls();
+	}
+
+	protected void browseRegisteredLibraries() {
+		browseRegisteredItems(Registry.getRegisteredLibraries(), "Browse Registered Libraries", "Select one of the registered libraries below.");
+	}
+
+	protected void browseRegisteredProfiles() {
+		browseRegisteredItems(Registry.getRegisteredProfiles(), "Browse Registered Profiles", "Select one of the registered profiles below.");
+	}
+
+	protected void browseRegisteredItems(Collection<? extends IRegisteredItem> items, String dialogTitle, String dialogDescription) {
+		TreeSelectorDialog dialog = new TreeSelectorDialog(getShell());
+		dialog.setTitle(dialogTitle);
+		dialog.setDescription(dialogDescription);
+		dialog.setContentProvider(new EncapsulatedContentProvider(new StaticContentProvider(items.toArray(new IRegisteredItem[0]))));
+		dialog.setLabelProvider(new RegisteredItemLabelProvider());
+
+		if (dialog.open() == Window.OK) {
+			Object[] result = dialog.getResult();
+			if (result == null || result.length == 0) {
+				return;
+			}
+
+			Object selectedElement = result[0];
+			if (selectedElement instanceof IRegisteredItem) {
+				IRegisteredItem item = (IRegisteredItem) selectedElement;
+
+				replaceSelectionWith(item.getUri());
+			}
+		}
+	}
+
+	@Override
+	protected void okPressed() {
+		dependencyHelper.propagateURIMappings(allMappings, result);
+		setResult(Collections.singletonList(result)); // Set the new result
+		super.okPressed();
+	}
+
+	
+
+	private class URIColumnsLabelProvider extends ColumnLabelProvider {
+
+		@Override
+		public void update(ViewerCell cell) {
+			Object element = cell.getElement();
+
+			URIMapping mapping = (element instanceof URIMapping) ? (URIMapping) element : null;
+
+			switch (cell.getColumnIndex()) {
+			case 0:
+				updateLocation(cell, mapping);
+				break;
+			case 1:
+				updateNewLocation(cell, mapping);
+				break;
+			}
+
+		}
+
+		public void updateLocation(ViewerCell cell, URIMapping mapping) {
+			String location = "Unknown";
+			if (mapping != null) {
+				location = mapping.getSourceURI();
+			}
+
+			cell.setText(location);
+		}
+
+		public void updateNewLocation(ViewerCell cell, URIMapping mapping) {
+			String location = "";
+
+			if (mapping.getTargetURI() != null) {
+				location = mapping.getTargetURI();
+			}
+
+			cell.setText(location);
+		}
+	}
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/AbstractTransformationWizard.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/AbstractTransformationWizard.java
new file mode 100644
index 0000000..99640e0
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/AbstractTransformationWizard.java
@@ -0,0 +1,190 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - Initial API and implementation
+ *****************************************************************************/
+
+package org.eclipse.papyrus.interoperability.common.wizard;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.wizard.IWizardPage;
+import org.eclipse.jface.wizard.Wizard;
+import org.eclipse.papyrus.interoperability.common.Activator;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig;
+import org.eclipse.papyrus.interoperability.common.transformation.AbstractImportTransformationLauncher;
+import org.eclipse.papyrus.interoperability.common.wizard.pages.AbstractDialogData;
+import org.eclipse.papyrus.interoperability.common.wizard.pages.TransformationConfigPage;
+import org.eclipse.papyrus.interoperability.common.wizard.pages.TransformationSelectionPage;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.ui.IImportWizard;
+import org.eclipse.ui.IWorkbench;
+
+/**
+ * 
+ * Abstract Wizard For Model Migration into Papyrus
+ *
+ */
+public abstract class AbstractTransformationWizard extends Wizard implements IImportWizard {
+
+	protected IWizardPage currentPage;
+
+	protected final AbstractDialogData dialogData;
+
+	protected TransformationSelectionPage selectionPage;
+
+	protected TransformationConfigPage configPage;
+
+
+	public AbstractTransformationWizard(final String wizardTitle, final AbstractDialogData dialogData) {
+		setWindowTitle(wizardTitle);
+		this.dialogData = dialogData;
+	}
+
+	@Override
+	public void addPages() {
+		this.addPage(this.selectionPage = createTransformationSelectionPage(this.dialogData));
+		this.addPage(this.configPage = createTransformationConfigPage(this.dialogData));
+
+	}
+
+	/**
+	 * 
+	 * @param dialogData
+	 * 
+	 * @return
+	 * 		the selection page to include into the wizard
+	 */
+	protected TransformationSelectionPage createTransformationSelectionPage(final AbstractDialogData dialogData) {
+		return new TransformationSelectionPage(dialogData);
+	};
+
+	/**
+	 * 
+	 * @param dialogData
+	 * @return
+	 * 		the configuration page to include into the wizard
+	 */
+	protected TransformationConfigPage createTransformationConfigPage(final AbstractDialogData dialogData) {
+		return new TransformationConfigPage(dialogData);
+	};
+
+	@Override
+	public IWizardPage getNextPage(IWizardPage currentPage) {
+		if (currentPage == selectionPage) {
+			this.currentPage = configPage;
+			// Resets the viewer input in order to show the newly selected elements from the selectionPage
+			configPage.resetViewerInput();
+			return configPage;
+		}
+		if (this.currentPage == configPage) {
+			this.currentPage = selectionPage;
+		}
+		return null;
+	}
+
+	@Override
+	public boolean canFinish() {
+		if (currentPage == configPage) {
+			return super.canFinish();
+		}
+		return false;
+	}
+
+	@Override
+	public boolean performCancel() {
+		removeWizardImportedProjects();
+		return super.performCancel();
+	}
+
+	@Override
+	public boolean performFinish() {
+		// Set or update the unchecked elements for future executions of the plugin
+		dialogData.setSelectionMap();
+		importFiles();
+
+		// Remove the imported projects from the workspace
+		// removeWizardImportedProjects();
+
+		return true;
+	}
+
+
+	/**
+	 * 
+	 * Remove any imported projects, through the wizard, from the workspace
+	 * 
+	 */
+	public void removeWizardImportedProjects() {
+		if (/* dialogData != null && */dialogData.getImportedProjects() != null) {
+			for (Object object : dialogData.getImportedProjects()) {
+				if (object instanceof IProject) {
+					IProject project = (IProject) object;
+					try {
+						project.delete(false, true, null);
+					} catch (CoreException e) {
+						Activator.log.error(e);
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 *
+	 * Launch the transformation with the previously selected files and configuration parameters
+	 *
+	 */
+	protected void importFiles() {
+		ThreadConfig config = dialogData.getConfig();
+		if (config == null) {
+			return;
+		}
+
+		List<URI> urisToImport = new LinkedList<URI>();
+
+		for (Object selectedFile : dialogData.getTransformationFiles()) {
+			String path = null;
+			if (selectedFile instanceof IFile) {
+				path = ((IFile) selectedFile).getFullPath().toString();
+			}
+			if (path != null) {
+				URI uri = URI.createPlatformResourceURI(path, true);
+				urisToImport.add(uri);
+			}
+		}
+
+		// The wizard's Shell will be disposed because the transformation is asynchronous. Use the Shell's parent instead
+		AbstractImportTransformationLauncher launcher = createTransformationLauncher(config, this.getShell().getParent());
+		launcher.run(urisToImport);
+	}
+
+
+	public void init(IWorkbench workbench, IStructuredSelection selection) {
+		// nothing
+	}
+
+	/**
+	 * 
+	 * @param config
+	 *            the migration configuration
+	 * @param baseControl
+	 *            the base control used to launch the transformation itself
+	 * @return
+	 * 		the create Import Transformation Launcher
+	 */
+	protected abstract AbstractImportTransformationLauncher createTransformationLauncher(final ThreadConfig config, Control baseControl);
+
+}
\ No newline at end of file
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/TransformationWizardConstants.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/TransformationWizardConstants.java
new file mode 100644
index 0000000..2d94cb9
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/TransformationWizardConstants.java
@@ -0,0 +1,41 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Quentin Le Menez (CEA LIST) quentin.lemenez@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.wizard;
+
+import org.eclipse.papyrus.interoperability.common.Activator;
+
+/**
+ * Constants used in the wizard
+ */
+public interface TransformationWizardConstants {
+	
+	/**
+	 * The name used for the settings file
+	 */
+	public static final String TRANSFORMATION_WIZARD_SETTINGS = Activator.PLUGIN_ID + "Wizard.lastUnselection"; //$NON-NLS-1$
+
+	/**
+	 * The key to retrieve the selection preferences from the settings file
+	 */
+	public static final String WIZARD_SELECTION_KEY = "selectionPeferences"; //$NON-NLS-1$
+
+	public static final String FILEDIALOG_SELECTION_KEY = "previousDialogSelection"; //$NON-NLS-1$
+
+	/**
+	 * The name of the newly created project's folders
+	 */
+	public static final String SRC_FOLDER = "src"; //$NON-NLS-1$
+
+	public static final String RSC_FOLDER = "resources"; //$NON-NLS-1$
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/AbstractDialogData.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/AbstractDialogData.java
new file mode 100644
index 0000000..215e240
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/AbstractDialogData.java
@@ -0,0 +1,269 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Quentin Le Menez (CEA LIST) quentin.lemenez@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+
+package org.eclipse.papyrus.interoperability.common.wizard.pages;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedList;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.jface.dialogs.IDialogSettings;
+import org.eclipse.papyrus.infra.widgets.util.FileUtil;
+import org.eclipse.papyrus.interoperability.common.Activator;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.MigrationParametersFactory;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig;
+import org.eclipse.papyrus.interoperability.common.wizard.TransformationWizardConstants;
+
+
+
+/**
+ * 
+ * Class containing the bulk of the wizard's data for an easy access throughout the wizard
+ * 
+ * @author Quentin Le Menez
+ *
+ */
+public abstract class AbstractDialogData {
+
+	protected Collection<Object> selectedFiles;
+
+	protected Collection<Object> systemSelectedFiles;
+
+	protected Collection<Object> transformationFiles;
+
+	protected ThreadConfig config = MigrationParametersFactory.eINSTANCE.createThreadConfig();
+
+	protected Collection<String> unselectedFiles;
+
+	public IDialogSettings dialogSection;
+
+	protected Collection<Object> uncheckedFiles;
+
+	protected Collection<Object> importedProjects;
+
+	/**
+	 * 
+	 * Constructor, instantiate the configuration file to store the user's selections, if none exist, or retrieve it
+	 *
+	 */
+	public AbstractDialogData() {
+		// Necessary for storing and recalling the previous selections
+		dialogSection = Activator.getDefault().getDialogSettings().getSection(TransformationWizardConstants.TRANSFORMATION_WIZARD_SETTINGS);
+		if (dialogSection == null) {
+			dialogSection = Activator.getDefault().getDialogSettings().addNewSection(TransformationWizardConstants.TRANSFORMATION_WIZARD_SETTINGS);
+		}
+
+		systemSelectedFiles = new LinkedList<Object>();
+	}
+
+	/**
+	 * 
+	 * @param selectedFiles
+	 *            The selected files from the workspace to be displayed in the transformation page
+	 */
+	public void setSelectedFiles(Collection<Object> selectedFiles) {
+		this.selectedFiles = selectedFiles;
+	}
+
+	/**
+	 * 
+	 * @param selectedFiles
+	 *            The selected files outside of the workspace to be displayed in the transformation page
+	 */
+	public void setSystemSelectedFiles(Collection<String> systemPaths) {
+		for (String filePath : systemPaths) {
+			File file = new File(filePath);
+			if (file != null && !systemSelectedFiles.contains(file)) {
+				systemSelectedFiles.add(file);
+			}
+		}
+	}
+
+	/**
+	 * 
+	 * @param transformationFiles
+	 *            The selected files in the configuration page to be transformed
+	 */
+	public void setTransformationFiles(Collection<Object> transformationFiles) {
+		this.transformationFiles = transformationFiles;
+	}
+
+	/**
+	 * 
+	 * @return
+	 *         The default extensions used to filter the workspace
+	 */
+	public abstract String[] getExtensions();
+
+	/**
+	 * 
+	 * @return
+	 *         The default extensions' name used to filter the workspace
+	 */
+	public abstract String[] getExtensionsNames(); 
+
+	/**
+	 * 
+	 * @return
+	 *         The selected files from the workspace
+	 */
+	public Collection<Object> getSelectedFiles() {
+		return selectedFiles;
+	}
+
+	/**
+	 * 
+	 * @return
+	 *         The selected files outside of the workspace
+	 */
+	public Collection<Object> getSystemSelectedFiles() {
+		return systemSelectedFiles;
+	}
+
+	/**
+	 * 
+	 * @return
+	 *         The selected files from both workspace and outside selections
+	 */
+	public Collection<Object> getAllSelectedFiles() {
+		Collection<Object> allSelectedFiles = new LinkedList<Object>();
+		if (selectedFiles != null && selectedFiles.size() > 0) {
+			// TODO select only the files that are not already present in the selection done outside of the workspace
+			// Test
+			// for (Object object : selectedFiles) {
+			// if (!systemSelectedFiles.contains(object)) {
+			// allSelectedFiles.add(object);
+			// }
+			// }
+			// endTest
+			allSelectedFiles.addAll(selectedFiles);
+		}
+		// if (systemSelectedFiles != null && systemSelectedFiles.size() > 0) {
+		// allSelectedFiles.addAll(systemSelectedFiles);
+		// }
+		return allSelectedFiles;
+	}
+
+	/**
+	 * 
+	 * @return
+	 *         The parameters used for the transformation
+	 */
+	public ThreadConfig getConfig() {
+		return config;
+	}
+
+	/**
+	 * 
+	 * @return
+	 *         The selected files to be transformed
+	 */
+	public Collection<Object> getTransformationFiles() {
+		return transformationFiles;
+	}
+
+	/**
+	 * 
+	 * @param uncheckedFiles
+	 *            The selected files to be ignored during the transformation
+	 */
+	public void setUncheckedFiles(Collection<Object> uncheckedFiles) {
+		this.uncheckedFiles = uncheckedFiles;
+	}
+
+	/**
+	 * 
+	 * Sets or updates the projects to be imported in the workspace
+	 * 
+	 * @param importedProjects
+	 *            The selcted projects
+	 */
+	public void setImportedProjects(Collection<Object> importedProjects) {
+		this.importedProjects = importedProjects;
+	}
+
+	/**
+	 * 
+	 * @return
+	 *         The imported projects
+	 */
+	public Collection<Object> getImportedProjects() {
+		return this.importedProjects;
+	}
+
+	/**
+	 * 
+	 * Update or create the selection map stored inside the configuration file in order to remember the previous selection choices
+	 * 
+	 */
+	public void setSelectionMap() {
+		// Retrieve or create the list of unselected elements
+		if (getUnSelectionArray() != null) {
+			unselectedFiles = new LinkedList<String>(Arrays.asList(getUnSelectionArray()));
+		}
+		else {
+			unselectedFiles = new LinkedList<String>();
+		}
+		// Updates the unselected files for future references
+		for (Object object : uncheckedFiles) {
+			if (object instanceof IFile) {
+				IFile ifile = (IFile) object;
+				String ifilePath = FileUtil.getPath(ifile, true);
+				if (!unselectedFiles.contains(ifilePath)) {
+					unselectedFiles.add(ifilePath);
+				}
+			}
+			if (object instanceof File) {
+				File file = (File) object;
+				String filePath = file.getAbsolutePath();
+				if (!unselectedFiles.contains(filePath)) {
+					unselectedFiles.add(filePath);
+				}
+			}
+		}
+		// Remove any newly selected files from the unselected files pool
+		for (Object object : transformationFiles) {
+			if (object instanceof IFile) {
+				IFile ifile = (IFile) object;
+				String ifilePath = FileUtil.getPath(ifile, true);
+				if (unselectedFiles.contains(ifilePath)) {
+					unselectedFiles.remove(ifilePath);
+				}
+			}
+			if (object instanceof File) {
+				File file = (File) object;
+				String filePath = file.getAbsolutePath();
+				if (unselectedFiles.contains(filePath)) {
+					unselectedFiles.remove(filePath);
+				}
+			}
+		}
+
+		// Update the map
+		dialogSection.put(TransformationWizardConstants.WIZARD_SELECTION_KEY, unselectedFiles.toArray(new String[unselectedFiles.size()]));
+	}
+
+	/**
+	 * 
+	 * Used to set the checked state of the selected files inside the viewer
+	 * 
+	 * @return
+	 *         The user's previously unchecked files in the configPage
+	 */
+	public String[] getUnSelectionArray() {
+		return dialogSection.getArray(TransformationWizardConstants.WIZARD_SELECTION_KEY);
+	}
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/DialogDataConfigComposite.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/DialogDataConfigComposite.java
new file mode 100644
index 0000000..99e6b51
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/DialogDataConfigComposite.java
@@ -0,0 +1,200 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Quentin Le Menez (CEA LIST) quentin.lemenez@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.wizard.pages;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedList;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.papyrus.infra.widgets.util.FileUtil;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.events.SelectionListener;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+
+/**
+ * 
+ * Actual composite used to display the previously selected elements and the migration options
+ * 
+ * @author Quentin Le Menez
+ *
+ */
+public class DialogDataConfigComposite extends ImportConfigComposite {
+
+	protected AbstractDialogData dialogData;
+
+	protected SelectionListener buttonListener;
+
+	protected Button selectAll;
+
+	protected Button deselectAll;
+
+	/**
+	 *
+	 * Constructor used when a DialogData class is employed to store the different informations of the dialog
+	 *
+	 * @param parent
+	 *            The parent composite
+	 * @param style
+	 *            The swt style used for this ConfigurationComposite
+	 * @param dialogData
+	 *            The DialogData in which is stored all the necessary informations
+	 */
+	public DialogDataConfigComposite(Composite parent, int style, AbstractDialogData dialogData) {
+		super(parent, style, dialogData.getConfig());
+		this.dialogData = dialogData;
+		this.setViewerInput(dialogData.getSelectedFiles());
+	}
+
+
+	/**
+	 *
+	 * Fills the composite with the selection buttons
+	 *
+	 * @param parent
+	 *            The parent composite
+	 */
+	@Override
+	protected void createSelectionButtons(Composite parent) {
+		Composite buttonsComposite = new Composite(parent, SWT.NONE);
+		buttonsComposite.setLayout(new GridLayout());
+
+		buttonListener = new SelectionAdapter() {
+			@Override
+			public void widgetSelected(SelectionEvent event) {
+				fireButtonSelectionEvent(event);
+			}
+		};
+
+		selectAll = new Button(buttonsComposite, SWT.PUSH);
+		selectAll.setData(true);
+		selectAll.setText("Select All");
+		selectAll.addSelectionListener(buttonListener);
+		selectAll.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, true, false));
+
+		deselectAll = new Button(buttonsComposite, SWT.PUSH);
+		deselectAll.setData(false);
+		deselectAll.setText("Deselect All");
+		deselectAll.addSelectionListener(buttonListener);
+		deselectAll.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, true, false));
+
+	}
+
+	/**
+	 * 
+	 * Handles the selections inside the tableViewer
+	 * 
+	 * @param event
+	 *            The event linked to the tableViewer's selection buttons
+	 */
+	protected void fireButtonSelectionEvent(SelectionEvent event) {
+		listViewer.setAllChecked((Boolean) ((Button) event.widget).getData());
+		setTransformationFiles();
+		setUncheckedFiles();
+
+		if (dialogData != null) {
+			dialogData.setTransformationFiles(transformationFiles);
+			dialogData.setUncheckedFiles(uncheckedFiles);
+		}
+	}
+
+	@Override
+	protected void fireSelectionEvent(SelectionChangedEvent event) {
+		transformationFiles = new LinkedList<Object>(Arrays.asList(listViewer.getCheckedElements()));
+		setUncheckedFiles();
+
+		if (dialogData != null) {
+			dialogData.setTransformationFiles(transformationFiles);
+			dialogData.setUncheckedFiles(uncheckedFiles);
+		}
+	}
+
+	@Override
+	public void setViewerInput(Collection<Object> selectedFiles) {
+		listViewer.setInput(selectedFiles);
+
+		if (dialogData != null) {
+			if (dialogData.getUnSelectionArray() == null) {
+				// Default selection when opening the viewer without previous executions
+				listViewer.setAllChecked(true);
+			}
+			else {
+				// Recall the last unselected files to update the display
+				Collection<String> previousUnSelection = Arrays.asList(dialogData.getUnSelectionArray());
+				for (Object object : selectedFiles) {
+					if (object instanceof IFile) {
+						IFile ifile = (IFile) object;
+						String ifilePath = FileUtil.getPath(ifile, true);
+						if (previousUnSelection.contains(ifilePath)) {
+							listViewer.setChecked(object, false);
+						}
+						else {
+							listViewer.setChecked(object, true);
+						}
+					}
+					else if (object instanceof File) {
+						File file = (File) object;
+						String filePath = file.getAbsolutePath();
+						if (previousUnSelection.contains(filePath)) {
+							listViewer.setChecked(object, false);
+						}
+						else {
+							listViewer.setChecked(object, true);
+						}
+					}
+				}
+			}
+
+			setTransformationFiles();
+			setUncheckedFiles();
+
+			dialogData.setTransformationFiles(transformationFiles);
+			dialogData.setUncheckedFiles(uncheckedFiles);
+		}
+	}
+
+	/**
+	 * 
+	 * Updates the unchecked files in the wizard's dialog settings to remember the last selection when reopening the wizard
+	 * 
+	 */
+	protected void setUncheckedFiles() {
+		if (dialogData != null) {
+			uncheckedFiles = new LinkedList<Object>();
+			for (Object object : dialogData.getAllSelectedFiles()) {
+				if (!transformationFiles.contains(object)) {
+					uncheckedFiles.add(object);
+				}
+			}
+			dialogData.setUncheckedFiles(uncheckedFiles);
+		}
+	}
+
+	@Override
+	public void dispose() {
+		if (buttonListener != null) {
+			selectAll.removeSelectionListener(buttonListener);
+			deselectAll.removeSelectionListener(buttonListener);
+		}
+
+		super.dispose();
+	}
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/DialogDataTreeComposite.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/DialogDataTreeComposite.java
new file mode 100644
index 0000000..1bf7b42
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/DialogDataTreeComposite.java
@@ -0,0 +1,342 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Quentin Le Menez (CEA LIST) quentin.lemenez@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.wizard.pages;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IProjectDescription;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.papyrus.infra.widgets.util.FileUtil;
+import org.eclipse.papyrus.interoperability.common.Activator;
+import org.eclipse.papyrus.interoperability.common.internal.utils.CreateProject;
+import org.eclipse.papyrus.interoperability.common.wizard.TransformationWizardConstants;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.events.SelectionListener;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.FileDialog;
+
+
+/**
+ * 
+ * Actual composite used to display the workspace and select the wanted elements
+ * 
+ * @author Quentin Le Menez
+ *
+ */
+public class DialogDataTreeComposite extends ImportTreeComposite {
+	
+	/**
+	 * The name of the newly created project's folders
+	 */
+	public static final String SRC_FOLDER = "src"; //$NON-NLS-1$
+
+	public static final String RSC_FOLDER = "resources"; //$NON-NLS-1$
+
+	protected AbstractDialogData dialogData;
+
+	protected String systemDialogFiles;
+
+	protected SelectionListener selectionButtonListener;
+
+	protected SelectionListener systemSelectionListener;
+
+	protected Button selectAllButton;
+
+	protected Button deselectAllButton;
+
+	protected Button systemSelectionButton;
+
+
+	/**
+	 * 
+	 * Constructor.
+	 *
+	 * @param parent
+	 *            The parent composite
+	 * @param style
+	 *            The swt style used for this ConfigurationComposite
+	 * @param dialogData
+	 *            The DialogData in which is stored all the necessary informations
+	 */
+	public DialogDataTreeComposite(Composite parent, int style, AbstractDialogData dialogData) {
+		super(parent, style, dialogData.getExtensions(), dialogData.getExtensionsNames());
+
+		this.dialogData = dialogData;
+
+		ISelection treeSelection = treeViewer.getSelection();
+		if (treeSelection instanceof StructuredSelection) {
+			setSelectedFiles(((StructuredSelection) treeSelection).toArray());
+			this.dialogData.setSelectedFiles(getSelectedFiles());
+		}
+	}
+
+
+	@Override
+	protected void fireTreeSelectionEvent(SelectionChangedEvent event) {
+		ISelection selection = event.getSelection();
+
+		if (selection instanceof IStructuredSelection) {
+			// Updates the selected files
+			selectedFiles.clear();
+			IStructuredSelection sSelection = (IStructuredSelection) selection;
+			setSelectedFiles(sSelection.toArray());
+
+			if (dialogData != null) {
+				dialogData.setSelectedFiles(selectedFiles);
+			}
+		}
+
+	}
+
+	@Override
+	protected void createSelectionButtons(Composite parent) {
+		// The composite will contain three buttons, two general selection (all and none) and one for selections using a fileDialog window
+		selectionButtonsComposite = new Composite(parent, SWT.NONE);
+		selectionButtonsComposite.setLayout(new GridLayout());
+
+		systemSelectionListener = new SelectionAdapter() {
+
+			@Override
+			public void widgetSelected(SelectionEvent event) {
+				fireSystemBrowseEvent(event);
+			}
+		};
+
+		systemSelectionButton = new Button(selectionButtonsComposite, SWT.PUSH);
+		systemSelectionButton.setText("File System Selection");
+		systemSelectionButton.addSelectionListener(systemSelectionListener);
+		systemSelectionButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
+
+
+		selectionButtonListener = new SelectionAdapter() {
+			@Override
+			public void widgetSelected(SelectionEvent event) {
+				fireButtonSelectionEvent(event);
+			}
+		};
+
+		selectAllButton = new Button(selectionButtonsComposite, SWT.PUSH);
+		selectAllButton.setText("Select All");
+		selectAllButton.setData(true);
+		selectAllButton.addSelectionListener(selectionButtonListener);
+		selectAllButton.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, true, false));
+
+		deselectAllButton = new Button(selectionButtonsComposite, SWT.PUSH);
+		deselectAllButton.setText("Deselect All");
+		deselectAllButton.setData(false);
+		deselectAllButton.addSelectionListener(selectionButtonListener);
+		deselectAllButton.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, true, false));
+	}
+
+
+	/**
+	 * 
+	 * Handles the selectAll/deselectAll options
+	 * 
+	 * @param event
+	 *            The event linked to the selection buttons
+	 */
+	protected void fireButtonSelectionEvent(SelectionEvent event) {
+		if ((Boolean) ((Button) event.widget).getData()) {
+			treeViewer.getTree().selectAll();
+			// Updates the selectedFiles collection
+			getNestedFiles(((IStructuredSelection) treeViewer.getSelection()).toArray());
+
+			if (dialogData != null) {
+				dialogData.setSelectedFiles(selectedFiles);
+			}
+		} else {
+			treeViewer.getTree().deselectAll();
+			selectedFiles.clear();
+
+			if (dialogData != null) {
+				dialogData.setSelectedFiles(selectedFiles);
+			}
+		}
+	}
+
+	/**
+	 * 
+	 * handle the selections outside of the workspace
+	 * 
+	 * @param event
+	 *            The event linked to the button
+	 */
+	protected void fireSystemBrowseEvent(SelectionEvent event) {
+
+		// Clears the previous selection
+		dialogData.getSystemSelectedFiles().clear();
+		// Instantiates a new selection window
+		FileDialog dialog = new FileDialog(treeViewerComposite.getShell(), SWT.MULTI);
+		dialog.setText("Select the files to import");
+		dialog.setFilterExtensions(dialogData.getExtensions());
+		dialog.setFilterNames(dialogData.getExtensionsNames());
+
+		if (dialogData != null) {
+			// Fetches the last visited folder or uses the Home of the current user
+			if (dialogData.dialogSection.get(TransformationWizardConstants.FILEDIALOG_SELECTION_KEY) != null) {
+				dialog.setFilterPath(dialogData.dialogSection.get(TransformationWizardConstants.FILEDIALOG_SELECTION_KEY));
+			} else {
+				String homeFolder = System.getProperty("user.home"); //$NON-NLS-1$
+				dialog.setFilterPath(homeFolder);
+			}
+
+			// Opens the selection window and stores the selected files
+			systemDialogFiles = dialog.open();
+			if (systemDialogFiles != null) {
+				// stores the last folder/directory visited
+				dialogData.dialogSection.put(TransformationWizardConstants.FILEDIALOG_SELECTION_KEY, systemDialogFiles);
+				String[] names = dialog.getFileNames();
+				// Empty the list to avoid remembering old selections
+				systemPaths.clear();
+				for (int i = 0, n = names.length; i < n; i++) {
+					StringBuffer buf = new StringBuffer(dialog.getFilterPath());
+					if (buf.charAt(buf.length() - 1) != File.separatorChar) {
+						buf.append(File.separatorChar);
+					}
+					buf.append(names[i]);
+					systemPaths.add(buf.toString());
+				}
+				// clear the list to accept the new input
+				dialogData.getSystemSelectedFiles().clear();
+				dialogData.setSystemSelectedFiles(systemPaths);
+			}
+		}
+
+		Collection<Object> systemSelection = dialogData.getSystemSelectedFiles();
+		getProjects(systemSelection);
+		if (!systemSelection.isEmpty()) {
+			// The selected files are inside a project
+			if (!foundProjects.isEmpty()) {
+				for (Object object : foundProjects) {
+					if (isWorkspaceObject(object)) {
+						revealSelectedFiles(systemSelection);
+					}
+					// Creates the project before revealing any imported files
+					else if (importProjects(foundProjects)) {
+						revealSelectedFiles(systemSelection);
+					}
+				}
+			}
+			// We need to create a project in order to house the selected files
+			else if (systemDialogFiles != null) {
+				try {
+					List<String> srcFolders = new ArrayList<String>();
+					srcFolders.add(TransformationWizardConstants.SRC_FOLDER);
+					CreateProject placeHolder = new CreateProject(dialogData.getSystemSelectedFiles());
+					IProject newProject = placeHolder.getCreatedProject();
+					Collection<Object> revealList = new ArrayList<Object>();
+					// This case can happen by pressing the cancel button and therefore interrupting the creation of the project
+					if (newProject != null) {
+						for (IResource resource : Arrays.asList(newProject.getFolder(TransformationWizardConstants.RSC_FOLDER).members())) {
+							if (resource instanceof IFile) {
+								revealList.add((IFile) resource);
+							}
+						}
+						revealSelectedFiles(revealList);
+					}
+				} catch (Exception e) {
+					Activator.log.error(e);
+				}
+			}
+		}
+
+	}
+
+	/**
+	 * 
+	 * Verify if the provided object is or is not inside the workspace
+	 * 
+	 * @param object
+	 *            The object
+	 * @return
+	 *         True or False
+	 */
+	protected boolean isWorkspaceObject(Object object) {
+		if (object instanceof File) {
+			File file = (File) object;
+			IFile ifile = FileUtil.getIFile(file.getAbsolutePath());
+			// Assumes that any files outside the workbench are not IFiles and therefore wont be find, i.e. are null
+			if (ifile != null) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * 
+	 * Handles the creation of the new workspace projects in case of a selection outside of an existing project or workspace
+	 * 
+	 * @param foundProjects
+	 *            The projects previously found
+	 * @return
+	 *         The success of the creation
+	 */
+	protected boolean importProjects(Collection<Object> foundProjects) {
+		Collection<Object> importedProjects = new LinkedList<Object>();
+		boolean importStatus = false;
+		for (Object object : foundProjects) {
+			if (object instanceof File) {
+				File file = (File) object;
+				Path filePath = new Path(file.getAbsolutePath());
+				try {
+					IProjectDescription description = ResourcesPlugin.getWorkspace().loadProjectDescription(filePath);
+					IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(description.getName());
+					importedProjects.add(project);
+					project.create(description, null);
+					project.open(null);
+					importStatus = true;
+				} catch (CoreException e) {
+					Activator.log.error(e);
+				}
+			}
+		}
+
+		dialogData.setImportedProjects(importedProjects);
+		return importStatus;
+	}
+
+	@Override
+	public void dispose() {
+		if (selectionButtonListener != null) {
+			selectAllButton.removeSelectionListener(selectionButtonListener);
+			deselectAllButton.removeSelectionListener(selectionButtonListener);
+		}
+		if (systemSelectionListener != null) {
+			systemSelectionButton.removeSelectionListener(systemSelectionListener);
+		}
+
+		super.dispose();
+	}
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/ImportConfigComposite.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/ImportConfigComposite.java
new file mode 100644
index 0000000..d6cd317
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/ImportConfigComposite.java
@@ -0,0 +1,196 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Quentin Le Menez (CEA LIST) quentin.lemenez@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.wizard.pages;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedList;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.jface.viewers.ArrayContentProvider;
+import org.eclipse.jface.viewers.CheckboxTableViewer;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.LabelProvider;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.papyrus.infra.properties.ui.runtime.DisplayEngine;
+import org.eclipse.papyrus.infra.properties.ui.util.PropertiesDisplayHelper;
+import org.eclipse.papyrus.infra.widgets.util.FileUtil;
+import org.eclipse.papyrus.interoperability.common.MigrationParameters.ThreadConfig;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.FillLayout;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+
+/**
+ * 
+ * Generic and reusable composite used to display the previously selected elements and the migration options
+ * 
+ * @author Quentin Le Menez
+ *
+ */
+public abstract class ImportConfigComposite extends Composite {
+
+	protected ThreadConfig config;
+
+	protected Collection<Object> transformationFiles;
+
+	protected CheckboxTableViewer listViewer;
+
+	protected ISelectionChangedListener listListener;
+
+	protected DisplayEngine displayEngine;
+
+	protected Collection<Object> uncheckedFiles;
+
+	/**
+	 * 
+	 * Constructor.
+	 *
+	 * @param parent
+	 *            The parent composite
+	 * @param style
+	 *            The swt style used for this ConfigurationComposite
+	 * @param config
+	 *            The configuration used to display the transformation options
+	 */
+	public ImportConfigComposite(Composite parent, int style, ThreadConfig config) {
+		super(parent, style);
+		this.setLayout(new GridLayout(1, false));
+		this.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+		this.config = config;
+
+		Composite filesComposite = new Composite(this, SWT.BORDER);
+		filesComposite.setLayout(new FillLayout());
+		filesComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+
+		Composite configComposite = new Composite(this, SWT.BORDER);
+		configComposite.setLayout(new FillLayout());
+		configComposite.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, true, false));
+
+		createFilesComposite(filesComposite);
+
+		createParamComposite(configComposite);
+	}
+
+
+	/**
+	 *
+	 * Fills the selection area with all the files selected previously
+	 *
+	 * @param parent
+	 *            The parent composite
+	 */
+	protected void createFilesComposite(Composite parent) {
+		Composite listComposite = new Composite(parent, SWT.NONE);
+		GridLayout gridLayout = new GridLayout(2, false);
+		listComposite.setLayout(gridLayout);
+
+		listViewer = CheckboxTableViewer.newCheckList(listComposite, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL);
+		GridData viewerGrid = new GridData(SWT.FILL, SWT.FILL, true, true);
+		listViewer.getTable().setLayoutData(viewerGrid);
+
+		listViewer.setLabelProvider(new LabelProvider() {
+			@Override
+			public String getText(Object element) {
+				if (element instanceof IFile) {
+					return FileUtil.getPath((IFile) element, true);
+				} else if (element instanceof File) {
+					return ((File) element).getAbsolutePath();
+				} else {
+					return "Not an IFile, wrong type to transform";
+				}
+			}
+		});
+
+		listViewer.setContentProvider(new ArrayContentProvider());
+
+		listListener = new ISelectionChangedListener() {
+			@Override
+			public void selectionChanged(SelectionChangedEvent event) {
+				fireSelectionEvent(event);
+			}
+		};
+
+		listViewer.addSelectionChangedListener(listListener);
+
+		setTransformationFiles();
+
+		createSelectionButtons(listComposite);
+
+	}
+
+
+	/**
+	 * 
+	 * Used to update the display from a changed selection in the ConfigPage
+	 * 
+	 * @param selectedFiles
+	 *            The new list of selected files
+	 */
+	abstract void setViewerInput(Collection<Object> selectedFiles);
+
+	/**
+	 * 
+	 * Abstract method to be implemented by the child in order to create the useful buttons to manipulate the tableViewer's elements
+	 * 
+	 * @param parent
+	 *            The parent composite in which the new buttons will be created
+	 */
+	abstract void createSelectionButtons(Composite parent);
+
+	/**
+	 * 
+	 * Abstract method to be implemented by the child in order to handle the transformation options
+	 * 
+	 * @param event
+	 *            The event linked to the configuration's selection buttons
+	 */
+	abstract void fireSelectionEvent(SelectionChangedEvent event);
+
+
+	/**
+	 * 
+	 * Updates the list of files to be transformed
+	 * 
+	 */
+	public void setTransformationFiles() {
+		transformationFiles = new LinkedList<Object>(Arrays.asList(listViewer.getCheckedElements()));
+	}
+
+
+	/**
+	 *
+	 * Fills the composite with the configuration parameters
+	 *
+	 * @param parent
+	 *            The parent composite
+	 */
+	public void createParamComposite(Composite parent) {
+		displayEngine = PropertiesDisplayHelper.display(config, parent);
+	}
+
+
+	@Override
+	public void dispose() {
+		if (displayEngine != null) {
+			displayEngine.dispose();
+		}
+		if (listListener != null) {
+			listViewer.removeSelectionChangedListener(listListener);
+		}
+		super.dispose();
+	}
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/ImportTreeComposite.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/ImportTreeComposite.java
new file mode 100644
index 0000000..dcbc5c5
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/ImportTreeComposite.java
@@ -0,0 +1,540 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Quentin Le Menez (CEA LIST) quentin.lemenez@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.wizard.pages;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jface.viewers.ILabelProvider;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.jface.viewers.TreeViewer;
+import org.eclipse.jface.viewers.ViewerFilter;
+import org.eclipse.papyrus.infra.core.services.ServiceException;
+import org.eclipse.papyrus.infra.services.labelprovider.service.LabelProviderService;
+import org.eclipse.papyrus.infra.services.labelprovider.service.impl.LabelProviderServiceImpl;
+import org.eclipse.papyrus.infra.widgets.providers.IGraphicalContentProvider;
+import org.eclipse.papyrus.infra.widgets.providers.PatternViewerFilter;
+import org.eclipse.papyrus.infra.widgets.providers.WorkspaceContentProvider;
+import org.eclipse.papyrus.interoperability.common.Activator;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.FillLayout;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.dialogs.PatternFilter;
+
+
+/**
+ * 
+ * Generic and reusable composite used to display the workspace and select the wanted elements
+ * 
+ * @author Quentin Le Menez
+ *
+ */
+public abstract class ImportTreeComposite extends Composite {
+
+	protected TreeViewer treeViewer;
+
+	protected LabelProviderService labelProviderService;
+
+	protected ILabelProvider treeViewerlabelProvider;
+
+	protected WorkspaceContentProvider treeViewercontentProvider;
+
+	protected ISelectionChangedListener treeViewerListener;
+
+	protected final List<String> filterNames;
+
+	protected final List<String> filterExtensions;
+
+	protected Collection<Object> selectedFiles;
+
+	protected Collection<String> systemPaths;
+
+	protected FillLayout layout;
+
+	protected Composite treeViewerComposite;
+
+	protected Composite selectionButtonsComposite;
+
+	protected Collection<Object> foundProjects;
+
+	/**
+	 * 
+	 * Constructor.
+	 *
+	 * @param parent
+	 *            The parent composite
+	 * @param style
+	 *            The swt style used for this ConfigurationComposite
+	 * @param extensions
+	 *            The default extensions used to filter the displayed results
+	 * @param extensionsNames
+	 *            The displayed names of those filters
+	 */
+	public ImportTreeComposite(Composite parent, int style, String[] extensions, String[] extensionsNames) {
+		super(parent, style);
+		this.setLayout(new GridLayout(2, false));
+		this.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+
+		selectedFiles = new LinkedList<Object>();
+		filterNames = new LinkedList<String>();
+		filterExtensions = new LinkedList<String>();
+		systemPaths = new LinkedList<String>();
+		foundProjects = new LinkedList<Object>();
+
+		createTreeViewerComposite(this, extensions, extensionsNames);
+
+		createSelectionButtons(this);
+	}
+
+
+	/**
+	 * 
+	 * Creates the visual representation of the workspace
+	 * 
+	 * @param parent
+	 *            The parent Composite
+	 * @param extensions
+	 *            The default extensions used to filter the displayed results
+	 * @param extensionsNames
+	 *            The displayed names of those filters
+	 */
+	private void createTreeViewerComposite(Composite parent, String[] extensions, String[] extensionsNames) {
+		treeViewerComposite = new Composite(parent, SWT.NONE);
+		treeViewerComposite.setLayout(new GridLayout(1, true));
+		treeViewerComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+		Composite beforeTreeComposite = new Composite(treeViewerComposite, SWT.NONE);
+
+		Composite treeComposite = new Composite(treeViewerComposite, SWT.NONE);
+		treeComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+		layout = new FillLayout();
+		layout.marginHeight = 0;
+		layout.marginWidth = 0;
+		treeComposite.setLayout(layout);
+
+		treeViewer = new TreeViewer(treeComposite, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
+		treeViewer.setFilters(new ViewerFilter[] { new PatternFilter() });
+
+		labelProviderService = new LabelProviderServiceImpl();
+		try {
+			labelProviderService.startService();
+		} catch (ServiceException ex) {
+			Activator.log.error(ex);
+		}
+
+		treeViewerlabelProvider = labelProviderService.getLabelProvider();
+		treeViewercontentProvider = new WorkspaceContentProvider();
+		setFilters(extensions, extensionsNames);
+
+		treeViewercontentProvider.setExtensionFilters(new LinkedHashMap<String, String>());
+		for (int i = 0; i < Math.min(filterNames.size(), filterExtensions.size()); i++) {
+			treeViewercontentProvider.addExtensionFilter(filterExtensions.get(i), filterNames.get(i));
+		}
+
+		treeViewer.setContentProvider(treeViewercontentProvider);
+		treeViewer.setLabelProvider(treeViewerlabelProvider);
+
+		defaultViewerInput();
+
+		treeViewerListener = new ISelectionChangedListener() {
+
+			@Override
+			public void selectionChanged(SelectionChangedEvent event) {
+				fireTreeSelectionEvent(event);
+			}
+		};
+
+		treeViewer.addSelectionChangedListener(treeViewerListener);
+
+		// This is used to display both of the filters (before and after the treeViewer)
+		if (treeViewercontentProvider instanceof IGraphicalContentProvider) {
+			IGraphicalContentProvider graphicalContentProvider = treeViewercontentProvider;
+
+			beforeTreeComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
+			layout = new FillLayout();
+			layout.marginHeight = 0;
+			layout.marginWidth = 0;
+			beforeTreeComposite.setLayout(layout);
+			graphicalContentProvider.createBefore(beforeTreeComposite);
+			beforeTreeComposite.moveAbove(treeViewer.getTree());
+
+			Composite afterTreeComposite = new Composite(treeViewerComposite, SWT.NONE);
+			layout = new FillLayout();
+			layout.marginHeight = 0;
+			layout.marginWidth = 0;
+			afterTreeComposite.setLayout(layout);
+			afterTreeComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
+			graphicalContentProvider.createAfter(afterTreeComposite);
+		}
+
+	}
+
+	/**
+	 * 
+	 * Sets the filters for the treeViewer, matching the names with the extensions
+	 * 
+	 * @param filterExtensions
+	 *            The extensions
+	 * @param filterNames
+	 *            The associated names
+	 */
+	protected void setFilters(String[] filterExtensions, String[] filterNames) {
+		if (filterExtensions.length != filterNames.length) {
+			// This is a simple warning. Only valid filters will be retained.
+			Activator.log.warn("FilterExtensions and FilterNames do not match");
+		}
+
+		setFilterNames(getFilterLabels(filterNames, filterExtensions));
+		setFilterExtensions(filterExtensions);
+	}
+
+	/**
+	 * 
+	 * Builds the filter labels to be displayed
+	 * 
+	 * @param filterNames
+	 * @param filterExtensions
+	 * @return
+	 *         The array containing the built labels
+	 */
+	protected String[] getFilterLabels(String[] filterNames, String[] filterExtensions) {
+		int size = Math.min(filterNames.length, filterExtensions.length);
+		String[] filters = new String[size];
+		for (int i = 0; i < size; i++) {
+			filters[i] = filterNames[i] + " (" + filterExtensions[i] + ")"; //$NON-NLS-1$ //$NON-NLS-2$
+		}
+		return filters;
+	}
+
+	/**
+	 * 
+	 * Fills the local array to be manipulated
+	 * 
+	 * @param filterExtensions
+	 *            The input extensions
+	 */
+	protected void setFilterExtensions(String[] filterExtensions) {
+		this.filterExtensions.clear();
+		this.filterExtensions.addAll(Arrays.asList(filterExtensions));
+	}
+
+	/**
+	 * 
+	 * Fills the local array to be manipulated
+	 * 
+	 * @param filterNames
+	 *            The input names
+	 */
+	protected void setFilterNames(String[] filterNames) {
+		this.filterNames.clear();
+		this.filterNames.addAll(Arrays.asList(filterNames));
+	}
+
+
+	/**
+	 * 
+	 * This method allows to set the default input of the treeViewer
+	 * 
+	 */
+	protected void defaultViewerInput() {
+		treeViewer.setInput(File.listRoots());
+		// Gets the selection in the workspace at the time of the launch
+		ISelection workbenchSelection = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getSelectionService().getSelection();
+		// Sets the first selection of the treeviewer from the selection in the workspace
+		revealSelection(workbenchSelection);
+		treeViewer.setSelection(workbenchSelection, true);
+	}
+
+
+	/**
+	 * 
+	 * Abstract method to be implemented by the child in order to create the useful buttons to manipulate the tree's elements
+	 * 
+	 * @param parent
+	 *            The parent composite in which the new buttons will be created
+	 */
+	abstract void createSelectionButtons(Composite parent);
+
+	/**
+	 * 
+	 * Abstract method to be implemented by the child in order to handle the treeViewer element selection
+	 * 
+	 * @param event
+	 *            The event linked to the selections inside the treeViewer
+	 */
+	abstract void fireTreeSelectionEvent(SelectionChangedEvent event);
+
+
+	/**
+	 * 
+	 * This method reveals the elements selected outside of the workspace or from the workspace selection at launch by expanding the tree
+	 * 
+	 * @param importedFiles
+	 *            The list of selected files
+	 */
+	protected void revealSelectedFiles(Collection<Object> importedFiles) {
+		// this method calls to expand any folders or projects containg the selected files in order to show the workspace selection
+		Collection<IFile> ifiles = new ArrayList<IFile>();
+		// Collection<IProject> iprojects = new ArrayList<IProject>();
+		// Collection<IFolder> ifolders = new ArrayList<IFolder>();
+		if (importedFiles != null && !importedFiles.isEmpty()) {
+			for (Object object : importedFiles) {
+				treeViewer.refresh();
+				if (object instanceof File) {
+					File file = (File) object;
+					IFile ifile = ResourcesPlugin.getWorkspace().getRoot().getFileForLocation(new Path(file.getAbsolutePath()));
+					if (ifile != null) {
+						ifiles.add(ifile);
+						revealTreeElement(ifile);
+					}
+				}
+				if (object instanceof IFile) {
+					IFile ifile = (IFile) object;
+					ifiles.add(ifile);
+					revealTreeElement(ifile);
+				}
+				// if (object instanceof IFolder) {
+				// IFolder ifolder = (IFolder) object;
+				// ifolders.add(ifolder);
+				// revealTreeElement(ifolder);
+				// }
+				// if (object instanceof IProject) {
+				// IProject iproject = (IProject) object;
+				// iprojects.add(iproject);
+				// // As a project is a root element, no need to expand it
+				// }
+			}
+		}
+
+		treeViewer.setSelection(new StructuredSelection(ifiles.toArray()), true);
+		// treeViewer.setSelection(new StructuredSelection(ifolders.toArray()), true);
+		// treeViewer.setSelection(new StructuredSelection(iprojects.toArray()), true);
+	}
+
+	/**
+	 * 
+	 * Handles the workspace selection
+	 * 
+	 * @param iselection
+	 *            The selection
+	 */
+	protected void revealSelection(ISelection iselection) {
+		if (iselection instanceof IStructuredSelection) {
+			IStructuredSelection sselection = (IStructuredSelection) iselection;
+			revealSelectedFiles(Arrays.asList(sselection.toArray()));
+		}
+	}
+
+	/**
+	 * 
+	 * Reveal each elements from the selected elements list
+	 * 
+	 * @param object
+	 *            The selected object
+	 */
+	protected void revealTreeElement(Object object) {
+		// verify the possibility of getting the file's parent and that the root directory is not already selected
+		if (object instanceof IFile && !(object instanceof IProject)) {
+			IFile ifile = (IFile) object;
+			treeViewer.setExpandedState(ifile.getParent(), true);
+			if (!(ifile.getParent() instanceof IProject)) {
+				revealTreeElement(ifile.getParent());
+			}
+		}
+		if (object instanceof IFolder && !(object instanceof IProject)) {
+			IFolder ifolder = (IFolder) object;
+			treeViewer.setExpandedState(ifolder.getParent(), true);
+			if (!(ifolder.getParent() instanceof IProject)) {
+				revealTreeElement(ifolder.getParent());
+			}
+		}
+	}
+
+	/**
+	 * 
+	 * This method is used to get the projects containing the selected objects
+	 * 
+	 * @param systemSelection
+	 *            The selection outside of the workspace
+	 * @return
+	 *         The list of projects found
+	 */
+	protected Collection<Object> getProjects(Collection<Object> systemSelection) {
+		if (systemSelection != null && !systemSelection.isEmpty()) {
+			for (Object object : systemSelection) {
+				if (object instanceof File) {
+					File file = (File) object;
+					getProject(file);
+				}
+			}
+		}
+		return foundProjects;
+	}
+
+	/**
+	 * 
+	 * This method is used to get the projects containing the file
+	 * 
+	 * @param file
+	 *            The selected file
+	 */
+	protected void getProject(File file) {
+		File parentFile = file.getParentFile();
+		if (parentFile == null) {
+			// No containing project has been found
+			return;
+		}
+
+		Collection<File> parentChildren = Arrays.asList(parentFile.listFiles());
+		for (File nestedFile : parentChildren) {
+			// String fileExtension = Files.getFileExtension(nestedFile.getAbsolutePath());
+			String fileExtension = getFileExtensions(nestedFile);
+			if (fileExtension.equals(".project") && !foundProjects.contains(nestedFile)) { // $NON-NLS-1$
+				// A containing project has been found
+				foundProjects.add(nestedFile);
+				return;
+			}
+		}
+
+		getProject(parentFile);
+	}
+
+	/**
+	 * 
+	 * This method gathers the file extensions in order to filter them
+	 * 
+	 * @param file
+	 *            The file
+	 * @return
+	 *         The file's extension
+	 */
+	protected String getFileExtensions(File file) {
+		String fileName = file.getName();
+		if (fileName.lastIndexOf(".") != -1 /* && fileName.lastIndexOf(".") != 0 */) { // $NON-NLS-1$
+			return fileName.substring(fileName.lastIndexOf(".")); // $NON-NLS-1$
+		} else {
+			return "";
+		}
+	}
+
+	/**
+	 * 
+	 * Constructs the list of the treeViewer's selected files
+	 * 
+	 * @param elements
+	 */
+	public void setSelectedFiles(Object[] elements) {
+		// get the viewer selection to obtain the filtered files
+		getNestedFiles(elements);
+	}
+
+	/**
+	 * 
+	 * getter used to access the selectedFiles list
+	 * 
+	 * @return
+	 *         the list of selected files
+	 */
+	public Collection<Object> getSelectedFiles() {
+		return selectedFiles;
+	}
+
+	/**
+	 *
+	 * Gets all the files from the user's selection in the viewer and updates the local selection list
+	 *
+	 * @param nestedElements
+	 *            The array containing the selected elements, be they files or folders
+	 */
+	protected void getNestedFiles(Object[] nestedElements) {
+		Collection<Object> projectList = new LinkedList<Object>();
+		Collection<Object> folderList = new LinkedList<Object>();
+		List<PatternViewerFilter> currentFilters = new ArrayList<PatternViewerFilter>();
+		for (ViewerFilter filter : treeViewer.getFilters()) {
+			if (filter instanceof PatternViewerFilter) {
+				currentFilters.add((PatternViewerFilter) filter);
+			}
+		}
+
+		for (Object element : nestedElements) {
+			if (element instanceof IProject) {
+				projectList.add(element);
+			}
+			if (element instanceof IFolder) {
+				folderList.add(element);
+			}
+			if (element instanceof IFile) {
+				Boolean isVisible = false;
+				IFile selectedFile = (IFile) element;
+				String fileExtension = "*." + selectedFile.getFileExtension(); //$NON-NLS-1$
+				if (filterExtensions.contains(fileExtension) && !selectedFiles.contains(selectedFile)) {
+					isVisible = true;
+				}
+				for (int index = 0; index < currentFilters.size() && isVisible; index++) {
+					isVisible = currentFilters.get(index).isVisible(treeViewer, selectedFile.getParent(), selectedFile);
+				}
+				if (isVisible) {
+					selectedFiles.add(selectedFile);
+				}
+			}
+		}
+
+		if (projectList.size() > 0) {
+			for (Object element : projectList) {
+				IProject selectedProject = (IProject) element;
+				try {
+					getNestedFiles(selectedProject.members());
+				} catch (CoreException e) {
+					Activator.log.error(e);
+				}
+			}
+		}
+
+		if (folderList.size() > 0) {
+			for (Object element : folderList) {
+				IFolder selectedFolder = (IFolder) element;
+				try {
+					getNestedFiles(selectedFolder.members());
+				} catch (CoreException e) {
+					Activator.log.error(e);
+				}
+			}
+		}
+	}
+
+	@Override
+	public void dispose() {
+		if (treeViewerListener != null) {
+			treeViewer.removeSelectionChangedListener(treeViewerListener);
+		}
+		super.dispose();
+	}
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/TransformationConfigPage.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/TransformationConfigPage.java
new file mode 100644
index 0000000..4c065d1
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/TransformationConfigPage.java
@@ -0,0 +1,73 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Quentin Le Menez (CEA LIST) quentin.lemenez@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.wizard.pages;
+
+import org.eclipse.jface.wizard.WizardPage;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+
+/**
+ * 
+ * Page displaying the selected elements and the migration's configuration options
+ * 
+ * @author Quentin Le Menez
+ *
+ */
+public class TransformationConfigPage extends WizardPage {
+
+	protected DialogDataConfigComposite dialogDataConfigComposite;
+
+	protected AbstractDialogData dialogData;
+
+
+	/**
+	 *
+	 * Constructor.
+	 * 
+	 * @param dialogData
+	 *            The instance used to get the previously selected files from both the settings file and the previous page selection,
+	 *            as well as the configuration used to display the transformation options
+	 */
+	public TransformationConfigPage(AbstractDialogData dialogData) {
+		super("Parameters selection");
+		setTitle("Define the transformation parameters");
+		setDescription("Select the files and the configuration options for the transformation");
+		// String iconPath = "icons/import_wiz_75x66.png"; //$NON-NLS-1$
+		// ImageDescriptor imgDescriptior = Activator.getDefault().getImageDescriptor(iconPath);
+		// setImageDescriptor(imgDescriptior);
+
+		this.dialogData = dialogData;
+	}
+
+	@Override
+	public void createControl(Composite parent) {
+		initializeDialogUnits(parent);
+		Composite pageComposite = new Composite(parent, SWT.NONE);
+		pageComposite.setLayout(new GridLayout());
+
+		dialogDataConfigComposite = new DialogDataConfigComposite(pageComposite, SWT.NONE, dialogData);
+
+		setControl(pageComposite);
+	}
+
+	/**
+	 * 
+	 * Used to update the input of the nested composite's viewer
+	 * 
+	 */
+	public void resetViewerInput() {
+		dialogDataConfigComposite.setViewerInput(dialogData.getAllSelectedFiles());
+	}
+
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/TransformationSelectionPage.java b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/TransformationSelectionPage.java
new file mode 100644
index 0000000..d1d69b6
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/src/org/eclipse/papyrus/interoperability/common/wizard/pages/TransformationSelectionPage.java
@@ -0,0 +1,59 @@
+/*****************************************************************************
+ * Copyright (c) 2014 CEA LIST.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Quentin Le Menez (CEA LIST) quentin.lemenez@cea.fr - Initial API and implementation
+ *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - bug 496176
+ *****************************************************************************/
+package org.eclipse.papyrus.interoperability.common.wizard.pages;
+
+import org.eclipse.jface.wizard.WizardPage;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+
+/**
+ * 
+ * Page displaying the workspace and its elements
+ * 
+ * @author Quentin Le Menez
+ *
+ */
+public class TransformationSelectionPage extends WizardPage {
+
+	protected AbstractDialogData dialogData;
+
+	/**
+	 *
+	 * Constructor.
+	 * 
+	 * @param dialogData
+	 *            The instance used to get the selection from the workspace and the filters
+	 */
+	public TransformationSelectionPage(AbstractDialogData dialogData) {
+		super("Workspace selection");
+		setTitle("Select a scope for the transformation");
+		setDescription("Select the folders or files for the transformation");
+		// String iconPath = "icons/import_wiz_75x66.png"; //$NON-NLS-1$
+		// ImageDescriptor imgDescriptior = Activator.getDefault().getImageDescriptor(iconPath);
+		// setImageDescriptor(imgDescriptior);
+
+		this.dialogData = dialogData;
+	}
+
+	@Override
+	public void createControl(Composite parent) {
+		initializeDialogUnits(parent);
+		Composite pageComposite = new Composite(parent, SWT.NONE);
+		pageComposite.setLayout(new GridLayout());
+
+		new DialogDataTreeComposite(pageComposite, SWT.NONE, dialogData);
+
+		setControl(pageComposite);
+	}
+}
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/ui/MigrationParameters.ecore b/common/plugins/org.eclipse.papyrus.interoperability.common/ui/MigrationParameters.ecore
new file mode 100644
index 0000000..d5107f3
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/ui/MigrationParameters.ecore
@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="MigrationParameters" nsURI="http:///MigrationParameters.ecore"
+    nsPrefix="MigrationParameters">
+  <eClassifiers xsi:type="ecore:EClass" name="AdvancedConfig" eSuperTypes="#//ThreadConfig">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="mappingParameters" ordered="false"
+        lowerBound="1" eType="#//MappingParameters" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="removeUnmappedDiagrams"
+        ordered="false" unique="false" lowerBound="1" eType="ecore:EDataType ../../org.eclipse.uml2.types/model/Types.ecore#//Boolean"
+        defaultValueLiteral="false">
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="documentation" value="If true, the diagrams which were not migrated will be removed. Otherwise, only the successfully imported diagrams will be removed"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="convertOpaqueExpressionToLiteralString"
+        ordered="false" unique="false" lowerBound="1" eType="ecore:EDataType ../../org.eclipse.uml2.types/model/Types.ecore#//Boolean"
+        defaultValueLiteral="true">
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="documentation" value="If true, the Opaque Expressions with a single body and no language (or a single empty language) will be converted to LiteralString"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="removeUnmappedProfilesAndStereotypes"
+        ordered="false" unique="false" lowerBound="1" eType="ecore:EDataType ../../org.eclipse.uml2.types/model/Types.ecore#//Boolean"
+        defaultValueLiteral="false">
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="documentation" value="If true, all unsupported RSA profiles and stereotypes will be deleted at the end of the transformation"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="removeUnmappedAnnotations"
+        ordered="false" unique="false" lowerBound="1" eType="ecore:EDataType ../../org.eclipse.uml2.types/model/Types.ecore#//Boolean"
+        defaultValueLiteral="false">
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="documentation" value="If true, the unmapped RSA EAnnotations will be deleted from the imported model"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="alwaysAcceptSuggestedMappings"
+        ordered="false" lowerBound="1" eType="ecore:EDataType ../../org.eclipse.uml2.types/model/Types.ecore#//Boolean"
+        defaultValueLiteral="false">
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="documentation" value="If true, the Transformation will not open a dialog to ask user-confirmation for the dependency mappings. The tool will automatically keep going by &quot;guessing&quot; the proper mapping"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="ThreadConfig">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" ordered="false" lowerBound="1"
+        eType="ecore:EDataType ../../org.eclipse.uml2.types/model/Types.ecore#//String"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="maxThreads" ordered="false"
+        unique="false" lowerBound="1" eType="ecore:EDataType ../../org.eclipse.uml2.types/model/Types.ecore#//Integer"
+        defaultValueLiteral="2">
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="documentation" value="The maximum number of threads to use during the migration.&#xD;&#xA;More threads will provide faster results, at the cost of memory consumption."/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="MappingParameters">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="uriMappings" ordered="false"
+        upperBound="-1" eType="#//URIMapping" containment="true">
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="documentation" value="When models/libraries have been migrated separately, maps the libraries imported from RSA to their Papyrus equivalent"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="profileUriMappings" ordered="false"
+        upperBound="-1" eType="#//URIMapping" containment="true">
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="documentation" value="When profiles have been migrated separately, maps the profiles imported from RSA to their Papyrus equivalent"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="URIMapping">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="sourceURI" ordered="false"
+        unique="false" lowerBound="1" eType="ecore:EDataType ../../org.eclipse.uml2.types/model/Types.ecore#//String"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="targetURI" ordered="false"
+        unique="false" lowerBound="1" eType="ecore:EDataType ../../org.eclipse.uml2.types/model/Types.ecore#//String"/>
+  </eClassifiers>
+</ecore:EPackage>
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/ui/migrationParameters.di b/common/plugins/org.eclipse.papyrus.interoperability.common/ui/migrationParameters.di
new file mode 100644
index 0000000..bf9abab
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/ui/migrationParameters.di
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xmi:XMI xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI"/>
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/ui/migrationParameters.genmodel b/common/plugins/org.eclipse.papyrus.interoperability.common/ui/migrationParameters.genmodel
new file mode 100644
index 0000000..0791ca8
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/ui/migrationParameters.genmodel
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:genmodel="http://www.eclipse.org/uml2/2.2.0/GenModel"
+    copyrightText="Copyright (c) 2014 CEA LIST.&#xD;&#xA;&#xD;&#xA;All rights reserved. This program and the accompanying materials&#xD;&#xA;are made available under the terms of the Eclipse Public License v1.0&#xD;&#xA;which accompanies this distribution, and is available at&#xD;&#xA;http://www.eclipse.org/legal/epl-v10.html&#xD;&#xA;&#xD;&#xA;Contributors:&#xD;&#xA;  Camille Letavernier (CEA LIST) camille.letavernier@cea.fr - Initial API and implementation&#xD;&#xA;  Vincent Lorenzo (CEA-LIST) vincent.lorenzo@cea.fr - bug 496176&#xD;&#xA;"
+    modelDirectory="/org.eclipse.papyrus.interoperability.common/src-gen" editDirectory="/org.eclipse.papyrus.interoperability.common.edit/src-gen"
+    editorDirectory="/org.eclipse.papyrus.interoperability.common.editor/src-gen"
+    modelPluginID="org.eclipse.papyrus.interoperability.common" modelName="MigrationParameters"
+    editPluginClass="org.eclipse.papyrus.interoperability.common.edit.MigrationParameters.provider.MigrationParametersEditPlugin"
+    editorPluginClass="org.eclipse.papyrus.interoperability.common.editor.MigrationParameters.presentation.MigrationParametersEditorPlugin"
+    nonNLSMarkers="true" rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container"
+    testsDirectory="/org.eclipse.papyrus.interoperability.common.tests/src-gen" testSuiteClass="org.eclipse.papyrus.interoperability.common.tests.MigrationParameters.tests.MigrationParametersAllTests"
+    importerID="org.eclipse.uml2.uml.ecore.importer" complianceLevel="8.0" copyrightFields="false"
+    providerRootExtendsClass="" editPluginID="org.eclipse.papyrus.interoperability.common.edit"
+    editorPluginID="org.eclipse.papyrus.interoperability.common.editor" usedGenPackages="../../org.eclipse.uml2.types/model/Types.genmodel#//types"
+    operationReflection="true" importOrganizing="true" oSGiCompatible="true">
+  <genAnnotations source="http://www.eclipse.org/emf/2002/GenModel/importer/org.eclipse.uml2.uml.ecore.importer">
+    <details key="OPPOSITE_ROLE_NAMES" value="IGNORE"/>
+    <details key="DUPLICATE_FEATURES" value="DISCARD"/>
+    <details key="ANNOTATION_DETAILS" value="PROCESS"/>
+    <details key="PROPERTY_DEFAULT_EXPRESSIONS" value="IGNORE"/>
+    <details key="DUPLICATE_FEATURE_INHERITANCE" value="DISCARD"/>
+    <details key="COMMENTS" value="PROCESS"/>
+    <details key="DERIVED_FEATURES" value="PROCESS"/>
+    <details key="SUPER_CLASS_ORDER" value="PROCESS"/>
+    <details key="DUPLICATE_OPERATION_INHERITANCE" value="DISCARD"/>
+    <details key="REDEFINING_OPERATIONS" value="REPORT"/>
+    <details key="INVARIANT_CONSTRAINTS" value="PROCESS"/>
+    <details key="UNION_PROPERTIES" value="REPORT"/>
+    <details key="DUPLICATE_OPERATIONS" value="DISCARD"/>
+    <details key="NON_API_INVARIANTS" value="IGNORE"/>
+    <details key="CAMEL_CASE_NAMES" value="IGNORE"/>
+    <details key="SUBSETTING_PROPERTIES" value="REPORT"/>
+    <details key="OPERATION_BODIES" value="IGNORE"/>
+    <details key="ECORE_TAGGED_VALUES" value="PROCESS"/>
+    <details key="UNTYPED_PROPERTIES" value="REPORT"/>
+    <details key="REDEFINING_PROPERTIES" value="REPORT"/>
+    <details key="INVOCATION_DELEGATES" value="IGNORE"/>
+    <details key="VALIDATION_DELEGATES" value="IGNORE"/>
+  </genAnnotations>
+  <foreignModel>migrationParameters.uml</foreignModel>
+  <genPackages xsi:type="genmodel:GenPackage" prefix="MigrationParameters" basePackage="org.eclipse.papyrus.interoperability.common"
+      disposableProviderFactory="true" ecorePackage="MigrationParameters.ecore#/">
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="MigrationParameters.ecore#//AdvancedConfig">
+      <genFeatures xsi:type="genmodel:GenFeature" property="None" children="true"
+          createChild="true" ecoreFeature="ecore:EReference MigrationParameters.ecore#//AdvancedConfig/mappingParameters"/>
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute MigrationParameters.ecore#//AdvancedConfig/removeUnmappedDiagrams"/>
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute MigrationParameters.ecore#//AdvancedConfig/convertOpaqueExpressionToLiteralString"/>
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute MigrationParameters.ecore#//AdvancedConfig/removeUnmappedProfilesAndStereotypes"/>
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute MigrationParameters.ecore#//AdvancedConfig/removeUnmappedAnnotations"/>
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute MigrationParameters.ecore#//AdvancedConfig/alwaysAcceptSuggestedMappings"/>
+    </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="MigrationParameters.ecore#//ThreadConfig">
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute MigrationParameters.ecore#//ThreadConfig/name"/>
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute MigrationParameters.ecore#//ThreadConfig/maxThreads"/>
+    </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="MigrationParameters.ecore#//MappingParameters">
+      <genFeatures xsi:type="genmodel:GenFeature" property="None" children="true"
+          createChild="true" ecoreFeature="ecore:EReference MigrationParameters.ecore#//MappingParameters/uriMappings"/>
+      <genFeatures xsi:type="genmodel:GenFeature" property="None" children="true"
+          createChild="true" ecoreFeature="ecore:EReference MigrationParameters.ecore#//MappingParameters/profileUriMappings"/>
+    </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="MigrationParameters.ecore#//URIMapping">
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute MigrationParameters.ecore#//URIMapping/sourceURI"/>
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute MigrationParameters.ecore#//URIMapping/targetURI"/>
+    </genClasses>
+  </genPackages>
+</genmodel:GenModel>
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/ui/migrationParameters.notation b/common/plugins/org.eclipse.papyrus.interoperability.common/ui/migrationParameters.notation
new file mode 100644
index 0000000..2aa1d57
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/ui/migrationParameters.notation
@@ -0,0 +1,246 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xmi:XMI xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:css="http://www.eclipse.org/papyrus/infra/gmfdiag/css" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:notation="http://www.eclipse.org/gmf/runtime/1.0.2/notation" xmlns:style="http://www.eclipse.org/papyrus/infra/viewpoints/policy/style" xmlns:uml="http://www.eclipse.org/uml2/5.0.0/UML">
+  <notation:Diagram xmi:id="_ffjeAEL1EeSSlqpbHKLCqA" type="PapyrusUMLClassDiagram" name="Config" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_tKu0kUL1EeSSlqpbHKLCqA" type="Class_Shape">
+      <children xmi:type="notation:DecorationNode" xmi:id="_tKu0k0L1EeSSlqpbHKLCqA" type="Class_NameLabel"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_tKu0lEL1EeSSlqpbHKLCqA" type="Class_AttributeCompartment">
+        <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_So1agHZLEeSwiJkQAQl2Jg" source="PapyrusCSSForceValue">
+          <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_So1agXZLEeSwiJkQAQl2Jg" key="visible" value="true"/>
+        </eAnnotations>
+        <children xmi:type="notation:Shape" xmi:id="_AblmMFOJEeSGbsrkEkSKIA" type="Property_ClassAttributeLabel">
+          <styles xmi:type="notation:StringListValueStyle" xmi:id="_GLzRUFOJEeSGbsrkEkSKIA" name="maskLabel">
+            <stringListValue>visibility</stringListValue>
+            <stringListValue>name</stringListValue>
+            <stringListValue>derived</stringListValue>
+            <stringListValue>multiplicity</stringListValue>
+            <stringListValue>defaultValue</stringListValue>
+            <stringListValue>type</stringListValue>
+          </styles>
+          <element xmi:type="uml:Property" href="migrationParameters.uml#_AYwUoFOJEeSGbsrkEkSKIA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_AblmMVOJEeSGbsrkEkSKIA"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_WuBhgEL2EeSSlqpbHKLCqA" type="Property_ClassAttributeLabel">
+          <styles xmi:type="notation:StringListValueStyle" xmi:id="_aEtJcEL2EeSSlqpbHKLCqA" name="maskLabel">
+            <stringListValue>visibility</stringListValue>
+            <stringListValue>name</stringListValue>
+            <stringListValue>derived</stringListValue>
+            <stringListValue>multiplicity</stringListValue>
+            <stringListValue>defaultValue</stringListValue>
+            <stringListValue>type</stringListValue>
+          </styles>
+          <element xmi:type="uml:Property" href="migrationParameters.uml#_Wt4XkEL2EeSSlqpbHKLCqA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_WuBhgUL2EeSSlqpbHKLCqA"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_t5AP0EL1EeSSlqpbHKLCqA" type="Property_ClassAttributeLabel">
+          <styles xmi:type="notation:StringListValueStyle" xmi:id="_Ko_pYEL2EeSSlqpbHKLCqA" name="maskLabel">
+            <stringListValue>visibility</stringListValue>
+            <stringListValue>name</stringListValue>
+            <stringListValue>derived</stringListValue>
+            <stringListValue>multiplicity</stringListValue>
+            <stringListValue>defaultValue</stringListValue>
+            <stringListValue>type</stringListValue>
+          </styles>
+          <element xmi:type="uml:Property" href="migrationParameters.uml#_t42e0EL1EeSSlqpbHKLCqA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_t5AP0UL1EeSSlqpbHKLCqA"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_65zMoEL1EeSSlqpbHKLCqA" type="Property_ClassAttributeLabel">
+          <styles xmi:type="notation:StringListValueStyle" xmi:id="_KNn8AEL2EeSSlqpbHKLCqA" name="maskLabel">
+            <stringListValue>visibility</stringListValue>
+            <stringListValue>name</stringListValue>
+            <stringListValue>derived</stringListValue>
+            <stringListValue>multiplicity</stringListValue>
+            <stringListValue>defaultValue</stringListValue>
+            <stringListValue>type</stringListValue>
+          </styles>
+          <element xmi:type="uml:Property" href="migrationParameters.uml#_65pboEL1EeSSlqpbHKLCqA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_65zMoUL1EeSSlqpbHKLCqA"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_Mv8HwUL2EeSSlqpbHKLCqA" type="Property_ClassAttributeLabel">
+          <styles xmi:type="notation:StringListValueStyle" xmi:id="_VFcaIEL2EeSSlqpbHKLCqA" name="maskLabel">
+            <stringListValue>visibility</stringListValue>
+            <stringListValue>name</stringListValue>
+            <stringListValue>derived</stringListValue>
+            <stringListValue>multiplicity</stringListValue>
+            <stringListValue>defaultValue</stringListValue>
+            <stringListValue>type</stringListValue>
+          </styles>
+          <element xmi:type="uml:Property" href="migrationParameters.uml#_Mv8HwEL2EeSSlqpbHKLCqA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_Mv8HwkL2EeSSlqpbHKLCqA"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_JWjgUXcbEeSwiJkQAQl2Jg" type="Property_ClassAttributeLabel">
+          <styles xmi:type="notation:StringListValueStyle" xmi:id="_Ro7mMHcbEeSwiJkQAQl2Jg" name="maskLabel">
+            <stringListValue>visibility</stringListValue>
+            <stringListValue>name</stringListValue>
+            <stringListValue>derived</stringListValue>
+            <stringListValue>multiplicity</stringListValue>
+            <stringListValue>defaultValue</stringListValue>
+            <stringListValue>type</stringListValue>
+          </styles>
+          <element xmi:type="uml:Property" href="migrationParameters.uml#_JWjgUHcbEeSwiJkQAQl2Jg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_JWjgUncbEeSwiJkQAQl2Jg"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_tKu0lUL1EeSSlqpbHKLCqA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_tKu0lkL1EeSSlqpbHKLCqA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_tKu0l0L1EeSSlqpbHKLCqA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_tKu0mEL1EeSSlqpbHKLCqA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_tKu0mUL1EeSSlqpbHKLCqA" visible="false" type="Class_OperationCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_tKu0mkL1EeSSlqpbHKLCqA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_tKu0m0L1EeSSlqpbHKLCqA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_tKu0nEL1EeSSlqpbHKLCqA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_tKu0nUL1EeSSlqpbHKLCqA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_tKu0nkL1EeSSlqpbHKLCqA" visible="false" type="Class_NestedClassifierCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_tKu0n0L1EeSSlqpbHKLCqA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_tKu0oEL1EeSSlqpbHKLCqA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_tKu0oUL1EeSSlqpbHKLCqA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_tKu0okL1EeSSlqpbHKLCqA"/>
+      </children>
+      <element xmi:type="uml:Class" href="migrationParameters.uml#_tKu0kEL1EeSSlqpbHKLCqA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_tKu0kkL1EeSSlqpbHKLCqA" x="81" y="524" width="373" height="129"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_MDv8IFOJEeSGbsrkEkSKIA" type="DataType_Shape">
+      <children xmi:type="notation:DecorationNode" xmi:id="_MDv8IlOJEeSGbsrkEkSKIA" type="DataType_NameLabel"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_MDv8I1OJEeSGbsrkEkSKIA" type="DataType_AttributeCompartment">
+        <children xmi:type="notation:Shape" xmi:id="_MiP2AVOJEeSGbsrkEkSKIA" type="Property_DataTypeAttributeLabel">
+          <element xmi:type="uml:Property" href="migrationParameters.uml#_MiP2AFOJEeSGbsrkEkSKIA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_MiP2AlOJEeSGbsrkEkSKIA"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_O-nKwFOJEeSGbsrkEkSKIA" type="Property_DataTypeAttributeLabel">
+          <element xmi:type="uml:Property" href="migrationParameters.uml#_O-dZwFOJEeSGbsrkEkSKIA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_O-nKwVOJEeSGbsrkEkSKIA"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_MDv8JFOJEeSGbsrkEkSKIA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_MDv8JVOJEeSGbsrkEkSKIA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_MDv8JlOJEeSGbsrkEkSKIA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_MDv8J1OJEeSGbsrkEkSKIA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_MDv8KFOJEeSGbsrkEkSKIA" visible="false" type="DataType_OperationCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_MDv8KVOJEeSGbsrkEkSKIA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_MDv8KlOJEeSGbsrkEkSKIA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_MDv8K1OJEeSGbsrkEkSKIA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_MDv8LFOJEeSGbsrkEkSKIA"/>
+      </children>
+      <element xmi:type="uml:DataType" href="migrationParameters.uml#_MDmyMFOJEeSGbsrkEkSKIA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_MDv8IVOJEeSGbsrkEkSKIA" x="497" y="715" height="112"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_erBPcXZKEeSwiJkQAQl2Jg" type="Class_Shape">
+      <children xmi:type="notation:DecorationNode" xmi:id="_erBPc3ZKEeSwiJkQAQl2Jg" type="Class_NameLabel"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_erBPdHZKEeSwiJkQAQl2Jg" type="Class_AttributeCompartment">
+        <children xmi:type="notation:Shape" xmi:id="_LgpPEVOJEeSGbsrkEkSKIA" type="Property_ClassAttributeLabel">
+          <element xmi:type="uml:Property" href="migrationParameters.uml#_LgpPEFOJEeSGbsrkEkSKIA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_LgpPElOJEeSGbsrkEkSKIA"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_pSQoEIQ5EeSC0ajaKNekyw" type="Property_ClassAttributeLabel">
+          <element xmi:type="uml:Property" href="migrationParameters.uml#_pR2YYIQ5EeSC0ajaKNekyw"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_pSQoEYQ5EeSC0ajaKNekyw"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_erBPdXZKEeSwiJkQAQl2Jg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_erBPdnZKEeSwiJkQAQl2Jg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_erBPd3ZKEeSwiJkQAQl2Jg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_erBPeHZKEeSwiJkQAQl2Jg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_erBPeXZKEeSwiJkQAQl2Jg" visible="false" type="Class_OperationCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_erBPenZKEeSwiJkQAQl2Jg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_erBPe3ZKEeSwiJkQAQl2Jg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_erBPfHZKEeSwiJkQAQl2Jg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_erBPfXZKEeSwiJkQAQl2Jg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_erBPfnZKEeSwiJkQAQl2Jg" visible="false" type="Class_NestedClassifierCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_erBPf3ZKEeSwiJkQAQl2Jg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_erBPgHZKEeSwiJkQAQl2Jg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_erBPgXZKEeSwiJkQAQl2Jg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_erBPgnZKEeSwiJkQAQl2Jg"/>
+      </children>
+      <element xmi:type="uml:Class" href="migrationParameters.uml#_erBPcHZKEeSwiJkQAQl2Jg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_erBPcnZKEeSwiJkQAQl2Jg" x="81" y="717" width="373" height="112"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_COs8QLiZEeapppGB0acXuA" type="Class_Shape">
+      <children xmi:type="notation:DecorationNode" xmi:id="_COs8QriZEeapppGB0acXuA" type="Class_NameLabel"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_COs8Q7iZEeapppGB0acXuA" type="Class_FloatingNameLabel">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_COtjULiZEeapppGB0acXuA" y="5"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_COtjUbiZEeapppGB0acXuA" type="Class_AttributeCompartment">
+        <children xmi:type="notation:Shape" xmi:id="_Fb6fILiZEeapppGB0acXuA" type="Property_ClassAttributeLabel">
+          <element xmi:type="uml:Property" href="migrationParameters.uml#_AYwUoFOJEeSGbsrkEkSKIA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_Fb6fIbiZEeapppGB0acXuA"/>
+        </children>
+        <children xmi:type="notation:Shape" xmi:id="_pOLPULieEeaGJtvDcJNNGA" type="Property_ClassAttributeLabel">
+          <element xmi:type="uml:Property" href="migrationParameters.uml#_-z_I4LiYEeapppGB0acXuA"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_pOLPUbieEeaGJtvDcJNNGA"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_COtjUriZEeapppGB0acXuA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_COtjU7iZEeapppGB0acXuA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_COtjVLiZEeapppGB0acXuA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_COtjVbiZEeapppGB0acXuA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_COtjVriZEeapppGB0acXuA" type="Class_OperationCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_COtjV7iZEeapppGB0acXuA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_COtjWLiZEeapppGB0acXuA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_COtjWbiZEeapppGB0acXuA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_COtjWriZEeapppGB0acXuA"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_COtjW7iZEeapppGB0acXuA" type="Class_NestedClassifierCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_COtjXLiZEeapppGB0acXuA"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_COtjXbiZEeapppGB0acXuA"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_COtjXriZEeapppGB0acXuA"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_COtjX7iZEeapppGB0acXuA"/>
+      </children>
+      <element xmi:type="uml:Class" href="migrationParameters.uml#_COqgALiZEeapppGB0acXuA"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_COs8QbiZEeapppGB0acXuA" x="167" y="240"/>
+    </children>
+    <styles xmi:type="notation:StringValueStyle" xmi:id="_ffjeAUL1EeSSlqpbHKLCqA" name="diagram_compatibility_version" stringValue="1.2.0"/>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_ffjeAkL1EeSSlqpbHKLCqA"/>
+    <styles xmi:type="style:PapyrusViewStyle" xmi:id="_ffjeA0L1EeSSlqpbHKLCqA">
+      <owner xmi:type="uml:Model" href="migrationParameters.uml#_fduSAEL1EeSSlqpbHKLCqA"/>
+    </styles>
+    <element xmi:type="uml:Model" href="migrationParameters.uml#_fduSAEL1EeSSlqpbHKLCqA"/>
+    <edges xmi:type="notation:Connector" xmi:id="_sluPwHZKEeSwiJkQAQl2Jg" type="Association_Edge" source="_tKu0kUL1EeSSlqpbHKLCqA" target="_erBPcXZKEeSwiJkQAQl2Jg" routing="Rectilinear">
+      <children xmi:type="notation:DecorationNode" xmi:id="_sluPw3ZKEeSwiJkQAQl2Jg" type="Association_StereotypeLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_P8QRYLiZEeapppGB0acXuA" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_sluPxHZKEeSwiJkQAQl2Jg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_sluPxXZKEeSwiJkQAQl2Jg" type="Association_NameLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_P8h-MLiZEeapppGB0acXuA" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_sluPxnZKEeSwiJkQAQl2Jg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_sluPx3ZKEeSwiJkQAQl2Jg" visible="false" type="Association_TargetRoleLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_P8vZkLiZEeapppGB0acXuA" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_sluPyHZKEeSwiJkQAQl2Jg" x="10" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_sluPyXZKEeSwiJkQAQl2Jg" type="Association_SourceRoleLabel">
+        <styles xmi:type="notation:StringListValueStyle" xmi:id="_9TsB4HZKEeSwiJkQAQl2Jg" name="maskLabel">
+          <stringListValue>name</stringListValue>
+          <stringListValue>derived</stringListValue>
+          <stringListValue>multiplicity</stringListValue>
+        </styles>
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_P9SzMLiZEeapppGB0acXuA" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_sluPynZKEeSwiJkQAQl2Jg" x="-40" y="77"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_sluPy3ZKEeSwiJkQAQl2Jg" visible="false" type="Association_SourceMultiplicityLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_P9bWELiZEeapppGB0acXuA" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_sluPzHZKEeSwiJkQAQl2Jg" x="10" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_sluPzXZKEeSwiJkQAQl2Jg" visible="false" type="Association_TargetMultiplicityLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_P9jR4LiZEeapppGB0acXuA" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_sluPznZKEeSwiJkQAQl2Jg" x="-38" y="-38"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_sluPwXZKEeSwiJkQAQl2Jg"/>
+      <element xmi:type="uml:Association" href="migrationParameters.uml#_slkew3ZKEeSwiJkQAQl2Jg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_sluPwnZKEeSwiJkQAQl2Jg" points="[257, 653, -643984, -643984]$[257, 717, -643984, -643984]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_sl4AwHZKEeSwiJkQAQl2Jg" id="(0.47257383966244726,0.9642857142857143)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_5rS-4HZKEeSwiJkQAQl2Jg" id="(0.4718498659517426,0.0)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_TUWOkLiZEeapppGB0acXuA" type="Generalization_Edge" source="_tKu0kUL1EeSSlqpbHKLCqA" target="_COs8QLiZEeapppGB0acXuA">
+      <children xmi:type="notation:DecorationNode" xmi:id="_TUWOk7iZEeapppGB0acXuA" type="Generalization_StereotypeLabel">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_TUWOlLiZEeapppGB0acXuA" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_TUWOkbiZEeapppGB0acXuA"/>
+      <element xmi:type="uml:Generalization" href="migrationParameters.uml#_TUKoYLiZEeapppGB0acXuA"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_TUWOkriZEeapppGB0acXuA" points="[258, 524, -643984, -643984]$[258, 340, -643984, -643984]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_TUnUULiZEeapppGB0acXuA" id="(0.4745308310991957,0.0)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_TUnUUbiZEeapppGB0acXuA" id="(0.5449101796407185,1.0)"/>
+    </edges>
+  </notation:Diagram>
+  <css:ModelStyleSheets xmi:id="_n2Dv0IQ5EeSC0ajaKNekyw"/>
+</xmi:XMI>
diff --git a/common/plugins/org.eclipse.papyrus.interoperability.common/ui/migrationParameters.uml b/common/plugins/org.eclipse.papyrus.interoperability.common/ui/migrationParameters.uml
new file mode 100644
index 0000000..49af745
--- /dev/null
+++ b/common/plugins/org.eclipse.papyrus.interoperability.common/ui/migrationParameters.uml
@@ -0,0 +1,107 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<uml:Model xmi:version="20131001" xmlns:xmi="http://www.omg.org/spec/XMI/20131001" xmlns:uml="http://www.eclipse.org/uml2/5.0.0/UML" xmi:id="_fduSAEL1EeSSlqpbHKLCqA" name="MigrationParameters">
+  <packageImport xmi:type="uml:PackageImport" xmi:id="_fduSAUL1EeSSlqpbHKLCqA">
+    <importedPackage xmi:type="uml:Model" href="pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml#_0"/>
+  </packageImport>
+  <packagedElement xmi:type="uml:Class" xmi:id="_tKu0kEL1EeSSlqpbHKLCqA" name="AdvancedConfig">
+    <generalization xmi:type="uml:Generalization" xmi:id="_TUKoYLiZEeapppGB0acXuA" general="_COqgALiZEeapppGB0acXuA"/>
+    <ownedAttribute xmi:type="uml:Property" xmi:id="_slkewHZKEeSwiJkQAQl2Jg" name="mappingParameters" type="_erBPcHZKEeSwiJkQAQl2Jg" aggregation="composite" association="_slkew3ZKEeSwiJkQAQl2Jg">
+      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_slkewXZKEeSwiJkQAQl2Jg" value="1"/>
+      <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_slkewnZKEeSwiJkQAQl2Jg" value="1"/>
+    </ownedAttribute>
+    <ownedAttribute xmi:type="uml:Property" xmi:id="_Wt4XkEL2EeSSlqpbHKLCqA" name="removeUnmappedDiagrams" visibility="public" isUnique="false">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_YchfIEMAEeSX267OQHSClQ" annotatedElement="_Wt4XkEL2EeSSlqpbHKLCqA">
+        <body>If true, the diagrams which were not migrated will be removed. Otherwise, only the successfully imported diagrams will be removed</body>
+      </ownedComment>
+      <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml#Boolean"/>
+      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_Yj3BwEL2EeSSlqpbHKLCqA" value="1"/>
+      <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_Yj3BwUL2EeSSlqpbHKLCqA" value="1"/>
+      <defaultValue xmi:type="uml:LiteralBoolean" xmi:id="_Zf9doEL2EeSSlqpbHKLCqA"/>
+    </ownedAttribute>
+    <ownedAttribute xmi:type="uml:Property" xmi:id="_t42e0EL1EeSSlqpbHKLCqA" name="convertOpaqueExpressionToLiteralString" visibility="public" isUnique="false">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_sSSQAEL9EeSX267OQHSClQ" annotatedElement="_t42e0EL1EeSSlqpbHKLCqA">
+        <body>If true, the Opaque Expressions with a single body and no language (or a single empty language) will be converted to LiteralString</body>
+      </ownedComment>
+      <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml#Boolean"/>
+      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_0H-TgEL1EeSSlqpbHKLCqA" value="1"/>
+      <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_0IHdcEL1EeSSlqpbHKLCqA" value="1"/>
+      <defaultValue xmi:type="uml:LiteralBoolean" xmi:id="_3f1nMEL1EeSSlqpbHKLCqA" value="true"/>
+    </ownedAttribute>
+    <ownedAttribute xmi:type="uml:Property" xmi:id="_65pboEL1EeSSlqpbHKLCqA" name="removeUnmappedProfilesAndStereotypes" visibility="public" isUnique="false">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_zDs5cEL9EeSX267OQHSClQ" annotatedElement="_65pboEL1EeSSlqpbHKLCqA">
+        <body>If true, all unsupported RSA profiles and stereotypes will be deleted at the end of the transformation</body>
+      </ownedComment>
+      <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml#Boolean"/>
+      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_Gy7WwEL2EeSSlqpbHKLCqA" value="1"/>
+      <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_Gy7WwUL2EeSSlqpbHKLCqA" value="1"/>
+      <defaultValue xmi:type="uml:LiteralBoolean" xmi:id="_H7rHgEL2EeSSlqpbHKLCqA"/>
+    </ownedAttribute>
+    <ownedAttribute xmi:type="uml:Property" xmi:id="_Mv8HwEL2EeSSlqpbHKLCqA" name="removeUnmappedAnnotations" visibility="public" isUnique="false">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_rogy4EMAEeSX267OQHSClQ" annotatedElement="_Mv8HwEL2EeSSlqpbHKLCqA">
+        <body>If true, the unmapped RSA EAnnotations will be deleted from the imported model</body>
+      </ownedComment>
+      <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml#Boolean"/>
+      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_S39O4EL2EeSSlqpbHKLCqA" value="1"/>
+      <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_S39O4UL2EeSSlqpbHKLCqA" value="1"/>
+      <defaultValue xmi:type="uml:LiteralBoolean" xmi:id="_UQehAEL2EeSSlqpbHKLCqA"/>
+    </ownedAttribute>
+    <ownedAttribute xmi:type="uml:Property" xmi:id="_JWjgUHcbEeSwiJkQAQl2Jg" name="alwaysAcceptSuggestedMappings" visibility="public">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_aOft0HcbEeSwiJkQAQl2Jg" annotatedElement="_JWjgUHcbEeSwiJkQAQl2Jg">
+        <body>If true, the Transformation will not open a dialog to ask user-confirmation for the dependency mappings. The tool will automatically keep going by &quot;guessing&quot; the proper mapping</body>
+      </ownedComment>
+      <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml#Boolean"/>
+      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_P_5L0HcbEeSwiJkQAQl2Jg" value="1"/>
+      <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_P_5L0XcbEeSwiJkQAQl2Jg" value="1"/>
+      <defaultValue xmi:type="uml:LiteralBoolean" xmi:id="_P_5L0ncbEeSwiJkQAQl2Jg"/>
+    </ownedAttribute>
+  </packagedElement>
+  <packagedElement xmi:type="uml:DataType" xmi:id="_MDmyMFOJEeSGbsrkEkSKIA" name="URIMapping">
+    <ownedAttribute xmi:type="uml:Property" xmi:id="_MiP2AFOJEeSGbsrkEkSKIA" name="sourceURI" visibility="public" isUnique="false">
+      <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml#String"/>
+      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_OrbJAFOJEeSGbsrkEkSKIA" value="1"/>
+      <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_OrbJAVOJEeSGbsrkEkSKIA" value="1"/>
+    </ownedAttribute>
+    <ownedAttribute xmi:type="uml:Property" xmi:id="_O-dZwFOJEeSGbsrkEkSKIA" name="targetURI" visibility="public" isUnique="false">
+      <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml#String"/>
+      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_RAos4FOJEeSGbsrkEkSKIA" value="1"/>
+      <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_RAos4VOJEeSGbsrkEkSKIA" value="1"/>
+    </ownedAttribute>
+  </packagedElement>
+  <packagedElement xmi:type="uml:Class" xmi:id="_erBPcHZKEeSwiJkQAQl2Jg" name="MappingParameters">
+    <ownedAttribute xmi:type="uml:Property" xmi:id="_LgpPEFOJEeSGbsrkEkSKIA" name="uriMappings" visibility="public" type="_MDmyMFOJEeSGbsrkEkSKIA" aggregation="composite">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_iBwD0GW5EeS5_vjAduszYQ" annotatedElement="_LgpPEFOJEeSGbsrkEkSKIA">
+        <body>When models/libraries have been migrated separately, maps the libraries imported from RSA to their Papyrus equivalent</body>
+      </ownedComment>
+      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_T5kB0FOJEeSGbsrkEkSKIA"/>
+      <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_T5kB0VOJEeSGbsrkEkSKIA" value="*"/>
+    </ownedAttribute>
+    <ownedAttribute xmi:type="uml:Property" xmi:id="_pR2YYIQ5EeSC0ajaKNekyw" name="profileUriMappings" visibility="public" type="_MDmyMFOJEeSGbsrkEkSKIA" aggregation="composite">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_49zT4IQ5EeSC0ajaKNekyw" annotatedElement="_pR2YYIQ5EeSC0ajaKNekyw">
+        <body>When profiles have been migrated separately, maps the profiles imported from RSA to their Papyrus equivalent</body>
+      </ownedComment>
+      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_qweSgIQ5EeSC0ajaKNekyw"/>
+      <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_qwfgoIQ5EeSC0ajaKNekyw" value="*"/>
+    </ownedAttribute>
+  </packagedElement>
+  <packagedElement xmi:type="uml:Association" xmi:id="_slkew3ZKEeSwiJkQAQl2Jg" memberEnd="_slkexHZKEeSwiJkQAQl2Jg _slkewHZKEeSwiJkQAQl2Jg">
+    <ownedEnd xmi:type="uml:Property" xmi:id="_slkexHZKEeSwiJkQAQl2Jg" name="config" type="_tKu0kEL1EeSSlqpbHKLCqA" association="_slkew3ZKEeSwiJkQAQl2Jg">
+      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_slkexXZKEeSwiJkQAQl2Jg" value="1"/>
+      <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_slkexnZKEeSwiJkQAQl2Jg" value="1"/>
+    </ownedEnd>
+  </packagedElement>
+  <packagedElement xmi:type="uml:Class" xmi:id="_COqgALiZEeapppGB0acXuA" name="ThreadConfig">
+    <ownedAttribute xmi:type="uml:Property" xmi:id="_-z_I4LiYEeapppGB0acXuA" name="name">
+      <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml#String"/>
+    </ownedAttribute>
+    <ownedAttribute xmi:type="uml:Property" xmi:id="_AYwUoFOJEeSGbsrkEkSKIA" name="maxThreads" visibility="public" isUnique="false">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_W1iDAGW5EeS5_vjAduszYQ" annotatedElement="_AYwUoFOJEeSGbsrkEkSKIA">
+        <body>The maximum number of threads to use during the migration.&#xD;
+More threads will provide faster results, at the cost of memory consumption.</body>
+      </ownedComment>
+      <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml#Integer"/>
+      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_DhmU4FOJEeSGbsrkEkSKIA" value="1"/>
+      <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_DhwF4FOJEeSGbsrkEkSKIA" value="1"/>
+      <defaultValue xmi:type="uml:LiteralInteger" xmi:id="_E7A-4FOJEeSGbsrkEkSKIA" value="2"/>
+    </ownedAttribute>
+  </packagedElement>
+</uml:Model>
