diff --git a/org.eclipse.mylyn.context.ui/.classpath b/org.eclipse.mylyn.context.ui/.classpath
deleted file mode 100644
index 45ae018..0000000
--- a/org.eclipse.mylyn.context.ui/.classpath
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins">
-		<accessrules>
-			<accessrule kind="accessible" pattern="**/internal/**"/>
-		</accessrules>
-	</classpathentry>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5">
-		<accessrules>
-			<accessrule kind="nonaccessible" pattern="com/sun/**"/>
-		</accessrules>
-	</classpathentry>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/org.eclipse.mylyn.context.ui/.cvsignore b/org.eclipse.mylyn.context.ui/.cvsignore
deleted file mode 100644
index ba077a4..0000000
--- a/org.eclipse.mylyn.context.ui/.cvsignore
+++ /dev/null
@@ -1 +0,0 @@
-bin
diff --git a/org.eclipse.mylyn.context.ui/.project b/org.eclipse.mylyn.context.ui/.project
deleted file mode 100644
index 396aed1..0000000
--- a/org.eclipse.mylyn.context.ui/.project
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.mylar.ui</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/org.eclipse.mylyn.context.ui/.settings/org.eclipse.jdt.core.prefs b/org.eclipse.mylyn.context.ui/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 668b6cc..0000000
--- a/org.eclipse.mylyn.context.ui/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,303 +0,0 @@
-#Mon Feb 13 11:20:16 PST 2006
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.5
-org.eclipse.jdt.core.compiler.debug.lineNumber=generate
-org.eclipse.jdt.core.compiler.debug.localVariable=generate
-org.eclipse.jdt.core.compiler.debug.sourceFile=generate
-org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
-org.eclipse.jdt.core.compiler.problem.deprecation=warning
-org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
-org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
-org.eclipse.jdt.core.compiler.problem.discouragedReference=warning
-org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
-org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
-org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
-org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
-org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
-org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
-org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore
-org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
-org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
-org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
-org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
-org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
-org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
-org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
-org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
-org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
-org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
-org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
-org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
-org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
-org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
-org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
-org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
-org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
-org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
-org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=ignore
-org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.unusedImport=warning
-org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
-org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
-org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning
-org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.5
-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_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_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_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.blank_lines_after_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_after_package=1
-org.eclipse.jdt.core.formatter.blank_lines_before_field=1
-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_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_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=false
-org.eclipse.jdt.core.formatter.comment.format_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_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=80
-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.format_guardian_clause_on_one_line=false
-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=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_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_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_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_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_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_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_while=insert
-org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=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_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.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=120
-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=1
-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_tabs_only_for_leading_indentations=false
diff --git a/org.eclipse.mylyn.context.ui/.settings/org.eclipse.jdt.ui.prefs b/org.eclipse.mylyn.context.ui/.settings/org.eclipse.jdt.ui.prefs
deleted file mode 100644
index 85d95dc..0000000
--- a/org.eclipse.mylyn.context.ui/.settings/org.eclipse.jdt.ui.prefs
+++ /dev/null
@@ -1,5 +0,0 @@
-#Mon Feb 13 11:20:16 PST 2006
-eclipse.preferences.version=1
-formatter_profile=_Mylar based on Eclipse [built-in]
-formatter_settings_version=10
-org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><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">/**\r\n * @return the ${bare_field_name}\r\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">/**\r\n * @param ${param} the ${bare_field_name} to set\r\n */</template><template autoinsert\="true" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/**\r\n * \r\n */</template><template autoinsert\="false" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/**\r\n * @author ${user}\r\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">/**\r\n * \r\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">/**\r\n * ${tags}\r\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"></template><template autoinsert\="false" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">/*******************************************************************************\r\n * Copyright (c) 2004 - 2006 University Of British Columbia and others.\r\n * All rights reserved. This program and the accompanying materials\r\n * are made available under the terms of the Eclipse Public License v1.0\r\n * which accompanies this distribution, and is available at\r\n * http\://www.eclipse.org/legal/epl-v10.html\r\n *\r\n * Contributors\:\r\n *     University Of British Columbia - initial API and implementation\r\n *******************************************************************************/\r\n\r\n${package_declaration}\r\n\r\n${typecomment}\r\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">\r\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">\r\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">\r\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">\r\n</template><template autoinsert\="false" 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\r\n${exception_var}.printStackTrace();</template><template autoinsert\="false" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ignore\r\n${body_statement}</template><template autoinsert\="false" 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}\r\n// ignore</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/org.eclipse.mylyn.context.ui/.settings/org.eclipse.ltk.core.refactoring.prefs b/org.eclipse.mylyn.context.ui/.settings/org.eclipse.ltk.core.refactoring.prefs
deleted file mode 100644
index 4999813..0000000
--- a/org.eclipse.mylyn.context.ui/.settings/org.eclipse.ltk.core.refactoring.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Fri Jun 02 15:31:46 PDT 2006
-eclipse.preferences.version=1
-org.eclipse.ltk.core.refactoring.enable.project.refactoring.history=true
diff --git a/org.eclipse.mylyn.context.ui/.settings/org.eclipse.pde.prefs b/org.eclipse.mylyn.context.ui/.settings/org.eclipse.pde.prefs
deleted file mode 100644
index 43bd042..0000000
--- a/org.eclipse.mylyn.context.ui/.settings/org.eclipse.pde.prefs
+++ /dev/null
@@ -1,12 +0,0 @@
-#Thu Nov 03 15:47:36 PST 2005
-compilers.p.deprecated=2
-compilers.p.no-required-att=0
-compilers.p.not-externalized-att=2
-compilers.p.unknown-attribute=0
-compilers.p.unknown-class=0
-compilers.p.unknown-element=0
-compilers.p.unknown-resource=0
-compilers.p.unresolved-ex-points=0
-compilers.p.unresolved-import=0
-compilers.use-project=true
-eclipse.preferences.version=1
diff --git a/org.eclipse.mylyn.context.ui/META-INF/MANIFEST.MF b/org.eclipse.mylyn.context.ui/META-INF/MANIFEST.MF
deleted file mode 100644
index 9ad1f01..0000000
--- a/org.eclipse.mylyn.context.ui/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,23 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: Mylar UI Plug-in
-Bundle-SymbolicName: org.eclipse.mylar.ui; singleton:=true
-Bundle-Version: 0.5.2.v20060601-2000
-Bundle-Activator: org.eclipse.mylar.provisional.ui.MylarUiPlugin
-Bundle-Localization: plugin
-Require-Bundle: org.eclipse.ui,
- org.eclipse.core.runtime,
- org.eclipse.mylar.core,
- org.eclipse.mylar.tasklist,
- org.eclipse.ui.views,
- org.eclipse.jface.text,
- org.eclipse.core.resources
-Eclipse-AutoStart: true
-Bundle-Vendor: Eclipse.org
-Bundle-ClassPath: mylar-ui.jar
-Export-Package: org.eclipse.mylar.internal.ui,
- org.eclipse.mylar.internal.ui.actions,
- org.eclipse.mylar.internal.ui.preferences,
- org.eclipse.mylar.internal.ui.views,
- org.eclipse.mylar.provisional.ui
-Bundle-RequiredExecutionEnvironment: J2SE-1.5
diff --git a/org.eclipse.mylyn.context.ui/about.html b/org.eclipse.mylyn.context.ui/about.html
deleted file mode 100644
index 1aeb16b..0000000
--- a/org.eclipse.mylyn.context.ui/about.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>May 2, 2006</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</a>.</p>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/org.eclipse.mylyn.context.ui/build-user.xml b/org.eclipse.mylyn.context.ui/build-user.xml
deleted file mode 100644
index 6097713..0000000
--- a/org.eclipse.mylyn.context.ui/build-user.xml
+++ /dev/null
@@ -1,3 +0,0 @@
-<target name="help">
-    <echo message="Please run: $ ant -v -projecthelp"/>
-</target>
\ No newline at end of file
diff --git a/org.eclipse.mylyn.context.ui/build.properties b/org.eclipse.mylyn.context.ui/build.properties
deleted file mode 100644
index 28890fb..0000000
--- a/org.eclipse.mylyn.context.ui/build.properties
+++ /dev/null
@@ -1,28 +0,0 @@
-###############################################################################
-# Copyright (c) 2004 - 2005 University Of British Columbia 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:
-#     University Of British Columbia - initial API and implementation
-###############################################################################
-bin.includes = plugin.xml,\
-               icons/,\
-               plugin.properties,\
-               mylar-ui.jar,\
-               META-INF/,\
-               about.html,\
-               schema/
-src.includes = icons/,\
-               plugin.xml,\
-               plugin.properties,\
-               src/,\
-               META-INF/,\
-               about.html,\
-               schema/
-jars.compile.order = mylar-ui.jar
-source.mylar-ui.jar = src/
-output.mylar-ui.jar = bin/
-jre.compilation.profile = J2SE-1.5
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/blank.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/blank.gif
deleted file mode 100644
index 45b7594..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/blank.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/bug-refresh.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/bug-refresh.gif
deleted file mode 100644
index bb8538b..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/bug-refresh.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/bug.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/bug.gif
deleted file mode 100644
index 54525a7..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/bug.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/capture-pause.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/capture-pause.gif
deleted file mode 100644
index 98e7743..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/capture-pause.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/capture-resume.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/capture-resume.gif
deleted file mode 100644
index 40bf78e..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/capture-resume.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/color-palette.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/color-palette.gif
deleted file mode 100644
index 4c94527..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/color-palette.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/context-clear.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/context-clear.gif
deleted file mode 100644
index cbb71be..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/context-clear.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/delete.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/delete.gif
deleted file mode 100644
index b6922ac..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/delete.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/edge-inheritance.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/edge-inheritance.gif
deleted file mode 100644
index bf41cd7..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/edge-inheritance.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/edge-read.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/edge-read.gif
deleted file mode 100644
index 5feec34..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/edge-read.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/edge-reference.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/edge-reference.gif
deleted file mode 100644
index 9f1a284..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/edge-reference.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/edge-write.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/edge-write.gif
deleted file mode 100644
index b438294..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/edge-write.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/file-xml.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/file-xml.gif
deleted file mode 100644
index 8af38f9..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/file-xml.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/file_obj.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/file_obj.gif
deleted file mode 100644
index 7ccc6a7..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/file_obj.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/fldr_obj.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/fldr_obj.gif
deleted file mode 100644
index 51e703b..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/fldr_obj.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/import-zip.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/import-zip.gif
deleted file mode 100644
index f3b6648..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/import-zip.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/interest-decrease.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/interest-decrease.gif
deleted file mode 100644
index 645a58f..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/interest-decrease.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/interest-filtering.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/interest-filtering.gif
deleted file mode 100644
index dee01c3..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/interest-filtering.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/interest-folding.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/interest-folding.gif
deleted file mode 100644
index 360c475..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/interest-folding.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/interest-increase.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/interest-increase.gif
deleted file mode 100644
index 98a2586..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/interest-increase.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/interest-landmark.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/interest-landmark.gif
deleted file mode 100644
index aad6ec2..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/interest-landmark.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/interest-working-set.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/interest-working-set.gif
deleted file mode 100644
index 9e3340d..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/interest-working-set.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/link-with-editor.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/link-with-editor.gif
deleted file mode 100644
index 068d4c9..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/link-with-editor.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/mylar-overlay.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/mylar-overlay.gif
deleted file mode 100644
index 0b145cb..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/mylar-overlay.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/refresh.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/refresh.gif
deleted file mode 100644
index 17002ac..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/refresh.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/remove.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/remove.gif
deleted file mode 100644
index 2cd9c54..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/remove.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/stop_all-color.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/stop_all-color.gif
deleted file mode 100644
index 6d47276..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/stop_all-color.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/stop_all.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/stop_all.gif
deleted file mode 100644
index ded722b..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/stop_all.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/synched.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/synched.gif
deleted file mode 100644
index 870934b..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/synched.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/elcl16/web-document.gif b/org.eclipse.mylyn.context.ui/icons/elcl16/web-document.gif
deleted file mode 100644
index 05a2053..0000000
--- a/org.eclipse.mylyn.context.ui/icons/elcl16/web-document.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/etool16/content-assist-separator.gif b/org.eclipse.mylyn.context.ui/icons/etool16/content-assist-separator.gif
deleted file mode 100644
index 25b1176..0000000
--- a/org.eclipse.mylyn.context.ui/icons/etool16/content-assist-separator.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/etool16/context-attach.gif b/org.eclipse.mylyn.context.ui/icons/etool16/context-attach.gif
deleted file mode 100644
index bee8fc5..0000000
--- a/org.eclipse.mylyn.context.ui/icons/etool16/context-attach.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/etool16/context-retrieve.gif b/org.eclipse.mylyn.context.ui/icons/etool16/context-retrieve.gif
deleted file mode 100644
index 02a46c8..0000000
--- a/org.eclipse.mylyn.context.ui/icons/etool16/context-retrieve.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/etool16/qualify-names.gif b/org.eclipse.mylyn.context.ui/icons/etool16/qualify-names.gif
deleted file mode 100644
index acbd9dc..0000000
--- a/org.eclipse.mylyn.context.ui/icons/etool16/qualify-names.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/etool16/wizard-feedback.gif b/org.eclipse.mylyn.context.ui/icons/etool16/wizard-feedback.gif
deleted file mode 100644
index bd69c45..0000000
--- a/org.eclipse.mylyn.context.ui/icons/etool16/wizard-feedback.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/etool16/wizard-study.gif b/org.eclipse.mylyn.context.ui/icons/etool16/wizard-study.gif
deleted file mode 100644
index 936601c..0000000
--- a/org.eclipse.mylyn.context.ui/icons/etool16/wizard-study.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/eview16/mylar-apply-activity-new.gif b/org.eclipse.mylyn.context.ui/icons/eview16/mylar-apply-activity-new.gif
deleted file mode 100644
index 9e7f543..0000000
--- a/org.eclipse.mylyn.context.ui/icons/eview16/mylar-apply-activity-new.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/eview16/mylar-apply-activity.gif b/org.eclipse.mylyn.context.ui/icons/eview16/mylar-apply-activity.gif
deleted file mode 100644
index 9e7f543..0000000
--- a/org.eclipse.mylyn.context.ui/icons/eview16/mylar-apply-activity.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/eview16/mylar-apply.gif b/org.eclipse.mylyn.context.ui/icons/eview16/mylar-apply.gif
deleted file mode 100644
index dee01c3..0000000
--- a/org.eclipse.mylyn.context.ui/icons/eview16/mylar-apply.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/eview16/overlay-mylar.gif b/org.eclipse.mylyn.context.ui/icons/eview16/overlay-mylar.gif
deleted file mode 100644
index 0b145cb..0000000
--- a/org.eclipse.mylyn.context.ui/icons/eview16/overlay-mylar.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/icons/wizban/banner-prefs.gif b/org.eclipse.mylyn.context.ui/icons/wizban/banner-prefs.gif
deleted file mode 100644
index ce0f6e3..0000000
--- a/org.eclipse.mylyn.context.ui/icons/wizban/banner-prefs.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.context.ui/plugin.properties b/org.eclipse.mylyn.context.ui/plugin.properties
deleted file mode 100644
index 02d653a..0000000
--- a/org.eclipse.mylyn.context.ui/plugin.properties
+++ /dev/null
@@ -1,10 +0,0 @@
-###############################################################################
-# Copyright (c) 2004 - 2005 University Of British Columbia 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:
-#     University Of British Columbia - initial API and implementation
-###############################################################################
diff --git a/org.eclipse.mylyn.context.ui/plugin.xml b/org.eclipse.mylyn.context.ui/plugin.xml
deleted file mode 100644
index 3c3d2e9..0000000
--- a/org.eclipse.mylyn.context.ui/plugin.xml
+++ /dev/null
@@ -1,337 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?eclipse version="3.0"?>
-<?eclipse version="3.0"?>
-<plugin>
-    <extension-point id="context" name="context" schema="schema/context.exsd"/>
- 
-    <extension
-         point="org.eclipse.mylar.core.context">
-      <structureBridge class="org.eclipse.mylar.internal.ui.TaskStructureBridge"/> 
-   </extension>
-   <extension
-         point="org.eclipse.mylar.ui.context">
-      <uiBridge
-            class="org.eclipse.mylar.internal.ui.TaskUiBridge"
-            contentType="meta/task"/>
-   </extension>   
- 
-  	<extension point = "org.eclipse.ui.popupMenus">
-     <objectContribution
-        id="org.eclipse.mylar.ui.interest"
-        objectClass="org.eclipse.mylar.provisional.core.IMylarElement">
-     	<action  
-  		  	label="Mylar: Mark as Less Interesting" 
-	  		tooltip="Mark selected element as uninteresting"
-	  		menubarPath="mylar" 
-	  		id="org.eclipse.mylar.ui.actions.InterestDecrementAction" 
-	  		class="org.eclipse.mylar.internal.ui.actions.InterestDecrementAction"
-	  		icon="icons/elcl16/interest-decrease.gif"
-	  		enablesFor="*"/>
-	    <action  
-  		  	label="Mylar: Mark as Landmark" 
-	  		tooltip="Make selected element a landmark"
-	  		menubarPath="mylar" 
-	  		id="org.eclipse.mylar.ui.actions.InterestIncrementAction" 
-	  		class="org.eclipse.mylar.internal.ui.actions.InterestIncrementAction"
-	  		icon="icons/elcl16/interest-increase.gif"
-	  		enablesFor="*"/>
-	 </objectContribution> 
-	 
-     <viewerContribution 
-           id="org.eclipse.mylar.ui.tasklist.contribution"
-           targetID="org.eclipse.mylar.tasks.ui.views.TaskListView">
-        <action
-              class="org.eclipse.mylar.internal.ui.actions.ContextClearAction"
-              enablesFor="1"
-              icon="icons/elcl16/context-clear.gif"
-              id="org.eclipse.mylar.ui.clear.context"
-              label="Clear Context"
-              menubarPath="context"
-              tooltip="Clear Context">
-           <enablement>
-              <or>
-                 <objectClass name="org.eclipse.mylar.provisional.tasklist.ITask"/>
-                 <objectClass name="org.eclipse.mylar.provisional.tasklist.AbstractQueryHit"/>
-              </or>
-           </enablement>
-        </action>
-        <action
-              class="org.eclipse.mylar.internal.ui.actions.ContextRetrieveAction"
-              enablesFor="1"
-              icon="icons/etool16/context-retrieve.gif"
-              id="org.eclipse.mylar.ui.context.repository.retrieve"
-              label="Retrieve Context"
-              menubarPath="context">
-           <enablement>
-              <or>
-                 <objectClass name="org.eclipse.mylar.provisional.tasklist.AbstractQueryHit"/>
-                 <objectClass name="org.eclipse.mylar.provisional.tasklist.AbstractRepositoryTask"/>
-              </or>
-           </enablement>
-        </action> 
-        <action
-              class="org.eclipse.mylar.internal.ui.actions.ContextAttachAction"
-              enablesFor="1"
-              icon="icons/etool16/context-attach.gif"
-              id="org.eclipse.mylar.ui.context.repository.attach"
-              label="Attach Context..."
-              menubarPath="context">
-           <enablement>
-              <or>
-                 <objectClass name="org.eclipse.mylar.provisional.tasklist.AbstractRepositoryTask"/>
-                 <objectClass name="org.eclipse.mylar.provisional.tasklist.AbstractQueryHit"/>
-              </or>
-           </enablement>
-        </action>
-        
-        <!--
-        <action
-              class="org.eclipse.mylar.tasklist.ui.actions.TaskActivateAction"
-              id="org.eclipse.mylar.tasklist.actions.context.activate"
-              label="Activate Task"
-              menubarPath="task"
-              tooltip="Activate Task"/>
-        -->
-     </viewerContribution>
-  </extension>
-    
-    
-   <extension
-         point="org.eclipse.ui.preferencePages">
-      <page
-            name="Mylar"
-            class="org.eclipse.mylar.internal.ui.preferences.MylarPreferencePage"
-            id="org.eclipse.mylar.ui.preferences">
-      </page>  
-   </extension>
- 
-  <!--  MARKER STUFF -->
-  
-    <extension point="org.eclipse.ui.ide.markerImageProviders">
-    <imageprovider 
-  		markertype="org.eclipse.mylar.ui.landmark" 
-  		icon="icons/elcl16/interest-landmark.gif" 
-  		id="org.eclipse.mylar.landmarkMarkerProvider" /> 
-   </extension> 
-  
-  <extension point="org.eclipse.ui.editors.annotationTypes">
-  	<type
-         markerSeverity="0"
-         markerType="org.eclipse.mylar.ui.landmark"
-         name="org.eclipse.mylar.ui.landmark.annotation"/> 
-  </extension> 
-   
-  <extension point="org.eclipse.ui.editors.markerAnnotationSpecification">
-  	<specification annotationType="org.eclipse.mylar.ui.landmark.annotation" 
-  		label="Mylar Landmark" 
-  		icon="icons/elcl16/interest-landmark.gif" 
-  		textPreferenceKey="landmarkIndication" 
-  		textPreferenceValue="false" 
-  		highlightPreferenceKey="landmarkHighlighting" 
-  		highlightPreferenceValue="true" 
-  		contributesToHeader="true" 
-  		overviewRulerPreferenceKey="landmarkIndicationInOverviewRuler" 
-  		overviewRulerPreferenceValue="true" 
-  		verticalRulerPreferenceKey="landmarkIndicationInVerticalRuler" 
-  		verticalRulerPreferenceValue="true" 
-  		colorPreferenceKey="landmarkIndicationColor" 
-  		colorPreferenceValue="255,255,255" 
-  		presentationLayer="0" 
-  		showInNextPrevDropdownToolbarActionKey="showLandmarkInNextPrevDropdownToolbarAction" 
-  		showInNextPrevDropdownToolbarAction="true" /> 
-  </extension>
-    
-      <!--  ACTION STUFF -->
-    
-   <extension
-       	 point="org.eclipse.ui.actionSets">
-   	  <actionSet
-            label="Mylar"
-            description="Mylar"
-            visible="true"
-            id="org.eclipse.mylar.ui.mylar.actionSet">
-         <action
-               definitionId="org.eclipse.mylar.ui.interest.increment"
-               label="Make landmark"
-               class="org.eclipse.mylar.internal.ui.actions.InterestIncrementAction"
-               menubarPath="navigate/open.ext2"
-               id="org.eclipse.mylar.ui.actions.InterestIncrementAction">
-         </action>
-         <action
-               definitionId="org.eclipse.mylar.ui.interest.decrement"
-               label="Make less interesting"
-               class="org.eclipse.mylar.internal.ui.actions.InterestDecrementAction"
-               menubarPath="navigate/open.ext2"
-               id="org.eclipse.mylar.ui.actions.InterestDecrementAction">
-         </action>
-         <!--
-         <action
-               definitionId="org.eclipse.mylar.ui.related.show"
-               label="Open Mylar related elements"
-               class="org.eclipse.mylar.ui.actions.OpenRelatedElementsQuickView"
-               menubarPath="navigate/open.ext2"
-               id="org.eclipse.mylar.ui.actions.OpenRelatedElementsQuickView">
-         </action>
-         <action
-               definitionId="org.eclipse.mylar.ui.show.filtered"
-               label="Make less interesting"
-               class="org.eclipse.mylar.ui.actions.ShowFilteredAction"
-               menubarPath="navigate/open.ext2"
-               id="org.eclipse.mylar.ui.actions.ShowFilteredAction">
-         </action>
-         -->
-      </actionSet>
-   </extension>
-                              
-   <extension point="org.eclipse.ui.commands">
-      <category
-            name="Mylar"
-            description="Mylar commands"
-            id="org.eclipse.mylar.ui">
-      </category>
-      <command
-            name="Global Filtering"
-            id="org.eclipse.mylar.ui.interest.filter.global"
-            categoryId="org.eclipse.mylar.ui">
-      </command>
-      <command
-            name="Show Related Elements"
-            description="Show Related Elements"
-            id="org.eclipse.mylar.ui.related.show"
-            categoryId="org.eclipse.mylar.ui">
-      </command>
-      <command
-            name="Make Landmark"
-            description="Make Landmark"
-            id="org.eclipse.mylar.ui.interest.increment"
-            categoryId="org.eclipse.mylar.ui">
-      </command>
-      <command
-            name="Make Less Interesting"
-            description="Make Less Interesting"
-            id="org.eclipse.mylar.ui.interest.decrement"
-            categoryId="org.eclipse.mylar.ui">
-      </command>
-      <!--
-      <command
-            name="Show Filtered Children"
-            description="Show Filtered Children"
-            id="org.eclipse.mylar.ui.show.filtered"
-            categoryId="org.eclipse.mylar.ui">
-      </command>
-      -->
-   </extension>
-     
-   <extension point="org.eclipse.ui.bindings">     
-      <key
-            sequence="M1+M2+M3+ARROW_UP"
-            contextId="org.eclipse.ui.globalScope"
-            commandId="org.eclipse.mylar.ui.interest.increment"
-            schemeId ="org.eclipse.ui.defaultAcceleratorConfiguration">
-      </key>
-      <key
-            sequence="M1+M2+M3+ARROW_DOWN"
-            contextId="org.eclipse.ui.globalScope"
-            commandId="org.eclipse.mylar.ui.interest.decrement"
-            schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
-      </key>
-      <key
-            sequence="M1+M2+M3+ARROW_LEFT"
-            contextId="org.eclipse.ui.globalScope"
-            commandId="org.eclipse.mylar.ui.related.show"
-            schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
-      </key> 
-	  <!--
-      <key
-            sequence="M1+M2+M3+ARROW_RIGHT"
-            contextId="org.eclipse.ui.globalScope"
-            commandId="org.eclipse.mylar.ui.show.filtered"
-            schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
-      </key> 
-      -->
-   </extension>     
-
-   <extension point="org.eclipse.ui.decorators">
-      <decorator
-            lightweight="true"
-            label="Mylar Interest Decorator"
-            class="org.eclipse.mylar.internal.ui.InterestDecoratorLightweight"
-            state="true"
-            id="org.eclipse.mylar.ui.decorator.interest">
-         <description>
-			Mylar degree of interest decorator
-		 </description>
-         <enablement>
-            <objectClass name="java.lang.Object"/>
-         </enablement>
-      </decorator>
-   </extension>
-
- <extension point="org.eclipse.ui.viewActions"> 
- 	<viewContribution 
-		id="org.eclipse.mylar.ui.tasklist.apply" 
-   		targetID="org.eclipse.mylar.tasks.ui.views.TaskListView">
-    	<action
-           class="org.eclipse.mylar.internal.ui.actions.ApplyMylarToTaskListAction"
-           enablesFor="*"
-           icon="icons/eview16/mylar-apply-activity.gif"
-           id="org.eclipse.mylar.ui.actions.ApplyMylarToOutlineAction"
-           label="Apply Mylar (Experimental)"
-           style="toggle"
-           toolbarPath="context"
-           tooltip="Apply Mylar (Experimental)"> 
-  		</action> 
-  	</viewContribution>
-	<viewContribution 
-		id="org.eclipse.mylar.outline.contribution.filter" 
-   		targetID="org.eclipse.ui.views.ContentOutline">
-    	<action
-           class="org.eclipse.mylar.internal.ui.actions.ApplyMylarToOutlineAction"
-           enablesFor="*"
-           icon="icons/elcl16/interest-filtering.gif"
-           id="org.eclipse.mylar.ui.actions.ApplyMylarToOutlineAction"
-           label="Apply Mylar"
-           menubarPath="mylar"
-           style="toggle"
-           toolbarPath="mylar"
-           tooltip="Apply Mylar"> 
-  		</action> 
-  	</viewContribution>
-    <viewContribution
-         id="org.eclipse.mylar.tasklist.contribution.context"
-         targetID="org.eclipse.mylar.tasks.ui.views.TaskListView">
-      <action
-            class="org.eclipse.mylar.internal.ui.actions.ToggleContextCaptureAction"
-            icon="icons/elcl16/capture-pause.gif"
-            id="org.eclipse.mylar.ui.context.capture.pause"
-            label="Pause Capturing Context"
-            style="toggle"
-            toolbarPath="context"
-            tooltip="Pause Capturing Context"/>
-   </viewContribution>
-   </extension>
-   
-   <extension point="org.eclipse.mylar.tasklist.providers"> 
-      <dynamicPopupMenu class="org.eclipse.mylar.internal.ui.TaskListHighlighterMenuContributor"/>
-   </extension>
- 
-      <extension point="org.eclipse.ui.workingSets">
-        <workingSet
-            id="org.eclipse.mylar.workingSetPage"
-            name="Mylar Task Context"
-            icon="icons/elcl16/interest-working-set.gif"
-            pageClass="org.eclipse.mylar.internal.ui.MylarWorkingSetPage"
-            updaterClass="org.eclipse.mylar.internal.core.search.MylarWorkingSetUpdater">
-        </workingSet>
-    </extension>
-</plugin>
-
-	    <!--
-	  	<action id="org.eclipse.mylar.ui.actions.ShowFilteredAction" 
-              label="Raise children" 
-	      	  menubarPath="mylar" 
-              icon="icons/elcl16/raise-children.gif" 
-              tooltip="Show all children of the current element" 
-              class="org.eclipse.mylar.ui.actions.ShowFilteredAction" 
-              enablesFor="1"/> 
-          --> 
diff --git a/org.eclipse.mylyn.context.ui/schema/context.exsd b/org.eclipse.mylyn.context.ui/schema/context.exsd
deleted file mode 100644
index 44beb73..0000000
--- a/org.eclipse.mylyn.context.ui/schema/context.exsd
+++ /dev/null
@@ -1,169 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.eclipse.mylar.ui.bridges">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.eclipse.mylar.ui.bridges" id="bridges" name="bridges"/>
-      </appInfo>
-      <documentation>
-         [Enter description of this extension point.]
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="uiBridge" minOccurs="1" maxOccurs="unbounded"/>
-            <element ref="labelProvider" minOccurs="1" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="uiBridge">
-      <complexType>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn=":org.eclipse.mylar.ui.IMylarUiBridge"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="contentType" type="string" use="required">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="labelProvider">
-      <complexType>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="contentType" type="string" use="required">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="since"/>
-      </appInfo>
-      <documentation>
-         [Enter the first release in which this extension point appears.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         [Enter extension point usage example here.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         [Enter API information here.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         [Enter information about supplied implementation of this extension point.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/AbstractContextLabelProvider.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/AbstractContextLabelProvider.java
deleted file mode 100644
index 4e249af..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/AbstractContextLabelProvider.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import org.eclipse.jface.viewers.ILabelProvider;
-import org.eclipse.jface.viewers.ILabelProviderListener;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.IMylarRelation;
-import org.eclipse.swt.graphics.Image;
-
-/**
- * TODO: this delegation idiom is breaking, refactor
- * 
- * @author Mik Kersten
- */
-public abstract class AbstractContextLabelProvider implements ILabelProvider {
-
-	public Image getImage(Object object) {
-		if (object instanceof IMylarRelation) {
-			return getImage((IMylarRelation) object);
-		} else if (object instanceof IMylarElement) {
-			return getImage((IMylarElement) object);
-		} else {
-			return getImageForObject(object);
-		}
-	}
-
-	public String getText(Object object) {
-		if (object instanceof IMylarRelation) {
-			return getText((IMylarRelation) object);
-		} else if (object instanceof IMylarElement) {
-			return getText((IMylarElement) object);
-		} else {
-			return getTextForObject(object);
-		}
-	}
-
-	protected abstract Image getImage(IMylarElement node);
-
-	protected abstract Image getImage(IMylarRelation edge);
-
-	protected abstract Image getImageForObject(Object object);
-
-	protected abstract String getText(IMylarElement node);
-
-	protected abstract String getTextForObject(Object object);
-
-	protected abstract String getText(IMylarRelation edge);
-
-	public void addListener(ILabelProviderListener listener) {
-		// TODO Auto-generated method stub
-
-	}
-
-	public void dispose() {
-		// TODO Auto-generated method stub
-
-	}
-
-	public boolean isLabelProperty(Object element, String property) {
-		// TODO Auto-generated method stub
-		return false;
-	}
-
-	public void removeListener(ILabelProviderListener listener) {
-		// TODO Auto-generated method stub
-
-	}
-
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/AbstractPartTracker.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/AbstractPartTracker.java
deleted file mode 100644
index f8b0081..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/AbstractPartTracker.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.ui.IPartListener;
-import org.eclipse.ui.IWorkbench;
-import org.eclipse.ui.IWorkbenchPart;
-
-/**
- * @author Mik Kersten
- */
-public abstract class AbstractPartTracker implements IPartListener {
-
-	public void install(IWorkbench workbench) {
-		MylarPlugin.getDefault().addWindowPartListener(this);
-//		if (workbench != null) {
-//			workbench.addWindowListener(this);
-//			IWorkbenchWindow[] windows = workbench.getWorkbenchWindows();
-//			for (int i = 0; i < windows.length; i++) {
-//				windows[i].addPageListener(this);
-//				IWorkbenchPage[] pages = windows[i].getPages();
-//				for (int j = 0; j < pages.length; j++) {
-//					pages[j].addPartListener(this);
-//				}
-//			}
-//		}
-	}
-
-	public void dispose(IWorkbench workbench) {
-		MylarPlugin.getDefault().removeWindowPartListener(this);
-//		if (workbench != null) {
-//			workbench.removeWindowListener(this);
-//			IWorkbenchWindow[] windows = workbench.getWorkbenchWindows();
-//			for (int i = 0; i < windows.length; i++) {
-//				windows[i].removePageListener(this);
-//				IWorkbenchPage[] pages = windows[i].getPages();
-//				for (int j = 0; j < pages.length; j++) {
-//					pages[j].removePartListener(this);
-//				}
-//			}
-//		}
-	}
-
-//	public void windowActivated(IWorkbenchWindow window) {
-//	}
-//
-//	public void windowDeactivated(IWorkbenchWindow window) {
-//	}
-
-//	public void windowClosed(IWorkbenchWindow window) {
-//		window.removePageListener(this);
-//	}
-//
-//	public void windowOpened(IWorkbenchWindow window) {
-//		window.addPageListener(this);
-//	}
-
-//	public void pageActivated(IWorkbenchPage page) {
-//	}
-//
-//	public void pageClosed(IWorkbenchPage page) {
-//		page.removePartListener(this);
-//	}
-//
-//	public void pageOpened(IWorkbenchPage page) {
-//		page.addPartListener(this);
-//	}
-
-	public abstract void partActivated(IWorkbenchPart part);
-
-	public abstract void partBroughtToTop(IWorkbenchPart part);
-
-	public abstract void partClosed(IWorkbenchPart part);
-
-	public abstract void partDeactivated(IWorkbenchPart part);
-
-	public abstract void partOpened(IWorkbenchPart part);
-
-}
\ No newline at end of file
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/BrowseFilteredListener.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/BrowseFilteredListener.java
deleted file mode 100644
index 8864f4e..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/BrowseFilteredListener.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.jface.viewers.StructuredViewer;
-import org.eclipse.jface.viewers.TreeViewer;
-import org.eclipse.jface.viewers.ViewerFilter;
-import org.eclipse.mylar.provisional.ui.InterestFilter;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.KeyEvent;
-import org.eclipse.swt.events.KeyListener;
-import org.eclipse.swt.events.MouseEvent;
-import org.eclipse.swt.events.MouseListener;
-import org.eclipse.swt.graphics.Point;
-import org.eclipse.swt.widgets.Table;
-import org.eclipse.swt.widgets.Tree;
-
-/**
- * @author Mik Kersten
- */
-public class BrowseFilteredListener implements MouseListener, KeyListener {
-
-	private StructuredViewer viewer;
-
-	public BrowseFilteredListener(StructuredViewer viewer) {
-		this.viewer = viewer;
-	}
-
-	private void unfilter(final InterestFilter filter, final TreeViewer treeViewer, Object targetObject) {
-		if (targetObject != null) {
-			filter.setTemporarilyUnfiltered(targetObject);
-			if (targetObject instanceof Tree) {
-				treeViewer.refresh();
-			} else { 
-				treeViewer.refresh(targetObject, true);
-				treeViewer.expandToLevel(targetObject, 1);
-			}
-		}
-	}
-
-	public void keyPressed(KeyEvent event) {
-		// ignore
-	}
-
-	public void keyReleased(KeyEvent event) {
-		final InterestFilter filter = getFilter(viewer);
-		if (filter == null || !(viewer instanceof TreeViewer)) {
-			return;
-		}
-
-		if (isUnfilterEvent(event)) {
-			final TreeViewer treeViewer = (TreeViewer) viewer;
-			ISelection selection = treeViewer.getSelection();
-			if (selection instanceof IStructuredSelection) {
-				Object targetObject = ((IStructuredSelection) selection).getFirstElement();
-				unfilter(filter, treeViewer, targetObject);
-			}
-		} else if (event.keyCode != SWT.ARROW_DOWN && event.keyCode != SWT.ARROW_UP) {
-			if (filter.resetTemporarilyUnfiltered()) {
-				viewer.refresh(false);
-			}
-		}
-	}
-
-	public void mouseDown(MouseEvent event) {
-		final InterestFilter filter = getFilter(viewer);
-		if (filter == null || !(viewer instanceof TreeViewer)) {
-			return;
-		}
-
-		if (isUnfilterEvent(event)) {
-			final TreeViewer treeViewer = (TreeViewer) viewer;
-			ISelection selection = treeViewer.getSelection();
-			if (selection instanceof IStructuredSelection) {
-				Object targetObject = null;
-				if (getClickedItem(event) != null) {
-					targetObject = ((IStructuredSelection) selection).getFirstElement();
-				} else {// if (treeViewer.getTree().getTopItem() != null) {
-					targetObject = treeViewer.getTree();
-				} 
-				unfilter(filter, treeViewer, targetObject);
-			}
-		} else {
-			if (filter.resetTemporarilyUnfiltered()) {
-				viewer.refresh(false);
-			}
-		}
-	}
-
-	private Object getClickedItem(MouseEvent event) {
-		if (event.getSource() instanceof Table) {
-			return ((Table) event.getSource()).getItem(new Point(event.x, event.y));
-		} else if (event.getSource() instanceof Tree) {
-			return ((Tree) event.getSource()).getItem(new Point(event.x, event.y));
-		}
-		return null;
-	}
-
-	private boolean isUnfilterEvent(MouseEvent event) {
-		return (event.stateMask & SWT.ALT) != 0;
-	}
-	
-	private boolean isUnfilterEvent(KeyEvent event) {
-		return (event.keyCode == SWT.ARROW_RIGHT) && (event.stateMask == SWT.ALT);
-	}
-	
-	private InterestFilter getFilter(StructuredViewer structuredViewer) {
-		ViewerFilter[] filters = structuredViewer.getFilters();
-		for (int i = 0; i < filters.length; i++) {
-			if (filters[i] instanceof InterestFilter)
-				return (InterestFilter) filters[i];
-		}
-		return null;
-	}
-
-	public void mouseUp(MouseEvent e) {
-	}
-
-	public void mouseDoubleClick(MouseEvent e) {
-	}
-
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/ColorCoordinatesChange.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/ColorCoordinatesChange.java
deleted file mode 100644
index 71abf2a..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/ColorCoordinatesChange.java
+++ /dev/null
@@ -1,137 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2005 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-public class ColorCoordinatesChange {
-	/**
-	 * Change RGB colors to HSV colors
-	 * 
-	 * @param R
-	 *            The red component of the color (0 - 255)
-	 * @param G
-	 *            The green component of the color (0 - 255)
-	 * @param B
-	 *            The blue component of the color (0 - 255)
-	 * @return The HSV colors in an array of doubles. This means that position 0 =
-	 *         H, position 1 = S, and position 2 = V
-	 */
-	public static double[] RGBToHSV(double R, double G, double B) {
-		double minVal = Math.min(Math.min(R, G), B);
-		double V = Math.max(Math.max(R, G), B);
-
-		double Delta = V - minVal;
-
-		double S = 0;
-		double H = 0;
-
-		// Calculate saturation: saturation is 0 if r, g and b are all 0
-		if (V == 0)
-			S = 0.0;
-		else
-			S = Delta / V;
-
-		if (S == 0)
-			H = 0; // Achromatic: When s = 0, h is undefined but who cares
-		else // Chromatic
-		{
-			if (R == V) // between yellow and magenta [degrees]
-				H = 60.0 * (G - B) / Delta;
-			else {
-				if (G == V) // between cyan and yellow
-					H = 120.0 + 60.0 * (B - R) / Delta;
-				else
-					// between magenta and cyan
-					H = 240.0 + 60.0 * (R - G) / Delta;
-
-			}
-		}
-
-		if (H < 0)
-			H = H + 360.0;
-		// return a list of values as an rgb object would not be sensible
-		return new double[] { H, S, V / 255.0 };
-	}
-
-	/**
-	 * Change HSV colors to RGB colors
-	 * 
-	 * @param H
-	 *            The hue of the color (0 - 360)
-	 * @param S
-	 *            The saturation of the color (0 - 1)
-	 * @param V
-	 *            The value of the color (0 - 1)
-	 * @return The RGB colors in an array of ints. This means that position 0 =
-	 *         R, position 1 = G, and position 2 = B
-	 */
-	public static int[] HSVtoRGB(double H, double S, double V) {
-		double R = 0, G = 0, B = 0;
-		double hTemp, f, p, q, t;
-		int i;
-		if (S == 0) // color is on black-and-white center line
-		{
-			R = V; // achromatic: shades of gray
-			G = V; // supposedly invalid for h=0 but who cares
-			B = V;
-		} else // chromatic color
-		{
-			if (H == 360.0) // 360 degrees same as 0 degrees
-				hTemp = 0.0;
-			else
-				hTemp = H;
-
-			hTemp = hTemp / 60.0; // h is now in [0,6)
-			i = new Double(hTemp).intValue(); // largest integer <= h
-			f = hTemp - i; // fractional part of h
-
-			p = V * (1.0 - S);
-			q = V * (1.0 - (S * f));
-			t = V * (1.0 - (S * (1.0 - f)));
-
-			switch (i) {
-			case 0:
-				R = V;
-				G = t;
-				B = p;
-				break;
-			case 1:
-				R = q;
-				G = V;
-				B = p;
-				break;
-			case 2:
-				R = p;
-				G = V;
-				B = t;
-				break;
-			case 3:
-				R = p;
-				G = q;
-				B = V;
-				break;
-			case 4:
-				R = t;
-				G = p;
-				B = V;
-				break;
-			case 5:
-				R = V;
-				G = p;
-				B = q;
-				break;
-			}
-		}
-		return new int[] { new Double(R * 255).intValue(), new Double(G * 255).intValue(),
-				new Double(B * 255).intValue() };
-	}
-
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/ColorMap.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/ColorMap.java
deleted file mode 100644
index 5066915..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/ColorMap.java
+++ /dev/null
@@ -1,132 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-/*
- * Created on Dec 28, 2004
- */
-package org.eclipse.mylar.internal.ui;
-
-import org.eclipse.mylar.internal.tasklist.ui.TaskListColorsAndFonts;
-import org.eclipse.swt.graphics.Color;
-import org.eclipse.swt.widgets.Display;
-
-/**
- * @author Mik Kersten
- */
-public class ColorMap {
-
-	// TODO: use themes?
-	public Color LANDMARK = TaskListColorsAndFonts.COLOR_TASK_ACTIVE;
-
-	public Color BACKGROUND_COLOR = new Color(Display.getDefault(), 255, 255, 255); 
-
-	public Color DEFAULT = null;//Display.getCurrent().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND);//new Color(Display.getDefault(), 255, 255, 255); 
-
-	public Color GRAY_DARK = new Color(Display.getDefault(), 70, 70, 70); 
-
-	public Color GRAY_MEDIUM = new Color(Display.getDefault(), 105, 105, 105); 
-
-	public Color GRAY_LIGHT = new Color(Display.getDefault(), 145, 145, 145); 
-
-	public Color GRAY_VERY_LIGHT = new Color(Display.getDefault(), 200, 200, 200); 
-
-	public Color RELATIONSHIP = new Color(Display.getDefault(), 32, 104, 157);
-
-	public Color HIGLIGHTER_RED_INTERSECTION = new Color(Display.getDefault(), 200, 0, 0);
-
-	public Color HIGHLIGHTER_ORANGE_GRADIENT = new Color(Display.getDefault(), 222, 137, 71);
-
-	public Color HIGLIGHTER_BLUE_GRADIENT = new Color(Display.getDefault(), 81, 158, 235);
-
-	public Color HIGHLIGHTER_YELLOW = new Color(Display.getDefault(), 255, 238, 99);
-
-	public Color PANTONE_PASTEL_YELLOW = new Color(Display.getDefault(), 244, 238, 175);
-
-	public Color PANTONE_PASTEL_ROSE = new Color(Display.getDefault(), 254, 179, 190);
-
-	public Color PANTONE_PASTEL_MAUVE = new Color(Display.getDefault(), 241, 183, 216);
-
-	public Color PANTONE_PASTEL_PURPLE = new Color(Display.getDefault(), 202, 169, 222);
-
-	public Color PANTONE_PASTEL_BLUE = new Color(Display.getDefault(), 120, 160, 250);
-
-	public Color PANTONE_PASTERL_GREEN = new Color(Display.getDefault(), 162, 231, 215);
-
-	public static Color COLOR_WHITE = new Color(Display.getCurrent(), 255, 255, 255);
-
-	public static Color COLOR_BLACK = new Color(Display.getCurrent(), 0, 0, 0);
-	
-	public void dispose() {
-		LANDMARK.dispose();
-		BACKGROUND_COLOR.dispose();
-		GRAY_DARK.dispose();
-		GRAY_MEDIUM.dispose();
-		GRAY_LIGHT.dispose();
-		GRAY_VERY_LIGHT.dispose();
-		RELATIONSHIP.dispose();
-		HIGLIGHTER_RED_INTERSECTION.dispose();
-		HIGHLIGHTER_ORANGE_GRADIENT.dispose();
-		HIGHLIGHTER_YELLOW.dispose();
-		PANTONE_PASTERL_GREEN.dispose();
-		PANTONE_PASTEL_BLUE.dispose();
-		PANTONE_PASTEL_MAUVE.dispose();
-		PANTONE_PASTEL_PURPLE.dispose();
-		PANTONE_PASTEL_ROSE.dispose();
-		PANTONE_PASTEL_YELLOW.dispose();
-		COLOR_WHITE.dispose();
-		COLOR_BLACK.dispose();
-		
-		// below disposed by registry
-		// DEFAULT.dispose();
-	}
-	
-	private GammaSetting gammaSetting = GammaSetting.STANDARD;
-
-	public enum GammaSetting {
-		LIGHTEN, DARKEN, STANDARD;
-
-		public static int compare(GammaSetting gs1, GammaSetting gs2) {
-			if (gs1 == LIGHTEN) {
-				if (gs2 == STANDARD) {
-					return 1;
-				} else if (gs2 == DARKEN) {
-					return 2;
-				} else {
-					return 0;
-				}
-			} else if (gs1 == STANDARD) {
-				if (gs2 == LIGHTEN) {
-					return -1;
-				} else if (gs2 == DARKEN) {
-					return 1;
-				} else {
-					return 0;
-				}
-			} else {
-				if (gs2 == LIGHTEN) {
-					return -2;
-				} else if (gs2 == STANDARD) {
-					return -1;
-				} else {
-					return 0;
-				}
-			}
-		}
-	}
-
-	public GammaSetting getGammaSetting() {
-		return gammaSetting;
-	}
-
-	public void setGammaSetting(GammaSetting gammaSetting) {
-		this.gammaSetting = gammaSetting;
-	}
-
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/ContentOutlineManager.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/ContentOutlineManager.java
deleted file mode 100644
index 78e6838..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/ContentOutlineManager.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-package org.eclipse.mylar.internal.ui;
-
-import org.eclipse.mylar.internal.ui.actions.ApplyMylarToOutlineAction;
-import org.eclipse.ui.IEditorPart;
-import org.eclipse.ui.IPartListener;
-import org.eclipse.ui.IWorkbenchPart;
-
-/**
- * @author Mik Kersten
- */
-public class ContentOutlineManager implements IPartListener {
-
-	public void partBroughtToTop(IWorkbenchPart part) {
-//		if (!MylarPlugin.getContextManager().isContextActive()) {
-//			return;
-//		} else {
-		if (part instanceof IEditorPart) {
-			IEditorPart editorPart = (IEditorPart) part;
-			ApplyMylarToOutlineAction applyAction = ApplyMylarToOutlineAction.getOutlineActionForEditor(editorPart);
-			if (applyAction != null) {
-				applyAction.update(editorPart);
-			}
-		}
-//		}
-	}
-	
-	public void partActivated(IWorkbenchPart part) {
-		// ignore
-	}
-
-	public void partOpened(IWorkbenchPart part) {
-		// ignore
-	}
-
-	public void partClosed(IWorkbenchPart partRef) {
-		// ignore
-	}
-
-	public void partDeactivated(IWorkbenchPart partRef) {
-		// ignore
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/Highlighter.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/Highlighter.java
deleted file mode 100644
index 25eac46..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/Highlighter.java
+++ /dev/null
@@ -1,295 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.swt.graphics.Color;
-import org.eclipse.swt.widgets.Display;
-
-/**
- * @author Mik Kersten
- */
-public class Highlighter {
-
-	private static final String LABEL_SOLID = "Solid";
-
-	private static final String LABEL_INTERSECTION = "Intersection";
-
-	private static final String LABEL_GRADIENT = "Gradient";
-
-	private static final int NUM_LEVELS = 40;
-
-	private static final String VAL_DEFAULT = "";
-
-	private final List<Color> gradients = new ArrayList<Color>();
-
-	private String name;
-
-	private Color core;
-
-	private Color landmarkColor;
-
-	private Color highlightColor;
-
-	private boolean isGradient;
-
-	private boolean isIntersection;
-
-	public boolean isIntersection() {
-		return isIntersection;
-	}
-
-	public void setIntersection(boolean isIntersection) {
-		this.isIntersection = isIntersection;
-	}
-
-	public Highlighter(String name, Color coreColor, boolean isGradient) {
-		this.name = name;
-		this.core = coreColor;
-		this.isGradient = isGradient;
-		if (coreColor != null) {
-			initializeGradients();
-			initializeHighlight();
-		}
-		if (!isGradient) {
-			this.landmarkColor = coreColor;
-		} else {
-			initializeLandmark();
-		}
-	}
-
-	public Highlighter(String attributes) {
-		if (initializeFromString(attributes)) {
-			initializeGradients();
-			initializeHighlight();
-			if (!isGradient) {
-				this.landmarkColor = highlightColor;
-			} else {
-				initializeLandmark();
-			}
-		} 
-	} 
-
-	public void dispose() {
-		for (Color color : gradients) {
-			color.dispose();
-		}
-	}
-
-	public Color getHighlightColor() {
-		return highlightColor;
-	}
-
-	public Color getLandmarkColor() {
-		return landmarkColor;
-	}
-
-	public Color getHighlight(IMylarElement info, boolean isLandmark) {
-		if (info.getInterest().getValue() > 0) {
-			if (isLandmark) {
-				return landmarkColor;
-			} else {
-				if (isGradient) {
-					return mapDoiToElevation(info);
-				} else {
-					return highlightColor;
-				}
-			}
-		} else {
-			return ColorMap.COLOR_WHITE;
-		}
-	}
-
-	public Color mapDoiToElevation(IMylarElement info) {
-		if (info == null)
-			return ColorMap.COLOR_WHITE;
-		if (info.getInterest().getValue() < 0)
-			return highlightColor;
-
-		int step = 2;
-		Color color = ColorMap.COLOR_WHITE;
-		for (Iterator<Color> it = gradients.iterator(); it.hasNext();) {
-			color = it.next();
-			if (info.getInterest().getValue() < step)
-				return color;
-			step += 2;
-		}
-		return color; // darkest color supported
-		// return landmarkColor;
-	}
-
-	private void initializeHighlight() {
-		try {
-			int redStep = (int) Math.ceil((core.getRed() + 2 * ColorMap.COLOR_WHITE.getRed()) / 3);
-			int greenStep = (int) Math.ceil((core.getGreen() + 2 * ColorMap.COLOR_WHITE.getGreen()) / 3);
-			int blueStep = (int) Math.ceil((core.getBlue() + 2 * ColorMap.COLOR_WHITE.getBlue()) / 3);
-
-			highlightColor = new Color(Display.getDefault(), redStep, greenStep, blueStep);
-		} catch (Throwable t) {
-			MylarStatusHandler.log(t, "highlighter init failed");
-		}
-	}
-
-	private void initializeLandmark() {
-		try {
-			int redStep = (int) Math.ceil((2 * core.getRed() + ColorMap.COLOR_BLACK.getRed()) / 3);
-			int greenStep = (int) Math.ceil((2 * core.getGreen() + ColorMap.COLOR_BLACK.getGreen()) / 3);
-			int blueStep = (int) Math.ceil((2 * core.getBlue() + ColorMap.COLOR_BLACK.getBlue()) / 3);
-
-			landmarkColor = new Color(Display.getDefault(), redStep, greenStep, blueStep);
-		} catch (Throwable t) {
-			MylarStatusHandler.log(t, "landmark init failed");
-		}
-	}
-
-	private void initializeGradients() {
-		try {
-			int redStep = (int) Math.ceil((core.getRed() - ColorMap.COLOR_WHITE.getRed()) / NUM_LEVELS);
-			int greenStep = (int) Math.ceil((core.getGreen() - ColorMap.COLOR_WHITE.getGreen()) / NUM_LEVELS);
-			int blueStep = (int) Math.ceil((core.getBlue() - ColorMap.COLOR_WHITE.getBlue()) / NUM_LEVELS);
-
-			int OFFSET = 5;
-			int red = ColorMap.COLOR_WHITE.getRed() + redStep * OFFSET;
-			int green = ColorMap.COLOR_WHITE.getGreen() + greenStep * OFFSET;
-			int blue = ColorMap.COLOR_WHITE.getBlue() + blueStep * OFFSET;
-			for (int i = 0; i < NUM_LEVELS - OFFSET; i++) {
-				if (red > 255)
-					red = 255; // TODO: fix this mess
-				if (green > 255)
-					green = 255;
-				if (blue > 255)
-					blue = 255;
-				if (red < 0)
-					red = 0;
-				if (green < 0)
-					green = 0;
-				if (blue < 0)
-					blue = 0;
-				gradients.add(new Color(Display.getDefault(), red, green, blue));
-				red += redStep;
-				blue += blueStep;
-				green += greenStep;
-			}
-		} catch (Throwable t) {
-			MylarStatusHandler.log(t, "gradients failed");
-		}
-	}
-
-	@Override
-	public String toString() {
-		return name;
-	}
-
-	public String getName() {
-		return name;
-	}
-
-	public void setName(String name) {
-		this.name = name;
-	}
-
-	public Color getBase() {
-		return ColorMap.COLOR_WHITE;
-	}
-
-	public void setBase(Color base) {
-		ColorMap.COLOR_WHITE = base;
-	}
-
-	public static Color blend(List<Highlighter> highlighters, IMylarElement info, boolean isLandmark) {
-		int red = 0;
-		int green = 0;
-		int blue = 0;
-		int num = highlighters.size();
-		for (Iterator<Highlighter> it = highlighters.iterator(); it.hasNext();) {
-			Highlighter highlighter = it.next();
-			Color color = highlighter.getHighlight(info, isLandmark);
-			red += color.getRed();
-			green += color.getGreen();
-			blue += color.getBlue();
-		}
-		return new Color(Display.getDefault(), red / num, green / num, blue / num);
-	}
-
-	public boolean isGradient() {
-		return isGradient;
-	}
-
-	public void setGradient(boolean isGradient) {
-		this.isGradient = isGradient;
-	}
-
-	public Color getCore() {
-		return core;
-	}
-
-	public void setCore(Color core) {
-		this.core = core;
-		this.initializeGradients();
-		this.initializeHighlight();
-		this.initializeLandmark();
-	}
-
-	public String getHighlightKind() {
-		String res = VAL_DEFAULT;
-		if (this.isGradient) {
-			res = LABEL_GRADIENT;
-		} else if (this.isIntersection) {
-			res = LABEL_INTERSECTION;
-		} else {
-			res = LABEL_SOLID;
-		}
-		return res;
-	}
-
-	public String externalizeToString() {
-		if (core == null) {
-			return VAL_DEFAULT;
-		} else {
-			Integer r = new Integer(this.core.getRed());
-			Integer g = new Integer(this.core.getGreen());
-			Integer b = new Integer(this.core.getBlue());
-			return r.toString() + ";" + g.toString() + ";" + b.toString() + ";" + this.name + ";"
-					+ this.getHighlightKind();
-		}
-	}
-
-private boolean initializeFromString(String attributes) {
-		if (!VAL_DEFAULT.equals(attributes)) {
-			String[] data = attributes.split(";");
-			Integer r = new Integer(data[0]);
-			Integer g = new Integer(data[1]);
-			Integer b = new Integer(data[2]);
-			this.core = new Color(Display.getCurrent(), r.intValue(), g.intValue(), b.intValue());
-			this.name = data[3];
-			if (data[4].compareTo(LABEL_GRADIENT) == 0) {
-				this.isGradient = true;
-				this.isIntersection = false;
-			} else if (data[4].compareTo(LABEL_INTERSECTION) == 0) {
-				this.isGradient = false;
-				this.isIntersection = true;
-			} else {
-				this.isGradient = false;
-				this.isIntersection = false;
-			}
-			return true;
-		} else {
-			this.name = HighlighterList.DEFAULT_HIGHLIGHTER.getName();
-			this.core = HighlighterList.DEFAULT_HIGHLIGHTER.getCore();
-			return false;
-		}
-	}}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/HighlighterImageDescriptor.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/HighlighterImageDescriptor.java
deleted file mode 100644
index 1acac7e..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/HighlighterImageDescriptor.java
+++ /dev/null
@@ -1,244 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-/*
- * Created on Dec 29, 2004
- */
-package org.eclipse.mylar.internal.ui;
-
-import org.eclipse.jface.resource.ImageDescriptor;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.Color;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.graphics.ImageData;
-import org.eclipse.swt.graphics.PaletteData;
-import org.eclipse.swt.graphics.RGB;
-import org.eclipse.swt.widgets.Display;
-
-public class HighlighterImageDescriptor extends ImageDescriptor {
-
-	private Image image;
-
-	public HighlighterImageDescriptor(Color fromColor, Color toColor) {
-		super();
-		if (fromColor == null) {
-			fromColor = Display.getCurrent().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND);
-		}
-		if (toColor == null) {
-			toColor = Display.getCurrent().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND);
-		}
-		ImageData band = createGradientBand(50, 20, false, new RGB(fromColor.getRed(), fromColor.getGreen(), fromColor
-				.getBlue()), new RGB(toColor.getRed(), toColor.getGreen(), toColor.getBlue()), 4, 4, 4);
-		image = new Image(Display.getCurrent(), band);
-	}
-
-	@Override
-	public void destroyResource(Object previouslyCreatedObject) {
-		image.dispose();
-		super.destroyResource(previouslyCreatedObject);
-	}
-
-	@Override
-	public boolean equals(Object obj) {
-		return obj instanceof HighlighterImageDescriptor && image.equals(((HighlighterImageDescriptor) obj).image);
-	}
-
-	@Override
-	public ImageData getImageData() {
-		return image.getImageData();
-	}
-
-	@Override
-	public int hashCode() {
-		return image.hashCode();
-	}
-
-	public Image getImage() {
-		return image;
-	}
-
-	// ----------- COPIED FROM ImageData ---------------
-
-	/**
-	 * Creates an ImageData containing one band's worth of a gradient filled
-	 * block. If <code>vertical</code> is true, the band must be tiled
-	 * horizontally to fill a region, otherwise it must be tiled vertically.
-	 * 
-	 * @param width
-	 *            the width of the region to be filled
-	 * @param height
-	 *            the height of the region to be filled
-	 * @param vertical
-	 *            if true sweeps from top to bottom, else sweeps from left to
-	 *            right
-	 * @param fromRGB
-	 *            the color to start with
-	 * @param toRGB
-	 *            the color to end with
-	 * @param redBits
-	 *            the number of significant red bits, 0 for palette modes
-	 * @param greenBits
-	 *            the number of significant green bits, 0 for palette modes
-	 * @param blueBits
-	 *            the number of significant blue bits, 0 for palette modes
-	 * @return the new ImageData
-	 */
-	static ImageData createGradientBand(int width, int height, boolean vertical, RGB fromRGB, RGB toRGB, int redBits,
-			int greenBits, int blueBits) {
-		/* Gradients are drawn as tiled bands */
-		final int bandWidth, bandHeight, bitmapDepth;
-		final byte[] bitmapData;
-		final PaletteData paletteData;
-		/* Select an algorithm depending on the depth of the screen */
-		if (redBits != 0 && greenBits != 0 && blueBits != 0) {
-			paletteData = new PaletteData(0x0000ff00, 0x00ff0000, 0xff000000);
-			bitmapDepth = 32;
-			if (redBits >= 8 && greenBits >= 8 && blueBits >= 8) {
-				/* Precise color */
-				final int steps;
-				if (vertical) {
-					bandWidth = 1;
-					bandHeight = height;
-					steps = bandHeight > 1 ? bandHeight - 1 : 1;
-				} else {
-					bandWidth = width;
-					bandHeight = 1;
-					steps = bandWidth > 1 ? bandWidth - 1 : 1;
-				}
-				final int bytesPerLine = bandWidth * 4;
-				bitmapData = new byte[bandHeight * bytesPerLine];
-				buildPreciseGradientChannel(fromRGB.blue, toRGB.blue, steps, bandWidth, bandHeight, vertical,
-						bitmapData, 0, bytesPerLine);
-				buildPreciseGradientChannel(fromRGB.green, toRGB.green, steps, bandWidth, bandHeight, vertical,
-						bitmapData, 1, bytesPerLine);
-				buildPreciseGradientChannel(fromRGB.red, toRGB.red, steps, bandWidth, bandHeight, vertical, bitmapData,
-						2, bytesPerLine);
-			} else {
-				/* Dithered color */
-				final int steps;
-				if (vertical) {
-					bandWidth = (width < 8) ? width : 8;
-					bandHeight = height;
-					steps = bandHeight > 1 ? bandHeight - 1 : 1;
-				} else {
-					bandWidth = width;
-					bandHeight = (height < 8) ? height : 8;
-					steps = bandWidth > 1 ? bandWidth - 1 : 1;
-				}
-				final int bytesPerLine = bandWidth * 4;
-				bitmapData = new byte[bandHeight * bytesPerLine];
-				buildDitheredGradientChannel(fromRGB.blue, toRGB.blue, steps, bandWidth, bandHeight, vertical,
-						bitmapData, 0, bytesPerLine, blueBits);
-				buildDitheredGradientChannel(fromRGB.green, toRGB.green, steps, bandWidth, bandHeight, vertical,
-						bitmapData, 1, bytesPerLine, greenBits);
-				buildDitheredGradientChannel(fromRGB.red, toRGB.red, steps, bandWidth, bandHeight, vertical,
-						bitmapData, 2, bytesPerLine, redBits);
-			}
-		} else {
-			/* Dithered two tone */
-			paletteData = new PaletteData(new RGB[] { fromRGB, toRGB });
-			bitmapDepth = 8;
-			final int blendi;
-			if (vertical) {
-				bandWidth = (width < 8) ? width : 8;
-				bandHeight = height;
-				blendi = (bandHeight > 1) ? 0x1040000 / (bandHeight - 1) + 1 : 1;
-			} else {
-				bandWidth = width;
-				bandHeight = (height < 8) ? height : 8;
-				blendi = (bandWidth > 1) ? 0x1040000 / (bandWidth - 1) + 1 : 1;
-			}
-			final int bytesPerLine = (bandWidth + 3) & -4;
-			bitmapData = new byte[bandHeight * bytesPerLine];
-			if (vertical) {
-				for (int dy = 0, blend = 0, dp = 0; dy < bandHeight; ++dy, blend += blendi, dp += bytesPerLine) {
-					for (int dx = 0; dx < bandWidth; ++dx) {
-						bitmapData[dp + dx] = (blend + DITHER_MATRIX[dy & 7][dx]) < 0x1000000 ? (byte) 0 : (byte) 1;
-					}
-				}
-			} else {
-				for (int dx = 0, blend = 0; dx < bandWidth; ++dx, blend += blendi) {
-					for (int dy = 0, dptr = dx; dy < bandHeight; ++dy, dptr += bytesPerLine) {
-						bitmapData[dptr] = (blend + DITHER_MATRIX[dy][dx & 7]) < 0x1000000 ? (byte) 0 : (byte) 1;
-					}
-				}
-			}
-		}
-		return new ImageData(bandWidth, bandHeight, bitmapDepth, paletteData, 4, bitmapData);
-	}
-
-	/*
-	 * Fill in dithered gradated values for a color channel
-	 */
-	static final void buildDitheredGradientChannel(int from, int to, int steps, int bandWidth, int bandHeight,
-			boolean vertical, byte[] bitmapData, int dp, int bytesPerLine, int bits) {
-		final int mask = 0xff00 >>> bits;
-		int val = from << 16;
-		final int inc = ((to << 16) - val) / steps + 1;
-		if (vertical) {
-			for (int dy = 0; dy < bandHeight; ++dy, dp += bytesPerLine) {
-				for (int dx = 0, dptr = dp; dx < bandWidth; ++dx, dptr += 4) {
-					final int thresh = DITHER_MATRIX[dy & 7][dx] >>> bits;
-					int temp = val + thresh;
-					if (temp > 0xffffff)
-						bitmapData[dptr] = -1;
-					else
-						bitmapData[dptr] = (byte) ((temp >>> 16) & mask);
-				}
-				val += inc;
-			}
-		} else {
-			for (int dx = 0; dx < bandWidth; ++dx, dp += 4) {
-				for (int dy = 0, dptr = dp; dy < bandHeight; ++dy, dptr += bytesPerLine) {
-					final int thresh = DITHER_MATRIX[dy][dx & 7] >>> bits;
-					int temp = val + thresh;
-					if (temp > 0xffffff)
-						bitmapData[dptr] = -1;
-					else
-						bitmapData[dptr] = (byte) ((temp >>> 16) & mask);
-				}
-				val += inc;
-			}
-		}
-	}
-
-	/*
-	 * Fill in gradated values for a color channel
-	 */
-	static final void buildPreciseGradientChannel(int from, int to, int steps, int bandWidth, int bandHeight,
-			boolean vertical, byte[] bitmapData, int dp, int bytesPerLine) {
-		int val = from << 16;
-		final int inc = ((to << 16) - val) / steps + 1;
-		if (vertical) {
-			for (int dy = 0; dy < bandHeight; ++dy, dp += bytesPerLine) {
-				bitmapData[dp] = (byte) (val >>> 16);
-				val += inc;
-			}
-		} else {
-			for (int dx = 0; dx < bandWidth; ++dx, dp += 4) {
-				bitmapData[dp] = (byte) (val >>> 16);
-				val += inc;
-			}
-		}
-	}
-
-	/**
-	 * Scaled 8x8 Bayer dither matrix.
-	 */
-	static final int[][] DITHER_MATRIX = {
-			{ 0xfc0000, 0x7c0000, 0xdc0000, 0x5c0000, 0xf40000, 0x740000, 0xd40000, 0x540000 },
-			{ 0x3c0000, 0xbc0000, 0x1c0000, 0x9c0000, 0x340000, 0xb40000, 0x140000, 0x940000 },
-			{ 0xcc0000, 0x4c0000, 0xec0000, 0x6c0000, 0xc40000, 0x440000, 0xe40000, 0x640000 },
-			{ 0x0c0000, 0x8c0000, 0x2c0000, 0xac0000, 0x040000, 0x840000, 0x240000, 0xa40000 },
-			{ 0xf00000, 0x700000, 0xd00000, 0x500000, 0xf80000, 0x780000, 0xd80000, 0x580000 },
-			{ 0x300000, 0xb00000, 0x100000, 0x900000, 0x380000, 0xb80000, 0x180000, 0x980000 },
-			{ 0xc00000, 0x400000, 0xe00000, 0x600000, 0xc80000, 0x480000, 0xe80000, 0x680000 },
-			{ 0x000000, 0x800000, 0x200000, 0xa00000, 0x080000, 0x880000, 0x280000, 0xa80000 } };
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/HighlighterList.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/HighlighterList.java
deleted file mode 100644
index 2e59d73..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/HighlighterList.java
+++ /dev/null
@@ -1,188 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-package org.eclipse.mylar.internal.ui;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-import org.eclipse.mylar.provisional.core.IMylarContextListener;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-import org.eclipse.swt.graphics.Color;
-import org.eclipse.swt.widgets.Display;
-
-/**
- * List class that wraps List of highlighters
- * 
- */
-public class HighlighterList {
-
-	public static final Highlighter DEFAULT_HIGHLIGHTER = new Highlighter("<default>", MylarUiPlugin.getDefault()
-			.getColorMap().DEFAULT, false);
-
-	private List<Highlighter> highlighters;
-
-	public HighlighterList() {
-		highlighters = new ArrayList<Highlighter>();
-	}
-
-	public HighlighterList(List<Highlighter> hlist) {
-		highlighters = new ArrayList<Highlighter>();
-		for (Iterator<Highlighter> it = hlist.iterator(); it.hasNext();) {
-			final Highlighter highlighter = it.next();
-			highlighters.add(highlighter);
-		}
-	}
-
-	public HighlighterList(String attributes) {
-		highlighters = new ArrayList<Highlighter>();
-		this.internalizeFromString(attributes);
-	}
-
-	public void dispose() {
-		for (Highlighter highlighter : highlighters) {
-			highlighter.dispose();
-		}
-	}
-	
-	public void setToDefaultList() {
-		this.highlighters.clear();
-		highlighters.add(DEFAULT_HIGHLIGHTER);
-		highlighters.add(new Highlighter("yellow", MylarUiPlugin.getDefault().getColorMap().HIGHLIGHTER_YELLOW, false));
-		highlighters.add(new Highlighter("rose", MylarUiPlugin.getDefault().getColorMap().PANTONE_PASTEL_ROSE, false));
-		highlighters.add(new Highlighter("purple", MylarUiPlugin.getDefault().getColorMap().PANTONE_PASTEL_PURPLE,
-				false));
-		highlighters.add(new Highlighter("blue", MylarUiPlugin.getDefault().getColorMap().PANTONE_PASTEL_BLUE, false));
-		highlighters
-				.add(new Highlighter("green", MylarUiPlugin.getDefault().getColorMap().PANTONE_PASTERL_GREEN, false));
-		highlighters.add(new Highlighter("blue gradient",
-				MylarUiPlugin.getDefault().getColorMap().HIGLIGHTER_BLUE_GRADIENT, true));
-		highlighters.add(new Highlighter("orange gradient",
-				MylarUiPlugin.getDefault().getColorMap().HIGHLIGHTER_ORANGE_GRADIENT, true));
-
-		Highlighter intersectionHighlighter = new Highlighter("intersection",
-				MylarUiPlugin.getDefault().getColorMap().HIGLIGHTER_RED_INTERSECTION, false);
-		intersectionHighlighter.setIntersection(true);
-		MylarUiPlugin.getDefault().setIntersectionHighlighter(intersectionHighlighter);
-
-		MylarPlugin.getContextManager().notifyPostPresentationSettingsChange(
-				IMylarContextListener.UpdateKind.HIGHLIGHTER);
-	}
-
-	public void add(Highlighter hl) {
-		this.highlighters.add(hl);
-	}
-
-	/**
-	 * @return Returns the list.
-	 */
-	public List<Highlighter> getHighlighters() {
-		return highlighters;
-	}
-
-	public Highlighter addHighlighter() {
-		ColorMap colorMap = new ColorMap();
-		Highlighter hl = new Highlighter("new", colorMap.GRAY_DARK, false);
-		this.highlighters.add(hl);
-		return hl;
-	}
-
-	public Highlighter getHighlighter(String name) {
-		for (Iterator<Highlighter> it = highlighters.iterator(); it.hasNext();) {
-			Highlighter highlighter = it.next();
-			if (highlighter.getName().equals(name))
-				return highlighter;
-		}
-		return null;
-	}
-
-	public void removeHighlighter(Highlighter hl) {
-		this.highlighters.remove(hl);
-		// MylarUiPlugin.getDefault().setDefaultHighlighter(
-		// this.highlighters.get(0));
-	}
-
-	public String externalizeToString() {
-		// Add an initial flag so that we know if the highlighterlist has been
-		// save before.
-		// This is only used when mylar is first launched with eclipse.
-		// if the preference store returns a null string, then we would
-		// initialize
-		// the default highlighter.
-		// but if this flag is in place, we will know if highlighterlist has
-		// ever been saved
-		String result = "flag:";
-		for (Iterator<Highlighter> it = highlighters.iterator(); it.hasNext();) {
-			Highlighter highlighter = it.next();
-			result += highlighter.externalizeToString() + ":";
-		}
-		return result;
-	}
-
-	public void internalizeFromString(String attributes) {
-		if (attributes != null) {
-			this.highlighters.clear();
-			String[] data = attributes.split(":");
-			// skip the flag
-			//
-			for (int i = 1; i < data.length; i++) {
-				Highlighter hl = new Highlighter(data[i]);
-				this.highlighters.add(hl);
-			}
-		}
-	}
-
-	public void updateHighlighterWithGamma(ColorMap.GammaSetting prev, ColorMap.GammaSetting curr) {
-		int res = ColorMap.GammaSetting.compare(prev, curr);
-		if (res < 0) {
-			lightenAllColors(Math.abs(res));
-
-		} else if (res > 0) {
-			darkenAllColors(Math.abs(res));
-		}
-		MylarPlugin.getContextManager().notifyPostPresentationSettingsChange(
-				IMylarContextListener.UpdateKind.HIGHLIGHTER);
-	}
-
-	private void darkenAllColors(int degree) {
-		for (Highlighter hl : highlighters) {
-			Color c = hl.getCore();
-			double[] HSV = ColorCoordinatesChange.RGBToHSV(c.getRed(), c.getGreen(), c.getBlue());
-			if (degree != 2) {
-				HSV[1] *= 2;
-			} else {
-				HSV[1] *= 3;
-			}
-			if (HSV[1] > 1)
-				HSV[1] = 1;
-
-			int[] newRGB = ColorCoordinatesChange.HSVtoRGB(HSV[0], HSV[1], HSV[2]);
-			Color rgb = new Color(Display.getDefault(), newRGB[0], newRGB[1], newRGB[2]);
-			hl.setCore(rgb);
-		}
-	}
-
-	private void lightenAllColors(int degree) {
-		for (Highlighter hl : highlighters) {
-			Color c = hl.getCore();
-			double[] HSV = ColorCoordinatesChange.RGBToHSV(c.getRed(), c.getGreen(), c.getBlue());
-			if (degree != 2) {
-				HSV[1] *= 0.5;
-			} else {
-				HSV[1] *= 0.333;
-			}
-			int[] newRGB = ColorCoordinatesChange.HSVtoRGB(HSV[0], HSV[1], HSV[2]);
-			Color rgb = new Color(Display.getDefault(), newRGB[0], newRGB[1], newRGB[2]);
-			hl.setCore(rgb);
-		}
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/InterestDecorator.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/InterestDecorator.java
deleted file mode 100644
index 2459840..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/InterestDecorator.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import org.eclipse.jface.viewers.*;
-import org.eclipse.mylar.internal.core.MylarContextRelation;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.IMylarStructureBridge;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-import org.eclipse.swt.graphics.*;
-
-/**
- * Not currently used.
- * 
- * @author Mik Kersten
- */
-public class InterestDecorator implements ILabelDecorator, IFontDecorator, IColorDecorator {
-
-	public InterestDecorator() {
-		super();
-	}
-
-	private IMylarElement getNode(Object element) {
-		IMylarElement node = null;
-		if (element instanceof IMylarElement) {
-			node = (IMylarElement) element;
-		} else {
-			IMylarStructureBridge adapter = MylarPlugin.getDefault().getStructureBridge(element);
-			node = MylarPlugin.getContextManager().getElement(adapter.getHandleIdentifier(element));
-		}
-		return node;
-	}
-
-	public void addListener(ILabelProviderListener listener) {
-		// don't care about listeners
-	}
-
-	public void dispose() {
-		// don't care when we are disposed
-	}
-
-	public boolean isLabelProperty(Object element, String property) {
-		return false;
-	}
-
-	public void removeListener(ILabelProviderListener listener) {
-		// don't care about listeners
-	}
-
-	public Image decorateImage(Image image, Object element) {
-		return null;
-	}
-
-	public String decorateText(String text, Object element) {
-		return null;
-	}
-
-	public Font decorateFont(Object element) {
-		IMylarElement node = getNode(element);
-		if (node != null) {
-			if (node.getInterest().isLandmark() && !node.getInterest().isPropagated()) {
-				return MylarUiPrefContstants.BOLD;
-			}
-		}
-		return null;
-	}
-
-	public Color decorateForeground(Object element) {
-		IMylarElement node = getNode(element);
-		if (element instanceof MylarContextRelation) {
-			return MylarUiPlugin.getDefault().getColorMap().RELATIONSHIP;
-		} else if (node != null) {
-			UiUtil.getForegroundForElement(node);
-		}
-		return null;
-	}
-
-	public Color decorateBackground(Object element) {
-		IMylarElement node = getNode(element);
-		if (node != null) {
-			return UiUtil.getBackgroundForElement(node);
-		} else {
-			return null;
-		}
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/InterestDecoratorLightweight.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/InterestDecoratorLightweight.java
deleted file mode 100644
index 7dca5b3..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/InterestDecoratorLightweight.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import java.util.ConcurrentModificationException;
-
-import org.eclipse.jface.viewers.*;
-import org.eclipse.mylar.internal.core.MylarContextRelation;
-import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.IMylarStructureBridge;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-
-/**
- * @author Mik Kersten
- */
-public class InterestDecoratorLightweight implements ILightweightLabelDecorator {
-
-	public InterestDecoratorLightweight() {
-		super();
-	}
-
-	public void decorate(Object element, IDecoration decoration) {
-		IMylarStructureBridge bridge = null;
-		try {
-			if (MylarPlugin.getDefault() == null)
-				return;
-			bridge = MylarPlugin.getDefault().getStructureBridge(element);
-		} catch (ConcurrentModificationException cme) {
-			// ignored, because we can add structure bridges during decoration
-		}
-		try {
-			IMylarElement node = null;
-			if (element instanceof MylarContextRelation) {
-				decoration.setForegroundColor(MylarUiPlugin.getDefault().getColorMap().RELATIONSHIP);
-			} else if (element instanceof IMylarElement) {
-				node = (IMylarElement) element;
-			} else {
-				if (bridge != null && bridge.getContentType() != null) {
-					node = MylarPlugin.getContextManager().getElement(bridge.getHandleIdentifier(element));
-				}
-			}
-			if (node != null) {
-				decoration.setBackgroundColor(UiUtil.getBackgroundForElement(node));
-				decoration.setForegroundColor(UiUtil.getForegroundForElement(node));
-				if (bridge != null && bridge.canBeLandmark(node.getHandleIdentifier())
-						&& node.getInterest().isLandmark() && !node.getInterest().isPropagated()
-						&& !node.getInterest().isPredicted()) {
-					decoration.setFont(MylarUiPrefContstants.BOLD);
-				}
-			}
-		} catch (Exception e) {
-			MylarStatusHandler.log(e, "decoration failed");
-		}
-	}
-
-	public void addListener(ILabelProviderListener listener) {
-		// don't care about listeners
-	}
-
-	public void dispose() {
-		// don't care when we are disposed
-	}
-
-	public boolean isLabelProperty(Object element, String property) {
-		return false;
-	}
-
-	public void removeListener(ILabelProviderListener listener) {
-		// don't care about listeners
-	}
-
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/MylarImages.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/MylarImages.java
deleted file mode 100644
index a69cc58..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/MylarImages.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import java.net.MalformedURLException;
-import java.net.URL;
-
-import org.eclipse.jface.resource.ImageDescriptor;
-import org.eclipse.jface.resource.ImageRegistry;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-import org.eclipse.swt.graphics.Image;
-
-/**
- * @author Mik Kersten
- */
-public class MylarImages {
-
-	private static ImageRegistry imageRegistry;
-
-	public static final String T_ELCL = "elcl16";
-
-	public static final String T_TOOL = "etool16";
-
-	public static final String T_VIEW = "eview16";
-	
-	private static final URL baseURL = MylarUiPlugin.getDefault().getBundle().getEntry("/icons/");
-
-	public static final ImageDescriptor MYLAR = create(T_ELCL, "mylar.gif");
-
-	public static final ImageDescriptor MYLAR_OVERLAY = create(T_ELCL, "mylar-overlay.gif");
-
-	public static final ImageDescriptor DECORATE_INTEREST = create(T_ELCL, "refresh.gif");
-
-	public static final ImageDescriptor SYNCHED = create(T_ELCL, "synched.gif");
-
-	public static final ImageDescriptor REMOVE = create(T_ELCL, "remove.gif");
-
-	public static final ImageDescriptor ERASE_TASKSCAPE = create(T_ELCL, "context-clear.gif");
-
-	public static final ImageDescriptor INTEREST_LANDMARK = create(T_ELCL, "interest-landmark.gif");
-
-	public static final ImageDescriptor INTEREST_FILTERING = create(T_ELCL, "interest-filtering.gif");
-
-	public static final ImageDescriptor INTEREST_FOLDING = create(T_ELCL, "interest-filtering.gif");
-
-	public static final ImageDescriptor CAPTURE_PAUSE = create(T_ELCL, "capture-pause.gif");
-
-	public static final ImageDescriptor CAPTURE_RESUME = create(T_ELCL, "capture-resume.gif");
-
-	public static final ImageDescriptor FILTER_COMPLETE = create(T_ELCL, "filter-complete.gif");
-
-	public static final ImageDescriptor FILTER_PRIORITY = create(T_ELCL, "filter-priority.gif");
-
-	public static final ImageDescriptor COPY = create(T_ELCL, "copy.png");
-
-	public static final ImageDescriptor COLOR_PALETTE = create(T_ELCL, "color-palette.gif");
-
-	public static final ImageDescriptor STOP_SEARCH = create(T_ELCL, "stop_all.gif");
-
-	public static final ImageDescriptor CONTENT_ASSIST_SEPARATOR = create(T_TOOL, "content-assist-separator.gif");
-
-	public static final ImageDescriptor QUALIFY_NAMES = create(T_TOOL, "qualify-names.gif");
-
-	public static final ImageDescriptor EDGE_INHERITANCE = create(T_ELCL, "edge-inheritance.gif");
-
-	public static final ImageDescriptor EDGE_REFERENCE = create(T_ELCL, "edge-reference.gif");
-
-	public static final ImageDescriptor EDGE_ACCESS_READ = create(T_ELCL, "edge-read.gif");
-
-	public static final ImageDescriptor EDGE_ACCESS_WRITE = create(T_ELCL, "edge-write.gif");
-
-	public static final ImageDescriptor IMPORT_ZIP = create(T_ELCL, "import-zip.gif");
-
-	public static final ImageDescriptor FILE_XML = create(T_ELCL, "file-xml.gif");
-
-	public static final ImageDescriptor FILE_GENERIC = create(T_ELCL, "file_obj.gif");
-
-	public static final ImageDescriptor FOLDER_GENERIC = create(T_ELCL, "fldr_obj.gif");
-
-	public static final ImageDescriptor LINK_WITH_EDITOR = create(T_ELCL, "link-with-editor.gif");
-
-//	public static final ImageDescriptor OVERLAY_MYLAR = create(T_VIEW, "overlay-mylar.gif");
-	
-	public static final ImageDescriptor BLANK = create(T_ELCL, "blank.gif");
-
-	public static ImageDescriptor create(String prefix, String name) {
-		return create(prefix, name, baseURL);
-	}
-
-	public static ImageDescriptor create(String prefix, String name, URL baseURL) {
-		try {
-			return ImageDescriptor.createFromURL(makeIconFileURL(prefix, name, baseURL));
-		} catch (MalformedURLException e) {
-			return ImageDescriptor.getMissingImageDescriptor();
-		}
-	}
-
-	private static URL makeIconFileURL(String prefix, String name, URL baseURL) throws MalformedURLException {
-		if (baseURL == null)
-			throw new MalformedURLException();
-
-		StringBuffer buffer = new StringBuffer(prefix);
-		buffer.append('/');
-		buffer.append(name);
-		return new URL(baseURL, buffer.toString());
-	}
-
-	private static ImageRegistry getImageRegistry() {
-		if (imageRegistry == null) {
-			imageRegistry = new ImageRegistry();
-		}
-
-		return imageRegistry;
-	}
-
-	/**
-	 * Lazily initializes image map.
-	 */
-	public static Image getImage(ImageDescriptor imageDescriptor) {
-		if (imageDescriptor == null) {
-			return null;
-		} 
-		
-		ImageRegistry imageRegistry = getImageRegistry();
-		Image image = imageRegistry.get("" + imageDescriptor.hashCode());
-		if (image == null) {
-			image = imageDescriptor.createImage();
-			imageRegistry.put("" + imageDescriptor.hashCode(), image);
-		}
-		return image;
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/MylarUiPrefContstants.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/MylarUiPrefContstants.java
deleted file mode 100644
index 0081655..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/MylarUiPrefContstants.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import org.eclipse.jface.resource.JFaceResources;
-import org.eclipse.swt.graphics.Font;
-
-/**
- * @author Mik Kersten
- */
-public class MylarUiPrefContstants {
-
-	public static final String MARKER_LANDMARK = "org.eclipse.mylar.ui.interest.landmark";
-
-	public static final String INTEREST_FILTER_EXCLUSION = "org.eclipse.mylar.ui.interest.filter.exclusion";
-
-	public static final String AUTO_MANAGE_EDITORS_OPEN_NUM = "org.eclipse.mylar.ide.ui.editors.auto.open.num";
-
-	public static final String AUTO_MANAGE_EDITORS = "org.eclipse.mylar.ide.ui.editors.auto.manage";
-	
-	public static final String HIGHLIGHTER_PREFIX = "org.eclipse.mylar.ui.interest.highlighters";
-
-	public static final String GAMMA_SETTING_DARKENED = "org.eclipse.mylar.ui.gamma.darkened";
-
-	public static final String GAMMA_SETTING_STANDARD = "org.eclipse.mylar.ui.gamma.standard";
-
-	public static final String GAMMA_SETTING_LIGHTENED = "org.eclipse.mylar.ui.gamma.lightened";
-
-	public static final String GLOBAL_FILTERING = "org.eclipse.mylar.ui.interest.filter.global";
-
-	public static final String INTERSECTION_MODE = "org.eclipse.mylar.ui.interest.intersection";
-
-	public static final Font ITALIC = JFaceResources.getFontRegistry().getItalic(JFaceResources.DEFAULT_FONT);
-
-	public static final String TASK_HIGHLIGHTER_PREFIX = "org.eclipse.mylar.ui.interest.highlighters.task.";
-
-	public static final Font BOLD = JFaceResources.getFontRegistry().getBold(JFaceResources.DEFAULT_FONT);
-
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/MylarViewerManager.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/MylarViewerManager.java
deleted file mode 100644
index 7fbab03..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/MylarViewerManager.java
+++ /dev/null
@@ -1,285 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import org.eclipse.jface.util.IPropertyChangeListener;
-import org.eclipse.jface.util.PropertyChangeEvent;
-import org.eclipse.jface.viewers.StructuredViewer;
-import org.eclipse.jface.viewers.TreeViewer;
-import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
-import org.eclipse.mylar.internal.ui.actions.AbstractApplyMylarAction;
-import org.eclipse.mylar.provisional.core.IMylarContext;
-import org.eclipse.mylar.provisional.core.IMylarContextListener;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.IMylarStructureBridge;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-import org.eclipse.ui.IViewPart;
-import org.eclipse.ui.IWorkbenchPart;
-import org.eclipse.ui.PlatformUI;
-
-/**
- * Encapsualted the element refresh and expansion state policy for all viewers
- * showing Mylar context.
- * 
- * @author Mik Kersten
- */
-public class MylarViewerManager implements IMylarContextListener, IPropertyChangeListener {
-
-	private List<StructuredViewer> managedViewers = new ArrayList<StructuredViewer>();
-
-	private List<StructuredViewer> filteredViewers = new ArrayList<StructuredViewer>();
-
-	private List<AbstractApplyMylarAction> managedActions = new ArrayList<AbstractApplyMylarAction>();
-
-	private Map<StructuredViewer, BrowseFilteredListener> listenerMap = new HashMap<StructuredViewer, BrowseFilteredListener>();
-
-	private Map<IViewPart, StructuredViewer> partToViewerMap = new HashMap<IViewPart, StructuredViewer>();
-	
-	/**
-	 * For testing.
-	 */
-	private boolean syncRefreshMode = false; 
-
-	private AbstractPartTracker VIEWER_PART_TRACKER = new AbstractPartTracker() {
-
-		@Override
-		public void partActivated(IWorkbenchPart part) {
-			if (partToViewerMap.containsKey(part)) {
-				StructuredViewer viewer = partToViewerMap.get(part);
-				refreshViewer(null, false, viewer);
-			} 
-		}
-		
-		@Override
-		public void partBroughtToTop(IWorkbenchPart part) {
-
-		}
-		
-		@Override
-		public void partClosed(IWorkbenchPart part) {
-			// ignore
-		}
-
-		@Override
-		public void partDeactivated(IWorkbenchPart part) {
-			// ignore	
-		}
-
-		@Override
-		public void partOpened(IWorkbenchPart part) {
-			// ignore
-		}
-	};
-	
-	public MylarViewerManager() {
-		MylarUiPlugin.getPrefs().addPropertyChangeListener(this);
-		VIEWER_PART_TRACKER.install(PlatformUI.getWorkbench());
-	}
-	
-	public void dispose() {
-		VIEWER_PART_TRACKER.dispose(PlatformUI.getWorkbench());
-	}
-
-	public void addManagedAction(AbstractApplyMylarAction action) {
-		managedActions.add(action);
-	}
-
-	public void removeManagedAction(AbstractApplyMylarAction action) {
-		managedActions.remove(action);
-	}
-
-	public void addManagedViewer(StructuredViewer viewer, IViewPart viewPart) {
-		if (!managedViewers.contains(viewer)) {
-			managedViewers.add(viewer);
-			partToViewerMap.put(viewPart, viewer);
-			BrowseFilteredListener listener = new BrowseFilteredListener(viewer);
-			listenerMap.put(viewer, listener);
-			viewer.getControl().addMouseListener(listener);
-			viewer.getControl().addKeyListener(listener);
-		}
-	}
-
-	public void removeManagedViewer(StructuredViewer viewer, IViewPart viewPart) {
-		managedViewers.remove(viewer);
-		partToViewerMap.remove(viewPart);
-		BrowseFilteredListener listener = listenerMap.get(viewer);
-		if (listener != null && viewer != null && !viewer.getControl().isDisposed()) {
-			viewer.getControl().removeMouseListener(listener);
-			viewer.getControl().removeKeyListener(listener);
-		}
-	}
-
-	public void addFilteredViewer(StructuredViewer viewer) {
-		if (!filteredViewers.contains(viewer)) {
-			filteredViewers.add(viewer);
-		}
-	}
-
-	public void removeFilteredViewer(StructuredViewer viewer) {
-		filteredViewers.remove(viewer);
-	}
-
-	public void contextActivated(IMylarContext context) {
-		if (context.getActiveNode() != null) {
-			for (AbstractApplyMylarAction action : managedActions) {
-				action.update(true);
-			}
-		}
-		refreshViewers();
-	}
-
-	public void contextDeactivated(IMylarContext context) {
-		for (AbstractApplyMylarAction action : managedActions) {
-			action.update(false);
-		}
-		refreshViewers();
-	}
-
-	public void presentationSettingsChanging(UpdateKind kind) {
-		// ignore
-	}
-
-	public void presentationSettingsChanged(UpdateKind kind) {
-		refreshViewers();
-	}
-
-	protected void refreshViewers() {
-		List<IMylarElement> toRefresh = Collections.emptyList();
-		refreshViewers(toRefresh, true);
-	}
-
-	protected void refreshViewers(IMylarElement node, boolean updateLabels) {
-		List<IMylarElement> toRefresh = new ArrayList<IMylarElement>();
-		toRefresh.add(node);
-		refreshViewers(toRefresh, updateLabels);
-	}
-
-	public void interestChanged(final List<IMylarElement> nodes) {
-		refreshViewers(nodes, false);
-	}
-
-	protected void refreshViewers(final List<IMylarElement> nodesToRefresh, final boolean updateLabels) {
-		if (syncRefreshMode) {
-			internalRefresh(nodesToRefresh, updateLabels);
-		} else {
-			PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
-				public void run() {
-					internalRefresh(nodesToRefresh, updateLabels);
-				}
-			});
-		}
-	}
-
-	private void internalRefresh(final List<IMylarElement> nodesToRefresh, final boolean updateLabels) {
-		try {
-			for (StructuredViewer viewer : new ArrayList<StructuredViewer>(managedViewers)) {
-				refreshViewer(nodesToRefresh, updateLabels, viewer);
-			}
-		} catch (Throwable t) {
-			MylarStatusHandler.fail(t, "could not refresh viewer", false);
-		}
-	}
-
-	private void refreshViewer(final List<IMylarElement> nodesToRefresh, final boolean minor, StructuredViewer viewer) {
-		if (viewer == null) {
-			return;
-		} else if (viewer.getControl().isDisposed()) {
-			managedViewers.remove(viewer);
-		} else { //if (viewer.getControl().isVisible()) {
-			if (nodesToRefresh == null || nodesToRefresh.isEmpty()) {
-				if (!minor) {
-					viewer.refresh(false);
-					updateExpansionState(viewer, null);
-				} else {
-					viewer.getControl().setRedraw(false);
-					viewer.refresh(true);
-					updateExpansionState(viewer, null);
-					viewer.getControl().setRedraw(true);
-				}
-			} else {
-				if (filteredViewers.contains(viewer)) {
-					viewer.getControl().setRedraw(false);
-					viewer.refresh(minor);
-					updateExpansionState(viewer, null);
-					viewer.getControl().setRedraw(true);
-				} else { // don't need to worry about content changes 
-					viewer.getControl().setRedraw(false);
-					for (IMylarElement node : nodesToRefresh) {
-						IMylarStructureBridge structureBridge = MylarPlugin.getDefault().getStructureBridge(
-								node.getContentType());
-						Object objectToRefresh = structureBridge.getObjectForHandle(node.getHandleIdentifier());
-						if (objectToRefresh != null) {
-							viewer.update(objectToRefresh, null);
-							updateExpansionState(viewer, objectToRefresh);
-						}
-					}
-					viewer.getControl().setRedraw(true);
-				}
-			}
-		}
-	}
-
-	private void updateExpansionState(StructuredViewer viewer, Object objectToRefresh) {
-		if (viewer instanceof TreeViewer && filteredViewers.contains(viewer)) {
-			TreeViewer treeViewer = (TreeViewer)viewer;
-			if (objectToRefresh == null) {
-				treeViewer.expandAll();
-			} else {
-				treeViewer.expandToLevel(objectToRefresh, TreeViewer.ALL_LEVELS);
-			}
-		}
-	}
-
-	public void nodeDeleted(IMylarElement node) {
-		IMylarStructureBridge structureBridge = MylarPlugin.getDefault().getStructureBridge(node.getContentType());
-		IMylarElement parent = MylarPlugin.getContextManager().getElement(
-				structureBridge.getParentHandle(node.getHandleIdentifier()));
-		ArrayList<IMylarElement> toRefresh = new ArrayList<IMylarElement>();
-  
-		if (parent != null) {
-			toRefresh.add(parent);
-			refreshViewers(toRefresh, false);
-		}
-	}
-
-	public void landmarkAdded(IMylarElement node) {
-		refreshViewers(node, true);
-	}
-
-	public void landmarkRemoved(IMylarElement node) {
-		refreshViewers(node, true);
-	}
-
-	public void edgesChanged(IMylarElement node) {
-		// ignore
-	}
-
-	public void propertyChange(PropertyChangeEvent event) {
-		if (MylarUiPrefContstants.INTEREST_FILTER_EXCLUSION.equals(event.getProperty())) {
-			refreshViewers();
-		}
-	}
-
-	/**
-	 * Set to true for testing
-	 */
-	public void setSyncRefreshMode(boolean syncRefreshMode) {
-		this.syncRefreshMode = syncRefreshMode;
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/MylarWorkingSetPage.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/MylarWorkingSetPage.java
deleted file mode 100644
index e2d692a..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/MylarWorkingSetPage.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import java.util.ArrayList;
-
-import org.eclipse.core.runtime.IAdaptable;
-import org.eclipse.jface.dialogs.Dialog;
-import org.eclipse.jface.wizard.WizardPage;
-import org.eclipse.mylar.internal.core.search.MylarWorkingSetUpdater;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Text;
-import org.eclipse.ui.IWorkingSet;
-import org.eclipse.ui.IWorkingSetManager;
-import org.eclipse.ui.dialogs.IWorkingSetPage;
-
-/**
- * @author Shawn Minto
- */
-public class MylarWorkingSetPage extends WizardPage implements IWorkingSetPage {
-
-	private Text workingSetNameText;
-
-	private IWorkingSet workingSet;
-
-	public static final String WORKING_SET_NAME = "Mylar Task Context (for search)";
-
-	public MylarWorkingSetPage() {
-		super("org.eclipse.mylar.monitor.workingSetPage", "Mylar Task Context Working Set", MylarUiPlugin
-				.imageDescriptorFromPlugin(MylarUiPlugin.PLUGIN_ID, "icons/wizban/banner-prefs.gif"));
-		setDescription("Create the Mylar Task Context working set.  It will be updated automatically to contain\n"
-				+ "all of the resources related to the active task.");
-	}
-
-	public void createControl(Composite parent) {
-		initializeDialogUnits(parent);
-
-		Composite composite = new Composite(parent, SWT.NONE);
-		composite.setLayout(new GridLayout());
-		composite.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));
-		setControl(composite);
-
-		Label label = new Label(composite, SWT.WRAP);
-		label.setText("Name");
-		GridData gd = new GridData(GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL
-				| GridData.VERTICAL_ALIGN_CENTER);
-		label.setLayoutData(gd);
-
-		workingSetNameText = new Text(composite, SWT.SINGLE | SWT.BORDER);
-		workingSetNameText.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL));
-		workingSetNameText.setFocus();
-		workingSetNameText.setEditable(false);
-		workingSetNameText.setText(WORKING_SET_NAME);
-
-		label = new Label(composite, SWT.WRAP);
-		label.setText("");
-		gd = new GridData(GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_CENTER);
-		label.setLayoutData(gd);
-
-		label = new Label(composite, SWT.WRAP);
-		label
-				.setText("NOTE: this working set should only be used for searches.  Do not select it in the Package Explorer.");
-		label.setFont(MylarUiPrefContstants.BOLD);
-		gd = new GridData(GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_CENTER);
-		label.setLayoutData(gd);
-
-		label = new Label(composite, SWT.WRAP);
-		label.setText("");
-		gd = new GridData(GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_CENTER);
-		label.setLayoutData(gd);
-
-		// label = new Label(composite, SWT.WRAP);
-		// label.setText("PLEASE DO NOT ACTIVATE THIS WORKING SET AT
-		// ANYTIME.\nTHIS WORKING SET IS ONLY USEFUL FOR SEARCHING.");
-		// label.setFont(UiUtil.BOLD);
-		// gd= new GridData(GridData.GRAB_HORIZONTAL |
-		// GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_CENTER);
-		// label.setLayoutData(gd);
-
-		Dialog.applyDialogFont(composite);
-	}
-
-	public IWorkingSet getSelection() {
-		return workingSet;
-	}
-
-	public void setSelection(IWorkingSet workingSet) {
-		// don't need to do anything here
-	}
-
-	public void finish() {
-		String workingSetName = workingSetNameText.getText();
-		ArrayList<IAdaptable> elements = new ArrayList<IAdaptable>(1);
-		MylarWorkingSetUpdater.getElementsFromTaskscape(elements);
-		if (workingSet == null) {
-			IWorkingSetManager workingSetManager = MylarUiPlugin.getDefault().getWorkbench().getWorkingSetManager();
-			if ((workingSet = workingSetManager.getWorkingSet(workingSetName)) == null) {
-				workingSet = workingSetManager.createWorkingSet(workingSetName, elements
-						.toArray(new IAdaptable[elements.size()]));
-			}
-		}
-	}
-
-	@Override
-	public boolean isPageComplete() {
-		String workingSetName = workingSetNameText.getText();
-		IWorkingSetManager workingSetManager = MylarUiPlugin.getDefault().getWorkbench().getWorkingSetManager();
-		if (workingSetManager.getWorkingSet(workingSetName) != null) {
-			setErrorMessage("Cannot create another Active Taskscape Working Set");
-			return false;
-		} else {
-			return true;
-		}
-	}
-
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/TaskListHighlighterMenuContributor.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/TaskListHighlighterMenuContributor.java
deleted file mode 100644
index 3b68914..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/TaskListHighlighterMenuContributor.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import org.eclipse.jface.action.Action;
-import org.eclipse.jface.action.MenuManager;
-import org.eclipse.jface.action.Separator;
-import org.eclipse.mylar.internal.tasklist.ui.IDynamicSubMenuContributor;
-import org.eclipse.mylar.internal.tasklist.ui.views.TaskListView;
-import org.eclipse.mylar.internal.ui.actions.EditHighlightersAction;
-import org.eclipse.mylar.provisional.core.IMylarContextListener;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.tasklist.AbstractQueryHit;
-import org.eclipse.mylar.provisional.tasklist.ITask;
-import org.eclipse.mylar.provisional.tasklist.ITaskListElement;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-
-/**
- * @author Mik Kersten
- */
-public class TaskListHighlighterMenuContributor implements IDynamicSubMenuContributor {
-
-	private static final String CHOOSE_HIGHLIGHTER = "Highlighter";
-
-	public MenuManager getSubMenuManager(TaskListView view, ITaskListElement selection) {
-		final ITaskListElement selectedElement = selection;
-		final TaskListView taskListView = view;
-		final MenuManager subMenuManager = new MenuManager(CHOOSE_HIGHLIGHTER);
-		for (final Highlighter highlighter : MylarUiPlugin.getDefault().getHighlighters()) {
-			if (selectedElement instanceof ITaskListElement) {
-				Action action = new Action() {
-					@Override
-					public void run() {
-						ITask task = null;
-						if (selectedElement instanceof ITask) {
-							task = (ITask) selectedElement;
-						} else if (selectedElement instanceof AbstractQueryHit) {
-							if (((AbstractQueryHit) selectedElement).getCorrespondingTask() != null) {
-								task = ((AbstractQueryHit) selectedElement).getCorrespondingTask();
-							}
-						}
-						if (task != null) {
-							MylarUiPlugin.getDefault().setHighlighterMapping(task.getHandleIdentifier(),
-									highlighter.getName());
-							taskListView.getViewer().refresh();
-							MylarPlugin.getContextManager().notifyPostPresentationSettingsChange(
-									IMylarContextListener.UpdateKind.HIGHLIGHTER);
-						}
-					}
-				};
-				if (highlighter.isGradient()) {
-					action.setImageDescriptor(new HighlighterImageDescriptor(highlighter.getBase(), highlighter
-							.getLandmarkColor()));
-				} else {
-					action.setImageDescriptor(new HighlighterImageDescriptor(highlighter.getLandmarkColor(),
-							highlighter.getLandmarkColor()));
-				}
-				action.setText(highlighter.toString());
-				subMenuManager.add(action);
-			}
-		}
-		subMenuManager.add(new Separator());
-		subMenuManager.add(new EditHighlightersAction());
-		return subMenuManager;
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/TaskListInterestFilter.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/TaskListInterestFilter.java
deleted file mode 100644
index a24699c..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/TaskListInterestFilter.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
-import org.eclipse.mylar.internal.tasklist.ui.AbstractTaskListFilter;
-import org.eclipse.mylar.internal.tasklist.ui.actions.NewLocalTaskAction;
-import org.eclipse.mylar.provisional.tasklist.AbstractQueryHit;
-import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryTask;
-import org.eclipse.mylar.provisional.tasklist.ITask;
-import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
-import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryTask.RepositoryTaskSyncState;
-
-/**
- * Goal is to have this reuse as much of the super as possible.
- * 
- * @author Mik Kersten
- */
-public class TaskListInterestFilter extends AbstractTaskListFilter {
-
-	@Override
-	public boolean select(Object object) {
-		try {
-			if (object instanceof ITask || object instanceof AbstractQueryHit) {
-				ITask task = null;
-				if (object instanceof ITask) {
-					task = (ITask) object;
-				} else if (object instanceof AbstractQueryHit) {
-					task = ((AbstractQueryHit) object).getCorrespondingTask();
-				}
-				if (task != null) {
-					if (isUninteresting(task)) {
-						return false;
-					} else if (isInteresting(task)) {
-						return true;
-					}
-				} else if (object instanceof AbstractQueryHit) {
-					return true;
-				}
-			}
-		} catch (Throwable t) {
-			MylarStatusHandler.fail(t, "interest filter failed", false);
-		}
-		return false;
-	}
-
-	protected boolean isUninteresting(ITask task) {
-		return !task.isActive()
-				&& ((task.isCompleted() 
-						&& !MylarTaskListPlugin.getTaskListManager().isCompletedToday(task)
-						&& !hasChanges(task)) 
-					|| (MylarTaskListPlugin.getTaskListManager().isReminderAfterThisWeek(task)) && !hasChanges(task));
-	}
-
-	// TODO: make meta-context more explicit
-	protected boolean isInteresting(ITask task) {
-		return shouldAlwaysShow(task);
-	}
-
-	@Override
-	public boolean shouldAlwaysShow(ITask task) {
-		return super.shouldAlwaysShow(task) 
-			|| hasChanges(task) 
-			|| (MylarTaskListPlugin.getTaskListManager().isCompletedToday(task))
-			|| (isInterestingForThisWeek(task) && !task.isCompleted())
-			|| NewLocalTaskAction.DESCRIPTION_DEFAULT.equals(task.getDescription());
-	}
-
-	public static boolean isInterestingForThisWeek(ITask task) {
-		return MylarTaskListPlugin.getTaskListManager().isReminderThisWeek(task)
-			|| MylarTaskListPlugin.getTaskListManager().isReminderToday(task) 
-			|| task.isPastReminder();
-	}
-
-	public static boolean hasChanges(ITask task) {
-		if (task instanceof AbstractRepositoryTask) {
-			AbstractRepositoryTask repositoryTask = (AbstractRepositoryTask) task;
-			if (repositoryTask.getSyncState() == RepositoryTaskSyncState.OUTGOING) {
-				return true;
-			} else if (repositoryTask.getSyncState() == RepositoryTaskSyncState.INCOMING) {
-				return true;
-			} else if (repositoryTask.getSyncState() == RepositoryTaskSyncState.CONFLICT) {
-				return true;
-			}
-		}
-		return false;
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/TaskListInterestSorter.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/TaskListInterestSorter.java
deleted file mode 100644
index 8de3b47..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/TaskListInterestSorter.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import org.eclipse.jface.viewers.Viewer;
-import org.eclipse.jface.viewers.ViewerSorter;
-import org.eclipse.mylar.internal.tasklist.ui.views.TaskKeyComparator;
-import org.eclipse.mylar.provisional.tasklist.AbstractQueryHit;
-import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryQuery;
-import org.eclipse.mylar.provisional.tasklist.AbstractTaskContainer;
-import org.eclipse.mylar.provisional.tasklist.ITask;
-import org.eclipse.mylar.provisional.tasklist.ITaskListElement;
-import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
-import org.eclipse.mylar.provisional.tasklist.TaskArchive;
-
-/**
- * @author Mik Kersten
- */
-public class TaskListInterestSorter extends ViewerSorter {
-
-	private TaskKeyComparator taskKeyComparator = new TaskKeyComparator();
-	
-	@Override
-	public int compare(Viewer compareViewer, Object o1, Object o2) {
-		if (o1 instanceof AbstractTaskContainer && o2 instanceof TaskArchive) {
-			return -1;
-		} else if (o2 instanceof AbstractTaskContainer && o1 instanceof TaskArchive) {
-			return 1;
-		}
-
-		if (o1 instanceof AbstractTaskContainer && o2 instanceof ITask) {
-			return 1;
-		}
-		if (o1 instanceof AbstractTaskContainer || o1 instanceof AbstractRepositoryQuery) {
-			if (o2 instanceof AbstractTaskContainer || o2 instanceof AbstractRepositoryQuery) {
-				return ((ITaskListElement) o1).getDescription().compareTo(((ITaskListElement) o2).getDescription());
-			} else {
-				return -1;
-			}
-		} else if (o1 instanceof ITaskListElement) {
-			if (o2 instanceof AbstractTaskContainer || o2 instanceof AbstractRepositoryQuery) {
-				return -1;
-			} else if (o2 instanceof ITaskListElement) {
-				ITaskListElement element1 = (ITaskListElement) o1;
-				ITaskListElement element2 = (ITaskListElement) o2;
-				
-				ITask task1 = null;
-				ITask task2 = null;
-				if (element1 instanceof AbstractQueryHit) {
-					task1 = ((AbstractQueryHit)element1).getCorrespondingTask();
-					if (task1 == null) {
-						return 1;
-					}
-				} else if (element1 instanceof ITask) {
-					task1 = (ITask)element1;
-				}				
-				if (element2 instanceof AbstractQueryHit) {
-					task2 = ((AbstractQueryHit)element2).getCorrespondingTask();
-					if (task2 == null) {
-						return -1;
-					}
-				} else if (element2 instanceof ITask) {
-					task2 = (ITask)element2;
-				}
-				
-				int complete = compareCompleted(task1, task2);
-				if (complete != 0) {
-					return complete;
-				} else {
-					int thisWeek = compareThisWeek(task1, task2);
-					if (thisWeek != 0) {
-						return thisWeek;
-					} else {
-						int today = compareToday(task1, task2);
-						if (today != 0) {
-							return today;
-						} else {
-							int overdue = compareOverdue(task1, task2);
-							if (overdue != 0) {
-								return overdue;
-							} else {
-								int hasChanges = compareChanges(task1, task2);
-								if (hasChanges != 0) {
-									return hasChanges;
-								}
-							}
-						}
-					}
-				} 
-				return comparePrioritiesAndKeys(element1, element2);
-			}
-		} 
-		return 0;
-	}
-
-	private int compareOverdue(ITask task1, ITask task2) {
-		if (task1.isPastReminder() && !task2.isPastReminder()) {
-			return 1;
-		} else if (!task1.isPastReminder() && task2.isPastReminder()) {
-			return -1;
-		} else if (task1.isPastReminder() && task2.isPastReminder()){
-			return comparePrioritiesAndKeys(task1, task2);
-		} else {
-			return 0;
-		}
-	}
-
-	private int compareToday(ITask task1, ITask task2) {
-		if (MylarTaskListPlugin.getTaskListManager().isReminderToday(task1) && !MylarTaskListPlugin.getTaskListManager().isReminderToday(task2)) {
-			return 1;
-		} else if (!MylarTaskListPlugin.getTaskListManager().isReminderToday(task1) && MylarTaskListPlugin.getTaskListManager().isReminderToday(task2)) {
-			return -1;
-		} else if (MylarTaskListPlugin.getTaskListManager().isReminderToday(task1) && MylarTaskListPlugin.getTaskListManager().isReminderToday(task2)) {
-			return comparePrioritiesAndKeys(task1, task2);
-		} else {
-			return 0;
-		}
-	}
-
-	private int compareChanges(ITask task1, ITask task2) {
-		if (TaskListInterestFilter.hasChanges(task1)
-				&& !TaskListInterestFilter.hasChanges(task2)) {
-			return 1;
-		} else if (!TaskListInterestFilter.hasChanges(task1)
-				&& TaskListInterestFilter.hasChanges(task2)) {
-			return -1;
-		} else if (TaskListInterestFilter.hasChanges(task1)
-				&& TaskListInterestFilter.hasChanges(task2)) {
-			return comparePrioritiesAndKeys(task1, task2);
-		} else {
-			return 0;
-		}
-	}
-	
-	private int compareThisWeek(ITask task1, ITask task2) {
-		if (MylarTaskListPlugin.getTaskListManager().isReminderThisWeek(task1)
-				&& !MylarTaskListPlugin.getTaskListManager().isReminderThisWeek(task2)) {
-			return 1;
-		} else if (!MylarTaskListPlugin.getTaskListManager().isReminderThisWeek(task1)
-				&& MylarTaskListPlugin.getTaskListManager().isReminderThisWeek(task2)) {
-			return -1;
-		} else if (MylarTaskListPlugin.getTaskListManager().isReminderThisWeek(task1)
-				&& MylarTaskListPlugin.getTaskListManager().isReminderThisWeek(task2)) {
-			return comparePrioritiesAndKeys(task1, task2);
-		} else {
-			return 0;
-		}
-	}
-
-	private int compareCompleted(ITask task1, ITask task2) {
-		if (task1.isCompleted() && !task2.isCompleted()) {
-			return 1;
-		} else if (!task1.isCompleted() && task2.isCompleted()) {
-			return -1;
-		} else if (task1.isCompleted() && task2.isCompleted()){
-			return comparePrioritiesAndKeys(task1, task2);
-		} else {
-			return 0;
-		}
-	}
-
-	private int comparePrioritiesAndKeys(ITaskListElement element1, ITaskListElement element2) {
-		int priority = comparePriorities(element1, element2);
-		if (priority != 0) {
-			return priority;
-		} 
-		
-		int description = compareKeys(element1, element2);
-		if (description != 0) {
-			return description;
-		}
-		return 0;
-	}
-
-	private int compareKeys(ITaskListElement element1, ITaskListElement element2) {
-		return taskKeyComparator.compare(element1.getDescription(), element2.getDescription());
-	}
-
-	private int comparePriorities(ITaskListElement element1, ITaskListElement element2) {
-		return element1.getPriority().compareTo(element2.getPriority());
-	}
-	
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/TaskStructureBridge.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/TaskStructureBridge.java
deleted file mode 100644
index 2db1cbe..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/TaskStructureBridge.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import java.util.Collections;
-import java.util.List;
-
-import org.eclipse.mylar.provisional.core.AbstractRelationProvider;
-import org.eclipse.mylar.provisional.core.IDegreeOfSeparation;
-import org.eclipse.mylar.provisional.core.IMylarStructureBridge;
-import org.eclipse.mylar.provisional.tasklist.AbstractQueryHit;
-import org.eclipse.mylar.provisional.tasklist.ITask;
-import org.eclipse.mylar.provisional.tasklist.ITaskListElement;
-import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
-
-/**
- * @author Mik Kersten
- */
-public class TaskStructureBridge implements IMylarStructureBridge {
-
-	public static final String CONTENT_TYPE = "meta/task";
-	
-	public void setParentBridge(IMylarStructureBridge bridge) {
-		// ignore
-	}
-
-	public String getContentType() {
-		return CONTENT_TYPE;
-	}
-
-	public String getHandleIdentifier(Object object) {
-		if (object instanceof ITask) {
-			return ((ITask)object).getHandleIdentifier();
-		} else {
-			return null;
-		}
-	}
-
-	public String getParentHandle(String handle) {
-		return null;
-	}
-
-	public Object getObjectForHandle(String handle) {
-		return MylarTaskListPlugin.getTaskListManager().getTaskList().getTask(handle);
-	}
-
-	public List<String> getChildHandles(String handle) {
-		return Collections.emptyList();
-	}
-
-	public String getName(Object object) {
-		if (object instanceof ITask) {
-			return ((ITask)object).getDescription();
-		} else {
-			return null;
-		}
-	}
-
-	public boolean canBeLandmark(String handle) {
-		return false;
-	}
-
-	public boolean acceptsObject(Object object) {
-		return object instanceof ITaskListElement;
-	}
-
-	public boolean canFilter(Object object) {
-		return object instanceof ITask || object instanceof AbstractQueryHit;
-	}
-
-	public boolean isDocument(String handle) {
-		return getObjectForHandle(handle) instanceof ITask;
-	}
-
-	public String getHandleForOffsetInObject(Object resource, int offset) {
-		return null;
-	}
-
-	public String getContentType(String elementHandle) {
-		return getContentType();
-	}
-
-	public List<AbstractRelationProvider> getRelationshipProviders() {
-		return null;
-	}
-
-	public List<IDegreeOfSeparation> getDegreesOfSeparation() {
-		return null;
-	}
-
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/TaskUiBridge.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/TaskUiBridge.java
deleted file mode 100644
index 4299da1..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/TaskUiBridge.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import java.util.Collections;
-import java.util.List;
-
-import org.eclipse.jface.text.TextSelection;
-import org.eclipse.jface.viewers.TreeViewer;
-import org.eclipse.mylar.internal.tasklist.ui.editors.MylarTaskEditor;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.ui.IMylarUiBridge;
-import org.eclipse.ui.IEditorInput;
-import org.eclipse.ui.IEditorPart;
-
-/**
- * @author Mik Kersten
- */
-public class TaskUiBridge implements IMylarUiBridge {
-
-	public void open(IMylarElement node) {
-		// ignore
-	}
-
-	public void setContextCapturePaused(boolean paused) {
-		// ignore
-	}
-
-	public void restoreEditor(IMylarElement document) {
-		// ignore
-	}
-
-	public void close(IMylarElement node) {
-		// ignore
-	}
-
-	public boolean acceptsEditor(IEditorPart editorPart) {
-		return editorPart instanceof MylarTaskEditor;
-	}
-
-	public List<TreeViewer> getContentOutlineViewers(IEditorPart editorPart) {
-		return Collections.emptyList();
-	}
-
-	public Object getObjectForTextSelection(TextSelection selection, IEditorPart editor) {
-		return null;
-	}
-
-	public IMylarElement getElement(IEditorInput input) {
-		return null;
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/UiUtil.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/UiUtil.java
deleted file mode 100644
index cf315fb..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/UiUtil.java
+++ /dev/null
@@ -1,115 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui;
-
-import org.eclipse.jface.dialogs.MessageDialog;
-import org.eclipse.mylar.internal.core.MylarContextManager;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-import org.eclipse.swt.graphics.Color;
-import org.eclipse.swt.widgets.Display;
-
-/**
- * @author Mik Kersten
- */
-public class UiUtil {
-
-	public static void displayInterestManipulationFailure() {
-		MessageDialog.openInformation(Display.getCurrent().getActiveShell(), "Mylar Interest Manipulation",
-				"Not a valid landmark, select an element within this resource instead.");
-	}
-
-	public static Color getBackgroundForElement(IMylarElement node) {
-		return getBackgroundForElement(node, false);
-	}
-
-	public static Color getBackgroundForElement(IMylarElement node, boolean resolveContextColor) {
-		if (node == null)
-			return null;
-		if (!resolveContextColor && (node.getInterest().isPropagated() || node.getInterest().isPredicted())) {
-			return null;
-		}
-
-		boolean isMultiple = false;
-		String contextId = MylarPlugin.getContextManager().getDominantContextHandleForElement(node);
-
-		if (contextId != null) {
-			Highlighter highlighter = MylarUiPlugin.getDefault().getHighlighterForContextId(contextId);
-			if (highlighter == null) {
-				return null;
-			} else if (MylarUiPlugin.getDefault().isIntersectionMode()) {
-				if (isMultiple) {
-					return MylarUiPlugin.getDefault().getIntersectionHighlighter().getHighlightColor();
-				} else {
-					return null;
-				}
-			} else {
-				return highlighter.getHighlight(node, false);
-			}
-		} else {
-			return MylarUiPlugin.getDefault().getColorMap().BACKGROUND_COLOR;
-		}
-	}
-
-	public static Color getForegroundForElement(IMylarElement node) {
-		if (node == null)
-			return null;
-		if (node.getInterest().isPredicted() || node.getInterest().isPropagated()) {
-			if (node.getInterest().getValue() >= MylarContextManager.getScalingFactors().getLandmark() / 3) {
-				return MylarUiPlugin.getDefault().getColorMap().GRAY_DARK;
-			} else if (node.getInterest().getValue() >= 10) {
-				return MylarUiPlugin.getDefault().getColorMap().GRAY_MEDIUM;
-			} else {
-				return MylarUiPlugin.getDefault().getColorMap().GRAY_LIGHT;
-			}
-		} else if (node.getInterest().isLandmark()) {
-			return MylarUiPlugin.getDefault().getColorMap().LANDMARK;
-		} else if (node.getInterest().isInteresting()) {
-			return null;
-		}
-		return MylarUiPlugin.getDefault().getColorMap().GRAY_MEDIUM;
-	}
-}
-
-// if (node instanceof CompositeContextElement) {
-// CompositeContextElement compositeNode = (CompositeContextElement)node;
-// if (compositeNode.getNodes().isEmpty()) return null;
-// dominantNode = (IMylarElement)compositeNode.getNodes().toArray()[0];
-// if (compositeNode.getNodes().size() > 1) isMultiple = true;
-//            
-// for(IMylarElement concreteNode : compositeNode.getNodes()) {
-// if (dominantNode != null
-// && dominantNode.getDegreeOfInterest().getValue() <
-// concreteNode.getDegreeOfInterest().getValue()) {
-// dominantNode = concreteNode;
-// }
-// }
-// } else if (node instanceof MylarContextElement) {
-// dominantNode = node;
-// }
-// List<Highlighter> highlighters = new ArrayList<Highlighter>();
-// for (Iterator<IDegreeOfInterest> it =
-// compositeDoiInfo.getComposite().getInfos().iterator(); it.hasNext();) {
-// IDegreeOfInterest specificInfo = it.next();
-// Taskscape taskscape = specificInfo.getCorrespondingTaskscape();
-// Highlighter highlighter =
-// MylarUiPlugin.getDefault().getHighlighterForTaskId(taskscape.getId());
-// if (highlighter != null) highlighters.add(highlighter);
-// }
-// if (highlighters.size() == 0) {
-// return MylarUiPlugin.getDefault().getColorMap().BACKGROUND_COLOR;
-// } else if (highlighters.size() == 1) {
-// return highlighters.get(0).getHighlight(info, false);
-// } else {
-// return Highlighter.blend(highlighters, info, false);
-// }
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/AbstractApplyMylarAction.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/AbstractApplyMylarAction.java
deleted file mode 100644
index 27f6fb3..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/AbstractApplyMylarAction.java
+++ /dev/null
@@ -1,264 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui.actions;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.WeakHashMap;
-
-import org.eclipse.jface.action.Action;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.jface.viewers.StructuredViewer;
-import org.eclipse.jface.viewers.TreeViewer;
-import org.eclipse.jface.viewers.ViewerFilter;
-import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
-import org.eclipse.mylar.internal.ui.MylarImages;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.ui.InterestFilter;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-import org.eclipse.swt.widgets.Event;
-import org.eclipse.ui.IActionDelegate2;
-import org.eclipse.ui.IViewActionDelegate;
-import org.eclipse.ui.IViewPart;
-import org.eclipse.ui.IWorkbenchWindowActionDelegate;
-import org.eclipse.ui.PlatformUI;
-
-/**
- * Extending this class makes it possible to apply Mylar management to a
- * structured view (e.g. to provide interest-based filtering).
- * 
- * @author Mik Kersten
- */
-public abstract class AbstractApplyMylarAction extends Action implements IViewActionDelegate, IActionDelegate2 {
-
-	private static final String ACTION_LABEL = "Apply Mylar";
-
-	public static final String PREF_ID_PREFIX = "org.eclipse.mylar.ui.interest.filter.";
-
-	protected String globalPrefId;
-
-	protected IAction initAction = null;
-
-	protected final InterestFilter interestFilter;
-
-	protected IViewPart viewPart;
-
-	protected Map<StructuredViewer, List<ViewerFilter>> previousFilters = new WeakHashMap<StructuredViewer, List<ViewerFilter>>();
-
-	private static Map<IViewPart, AbstractApplyMylarAction> partMap = new WeakHashMap<IViewPart, AbstractApplyMylarAction>();
-
-	public static AbstractApplyMylarAction getActionForPart(IViewPart part) {
-		return partMap.get(part);
-	}
-
-	public IViewPart getPartForAction() {
-		if (viewPart == null) {
-			if (this instanceof IWorkbenchWindowActionDelegate) {
-				throw new RuntimeException("not supported on IWorkbenchWindowActionDelegate");
-			} else {
-				throw new RuntimeException("error: viewPart is null");
-			}
-		}
-		return viewPart;
-	}
-
-	public AbstractApplyMylarAction(InterestFilter interestFilter) {
-		super();
-		this.interestFilter = interestFilter;
-		setText(ACTION_LABEL);
-		setToolTipText(ACTION_LABEL);
-		setImageDescriptor(MylarImages.INTEREST_FILTERING);
-	}
-
-	public void init(IAction action) {
-		initAction = action;
-		setChecked(action.isChecked());
-	}
-
-	public void init(IViewPart view) {
-		String id = view.getSite().getId();
-		globalPrefId = PREF_ID_PREFIX + id;
-		viewPart = view;
-		partMap.put(view, this);
-	}
-
-	public void run(IAction action) {
-		setChecked(action.isChecked());
-		valueChanged(action, action.isChecked(), true);
-	}
-
-	/**
-	 * Don't update if the preference has not been initialized.
-	 */
-	public void update() {
-		if (globalPrefId != null) {
-			update(MylarPlugin.getDefault().getPreferenceStore().getBoolean(globalPrefId));
-		}
-	}
-
-	/**
-	 * This operation is expensive.
-	 */
-	public void update(boolean on) {
-		valueChanged(initAction, on, false);
-	}
-
-	protected void valueChanged(IAction action, final boolean on, boolean store) {
-		if (PlatformUI.getWorkbench().isClosing()) {
-			return;
-		}
-		try {
-			MylarPlugin.getContextManager().setContextCapturePaused(true);
-			setChecked(on);
-			action.setChecked(on);
-			if (store && MylarPlugin.getDefault() != null) {
-				MylarPlugin.getDefault().getPreferenceStore().setValue(globalPrefId, on);
-			}
-
-			for (StructuredViewer viewer : getViewers()) {
-				if (viewPart != null && !viewer.getControl().isDisposed()) {
-					MylarUiPlugin.getDefault().getViewerManager().addManagedViewer(viewer, viewPart);
-				}
-				updateInterestFilter(on, viewer);
-			}
-		} catch (Throwable t) {
-			MylarStatusHandler.fail(t, "Could not install viewer manager on: " + globalPrefId, false);
-		} finally {
-			MylarPlugin.getContextManager().setContextCapturePaused(false);
-		}
-	}
-
-	/**
-	 * Public for testing
-	 */
-	public void updateInterestFilter(final boolean on, StructuredViewer viewer) {
-		if (viewer != null) {
-			if (on) {
-				installInterestFilter(viewer);
-				MylarUiPlugin.getDefault().getViewerManager().addFilteredViewer(viewer);
-			} else {
-				MylarUiPlugin.getDefault().getViewerManager().removeFilteredViewer(viewer);
-				uninstallInterestFilter(viewer);
-			}
-		}
-	}
-
-	/**
-	 * Public for testing
-	 */
-	public abstract List<StructuredViewer> getViewers();
-
-	/**
-	 * @return filters that should not be removed when the interest filter is
-	 *         installed
-	 */
-	public abstract List<Class> getPreservedFilters();
-
-	protected boolean installInterestFilter(StructuredViewer viewer) {
-		if (viewer == null) {
-			MylarStatusHandler.log("The viewer to install InterestFilter is null", this);
-			return false;
-		} else if (viewer.getControl().isDisposed()) {
-			// TODO: do this with part listener, not lazily?
-			MylarUiPlugin.getDefault().getViewerManager().removeManagedViewer(viewer, viewPart);
-			return false;
-		}
-
-		try {
-			viewer.getControl().setRedraw(false);
-			previousFilters.put(viewer, Arrays.asList(viewer.getFilters()));
-			List<Class> excludedFilters = getPreservedFilters();
-			for (ViewerFilter filter : previousFilters.get(viewer)) {
-				if (!excludedFilters.contains(filter.getClass())) {
-					try {
-						viewer.removeFilter(filter);
-					} catch (Throwable t) {
-						MylarStatusHandler.fail(t, "Failed to remove filter: " + filter, false);
-					}
-				}
-			}
-			viewer.addFilter(interestFilter);
-			if (viewer instanceof TreeViewer) {
-				((TreeViewer) viewer).expandAll();
-			}
-			viewer.getControl().setRedraw(true);
-			return true;
-		} catch (Throwable t) {
-			MylarStatusHandler.fail(t, "Could not install viewer filter on: " + globalPrefId, false);
-		}
-		return false;
-	}
-
-	protected void uninstallInterestFilter(StructuredViewer viewer) {
-		if (viewer == null) {
-			MylarStatusHandler.log("Could not uninstall interest filter", this);
-			return;
-		} else if (viewer.getControl().isDisposed()) {
-			// TODO: do this with part listener, not lazily?
-			MylarUiPlugin.getDefault().getViewerManager().removeManagedViewer(viewer, viewPart);
-			return;
-		}
-
-		viewer.getControl().setRedraw(false);
-		List<Class> excludedFilters = getPreservedFilters();
-		if (previousFilters.containsKey(viewer)) {
-			for (ViewerFilter filter : previousFilters.get(viewer)) {
-				if (!excludedFilters.contains(filter.getClass())) {
-					try {
-						viewer.addFilter(filter);
-					} catch (Throwable t) {
-						MylarStatusHandler.fail(t, "Failed to remove filter: " + filter, false);
-					}
-				}
-			}
-			previousFilters.remove(viewer);
-		}
-//		previousFilters.remove(key)();
-		for (ViewerFilter filter : Arrays.asList(viewer.getFilters())) {
-			if (filter instanceof InterestFilter) {
-				viewer.removeFilter(interestFilter);
-			}
-		}
-		viewer.getControl().setRedraw(true);
-	}
-
-	public void selectionChanged(IAction action, ISelection selection) {
-		// ignore
-	}
-
-	public void dispose() {
-		partMap.remove(getPartForAction());
-		if (viewPart != null && !PlatformUI.getWorkbench().isClosing()) {
-			for (StructuredViewer viewer : getViewers()) {
-				MylarUiPlugin.getDefault().getViewerManager().removeManagedViewer(viewer, viewPart);
-			}
-		}
-	}
-
-	public void runWithEvent(IAction action, Event event) {
-		run(action);
-	}
-
-	public String getGlobalPrefId() {
-		return globalPrefId;
-	}
-
-	/**
-	 * For testing.
-	 */
-	public InterestFilter getInterestFilter() {
-		return interestFilter;
-	}
-
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/AbstractInterestManipulationAction.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/AbstractInterestManipulationAction.java
deleted file mode 100644
index 8dd0f3c..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/AbstractInterestManipulationAction.java
+++ /dev/null
@@ -1,109 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui.actions;
-
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.dialogs.MessageDialog;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.mylar.internal.ui.UiUtil;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.IMylarStructureBridge;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.ui.IViewActionDelegate;
-import org.eclipse.ui.IViewPart;
-import org.eclipse.ui.IWorkbenchWindow;
-import org.eclipse.ui.IWorkbenchWindowActionDelegate;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.ui.internal.ObjectPluginAction;
-
-/**
- * @author Mik Kersten
- */
-public abstract class AbstractInterestManipulationAction implements IViewActionDelegate, IWorkbenchWindowActionDelegate {
-
-	private static final String MESSAGE_NO_CONTEXT = "No task context is active, or element not found in context";
-
-	public static final String SOURCE_ID = "org.eclipse.mylar.ui.interest.user";
-
-	protected IViewPart view;
-
-	public void init(IWorkbenchWindow window) {
-		// don't have anything to initialize
-	}
-
-	public void init(IViewPart view) {
-		this.view = view;
-	}
-
-	protected abstract boolean isIncrement();
-
-	public void run(IAction action) {
-		boolean increment = isIncrement();
-		ISelection currentSelection = null;
-		if (action instanceof ObjectPluginAction) {
-			ObjectPluginAction objectAction = (ObjectPluginAction) action;
-			currentSelection = objectAction.getSelection();
-		} else {
-			try {
-				currentSelection = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getSelection();
-			} catch (Exception e) {
-				// ignore
-			}
-		}
-
-		if (currentSelection instanceof StructuredSelection) {
-			StructuredSelection selection = (StructuredSelection) currentSelection;
-			for (Object object : selection.toList()) {
-				IMylarElement node = null;
-				if (object instanceof IMylarElement) {
-					node = (IMylarElement) object;
-				} else {
-					IMylarStructureBridge bridge = MylarPlugin.getDefault().getStructureBridge(object);
-					String handle = bridge.getHandleIdentifier(object);
-					node = MylarPlugin.getContextManager().getElement(handle);
-				}
-				if (node != null) {
-					boolean manipulated = MylarPlugin.getContextManager().manipulateInterestForElement(node, increment, false, SOURCE_ID);
-					if (!manipulated) {
-						UiUtil.displayInterestManipulationFailure();
-					}
-				} else {
-					MessageDialog.openInformation(Display.getCurrent().getActiveShell(), 
-							MylarTaskListPlugin.TITLE_DIALOG, MESSAGE_NO_CONTEXT);
-				}
-			}
-		} else {
-			IMylarElement node = MylarPlugin.getContextManager().getActiveElement();
-			if (node != null) {
-				boolean manipulated = MylarPlugin.getContextManager().manipulateInterestForElement(node, increment, false, SOURCE_ID);
-				if (!manipulated) {
-					UiUtil.displayInterestManipulationFailure();
-				}
-			} else {
-				MessageDialog.openInformation(Display.getCurrent().getActiveShell(), 
-						MylarTaskListPlugin.TITLE_DIALOG, MESSAGE_NO_CONTEXT);
-//				MylarStatusHandler.log("no active element for interest manipulation", this);
-			}
-		}
-	}
-
-	public void dispose() {
-		// ignore
-	}
-
-	public void selectionChanged(IAction action, ISelection selection) {
-		// ignore
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ApplyMylarToOutlineAction.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ApplyMylarToOutlineAction.java
deleted file mode 100644
index 6fc7a96..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ApplyMylarToOutlineAction.java
+++ /dev/null
@@ -1,116 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui.actions;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import org.eclipse.core.runtime.Preferences.PropertyChangeEvent;
-import org.eclipse.jface.viewers.DecoratingLabelProvider;
-import org.eclipse.jface.viewers.ILabelProvider;
-import org.eclipse.jface.viewers.StructuredViewer;
-import org.eclipse.jface.viewers.TreeViewer;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.ui.IMylarUiBridge;
-import org.eclipse.mylar.provisional.ui.InterestFilter;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-import org.eclipse.ui.IEditorPart;
-import org.eclipse.ui.IViewPart;
-import org.eclipse.ui.IWorkbenchPage;
-import org.eclipse.ui.IWorkbenchWindow;
-import org.eclipse.ui.PlatformUI;
-
-/**
- * @author Shawn Minto
- * @author Mik Kersten
- */
-public class ApplyMylarToOutlineAction extends AbstractApplyMylarAction {
-
-	// TODO: move or delete?
-	public static final String ID_CONTENT_OUTLINE = "org.eclipse.ui.views.ContentOutline";
-
-	public ApplyMylarToOutlineAction() {
-		super(new InterestFilter());
-	}
-
-	/**
-	 * TODO: refactor this optimization?
-	 */
-	public void update(IEditorPart editorPart) {
-		boolean on = MylarPlugin.getDefault().getPreferenceStore().getBoolean(getGlobalPrefId());
-
-		IMylarUiBridge bridge = MylarUiPlugin.getDefault().getUiBridgeForEditor(editorPart);
-		List<TreeViewer> outlineViewers = bridge.getContentOutlineViewers(editorPart);
-		for (TreeViewer viewer : outlineViewers) {
-			if (viewPart != null) {
-				MylarUiPlugin.getDefault().getViewerManager().addManagedViewer(viewer, viewPart);
-			}
-			updateInterestFilter(on, viewer);
-			configureDecorator(viewer);
-		}
-	}
-
-	/**
-	 * TODO: remove once all outlines have platform decorator
-	 */
-	private void configureDecorator(TreeViewer viewer) {
-		if (viewer != null) {
-			if (!(viewer.getLabelProvider() instanceof DecoratingLabelProvider)) {
-				viewer.setLabelProvider(new DecoratingLabelProvider((ILabelProvider) viewer.getLabelProvider(),
-						PlatformUI.getWorkbench().getDecoratorManager().getLabelDecorator()));
-			}
-		}
-	}
-
-	@SuppressWarnings("deprecation")
-	@Override
-	public List<StructuredViewer> getViewers() {
-		List<StructuredViewer> viewers = new ArrayList<StructuredViewer>();
-		if (PlatformUI.getWorkbench().isClosing()) {
-			return viewers;
-		}
-		for (IWorkbenchWindow w : PlatformUI.getWorkbench().getWorkbenchWindows()) {
-			IWorkbenchPage page = w.getActivePage();
-			if (page != null) {
-				IEditorPart[] parts = page.getEditors();
-				for (int i = 0; i < parts.length; i++) {
-					IMylarUiBridge bridge = MylarUiPlugin.getDefault().getUiBridgeForEditor(parts[i]);
-					List<TreeViewer> outlineViewers = bridge.getContentOutlineViewers(parts[i]);
-					for (TreeViewer viewer : outlineViewers) {
-						if (viewer != null && !viewers.contains(viewer))
-							viewers.add(viewer);
-					}
-				}
-			}
-		}
-		return viewers;
-	}
-
-	public void propertyChange(PropertyChangeEvent event) {
-		// ignore
-	}
-
-	@Override
-	public List<Class> getPreservedFilters() {
-		return Collections.emptyList();
-	}
-
-	public static ApplyMylarToOutlineAction getOutlineActionForEditor(IEditorPart part) {
-		IViewPart outlineView = part.getSite().getPage().findView(ID_CONTENT_OUTLINE);
-		if (outlineView != null) {
-			return (ApplyMylarToOutlineAction) AbstractApplyMylarAction.getActionForPart(outlineView);
-		} else {
-			return null;
-		}
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ApplyMylarToTaskListAction.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ApplyMylarToTaskListAction.java
deleted file mode 100644
index ddad1e2..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ApplyMylarToTaskListAction.java
+++ /dev/null
@@ -1,101 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui.actions;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import org.eclipse.core.runtime.Preferences.PropertyChangeEvent;
-import org.eclipse.jface.viewers.StructuredViewer;
-import org.eclipse.jface.viewers.ViewerSorter;
-import org.eclipse.mylar.internal.tasklist.ui.AbstractTaskListFilter;
-import org.eclipse.mylar.internal.tasklist.ui.views.TaskListView;
-import org.eclipse.mylar.internal.ui.TaskListInterestFilter;
-import org.eclipse.mylar.internal.ui.TaskListInterestSorter;
-import org.eclipse.mylar.provisional.ui.InterestFilter;
-import org.eclipse.ui.IViewPart;
-
-/**
- * TODO: abuses contract from super class
- * 
- * @author Mik Kersten
- */
-public class ApplyMylarToTaskListAction extends AbstractApplyMylarAction {
-
-	private TaskListInterestFilter taskListInterestFilter = new TaskListInterestFilter();
-
-	private TaskListInterestSorter taskListInterestSorter = new TaskListInterestSorter();
-
-	private Set<AbstractTaskListFilter> previousFilters = new HashSet<AbstractTaskListFilter>();
-
-	private ViewerSorter previousSorter;
-
-	public ApplyMylarToTaskListAction() {
-		super(new InterestFilter());
-	}
-
-	@Override
-	public List<StructuredViewer> getViewers() {
-		List<StructuredViewer> viewers = new ArrayList<StructuredViewer>();
-		IViewPart part = super.getPartForAction();
-		if (part instanceof TaskListView) {
-			viewers.add(((TaskListView) part).getViewer());
-		}
-		return viewers;
-	}
-
-	@Override
-	protected boolean installInterestFilter(StructuredViewer viewer) {
-		IViewPart part = super.getPartForAction();
-		if (part instanceof TaskListView) {
-			TaskListView taskListView = (TaskListView) part;
-			previousSorter = TaskListView.getFromActivePerspective().getViewer().getSorter();
-			taskListView.getViewer().setSorter(taskListInterestSorter);
-			previousFilters = new HashSet<AbstractTaskListFilter>(taskListView.getFilters());
-			taskListView.clearFilters(true);
-			taskListView.addFilter(taskListInterestFilter);
-			taskListView.setPriorityButtonEnabled(false);
-			taskListView.refreshAndFocus();
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	@Override
-	protected void uninstallInterestFilter(StructuredViewer viewer) {
-		IViewPart part = super.getPartForAction();
-		if (part instanceof TaskListView) {
-			TaskListView taskListView = (TaskListView) part;
-			taskListView.getViewer().setSorter(previousSorter);
-			taskListView.removeFilter(taskListInterestFilter);
-			taskListView.setPriorityButtonEnabled(true);
-			for (AbstractTaskListFilter filter : previousFilters) {
-				TaskListView.getFromActivePerspective().addFilter(filter);
-			}
-			taskListView.getViewer().collapseAll();
-			taskListView.refreshAndFocus();
-		} 
-	}
-
-	public void propertyChange(PropertyChangeEvent event) {
-		// ignore
-	}
-
-	@Override
-	public List<Class> getPreservedFilters() {
-		return Collections.emptyList();
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ContextAttachAction.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ContextAttachAction.java
deleted file mode 100644
index 7b62049..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ContextAttachAction.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui.actions;
-
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.dialogs.Dialog;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.jface.wizard.WizardDialog;
-import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
-import org.eclipse.mylar.internal.tasklist.ui.views.TaskListView;
-import org.eclipse.mylar.internal.tasklist.ui.wizards.ContextAttachWizard;
-import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryTask;
-import org.eclipse.mylar.provisional.tasklist.ITask;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.ui.IViewActionDelegate;
-import org.eclipse.ui.IViewPart;
-import org.eclipse.ui.PlatformUI;
-
-/**
- * @author Mik Kersten
- * @author Rob Elves
- */
-public class ContextAttachAction implements IViewActionDelegate {
-
-	ISelection selection = null;
-
-	IViewPart view = null;
-
-	public void init(IViewPart view) {
-		this.view = view;
-	}
-
-	public void run(IAction action) {
-		ITask task = TaskListView.getFromActivePerspective().getSelectedTask();
-		if (task instanceof AbstractRepositoryTask) {
-			try {	
-				ContextAttachWizard wizard = new ContextAttachWizard((AbstractRepositoryTask)task);
-				Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
-				if (wizard != null && shell != null && !shell.isDisposed()) {
-					WizardDialog dialog = new WizardDialog(shell, wizard);
-					dialog.create();
-					dialog.setTitle(ContextAttachWizard.WIZARD_TITLE);
-					dialog.setBlockOnOpen(true);
-					if (dialog.open() == Dialog.CANCEL) {
-						dialog.close();
-						return;
-					}
-				}
-			} catch (Exception e) {
-				MylarStatusHandler.fail(e, e.getMessage(), true);
-			}
-		}
-	}
-
-	public void selectionChanged(IAction action, ISelection selection) {
-		this.selection = selection;
-	}
-
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ContextClearAction.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ContextClearAction.java
deleted file mode 100644
index b12f081..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ContextClearAction.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui.actions;
-
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.dialogs.MessageDialog;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.mylar.internal.tasklist.ui.views.TaskListView;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.tasklist.ITask;
-import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
-import org.eclipse.ui.IViewActionDelegate;
-import org.eclipse.ui.IViewPart;
-import org.eclipse.ui.PlatformUI;
-
-/**
- * @author Mik Kersten
- */
-public class ContextClearAction implements IViewActionDelegate {
-
-	public static final String ID = "org.eclipse.mylar.ui.clear.context";
-
-	public void init(IViewPart view) {
-
-	}
-
-	public void run(IAction action) {
-		ITask task = TaskListView.getFromActivePerspective().getSelectedTask();
-		if (task instanceof ITask) {
-			boolean deleteConfirmed = MessageDialog.openQuestion(PlatformUI.getWorkbench().getActiveWorkbenchWindow()
-					.getShell(), "Confirm clear context", "Clear context for the selected task?");
-			if (!deleteConfirmed)
-				return;
-			
-			if (task.isActive()) {
-				MylarTaskListPlugin.getTaskListManager().deactivateTask(task);
-				MylarPlugin.getContextManager().deleteContext((task).getHandleIdentifier());
-				MylarTaskListPlugin.getTaskListManager().activateTask(task);
-			} else {
-				MylarPlugin.getContextManager().deleteContext((task).getHandleIdentifier());
-			}
-//			MylarPlugin.getContextManager().contextDeleted((task).getHandleIdentifier());																					// ((Task)selectedObject).getContextPath());
-//			MylarPlugin.getContextManager().contextActivated((task).getHandleIdentifier());
-																												// ((Task)selectedObject).getContextPath());
-			TaskListView.getFromActivePerspective().getViewer().refresh();
-		}
-	}
-
-	public void selectionChanged(IAction action, ISelection selection) {
-
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ContextRetrieveAction.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ContextRetrieveAction.java
deleted file mode 100644
index 7979ba9..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ContextRetrieveAction.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui.actions;
-
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.dialogs.Dialog;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.jface.wizard.WizardDialog;
-import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
-import org.eclipse.mylar.internal.tasklist.ui.views.TaskListView;
-import org.eclipse.mylar.internal.tasklist.ui.wizards.ContextRetrieveWizard;
-import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryTask;
-import org.eclipse.mylar.provisional.tasklist.ITask;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.ui.IViewActionDelegate;
-import org.eclipse.ui.IViewPart;
-import org.eclipse.ui.PlatformUI;
-
-/**
- * @author Mik Kersten
- * @author Rob Elves
- */
-public class ContextRetrieveAction implements IViewActionDelegate {
-	
-	ISelection selection = null;
-	
-	public void init(IViewPart view) {
-		// ignore
-	}
-
-	public void run(IAction action) {
-		ITask task = TaskListView.getFromActivePerspective().getSelectedTask();
-		if (task instanceof AbstractRepositoryTask) {
-			try {
-				ContextRetrieveWizard wizard = new ContextRetrieveWizard((AbstractRepositoryTask)task);
-				Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
-				if (wizard != null && shell != null && !shell.isDisposed()) {
-					WizardDialog dialog = new WizardDialog(shell, wizard);
-					dialog.create();
-					dialog.setTitle(ContextRetrieveWizard.WIZARD_TITLE);
-					dialog.setBlockOnOpen(true);
-					if (dialog.open() == Dialog.CANCEL) {
-						dialog.close();
-						return;
-					}
-				}
-			} catch (Exception e) {
-				MylarStatusHandler.fail(e, e.getMessage(), true);
-			}
-		}
-	}
-
-	public void selectionChanged(IAction action, ISelection selection) {
-		this.selection = selection;
-	}
-
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/EditHighlightersAction.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/EditHighlightersAction.java
deleted file mode 100644
index 3ff121d..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/EditHighlightersAction.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui.actions;
-
-import org.eclipse.jface.action.Action;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.preference.IPreferenceNode;
-import org.eclipse.jface.preference.IPreferencePage;
-import org.eclipse.jface.preference.PreferenceDialog;
-import org.eclipse.jface.preference.PreferenceManager;
-import org.eclipse.jface.preference.PreferenceNode;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.jface.window.Window;
-import org.eclipse.mylar.internal.ui.MylarImages;
-import org.eclipse.mylar.internal.ui.preferences.MylarPreferencePage;
-import org.eclipse.swt.custom.BusyIndicator;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.ui.IViewActionDelegate;
-import org.eclipse.ui.IViewPart;
-import org.eclipse.ui.PlatformUI;
-
-/**
- * @author Mik Kersten
- */
-public class EditHighlightersAction extends Action implements IViewActionDelegate {
-
-	public static final String ID = "org.eclipse.mylar.tasklist.actions.context.highlighters.edit";
-
-	public EditHighlightersAction() {
-		setText("Edit Highlighters...");
-		setToolTipText("Edit Highlighters...");
-		setId(ID);
-		setImageDescriptor(MylarImages.COLOR_PALETTE);
-	}
-
-	@Override
-	public void run() {
-		IPreferencePage page = new MylarPreferencePage();
-		showPreferencePage("org.eclipse.mylar.internal.ui.preferences", page);
-	}
-
-	protected void showPreferencePage(String id, IPreferencePage page) {
-		final IPreferenceNode targetNode = new PreferenceNode(id, page);
-
-		PreferenceManager manager = new PreferenceManager();
-		manager.addToRoot(targetNode);
-		final PreferenceDialog dialog = new PreferenceDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow()
-				.getShell(), manager);
-		final boolean[] result = new boolean[] { false };
-		BusyIndicator.showWhile(Display.getDefault(), new Runnable() {
-			public void run() {
-				dialog.create();
-				dialog.setMessage(targetNode.getLabelText());
-				result[0] = (dialog.open() == Window.OK);
-			}
-		});
-	}
-
-	public void init(IViewPart view) {
-
-	}
-
-	public void run(IAction action) {
-		run();
-	}
-
-	public void selectionChanged(IAction action, ISelection selection) {
-
-	}
-}
\ No newline at end of file
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/InterestDecrementAction.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/InterestDecrementAction.java
deleted file mode 100644
index 7961b34..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/InterestDecrementAction.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui.actions;
-
-/**
- * @author Mik Kersten
- */
-public class InterestDecrementAction extends AbstractInterestManipulationAction {
-
-	@Override
-	protected boolean isIncrement() {
-		return false;
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/InterestIncrementAction.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/InterestIncrementAction.java
deleted file mode 100644
index 3c19361..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/InterestIncrementAction.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui.actions;
-
-/**
- * @author Mik Kersten
- */
-public class InterestIncrementAction extends AbstractInterestManipulationAction {
-
-	@Override
-	protected boolean isIncrement() {
-		return true;
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/OpenPrefsAction.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/OpenPrefsAction.java
deleted file mode 100644
index dfb7620..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/OpenPrefsAction.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui.actions;
-
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.ui.IWorkbenchWindow;
-import org.eclipse.ui.IWorkbenchWindowActionDelegate;
-
-/**
- * @author Mik Kersten
- */
-public class OpenPrefsAction implements IWorkbenchWindowActionDelegate {
-
-	public void dispose() {
-		// don't care when we are disposed
-	}
-
-	public void init(IWorkbenchWindow window) {
-		// don't have anything to initialize
-	}
-
-	public void run(IAction action) {
-		// don't have anything to run
-	}
-
-	public void selectionChanged(IAction action, ISelection selection) {
-		// don't care about selection changes
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ToggleContextCaptureAction.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ToggleContextCaptureAction.java
deleted file mode 100644
index 0cde270..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ToggleContextCaptureAction.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui.actions;
-
-import org.eclipse.jface.action.Action;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.mylar.internal.tasklist.ui.views.TaskListView;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.ui.IViewActionDelegate;
-import org.eclipse.ui.IViewPart;
-
-/**
- * This action is not persistent, in order to avoid Mylar not working on
- * startup.
- * 
- * @author Mik Kersten
- */
-public class ToggleContextCaptureAction extends Action implements IViewActionDelegate {
-	
-	public void init(IViewPart view) {
-		// ignore
-	}
-
-	public void run(IAction action) {
-		setChecked(!action.isChecked());
-		if (isChecked()) {
-			resume();
-		} else {
-			pause();
-		}
-		// super.setChecked(!super.isChecked());
-	}
-
-	public void pause() {
-		MylarPlugin.getContextManager().setContextCapturePaused(true);
-		TaskListView.getFromActivePerspective().indicatePaused(true);
-	}
-
-	public void resume() {
-		MylarPlugin.getContextManager().setContextCapturePaused(false);
-		TaskListView.getFromActivePerspective().indicatePaused(false);
-	}
-
-	public void selectionChanged(IAction action, ISelection selection) {
-		// ignore
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ToggleDecorateInterestLevelAction.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ToggleDecorateInterestLevelAction.java
deleted file mode 100644
index 025076c..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ToggleDecorateInterestLevelAction.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui.actions;
-
-import org.eclipse.jface.action.Action;
-import org.eclipse.mylar.internal.ui.MylarImages;
-import org.eclipse.mylar.provisional.core.IMylarContextListener;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-
-/**
- * @author Mik Kersten
- */
-public class ToggleDecorateInterestLevelAction extends Action {
-
-	public static final String PREF_ID = "org.eclipse.mylar.ui.decorators.interest";
-
-	public ToggleDecorateInterestLevelAction() {
-		super();
-		setImageDescriptor(MylarImages.DECORATE_INTEREST);
-		setToolTipText("Toggle Interest Level Decorator");
-
-		boolean checked = MylarPlugin.getDefault().getPreferenceStore().getBoolean(PREF_ID);
-		valueChanged(checked, false);
-	}
-
-	@Override
-	public void run() {
-		valueChanged(isChecked(), true);
-	}
-
-	private void valueChanged(final boolean on, boolean store) {
-		setChecked(on);
-		if (store)
-			MylarPlugin.getDefault().getPreferenceStore().setValue(PREF_ID, on);
-		MylarUiPlugin.getDefault().setDecorateInterestMode(on);
-		MylarPlugin.getContextManager().notifyActivePresentationSettingsChange(IMylarContextListener.UpdateKind.UPDATE);
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ToggleGlobalInterestFilteringAction.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ToggleGlobalInterestFilteringAction.java
deleted file mode 100644
index 4e6053d..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ToggleGlobalInterestFilteringAction.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui.actions;
-
-import org.eclipse.jface.action.Action;
-import org.eclipse.mylar.internal.ui.MylarImages;
-import org.eclipse.mylar.provisional.core.IMylarContextListener;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-
-/**
- * @author Mik Kersten
- */
-public class ToggleGlobalInterestFilteringAction extends Action {
-
-	public static final String ID = "org.eclipse.mylar.ui.interest.filter.global";
-
-	public ToggleGlobalInterestFilteringAction() {
-		super();
-		setText("Apply Mylar to All Views");
-		setToolTipText("Apply Mylar to All Views");
-		setImageDescriptor(MylarImages.INTEREST_FILTERING);
-		setActionDefinitionId(ID);
-		// setChecked(MylarUiPlugin.getDefault().isGlobalFilteringEnabled());
-	}
-
-	@Override
-	public void run() {
-		setChecked(isChecked());
-		MylarUiPlugin.getDefault().setGlobalFilteringEnabled(isChecked());
-		MylarPlugin.getContextManager().notifyPostPresentationSettingsChange(IMylarContextListener.UpdateKind.UPDATE);
-		// MylarPlugin.getTaskscapeManager().notifyPostPresentationSettingsChange(
-		// ITaskscapeListener.UpdateKind.UPDATE);
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ToggleRelationshipProviderAction.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ToggleRelationshipProviderAction.java
deleted file mode 100644
index 74aa0a6..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/actions/ToggleRelationshipProviderAction.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-/*
- * Created on Jul 27, 2004
- */
-package org.eclipse.mylar.internal.ui.actions;
-
-import org.eclipse.jface.action.Action;
-import org.eclipse.jface.action.ActionContributionItem;
-import org.eclipse.jface.action.IMenuCreator;
-import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
-import org.eclipse.mylar.provisional.core.IDegreeOfSeparation;
-import org.eclipse.mylar.provisional.core.IMylarStructureBridge;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Menu;
-import org.eclipse.swt.widgets.MenuItem;
-
-/**
- * @author Mik Kersten
- */
-public class ToggleRelationshipProviderAction extends Action implements IMenuCreator {
-
-	private static final String LABEL_DEGREE_OF_SEPARATION = "Degree of Separation:";
-
-	public static final String ID = "org.eclipse.mylar.ui.actions.active.search.toggle";
-
-	private IMylarStructureBridge bridge;
-
-	private Menu dropDownMenu = null;
-
-	public ToggleRelationshipProviderAction(IMylarStructureBridge bridge) {
-		super();
-		this.bridge = bridge;
-		setImageDescriptor(MylarPlugin.getDefault().getActiveSearchIcon(bridge));
-		setId(ID);
-		setText(MylarPlugin.getDefault().getActiveSearchLabel(bridge));
-		setToolTipText(MylarPlugin.getDefault().getActiveSearchLabel(bridge));
-		setMenuCreator(this);
-
-		degreeOfSeparation = bridge.getRelationshipProviders().get(0).getCurrentDegreeOfSeparation();
-
-		if (degreeOfSeparation > 0)
-			run();
-	}
-
-	@Override
-	public void run() {
-		MylarPlugin.getContextManager()
-				.updateDegreesOfSeparation(bridge.getRelationshipProviders(), degreeOfSeparation);
-	}
-
-	public void dispose() {
-		if (dropDownMenu != null) {
-			dropDownMenu.dispose();
-			dropDownMenu = null;
-		}
-	}
-
-	public Menu getMenu(Control parent) {
-		if (dropDownMenu != null) {
-			dropDownMenu.dispose();
-		}
-		dropDownMenu = new Menu(parent);
-		addActionsToMenu();
-		return dropDownMenu;
-	}
-
-	public Menu getMenu(Menu parent) {
-		if (dropDownMenu != null) {
-			dropDownMenu.dispose();
-		}
-		dropDownMenu = new Menu(parent);
-		addActionsToMenu();
-		return dropDownMenu;
-	}
-
-	private int degreeOfSeparation = 0;
-
-	public void addActionsToMenu() {
-		// HACK: if there are multiple providers, all store the same current DOS
-		degreeOfSeparation = bridge.getRelationshipProviders().get(0).getCurrentDegreeOfSeparation();
-
-		MenuItem menuItem = new MenuItem(dropDownMenu, SWT.NONE);
-		menuItem.setText(LABEL_DEGREE_OF_SEPARATION);
-		// menuItem.setEnabled(false);
-
-		new MenuItem(dropDownMenu, SWT.SEPARATOR);
-
-		for (IDegreeOfSeparation separation : bridge.getDegreesOfSeparation()) {
-
-			Action degreeOfSeparationSelectionAction = new Action(
-					separation.getDegree() + ": " + separation.getLabel(), AS_CHECK_BOX) {
-				@Override
-				public void run() {
-					try {
-						degreeOfSeparation = Integer.parseInt(getId());
-						MylarPlugin.getContextManager().updateDegreesOfSeparation(bridge.getRelationshipProviders(),
-								degreeOfSeparation);
-					} catch (NumberFormatException e) {
-						// ignore this for now
-						MylarStatusHandler.fail(e, "invalid degree of separation", false);
-					}
-				}
-			};
-			degreeOfSeparationSelectionAction.setId("" + separation.getDegree());
-			degreeOfSeparationSelectionAction.setEnabled(true);
-			degreeOfSeparationSelectionAction.setToolTipText(separation.getLabel());
-			ActionContributionItem item = new ActionContributionItem(degreeOfSeparationSelectionAction);
-			item.fill(dropDownMenu, -1);
-
-			degreeOfSeparationSelectionAction.setChecked(false);
-			if (degreeOfSeparation == 0 && separation.getDegree() == 0) {
-				degreeOfSeparationSelectionAction.setChecked(true);
-			} else if (degreeOfSeparation != 0 && separation.getDegree() != 0
-					&& degreeOfSeparation == separation.getDegree()) {
-				degreeOfSeparationSelectionAction.setChecked(true);
-			}
-		}
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/preferences/MylarPreferencePage.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/preferences/MylarPreferencePage.java
deleted file mode 100644
index bb95d4a..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/preferences/MylarPreferencePage.java
+++ /dev/null
@@ -1,766 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-/*
- * Created on Feb 13, 2005
- *
- */
-package org.eclipse.mylar.internal.ui.preferences;
-
-import java.util.Arrays;
-
-import org.eclipse.jface.preference.IntegerFieldEditor;
-import org.eclipse.jface.preference.PreferencePage;
-import org.eclipse.jface.preference.StringFieldEditor;
-import org.eclipse.jface.viewers.CellEditor;
-import org.eclipse.jface.viewers.ColorCellEditor;
-import org.eclipse.jface.viewers.ComboBoxCellEditor;
-import org.eclipse.jface.viewers.ICellEditorListener;
-import org.eclipse.jface.viewers.ICellModifier;
-import org.eclipse.jface.viewers.IStructuredContentProvider;
-import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.jface.viewers.ITableLabelProvider;
-import org.eclipse.jface.viewers.LabelProvider;
-import org.eclipse.jface.viewers.TableViewer;
-import org.eclipse.jface.viewers.TextCellEditor;
-import org.eclipse.jface.viewers.Viewer;
-import org.eclipse.jface.viewers.ViewerSorter;
-import org.eclipse.mylar.internal.ui.Highlighter;
-import org.eclipse.mylar.internal.ui.HighlighterImageDescriptor;
-import org.eclipse.mylar.internal.ui.HighlighterList;
-import org.eclipse.mylar.internal.ui.MylarUiPrefContstants;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-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.graphics.Color;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.graphics.RGB;
-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.Display;
-import org.eclipse.swt.widgets.Group;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Table;
-import org.eclipse.swt.widgets.TableColumn;
-import org.eclipse.swt.widgets.TableItem;
-import org.eclipse.swt.widgets.Text;
-import org.eclipse.ui.IWorkbench;
-import org.eclipse.ui.IWorkbenchPreferencePage;
-import org.eclipse.ui.dialogs.PreferenceLinkArea;
-import org.eclipse.ui.internal.WorkbenchMessages;
-import org.eclipse.ui.preferences.IWorkbenchPreferenceContainer;
-
-/**
- * Preference page for mylar. Allows for adding / removing highlighters and
- * gamma settings.
- * 
- * @author Ken Sueda
- * @author Mik Kersten
- */
-public class MylarPreferencePage extends PreferencePage implements IWorkbenchPreferencePage, SelectionListener,
-		ICellEditorListener {
-
-	private StringFieldEditor exclusionFieldEditor;
-
-	private IntegerFieldEditor autoOpenEditorsNum;
-
-	private Table table;
-
-	private TableViewer tableViewer;
-
-	private ColorCellEditor colorDialogEditor;
-
-	private Highlighter selection = null;
-
-	private HighlighterContentProvider contentProvider = null;
-
-	private Button manageEditorsButton = null;
-	
-	// Buttons for gamma setting
-	// private Button lightened;
-	// private Button darkened;
-	// private Button standard;
-
-	// Set the table column property names
-	private static final String LABEL_COLUMN = "Label";
-
-	private static final String COLOR_COLUMN = "Color";
-
-	private static final String TYPE_COLUMN = "Type";
-
-	private static String[] columnNames = new String[] { LABEL_COLUMN, COLOR_COLUMN, TYPE_COLUMN, };
-
-	static final String[] TYPE_ARRAY = { "Gradient", "Solid" }; 
-
-	/**
-	 * Constructor - set preference store to MylarUiPlugin store since the
-	 * tasklist plugin needs access to the values stored from the preference
-	 * page because it needs access to the highlighters on start up.
-	 * 
-	 */
-	public MylarPreferencePage() {
-		super();
-		setPreferenceStore(MylarUiPlugin.getPrefs());
-		setTitle("Mylar");
-		// setDescription("Mylar UI Preferences");
-	}
-
-	@Override
-	protected Control createContents(Composite parent) {
-		Composite entryTable = new Composite(parent, SWT.NULL);
-		GridLayout layout = new GridLayout(1, false);
-		layout.verticalSpacing = 4;
-		entryTable.setLayout(layout);
-
-		createEditorsSection(entryTable);
-		createExclusionFilterControl(entryTable);
-		
-		createTable(entryTable);
-		createTableViewer();
-		contentProvider = new HighlighterContentProvider();
-		tableViewer.setContentProvider(contentProvider);
-		tableViewer.setLabelProvider(new HighlighterLabelProvider());
-		tableViewer.setInput(MylarUiPlugin.getDefault().getHighlighterList());
-
-		// createGammaSettingControl(entryTable);
-		// lightened.setEnabled(false);
-		// darkened.setEnabled(false);
-		// standard.setEnabled(false);
-
-		return entryTable;
-	}
-	public void init(IWorkbench workbench) {
-		// don't have anything to initialize
-	}
-
-	/***************************************************************************
-	 * SelectionListener Methods
-	 **************************************************************************/
-
-	/**
-	 * Handle selection of an item in the menu.
-	 */
-	public void widgetDefaultSelected(SelectionEvent se) {
-		widgetSelected(se);
-	}
-
-	/**
-	 * Handle selection of an item in the menu.
-	 */
-	public void widgetSelected(SelectionEvent se) {
-		// don't care when the widget is selected
-	}
-
-	/***************************************************************************
-	 * PropertyPage Methods
-	 **************************************************************************/
-
-	/**
-	 * Handle Ok and Apply Store all data in the preference store
-	 */
-	@Override
-	public boolean performOk() {
-		getPreferenceStore().setValue(MylarUiPrefContstants.HIGHLIGHTER_PREFIX,
-				MylarUiPlugin.getDefault().getHighlighterList().externalizeToString());
-		getPreferenceStore().setValue(MylarUiPrefContstants.INTEREST_FILTER_EXCLUSION,
-				exclusionFieldEditor.getStringValue());
-		getPreferenceStore().setValue(MylarUiPrefContstants.AUTO_MANAGE_EDITORS, 
-				manageEditorsButton.getSelection());
-		
-		int value = autoOpenEditorsNum.getIntValue();
-		if (value > 0) {
-			getPreferenceStore().setValue(MylarUiPrefContstants.AUTO_MANAGE_EDITORS_OPEN_NUM, value);
-		}
-
-		// ColorMap.GammaSetting gm = null;
-		// if (standard.getSelection()) {
-		// getPreferenceStore().setValue(MylarUiPlugin.GAMMA_SETTING_LIGHTENED,false);
-		// getPreferenceStore().setValue(MylarUiPlugin.GAMMA_SETTING_STANDARD,true);
-		// getPreferenceStore().setValue(MylarUiPlugin.GAMMA_SETTING_DARKENED,false);
-		// gm = ColorMap.GammaSetting.STANDARD;
-		// } else if (lightened.getSelection()) {
-		// getPreferenceStore().setValue(MylarUiPlugin.GAMMA_SETTING_LIGHTENED,true);
-		// getPreferenceStore().setValue(MylarUiPlugin.GAMMA_SETTING_STANDARD,false);
-		// getPreferenceStore().setValue(MylarUiPlugin.GAMMA_SETTING_DARKENED,false);
-		// gm = ColorMap.GammaSetting.LIGHTEN;
-		// } else if (darkened.getSelection()) {
-		// getPreferenceStore().setValue(MylarUiPlugin.GAMMA_SETTING_LIGHTENED,false);
-		// getPreferenceStore().setValue(MylarUiPlugin.GAMMA_SETTING_STANDARD,false);
-		// getPreferenceStore().setValue(MylarUiPlugin.GAMMA_SETTING_DARKENED,true);
-		// gm = ColorMap.GammaSetting.DARKEN;
-		// }
-		// update gamma setting
-		// MylarUiPlugin.getDefault().updateGammaSetting(gm);
-
-		return true;
-	}
-
-	/**
-	 * Handle Cancel Undo all changes back to what is stored in preference store
-	 */
-	@Override
-	public boolean performCancel() {
-		String highlighters = getPreferenceStore().getString(MylarUiPrefContstants.HIGHLIGHTER_PREFIX);
-		MylarUiPlugin.getDefault().getHighlighterList().internalizeFromString(highlighters);
-
-		contentProvider = new HighlighterContentProvider();
-		tableViewer.setContentProvider(contentProvider);
-
-		// lightened.setSelection(getPreferenceStore().getBoolean(
-		// MylarUiPlugin.GAMMA_SETTING_LIGHTENED));
-		// standard.setSelection(getPreferenceStore().getBoolean(
-		// MylarUiPlugin.GAMMA_SETTING_STANDARD));
-		// darkened.setSelection(getPreferenceStore().getBoolean(
-		// MylarUiPlugin.GAMMA_SETTING_DARKENED));
-
-		return true;
-	}
-
-	/**
-	 * Handle RestoreDefaults Note: changes to default are not stored in the
-	 * preference store until OK or Apply is pressed
-	 */
-	@Override
-	public void performDefaults() {
-		super.performDefaults();
-
-		contentProvider = new HighlighterContentProvider();
-		tableViewer.setContentProvider(contentProvider);
-
-		// standard.setSelection(getPreferenceStore().getDefaultBoolean(
-		// MylarUiPlugin.GAMMA_SETTING_STANDARD));
-		// lightened.setSelection(getPreferenceStore().getDefaultBoolean(
-		// MylarUiPlugin.GAMMA_SETTING_LIGHTENED));
-		// darkened.setSelection(getPreferenceStore().getDefaultBoolean(
-		// MylarUiPlugin.GAMMA_SETTING_DARKENED));
-		//		
-		MylarUiPlugin.getDefault().getHighlighterList().setToDefaultList();
-		return;
-	}
-
-	/***************************************************************************
-	 * ICellEditorListener Methods For ColorDialog box
-	 **************************************************************************/
-
-	/**
-	 * applyEditorValue - method called when Color selected
-	 */
-	public void applyEditorValue() {
-		Object obj = colorDialogEditor.getValue();
-		if (!colorDialogEditor.isDirty() || !colorDialogEditor.isValueValid()) {
-			return;
-		}
-
-		if (obj instanceof RGB) {
-			// create new color
-			RGB rgb = (RGB) obj;
-			Color c = new Color(Display.getCurrent(), rgb.red, rgb.green, rgb.blue);
-			if (selection != null) {
-				// selection is the highlighter that has been selected
-				// set the core color to new color.
-				// update Highlighter in contentProvider
-				selection.setCore(c);
-				contentProvider.updateHighlighter(selection);
-			}
-		} else {
-			// ignore
-			// MylarPlugin.log("Received Unknown change in Editor: ", this);
-		}
-	}
-
-	public void cancelEditor() {
-		// don't care about this
-	}
-
-	public void editorValueChanged(boolean oldValidState, boolean newValidState) {
-		// don't care when the value is changed
-	}
-
-	/**
-	 * Class HighlighterLabelProvider - Label and image provider for tableViewer
-	 */
-	private static class HighlighterLabelProvider extends LabelProvider implements ITableLabelProvider {
-
-		public HighlighterLabelProvider() {
-			// don't have any initialization to do
-		}
-
-		/**
-		 * getColumnText - returns text for label and combo box cells
-		 */
-		public String getColumnText(Object obj, int columnIndex) {
-			String result = "";
-			if (obj instanceof Highlighter) {
-				Highlighter h = (Highlighter) obj;
-				switch (columnIndex) {
-				case 0:
-					// return name for label column
-					result = h.getName();
-					break;
-				case 2:
-					// return type for type column
-					result = h.getHighlightKind();
-					break;
-				default:
-					break;
-				}
-			}
-			return result;
-		}
-
-		/**
-		 * getColumnImage - returns image for color column
-		 */
-		public Image getColumnImage(Object obj, int columnIndex) {
-			if (obj instanceof Highlighter) {
-				Highlighter h = (Highlighter) obj;
-				switch (columnIndex) {
-				case 1:
-					HighlighterImageDescriptor des;
-					if (h.isGradient()) {
-						des = new HighlighterImageDescriptor(h.getBase(), h.getLandmarkColor());
-					} else {
-						des = new HighlighterImageDescriptor(h.getLandmarkColor(), h.getLandmarkColor());
-					}
-					return des.getImage();
-				default:
-					break;
-				}
-			}
-			return null;
-		}
-	}
-
-	/**
-	 * Class HighLighterContentProvider - content provider for table viewer
-	 */
-	private class HighlighterContentProvider implements IStructuredContentProvider {
-
-		/**
-		 * getElements - returns array of Highlighters for table
-		 */
-		public Object[] getElements(Object inputElement) {
-			return MylarUiPlugin.getDefault().getHighlighterList().getHighlighters().toArray();
-		}
-
-		public void dispose() {
-			// don't care when we are disposed
-		}
-
-		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
-			// don't care when the input changes
-		}
-
-		/**
-		 * addHighlighter - notify the tableViewer to add a highlighter called
-		 * when a highlighter is added to the HighlighterList
-		 */
-		public void addHighlighter(Highlighter hl) {
-			tableViewer.add(hl);
-		}
-
-		/**
-		 * removeHighlighter - notify the tableViewer to remove a highlighter
-		 * called when a highlighter is removed from the HighlighterList
-		 */
-		public void removeHighlighter(Highlighter hl) {
-			tableViewer.remove(hl);
-		}
-
-		/**
-		 * updateHighlighter - notify the tableViewer to update a highlighter
-		 * called when a highlighter property has been changed
-		 */
-		public void updateHighlighter(Highlighter hl) {
-			tableViewer.update(hl, null);
-		}
-	}
-
-	/**
-	 * class HighlighterCellModifier - cellModifier for tableViewer handles all
-	 * modification to the table
-	 */
-	private class HighlighterCellModifier implements ICellModifier {
-
-		HighlighterCellModifier() {
-			super();
-		}
-
-		public boolean canModify(Object element, String property) {
-			if (element instanceof Highlighter) {
-				if (!((Highlighter)element).getName().equals(HighlighterList.DEFAULT_HIGHLIGHTER.getName())) {
-					return true;
-				}
-			}
-			return false;
-		}
- 
-		/**
-		 * getValue - returns content of the current selection
-		 */
-		public Object getValue(Object element, String property) {
-			// Find the index of the column
-			int columnIndex = Arrays.asList(columnNames).indexOf(property);
-			Object res = null;
-			if (element instanceof Highlighter) {
-				Highlighter hl = (Highlighter) element;
-				switch (columnIndex) {
-				case 0: // LABEL_COLUMN
-					res = hl.getName();
-					break;
-				case 1: // COLOR_COLUMN
-					selection = hl;
-					if (selection.getCore() != null) {
-						return selection.getCore().getRGB();
-					} else {
-						return Display.getCurrent().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND).getRGB();
-					}
-				case 2: // KIND_COLUMN
-					// return index of current value
-					if (hl.isGradient()) {
-						res = new Integer(0);
-					} else if (hl.isIntersection()) {
-						res = new Integer(2);
-					} else {
-						res = new Integer(1);
-					}
-					break;
-				default:
-					return null;
-				}
-			}
-			return res;
-		}
-
-		/**
-		 * modify - modifies Highlighter with new property
-		 */
-		public void modify(Object element, String property, Object value) {
-			// Find the index of the column
-			int columnIndex = Arrays.asList(columnNames).indexOf(property);
-
-			TableItem item = (TableItem) element;
-			Highlighter hl = (Highlighter) item.getData();
-			switch (columnIndex) {
-			case 0: // LABEL_COLUMN
-				// change value of name
-				if (value instanceof String) {
-					// TableItem ti = (TableItem) element;
-					hl.setName((String) value);
-
-					// update contentprovider
-					contentProvider.updateHighlighter(hl);
-				}
-				break;
-			case 1: // COLOR_COLUMN
-				// never gets called since color dialog is used.
-				break;
-			case 2: // KIND_COLUMN
-				// sets new type
-				if (value instanceof Integer) {
-					int choice = ((Integer) value).intValue();
-					switch (choice) {
-					case 0:
-						// Gradient
-						hl.setGradient(true);
-						hl.setIntersection(false);
-						break;
-					case 1:
-						// Solid
-						hl.setGradient(false);
-						hl.setIntersection(false);
-						break;
-					case 2:
-						// Instersection
-						hl.setGradient(false);
-						hl.setIntersection(true);
-						break;
-					default:
-						break;
-					}
-					// update content provider
-					contentProvider.updateHighlighter(hl);
-				}
-			default:
-				break;
-			}
-			return;
-		}
-
-	}
-
-	/**
-	 * class HighlighterTableSorter - sort columns of table added to every
-	 * column as a sorter
-	 */
-	private static class HighlighterTableSorter extends ViewerSorter {
-
-		public final static int LABEL = 1;
-
-		public final static int COLOR = 2;
-
-		public final static int TYPE = 3;
-
-		private int criteria;
-
-		/**
-		 * set the criteria
-		 */
-		public HighlighterTableSorter(int criteria) {
-			super();
-			this.criteria = criteria;
-		}
-
-		/**
-		 * compare - invoked when column is selected calls the actual comparison
-		 * method for particular criteria
-		 */
-		@Override
-		public int compare(Viewer viewer, Object o1, Object o2) {
-			Highlighter h1 = (Highlighter) o1;
-			Highlighter h2 = (Highlighter) o2;
-			switch (criteria) {
-			case LABEL:
-				return compareLabel(h1, h2);
-			case COLOR:
-				return compareImage(h1, h2);
-			case TYPE:
-				return compareType(h1, h2);
-			default:
-				return 0;
-			}
-		}
-
-		/**
-		 * compareLabel - compare by label
-		 */
-		protected int compareLabel(Highlighter h1, Highlighter h2) {
-			return h1.getName().compareTo(h2.getName());
-		}
-
-		/**
-		 * compareImage - do nothing
-		 */
-		protected int compareImage(Highlighter h1, Highlighter h2) {
-			return 0;
-		}
-
-		/**
-		 * compareType - compare by type
-		 */
-		protected int compareType(Highlighter h1, Highlighter h2) {
-			return h1.getHighlightKind().compareTo(h2.getHighlightKind());
-		}
-
-		/**
-		 * getCriteria
-		 */
-		public int getCriteria() {
-			return criteria;
-		}
-	}
-
-	/***************************************************************************
-	 * Helper Functions
-	 **************************************************************************/
-
-	private void createTable(Composite parent) {
-		Group tableComposite = new Group(parent, SWT.SHADOW_ETCHED_IN);
-		tableComposite.setText("Context Highlighters");
-		tableComposite.setLayout(new GridLayout(2, false));
-		tableComposite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-
-		int style = SWT.SINGLE | SWT.BORDER | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.HIDE_SELECTION;
-
-		table = new Table(tableComposite, style);
-
-		GridData gridData = new GridData();
-		gridData.horizontalSpan = 2;
-		gridData.horizontalAlignment = SWT.FILL;
-		gridData.verticalAlignment = SWT.FILL;
-		table.setLayoutData(gridData);
-		table.setLinesVisible(true);
-		table.setHeaderVisible(true);
-
-		// 1st column with Label
-		TableColumn column = new TableColumn(table, SWT.LEAD, 0);
-		column.setResizable(false);
-		column.setText("Label");
-		column.setWidth(150);
-		column.addSelectionListener(new SelectionAdapter() {
-
-			@Override
-			public void widgetSelected(SelectionEvent e) {
-				tableViewer.setSorter(new HighlighterTableSorter(HighlighterTableSorter.LABEL));
-			}
-		});
-
-		// 2nd column with highlighter Description
-		column = new TableColumn(table, SWT.LEAD, 1);
-		column.setResizable(false);
-		column.setText("Color");
-		column.setWidth(100);
-		column.addSelectionListener(new SelectionAdapter() {
-
-			@Override
-			public void widgetSelected(SelectionEvent e) {
-				tableViewer.setSorter(new HighlighterTableSorter(HighlighterTableSorter.COLOR));
-			}
-		});
-
-		// 3rd column with Type
-		column = new TableColumn(table, SWT.LEAD, 2);
-		column.setResizable(false);
-		column.setText("Kind");
-		column.setWidth(80);
-		column.addSelectionListener(new SelectionAdapter() {
-
-			@Override
-			public void widgetSelected(SelectionEvent e) {
-				tableViewer.setSorter(new HighlighterTableSorter(HighlighterTableSorter.TYPE));
-			}
-		});
-		createAddRemoveButtons(tableComposite);
-	}
-
-	private void createTableViewer() {
-
-		tableViewer = new TableViewer(table);
-		tableViewer.setUseHashlookup(true);
-		tableViewer.setColumnProperties(columnNames);
-
-		CellEditor[] editors = new CellEditor[columnNames.length];
-
-		TextCellEditor textEditor = new TextCellEditor(table);
-		((Text) textEditor.getControl()).setTextLimit(20);
-		((Text) textEditor.getControl()).setOrientation(SWT.LEFT_TO_RIGHT);
-		editors[0] = textEditor;
-
-		colorDialogEditor = new ColorCellEditor(table);
-		colorDialogEditor.addListener(this);
-		editors[1] = colorDialogEditor;
-
-		editors[2] = new ComboBoxCellEditor(table, TYPE_ARRAY, SWT.READ_ONLY);
-
-		tableViewer.setCellEditors(editors);
-		tableViewer.setCellModifier(new HighlighterCellModifier());
-	}
-
-	private void createAddRemoveButtons(Composite parent) {
-
-		Composite addRemoveComposite = new Composite(parent, SWT.LEAD);
-		addRemoveComposite.setLayout(new GridLayout(2, false));
-
-		Button add = new Button(addRemoveComposite, SWT.PUSH | SWT.CENTER);
-		add.setText("Add");
-		GridData gridData = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
-		gridData.widthHint = 80;
-		add.setLayoutData(gridData);
-
-		add.addSelectionListener(new SelectionAdapter() {
-
-			@Override
-			public void widgetSelected(SelectionEvent e) {
-				Highlighter hl = MylarUiPlugin.getDefault().getHighlighterList().addHighlighter();
-				contentProvider.addHighlighter(hl);
-			}
-		});
-
-		Button delete = new Button(addRemoveComposite, SWT.PUSH | SWT.CENTER);
-		delete.setText("Delete");
-		gridData = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
-		gridData.widthHint = 80;
-		delete.setLayoutData(gridData);
-
-		delete.addSelectionListener(new SelectionAdapter() {
-
-			@Override
-			public void widgetSelected(SelectionEvent e) {
-				Highlighter hl = (Highlighter) ((IStructuredSelection) tableViewer.getSelection()).getFirstElement();
-				if (hl != null) {
-					MylarUiPlugin.getDefault().getHighlighterList().removeHighlighter(hl);
-					contentProvider.removeHighlighter(hl);
-				}
-			}
-		});
-	}
-
-	private void createExclusionFilterControl(Composite parent) {
-		Group exclusionControl = new Group(parent, SWT.SHADOW_ETCHED_IN);
-
-		exclusionControl.setLayout(new GridLayout(1, false));
-		exclusionControl.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-		exclusionControl.setText("Interest Filter");
-
-		Label label = new Label(exclusionControl, SWT.LEFT);
-		label.setText("Exclusion pattern, matches will always be shown (e.g. build*.xml):");
-
-		exclusionFieldEditor = new StringFieldEditor("", "", StringFieldEditor.UNLIMITED, exclusionControl);
-
-		String text = getPreferenceStore().getString(MylarUiPrefContstants.INTEREST_FILTER_EXCLUSION);
-		if (text != null)
-			exclusionFieldEditor.setStringValue(text);
-		return;
-	}
-
-	private void createEditorsSection(Composite parent) {
-		Group group = new Group(parent, SWT.SHADOW_ETCHED_IN);
-
-		group.setLayout(new GridLayout(1, false));
-		group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-		group.setText("Editor Management");
-		
-		Composite composite = new Composite(group, SWT.NULL);
-		composite.setLayout(new GridLayout(2, false));
-		manageEditorsButton = new Button(composite, SWT.CHECK);
-		manageEditorsButton.setText("Enable automatic editor opening/closing with context. ");
-		manageEditorsButton.setSelection(getPreferenceStore().getBoolean(MylarUiPrefContstants.AUTO_MANAGE_EDITORS));
-
-		Composite numComposite = new Composite(composite, SWT.NULL);
-		autoOpenEditorsNum = new IntegerFieldEditor("", "Max to open: ", numComposite, 4);
-		autoOpenEditorsNum.setErrorMessage("Must be an integer");
-		int num = getPreferenceStore().getInt(MylarUiPrefContstants.AUTO_MANAGE_EDITORS_OPEN_NUM);
-		if (num > 0) {
-			autoOpenEditorsNum.setStringValue("" + num);
-			autoOpenEditorsNum.setEmptyStringAllowed(false);
-		}
-		
-		String prefName = WorkbenchMessages.WorkbenchPreference_reuseEditors;
-		if (getContainer() instanceof IWorkbenchPreferenceContainer) {
-			String message =  "     \"" + prefName + "\" from <a>''{0}''</a> will be toggled with activation";
-			new PreferenceLinkArea(group, SWT.NONE,
-					"org.eclipse.ui.preferencePages.Editors", message,
-					(IWorkbenchPreferenceContainer) getContainer(), null);
-		}
-		return;
-	}
-
-	// private void createGammaSettingControl(Composite parent) {
-	// Group gammaSettingComposite= new Group(null, SWT.SHADOW_ETCHED_IN);
-	//		
-	// gammaSettingComposite.setLayout(new RowLayout());
-	// gammaSettingComposite.setText("Gamma Setting");
-	// lightened = new Button(gammaSettingComposite, SWT.RADIO);
-	// lightened.setText("Lightened");
-	// lightened.setSelection(getPreferenceStore().getBoolean(MylarUiPlugin.GAMMA_SETTING_LIGHTENED));
-	// standard = new Button(gammaSettingComposite, SWT.RADIO);
-	// standard.setText("Standard");
-	// standard.setSelection(getPreferenceStore().getBoolean(MylarUiPlugin.GAMMA_SETTING_STANDARD));
-	// darkened = new Button(gammaSettingComposite, SWT.RADIO);
-	// darkened.setText("Darkened");
-	// darkened.setSelection(getPreferenceStore().getBoolean(MylarUiPlugin.GAMMA_SETTING_DARKENED));
-	// return;
-	// }
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/views/ContextContentProvider.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/views/ContextContentProvider.java
deleted file mode 100644
index ee1a63a..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/views/ContextContentProvider.java
+++ /dev/null
@@ -1,189 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.internal.ui.views;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import org.eclipse.jface.viewers.IStructuredContentProvider;
-import org.eclipse.jface.viewers.ITreeContentProvider;
-import org.eclipse.jface.viewers.Viewer;
-import org.eclipse.mylar.internal.core.MylarContextRelation;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.IMylarRelation;
-import org.eclipse.mylar.provisional.core.IMylarStructureBridge;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.swt.widgets.Tree;
-import org.eclipse.swt.widgets.TreeItem;
-import org.eclipse.ui.IViewSite;
-
-/**
- * @author Mik Kersten
- */
-public class ContextContentProvider implements IStructuredContentProvider, ITreeContentProvider {
-
-	private IViewSite site = null;
-
-	private Tree tree;
-
-	private Shell shell = null;
-
-	private boolean landmarkOnlyMode;
-
-	public ContextContentProvider(Tree tree, IViewSite site, boolean landmarkOnlyMode) {
-		this.tree = tree;
-		this.site = site;
-		this.landmarkOnlyMode = landmarkOnlyMode;
-	}
-
-	public ContextContentProvider(Shell shell, boolean landmarkOnlyMode) {
-		this.shell = shell;
-		this.landmarkOnlyMode = landmarkOnlyMode;
-	}
-
-	public void inputChanged(Viewer v, Object oldInput, Object newInput) {
-		// don't care when the input changes
-	}
-
-	public void dispose() {
-		// don't care when we are disposed
-	}
-
-	public Object[] getElements(Object parent) {
-		if (matchesParent(parent)) {
-			List<IMylarElement> nodes;
-			if (landmarkOnlyMode) {
-				List<IMylarElement> landmarks = MylarPlugin.getContextManager().getActiveLandmarks();
-				nodes = new ArrayList<IMylarElement>();
-				for (IMylarElement node : landmarks) {
-					if (!node.getContentType().equals(MylarPlugin.CONTENT_TYPE_ANY)
-							&& !node.getInterest().isPredicted()) {
-						// && node.getRelations().size() > 0) {
-						nodes.add(node);
-					}
-				}
-			} else {
-				nodes = MylarPlugin.getContextManager().getActiveContext().getAllElements();
-			}
-			List<Object> resolvedNodes = new ArrayList<Object>();
-			for (IMylarElement node : nodes) {
-				IMylarStructureBridge bridge = MylarPlugin.getDefault().getStructureBridge(node.getContentType());
-				Object object = bridge.getObjectForHandle(node.getHandleIdentifier());
-				if (object != null)
-					resolvedNodes.add(object);
-			}
-			return resolvedNodes.toArray();
-		}
-		return getChildren(parent);
-	}
-
-	private boolean matchesParent(Object parent) {
-		if (site != null && parent.equals(site)) {
-			return true;
-		} else if (shell != null && parent.equals(shell)) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	public Object getParent(Object child) {
-		return null;
-	}
-
-	public Object[] getChildren(Object parent) {
-		if (parent == null)
-			return new Object[0];
-		if (parent instanceof MylarContextRelation) {
-			IMylarRelation edge = (IMylarRelation) parent;
-			IMylarElement source = MylarPlugin.getContextManager().getElement(
-					((IMylarRelation) parent).getSource().getHandleIdentifier());
-
-			return getAllTagetsForSource(source, edge.getRelationshipHandle());
-		} else {
-			IMylarElement node;
-			if (parent instanceof IMylarElement) {
-				node = (IMylarElement) parent;
-			} else {
-				IMylarStructureBridge bridge = MylarPlugin.getDefault().getStructureBridge(parent);
-				node = MylarPlugin.getContextManager().getElement(bridge.getHandleIdentifier(parent));
-			}
-			if (node != null) {
-				return getAllEdgeTypes(node.getRelations());
-			} else {
-				return new Object[0];
-			}
-		}
-	}
-
-	private boolean isRootItem(Object object) {
-		boolean isRootItem = false;
-		for (int i = 0; i < tree.getItems().length; i++) {
-			TreeItem item = tree.getItems()[i];
-			if (object.equals(item.getData()))
-				isRootItem = true;
-		}
-		return isRootItem;
-	}
-
-	private Object[] getAllTagetsForSource(IMylarElement source, String kind) {
-		Collection<MylarContextRelation> edges = source.getRelations();
-		List<Object> targets = new ArrayList<Object>();
-		for (MylarContextRelation edge : edges) {
-			if (edge.getRelationshipHandle().equals(kind)) {
-				IMylarElement target = edge.getTarget();
-				IMylarStructureBridge bridge = MylarPlugin.getDefault().getStructureBridge(target.getContentType());
-				Object object = bridge.getObjectForHandle(target.getHandleIdentifier());
-				if (object != null)
-					targets.add(object);
-			}
-		}
-
-		return targets.toArray();
-	}
-
-	private Object[] getAllEdgeTypes(Collection<MylarContextRelation> edges) {
-		Map<String, IMylarRelation> map = new HashMap<String, IMylarRelation>();
-		for (IMylarRelation edge : edges) {
-			IMylarRelation edgeType = map.get(edge.getRelationshipHandle());
-			if (edgeType == null) {
-				edgeType = edge;
-				map.put(edge.getRelationshipHandle(), edgeType);
-			}
-		}
-		Object[] edgeTypes = new Object[map.size()];
-		int index = 0;
-		for (IMylarRelation value : map.values()) {
-			edgeTypes[index] = value;
-			index++;
-		}
-		return edgeTypes;
-	}
-
-	public boolean hasChildren(Object parent) {
-		if (parent instanceof IMylarRelation) {
-			return true;
-		} else {
-			return isRootItem(parent);
-			// note: code below is too slow since edges change
-			// IMylarStructureBridge bridge =
-			// MylarPlugin.getDefault().getStructureBridge(parent);
-			// IMylarElement node =
-			// MylarPlugin.getContextManager().getNode(bridge.getHandleIdentifier(parent));
-			// return isRootItem(parent) && node.getEdges().size() > 0;
-		}
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/views/ContextNodeOpenListener.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/views/ContextNodeOpenListener.java
deleted file mode 100644
index e4ef659..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/views/ContextNodeOpenListener.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-/*
- * Created on Feb 17, 2005
- */
-package org.eclipse.mylar.internal.ui.views;
-
-import org.eclipse.jface.viewers.*;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.IMylarRelation;
-import org.eclipse.mylar.provisional.core.IMylarStructureBridge;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-
-/**
- * @author Mik Kersten
- */
-public class ContextNodeOpenListener implements IOpenListener {
-
-	private final Viewer viewer;
-
-	public ContextNodeOpenListener(Viewer viewer) {
-		this.viewer = viewer;
-	}
-
-	public void open(OpenEvent event) {
-		StructuredSelection selection = (StructuredSelection) viewer.getSelection();
-		Object object = selection.getFirstElement();
-		IMylarElement node = null;
-		if (object instanceof IMylarElement) {
-			node = (IMylarElement) object;
-		} else if (!(object instanceof IMylarRelation)) {
-			IMylarStructureBridge bridge = MylarPlugin.getDefault().getStructureBridge(object);
-			String handle = bridge.getHandleIdentifier(object);
-			node = MylarPlugin.getContextManager().getElement(handle);
-		}
-		if (node != null)
-			MylarUiPlugin.getDefault().getUiBridge(node.getContentType()).open(node);
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/views/DelegatingContextLabelProvider.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/views/DelegatingContextLabelProvider.java
deleted file mode 100644
index 40691b2..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/internal/ui/views/DelegatingContextLabelProvider.java
+++ /dev/null
@@ -1,98 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-/*
- * Created on Apr 18, 2005
- */
-package org.eclipse.mylar.internal.ui.views;
-
-import org.eclipse.jface.viewers.ILabelProvider;
-import org.eclipse.jface.viewers.ILabelProviderListener;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.IMylarObject;
-import org.eclipse.mylar.provisional.core.IMylarStructureBridge;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-import org.eclipse.swt.graphics.Image;
-
-/**
- * TODO: refactor edge stuff
- * 
- * @author Mik Kersten
- */
-public class DelegatingContextLabelProvider implements ILabelProvider {
-
-	private static boolean qualifyNamesMode = false; // TODO: make non-static
-
-	public static boolean isQualifyNamesMode() {
-		return qualifyNamesMode;
-	}
-
-	public static void setQualifyNamesMode(boolean qualify) {
-		qualifyNamesMode = qualify;
-	}
-
-	public Image getImage(Object element) {
-		if (element instanceof IMylarObject) {
-			ILabelProvider provider = MylarUiPlugin.getDefault().getContextLabelProvider(
-					((IMylarObject) element).getContentType());
-			return provider.getImage(element);
-		} else {
-			IMylarStructureBridge bridge = MylarPlugin.getDefault().getStructureBridge(element);
-			ILabelProvider provider = MylarUiPlugin.getDefault().getContextLabelProvider(bridge.getContentType());
-			if (provider != null)
-				return provider.getImage(element);
-		}
-		return null;
-	}
-
-	public String getText(Object object) {
-		if (object instanceof IMylarObject) {
-			IMylarObject element = (IMylarObject) object;
-			ILabelProvider provider = MylarUiPlugin.getDefault().getContextLabelProvider(element.getContentType());
-			if (MylarUiPlugin.getDefault().isDecorateInterestMode()) { // TODO:
-																		// move
-				return provider.getText(element) + " [" + element.getInterest().getValue() + "]";
-			} else {
-				return provider.getText(element);
-			}
-		} else {
-			IMylarStructureBridge bridge = MylarPlugin.getDefault().getStructureBridge(object);
-			ILabelProvider provider = MylarUiPlugin.getDefault().getContextLabelProvider(bridge.getContentType());
-			if (provider != null) {
-				if (MylarUiPlugin.getDefault().isDecorateInterestMode()) {
-					IMylarElement element = MylarPlugin.getContextManager().getElement(
-							bridge.getHandleIdentifier(object));
-					return provider.getText(object) + " [" + element.getInterest().getValue() + "]";
-				} else {
-					return provider.getText(object);
-				}
-			}
-		}
-		return "? " + object;
-	}
-
-	public boolean isLabelProperty(Object element, String property) {
-		// TODO: implement?
-		return false;
-	}
-
-	public void addListener(ILabelProviderListener listener) {
-		// TODO: implement?
-	}
-
-	public void dispose() {
-		// TODO: implement?
-	}
-
-	public void removeListener(ILabelProviderListener listener) {
-		// TODO: implement?
-	}
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/provisional/ui/IMylarUiBridge.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/provisional/ui/IMylarUiBridge.java
deleted file mode 100644
index 6aa00b9..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/provisional/ui/IMylarUiBridge.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.provisional.ui;
-
-import java.util.List;
-
-import org.eclipse.jface.text.TextSelection;
-import org.eclipse.jface.viewers.TreeViewer;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.ui.IEditorInput;
-import org.eclipse.ui.IEditorPart;
-
-/**
- * @author Mik Kersten
- */
-public interface IMylarUiBridge {
-
-	public abstract void open(IMylarElement element);
-
-	public abstract void setContextCapturePaused(boolean paused);
-
-	public abstract void restoreEditor(IMylarElement document);
-
-	public abstract void close(IMylarElement element);
-
-	public abstract boolean acceptsEditor(IEditorPart editorPart);
-
-	public abstract IMylarElement getElement(IEditorInput input);
-	
-	/**
-	 * Note that a single editor part can correspond to multipe outlines (e.g.
-	 * the PDE manifest editor).
-	 * 
-	 * @return	an empty list if none
-	 */
-	public abstract List<TreeViewer> getContentOutlineViewers(IEditorPart editorPart);
-
-	public abstract Object getObjectForTextSelection(TextSelection selection, IEditorPart editor);
-
-}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/provisional/ui/InterestFilter.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/provisional/ui/InterestFilter.java
deleted file mode 100644
index 300ee27..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/provisional/ui/InterestFilter.java
+++ /dev/null
@@ -1,198 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-/*
- * Created on Apr 7, 2005
- */
-package org.eclipse.mylar.provisional.ui;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IProjectNature;
-import org.eclipse.jface.util.IPropertyChangeListener;
-import org.eclipse.jface.util.PropertyChangeEvent;
-import org.eclipse.jface.viewers.StructuredViewer;
-import org.eclipse.jface.viewers.TreePath;
-import org.eclipse.jface.viewers.Viewer;
-import org.eclipse.jface.viewers.ViewerFilter;
-import org.eclipse.mylar.internal.core.MylarContextManager;
-import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
-import org.eclipse.mylar.internal.ui.MylarUiPrefContstants;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.IMylarStructureBridge;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.swt.widgets.Tree;
-
-/**
- * This is a generic interest filter that can be applied to any
- * StructuredViewer. It figures out whether an object is interesting by getting
- * it's handle from the corresponding structure bridge.
- * 
- * @author Mik Kersten
- */
-public class InterestFilter extends ViewerFilter implements IPropertyChangeListener {
-
-	private Object temporarilyUnfiltered = null;
-
-	private String excludedMatches = null;
-
-	public InterestFilter() {
-		MylarUiPlugin.getPrefs().addPropertyChangeListener(this);
-	}
-
-	@Override
-	public boolean select(Viewer viewer, Object parent, Object object) {
-		try {
-			if (!(viewer instanceof StructuredViewer) || 
-				!containsMylarInterestFilter((StructuredViewer) viewer)) {
-				return true;
-			}
-			if (isTemporarilyUnfiltered(parent)) {
-				return true;
-			} else if (temporarilyUnfiltered instanceof Tree) {
-				// HACK: should also work for trees without project as root
-				if (object instanceof IProjectNature || object instanceof IProject) {
-					return true;
-				}
-			}
-
-			IMylarElement element = null;
-			if (object instanceof IMylarElement) {
-				element = (IMylarElement) object;
-			} else {
-				IMylarStructureBridge bridge = MylarPlugin.getDefault().getStructureBridge(object);
-				if (!bridge.canFilter(object)) {
-					return true;
-				}
-				if (isImplicitlyInteresting(object, bridge)) {
-					return true;
-				}
-				
-				if (!object.getClass().getName().equals(Object.class.getCanonicalName())) {
-					String handle = bridge.getHandleIdentifier(object);
-					element = MylarPlugin.getContextManager().getElement(handle);
-				} else {
-					return true;
-				}
-			}
-			if (element != null) {
-				if (element.getInterest().isPredicted()) {
-					return false;
-				} else {
-					return element.getInterest().getValue() > MylarContextManager.getScalingFactors().getInteresting();
-				}
-			}
-		} catch (Throwable t) {
-			MylarStatusHandler.fail(t, "interest filter failed on viewer: " + viewer.getClass(), false);
-		}
-		return false;
-	}
-
-	private boolean isTemporarilyUnfiltered(Object parent) {
-		if (parent instanceof TreePath) {
-			TreePath treePath = (TreePath)parent;
-			parent = treePath.getLastSegment();
-		}
-		return temporarilyUnfiltered != null && temporarilyUnfiltered.equals(parent);
-	}
-
-	protected boolean isImplicitlyInteresting(Object element, IMylarStructureBridge bridge) {
-		if (excludedMatches == null)
-			return false;
-		if (excludedMatches.equals("*"))
-			return false;
-		try {
-			String name = bridge.getName(element);
-			return name.matches(excludedMatches.replaceAll("\\*", ".*").replaceAll("\\.", "\\."));
-		} catch (Throwable t) {
-			return false;
-		}
-	}
-
-	protected boolean containsMylarInterestFilter(StructuredViewer viewer) {
-	    for (ViewerFilter filter : viewer.getFilters()) {
-	        if (filter instanceof InterestFilter) {
-				return true;
-	        }
-		} 
-		return false;
-	}
-
-	public void setTemporarilyUnfiltered(Object temprarilyUnfiltered) {
-		this.temporarilyUnfiltered = temprarilyUnfiltered;
-	}
-
-	/**
-	 * @return	true if there was an unfiltered node
-	 */
-	public boolean resetTemporarilyUnfiltered() {
-		if (temporarilyUnfiltered != null) {
-			this.temporarilyUnfiltered = null;
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	public Object getTemporarilyUnfiltered() {
-		return temporarilyUnfiltered;
-	}
-
-	public String getExcludedMatches() {
-		return excludedMatches;
-	}
-
-	public void setExcludedMatches(String excludedMatches) {
-		this.excludedMatches = excludedMatches;
-	}
-
-	public void propertyChange(PropertyChangeEvent event) {
-		if (MylarUiPrefContstants.INTEREST_FILTER_EXCLUSION.equals(event.getProperty())
-				&& event.getNewValue() instanceof String) {
-
-			excludedMatches = (String) event.getNewValue();
-		}
-	}
-}
-
-
-//boolean testselect(Viewer viewer, Object parent, Object element) {
-//	try {
-//		if (!(viewer instanceof StructuredViewer))
-//			return true;
-//		if (!containsMylarInterestFilter((StructuredViewer) viewer))
-//			return true;
-//		if (isTemporarilyUnfiltered(parent))
-//			return true;
-//
-//		IMylarElement node = null;
-//		if (element instanceof IMylarElement) {
-//			node = (IMylarElement) element;
-//		} else {
-//			IMylarStructureBridge bridge = MylarPlugin.getDefault().getStructureBridge(element);
-//			if (!bridge.canFilter(element))
-//				return true;
-//			if (isImplicitlyInteresting(element, bridge))
-//				return true;
-//
-//			String handle = bridge.getHandleIdentifier(element);
-//			node = MylarPlugin.getContextManager().getElement(handle);
-//		}
-//		if (node != null) {
-//			if (node.getInterest().isPredicted()) {
-//				return false;
-//			} else {
-//				return node.getInterest().getValue() > MylarContextManager.getScalingFactors().getInteresting();
-//			}
-//		}
-//	} catch (Throwable t) {
-//		MylarStatusHandler.log(t, "interest filter failed on viewer: " + viewer.getClass());
-//	}
-//	return false;
-//}
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/provisional/ui/InterestSorter.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/provisional/ui/InterestSorter.java
deleted file mode 100644
index 9aef3c0..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/provisional/ui/InterestSorter.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.provisional.ui;
-
-import org.eclipse.jface.viewers.Viewer;
-import org.eclipse.jface.viewers.ViewerSorter;
-import org.eclipse.mylar.provisional.core.InterestComparator;
-
-/**
- * @author Mik Kersten
- */
-public class InterestSorter extends ViewerSorter {
-
-	protected InterestComparator<Object> comparator = new InterestComparator<Object>();
-
-	@Override
-	public int compare(Viewer viewer, Object e1, Object e2) {
-		return comparator.compare(e1, e2);
-	}
-
-}
\ No newline at end of file
diff --git a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/provisional/ui/MylarUiPlugin.java b/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/provisional/ui/MylarUiPlugin.java
deleted file mode 100644
index a3fff24..0000000
--- a/org.eclipse.mylyn.context.ui/src/org/eclipse/mylyn/provisional/ui/MylarUiPlugin.java
+++ /dev/null
@@ -1,520 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.provisional.ui;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IConfigurationElement;
-import org.eclipse.core.runtime.IExtension;
-import org.eclipse.core.runtime.IExtensionPoint;
-import org.eclipse.core.runtime.IExtensionRegistry;
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.jface.preference.IPreferenceStore;
-import org.eclipse.jface.text.TextSelection;
-import org.eclipse.jface.viewers.ILabelProvider;
-import org.eclipse.jface.viewers.TreeViewer;
-import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
-import org.eclipse.mylar.internal.tasklist.ui.ITaskHighlighter;
-import org.eclipse.mylar.internal.ui.AbstractContextLabelProvider;
-import org.eclipse.mylar.internal.ui.ColorMap;
-import org.eclipse.mylar.internal.ui.ContentOutlineManager;
-import org.eclipse.mylar.internal.ui.Highlighter;
-import org.eclipse.mylar.internal.ui.HighlighterList;
-import org.eclipse.mylar.internal.ui.MylarUiPrefContstants;
-import org.eclipse.mylar.internal.ui.MylarViewerManager;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.IMylarRelation;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.tasklist.ITask;
-import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
-import org.eclipse.swt.graphics.Color;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.ui.IEditorInput;
-import org.eclipse.ui.IEditorPart;
-import org.eclipse.ui.IWorkbench;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.ui.plugin.AbstractUIPlugin;
-import org.osgi.framework.BundleContext;
-
-/**
- * @author Mik Kersten
- */
-public class MylarUiPlugin extends AbstractUIPlugin {
-
-	public static final String PLUGIN_ID = "org.eclipse.mylar.ui";
-
-	private Map<String, IMylarUiBridge> bridges = new HashMap<String, IMylarUiBridge>();
-
-	private Map<String, ILabelProvider> contextLabelProviders = new HashMap<String, ILabelProvider>();
-
-	private static MylarUiPlugin plugin;
-
-	private ResourceBundle resourceBundle;
-
-	private boolean decorateInterestMode = false;
-
-	private HighlighterList highlighters = null;
-
-	private Highlighter intersectionHighlighter;
-
-	private ColorMap colorMap = new ColorMap();
-
-	private MylarViewerManager viewerManager = new MylarViewerManager();
-
-	private ContentOutlineManager contentOutlineManager = new ContentOutlineManager();
-
-	private final ITaskHighlighter DEFAULT_HIGHLIGHTER = new ITaskHighlighter() {
-		public Color getHighlightColor(ITask task) {
-			Highlighter highlighter = getHighlighterForContextId("" + task.getHandleIdentifier());
-			if (highlighter != null) {
-				return highlighter.getHighlightColor();
-			} else {
-				return null;
-			}
-		}
-	};
-
-	private static final AbstractContextLabelProvider DEFAULT_LABEL_PROVIDER = new AbstractContextLabelProvider() {
-
-		@Override
-		protected Image getImage(IMylarElement node) {
-			return null;
-		}
-
-		@Override
-		protected Image getImage(IMylarRelation edge) {
-			return null;
-		}
-
-		@Override
-		protected String getText(IMylarElement node) {
-			return "? " + node;
-		}
-
-		@Override
-		protected String getText(IMylarRelation edge) {
-			return "? " + edge;
-		}
-
-		@Override
-		protected Image getImageForObject(Object object) {
-			return null;
-		}
-
-		@Override
-		protected String getTextForObject(Object node) {
-			return "? " + node;
-		}
-
-	};
-
-	private static final IMylarUiBridge DEFAULT_UI_BRIDGE = new IMylarUiBridge() {
-
-		public void open(IMylarElement node) {
-			// ignore
-		}
-
-		public void close(IMylarElement node) {
-			// ignore
-		}
-
-		public boolean acceptsEditor(IEditorPart editorPart) {
-			return false;
-		}
-
-		public List<TreeViewer> getContentOutlineViewers(IEditorPart editor) {
-			return Collections.emptyList();
-		}
-
-		public Object getObjectForTextSelection(TextSelection selection, IEditorPart editor) {
-			return null;
-		}
-
-		public void restoreEditor(IMylarElement document) {
-			// ignore
-		}
-
-		public void setContextCapturePaused(boolean paused) {
-			// ignore
-		}
-
-		public IMylarElement getElement(IEditorInput input) {
-			return null;
-		}
-	};
-
-	public MylarUiPlugin() {
-		super();
-		plugin = this;
-		try {
-			resourceBundle = ResourceBundle.getBundle("org.eclipse.mylar.MylarUiPluginResources");
-		} catch (MissingResourceException x) {
-			resourceBundle = null;
-		} catch (Throwable t) {
-			MylarStatusHandler.log(t, "plug-in intialization failed");
-		}
-		initializeHighlighters();
-		initializeDefaultPreferences(getPrefs());
-		initializeActions();
-	}
-
-	// public void earlyStartup() {
-	// }
-
-	@Override
-	public void start(BundleContext context) throws Exception {
-		super.start(context);
-		final IWorkbench workbench = PlatformUI.getWorkbench();
-		workbench.getDisplay().asyncExec(new Runnable() {
-			public void run() {
-				try {
-					// TODO: move to MylarPlugin?
-					PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell().addShellListener(
-							MylarPlugin.getContextManager().getShellLifecycleListener());
-					MylarPlugin.getContextManager().addListener(viewerManager);
-
-					MylarPlugin.getDefault().addWindowPartListener(contentOutlineManager);
-//					MylarPlugin.getDefault().addWindowPageListener(contentOutlineManager);
-
-//					if (ApplyMylarToOutlineAction.getDefault() != null)
-//						ApplyMylarToOutlineAction.getDefault().update();
-					MylarTaskListPlugin.getDefault().setHighlighter(DEFAULT_HIGHLIGHTER);
-				} catch (Exception e) {
-					MylarStatusHandler.fail(e, "Mylar UI initialization failed", true);
-				}
-			}
-		});
-	}
-
-	/**
-	 * This method is called when the plug-in is stopped
-	 */
-	@Override
-	public void stop(BundleContext context) throws Exception {
-		try {
-			super.stop(context);
-			MylarPlugin.getContextManager().removeListener(viewerManager);
-			MylarPlugin.getDefault().removeWindowPartListener(contentOutlineManager);
-//			MylarPlugin.getDefault().removeWindowPageListener(contentOutlineManager);
-			viewerManager.dispose();
-			colorMap.dispose();
-			highlighters.dispose();
-			if (PlatformUI.getWorkbench() != null && !PlatformUI.getWorkbench().isClosing()) {
-				PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell().removeShellListener(
-						MylarPlugin.getContextManager().getShellLifecycleListener());
-			}
-		} catch (Exception e) {
-			MylarStatusHandler.fail(e, "Mylar UI stop failed", false);
-		}
-	}
-
-	private void initializeActions() {
-		// don't have any actions to initialize
-	}
-
-	private void initializeHighlighters() {
-		String hlist = getPrefs().getString(MylarUiPrefContstants.HIGHLIGHTER_PREFIX);
-		if (hlist != null && hlist.length() != 0) {
-			highlighters = new HighlighterList(hlist);
-		} else {
-			// Only get here if it is the first time running
-			// mylar. load default colors
-			highlighters = new HighlighterList();
-			highlighters.setToDefaultList();
-			getPrefs().setValue(MylarUiPrefContstants.HIGHLIGHTER_PREFIX, this.highlighters.externalizeToString());
-		}
-	}
-
-	@Override
-	protected void initializeDefaultPreferences(IPreferenceStore store) {
-		store.setDefault(MylarUiPrefContstants.AUTO_MANAGE_EDITORS, true);
-		store.setDefault(MylarUiPrefContstants.AUTO_MANAGE_EDITORS_OPEN_NUM, 8);
-
-		store.setDefault(MylarUiPrefContstants.GAMMA_SETTING_LIGHTENED, false);
-		store.setDefault(MylarUiPrefContstants.GAMMA_SETTING_STANDARD, true);
-		store.setDefault(MylarUiPrefContstants.GAMMA_SETTING_DARKENED, false);
-
-		if (!store.contains(MylarUiPrefContstants.GLOBAL_FILTERING))
-			store.setDefault(MylarUiPrefContstants.GLOBAL_FILTERING, true);
-	}
-
-	public void setHighlighterMapping(String id, String name) {
-		String prefId = MylarUiPrefContstants.TASK_HIGHLIGHTER_PREFIX + id;
-		getPrefs().putValue(prefId, name);
-	}
-
-	/**
-	 * Returns the shared instance.
-	 */
-	public static MylarUiPlugin getDefault() {
-		return plugin;
-	}
-
-	public static IPreferenceStore getPrefs() {
-		return MylarPlugin.getDefault().getPreferenceStore();
-	}
-
-	/**
-	 * Returns the string from the plugin's resource bundle, or 'key' if not
-	 * found.
-	 */
-	public static String getResourceString(String key) {
-		ResourceBundle bundle = MylarUiPlugin.getDefault().getResourceBundle();
-		try {
-			return (bundle != null) ? bundle.getString(key) : key;
-		} catch (MissingResourceException e) {
-			return key;
-		}
-	}
-
-	/**
-	 * Returns the string from the plugin's resource bundle, or 'key' if not
-	 * found.
-	 */
-	public static String getMessage(String key) {
-		ResourceBundle bundle = getDefault().getResourceBundle();
-		try {
-			return (bundle != null) ? bundle.getString(key) : key;
-		} catch (MissingResourceException e) {
-			return key;
-		}
-	}
-
-	/**
-	 * Returns the plugin's resource bundle,
-	 */
-	public ResourceBundle getResourceBundle() {
-		return resourceBundle;
-	}
-
-	public boolean isDecorateInterestMode() {
-		return decorateInterestMode;
-	}
-
-	public void setDecorateInterestMode(boolean decorateInterestLevel) {
-		this.decorateInterestMode = decorateInterestLevel;
-	}
-
-	public List<IMylarUiBridge> getUiBridges() {
-		return new ArrayList<IMylarUiBridge>(bridges.values());
-	}
-
-	/**
-	 * @return the corresponding adapter if found, or an adapter with no
-	 *         behavior otherwise (so null is never returned)
-	 */
-	public IMylarUiBridge getUiBridge(String contentType) {
-		if (!UiExtensionPointReader.extensionsRead)
-			UiExtensionPointReader.initExtensions();
-		IMylarUiBridge bridge = bridges.get(contentType);
-		if (bridge != null) {
-			return bridge;
-		} else {
-			return DEFAULT_UI_BRIDGE;
-		}
-	}
-
-	/**
-	 * TODO: cache this to improve performance?
-	 */
-	public IMylarUiBridge getUiBridgeForEditor(IEditorPart editorPart) {
-		if (!UiExtensionPointReader.extensionsRead)
-			UiExtensionPointReader.initExtensions();
-		IMylarUiBridge foundBridge = null;
-		for (IMylarUiBridge bridge : bridges.values()) {
-			if (bridge.acceptsEditor(editorPart)) {
-				foundBridge = bridge;
-				break;
-			}
-		}
-		if (foundBridge != null) {
-			return foundBridge;
-		} else {
-			return DEFAULT_UI_BRIDGE;
-		}
-	}
-
-	private void internalAddBridge(String extension, IMylarUiBridge bridge) {
-		this.bridges.put(extension, bridge);
-	}
-
-	public ILabelProvider getContextLabelProvider(String extension) {
-		if (!UiExtensionPointReader.extensionsRead)
-			UiExtensionPointReader.initExtensions();
-		ILabelProvider provider = contextLabelProviders.get(extension);
-		if (provider != null) {
-			return provider;
-		} else {
-			return DEFAULT_LABEL_PROVIDER;
-		}
-	}
-
-	private void internalAddContextLabelProvider(String extension, ILabelProvider provider) {
-		this.contextLabelProviders.put(extension, provider);
-	}
-
-	public void updateGammaSetting(ColorMap.GammaSetting setting) {
-		if (colorMap.getGammaSetting() != setting) {
-			highlighters.updateHighlighterWithGamma(colorMap.getGammaSetting(), setting);
-			colorMap.setGammaSetting(setting);
-		}
-	}
-
-	public ColorMap getColorMap() {
-		return colorMap;
-	}
-
-	public Highlighter getDefaultHighlighter() {
-		return HighlighterList.DEFAULT_HIGHLIGHTER;
-	}
-
-	/**
-	 * @return null if not found
-	 */
-	public Highlighter getHighlighter(String name) {
-		if (highlighters == null) {
-			this.initializeHighlighters();
-		}
-		return highlighters.getHighlighter(name);
-	}
-
-	public Highlighter getHighlighterForContextId(String id) {
-		String prefId = MylarUiPrefContstants.TASK_HIGHLIGHTER_PREFIX + id;
-		String highlighterName = getPrefs().getString(prefId);
-		return getHighlighter(highlighterName);
-	}
-
-	public HighlighterList getHighlighterList() {
-		if (this.highlighters == null) {
-			this.initializeHighlighters();
-		}
-		return this.highlighters;
-	}
-
-	public List<Highlighter> getHighlighters() {
-		if (highlighters == null) {
-			this.initializeHighlighters();
-		}
-		return highlighters.getHighlighters();
-	}
-
-	public Highlighter getIntersectionHighlighter() {
-		return intersectionHighlighter;
-	}
-
-	public void setColorMap(ColorMap colorMap) {
-		this.colorMap = colorMap;
-	}
-
-	public void setIntersectionHighlighter(Highlighter intersectionHighlighter) {
-		this.intersectionHighlighter = intersectionHighlighter;
-	}
-
-	public boolean isGlobalFoldingEnabled() {
-		return getPrefs().getBoolean(MylarUiPrefContstants.GLOBAL_FILTERING);
-	}
-
-	public void setGlobalFilteringEnabled(boolean globalFilteringEnabled) {
-		getPrefs().setValue(MylarUiPrefContstants.GLOBAL_FILTERING, globalFilteringEnabled);
-	}
-
-	public boolean isIntersectionMode() {
-		return getPrefs().getBoolean(MylarUiPrefContstants.INTERSECTION_MODE);
-	}
-
-	public void setIntersectionMode(boolean isIntersectionMode) {
-		getPrefs().setValue(MylarUiPrefContstants.INTERSECTION_MODE, isIntersectionMode);
-	}
-
-	public MylarViewerManager getViewerManager() {
-		return viewerManager;
-	}
-
-	static class UiExtensionPointReader {
-
-		private static boolean extensionsRead = false;
-
-		private static UiExtensionPointReader thisReader = new UiExtensionPointReader();
-
-		// read the extensions and load the required plugins
-		public static void initExtensions() {
-			// code from "contributing to eclipse" with modifications for
-			// deprecated code
-			if (!extensionsRead) {
-				IExtensionRegistry registry = Platform.getExtensionRegistry();
-				IExtensionPoint extensionPoint = registry
-						.getExtensionPoint(UiExtensionPointReader.EXTENSION_ID_CONTEXT);
-				IExtension[] extensions = extensionPoint.getExtensions();
-				for (int i = 0; i < extensions.length; i++) {
-					IConfigurationElement[] elements = extensions[i].getConfigurationElements();
-					for (int j = 0; j < elements.length; j++) {
-						if (elements[j].getName().compareTo(UiExtensionPointReader.ELEMENT_UI_BRIDGE) == 0) {
-							readBridge(elements[j]);
-						} else if (elements[j].getName().compareTo(
-								UiExtensionPointReader.ELEMENT_UI_CONTEXT_LABEL_PROVIDER) == 0) {
-							readLabelProvider(elements[j]);
-						}
-					}
-				}
-				extensionsRead = true;
-			}
-		}
-
-		private static void readLabelProvider(IConfigurationElement element) {
-			try {
-				Object provider = element.createExecutableExtension(UiExtensionPointReader.ELEMENT_UI_CLASS);
-				Object contentType = element.getAttribute(UiExtensionPointReader.ELEMENT_UI_BRIDGE_CONTENT_TYPE);
-				if (provider instanceof ILabelProvider && contentType != null) {
-					MylarUiPlugin.getDefault().internalAddContextLabelProvider((String) contentType,
-							(ILabelProvider) provider);
-				} else {
-					MylarStatusHandler.log("Could not load label provider: " + provider.getClass().getCanonicalName()
-							+ " must implement " + ILabelProvider.class.getCanonicalName(), thisReader);
-				}
-			} catch (CoreException e) {
-				MylarStatusHandler.log(e, "Could not load label provider extension");
-			}
-		}
-
-		private static void readBridge(IConfigurationElement element) {
-			try {
-				Object bridge = element.createExecutableExtension(UiExtensionPointReader.ELEMENT_UI_CLASS);
-				Object contentType = element.getAttribute(UiExtensionPointReader.ELEMENT_UI_BRIDGE_CONTENT_TYPE);
-				if (bridge instanceof IMylarUiBridge && contentType != null) {
-					MylarUiPlugin.getDefault().internalAddBridge((String) contentType, (IMylarUiBridge) bridge);
-				} else {
-					MylarStatusHandler.log("Could not load bridge: " + bridge.getClass().getCanonicalName()
-							+ " must implement " + IMylarUiBridge.class.getCanonicalName(), thisReader);
-				}
-			} catch (CoreException e) {
-				MylarStatusHandler.log(e, "Could not load bridge extension");
-			}
-		}
-
-		public static final String EXTENSION_ID_CONTEXT = "org.eclipse.mylar.ui.context";
-
-		public static final String ELEMENT_UI_BRIDGE = "uiBridge";
-
-		public static final String ELEMENT_UI_CLASS = "class";
-
-		public static final String ELEMENT_UI_CONTEXT_LABEL_PROVIDER = "labelProvider";
-
-		public static final String ELEMENT_UI_BRIDGE_CONTENT_TYPE = "contentType";
-	}
-}
diff --git a/org.eclipse.mylyn.ide-feature/.project b/org.eclipse.mylyn.ide-feature/.project
deleted file mode 100644
index 2d230d5..0000000
--- a/org.eclipse.mylyn.ide-feature/.project
+++ /dev/null
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.mylar.ide-feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-	</buildSpec>
-	<natures>
-	</natures>
-</projectDescription>
diff --git a/org.eclipse.mylyn.ide-feature/.settings/org.eclipse.ltk.core.refactoring.prefs b/org.eclipse.mylyn.ide-feature/.settings/org.eclipse.ltk.core.refactoring.prefs
deleted file mode 100644
index 4c9ebcf..0000000
--- a/org.eclipse.mylyn.ide-feature/.settings/org.eclipse.ltk.core.refactoring.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Fri Jun 02 15:30:51 PDT 2006
-eclipse.preferences.version=1
-org.eclipse.ltk.core.refactoring.enable.project.refactoring.history=true
diff --git a/org.eclipse.mylyn.ide-feature/about.html b/org.eclipse.mylyn.ide-feature/about.html
deleted file mode 100644
index 1aeb16b..0000000
--- a/org.eclipse.mylyn.ide-feature/about.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>May 2, 2006</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</a>.</p>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/org.eclipse.mylyn.ide-feature/build.properties b/org.eclipse.mylyn.ide-feature/build.properties
deleted file mode 100644
index 99e33ec..0000000
--- a/org.eclipse.mylyn.ide-feature/build.properties
+++ /dev/null
@@ -1,7 +0,0 @@
-bin.includes = feature.xml,\
-               epl-v10.html,\
-               license.html
-src.includes = feature.xml,\
-               license.html,\
-               epl-v10.html,\
-               build.properties
diff --git a/org.eclipse.mylyn.ide-feature/epl-v10.html b/org.eclipse.mylyn.ide-feature/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/org.eclipse.mylyn.ide-feature/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/org.eclipse.mylyn.ide-feature/feature.xml b/org.eclipse.mylyn.ide-feature/feature.xml
deleted file mode 100644
index fdefd12..0000000
--- a/org.eclipse.mylyn.ide-feature/feature.xml
+++ /dev/null
@@ -1,282 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.mylar.ide_feature"
-      label="Mylar Focused UI (Recommended)"
-      version="0.5.2.v20060601-2000"
-      provider-name="Eclipse.org"
-      plugin="org.eclipse.mylar">
-
-   <description url="http://eclipse.org/mylar">
-      Mylar Focused UI for reducing information overload when working with tasks. Filters and decorates views and editors to focus on the task context.
-   </description>
-
-   <copyright>
-      Copyright (c) 2004 - 2006 Mylar project committers and others.
-   </copyright>
-
-   <license url="http://www.eclipse.org/legal/epl-v10.html">
-      Eclipse Public License - v 1.0
-THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS
-ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT&apos;S ACCEPTANCE
-OF THIS AGREEMENT.
-1. DEFINITIONS
-&quot;Contribution&quot; means:
-a) in the case of the initial Contributor, the initial code and
-documentation distributed under this Agreement, and
-b) in the case of each subsequent Contributor:
-i) changes to the Program, and
-ii) additions to the Program;
-where such changes and/or additions to the Program originate
-from and are distributed by that particular Contributor. A Contribution
-&apos;originates&apos; from a Contributor if it was added to the Program
-by such Contributor itself or anyone acting on such Contributor&apos;s
-behalf. Contributions do not include additions to the Program
-which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.
-&quot;Contributor&quot; means any person or entity that distributes the
-Program.
-&quot;Licensed Patents &quot; mean patent claims licensable by a Contributor
-which are necessarily infringed by the use or sale of its Contribution
-alone or when combined with the Program.
-&quot;Program&quot; means the Contributions distributed in accordance with
-this Agreement.
-&quot;Recipient&quot; means anyone who receives the Program under this
-Agreement, including all Contributors.
-2. GRANT OF RIGHTS
-a) Subject to the terms of this Agreement, each Contributor hereby
-grants Recipient a non-exclusive, worldwide, royalty-free copyright
-license to reproduce, prepare derivative works of, publicly display,
-publicly perform, distribute and sublicense the Contribution
-of such Contributor, if any, and such derivative works, in source
-code and object code form.
-b) Subject to the terms of this Agreement, each Contributor hereby
-grants Recipient a non-exclusive, worldwide, royalty-free patent
-license under Licensed Patents to make, use, sell, offer to sell,
-import and otherwise transfer the Contribution of such Contributor,
-if any, in source code and object code form. This patent license
-shall apply to the combination of the Contribution and the Program
-if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to
-be covered by the Licensed Patents. The patent license shall
-not apply to any other combinations which include the Contribution.
-No hardware per se is licensed hereunder.
-c) Recipient understands that although each Contributor grants
-the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe
-the patent or other intellectual property rights of any other
-entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement
-of intellectual property rights or otherwise. As a condition
-to exercising the rights and licenses granted hereunder, each
-Recipient hereby assumes sole responsibility to secure any other
-intellectual property rights needed, if any. For example, if
-a third party patent license is required to allow Recipient to
-distribute the Program, it is Recipient&apos;s responsibility to acquire
-that license before distributing the Program.
-d) Each Contributor represents that to its knowledge it has sufficient
-copyright rights in its Contribution, if any, to grant the copyright
-license set forth in this Agreement.
-3. REQUIREMENTS
-A Contributor may choose to distribute the Program in object
-code form under its own license agreement, provided that:
-a) it complies with the terms and conditions of this Agreement;
-and
-b) its license agreement:
-i) effectively disclaims on behalf of all Contributors all warranties
-and conditions, express and implied, including warranties or
-conditions of title and non-infringement, and implied warranties
-or conditions of merchantability and fitness for a particular
-purpose;
-ii) effectively excludes on behalf of all Contributors all liability
-for damages, including direct, indirect, special, incidental
-and consequential damages, such as lost profits;
-iii) states that any provisions which differ from this Agreement
-are offered by that Contributor alone and not by any other party;
-and
-iv) states that source code for the Program is available from
-such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for
-software exchange.
-When the Program is made available in source code form:
-a) it must be made available under this Agreement; and
-b) a copy of this Agreement must be included with each copy of
-the Program.
-Contributors may not remove or alter any copyright notices contained
-within the Program.
-Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.
-4. COMMERCIAL DISTRIBUTION
-Commercial distributors of software may accept certain responsibilities
-with respect to end users, business partners and the like. While
-this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-(&quot;Commercial Contributor&quot;) hereby agrees to defend and indemnify
-every other Contributor (&quot;Indemnified Contributor&quot;) against any
-losses, damages and costs (collectively &quot;Losses&quot;) arising from
-claims, lawsuits and other legal actions brought by a third party
-against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection
-with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any
-claims or Losses relating to any actual or alleged intellectual
-property infringement. In order to qualify, an Indemnified Contributor
-must: a) promptly notify the Commercial Contributor in writing
-of such claim, and b) allow the Commercial Contributor to control,
-and cooperate with the Commercial Contributor in, the defense
-and any related settlement negotiations. The Indemnified Contributor
-may participate in any such claim at its own expense.
-For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor&apos;s responsibility
-alone. Under this section, the Commercial Contributor would have
-to defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any
-other Contributor to pay any damages as a result, the Commercial
-Contributor must pay those damages.
-5. NO WARRANTY
-EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM
-IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with
-its exercise of rights under this Agreement , including but not
-limited to the risks and costs of program errors, compliance
-with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations.
-6. DISCLAIMER OF LIABILITY
-EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT,
-INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE
-OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY
-OF SUCH DAMAGES.
-7. GENERAL
-If any provision of this Agreement is invalid or unenforceable
-under applicable law, it shall not affect the validity or enforceability
-of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be
-reformed to the minimum extent necessary to make such provision
-valid and enforceable.
-If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging
-that the Program itself (excluding combinations of the Program
-with other software or hardware) infringes such Recipient&apos;s patent(s),
-then such Recipient&apos;s rights granted under Section 2(b) shall
-terminate as of the date such litigation is filed.
-All Recipient&apos;s rights under this Agreement shall terminate if
-it fails to comply with any of the material terms or conditions
-of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If
-all Recipient&apos;s rights under this Agreement terminate, Recipient
-agrees to cease use and distribution of the Program as soon as
-reasonably practicable. However, Recipient&apos;s obligations under
-this Agreement and any licenses granted by Recipient relating
-to the Program shall continue and survive.
-Everyone is permitted to copy and distribute copies of this Agreement,
-but in order to avoid inconsistency the Agreement is copyrighted
-and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other
-than the Agreement Steward has the right to modify this Agreement.
-The Eclipse Foundation is the initial Agreement Steward. The
-Eclipse Foundation may assign the responsibility to serve as
-the Agreement Steward to a suitable separate entity. Each new
-version of the Agreement will be given a distinguishing version
-number. The Program (including Contributions) may always be distributed
-subject to the version of the Agreement under which it was received.
-In addition, after a new version of the Agreement is published,
-Contributor may elect to distribute the Program (including its
-Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights
-or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under
-this Agreement are reserved.
-This Agreement is governed by the laws of the State of New York
-and the intellectual property laws of the United States of America.
-No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose.
-Each party waives its rights to a jury trial in any resulting
-litigation.
-   </license>
-
-   <url>
-      <update label="Mylar for Eclipse 3.2" url="http://download.eclipse.org/technology/mylar/update-site/e3.2"/>
-   </url>
-
-   <requires>
-      <import plugin="org.eclipse.ui"/>
-      <import plugin="org.eclipse.core.runtime"/>
-      <import plugin="org.eclipse.mylar.core"/>
-      <import plugin="org.eclipse.mylar.tasklist"/>
-      <import plugin="org.eclipse.ui.views"/>
-      <import plugin="org.eclipse.jface.text"/>
-      <import plugin="org.eclipse.core.resources"/>
-      <import plugin="org.eclipse.jdt"/>
-      <import plugin="org.eclipse.jdt.core"/>
-      <import plugin="org.eclipse.ui.editors"/>
-      <import plugin="org.eclipse.ui.workbench.texteditor"/>
-      <import plugin="org.eclipse.search"/>
-      <import plugin="org.eclipse.jdt.debug.ui"/>
-      <import plugin="org.eclipse.jdt.ui"/>
-      <import plugin="org.eclipse.team.cvs.ui"/>
-      <import plugin="org.eclipse.debug.ui"/>
-      <import plugin="org.eclipse.jdt.junit"/>
-      <import plugin="org.eclipse.jdt.junit.runtime"/>
-      <import plugin="org.eclipse.pde.junit.runtime"/>
-      <import plugin="org.eclipse.jdt.launching"/>
-      <import plugin="org.eclipse.debug.core"/>
-      <import plugin="org.eclipse.pde.ui"/>
-      <import plugin="org.eclipse.pde.core"/>
-      <import plugin="org.eclipse.ui.ide"/>
-      <import plugin="org.eclipse.team.ui"/>
-      <import plugin="org.eclipse.team.cvs.core"/>
-      <import plugin="org.eclipse.team.core"/>
-      <import plugin="org.eclipse.ant.ui"/>
-      <import plugin="org.eclipse.ui.forms"/>
-      <import plugin="org.eclipse.ui.browser"/>
-      <import feature="org.eclipse.mylar_feature" version="0.5.2" match="greaterOrEqual"/>
-   </requires>
-
-   <plugin
-         id="org.eclipse.mylar.ui"
-         download-size="0"
-         install-size="0"
-         version="0.5.2.v20060601-2000"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.mylar.java"
-         download-size="0"
-         install-size="0"
-         version="0.5.2.v20060601-2000"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.mylar.xml"
-         download-size="0"
-         install-size="0"
-         version="0.5.2.v20060601-2000"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.mylar.ide"
-         download-size="0"
-         install-size="0"
-         version="0.5.2.v20060601-2000"
-         unpack="false"/>
-
-</feature>
diff --git a/org.eclipse.mylyn.ide-feature/license.html b/org.eclipse.mylyn.ide-feature/license.html
deleted file mode 100644
index 3259fb9..0000000
--- a/org.eclipse.mylyn.ide-feature/license.html
+++ /dev/null
@@ -1,73 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<title>Eclipse.org Software User Agreement</title>
-</head>
-
-<body lang="EN-US" link=blue vlink=purple>
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>January 28, 2005</p>
-
-<h3>Usage Of Content</h3>
-
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
-   
-<h3>Applicable Licenses</h3>   
-   
-<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation 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 provided with this Content and is also 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>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse.org CVS repository (&quot;Repository&quot;) in CVS
-   modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
-
-<p>Content may be apportioned into plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;). A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material. Files named &quot;feature.xml&quot; may contain a list of the names and version numbers of  the Plug-ins and/or Fragments associated with a Feature.   Plug-ins and Fragments are located in directories
-   named &quot;plugins&quot; and Features are located in directories named &quot;features&quot;.</p>
-  
-<p>Features may also include other Features (&quot;Included Features&quot;). Files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</p>
-  
-<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
-Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and Feature Licenses may be located in any directory of a Download or Module
-including, but not limited to the following locations:</p>
-
-<ul>
-	<li>The top-level (root) directory</li>
-	<li>Plug-in and Fragment directories</li>
-	<li>Subdirectories of the directory named &quot;src&quot; of certain Plug-ins</li>
-	<li>Feature directories</li>
-</ul>
-		
-<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Eclipse Update Manager, you must agree to a license (&quot;Feature Update License&quot;) during the
-installation process. If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
-inform you where you can locate them. Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot;.
-Such Abouts, Feature Licenses and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
-that directory.</p>
-
-<p>THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
-
-<ul>
-	<li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-	<li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-	<li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-	<li>IBM Public License 1.0 (available at <a href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</a>)</li>	
-	<li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-	<li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
-
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
-
-<h3>Cryptography</h3>
-
-<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
-   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
-   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
-</body>
-</html>
diff --git a/org.eclipse.mylyn.ide.tests/.classpath b/org.eclipse.mylyn.ide.tests/.classpath
deleted file mode 100644
index c9c6503..0000000
--- a/org.eclipse.mylyn.ide.tests/.classpath
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins">
-		<accessrules>
-			<accessrule kind="accessible" pattern="**/internal/**"/>
-		</accessrules>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5">
-		<accessrules>
-			<accessrule kind="nonaccessible" pattern="com/sun/**"/>
-		</accessrules>
-	</classpathentry>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/org.eclipse.mylyn.ide.tests/.cvsignore b/org.eclipse.mylyn.ide.tests/.cvsignore
deleted file mode 100644
index ba077a4..0000000
--- a/org.eclipse.mylyn.ide.tests/.cvsignore
+++ /dev/null
@@ -1 +0,0 @@
-bin
diff --git a/org.eclipse.mylyn.ide.tests/.project b/org.eclipse.mylyn.ide.tests/.project
deleted file mode 100644
index 51c5145..0000000
--- a/org.eclipse.mylyn.ide.tests/.project
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.mylar.ide.tests</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/org.eclipse.mylyn.ide.tests/.settings/org.eclipse.jdt.core.prefs b/org.eclipse.mylyn.ide.tests/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 67eb724..0000000
--- a/org.eclipse.mylyn.ide.tests/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,258 +0,0 @@
-#Mon Feb 13 11:20:15 PST 2006
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.5
-org.eclipse.jdt.core.compiler.debug.lineNumber=generate
-org.eclipse.jdt.core.compiler.debug.localVariable=generate
-org.eclipse.jdt.core.compiler.debug.sourceFile=generate
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.5
-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_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_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_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.blank_lines_after_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_after_package=1
-org.eclipse.jdt.core.formatter.blank_lines_before_field=1
-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_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_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=false
-org.eclipse.jdt.core.formatter.comment.format_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_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=80
-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.format_guardian_clause_on_one_line=false
-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=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_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_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_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_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_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_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_while=insert
-org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=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_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.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=120
-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=1
-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_tabs_only_for_leading_indentations=false
diff --git a/org.eclipse.mylyn.ide.tests/.settings/org.eclipse.jdt.ui.prefs b/org.eclipse.mylyn.ide.tests/.settings/org.eclipse.jdt.ui.prefs
deleted file mode 100644
index 52a2382..0000000
--- a/org.eclipse.mylyn.ide.tests/.settings/org.eclipse.jdt.ui.prefs
+++ /dev/null
@@ -1,6 +0,0 @@
-#Mon Feb 13 11:20:14 PST 2006
-eclipse.preferences.version=1
-formatter_profile=_Mylar based on Eclipse [built-in]
-formatter_settings_version=10
-internal.default.compliance=default
-org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><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">/**\r\n * @return the ${bare_field_name}\r\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">/**\r\n * @param ${param} the ${bare_field_name} to set\r\n */</template><template autoinsert\="true" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/**\r\n * \r\n */</template><template autoinsert\="false" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/**\r\n * @author ${user}\r\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">/**\r\n * \r\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">/**\r\n * ${tags}\r\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"></template><template autoinsert\="false" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">/*******************************************************************************\r\n * Copyright (c) 2004 - 2006 University Of British Columbia and others.\r\n * All rights reserved. This program and the accompanying materials\r\n * are made available under the terms of the Eclipse Public License v1.0\r\n * which accompanies this distribution, and is available at\r\n * http\://www.eclipse.org/legal/epl-v10.html\r\n *\r\n * Contributors\:\r\n *     University Of British Columbia - initial API and implementation\r\n *******************************************************************************/\r\n\r\n${package_declaration}\r\n\r\n${typecomment}\r\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">\r\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">\r\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">\r\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">\r\n</template><template autoinsert\="false" 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\r\n${exception_var}.printStackTrace();</template><template autoinsert\="false" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ignore\r\n${body_statement}</template><template autoinsert\="false" 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}\r\n// ignore</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/org.eclipse.mylyn.ide.tests/.settings/org.eclipse.ltk.core.refactoring.prefs b/org.eclipse.mylyn.ide.tests/.settings/org.eclipse.ltk.core.refactoring.prefs
deleted file mode 100644
index bf0b12d..0000000
--- a/org.eclipse.mylyn.ide.tests/.settings/org.eclipse.ltk.core.refactoring.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Fri Jun 02 15:30:54 PDT 2006
-eclipse.preferences.version=1
-org.eclipse.ltk.core.refactoring.enable.project.refactoring.history=true
diff --git a/org.eclipse.mylyn.ide.tests/META-INF/MANIFEST.MF b/org.eclipse.mylyn.ide.tests/META-INF/MANIFEST.MF
deleted file mode 100644
index f74769c..0000000
--- a/org.eclipse.mylyn.ide.tests/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,23 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: Mylar IDE Tests Plug-in
-Bundle-SymbolicName: org.eclipse.mylar.ide.tests
-Bundle-Version: 0.0.0
-Bundle-Vendor: Eclipse.org
-Bundle-Localization: plugin
-Require-Bundle: org.junit,
- org.eclipse.core.resources,
- org.eclipse.core.runtime,
- org.eclipse.mylar.ide,
- org.eclipse.mylar.ui,
- org.eclipse.mylar.core,
- org.eclipse.ui.workbench,
- org.eclipse.ui.ide,
- org.eclipse.mylar.core.tests,
- org.eclipse.ui.views,
- org.eclipse.jface,
- org.eclipse.mylar.tasklist,
- org.eclipse.team.core,
- org.eclipse.team.cvs.ui
-Export-Package: org.eclipse.mylar.ide.tests
-Bundle-RequiredExecutionEnvironment: J2SE-1.5
diff --git a/org.eclipse.mylyn.ide.tests/about.html b/org.eclipse.mylyn.ide.tests/about.html
deleted file mode 100644
index 1aeb16b..0000000
--- a/org.eclipse.mylyn.ide.tests/about.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>May 2, 2006</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</a>.</p>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/org.eclipse.mylyn.ide.tests/build.properties b/org.eclipse.mylyn.ide.tests/build.properties
deleted file mode 100644
index 01faa9d..0000000
--- a/org.eclipse.mylyn.ide.tests/build.properties
+++ /dev/null
@@ -1,5 +0,0 @@
-source.. = src/
-output.. = bin/
-bin.includes = META-INF/,\
-               .
-jre.compilation.profile = J2SE-1.5
diff --git a/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/AbstractResourceContextTest.java b/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/AbstractResourceContextTest.java
deleted file mode 100644
index 1b9f641..0000000
--- a/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/AbstractResourceContextTest.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.ide.tests;
-
-import org.eclipse.mylar.core.tests.AbstractContextTest;
-import org.eclipse.mylar.internal.core.MylarContext;
-import org.eclipse.mylar.internal.core.MylarContextManager;
-import org.eclipse.mylar.internal.core.ScalingFactors;
-import org.eclipse.mylar.internal.ide.MylarIdePlugin;
-import org.eclipse.mylar.internal.ide.ResourceInteractionMonitor;
-import org.eclipse.mylar.internal.ide.ResourceStructureBridge;
-import org.eclipse.mylar.internal.ide.ui.IdeUiUtil;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-import org.eclipse.ui.views.navigator.ResourceNavigator;
-
-/**
- * @author Mik Kersten
- */
-public abstract class AbstractResourceContextTest extends AbstractContextTest {
-
-	protected MylarContextManager manager = MylarPlugin.getContextManager();
-
-	protected ResourceInteractionMonitor monitor = new ResourceInteractionMonitor();
-
-	protected ResourceStructureBridge structureBridge = new ResourceStructureBridge();
-
-	protected TestProject project;
-
-	protected MylarContext context;
-
-	protected ScalingFactors scaling = new ScalingFactors();
-
-	protected String taskId = this.getClass().getName();
-
-	protected ResourceNavigator navigator;
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-		assertNotNull(MylarIdePlugin.getDefault());
-		project = new TestProject(this.getClass().getName());
-		context = new MylarContext(taskId, scaling);
-		context.reset();
-		manager.activateContext(context);
-		MylarUiPlugin.getDefault().getViewerManager().setSyncRefreshMode(true);
-		navigator = (ResourceNavigator) openView(IdeUiUtil.ID_NAVIGATOR);
-		assertNotNull(navigator);
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		context.reset();
-		assertTrue(context.getInteresting().isEmpty());
-		manager.deactivateContext(taskId);
-		manager.deleteContext(taskId);
-		manager.getFileForContext(taskId).delete();
-		ResourceTestUtil.deleteProject(project.getProject());
-		super.tearDown();
-	}
-}
diff --git a/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/AllIdeTests.java b/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/AllIdeTests.java
deleted file mode 100644
index ea68326..0000000
--- a/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/AllIdeTests.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.ide.tests;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-
-/**
- * @author Mik Kersten
- */
-public class AllIdeTests {
-
-	public static Test suite() {
-		TestSuite suite = new TestSuite("Test for org.eclipse.mylar.ide.tests");
-
-		// $JUnit-BEGIN$
-		suite.addTestSuite(ResourceContextTest.class);
-		suite.addTestSuite(ChangeSetManagerTest.class);
-		suite.addTestSuite(CommitMessageTest.class);
-		// $JUnit-END$
-
-		return suite;
-	}
-}
diff --git a/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/ChangeSetManagerTest.java b/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/ChangeSetManagerTest.java
deleted file mode 100644
index d3db3df..0000000
--- a/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/ChangeSetManagerTest.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.ide.tests;
-
-import java.util.List;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.mylar.internal.ide.MylarIdePlugin;
-import org.eclipse.mylar.internal.ide.team.MylarChangeSetManager;
-import org.eclipse.mylar.internal.ide.team.MylarActiveChangeSet;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
-import org.eclipse.mylar.provisional.tasklist.Task;
-import org.eclipse.team.internal.ccvs.ui.CVSUIPlugin;
-import org.eclipse.team.internal.core.subscribers.ActiveChangeSetManager;
-import org.eclipse.team.internal.core.subscribers.ChangeSet;
-
-/**
- * @author Mik Kersten
- */
-public class ChangeSetManagerTest extends AbstractResourceContextTest {
-
-	private MylarChangeSetManager changeSetManager;
-
-	private ActiveChangeSetManager collector;
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-		assertNotNull(MylarIdePlugin.getDefault());
-		changeSetManager = MylarIdePlugin.getDefault().getChangeSetManager();
-		collector = CVSUIPlugin.getPlugin().getChangeSetManager();
-		assertNotNull(changeSetManager);
-		assertEquals(0, MylarTaskListPlugin.getTaskListManager().getTaskList().getActiveTasks().size());
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		super.tearDown();
-	}
-
-	public void testDisabledMode() {
-		ChangeSet[] sets = collector.getSets();
-		for (int i = 0; i < sets.length; i++)
-			collector.remove(sets[i]);
-
-		assertEquals(0, collector.getSets().length);
-		manager.deactivateContext(taskId);
-		changeSetManager.clearActiveChangeSets();
-		assertEquals(0, changeSetManager.getActiveChangeSets().size());
-
-		MylarIdePlugin.getDefault().getChangeSetManager().disable();
-
-		Task task1 = new Task("task1", "label", true);
-		MylarTaskListPlugin.getTaskListManager().activateTask(task1);
-		assertEquals(0, changeSetManager.getActiveChangeSets().size());
-		assertEquals(0, collector.getSets().length);
-
-		MylarTaskListPlugin.getTaskListManager().deactivateTask(task1);
-		MylarIdePlugin.getDefault().getChangeSetManager().enable();
-	}
-
-	public void testSingleContextActivation() {
-		ChangeSet[] sets = collector.getSets();
-		for (int i = 0; i < sets.length; i++)
-			collector.remove(sets[i]);
-
-		assertEquals(0, collector.getSets().length);
-		manager.deactivateContext(taskId);
-		changeSetManager.clearActiveChangeSets();
-		assertEquals(0, changeSetManager.getActiveChangeSets().size());
-
-		Task task1 = new Task("task1", "label", true);
-		MylarTaskListPlugin.getTaskListManager().activateTask(task1);
-		assertEquals(1, changeSetManager.getActiveChangeSets().size());
-		assertEquals(1, collector.getSets().length);
-
-		MylarTaskListPlugin.getTaskListManager().deactivateTask(task1);
-		assertFalse(MylarPlugin.getContextManager().isContextActive());
-		assertEquals(0, changeSetManager.getActiveChangeSets().size());
-		assertEquals(0, collector.getSets().length); // deleted because no
-		// active resources
-		MylarTaskListPlugin.getTaskListManager().deactivateTask(task1);
-		
-		// TODO: test with resource
-	}
-
-	public void testContentsAfterDecay() throws CoreException {
-		IFile file = project.getProject().getFile(new Path("foo.txt"));
-		file.create(null, true, null);
-
-		Task task1 = new Task("task1", "label", true);
-		MylarTaskListPlugin.getTaskListManager().activateTask(task1);
-
-		monitor.selectionChanged(navigator, new StructuredSelection(file));
-		IMylarElement fileElement = MylarPlugin.getContextManager().getElement(
-				structureBridge.getHandleIdentifier(file));
-		assertTrue(fileElement.getInterest().isInteresting());
-
-		List<MylarActiveChangeSet> changeSets = changeSetManager.getActiveChangeSets();
-		assertEquals(1, changeSets.size());
-		MylarActiveChangeSet set = changeSets.get(0);
-		IResource[] resources = set.getResources();
-		// can have .project file in there
-		assertTrue("length: " + resources.length, resources.length <= 2); 
-
-		for (int i = 0; i < 1 / (scaling.getDecay().getValue()) * 3; i++) {
-			MylarPlugin.getContextManager().handleInteractionEvent(mockSelection());
-		}
-		assertTrue("" + fileElement.getInterest().getValue(), fileElement.getInterest().getValue() < 0);
-		assertTrue("length: " + resources.length, resources.length <= 2); 
-
-		MylarTaskListPlugin.getTaskListManager().deactivateTask(task1);
-	}
-}
diff --git a/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/CommitMessageTest.java b/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/CommitMessageTest.java
deleted file mode 100644
index 27d435b..0000000
--- a/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/CommitMessageTest.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.ide.tests;
-
-import junit.framework.TestCase;
-
-import org.eclipse.mylar.internal.ide.MylarIdePlugin;
-import org.eclipse.mylar.internal.ide.team.MylarActiveChangeSet;
-import org.eclipse.mylar.provisional.tasklist.ITask;
-import org.eclipse.mylar.provisional.tasklist.Task;
-
-/**
- * @author Mik Kersten
- */
-public class CommitMessageTest extends TestCase {
-
-	@SuppressWarnings("serial")
-	public void testBugzillaCommentParsing() {
-		ITask task = new Task("handle", "111: foo", false) {
-			public boolean isLocal() {
-				return false;
-			}
-		};
-		String comment = MylarActiveChangeSet.generateComment(task, MylarIdePlugin.DEFAULT_PREFIX_COMPLETED,
-				MylarIdePlugin.DEFAULT_PREFIX_PROGRESS);
-		String bugId = MylarActiveChangeSet.getTaskIdFromCommentOrLabel(comment);
-		assertEquals("111", bugId);
-	}
-
-	@SuppressWarnings("serial")
-	public void testLocalTaskCommentParsing() {
-		ITask task = new Task("handle", "foo", false);
-		task.setUrl("http://eclipse.org/mylar");
-		String comment = MylarActiveChangeSet.generateComment(task, MylarIdePlugin.DEFAULT_PREFIX_COMPLETED,
-				MylarIdePlugin.DEFAULT_PREFIX_PROGRESS);
-//		String bugId = MylarContextChangeSet.getTaskIdFromCommentOrLabel(comment);
-//		assertEquals(null, bugId);
-		String url = MylarActiveChangeSet.getUrlFromComment(comment);
-		assertEquals("http://eclipse.org/mylar", url);
-
-		task.setUrl("http://eclipse.org/mylar bla \n bla");
-		String comment2 = MylarActiveChangeSet.generateComment(task, MylarIdePlugin.DEFAULT_PREFIX_COMPLETED,
-				MylarIdePlugin.DEFAULT_PREFIX_PROGRESS);
-		String url2 = MylarActiveChangeSet.getUrlFromComment(comment2);
-		assertEquals("http://eclipse.org/mylar", url2);
-	}
-	
-	public void testChangeSetLabelParsing() {
-		String label = "1: foo";
-		String id = MylarActiveChangeSet.getTaskIdFromCommentOrLabel(label);
-		assertEquals("1", id);
-	}
-
-}
diff --git a/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/ResourceContextTest.java b/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/ResourceContextTest.java
deleted file mode 100644
index 543db28..0000000
--- a/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/ResourceContextTest.java
+++ /dev/null
@@ -1,98 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.ide.tests;
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IFolder;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.mylar.internal.ide.MylarIdePlugin;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-
-/**
- * @author Mik Kersten
- */
-public class ResourceContextTest extends AbstractResourceContextTest {
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-		MylarIdePlugin.getDefault().setResourceMonitoringEnabled(true);
-		MylarIdePlugin.getDefault().getInterestUpdater().setSyncExec(true);
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		super.tearDown();
-		MylarIdePlugin.getDefault().getInterestUpdater().setSyncExec(false);
-	}
-
-	public void testResourceSelect() throws CoreException {
-		MylarPlugin.getContextManager().setContextCapturePaused(true);
-		IFile file = project.getProject().getFile("file");
-		file.create(null, true, null);
-		assertTrue(file.exists());
-
-		IMylarElement element = MylarPlugin.getContextManager().getElement(structureBridge.getHandleIdentifier(file));
-		assertFalse(element.getInterest().isInteresting());
-		MylarPlugin.getContextManager().setContextCapturePaused(false);
-
-		monitor.selectionChanged(navigator, new StructuredSelection(file));
-		element = MylarPlugin.getContextManager().getElement(structureBridge.getHandleIdentifier(file));
-		assertTrue(element.getInterest().isInteresting());
-	}
-
-	public void testFileAdded() throws CoreException {
-		IFile file = project.getProject().getFile("new-file.txt");
-		file.create(null, true, null);
-		assertTrue(file.exists());
-
-		IMylarElement element = MylarPlugin.getContextManager().getElement(structureBridge.getHandleIdentifier(file));
-		assertTrue(element.getInterest().isInteresting());
-	}
-
-	public void testFolderAddedOnCreation() throws CoreException {
-		IFolder folder = project.getProject().getFolder("folder");
-		folder.create(true, true, null);
-		assertTrue(folder.exists());
-
-		IMylarElement element = MylarPlugin.getContextManager().getElement(structureBridge.getHandleIdentifier(folder));
-		assertTrue(element.getInterest().isInteresting());
-	}
-
-	public void testDecrementOfFile() throws CoreException, InvocationTargetException, InterruptedException {
-		IFolder folder = project.getProject().getFolder("folder");
-		folder.create(true, true, null);
-		IFile file = project.getProject().getFile(new Path("folder/foo.txt"));
-		file.create(null, true, null);
-
-		monitor.selectionChanged(navigator, new StructuredSelection(file));
-		monitor.selectionChanged(navigator, new StructuredSelection(folder));
-
-		IMylarElement fileElement = MylarPlugin.getContextManager().getElement(
-				structureBridge.getHandleIdentifier(file));
-		IMylarElement folderElement = MylarPlugin.getContextManager().getElement(
-				structureBridge.getHandleIdentifier(folder));
-
-		assertTrue(fileElement.getInterest().isInteresting());
-		assertTrue(folderElement.getInterest().isInteresting());
-
-		assertTrue(MylarPlugin.getContextManager().manipulateInterestForElement(folderElement, false, false, "test"));
-
-		assertFalse(folderElement.getInterest().isInteresting());
-		assertFalse(fileElement.getInterest().isInteresting());
-	}
-}
diff --git a/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/ResourceTestUtil.java b/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/ResourceTestUtil.java
deleted file mode 100644
index 03fbb31..0000000
--- a/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/ResourceTestUtil.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.ide.tests;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.runtime.CoreException;
-
-/**
- * @author Mik Kersten
- */
-public class ResourceTestUtil {
-
-	public static void deleteProject(IProject project) throws CoreException {
-		if (project.exists() && !project.isOpen()) { // force opening so that
-			// project can be
-			// deleted without
-			// logging (see bug
-			// 23629)
-			project.open(null);
-		}
-		deleteResource(project);
-	}
-
-	public static void deleteResource(IResource resource) throws CoreException {
-		CoreException lastException = null;
-		try {
-			resource.delete(true, null);
-		} catch (CoreException e) {
-			lastException = e;
-			// just print for info
-			System.out.println("(CoreException): " + e.getMessage() + ", resource " + resource.getFullPath()); //$NON-NLS-1$ //$NON-NLS-2$
-		} catch (IllegalArgumentException iae) {
-			// just print for info
-			System.out
-					.println("(IllegalArgumentException): " + iae.getMessage() + ", resource " + resource.getFullPath()); //$NON-NLS-1$ //$NON-NLS-2$
-		}
-		int retryCount = 60; // wait 1 minute at most
-		while (resource.isAccessible() && --retryCount >= 0) {
-			try {
-				Thread.sleep(1000);
-			} catch (InterruptedException e) {
-			}
-			try {
-				resource.delete(true, null);
-			} catch (CoreException e) {
-				lastException = e;
-				// just print for info
-				System.out
-						.println("(CoreException) Retry " + retryCount + ": " + e.getMessage() + ", resource " + resource.getFullPath()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-			} catch (IllegalArgumentException iae) {
-				// just print for info
-				System.out
-						.println("(IllegalArgumentException) Retry " + retryCount + ": " + iae.getMessage() + ", resource " + resource.getFullPath()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-			}
-		}
-		if (!resource.isAccessible())
-			return;
-		System.err.println("Failed to delete " + resource.getFullPath()); //$NON-NLS-1$
-		if (lastException != null) {
-			throw lastException;
-		}
-	}
-}
diff --git a/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/TestProject.java b/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/TestProject.java
deleted file mode 100644
index 5cc8ffd..0000000
--- a/org.eclipse.mylyn.ide.tests/src/org/eclipse/mylyn/ide/tests/TestProject.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-/*
- * Created on Jul 20, 2004
- */
-package org.eclipse.mylar.ide.tests;
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.eclipse.core.resources.IFolder;
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IWorkspaceRoot;
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.CoreException;
-
-/**
- * @author Mik Kersten
- */
-public class TestProject {
-
-	public IProject project;
-
-	public TestProject(final String name) throws CoreException, InvocationTargetException, InterruptedException {
-		IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
-		project = root.getProject(name);
-		project.create(null);
-		project.open(null);
-	}
-
-	public IProject getProject() {
-		return project;
-	}
-
-	public IFolder createFolder(String name) throws CoreException {
-		IFolder folder = project.getFolder(name);
-		folder.create(false, true, null);
-		return folder;
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/.classpath b/org.eclipse.mylyn.java.tests/.classpath
deleted file mode 100644
index c9c6503..0000000
--- a/org.eclipse.mylyn.java.tests/.classpath
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins">
-		<accessrules>
-			<accessrule kind="accessible" pattern="**/internal/**"/>
-		</accessrules>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5">
-		<accessrules>
-			<accessrule kind="nonaccessible" pattern="com/sun/**"/>
-		</accessrules>
-	</classpathentry>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/org.eclipse.mylyn.java.tests/.cvsignore b/org.eclipse.mylyn.java.tests/.cvsignore
deleted file mode 100644
index ba077a4..0000000
--- a/org.eclipse.mylyn.java.tests/.cvsignore
+++ /dev/null
@@ -1 +0,0 @@
-bin
diff --git a/org.eclipse.mylyn.java.tests/.project b/org.eclipse.mylyn.java.tests/.project
deleted file mode 100644
index 6232f60..0000000
--- a/org.eclipse.mylyn.java.tests/.project
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.mylar.java.tests</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/org.eclipse.mylyn.java.tests/.settings/org.eclipse.jdt.core.prefs b/org.eclipse.mylyn.java.tests/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 12b2c1a..0000000
--- a/org.eclipse.mylyn.java.tests/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,303 +0,0 @@
-#Mon Feb 13 11:20:15 PST 2006
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.5
-org.eclipse.jdt.core.compiler.debug.lineNumber=generate
-org.eclipse.jdt.core.compiler.debug.localVariable=generate
-org.eclipse.jdt.core.compiler.debug.sourceFile=generate
-org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
-org.eclipse.jdt.core.compiler.problem.deprecation=warning
-org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
-org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
-org.eclipse.jdt.core.compiler.problem.discouragedReference=warning
-org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
-org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
-org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
-org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
-org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
-org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
-org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore
-org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
-org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
-org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
-org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
-org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
-org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
-org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
-org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
-org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
-org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
-org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
-org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
-org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
-org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
-org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
-org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
-org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
-org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
-org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=ignore
-org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.unusedImport=warning
-org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
-org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
-org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning
-org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.5
-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_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_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_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.blank_lines_after_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_after_package=1
-org.eclipse.jdt.core.formatter.blank_lines_before_field=1
-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_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_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=false
-org.eclipse.jdt.core.formatter.comment.format_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_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=80
-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.format_guardian_clause_on_one_line=false
-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=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_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_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_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_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_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_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_while=insert
-org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=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_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.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=120
-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=1
-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_tabs_only_for_leading_indentations=false
diff --git a/org.eclipse.mylyn.java.tests/.settings/org.eclipse.jdt.ui.prefs b/org.eclipse.mylyn.java.tests/.settings/org.eclipse.jdt.ui.prefs
deleted file mode 100644
index 2448f88..0000000
--- a/org.eclipse.mylyn.java.tests/.settings/org.eclipse.jdt.ui.prefs
+++ /dev/null
@@ -1,5 +0,0 @@
-#Mon Feb 13 11:20:15 PST 2006
-eclipse.preferences.version=1
-formatter_profile=_Mylar based on Eclipse [built-in]
-formatter_settings_version=10
-org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><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">/**\r\n * @return the ${bare_field_name}\r\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">/**\r\n * @param ${param} the ${bare_field_name} to set\r\n */</template><template autoinsert\="true" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/**\r\n * \r\n */</template><template autoinsert\="false" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/**\r\n * @author ${user}\r\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">/**\r\n * \r\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">/**\r\n * ${tags}\r\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"></template><template autoinsert\="false" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">/*******************************************************************************\r\n * Copyright (c) 2004 - 2006 University Of British Columbia and others.\r\n * All rights reserved. This program and the accompanying materials\r\n * are made available under the terms of the Eclipse Public License v1.0\r\n * which accompanies this distribution, and is available at\r\n * http\://www.eclipse.org/legal/epl-v10.html\r\n *\r\n * Contributors\:\r\n *     University Of British Columbia - initial API and implementation\r\n *******************************************************************************/\r\n\r\n${package_declaration}\r\n\r\n${typecomment}\r\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">\r\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">\r\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">\r\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">\r\n</template><template autoinsert\="false" 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\r\n${exception_var}.printStackTrace();</template><template autoinsert\="false" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ignore\r\n${body_statement}</template><template autoinsert\="false" 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}\r\n// ignore</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/org.eclipse.mylyn.java.tests/.settings/org.eclipse.ltk.core.refactoring.prefs b/org.eclipse.mylyn.java.tests/.settings/org.eclipse.ltk.core.refactoring.prefs
deleted file mode 100644
index daed405..0000000
--- a/org.eclipse.mylyn.java.tests/.settings/org.eclipse.ltk.core.refactoring.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Fri Jun 02 15:30:59 PDT 2006
-eclipse.preferences.version=1
-org.eclipse.ltk.core.refactoring.enable.project.refactoring.history=true
diff --git a/org.eclipse.mylyn.java.tests/.settings/org.eclipse.pde.prefs b/org.eclipse.mylyn.java.tests/.settings/org.eclipse.pde.prefs
deleted file mode 100644
index e423c50..0000000
--- a/org.eclipse.mylyn.java.tests/.settings/org.eclipse.pde.prefs
+++ /dev/null
@@ -1,12 +0,0 @@
-#Thu Nov 03 15:46:48 PST 2005
-compilers.p.deprecated=2
-compilers.p.no-required-att=0
-compilers.p.not-externalized-att=2
-compilers.p.unknown-attribute=0
-compilers.p.unknown-class=0
-compilers.p.unknown-element=0
-compilers.p.unknown-resource=0
-compilers.p.unresolved-ex-points=0
-compilers.p.unresolved-import=0
-compilers.use-project=true
-eclipse.preferences.version=1
diff --git a/org.eclipse.mylyn.java.tests/META-INF/MANIFEST.MF b/org.eclipse.mylyn.java.tests/META-INF/MANIFEST.MF
deleted file mode 100644
index d167881..0000000
--- a/org.eclipse.mylyn.java.tests/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,38 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: Mylar Java Tests Plug-in
-Bundle-SymbolicName: org.eclipse.mylar.java.tests
-Bundle-Version: 0.0.0
-Bundle-Vendor: Eclipse.org
-Bundle-Localization: plugin
-Require-Bundle: org.eclipse.core.runtime,
- org.eclipse.jdt.core,
- org.eclipse.jdt.ui,
- org.eclipse.core.resources,
- org.eclipse.jface,
- org.eclipse.jface.text,
- org.eclipse.ui.workbench,
- org.junit,
- org.eclipse.ui,
- org.eclipse.ui.editors,
- org.eclipse.ui.workbench.texteditor,
- org.eclipse.jdt.core,
- org.eclipse.core.resources,
- org.eclipse.core.runtime,
- org.junit,
- org.eclipse.ui,
- org.eclipse.mylar.core,
- org.eclipse.mylar.core.tests,
- org.eclipse.mylar.java,
- org.eclipse.mylar.xml,
- org.eclipse.mylar.ide,
- org.eclipse.mylar.ui,
- org.eclipse.ui.ide,
- org.eclipse.mylar.tasklist,
- org.eclipse.jdt.launching,
- org.eclipse.mylar.ide.tests
-Eclipse-AutoStart: true
-Bundle-ClassPath: mylar-java-tests.jar
-Export-Package: org.eclipse.mylar.java.tests,
- org.eclipse.mylar.java.tests.search
-Bundle-RequiredExecutionEnvironment: J2SE-1.5
diff --git a/org.eclipse.mylyn.java.tests/about.html b/org.eclipse.mylyn.java.tests/about.html
deleted file mode 100644
index 1aeb16b..0000000
--- a/org.eclipse.mylyn.java.tests/about.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>May 2, 2006</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</a>.</p>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/org.eclipse.mylyn.java.tests/build.properties b/org.eclipse.mylyn.java.tests/build.properties
deleted file mode 100644
index 8f04f20..0000000
--- a/org.eclipse.mylyn.java.tests/build.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-###############################################################################
-# Copyright (c) 2004 - 2005 University Of British Columbia 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:
-#     University Of British Columbia - initial API and implementation
-###############################################################################
-bin.includes = META-INF/,\
-               mylar-java-tests.jar,\
-               about.html
-src.includes = META-INF/,\
-               src/,\
-               about.html
-jars.compile.order = mylar-java-tests.jar
-source.mylar-java-tests.jar = src/
-output.mylar-java-tests.jar = bin/
-jre.compilation.profile = J2SE-1.5
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/AbstractJavaContextTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/AbstractJavaContextTest.java
deleted file mode 100644
index 940befb..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/AbstractJavaContextTest.java
+++ /dev/null
@@ -1,158 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.OperationCanceledException;
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.jdt.core.IPackageFragment;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.internal.ui.JavaPlugin;
-import org.eclipse.mylar.core.tests.AbstractContextTest;
-import org.eclipse.mylar.ide.tests.ResourceTestUtil;
-import org.eclipse.mylar.internal.core.MylarContext;
-import org.eclipse.mylar.internal.core.MylarContextManager;
-import org.eclipse.mylar.internal.core.ScalingFactors;
-import org.eclipse.mylar.internal.ide.MylarIdePlugin;
-import org.eclipse.mylar.internal.java.JavaEditingMonitor;
-import org.eclipse.mylar.internal.java.JavaStructureBridge;
-import org.eclipse.mylar.internal.java.MylarJavaPlugin;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-
-/**
- * @author Mik Kersten
- */
-public abstract class AbstractJavaContextTest extends AbstractContextTest {
-
-	protected MylarContextManager manager = MylarPlugin.getContextManager();
-
-	protected JavaEditingMonitor monitor = new JavaEditingMonitor();
-
-	protected TestJavaProject project;
-
-	protected IPackageFragment p1;
-
-	protected IType type1;
-
-	protected String contextId = this.getClass().getSimpleName();
-
-	protected MylarContext context;
-
-	protected ScalingFactors scaling = new ScalingFactors();
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-		assertNotNull(JavaPlugin.getDefault());
-		assertNotNull(MylarJavaPlugin.getDefault());
-		project = new TestJavaProject(this.getClass().getSimpleName());// + "-"
-																		// +
-																		// projectCounter++);
-		p1 = project.createPackage("p1");
-		type1 = project.createType(p1, "Type1.java", "public class Type1 { }");
-		context = new MylarContext(contextId, scaling);
-		context.reset();
-		// assertTrue(manager.getActiveContext().getInteresting().toString(),
-		// manager.getActiveContext().getInteresting().isEmpty());
-		manager.activateContext(context);
-		assertNotNull(MylarJavaPlugin.getDefault());
-		assertTrue(MylarPlugin.getDefault().getStructureBridges().toString().indexOf(
-				JavaStructureBridge.class.getCanonicalName()) != -1);
-
-		MylarUiPlugin.getDefault().getViewerManager().setSyncRefreshMode(true);
-		MylarIdePlugin.getDefault().setResourceMonitoringEnabled(false);
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		context.reset();
-		assertTrue(context.getInteresting().isEmpty());
-		manager.deactivateContext(contextId);
-		manager.deleteContext(contextId);
-		manager.getFileForContext(contextId).delete();
-
-		ResourceTestUtil.deleteProject(project.getProject());
-
-		for (MylarContext context : manager.getActiveContexts()) {
-			manager.deactivateContext(context.getHandleIdentifier());
-		}
-		if (manager.isContextActive())
-			System.err.println("> still active: " + manager.getActiveContext().getInteresting());
-		assertFalse(manager.isContextActive());
-		waitForAutoBuild();
-		super.tearDown();
-	}
-
-	public static void waitForAutoBuild() {
-		boolean wasInterrupted = false;
-		do {
-			try {
-				Platform.getJobManager().join(ResourcesPlugin.FAMILY_AUTO_BUILD, null);
-				wasInterrupted = false;
-			} catch (OperationCanceledException e) {
-				e.printStackTrace();
-			} catch (InterruptedException e) {
-				wasInterrupted = true;
-			}
-		} while (wasInterrupted);
-	}
-
-	class TestProgressMonitor implements IProgressMonitor {
-
-		boolean done = false;
-
-		public void beginTask(String name, int totalWork) {
-			// TODO Auto-generated method stub
-
-		}
-
-		public void done() {
-			done = true;
-		}
-
-		public void internalWorked(double work) {
-			// TODO Auto-generated method stub
-
-		}
-
-		public boolean isCanceled() {
-			// TODO Auto-generated method stub
-			return false;
-		}
-
-		public void setCanceled(boolean value) {
-			// TODO Auto-generated method stub
-
-		}
-
-		public void setTaskName(String name) {
-			// TODO Auto-generated method stub
-
-		}
-
-		public void subTask(String name) {
-			// TODO Auto-generated method stub
-
-		}
-
-		public void worked(int work) {
-			// TODO Auto-generated method stub
-
-		}
-
-		public boolean isDone() {
-			return done;
-		}
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ActiveHierarchyTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ActiveHierarchyTest.java
deleted file mode 100644
index a75765e..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ActiveHierarchyTest.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.eclipse.jdt.core.IJavaElement;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.internal.ui.JavaPlugin;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.mylar.core.tests.UiTestUtil;
-import org.eclipse.mylar.internal.java.ui.views.ActiveHierarchyView;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.swt.widgets.Tree;
-import org.eclipse.swt.widgets.TreeItem;
-import org.eclipse.ui.PartInitException;
-
-/**
- * @author Mik Kersten
- */
-public class ActiveHierarchyTest extends AbstractJavaContextTest {
-
-	private ActiveHierarchyView view;
-
-	private Tree tree;
-
-	public ActiveHierarchyTest() throws PartInitException {
-		view = (ActiveHierarchyView) JavaPlugin.getActivePage().showView(ActiveHierarchyView.ID);
-		tree = view.getViewer().getTree();
-	}
-
-	/**
-	 * bug#107384
-	 */
-	public void testElementDuplication() throws JavaModelException {
-		assertEquals(0, tree.getItemCount());
-		assertEquals(0, MylarPlugin.getContextManager().getActiveLandmarks().size());
-
-		IType superType = project.createType(p1, "Super.java", "public class Super { }");
-		makeLandmark(superType);
-		List<TreeItem> collectedItems = new ArrayList<TreeItem>();
-		UiTestUtil.collectTreeItemsInView(tree.getItems(), collectedItems);
-		assertEquals(2, collectedItems.size());
-
-		IType sub1 = project.createType(p1, "Sub1.java", "public class Sub1 extends Super { }");
-		makeLandmark(sub1);
-		collectedItems = new ArrayList<TreeItem>();
-		UiTestUtil.collectTreeItemsInView(tree.getItems(), collectedItems);
-		assertEquals(3, collectedItems.size());
-
-		IType sub2 = project.createType(p1, "Sub2.java", "public class Sub2 extends Super { }");
-		makeLandmark(sub2);
-		collectedItems = new ArrayList<TreeItem>();
-		UiTestUtil.collectTreeItemsInView(tree.getItems(), collectedItems);
-		assertEquals(4, collectedItems.size());
-
-		IType subsub = project.createType(p1, "SubSub.java", "public class SubSub extends Sub1 { }");
-		makeLandmark(subsub);
-		collectedItems = new ArrayList<TreeItem>();
-		UiTestUtil.collectTreeItemsInView(tree.getItems(), collectedItems);
-		assertEquals(5, collectedItems.size());
-	}
-
-	private void makeLandmark(IJavaElement element) {
-		StructuredSelection s1 = new StructuredSelection(element);
-		monitor.selectionChanged(view, s1);
-		manager.handleInteractionEvent(mockInterestContribution(element.getHandleIdentifier(), scaling.getLandmark()));
-		view.refreshHierarchy(false);
-	}
-
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ActiveSearchTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ActiveSearchTest.java
deleted file mode 100644
index d8fd6c8..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ActiveSearchTest.java
+++ /dev/null
@@ -1,152 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.core.search.IJavaSearchConstants;
-import org.eclipse.jdt.internal.ui.JavaPlugin;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.mylar.core.tests.UiTestUtil;
-import org.eclipse.mylar.core.tests.support.search.TestActiveSearchListener;
-import org.eclipse.mylar.internal.core.search.IMylarSearchOperation;
-import org.eclipse.mylar.internal.ide.ui.views.ActiveSearchView;
-import org.eclipse.mylar.internal.java.search.JavaReferencesProvider;
-import org.eclipse.mylar.java.tests.search.SearchPluginTestHelper;
-import org.eclipse.mylar.provisional.core.AbstractRelationProvider;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.swt.widgets.TreeItem;
-import org.eclipse.ui.IViewReference;
-import org.eclipse.ui.IWorkbenchPart;
-import org.eclipse.ui.PartInitException;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.ui.internal.Perspective;
-import org.eclipse.ui.internal.WorkbenchPage;
-
-/**
- * @author Mik Kersten
- */
-public class ActiveSearchTest extends AbstractJavaContextTest {
-
-	private ActiveSearchView view;
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		super.tearDown();
-	}
-
-	public void testViewRecursion() throws JavaModelException, PartInitException {
-		view = (ActiveSearchView) JavaPlugin.getActivePage().showView(ActiveSearchView.ID);
-		ActiveSearchView.getFromActivePerspective().setSyncExecForTesting(false);
-
-		for (AbstractRelationProvider provider : MylarPlugin.getContextManager().getActiveRelationProviders()) {
-			assertTrue(provider.isEnabled());
-		}
-		assertEquals(0, view.getViewer().getTree().getItemCount());
-
-		IWorkbenchPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
-		IMethod m1 = type1.createMethod("void m1() {\n m1(); \n}", null, true, null);
-		StructuredSelection sm1 = new StructuredSelection(m1);
-		monitor.selectionChanged(part, sm1);
-		IMylarElement node = manager.handleInteractionEvent(mockInterestContribution(m1.getHandleIdentifier(), scaling
-				.getLandmark()));
-
-		// force an edge on so that it shows up in the view
-		// ((MylarContextElement)((CompositeContextElement)node).getNodes().iterator().next()).addEdge(new
-		// MylarContextRelation("kind", "edgeKind", node, node, context));
-
-		assertEquals(1, MylarPlugin.getContextManager().getActiveLandmarks().size());
-
-		assertEquals(1, search(2, node).size());
-
-		List<TreeItem> collectedItems = new ArrayList<TreeItem>();
-		UiTestUtil.collectTreeItemsInView(view.getViewer().getTree().getItems(), collectedItems);
-
-		// just make sure that the view didn't blow up.
-		assertEquals(1, collectedItems.size());
-		monitor.selectionChanged(part, sm1);
-		manager.handleInteractionEvent(mockInterestContribution(m1.getHandleIdentifier(), -scaling.getLandmark()));
-	}
-
-	public void testSearchNotRunIfViewDeactivated() throws PartInitException, JavaModelException {
-		view = (ActiveSearchView) JavaPlugin.getActivePage().showView(ActiveSearchView.ID);
-		for (AbstractRelationProvider provider : MylarPlugin.getContextManager().getActiveRelationProviders()) {
-			assertTrue(provider.getCurrentDegreeOfSeparation() > 0);
-		}
-		JavaPlugin.getActivePage().showView("org.eclipse.ui.views.ProblemView"); 
-
-		Perspective perspective = ((WorkbenchPage) JavaPlugin.getActivePage()).getActivePerspective();
-		IViewReference reference = JavaPlugin.getActivePage().findViewReference(ActiveSearchView.ID);
-		assertNotNull(reference);
-//		assertTrue(perspective.canCloseView(view));
-		assertTrue(perspective.hideView(reference));
-
-		for (AbstractRelationProvider provider : MylarPlugin.getContextManager().getActiveRelationProviders()) {
-			assertFalse(provider.isEnabled());
-		}
-
-		JavaPlugin.getActivePage().showView(ActiveSearchView.ID);
-		for (AbstractRelationProvider provider : MylarPlugin.getContextManager().getActiveRelationProviders()) {
-			assertTrue(provider.isEnabled());
-		}
-	}
-
-	public void testSearchAfterDeletion() throws JavaModelException, PartInitException, IOException, CoreException {
-		view = (ActiveSearchView) JavaPlugin.getActivePage().showView(ActiveSearchView.ID);
-		if (view != null) {
-			assertEquals(0, view.getViewer().getTree().getItemCount());
-
-			IWorkbenchPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
-			IMethod m1 = type1.createMethod("void m1() {\n m2() \n}", null, true, null);
-			IMethod m2 = type1.createMethod("void m2() { }", null, true, null);
-			StructuredSelection sm2 = new StructuredSelection(m2);
-			monitor.selectionChanged(part, sm2);
-			IMylarElement node = manager.handleInteractionEvent(mockInterestContribution(m2.getHandleIdentifier(),
-					scaling.getLandmark()));
-			assertEquals(1, MylarPlugin.getContextManager().getActiveLandmarks().size());
-
-			assertEquals(1, search(2, node).size());
-
-			m1.delete(true, null);
-			assertFalse(m1.exists());
-
-			assertEquals(0, search(2, node).size());
-		}
-	}
-
-	public List<?> search(int dos, IMylarElement node) {
-		if (node == null) {
-			fail("null element");
-		}
-
-		JavaReferencesProvider prov = new JavaReferencesProvider();
-
-		TestActiveSearchListener l = new TestActiveSearchListener(prov);
-		IMylarSearchOperation o = prov.getSearchOperation(node, IJavaSearchConstants.REFERENCES, dos);
-		if (o == null)
-			return null;
-
-		SearchPluginTestHelper.search(o, l);
-		return l.getResults();
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/AllJavaTests.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/AllJavaTests.java
deleted file mode 100644
index c8dea2e..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/AllJavaTests.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-
-import org.eclipse.mylar.ide.tests.ChangeSetManagerTest;
-import org.eclipse.mylar.ide.tests.CommitMessageTest;
-import org.eclipse.mylar.internal.ide.MylarIdePlugin;
-import org.eclipse.mylar.java.tests.search.JUnitReferencesSearchPluginTest;
-import org.eclipse.mylar.java.tests.search.JavaImplementorsSearchPluginTest;
-import org.eclipse.mylar.java.tests.search.JavaReadAccessSearchPluginTest;
-import org.eclipse.mylar.java.tests.search.JavaReferencesSearchTest;
-import org.eclipse.mylar.java.tests.search.JavaWriteAccessSearchPluginTest;
-
-/**
- * @author Mik Kersten
- */
-public class AllJavaTests {
-
-	public static Test suite() {
-		TestSuite suite = new TestSuite("Tests for org.eclipse.mylar.java.tests");
-
-		// $JUnit-BEGIN$
-		suite.addTestSuite(ResourceStructureMappingTest.class);
-		suite.addTestSuite(CommitMessageTest.class);
-		suite.addTestSuite(InterestManipulationTest.class);
-		suite.addTestSuite(ChangeSetManagerTest.class);
-		suite.addTestSuite(EditorManagerTest.class);
-		suite.addTestSuite(RefactoringTest.class);
-		suite.addTestSuite(ContentOutlineRefreshTest.class);
-		suite.addTestSuite(TypeHistoryManagerTest.class);
-		suite.addTestSuite(PackageExplorerRefreshTest.class);
-		suite.addTestSuite(ActiveHierarchyTest.class);
-		suite.addTestSuite(ActiveSearchTest.class);
-		suite.addTestSuite(ProblemsListTest.class);
-		suite.addTestSuite(InterestFilterTest.class);
-		suite.addTestSuite(ContextManagerTest.class);
-		suite.addTestSuite(JavaStructureTest.class);
-		suite.addTestSuite(JavaImplementorsSearchPluginTest.class);
-		suite.addTestSuite(JavaReadAccessSearchPluginTest.class);
-		suite.addTestSuite(JavaReferencesSearchTest.class);
-		suite.addTestSuite(JavaWriteAccessSearchPluginTest.class);
-		suite.addTestSuite(JUnitReferencesSearchPluginTest.class);
-		// $JUnit-END$
-
-		MylarIdePlugin.getDefault().setResourceMonitoringEnabled(true);
-		return suite;
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ApplyMylarActionTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ApplyMylarActionTest.java
deleted file mode 100644
index 79d62ec..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ApplyMylarActionTest.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.ui.JavaUI;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.jface.viewers.StructuredViewer;
-import org.eclipse.jface.viewers.TreeViewer;
-import org.eclipse.mylar.core.tests.UiTestUtil;
-import org.eclipse.mylar.internal.java.MylarJavaPlugin;
-import org.eclipse.mylar.internal.ui.actions.ApplyMylarToOutlineAction;
-import org.eclipse.mylar.provisional.ui.IMylarUiBridge;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-import org.eclipse.ui.IEditorPart;
-import org.eclipse.ui.IViewPart;
-import org.eclipse.ui.PartInitException;
-import org.eclipse.ui.PlatformUI;
-
-/**
- * @author Mik Kersten
- */
-public class ApplyMylarActionTest extends AbstractJavaContextTest {
-
-	private IViewPart view;
-
-	private ApplyMylarToOutlineAction action;
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-		view = openView(ApplyMylarToOutlineAction.ID_CONTENT_OUTLINE);
-		assertNotNull(view);
-		assertNotNull(MylarUiPlugin.getDefault());
-		assertNotNull(MylarJavaPlugin.getDefault());
-		action = new ApplyMylarToOutlineAction();
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		super.tearDown();
-	}
-	
-	@SuppressWarnings("deprecation")
-	public void testContents() throws JavaModelException, PartInitException {
-		IMethod m1 = type1.createMethod("void m1() { }", null, true, null);
-		openView("org.eclipse.ui.views.ContentOutline");
-		JavaUI.openInEditor(m1);
-
-//		ApplyMylarToOutlineAction.getDefault().update(true);
-		List<StructuredViewer> viewers = new ArrayList<StructuredViewer>();
-		IEditorPart[] parts = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getEditors();
-		for (int i = 0; i < parts.length; i++) {
-			if (parts[i].getTitle().equals("Type1.java")) {
-				IMylarUiBridge bridge = MylarUiPlugin.getDefault().getUiBridgeForEditor(parts[i]);
-				List<TreeViewer> outlineViewers = bridge.getContentOutlineViewers(parts[i]);
-				for (TreeViewer viewer : outlineViewers) {
-					if (viewer != null && !viewers.contains(viewer))
-						viewers.add(viewer);
-				}
-			}
-		}
-		assertEquals(1, viewers.size());
-		TreeViewer viewer = (TreeViewer) viewers.get(0);
-		assertEquals(3, UiTestUtil.countItemsInTree(viewer.getTree()));
-
-		action.updateInterestFilter(true, viewer);
-		assertEquals(0, UiTestUtil.countItemsInTree(viewer.getTree()));
-
-		StructuredSelection sm1 = new StructuredSelection(m1);
-		monitor.selectionChanged(view, sm1);
-		viewer.refresh();
-		assertEquals(2, UiTestUtil.countItemsInTree(viewer.getTree()));
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ContentOutlineRefreshTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ContentOutlineRefreshTest.java
deleted file mode 100644
index 57098f1..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ContentOutlineRefreshTest.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.ui.JavaUI;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.jface.viewers.StructuredViewer;
-import org.eclipse.jface.viewers.TreeViewer;
-import org.eclipse.mylar.core.tests.UiTestUtil;
-import org.eclipse.mylar.internal.java.MylarJavaPlugin;
-import org.eclipse.mylar.internal.ui.actions.ApplyMylarToOutlineAction;
-import org.eclipse.mylar.provisional.ui.IMylarUiBridge;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-import org.eclipse.ui.IEditorPart;
-import org.eclipse.ui.IViewPart;
-import org.eclipse.ui.PartInitException;
-import org.eclipse.ui.PlatformUI;
-
-/**
- * @author Mik Kersten
- */
-public class ContentOutlineRefreshTest extends AbstractJavaContextTest {
-
-	private IViewPart view;
-
-	private ApplyMylarToOutlineAction action;
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-		view = openView(ApplyMylarToOutlineAction.ID_CONTENT_OUTLINE);
-		assertNotNull(view);
-		assertNotNull(MylarUiPlugin.getDefault());
-		assertNotNull(MylarJavaPlugin.getDefault());
-		action = new ApplyMylarToOutlineAction();
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		super.tearDown();
-	}
-	
-	@SuppressWarnings("deprecation")
-	public void testContents() throws JavaModelException, PartInitException {
-		IMethod m1 = type1.createMethod("void m1() { }", null, true, null);
-		openView("org.eclipse.ui.views.ContentOutline");
-		JavaUI.openInEditor(m1);
-
-		// ApplyMylarToOutlineAction.getDefault().update(true);
-		List<StructuredViewer> viewers = new ArrayList<StructuredViewer>();
-		IEditorPart[] parts = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getEditors();
-		for (int i = 0; i < parts.length; i++) {
-			if (parts[i].getTitle().equals("Type1.java")) {
-				IMylarUiBridge bridge = MylarUiPlugin.getDefault().getUiBridgeForEditor(parts[i]);
-				List<TreeViewer> outlineViewers = bridge.getContentOutlineViewers(parts[i]);
-				for (TreeViewer viewer : outlineViewers) {
-					if (viewer != null && !viewers.contains(viewer))
-						viewers.add(viewer);
-				}
-			}
-		}
-		assertEquals(1, viewers.size());
-		TreeViewer viewer = (TreeViewer) viewers.get(0);
-		assertEquals(3, UiTestUtil.countItemsInTree(viewer.getTree()));
-
-		action.updateInterestFilter(true, viewer);
-		assertEquals(0, UiTestUtil.countItemsInTree(viewer.getTree()));
-
-		StructuredSelection sm1 = new StructuredSelection(m1);
-		monitor.selectionChanged(view, sm1);
-		viewer.refresh();
-		assertEquals(2, UiTestUtil.countItemsInTree(viewer.getTree()));
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ContextManagerTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ContextManagerTest.java
deleted file mode 100644
index 7860f9e..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ContextManagerTest.java
+++ /dev/null
@@ -1,408 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import java.io.File;
-import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
-import java.util.List;
-
-import org.eclipse.core.resources.IMarker;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jdt.core.IJavaElement;
-import org.eclipse.jdt.core.IJavaModelMarker;
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.IPackageFragment;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.internal.core.JavaModel;
-import org.eclipse.jdt.internal.ui.JavaPlugin;
-import org.eclipse.jdt.internal.ui.packageview.PackageExplorerPart;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.mylar.internal.core.MylarContext;
-import org.eclipse.mylar.internal.core.MylarContextManager;
-import org.eclipse.mylar.internal.java.JavaProblemListener;
-import org.eclipse.mylar.internal.java.JavaStructureBridge;
-import org.eclipse.mylar.provisional.core.AbstractRelationProvider;
-import org.eclipse.mylar.provisional.core.IMylarContext;
-import org.eclipse.mylar.provisional.core.IMylarContextListener;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.IMylarStructureBridge;
-import org.eclipse.mylar.provisional.core.InteractionEvent;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.ui.IViewPart;
-import org.eclipse.ui.IWorkbenchPart;
-import org.eclipse.ui.PlatformUI;
-
-/**
- * @author Mik Kersten
- */
-public class ContextManagerTest extends AbstractJavaContextTest {
-
-	protected PackageExplorerPart explorer;
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-		explorer = PackageExplorerPart.openInActivePerspective();
-		assertNotNull(explorer);
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		super.tearDown();
-	};
-
-	class LandmarksModelListener implements IMylarContextListener {
-		public int numAdditions = 0;
-
-		public int numDeletions = 0;
-
-		public void interestChanged(IMylarElement info) {
-			// don't care about this event
-		}
-
-		public void landmarkAdded(IMylarElement element) {
-			numAdditions++;
-		}
-
-		public void landmarkRemoved(IMylarElement element) {
-			numDeletions++;
-		}
-
-		public void modelUpdated() {
-			// don't care about this event
-		}
-
-		public void edgesChanged(IMylarElement node) {
-			// don't care about this event
-		}
-
-		public void presentationSettingsChanging(UpdateKind kind) {
-			// don't care about this event
-		}
-
-		public void presentationSettingsChanged(UpdateKind kind) {
-			// don't care about this event
-		}
-
-		public void nodeDeleted(IMylarElement node) {
-			// don't care about this event
-		}
-
-		public void contextActivated(IMylarContext taskscapeActivated) {
-			// don't care about this event
-		}
-
-		public void contextDeactivated(IMylarContext taskscapeDeactivated) {
-			// don't care about this event
-		}
-
-		public void interestChanged(List<IMylarElement> elements) {
-			// ignore
-			
-		}
-	}
-
-	public void testHandleToPathConversion() throws IOException {
-		String handle = "https://bugs.eclipse.org/bugs" + MylarContextManager.CONTEXT_HANDLE_DELIM + "123";
-		File file = manager.getFileForContext(handle);
-		assertFalse(file.exists());
-		file.createNewFile();
-		assertTrue(file.exists());
-	}
-
-	public void testPauseAndResume() throws JavaModelException {
-		MylarPlugin.getContextManager().setContextCapturePaused(true);
-		MylarPlugin.getContextManager().handleInteractionEvent(mockInterestContribution("paused", 3));
-		IMylarElement paused = MylarPlugin.getContextManager().getElement("paused");
-		assertFalse(paused.getInterest().isInteresting());
-
-		MylarPlugin.getContextManager().setContextCapturePaused(false);
-		MylarPlugin.getContextManager().handleInteractionEvent(mockInterestContribution("paused", 3));
-		IMylarElement resumed = MylarPlugin.getContextManager().getElement("paused");
-		assertTrue(resumed.getInterest().isInteresting());
-	}
-
-	public void testShellLifecycleActivityStart() {
-		List<InteractionEvent> events = manager.getActivityHistoryMetaContext().getInteractionHistory();
-		assertEquals(MylarContextManager.ACTIVITY_DELTA_STARTED, events.get(0).getDelta());
-		assertEquals(MylarContextManager.ACTIVITY_DELTA_ACTIVATED, events.get(1).getDelta());
-	}
-	
-	public void testActivityHistory() {
-		manager.resetActivityHistory();
-		MylarContext history = manager.getActivityHistoryMetaContext();
-		assertNotNull(history);
-		assertEquals(0, manager.getActivityHistoryMetaContext().getInteractionHistory().size());
-
-		manager.activateContext(manager.loadContext("1"));
-		assertEquals(1, manager.getActivityHistoryMetaContext().getInteractionHistory().size());
-
-		manager.deactivateContext("2");
-		assertEquals(2, manager.getActivityHistoryMetaContext().getInteractionHistory().size());
-	}
-
-	public void testChangeHandle() {
-		MylarPlugin.getContextManager().handleInteractionEvent(mockInterestContribution("old", 3));
-		IMylarElement old = MylarPlugin.getContextManager().getElement("old");
-		assertTrue(old.getInterest().isInteresting());
-
-		MylarPlugin.getContextManager().getActiveContext().updateElementHandle(old, "new");
-		IMylarElement changed = MylarPlugin.getContextManager().getElement("new");
-		assertTrue(changed.getInterest().isInteresting());
-	}
-
-	public void testHasContext() {
-		manager.getFileForContext("1").delete();
-		assertFalse(manager.getFileForContext("1").exists());
-		assertFalse(manager.hasContext("1"));
-		manager.activateContext(manager.loadContext("1"));
-		assertTrue(manager.isContextActive());
-
-		manager.deactivateContext("1");
-		assertFalse(manager.hasContext("1"));
-
-		manager.activateContext(manager.loadContext("1"));
-		manager.handleInteractionEvent(mockSelection());
-		manager.deactivateContext("1");
-		assertTrue(manager.hasContext("1"));
-		manager.getFileForContext("1").delete();
-	}
-
-	public void testEdgeReset() throws CoreException, InterruptedException, InvocationTargetException {
-		IWorkbenchPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
-		IMethod m1 = type1.createMethod("public void m1() { }", null, true, null);
-		IPackageFragment p2 = project.createPackage("p2");
-
-		IType type2 = project.createType(p2, "Type2.java", "public class Type2 { }");
-		IMethod m2 = type2.createMethod("void m2() { }", null, true, null);
-
-		assertTrue(m1.exists());
-		assertEquals(1, type1.getMethods().length);
-
-		monitor.selectionChanged(part, new StructuredSelection(m1));
-		IMylarElement m1Node = MylarPlugin.getContextManager().getElement(m1.getHandleIdentifier());
-		assertTrue(m1Node.getInterest().isInteresting());
-		monitor.selectionChanged(part, new StructuredSelection(m2));
-		IMylarElement m2Node = MylarPlugin.getContextManager().getElement(m2.getHandleIdentifier());
-		manager.handleInteractionEvent(mockInterestContribution(m2.getHandleIdentifier(), scaling.getLandmark()));
-		assertTrue(m2Node.getInterest().isLandmark());
-
-		AbstractRelationProvider provider = new JavaStructureBridge().getRelationshipProviders().get(0);
-		provider.createEdge(m2Node, m1Node.getContentType(), m2.getHandleIdentifier());
-
-		assertEquals(1, m2Node.getRelations().size());
-
-		manager.resetLandmarkRelationshipsOfKind(provider.getId());
-
-		assertEquals(0, m2Node.getRelations().size());
-	}
-
-	public void testPredictedInterest() {
-		IMylarElement node = MylarPlugin.getContextManager().getElement("doesn't exist");
-		assertFalse(node.getInterest().isInteresting());
-		assertFalse(node.getInterest().isPropagated());
-	}
-
-	public void testErrorInterest() throws CoreException, InterruptedException, InvocationTargetException {
-		JavaPlugin.getDefault().getProblemMarkerManager().addListener(new JavaProblemListener());
-
-		IViewPart problemsPart = JavaPlugin.getActivePage().showView("org.eclipse.ui.views.ProblemView");
-		assertNotNull(problemsPart);
-
-		IWorkbenchPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
-		IMethod m1 = type1.createMethod("public void m1() { }", null, true, null);
-		IPackageFragment p2 = project.createPackage("p2");
-
-		IType type2 = project.createType(p2, "Type2.java", "public class Type2 { }");
-		IMethod m2 = type2.createMethod("void m2() { new p1.Type1().m1(); }", null, true, null);
-
-		assertTrue(m1.exists());
-		assertEquals(1, type1.getMethods().length);
-
-		monitor.selectionChanged(part, new StructuredSelection(m1));
-		IMylarElement m1Node = MylarPlugin.getContextManager().getElement(m1.getHandleIdentifier());
-		assertTrue(m1Node.getInterest().isInteresting());
-
-		// delete method to cause error
-		m1.delete(true, null);
-		assertEquals(0, type1.getMethods().length);
-		project.build();
-
-		IMarker[] markers = type2.getResource().findMarkers(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER, false,
-				IResource.DEPTH_INFINITE);
-		assertEquals(1, markers.length);
-
-		String resourceHandle = new JavaStructureBridge().getHandleIdentifier(m2.getCompilationUnit());
-		assertTrue(MylarPlugin.getContextManager().getElement(resourceHandle).getInterest().isInteresting());
-
-		// put it back
-		type1.createMethod("public void m1() { }", null, true, null);
-
-		// XXX: put this back, but it needs to wait on the resource marker
-		// update somehow
-		// project.build();
-		// project.build(); // HACK
-		// project.build(); // HACK
-		// assertFalse(MylarPlugin.getContextManager().getElement(resourceHandle).getInterest().isInteresting());
-	}
-
-	public void testParentInterestAfterDecay() throws JavaModelException {
-		IWorkbenchPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
-		IMethod m1 = type1.createMethod("void m1() { }", null, true, null);
-		StructuredSelection sm1 = new StructuredSelection(m1);
-		monitor.selectionChanged(part, sm1);
-
-		IMylarElement node = MylarPlugin.getContextManager().getElement(m1.getHandleIdentifier());
-		assertTrue(node.getInterest().isInteresting());
-		IMylarStructureBridge bridge = MylarPlugin.getDefault().getStructureBridge(node.getContentType());
-		IMylarElement parent = MylarPlugin.getContextManager().getElement(
-				bridge.getParentHandle(node.getHandleIdentifier()));
-		assertTrue(parent.getInterest().isInteresting());
-		assertTrue(parent.getInterest().isPropagated());
-
-		for (int i = 0; i < 1 / (scaling.getDecay().getValue()) * 3; i++) {
-			MylarPlugin.getContextManager().handleInteractionEvent(mockSelection());
-		}
-
-		assertFalse(MylarPlugin.getContextManager().getElement(m1.getHandleIdentifier()).getInterest().isInteresting());
-		MylarPlugin.getContextManager().handleInteractionEvent(mockSelection(m1.getHandleIdentifier()));
-		assertTrue(MylarPlugin.getContextManager().getElement(m1.getHandleIdentifier()).getInterest().isInteresting());
-	}
-
-	public void testPropagation() throws JavaModelException, Exception {
-		IMethod m1 = type1.createMethod("void m1() { }", null, true, null);
-		IMylarElement node = MylarPlugin.getContextManager().getElement(m1.getHandleIdentifier());
-		assertFalse(node.getInterest().isInteresting());
-
-		InteractionEvent event = new InteractionEvent(InteractionEvent.Kind.MANIPULATION, new JavaStructureBridge().getContentType(), m1.getHandleIdentifier(), "source");
-		MylarPlugin.getContextManager().handleInteractionEvent(event, true);
-		
-		node = MylarPlugin.getContextManager().getElement(m1.getHandleIdentifier());
-		assertTrue(node.getInterest().isInteresting());
-
-		project.build();
-		IJavaElement parent = m1.getParent();
-		IMylarElement parentNode = MylarPlugin.getContextManager().getElement(parent.getHandleIdentifier());
-		assertFalse(parentNode.getInterest().isInteresting());
-		
-		InteractionEvent selectionEvent = new InteractionEvent(InteractionEvent.Kind.SELECTION, new JavaStructureBridge().getContentType(), m1.getHandleIdentifier(), "source");
-		MylarPlugin.getContextManager().handleInteractionEvent(selectionEvent, true);
-		parentNode = MylarPlugin.getContextManager().getElement(parent.getHandleIdentifier());
-		assertTrue(parentNode.getInterest().isInteresting()); 
-	}
-	
-	public void testIncremenOfParentDoi() throws JavaModelException, Exception {
-		IWorkbenchPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
-		IMethod m1 = type1.createMethod("void m1() { }", null, true, null);
-		IMylarElement node = MylarPlugin.getContextManager().getElement(m1.getHandleIdentifier());
-		assertFalse(node.getInterest().isInteresting());
-
-		StructuredSelection sm1 = new StructuredSelection(m1);
-		monitor.selectionChanged(part, sm1);
-		node = MylarPlugin.getContextManager().getElement(m1.getHandleIdentifier());
-		assertTrue(node.getInterest().isInteresting());
-
-		project.build();
-		IJavaElement parent = m1.getParent();
-		int level = 1;
-		do {
-			level++;
-			IMylarElement parentNode = MylarPlugin.getContextManager().getElement(parent.getHandleIdentifier());
-			if (!(parent instanceof JavaModel)) {
-				assertEquals("failed on: " + parent.getClass(), node.getInterest().getValue(), parentNode.getInterest()
-						.getValue());
-			}
-			parent = parent.getParent();
-		} while (parent != null);
-	}
-
-	public void testIncremenOfParentDoiAfterForcedDecay() throws JavaModelException, Exception {
-		IWorkbenchPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
-		IMethod m1 = type1.createMethod("void m1() { }", null, true, null);
-		IMethod m2 = type1.createMethod("void m2() { }", null, true, null);
-		IMylarElement node = MylarPlugin.getContextManager().getElement(m1.getHandleIdentifier());
-		assertFalse(node.getInterest().isInteresting());
-
-		monitor.selectionChanged(part, new StructuredSelection(m1));
-		node = MylarPlugin.getContextManager().getElement(m1.getHandleIdentifier());
-		assertTrue(node.getInterest().isInteresting());
-
-		// make all the parents interest propated to have negative interest
-		IJavaElement parent = m1.getParent();
-		int level = 1;
-		do {
-			level++;
-			IMylarElement parentNode = MylarPlugin.getContextManager().getElement(parent.getHandleIdentifier());
-			if (!(parent instanceof JavaModel)) {
-				assertTrue(parentNode.getInterest().isInteresting());
-				MylarPlugin.getContextManager().handleInteractionEvent(mockInterestContribution(parentNode.getHandleIdentifier(), 
-						-2*parentNode.getInterest().getValue()));
-				IMylarElement updatedParent = MylarPlugin.getContextManager().getElement(parent.getHandleIdentifier());
-				assertFalse(updatedParent.getInterest().isInteresting());
-			}
-			parent = parent.getParent();
-		} while (parent != null);
-		
-//		assertFalse(node.getInterest().isInteresting());
-		
-		// select the element, should propagate up
-		monitor.selectionChanged(part, new StructuredSelection(m2));
-		monitor.selectionChanged(part, new StructuredSelection(m1));
-		node = MylarPlugin.getContextManager().getElement(m1.getHandleIdentifier());
-		assertTrue(node.getInterest().isInteresting());
-		
-		project.build();
-		parent = m1.getParent();
-		level = 1;
-		do {
-			level++;
-			IMylarElement parentNode = MylarPlugin.getContextManager().getElement(parent.getHandleIdentifier());
-			if (!(parent instanceof JavaModel)) {
-				assertTrue(parentNode.getInterest().isInteresting());
-//				assertEquals("failed on: " + parent.getClass(), node.getInterest().getValue(), parentNode.getInterest()
-//						.getValue());
-			}
-			parent = parent.getParent();
-		} while (parent != null);
-	}
-	
-	public void testLandmarks() throws CoreException, IOException {
-		LandmarksModelListener listener = new LandmarksModelListener();
-		manager.addListener(listener);
-
-		IWorkbenchPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
-		IMethod m1 = type1.createMethod("void m1() { }", null, true, null);
-
-		StructuredSelection sm1 = new StructuredSelection(m1);
-		monitor.selectionChanged(part, sm1);
-		manager.handleInteractionEvent(mockInterestContribution(m1.getHandleIdentifier(), scaling.getLandmark()));
-		// packages can't be landmarks
-		manager.handleInteractionEvent(mockInterestContribution(m1.getCompilationUnit().getParent()
-				.getHandleIdentifier(), scaling.getLandmark()));
-		// source folders can't be landmarks
-		manager.handleInteractionEvent(mockInterestContribution(m1.getCompilationUnit().getParent().getParent()
-				.getHandleIdentifier(), scaling.getLandmark()));
-		// projects can't be landmarks
-		manager.handleInteractionEvent(mockInterestContribution(m1.getCompilationUnit().getParent().getParent()
-				.getParent().getHandleIdentifier(), scaling.getLandmark()));
-
-		assertEquals(1, MylarPlugin.getContextManager().getActiveLandmarks().size());
-		assertEquals(1, listener.numAdditions);
-
-		manager.handleInteractionEvent(mockInterestContribution(m1.getHandleIdentifier(), -scaling.getLandmark()));
-		assertEquals(1, listener.numDeletions);
-	}
-
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/EditorManagerTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/EditorManagerTest.java
deleted file mode 100644
index 7decc7d..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/EditorManagerTest.java
+++ /dev/null
@@ -1,253 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.internal.ui.packageview.PackageExplorerPart;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.mylar.internal.core.MylarContextManager;
-import org.eclipse.mylar.internal.ide.MylarIdePlugin;
-import org.eclipse.mylar.internal.java.ActiveFoldingEditorTracker;
-import org.eclipse.mylar.internal.java.JavaStructureBridge;
-import org.eclipse.mylar.internal.java.MylarJavaPlugin;
-import org.eclipse.mylar.internal.tasklist.ui.TaskUiUtil;
-import org.eclipse.mylar.internal.ui.MylarUiPrefContstants;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.IMylarStructureBridge;
-import org.eclipse.mylar.provisional.core.InteractionEvent;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.mylar.provisional.tasklist.ITask;
-import org.eclipse.mylar.provisional.tasklist.Task;
-import org.eclipse.mylar.provisional.ui.IMylarUiBridge;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-import org.eclipse.ui.IViewPart;
-import org.eclipse.ui.IWorkbenchPage;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.ui.ide.IDE;
-
-/**
- * @author Mik Kersten
- */
-public class EditorManagerTest extends AbstractJavaContextTest {
-
-	private IWorkbenchPage page;
-
-	private IViewPart view;
-
-	@SuppressWarnings("deprecation")
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-		page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
-		assertNotNull(page);
-		view = PackageExplorerPart.openInActivePerspective();
-		assertNotNull(view);
-		assertTrue(MylarUiPlugin.getPrefs().getBoolean(MylarUiPrefContstants.AUTO_MANAGE_EDITORS));
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		super.tearDown();
-		MylarIdePlugin.getDefault().getEditorManager().closeAllEditors();
-	}
-
-	public void testInterestCapturedForResourceOnFocus() throws CoreException, InvocationTargetException,
-			InterruptedException {
-		MylarPlugin.getContextManager().setContextCapturePaused(true);
-
-		IType typeA = project.createType(p1, "TypeA.java", "public class TypeA{ }");
-		IType typeB = project.createType(p1, "TypeB.java", "public class TypeB{ }");
-				
-		IFile fileA = (IFile)typeA.getAdapter(IResource.class);
-		IFile fileB = (IFile)typeB.getAdapter(IResource.class);
-		
-		IMylarStructureBridge structureBridge = MylarPlugin.getDefault().getStructureBridge(fileA);
-		
-		IMylarElement elementA = MylarPlugin.getContextManager().getElement(structureBridge.getHandleIdentifier(fileA));
-		IMylarElement elementB = MylarPlugin.getContextManager().getElement(structureBridge.getHandleIdentifier(fileB));
-		
-		assertFalse(elementA.getInterest().isInteresting());
-		assertFalse(elementB.getInterest().isInteresting());
-		MylarPlugin.getContextManager().setContextCapturePaused(false);
-
-		IDE.openEditor(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(), fileA, true);
-		elementA = MylarPlugin.getContextManager().getElement(structureBridge.getHandleIdentifier(fileA));
-		float selectionFactor = MylarContextManager.getScalingFactors().get(InteractionEvent.Kind.SELECTION).getValue();
-		float decayFactor = MylarContextManager.getScalingFactors().getDecay().getValue();
-		
-		assertEquals(selectionFactor, elementA.getInterest().getValue());
-		IDE.openEditor(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(), fileB, true);
-		IDE.openEditor(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(), fileA, true);
-		elementA = MylarPlugin.getContextManager().getElement(structureBridge.getHandleIdentifier(fileA));
-		assertEquals(selectionFactor*2-decayFactor*2, elementA.getInterest().getValue());
-	}
-
-	public void testWaitingListenersDoNotLeakOnEditorActivation() throws JavaModelException {
-		manager.deleteContext(contextId);
-		MylarIdePlugin.getDefault().getEditorManager().closeAllEditors();
-
-		int initialNumListeners = manager.getListeners().size();
-		manager.activateContext(contextId);
-		assertEquals(initialNumListeners, manager.getListeners().size());
-
-		IType typeA = project.createType(p1, "TypeA.java", "public class TypeA{ }");
-		monitor.selectionChanged(view, new StructuredSelection(typeA));
-		manager.deactivateContext(contextId);
-		assertEquals(initialNumListeners, manager.getListeners().size());
-
-		manager.activateContext(contextId);
-		assertEquals(initialNumListeners + 1, manager.getListeners().size());
-		manager.deactivateContext(contextId);
-		assertEquals(initialNumListeners, manager.getListeners().size());
-
-		manager.activateContext(contextId);
-		manager.deactivateContext(contextId);
-		assertEquals(initialNumListeners, manager.getListeners().size());
-
-		manager.activateContext(contextId);
-		manager.deactivateContext(contextId);
-		assertEquals(initialNumListeners, manager.getListeners().size());
-	}
-
-	public void testEditorTrackerListenerRegistration() throws JavaModelException {
-		MylarIdePlugin.getDefault().getEditorManager().closeAllEditors();
-
-		ActiveFoldingEditorTracker tracker = MylarJavaPlugin.getDefault().getEditorTracker();
-		assertTrue(tracker.getEditorListenerMap().isEmpty());
-
-		IMylarUiBridge bridge = MylarUiPlugin.getDefault().getUiBridge(JavaStructureBridge.CONTENT_TYPE);
-		IMethod m1 = type1.createMethod("void m111() { }", null, true, null);
-		monitor.selectionChanged(view, new StructuredSelection(m1));
-
-		int numListeners = MylarPlugin.getContextManager().getListeners().size();
-		IMylarElement element = MylarPlugin.getContextManager().getElement(type1.getHandleIdentifier());
-		bridge.open(element);
-
-		assertEquals(numListeners + 1, MylarPlugin.getContextManager().getListeners().size());
-		assertEquals(1, page.getEditorReferences().length);
-		assertEquals(1, tracker.getEditorListenerMap().size());
-		MylarIdePlugin.getDefault().getEditorManager().closeAllEditors();
-
-		assertEquals(numListeners, MylarPlugin.getContextManager().getListeners().size());
-		assertEquals(0, page.getEditorReferences().length);
-		assertEquals(0, tracker.getEditorListenerMap().size());
-	}
-
-	@SuppressWarnings("deprecation")
-	public void testActivationPreservesActiveTaskEditor() throws JavaModelException, InvocationTargetException,
-			InterruptedException {
-		assertEquals(0, page.getEditorReferences().length);
-		ITask task = new Task(contextId, contextId, true);
-		TaskUiUtil.openEditor(task, false, false);
-		assertEquals(1, page.getEditorReferences().length);
-		manager.activateContext(contextId);
-		assertEquals(1, page.getEditorReferences().length);
-	}
-
-	@SuppressWarnings("deprecation")
-	public void testAutoCloseWithDecay() throws JavaModelException, InvocationTargetException, InterruptedException {
-		MylarIdePlugin.getDefault().getEditorManager().closeAllEditors();
-		assertEquals(0, page.getEditors().length);
-		IMylarUiBridge bridge = MylarUiPlugin.getDefault().getUiBridge(JavaStructureBridge.CONTENT_TYPE);
-		IMethod m1 = type1.createMethod("void m111() { }", null, true, null);
-		monitor.selectionChanged(view, new StructuredSelection(m1));
-		IMylarElement element = MylarPlugin.getContextManager().getElement(type1.getHandleIdentifier());
-		bridge.open(element);
-
-		IType typeA = project.createType(p1, "TypeA.java", "public class TypeA{ }");
-		monitor.selectionChanged(view, new StructuredSelection(typeA));
-		IMylarElement elementA = MylarPlugin.getContextManager().getElement(typeA.getHandleIdentifier());
-		bridge.open(elementA);
-
-		assertEquals(2, page.getEditors().length);
-		for (int i = 0; i < 1 / (scaling.getDecay().getValue()) * 3; i++) {
-			MylarPlugin.getContextManager().handleInteractionEvent(mockSelection());
-		}
-		assertFalse(element.getInterest().isInteresting());
-		assertFalse(elementA.getInterest().isInteresting());
-		IType typeB = project.createType(p1, "TypeB.java", "public class TypeB{ }");
-		monitor.selectionChanged(view, new StructuredSelection(typeB));
-		IMylarElement elementB = MylarPlugin.getContextManager().getElement(typeB.getHandleIdentifier());
-		bridge.open(elementB);
-		monitor.selectionChanged(view, new StructuredSelection(typeB));
-		assertEquals(1, page.getEditors().length);
-	}
-
-	@SuppressWarnings("deprecation")
-	public void testAutoClose() throws JavaModelException, InvocationTargetException, InterruptedException {
-		MylarIdePlugin.getDefault().getEditorManager().closeAllEditors();
-		assertEquals(0, page.getEditors().length);
-		IMylarUiBridge bridge = MylarUiPlugin.getDefault().getUiBridge(JavaStructureBridge.CONTENT_TYPE);
-		IMethod m1 = type1.createMethod("void m111() { }", null, true, null);
-		monitor.selectionChanged(view, new StructuredSelection(m1));
-		IMylarElement element = MylarPlugin.getContextManager().getElement(type1.getHandleIdentifier());
-		bridge.open(element);
-
-		assertEquals(1, page.getEditors().length);
-		manager.deactivateContext(contextId);
-		assertEquals(0, page.getEditors().length);
-	}
-
-	@SuppressWarnings("deprecation")
-	public void testAutoOpen() throws JavaModelException, InvocationTargetException, InterruptedException {
-		manager.deleteContext(contextId);
-		MylarIdePlugin.getDefault().getEditorManager().closeAllEditors();
-		assertEquals(0, page.getEditors().length);
-
-		manager.activateContext(contextId);
-		// assertEquals(0, page.getEditors().length);
-
-		IType typeA = project.createType(p1, "TypeA.java", "public class TypeA{ }");
-		IType typeB = project.createType(p1, "TypeB.java", "public class TypeB{ }");
-		monitor.selectionChanged(view, new StructuredSelection(typeA));
-		monitor.selectionChanged(view, new StructuredSelection(typeB));
-		manager.deactivateContext(contextId);
-		assertEquals(0, page.getEditors().length);
-
-		manager.activateContext(contextId);
-		assertTrue("num editors: " + page.getEditors().length, page.getEditors().length == 2
-				|| page.getEditors().length == 3);
-	}
-
-	public void testCloseOnUninteresting() {
-		// fail();
-	}
-
-	// private int getNumActiveEditors() {
-	// return ;
-	// for (int i = 0; i < page.getEditors().length; i++) {
-	// IEditorPart editor = page.getEditors()[i];
-
-	// if (editor instanceof AbstractDecoratedTextEditor) {
-	// manager.contextDeactivated(contextId, contextId);
-	// assertEquals(0, page.getEditors().length);
-	// }
-	// }
-	// }
-
-	// assertEquals(1, page.getEditors().length);
-	// WorkspaceModifyOperation op = new WorkspaceModifyOperation() {
-	// protected void execute(IProgressMonitor monitor) throws CoreException {
-
-	// }
-	// };
-	// IProgressService service =
-	// PlatformUI.getWorkbench().getProgressService();
-	// service.run(true, true, op);
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/InterestFilterTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/InterestFilterTest.java
deleted file mode 100644
index 4431464..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/InterestFilterTest.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.internal.ui.filters.ImportDeclarationFilter;
-import org.eclipse.jdt.internal.ui.packageview.PackageExplorerPart;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.jface.viewers.ViewerFilter;
-import org.eclipse.mylar.internal.java.ui.actions.ApplyMylarToPackageExplorerAction;
-import org.eclipse.mylar.internal.ui.actions.AbstractApplyMylarAction;
-import org.eclipse.mylar.provisional.ui.InterestFilter;
-
-/**
- * @author Mik Kersten
- */
-public class InterestFilterTest extends AbstractJavaContextTest {
-
-	private InterestFilter filter;
-
-	private PackageExplorerPart explorer;
-
-	private AbstractApplyMylarAction applyAction;
-	
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-		explorer = PackageExplorerPart.openInActivePerspective();
-		assertNotNull(explorer);
-		applyAction = AbstractApplyMylarAction.getActionForPart(explorer);		
-		assertTrue(applyAction instanceof ApplyMylarToPackageExplorerAction);
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		super.tearDown();
-	}
-
-	public void testPreservedFilterRemovalExclusion() throws JavaModelException {
-		List<Class> filterClasses = new ArrayList<Class>();
-		for (ViewerFilter filter : Arrays.asList(explorer.getTreeViewer().getFilters())) {
-			filterClasses.add(filter.getClass());
-		}
-		assertTrue(filterClasses.contains(ImportDeclarationFilter.class));
-
-		applyAction.update(true);
-		filterClasses = new ArrayList<Class>();
-		for (ViewerFilter filter : Arrays.asList(explorer.getTreeViewer().getFilters())) {
-			filterClasses.add(filter.getClass());
-		} 
-		assertTrue(filterClasses.contains(ImportDeclarationFilter.class));
-	}
-	
-	public void testFilterRemovalAndRestore() throws JavaModelException {
-
-		ViewerFilter[] previousFilters = explorer.getTreeViewer().getFilters();
-		assertTrue(previousFilters.length > 1);
-		applyAction.update(true);
-		ViewerFilter[] afterInstall = explorer.getTreeViewer().getFilters();
-		// more than 1 since we preserve some filters
-		assertEquals(3, afterInstall.length);
-		
-		applyAction.update(false);
-		ViewerFilter[] restoredFilters = explorer.getTreeViewer().getFilters();
-		assertEquals(previousFilters.length, restoredFilters.length);
-	}
-	
-	public void testInterestFilter() throws JavaModelException {
-
-		applyAction.update(true);
-		filter = applyAction.getInterestFilter();
-		assertNotNull(filter);
-
-		IMethod m1 = type1.createMethod("public void m10() { }", null, true, null);
-
-		assertFalse(filter.select(explorer.getTreeViewer(), null, type1));
-		monitor.selectionChanged(PackageExplorerPart.getFromActivePerspective(), new StructuredSelection(type1));
-		manager.activateContext(context);
-
-		monitor.selectionChanged(PackageExplorerPart.getFromActivePerspective(), new StructuredSelection(type1));
-		assertTrue(filter.select(explorer.getTreeViewer(), null, type1));
-
-		assertFalse(filter.select(explorer.getTreeViewer(), null, m1));
-
-		filter.setExcludedMatches("*1*");
-		assertTrue(filter.select(explorer.getTreeViewer(), null, m1));
-	}
-
-	
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/InterestManipulationTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/InterestManipulationTest.java
deleted file mode 100644
index 7438cff..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/InterestManipulationTest.java
+++ /dev/null
@@ -1,151 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jdt.core.ICompilationUnit;
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.IPackageFragment;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.mylar.internal.ide.ResourceInteractionMonitor;
-import org.eclipse.mylar.internal.ide.ResourceStructureBridge;
-import org.eclipse.mylar.internal.ui.actions.AbstractInterestManipulationAction;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.InteractionEvent;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.ui.IWorkbenchPart;
-import org.eclipse.ui.PlatformUI;
-
-/**
- * @author Mik Kersten
- */
-public class InterestManipulationTest extends AbstractJavaContextTest {
-
-	private IMylarElement method;
-
-	private IMylarElement clazz;
-
-	private IMylarElement cu;
-
-	private IMethod javaMethod;
-
-	private IType javaType;
-
-	private ICompilationUnit javaCu;
-
-	private IPackageFragment javaPackage;
-
-	private IWorkbenchPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-		javaMethod = type1.createMethod("void testDecrement() { }", null, true, null);
-		javaType = (IType) javaMethod.getParent();
-		javaCu = (ICompilationUnit) javaType.getParent();
-		javaPackage = (IPackageFragment) javaCu.getParent();
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		super.tearDown();
-	}
-
-	public void testDecrementAcrossBridges() throws CoreException, InvocationTargetException, InterruptedException {
-		monitor.selectionChanged(part, new StructuredSelection(javaMethod));
-		method = MylarPlugin.getContextManager().getElement(javaMethod.getHandleIdentifier());
-
-		IFile file = project.getProject().getFile("foo.txt");
-		file.create(null, true, null);
-		// IFile file = (IFile)javaCu.getAdapter(IResource.class);
-		ResourceStructureBridge bridge = new ResourceStructureBridge();
-		new ResourceInteractionMonitor().selectionChanged(part, new StructuredSelection(file));
-
-		IMylarElement fileElement = MylarPlugin.getContextManager().getElement(bridge.getHandleIdentifier(file));
-		IMylarElement projectElement = MylarPlugin.getContextManager().getElement(
-				javaCu.getJavaProject().getHandleIdentifier());
-
-		assertTrue(fileElement.getInterest().isInteresting());
-		assertTrue(method.getInterest().isInteresting());
-
-		assertTrue(MylarPlugin.getContextManager().manipulateInterestForElement(projectElement, false, false, "test"));
- 
-		assertFalse(fileElement.getInterest().isInteresting());
-		// TODO: re-enable, fails in AllTests
-		// assertFalse(method.getInterest().isInteresting());
-	}
-
-	public void testDecrementInterestOfCompilationUnit() throws JavaModelException {
-		monitor.selectionChanged(part, new StructuredSelection(javaMethod));
-		monitor.selectionChanged(part, new StructuredSelection(javaCu));
-		method = MylarPlugin.getContextManager().getElement(javaMethod.getHandleIdentifier());
-		clazz = MylarPlugin.getContextManager().getElement(javaType.getHandleIdentifier());
-		cu = MylarPlugin.getContextManager().getElement(javaCu.getHandleIdentifier());
-
-		IMylarElement packageNode = MylarPlugin.getContextManager().getElement(javaPackage.getHandleIdentifier());
-
-		assertTrue(method.getInterest().isInteresting());
-		assertTrue(clazz.getInterest().isInteresting());
-		assertTrue(cu.getInterest().isInteresting());
-
-		assertTrue(MylarPlugin.getContextManager().manipulateInterestForElement(packageNode, false, false, "test"));
-		assertFalse(packageNode.getInterest().isInteresting()); 
-		assertFalse(cu.getInterest().isInteresting());
-		assertFalse(clazz.getInterest().isInteresting());
-		assertFalse(method.getInterest().isInteresting());
-	}
-
-	public void testManipulation() throws JavaModelException {
-		InterestManipulationAction action = new InterestManipulationAction();
-
-		IWorkbenchPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
-		IMethod m1 = type1.createMethod("void m22() { }", null, true, null);
-		StructuredSelection sm1 = new StructuredSelection(m1);
-		monitor.selectionChanged(part, sm1);
-		IMylarElement node = MylarPlugin.getContextManager().getElement(m1.getHandleIdentifier());
-		assertFalse(node.getInterest().isLandmark());
-		assertNotNull(MylarPlugin.getContextManager().getActiveElement());
-		action.changeInterestForSelected(true);
-		assertTrue(node.getInterest().isLandmark());
-		action.changeInterestForSelected(true);
-
-		assertEquals((2*scaling.getLandmark()) + scaling.get(InteractionEvent.Kind.SELECTION).getValue(), node
-				.getInterest().getValue());
-
-		action.changeInterestForSelected(false);
-		assertFalse(node.getInterest().isLandmark());
-		assertTrue(node.getInterest().isInteresting());
-		action.changeInterestForSelected(false);
-		assertFalse(node.getInterest().isInteresting());
-		assertEquals(node.getInterest().getValue(), -scaling.get(InteractionEvent.Kind.SELECTION).getValue());
-		action.changeInterestForSelected(false);
-		assertEquals(node.getInterest().getValue(), -scaling.get(InteractionEvent.Kind.SELECTION).getValue());
-	}
-
-	class InterestManipulationAction extends AbstractInterestManipulationAction {
-
-		@Override
-		protected boolean isIncrement() {
-			return true;
-		}
-
-		public void changeInterestForSelected(boolean increment) {
-			assertTrue(MylarPlugin.getContextManager().manipulateInterestForElement(
-					MylarPlugin.getContextManager().getActiveElement(), increment, false, ""));
-		}
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/JavaStructureTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/JavaStructureTest.java
deleted file mode 100644
index 436d11b..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/JavaStructureTest.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.IPackageFragment;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitEditor;
-import org.eclipse.jdt.ui.JavaUI;
-import org.eclipse.jface.text.Document;
-import org.eclipse.jface.text.TextSelection;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.mylar.ide.tests.ResourceTestUtil;
-import org.eclipse.mylar.internal.core.MylarContext;
-import org.eclipse.mylar.internal.core.MylarContextManager;
-import org.eclipse.mylar.internal.core.ScalingFactors;
-import org.eclipse.mylar.internal.java.JavaEditingMonitor;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.ui.IWorkbenchPart;
-import org.eclipse.ui.PartInitException;
-import org.eclipse.ui.PlatformUI;
-
-/**
- * @author Mik Kersten
- */
-public class JavaStructureTest extends AbstractJavaContextTest {
-
-	private MylarContextManager manager = MylarPlugin.getContextManager();
-
-	private JavaEditingMonitor monitor = new JavaEditingMonitor();
-
-	private IWorkbenchPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
-
-	private TestJavaProject project;
-
-	private IPackageFragment pkg;
-
-	private IType typeFoo;
-
-	private IMethod caller;
-
-	private IMethod callee;
-
-	private MylarContext taskscape;
-
-	private ScalingFactors scaling = new ScalingFactors();
-
-	@Override
-	protected void setUp() throws Exception {
-		project = new TestJavaProject(this.getClass().getName());
-		pkg = project.createPackage("pkg1");
-		typeFoo = project.createType(pkg, "Foo.java", "public class Foo { }");
-		caller = typeFoo.createMethod("void caller() { callee(); }", null, true, null);
-		callee = typeFoo.createMethod("void callee() { }", callee, true, null);
-
-		taskscape = new MylarContext("12312", scaling);
-		manager.activateContext(taskscape);
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		manager.removeAllListeners();
-		manager.deactivateContext("12312");
-		ResourceTestUtil.deleteProject(project.getProject());
-	}
-
-	public void testNavigation() throws JavaModelException, PartInitException {
-		CompilationUnitEditor editorPart = (CompilationUnitEditor) JavaUI.openInEditor(caller);
-
-		monitor.selectionChanged(part, new StructuredSelection(caller));
-
-		Document document = new Document(typeFoo.getCompilationUnit().getSource());
-
-		TextSelection callerSelection = new TextSelection(document, typeFoo.getCompilationUnit().getSource().indexOf(
-				"callee();"), "callee".length());
-		editorPart.setHighlightRange(callerSelection.getOffset(), callerSelection.getLength(), true);
-		monitor.selectionChanged(editorPart, callerSelection);
-
-		TextSelection calleeSelection = new TextSelection(document, callee.getSourceRange().getOffset(), callee
-				.getSourceRange().getLength());
-		editorPart.setHighlightRange(callerSelection.getOffset(), callerSelection.getLength(), true);
-		monitor.selectionChanged(editorPart, calleeSelection);
-
-		IMylarElement callerNode = manager.getElement(caller.getHandleIdentifier());
-		IMylarElement calleeNode = manager.getElement(callee.getHandleIdentifier());
-		assertTrue(callerNode.getInterest().isInteresting());
-		assertTrue(calleeNode.getInterest().isInteresting());
-		assertEquals(1, callerNode.getRelations().size());
-
-		TextSelection callerAgain = new TextSelection(document, typeFoo.getCompilationUnit().getSource().indexOf(
-				"callee();"), "callee".length());
-		editorPart.setHighlightRange(callerAgain.getOffset(), callerAgain.getLength(), true);
-		monitor.selectionChanged(editorPart, callerSelection);
-		assertTrue(calleeNode.getRelations().size() == 1);
-	}
-
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/PackageExplorerRefreshTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/PackageExplorerRefreshTest.java
deleted file mode 100644
index 51a0934..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/PackageExplorerRefreshTest.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.internal.ui.packageview.PackageExplorerPart;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.jface.viewers.TreeViewer;
-import org.eclipse.mylar.core.tests.UiTestUtil;
-import org.eclipse.mylar.internal.java.ui.actions.ApplyMylarToPackageExplorerAction;
-import org.eclipse.mylar.provisional.ui.MylarUiPlugin;
-
-/**
- * @author Mik Kersten
- */
-public class PackageExplorerRefreshTest extends AbstractJavaContextTest {
-
-	private PackageExplorerPart view;
-
-	private TreeViewer viewer;
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-		view = PackageExplorerPart.openInActivePerspective();
-		viewer = view.getTreeViewer();
-		MylarUiPlugin.getDefault().getViewerManager().setSyncRefreshMode(true);
-		ApplyMylarToPackageExplorerAction.getActionForPart(view).update(true);
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		super.tearDown();
-	}
-
-	public void testIsEmptyAfterDeactivation() throws JavaModelException, InterruptedException {
-		IMethod m1 = type1.createMethod("void m111() { }", null, true, null);
-		StructuredSelection sm1 = new StructuredSelection(m1);
-		monitor.selectionChanged(view, sm1);
-		viewer.expandAll();
-
-		assertTrue(UiTestUtil.countItemsInTree(viewer.getTree()) > 0);
-		assertNotNull(viewer.testFindItem(m1));
-		assertNotNull(viewer.testFindItem(m1.getParent()));
-
-		manager.deactivateContext(contextId);
-		ApplyMylarToPackageExplorerAction.getActionForPart(view).update(true);
-		assertTrue("num items: " + UiTestUtil.countItemsInTree(viewer.getTree()), UiTestUtil.countItemsInTree(viewer.getTree()) == 0);
-		ApplyMylarToPackageExplorerAction.getActionForPart(view).update();
-	}
-
-	public void testPropagation() throws JavaModelException {
-		IMethod m1 = type1.createMethod("void m111() { }", null, true, null);
-		StructuredSelection sm1 = new StructuredSelection(m1);
-		monitor.selectionChanged(view, sm1);
-		viewer.expandAll();
-
-		assertNotNull(viewer.testFindItem(m1));
-		assertNotNull(viewer.testFindItem(m1.getParent()));
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ProblemsListTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ProblemsListTest.java
deleted file mode 100644
index b54245d..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ProblemsListTest.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import java.lang.reflect.InvocationTargetException;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.eclipse.core.resources.IMarker;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jdt.core.IJavaModelMarker;
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.internal.ui.JavaPlugin;
-import org.eclipse.jface.viewers.TableViewer;
-import org.eclipse.mylar.internal.ide.ui.ProblemsListDoiSorter;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.widgets.Table;
-import org.eclipse.ui.IViewPart;
-import org.eclipse.ui.views.markers.internal.ProblemMarker;
-
-/**
- * @author Mik Kersten
- */
-public class ProblemsListTest extends AbstractJavaContextTest {
-
-	boolean done = false;
-
-	public void testInterestSorting() throws CoreException, InvocationTargetException, InterruptedException {
-		IViewPart problemsPart = JavaPlugin.getActivePage().showView("org.eclipse.ui.views.ProblemView");
-		assertNotNull(problemsPart);
-
-		IMethod m1 = type1.createMethod("void m1() { int a; }\n", null, true, null);
-		IMethod m2 = type1.createMethod("void m2() { int b; }\n", null, true, null);
-		type1.createMethod("void m3() { c; }", null, true, null);
-		project.build();
-
-		manager.handleInteractionEvent(mockInterestContribution(m1.getHandleIdentifier(), 3f));
-		manager.handleInteractionEvent(mockInterestContribution(m2.getHandleIdentifier(), 2f));
-
-		TableViewer viewer = new TableViewer(new Table(problemsPart.getViewSite().getShell(), SWT.NULL));
-		viewer.setSorter(new ProblemsListDoiSorter());
-
-		IMarker[] markers = type1.getResource().findMarkers(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER, false,
-				IResource.DEPTH_INFINITE);
-		List<ProblemMarker> problemMarkers = new ArrayList<ProblemMarker>();
-		for (int i = 0; i < markers.length; i++) {
-			ProblemMarker marker = new ProblemMarker(markers[i]);
-			problemMarkers.add(marker);
-			viewer.add(marker);
-		}
-
-		// TODO: re-enable
-		// // item 0 should be error
-		// assertEquals(problemMarkers.get(0),
-		// viewer.getTable().getItem(1).getData());
-		// viewer.refresh();
-		// manager.handleInteractionEvent(mockInterestContribution(m2.getHandleIdentifier(),
-		// 4f));
-		// for (int i = 0; i < markers.length; i++) viewer.add(new
-		// ProblemMarker(markers[i]));
-		// assertEquals(problemMarkers.get(1),
-		// viewer.getTable().getItem(1).getData());
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/RefactoringTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/RefactoringTest.java
deleted file mode 100644
index 3ca184f..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/RefactoringTest.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jdt.core.ICompilationUnit;
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.internal.ui.packageview.PackageExplorerPart;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.mylar.internal.java.InterestUpdateDeltaListener;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.ui.IViewPart;
-
-/**
- * @author Mik Kersten
- */
-public class RefactoringTest extends AbstractJavaContextTest {
-
-	private IViewPart view;
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-		view = PackageExplorerPart.openInActivePerspective();
-		InterestUpdateDeltaListener.setAsyncExecMode(false);
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		super.tearDown();
-	}
-
-	public void testDelete() throws CoreException, InvocationTargetException, InterruptedException {
-		IType type = project.createType(p1, "Refactor.java", "public class Refactor { }");
-
-		IMethod method = type.createMethod("public void deleteMe() { }", null, true, null);
-		monitor.selectionChanged(view, new StructuredSelection(method));
-		IMylarElement node = MylarPlugin.getContextManager().getElement(method.getHandleIdentifier());
-		assertTrue(node.getInterest().isInteresting());
-		project.build();
-		TestProgressMonitor monitor = new TestProgressMonitor();
-		method.delete(true, monitor);
-		if (!monitor.isDone())
-			Thread.sleep(100);
-		IMylarElement deletedNode = MylarPlugin.getContextManager().getElement(method.getHandleIdentifier());
-		assertFalse(deletedNode.getInterest().isInteresting());
-	}
-
-	/**
-	 * Limitation: only interest of compilation unit is preserved
-	 */
-	public void testTypeRename() throws CoreException, InterruptedException, InvocationTargetException {
-		IType type = project.createType(p1, "Refactor.java", "public class Refactor { }");
-		monitor.selectionChanged(view, new StructuredSelection(type));
-		monitor.selectionChanged(view, new StructuredSelection(type.getParent()));
-		project.build();
-		IMylarElement node = MylarPlugin.getContextManager().getElement(type.getHandleIdentifier());
-		IMylarElement parentNode = MylarPlugin.getContextManager().getElement(type.getParent().getHandleIdentifier());
-		assertTrue(node.getInterest().isInteresting());
-		assertTrue(parentNode.getInterest().isInteresting());
-
-		TestProgressMonitor monitor = new TestProgressMonitor();
-		type.rename("NewName", true, monitor);
-		if (!monitor.isDone())
-			Thread.sleep(200);
-		project.build();
-		ICompilationUnit unit = (ICompilationUnit) p1.getChildren()[0];
-
-		IType newType = (IType) unit.getTypes()[0];
-		IMylarElement newParentNode = MylarPlugin.getContextManager().getElement(
-				newType.getParent().getHandleIdentifier());
-		IMylarElement oldParentNode = MylarPlugin.getContextManager().getElement(parentNode.getHandleIdentifier());
-		assertFalse(oldParentNode.getInterest().isInteresting());
-		assertTrue(newParentNode.getInterest().isInteresting());
-
-		// IMylarElement newNode =
-		// MylarPlugin.getContextManager().getElement(newType.getHandleIdentifier());
-		// assertTrue(newNode.getInterest().isInteresting());
-		// IMylarElement oldNode =
-		// MylarPlugin.getContextManager().getElement(node.getHandleIdentifier());
-		// assertFalse(oldNode.getInterest().isInteresting());
-	}
-
-	public void testMethodRename() throws CoreException, InterruptedException, InvocationTargetException {
-		IType type = project.createType(p1, "Refactor.java", "public class Refactor { }");
-		IMethod method = type.createMethod("public void refactorMe() { }", null, true, null);
-
-		assertTrue(method.exists());
-		assertEquals(1, type.getMethods().length);
-
-		monitor.selectionChanged(view, new StructuredSelection(method));
-		IMylarElement node = MylarPlugin.getContextManager().getElement(method.getHandleIdentifier());
-		assertTrue(node.getInterest().isInteresting());
-
-		project.build();
-		TestProgressMonitor monitor = new TestProgressMonitor();
-		method.rename("refactored", true, monitor);
-		if (!monitor.isDone())
-			Thread.sleep(200);
-		IMethod newMethod = type.getMethods()[0];
-		assertTrue(newMethod.getElementName().equals("refactored"));
-		IMylarElement newNode = MylarPlugin.getContextManager().getElement(newMethod.getHandleIdentifier());
-		assertTrue(newNode.getInterest().isInteresting());
-
-		IMylarElement goneNode = MylarPlugin.getContextManager().getElement(node.getHandleIdentifier());
-		assertFalse(goneNode.getInterest().isInteresting());
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ResourceStructureMappingTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ResourceStructureMappingTest.java
deleted file mode 100644
index 8b25b67..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/ResourceStructureMappingTest.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.mylar.internal.ide.MylarIdePlugin;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.ui.IWorkbenchPart;
-import org.eclipse.ui.PlatformUI;
-
-/**
- * @author Mik Kersten
- */
-public class ResourceStructureMappingTest extends AbstractJavaContextTest {
-
-	public void testParentResourceMapping() throws CoreException {
-		IWorkbenchPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
-		IMethod m1 = type1.createMethod("public void m1() { }", null, true, null);
-
-		monitor.selectionChanged(part, new StructuredSelection(m1));
-		IMylarElement m1Node = MylarPlugin.getContextManager().getElement(m1.getHandleIdentifier());
-		assertTrue(m1Node.getInterest().isInteresting());
-		
-		IResource containingResource = MylarIdePlugin.getDefault().getResourceForElement(m1Node, true);
-		assertEquals(m1.getCompilationUnit().getAdapter(IResource.class), containingResource);
-	}
-	
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/TestJavaProject.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/TestJavaProject.java
deleted file mode 100644
index 0c86e10..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/TestJavaProject.java
+++ /dev/null
@@ -1,169 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-/*
- * Created on Jul 20, 2004
- */
-package org.eclipse.mylar.java.tests;
-
-import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
-import java.net.MalformedURLException;
-import java.net.URL;
-
-import org.eclipse.core.resources.IFolder;
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IProjectDescription;
-import org.eclipse.core.resources.IWorkspaceRoot;
-import org.eclipse.core.resources.IncrementalProjectBuilder;
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.FileLocator;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.core.runtime.Plugin;
-import org.eclipse.jdt.core.IClasspathEntry;
-import org.eclipse.jdt.core.ICompilationUnit;
-import org.eclipse.jdt.core.IJavaElement;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.IPackageFragment;
-import org.eclipse.jdt.core.IPackageFragmentRoot;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.core.search.IJavaSearchConstants;
-import org.eclipse.jdt.core.search.SearchEngine;
-import org.eclipse.jdt.core.search.SearchPattern;
-import org.eclipse.jdt.core.search.TypeNameRequestor;
-import org.eclipse.jdt.launching.JavaRuntime;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.ui.actions.WorkspaceModifyOperation;
-import org.eclipse.ui.progress.IProgressService;
-
-/**
- * From Erich Gamma's "Contributing to Eclipse" book.
- */
-public class TestJavaProject {
-	public IProject project;
-
-	public IJavaProject javaProject;
-
-	private IPackageFragmentRoot sourceFolder;
-
-	public TestJavaProject(final String name) throws CoreException, InvocationTargetException, InterruptedException {
-		IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
-		project = root.getProject(name);
-		project.create(null);
-		project.open(null);
-
-		javaProject = JavaCore.create(project);
-		IFolder binFolder = createBinFolder();
-		setJavaNature();
-		javaProject.setRawClasspath(new IClasspathEntry[0], null);
-		createOutputFolder(binFolder);
-		addSystemLibraries();
-	}
-
-	public IProject getProject() {
-		return project;
-	}
-
-	public IJavaProject getJavaProject() {
-		return javaProject;
-	}
-
-	public void build() throws CoreException, InvocationTargetException, InterruptedException {
-		WorkspaceModifyOperation op = new WorkspaceModifyOperation() {
-			protected void execute(IProgressMonitor monitor) throws CoreException {
-				project.build(IncrementalProjectBuilder.FULL_BUILD, null);
-			};
-		};
-		IProgressService service = PlatformUI.getWorkbench().getProgressService();
-		service.run(true, true, op);
-	}
-
-	public IPackageFragment createPackage(String name) throws CoreException {
-		if (sourceFolder == null)
-			sourceFolder = createSourceFolder();
-		return sourceFolder.createPackageFragment(name, false, null);
-	}
-
-	public IType createType(IPackageFragment pack, String cuName, String source) throws JavaModelException {
-		StringBuffer buf = new StringBuffer();
-		buf.append("package " + pack.getElementName() + ";\n");
-		buf.append("\n");
-		buf.append(source);
-		ICompilationUnit cu = pack.createCompilationUnit(cuName, buf.toString(), false, null);
-		return cu.getTypes()[0];
-	}
-
-	private IFolder createBinFolder() throws CoreException {
-		IFolder binFolder = project.getFolder("bin");
-		binFolder.create(false, true, null);
-		return binFolder;
-	}
-
-	private void setJavaNature() throws CoreException {
-		IProjectDescription description = project.getDescription();
-		description.setNatureIds(new String[] { JavaCore.NATURE_ID });
-		project.setDescription(description, null);
-	}
-
-	private void createOutputFolder(IFolder binFolder) throws JavaModelException {
-		IPath outputLocation = binFolder.getFullPath();
-		javaProject.setOutputLocation(outputLocation, null);
-	}
-
-	private IPackageFragmentRoot createSourceFolder() throws CoreException {
-		IFolder folder = project.getFolder("src");
-		folder.create(false, true, null);
-		IPackageFragmentRoot root = javaProject.getPackageFragmentRoot(folder);
-
-		IClasspathEntry[] oldEntries = javaProject.getRawClasspath();
-		IClasspathEntry[] newEntries = new IClasspathEntry[oldEntries.length + 1];
-		System.arraycopy(oldEntries, 0, newEntries, 0, oldEntries.length);
-		newEntries[oldEntries.length] = JavaCore.newSourceEntry(root.getPath());
-		javaProject.setRawClasspath(newEntries, null);
-		return root;
-	}
-
-	private void addSystemLibraries() throws JavaModelException {
-		IClasspathEntry[] oldEntries = javaProject.getRawClasspath();
-		IClasspathEntry[] newEntries = new IClasspathEntry[oldEntries.length + 1];
-		System.arraycopy(oldEntries, 0, newEntries, 0, oldEntries.length);
-		newEntries[oldEntries.length] = JavaRuntime.getDefaultJREContainerEntry();
-		javaProject.setRawClasspath(newEntries, null);
-	}
-
-	public void addJar(Plugin plugin, String jar) throws MalformedURLException, IOException, JavaModelException {
-		Path result = findFileInPlugin(plugin, jar);
-		IClasspathEntry[] oldEntries = javaProject.getRawClasspath();
-		IClasspathEntry[] newEntries = new IClasspathEntry[oldEntries.length + 1];
-		System.arraycopy(oldEntries, 0, newEntries, 0, oldEntries.length);
-		newEntries[oldEntries.length] = JavaCore.newLibraryEntry(result, null, null);
-		javaProject.setRawClasspath(newEntries, null);
-	}
-
-	private Path findFileInPlugin(Plugin plugin, String file) throws MalformedURLException, IOException {
-		// Plugin p = Platform.getPlugin(plugin);
-		URL pluginURL = plugin.getBundle().getEntry("/");
-		URL jarURL = new URL(pluginURL, file);
-		URL localJarURL = FileLocator.toFileURL(jarURL);//Platform.asLocalURL(jarURL);
-		return new Path(localJarURL.getPath());
-	}
-
-	public void waitForIndexer() throws JavaModelException {
-		new SearchEngine().searchAllTypeNames(null, null, SearchPattern.R_EXACT_MATCH, IJavaSearchConstants.CLASS,
-				SearchEngine.createJavaSearchScope(new IJavaElement[0]), new TypeNameRequestor() {
-					// nothing needs to be done here...we accept everything
-				}, IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH, null);
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/TypeHistoryManagerTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/TypeHistoryManagerTest.java
deleted file mode 100644
index 9c17645..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/TypeHistoryManagerTest.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.java.tests;
-
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.internal.corext.util.OpenTypeHistory;
-import org.eclipse.jdt.internal.ui.packageview.PackageExplorerPart;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.mylar.internal.java.MylarJavaPlugin;
-import org.eclipse.mylar.internal.java.TypeHistoryManager;
-
-/**
- * @author Mik Kersten
- */
-public class TypeHistoryManagerTest extends AbstractJavaContextTest {
-
-	private TypeHistoryManager manager;
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-		manager = MylarJavaPlugin.getDefault().getTypeHistoryManager();
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		super.tearDown();
-	}
-
-	public void testPredictedElementPopulation() throws JavaModelException {
-		manager.clearTypeHistory();
-		assertEquals(0, OpenTypeHistory.getInstance().getTypeInfos().length);
- 
-		StructuredSelection sm1 = new StructuredSelection(type1);
-		monitor.selectionChanged(PackageExplorerPart.openInActivePerspective(), sm1);
-		assertEquals(1, OpenTypeHistory.getInstance().getTypeInfos().length);
-
-		IType type2 = project.createType(p1, "Type2.java", "public class Type2 { }");
-		IMethod m1 = type2.createMethod("void m1() { }", null, true, null);
-		StructuredSelection sm2 = new StructuredSelection(m1);
-		monitor.selectionChanged(PackageExplorerPart.openInActivePerspective(), sm2);
-		assertEquals(2, OpenTypeHistory.getInstance().getTypeInfos().length);
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/ActiveSearchNotifier.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/ActiveSearchNotifier.java
deleted file mode 100644
index 6cce9f4..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/ActiveSearchNotifier.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-package org.eclipse.mylar.java.tests.search;
-
-import java.io.IOException;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.mylar.core.tests.AbstractContextTest;
-import org.eclipse.mylar.internal.core.CompositeContext;
-import org.eclipse.mylar.internal.core.MylarContext;
-import org.eclipse.mylar.internal.core.MylarContextManager;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.InteractionEvent;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-
-/**
- * @author Shawn Minto
- */
-public class ActiveSearchNotifier extends AbstractContextTest {
-
-	private CompositeContext context;
-
-	private String source;
-
-	public ActiveSearchNotifier(CompositeContext context, String source) {
-		this.context = context;
-		this.source = source;
-	}
-
-	public IMylarElement mockLowerInterest(IMylarElement node) {
-		return context.addEvent(mockUserEvent(node.getHandleIdentifier(), node.getContentType(), source, -3));
-	}
-
-	public IMylarElement mockRaiseInterest(IMylarElement node) {
-		return context.addEvent(mockUserEvent(node.getHandleIdentifier(), node.getContentType(), source, 2));
-	}
-
-	public IMylarElement mockLowerInterest(String handle, String kind) {
-		return mockLowerInterest(mockEditorSelection(handle, kind));
-	}
-
-	public IMylarElement mockRaiseInterest(String handle, String kind) {
-		return mockRaiseInterest(mockEditorSelection(handle, kind));
-	}
-
-	public IMylarElement mockEditorSelection(String handle, String kind) {
-		context.addEvent(mockSelection(handle, kind, source));
-		return context.addEvent(mockSelection(handle, kind, source));
-	}
-
-	public IMylarElement getElement(String handle, String kind) {
-		IMylarElement node = context.addEvent(mockSelection(handle, kind, source));
-		MylarPlugin.getContextManager().handleInteractionEvent(
-				mockUserEvent(handle, kind, source, (1 / MylarContextManager.getScalingFactors().getLandmark()) * -2),
-				true);
-		// context.addEvent(mockUserEvent(handle, kind, source,
-		// (1/MylarContextManager.getScalingFactors().getLandmark()) * -2));
-		return node;
-	}
-
-	public void clearContext() throws IOException, CoreException {
-		WorkspaceSetupHelper.clearDoiModel();
-		try {
-			MylarContext workspaceContext = WorkspaceSetupHelper.getContext();
-			MylarPlugin.getContextManager().activateContext(workspaceContext.getHandleIdentifier());
-			context = (CompositeContext) MylarPlugin.getContextManager().getActiveContext();
-		} catch (Exception e) {
-			fail();
-		}
-	}
-
-	private InteractionEvent mockSelection(String handle, String kind, String origin) {
-		return new InteractionEvent(InteractionEvent.Kind.SELECTION, kind, handle, origin);
-	}
-
-	private InteractionEvent mockUserEvent(String handle, String kind, String origin, float scale) {
-		InteractionEvent e = new InteractionEvent(InteractionEvent.Kind.MANIPULATION, kind, handle, origin, scale
-				* MylarContextManager.getScalingFactors().getLandmark());
-		e.getInterestContribution();
-		return e;
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/JUnitReferencesSearchPluginTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/JUnitReferencesSearchPluginTest.java
deleted file mode 100644
index d6f3d8a..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/JUnitReferencesSearchPluginTest.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-package org.eclipse.mylar.java.tests.search;
-
-import java.util.List;
-
-import junit.framework.TestCase;
-
-import org.eclipse.jdt.core.search.IJavaSearchConstants;
-import org.eclipse.mylar.core.tests.support.search.ISearchPluginTest;
-import org.eclipse.mylar.core.tests.support.search.TestActiveSearchListener;
-import org.eclipse.mylar.internal.core.search.IMylarSearchOperation;
-import org.eclipse.mylar.internal.java.search.JUnitReferencesProvider;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-
-public class JUnitReferencesSearchPluginTest extends TestCase implements ISearchPluginTest {
-
-	// TESTCASENEEDED need a project that has a method that starts with test,
-	// but doesn't extend junit.framework.TestCase
-
-	public void testJUnitReferencesSearchDOS1() {
-		// List<?> results = search(1);
-	}
-
-	//	
-	// public void testJUnitReferencesSearchDOS2(){
-	// List<?> results = search(2);
-	// }
-	//	
-	// public void testJUnitReferencesSearchDOS3(){
-	// List<?> results = search(3);
-	// }
-	//	
-	// public void testJUnitReferencesSearchDOS4(){
-	// List<?> results = search(4);
-	// }
-	//	
-	// public void testJUnitReferencesSearchDOS5(){
-	// List<?> results = search(5);
-	// }
-
-	public List<?> search(int dos, IMylarElement node) {
-
-		if (node == null)
-			return null;
-
-		// test with each of the sepatations
-		JUnitReferencesProvider prov = new JUnitReferencesProvider();
-
-		TestActiveSearchListener l = new TestActiveSearchListener(prov);
-		IMylarSearchOperation o = prov.getSearchOperation(node, IJavaSearchConstants.REFERENCES, dos);
-		SearchPluginTestHelper.search(o, l);
-		return l.getResults();
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/JavaImplementorsSearchPluginTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/JavaImplementorsSearchPluginTest.java
deleted file mode 100644
index a5b3fce..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/JavaImplementorsSearchPluginTest.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-package org.eclipse.mylar.java.tests.search;
-
-import java.util.List;
-
-import junit.framework.TestCase;
-
-import org.eclipse.jdt.core.search.IJavaSearchConstants;
-import org.eclipse.mylar.core.tests.support.search.ISearchPluginTest;
-import org.eclipse.mylar.core.tests.support.search.TestActiveSearchListener;
-import org.eclipse.mylar.internal.core.search.IMylarSearchOperation;
-import org.eclipse.mylar.internal.java.search.JavaImplementorsProvider;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-
-/*
- * TEST CASES TO HANDLE 1. all different degree of separations - with result,
- * with multiple, with none
- * 
- * DEGREE OF SEPARATIONS 1 Files of Landmarks 2 Files of Interesting 3 projects
- * of interesting elements 4 projects of interesting elements 5 workspace
- */
-
-public class JavaImplementorsSearchPluginTest extends TestCase implements ISearchPluginTest {
-
-	@Override
-	protected void setUp() throws Exception {
-		// nothing to do here yet
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		// nothing to do here yet
-	}
-
-	public void testJavaImplementorsSearchDOS1() throws InterruptedException {
-		// List<?> results = search(1);
-	}
-
-	//	
-	// public void testJavaImplementorsSearchDOS2(){
-	// List<?> results = search(2);
-	// }
-	//	
-	// public void testJavaImplementorsSearchDOS3(){
-	// List<?> results = search(3);
-	// }
-	//	
-	// public void testJavaImplementorsSearchDOS4(){
-	// List<?> results = search(4);
-	// }
-	//	
-	// public void testJavaImplementorsSearchDOS5(){
-	// List<?> results = search(5);
-	// }
-
-	public List<?> search(int dos, IMylarElement node) {
-		if (node == null)
-			return null;
-
-		// test with each of the sepatations
-		JavaImplementorsProvider prov = new JavaImplementorsProvider();
-
-		IMylarSearchOperation o = prov.getSearchOperation(node, IJavaSearchConstants.IMPLEMENTORS, dos);
-		TestActiveSearchListener l = new TestActiveSearchListener(prov);
-		SearchPluginTestHelper.search(o, l);
-		return l.getResults();
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/JavaReadAccessSearchPluginTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/JavaReadAccessSearchPluginTest.java
deleted file mode 100644
index ae96ae1..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/JavaReadAccessSearchPluginTest.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-package org.eclipse.mylar.java.tests.search;
-
-import java.util.List;
-
-import junit.framework.TestCase;
-
-import org.eclipse.jdt.core.search.IJavaSearchConstants;
-import org.eclipse.mylar.core.tests.support.search.ISearchPluginTest;
-import org.eclipse.mylar.core.tests.support.search.TestActiveSearchListener;
-import org.eclipse.mylar.internal.core.search.IMylarSearchOperation;
-import org.eclipse.mylar.internal.java.search.JavaReadAccessProvider;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-
-public class JavaReadAccessSearchPluginTest extends TestCase implements ISearchPluginTest {
-
-	public void testJavaReadAccessSearchDOS1() {
-		// List<?> results = search(1);
-	}
-
-	//	
-	// public void testJavaReadAccessSearchDOS2(){
-	// List<?> results = search(2);
-	// }
-	//	
-	// public void testJavaReadAccessSearchDOS3(){
-	// List<?> results = search(3);
-	// }
-	//	
-	// public void testJavaReadAccessSearchDOS4(){
-	// List<?> results = search(4);
-	// }
-	//	
-	// public void testJavaReadAccessSearchDOS5(){
-	// List<?> results = search(5);
-	// }
-
-	public List<?> search(int dos, IMylarElement node) {
-
-		if (node == null)
-			return null;
-
-		// test with each of the sepatations
-		JavaReadAccessProvider prov = new JavaReadAccessProvider();
-
-		TestActiveSearchListener l = new TestActiveSearchListener(null);
-		IMylarSearchOperation o = prov.getSearchOperation(node, IJavaSearchConstants.READ_ACCESSES, dos);
-		SearchPluginTestHelper.search(o, l);
-		return l.getResults();
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/JavaReferencesSearchTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/JavaReferencesSearchTest.java
deleted file mode 100644
index ce30f1f..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/JavaReferencesSearchTest.java
+++ /dev/null
@@ -1,297 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-package org.eclipse.mylar.java.tests.search;
-
-import java.io.IOException;
-import java.util.List;
-
-import junit.framework.TestCase;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.search.IJavaSearchConstants;
-import org.eclipse.mylar.core.tests.support.search.ISearchPluginTest;
-import org.eclipse.mylar.core.tests.support.search.TestActiveSearchListener;
-import org.eclipse.mylar.internal.core.CompositeContext;
-import org.eclipse.mylar.internal.core.MylarContext;
-import org.eclipse.mylar.internal.core.search.IMylarSearchOperation;
-import org.eclipse.mylar.internal.java.JavaStructureBridge;
-import org.eclipse.mylar.internal.java.search.JavaReferencesProvider;
-import org.eclipse.mylar.internal.xml.pde.PdeStructureBridge;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-
-/**
- * @author Shawn Minto
- * @author Mik Kersten
- */
-public class JavaReferencesSearchTest extends TestCase implements ISearchPluginTest {
-
-	private IType type1;
-
-	private IType type11;
-
-	private IType type2;
-
-	private IFile plugin1;
-
-	private IJavaProject jp1;
-
-	private IJavaProject jp2;
-
-	private static final String SOURCE_ID = "JavaReferencesSearchTest";
-
-	private SearchPluginTestHelper helper;
-
-	@Override
-	protected void setUp() throws Exception {
-		// TODO: clear the relationship providers?
-		WorkspaceSetupHelper.setupWorkspace();
-		jp1 = WorkspaceSetupHelper.getProject1();
-		jp2 = WorkspaceSetupHelper.getProject2();
-		type1 = WorkspaceSetupHelper.getType(jp1, "org.eclipse.mylar.tests.project1.views.SampleView");
-		type11 = WorkspaceSetupHelper.getType(jp1, "org.eclipse.mylar.tests.project1.Project1Plugin");
-		type2 = WorkspaceSetupHelper.getType(jp2, "org.eclipse.mylar.tests.project2.builder.ToggleNatureAction");
-		plugin1 = WorkspaceSetupHelper.getFile(jp1, "plugin.xml");
-
-		MylarContext context = WorkspaceSetupHelper.getContext();
-		MylarPlugin.getContextManager().activateContext(context.getHandleIdentifier());
-		helper = new SearchPluginTestHelper(this);
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		WorkspaceSetupHelper.clearDoiModel();
-		MylarPlugin.getContextManager().deactivateContext(WorkspaceSetupHelper.getContext().getHandleIdentifier());
-		assertFalse(MylarPlugin.getContextManager().isContextActive());
-	}
-
-	public void testJavaReferencesSearchDOS1() throws IOException, CoreException {
-
-		int dos = 1;
-
-		CompositeContext t = (CompositeContext) MylarPlugin.getContextManager().getActiveContext();
-		ActiveSearchNotifier notifier = new ActiveSearchNotifier(t, SOURCE_ID);
-		IMylarElement searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-
-		// results should be null since the scope would be null.
-		// There are no landmarks to search over
-		helper.searchResultsNull(notifier, searchNode, dos);
-
-		// results should be not null, but have no references since the landmark
-		// is an element in a different project
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, type2.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 0);
-
-		// results should be not null, but have no java references since the
-		// landmark
-		// is an element in the same project, but there are no references in it
-		// NOTE: as of 3.2M3 there is a plugin.xml reference
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, type11.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 1);
-
-		// results should be not null, but have no references
-		// This file type should never affect the scope
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNull(notifier, plugin1.getFullPath().toString(), PdeStructureBridge.CONTENT_TYPE,
-				searchNode, dos);
-
-		// results should be not null, and there should be 1 reference since we
-		// are searching
-		// the file with the element in it
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 2);
-	}
-
-	public void testJavaReferencesSearchDOS2() throws CoreException, IOException {
-		int dos = 2;
-
-		CompositeContext t = (CompositeContext) MylarPlugin.getContextManager().getActiveContext();
-		ActiveSearchNotifier notifier = new ActiveSearchNotifier(t, SOURCE_ID);
-		IMylarElement searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-
-		// results should be null since the scope would be null.
-		// There are no landmarks to search over
-		helper.searchResultsNull(notifier, searchNode, dos);
-
-		// results should be not null, but have no references since the landmark
-		// is an element in a different project
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, type2.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 0);
-
-		// results should be not null, but have no references since the
-		// interesting element
-		// is an element in the same project, but no references in it
-		// NOTE: as of 3.2M3 there is a plugin.xml reference
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, type11.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 1);
-
-		// results should be not null, but have no references
-		// This file type should never affect the scope
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNull(notifier, plugin1.getFullPath().toString(), PdeStructureBridge.CONTENT_TYPE,
-				searchNode, dos);
-
-		// results should be not null, and we should get 1 result back
-		// NOTE: as of 3.2M3 there is a plugin.xml reference
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 2);
-
-		// results should be null, since we have nothing to search
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNull(notifier, searchNode, dos);
-
-		// results should be not null, and we should get 1 result back
-		// NOTE: as of 3.2M3 there is a plugin.xml reference
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNullInteresting(notifier, type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 2);
-	}
-
-	public void testJavaReferencesSearchDOS3() throws Exception {
-		int dos = 3;
-
-		CompositeContext t = (CompositeContext) MylarPlugin.getContextManager().getActiveContext();
-		ActiveSearchNotifier notifier = new ActiveSearchNotifier(t, SOURCE_ID);
-		IMylarElement searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-
-		// results should be null since the scope would be null.
-		// There are no landmarks to search over
-		helper.searchResultsNull(notifier, searchNode, dos);
-
-		// results should be not null, but have no references since the landmark
-		// is an element in a different project
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, type2.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 0);
-
-		// results should be not null, and have 1 reference since the project is
-		// the same
-		// NOTE: as of 3.2M3 there is a plugin.xml reference
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNullInteresting(notifier, type11.getHandleIdentifier(),
-				JavaStructureBridge.CONTENT_TYPE, searchNode, dos, 2);
-
-		// results should be not null, and have 1 reference
-		// NOTE: as of 3.2M3 there is a plugin.xml reference
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, plugin1.getFullPath().toString(), PdeStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 2);
-
-		// results should be not null, and we should get 1 result back
-		// NOTE: as of 3.2M3 there is a plugin.xml reference
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 2);
-
-		// results should be null, since we have nothing to search
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNull(notifier, searchNode, dos);
-
-		// results should be not null, and we should get 1 result back
-		// NOTE: as of 3.2M3 there is a plugin.xml reference
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNullInteresting(notifier, type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 2);
-	}
-
-	public void testJavaReferencesSearchDOS4() throws Exception {
-		// TODO this is the same as 3, but there are some flags to search
-		// libraries...we should check this too
-
-		int dos = 4;
-
-		CompositeContext t = (CompositeContext) MylarPlugin.getContextManager().getActiveContext();
-		ActiveSearchNotifier notifier = new ActiveSearchNotifier(t, SOURCE_ID);
-		IMylarElement searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-
-		// results should be null since the scope would be null.
-		// There are no landmarks to search over
-		helper.searchResultsNull(notifier, searchNode, dos);
-
-		// results should be not null, but have no references since the landmark
-		// is an element in a different project
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, type2.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 0);
-
-		// results should be not null, and have 1 reference since the project is
-		// the same
-		// NOTE: as of 3.2M3 there is a plugin.xml reference
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNullInteresting(notifier, type11.getHandleIdentifier(),
-				JavaStructureBridge.CONTENT_TYPE, searchNode, dos, 2);
-
-		// results should be not null, and have 1 reference
-		// NOTE: as of 3.2M3 there is a plugin.xml reference
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, plugin1.getFullPath().toString(), PdeStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 2);
-
-		// results should be not null, and we should get 1 result back
-		// NOTE: as of 3.2M3 there is a plugin.xml reference
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 2);
-
-		// results should be null, since we have nothing to search
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNull(notifier, searchNode, dos);
-
-		// results should be not null, and we should get 1 result back
-		// NOTE: as of 3.2M3 there is a plugin.xml reference
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNullInteresting(notifier, type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 2);
-	}
-
-	public void testJavaReferencesSearchDOS5() throws IOException, CoreException {
-		int dos = 5;
-
-		// NOTE: as of 3.2M3 there is a plugin.xml reference
-		CompositeContext t = (CompositeContext) MylarPlugin.getContextManager().getActiveContext();
-		ActiveSearchNotifier notifier = new ActiveSearchNotifier(t, SOURCE_ID);
-		IMylarElement searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-
-		// we should have 1 result since we are searching the entire workspace
-		helper.searchResultsNotNull(notifier, searchNode, dos, 2);
-
-		// we should have no results since there are no java references in the
-		// workspace
-		// NOTE: as of 3.2M3 there is a plugin.xml reference
-		searchNode = notifier.getElement(type2.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, searchNode, dos, 1);
-	}
-
-	public List<?> search(int dos, IMylarElement node) {
-		if (node == null)
-			return null;
-
-		// test with each of the sepatations
-		JavaReferencesProvider prov = new JavaReferencesProvider();
-
-		TestActiveSearchListener l = new TestActiveSearchListener(prov);
-		IMylarSearchOperation o = prov.getSearchOperation(node, IJavaSearchConstants.REFERENCES, dos);
-		if (o == null)
-			return null;
-
-		SearchPluginTestHelper.search(o, l);
-		return l.getResults();
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/JavaWriteAccessSearchPluginTest.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/JavaWriteAccessSearchPluginTest.java
deleted file mode 100644
index f29665f..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/JavaWriteAccessSearchPluginTest.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-package org.eclipse.mylar.java.tests.search;
-
-import java.util.List;
-
-import junit.framework.TestCase;
-
-import org.eclipse.jdt.core.search.IJavaSearchConstants;
-import org.eclipse.mylar.core.tests.support.search.ISearchPluginTest;
-import org.eclipse.mylar.core.tests.support.search.TestActiveSearchListener;
-import org.eclipse.mylar.internal.core.search.IMylarSearchOperation;
-import org.eclipse.mylar.internal.java.search.JavaWriteAccessProvider;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-
-public class JavaWriteAccessSearchPluginTest extends TestCase implements ISearchPluginTest {
-
-	public void testJavaWriteAccessSearchDOS1() {
-		// List<?> results = search(1);
-	}
-
-	//	
-	// public void testJavaWriteAccessSearchDOS2(){
-	// List<?> results = search(2);
-	// }
-	//	
-	// public void testJavaWriteAccessSearchDOS3(){
-	// List<?> results = search(3);
-	// }
-	//	
-	// public void testJavaWriteAccessSearchDOS4(){
-	// List<?> results = search(4);
-	// }
-	//	
-	// public void testJavaWriteAccessSearchDOS5(){
-	// List<?> results = search(5);
-	// }
-
-	public List<?> search(int dos, IMylarElement node) {
-
-		if (node == null)
-			return null;
-
-		// test with each of the sepatations
-		JavaWriteAccessProvider prov = new JavaWriteAccessProvider();
-
-		TestActiveSearchListener l = new TestActiveSearchListener(prov);
-		IMylarSearchOperation o = prov.getSearchOperation(node, IJavaSearchConstants.WRITE_ACCESSES, dos);
-		SearchPluginTestHelper.search(o, l);
-		return l.getResults();
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/SearchPluginTestHelper.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/SearchPluginTestHelper.java
deleted file mode 100644
index 8963bc9..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/SearchPluginTestHelper.java
+++ /dev/null
@@ -1,115 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-package org.eclipse.mylar.java.tests.search;
-
-import java.io.IOException;
-import java.util.Date;
-import java.util.List;
-
-import junit.framework.TestCase;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.NullProgressMonitor;
-import org.eclipse.mylar.core.tests.support.search.ISearchPluginTest;
-import org.eclipse.mylar.internal.core.search.IActiveSearchListener;
-import org.eclipse.mylar.internal.core.search.IMylarSearchOperation;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-
-/**
- * @author Shawn Minto
- */
-public class SearchPluginTestHelper extends TestCase {
-
-	private ISearchPluginTest test;
-
-	/**
-	 * maximum time to wait for search results * 2. so 60 = 30sec - only
-	 * sleeping 500ms at a time instead of 1 sec
-	 */
-	private static final long MAXWAIT = 360;
-
-	public SearchPluginTestHelper(ISearchPluginTest test) {
-		this.test = test;
-	}
-
-	public void searchResultsNotNull(ActiveSearchNotifier notifier, String handle, String kind,
-			IMylarElement searchNode, int dos, int expected) throws IOException, CoreException {
-		notifier.mockRaiseInterest(handle, kind);
-
-		List<?> results = test.search(dos, searchNode);
-		assertNotNull("Results Null", results);
-		assertEquals("Wrong number search results", expected, results.size());
-		notifier.clearContext();
-	}
-
-	public void searchResultsNotNullInteresting(ActiveSearchNotifier notifier, String handle, String kind,
-			IMylarElement searchNode, int dos, int expected) throws IOException, CoreException {
-		notifier.mockEditorSelection(handle, kind);
-
-		List<?> results = test.search(dos, searchNode);
-		assertNotNull("Results Null", results);
-		assertEquals("Wrong number search results", expected, results.size());
-		notifier.clearContext();
-	}
-
-	public void searchResultsNotNull(ActiveSearchNotifier notifier, IMylarElement searchNode, int dos, int expected)
-			throws IOException, CoreException {
-		List<?> results = test.search(dos, searchNode);
-		assertNotNull("Results Null", results);
-		assertEquals("Wrong number search results", expected, results.size());
-		notifier.clearContext();
-	}
-
-	public void searchResultsNull(ActiveSearchNotifier notifier, String handle, String kind, IMylarElement searchNode,
-			int dos) throws IOException, CoreException {
-		notifier.mockRaiseInterest(handle, kind);
-
-		List<?> results = test.search(dos, searchNode);
-		assertNull("Results Not Null", results);
-		notifier.clearContext();
-	}
-
-	public void searchResultsNull(ActiveSearchNotifier notifier, IMylarElement searchNode, int dos) throws IOException,
-			CoreException {
-		List<?> results = test.search(dos, searchNode);
-		assertNull("Results Not Null", results);
-		notifier.clearContext();
-	}
-
-	/**
-	 * @return -1 if there was a prob, else the search time in seconds
-	 */
-	public static long search(IMylarSearchOperation op, IActiveSearchListener listener) {
-		if (op == null)
-			return -1;
-
-		op.addListener(listener);
-
-		long start = new Date().getTime();
-
-		op.run(new NullProgressMonitor());
-
-		for (int i = 0; i < MAXWAIT && !listener.resultsGathered(); i++) {
-			try {
-				Thread.sleep(500);
-			} catch (InterruptedException e) {
-				// don't need to do anything here
-			}
-		}
-
-		long time = (new Date().getTime() - start) / 1000;
-
-		if (!listener.resultsGathered()) {
-			return -1;
-		}
-		return time;
-	}
-}
diff --git a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/WorkspaceSetupHelper.java b/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/WorkspaceSetupHelper.java
deleted file mode 100644
index 5c1e53a..0000000
--- a/org.eclipse.mylyn.java.tests/src/org/eclipse/mylyn/java/tests/search/WorkspaceSetupHelper.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-package org.eclipse.mylar.java.tests.search;
-
-import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IWorkspaceRoot;
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.NullProgressMonitor;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.IPackageFragment;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.mylar.core.tests.support.ResourceHelper;
-import org.eclipse.mylar.internal.core.MylarContext;
-import org.eclipse.mylar.internal.core.ScalingFactors;
-import org.eclipse.mylar.java.tests.TestJavaProject;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-
-public class WorkspaceSetupHelper {
-
-	private static final String HELPER_CONTEXT_ID = "helper-context";
-
-	private static boolean isSetup = false;
-
-	private static MylarContext taskscape;
-
-	private static IJavaProject project1;
-
-	private static IJavaProject project2;
-
-	private static TestJavaProject jdtCoreDomProject;
-
-	private static IWorkspaceRoot workspaceRoot;
-
-	public static void clearWorkspace() throws CoreException, IOException {
-		isSetup = false;
-		ResourcesPlugin.getWorkspace().getRoot().delete(true, true, new NullProgressMonitor());
-		clearDoiModel();
-	}
-
-	public static IWorkspaceRoot setupWorkspace() throws CoreException, IOException, InvocationTargetException,
-			InterruptedException {
-		if (isSetup) {
-			clearDoiModel();
-			return workspaceRoot;
-		}
-		taskscape = new MylarContext(HELPER_CONTEXT_ID, new ScalingFactors());
-
-		workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
-
-		project1 = ResourceHelper.createJavaPluginProjectFromZip("project1", "project1.zip");
-		project2 = ResourceHelper.createJavaPluginProjectFromZip("project2", "project2.zip");
-
-		jdtCoreDomProject = new TestJavaProject("workspace-helper-project");
-		IPackageFragment jdtCoreDomPkg = jdtCoreDomProject.createPackage("org.eclipse.jdt.core.dom");
-		IType astNodeType = jdtCoreDomProject.createType(jdtCoreDomPkg, "ASTNode.java", "public class ASTNode { }");
-		astNodeType.createMethod("public final void setSourceRange(int startPosition, int length) { }", null, false,
-				null);
-		isSetup = true;
-
-		project1.open(new NullProgressMonitor());
-		project2.open(new NullProgressMonitor());
-		jdtCoreDomProject.getJavaProject().open(new NullProgressMonitor());
-
-		return workspaceRoot;
-	}
-
-	public static void clearDoiModel() throws CoreException {
-		MylarPlugin.getContextManager().deleteContext(HELPER_CONTEXT_ID);
-		taskscape = new MylarContext(HELPER_CONTEXT_ID, new ScalingFactors());
-	}
-
-	public static MylarContext getContext() throws CoreException, IOException, InvocationTargetException,
-			InterruptedException {
-		if (!isSetup)
-			setupWorkspace();
-		return taskscape;
-	}
-
-	public static IJavaProject getJdtCoreDomProject() throws CoreException, IOException, InvocationTargetException,
-			InterruptedException {
-		if (!isSetup)
-			setupWorkspace();
-		return jdtCoreDomProject.getJavaProject();
-	}
-
-	public static IJavaProject getProject1() throws CoreException, IOException, InvocationTargetException,
-			InterruptedException {
-		if (!isSetup)
-			setupWorkspace();
-		return project1;
-	}
-
-	public static IJavaProject getProject2() throws CoreException, IOException, InvocationTargetException,
-			InterruptedException {
-		if (!isSetup)
-			setupWorkspace();
-		return project2;
-	}
-
-	public static IWorkspaceRoot getWorkspaceRoot() throws CoreException, IOException, InvocationTargetException,
-			InterruptedException {
-		if (!isSetup)
-			setupWorkspace();
-		return workspaceRoot;
-	}
-
-	public static IFile getFile(IJavaProject jp, String name) throws JavaModelException {
-		if (jp == null || name == null)
-			return null;
-		Object[] files = jp.getNonJavaResources();
-		for (Object o : files) {
-			if (o instanceof IFile && ((IFile) o).getName().equals(name))
-				return (IFile) o;
-		}
-		return null;
-	}
-
-	public static IType getType(IJavaProject jp, String fullyQualifiedName) throws JavaModelException {
-		if (jp == null || fullyQualifiedName == null)
-			return null;
-		IType t = jp.findType(fullyQualifiedName);
-		return t;
-	}
-
-	public static IMethod getMethod(IType t, String methodName, String[] params) {
-		if (t == null || methodName == null || params == null)
-			return null;
-		return t.getMethod(methodName, params);
-	}
-}
diff --git a/org.eclipse.mylyn.resources.tests/.classpath b/org.eclipse.mylyn.resources.tests/.classpath
deleted file mode 100644
index c9c6503..0000000
--- a/org.eclipse.mylyn.resources.tests/.classpath
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins">
-		<accessrules>
-			<accessrule kind="accessible" pattern="**/internal/**"/>
-		</accessrules>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5">
-		<accessrules>
-			<accessrule kind="nonaccessible" pattern="com/sun/**"/>
-		</accessrules>
-	</classpathentry>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/org.eclipse.mylyn.resources.tests/.cvsignore b/org.eclipse.mylyn.resources.tests/.cvsignore
deleted file mode 100644
index ba077a4..0000000
--- a/org.eclipse.mylyn.resources.tests/.cvsignore
+++ /dev/null
@@ -1 +0,0 @@
-bin
diff --git a/org.eclipse.mylyn.resources.tests/.project b/org.eclipse.mylyn.resources.tests/.project
deleted file mode 100644
index 1096895..0000000
--- a/org.eclipse.mylyn.resources.tests/.project
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.mylar.xml.tests</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/org.eclipse.mylyn.resources.tests/.settings/org.eclipse.jdt.core.prefs b/org.eclipse.mylyn.resources.tests/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 668b6cc..0000000
--- a/org.eclipse.mylyn.resources.tests/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,303 +0,0 @@
-#Mon Feb 13 11:20:16 PST 2006
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.5
-org.eclipse.jdt.core.compiler.debug.lineNumber=generate
-org.eclipse.jdt.core.compiler.debug.localVariable=generate
-org.eclipse.jdt.core.compiler.debug.sourceFile=generate
-org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
-org.eclipse.jdt.core.compiler.problem.deprecation=warning
-org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
-org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
-org.eclipse.jdt.core.compiler.problem.discouragedReference=warning
-org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
-org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
-org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
-org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
-org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
-org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
-org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore
-org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
-org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
-org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
-org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
-org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
-org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
-org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
-org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
-org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
-org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
-org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
-org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
-org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
-org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
-org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
-org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
-org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
-org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
-org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=ignore
-org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.unusedImport=warning
-org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
-org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
-org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning
-org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.5
-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_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_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_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.blank_lines_after_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_after_package=1
-org.eclipse.jdt.core.formatter.blank_lines_before_field=1
-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_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_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=false
-org.eclipse.jdt.core.formatter.comment.format_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_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=80
-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.format_guardian_clause_on_one_line=false
-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=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_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_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_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_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_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_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_while=insert
-org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=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_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.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=120
-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=1
-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_tabs_only_for_leading_indentations=false
diff --git a/org.eclipse.mylyn.resources.tests/.settings/org.eclipse.jdt.ui.prefs b/org.eclipse.mylyn.resources.tests/.settings/org.eclipse.jdt.ui.prefs
deleted file mode 100644
index 85d95dc..0000000
--- a/org.eclipse.mylyn.resources.tests/.settings/org.eclipse.jdt.ui.prefs
+++ /dev/null
@@ -1,5 +0,0 @@
-#Mon Feb 13 11:20:16 PST 2006
-eclipse.preferences.version=1
-formatter_profile=_Mylar based on Eclipse [built-in]
-formatter_settings_version=10
-org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><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">/**\r\n * @return the ${bare_field_name}\r\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">/**\r\n * @param ${param} the ${bare_field_name} to set\r\n */</template><template autoinsert\="true" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/**\r\n * \r\n */</template><template autoinsert\="false" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/**\r\n * @author ${user}\r\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">/**\r\n * \r\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">/**\r\n * ${tags}\r\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"></template><template autoinsert\="false" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">/*******************************************************************************\r\n * Copyright (c) 2004 - 2006 University Of British Columbia and others.\r\n * All rights reserved. This program and the accompanying materials\r\n * are made available under the terms of the Eclipse Public License v1.0\r\n * which accompanies this distribution, and is available at\r\n * http\://www.eclipse.org/legal/epl-v10.html\r\n *\r\n * Contributors\:\r\n *     University Of British Columbia - initial API and implementation\r\n *******************************************************************************/\r\n\r\n${package_declaration}\r\n\r\n${typecomment}\r\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">\r\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">\r\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">\r\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">\r\n</template><template autoinsert\="false" 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\r\n${exception_var}.printStackTrace();</template><template autoinsert\="false" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ignore\r\n${body_statement}</template><template autoinsert\="false" 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}\r\n// ignore</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/org.eclipse.mylyn.resources.tests/.settings/org.eclipse.ltk.core.refactoring.prefs b/org.eclipse.mylyn.resources.tests/.settings/org.eclipse.ltk.core.refactoring.prefs
deleted file mode 100644
index 771bfc5..0000000
--- a/org.eclipse.mylyn.resources.tests/.settings/org.eclipse.ltk.core.refactoring.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Fri Jun 02 15:32:03 PDT 2006
-eclipse.preferences.version=1
-org.eclipse.ltk.core.refactoring.enable.project.refactoring.history=true
diff --git a/org.eclipse.mylyn.resources.tests/.settings/org.eclipse.pde.prefs b/org.eclipse.mylyn.resources.tests/.settings/org.eclipse.pde.prefs
deleted file mode 100644
index 094985e..0000000
--- a/org.eclipse.mylyn.resources.tests/.settings/org.eclipse.pde.prefs
+++ /dev/null
@@ -1,12 +0,0 @@
-#Thu Nov 03 15:47:51 PST 2005
-compilers.p.deprecated=2
-compilers.p.no-required-att=0
-compilers.p.not-externalized-att=2
-compilers.p.unknown-attribute=0
-compilers.p.unknown-class=0
-compilers.p.unknown-element=0
-compilers.p.unknown-resource=0
-compilers.p.unresolved-ex-points=0
-compilers.p.unresolved-import=0
-compilers.use-project=true
-eclipse.preferences.version=1
diff --git a/org.eclipse.mylyn.resources.tests/META-INF/MANIFEST.MF b/org.eclipse.mylyn.resources.tests/META-INF/MANIFEST.MF
deleted file mode 100644
index d20f156..0000000
--- a/org.eclipse.mylyn.resources.tests/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,26 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: Mylar Xml Tests Plug-in
-Bundle-SymbolicName: org.eclipse.mylar.xml.tests
-Bundle-Version: 1.0.0
-Bundle-Activator: org.eclipse.mylar.tests.xml.MylarXmlTestsPlugin
-Bundle-Vendor: Eclipse.org
-Bundle-Localization: plugin
-Require-Bundle: org.eclipse.core.runtime,
- org.eclipse.search,
- org.eclipse.core.resources,
- org.eclipse.ui.ide,
- org.eclipse.jface.text,
- org.eclipse.jdt,
- org.eclipse.jdt.core,
- org.junit,
- org.eclipse.mylar.core,
- org.eclipse.mylar.core.tests,
- org.eclipse.mylar.java,
- org.eclipse.mylar.xml,
- org.eclipse.mylar.ide,
- org.eclipse.mylar.java.tests
-Eclipse-AutoStart: true
-Bundle-ClassPath: mylar-xml-tests.jar
-Export-Package: org.eclipse.mylar.tests.xml
-Bundle-RequiredExecutionEnvironment: J2SE-1.5
diff --git a/org.eclipse.mylyn.resources.tests/about.html b/org.eclipse.mylyn.resources.tests/about.html
deleted file mode 100644
index 1aeb16b..0000000
--- a/org.eclipse.mylyn.resources.tests/about.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>May 2, 2006</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</a>.</p>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/org.eclipse.mylyn.resources.tests/build.properties b/org.eclipse.mylyn.resources.tests/build.properties
deleted file mode 100644
index 430e7a3..0000000
--- a/org.eclipse.mylyn.resources.tests/build.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-###############################################################################
-# Copyright (c) 2004 - 2005 University Of British Columbia 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:
-#     University Of British Columbia - initial API and implementation
-###############################################################################
-bin.includes = META-INF/,\
-               mylar-xml-tests.jar,\
-               about.html
-jars.compile.order = mylar-xml-tests.jar
-source.mylar-xml-tests.jar = src/
-output.mylar-xml-tests.jar = bin/
-src.includes = META-INF/,\
-               about.html,\
-               src/
-jre.compilation.profile = J2SE-1.5
diff --git a/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/AllXmlTests.java b/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/AllXmlTests.java
deleted file mode 100644
index 9f3f9b9..0000000
--- a/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/AllXmlTests.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.tests.xml;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-
-/**
- * @author Mik Kersten
- */
-public class AllXmlTests {
-
-	public static Test suite() {
-		TestSuite suite = new TestSuite("Test for org.eclipse.mylar.tests.xml");
-		// $JUnit-BEGIN$
-		suite.addTestSuite(XMLSearchPluginTest.class);
-		// suite.addTestSuite(ResultUpdaterTest.class);
-		// $JUnit-END$
-		return suite;
-	}
-
-}
diff --git a/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/MylarXmlTestsPlugin.java b/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/MylarXmlTestsPlugin.java
deleted file mode 100644
index a1eb247..0000000
--- a/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/MylarXmlTestsPlugin.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-package org.eclipse.mylar.tests.xml;
-
-import org.eclipse.core.runtime.Plugin;
-import org.osgi.framework.BundleContext;
-
-/**
- * The main plugin class to be used in the desktop.
- */
-public class MylarXmlTestsPlugin extends Plugin {
-	// The shared instance.
-	private static MylarXmlTestsPlugin plugin;
-
-	/**
-	 * The constructor.
-	 */
-	public MylarXmlTestsPlugin() {
-		super();
-		plugin = this;
-	}
-
-	@Override
-	public void start(BundleContext context) throws Exception {
-		super.start(context);
-	}
-
-	@Override
-	public void stop(BundleContext context) throws Exception {
-		super.stop(context);
-		plugin = null;
-	}
-
-	/**
-	 * Returns the shared instance.
-	 */
-	public static MylarXmlTestsPlugin getDefault() {
-		return plugin;
-	}
-
-}
diff --git a/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/ResultUpdaterTest.java b/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/ResultUpdaterTest.java
deleted file mode 100644
index 2e8976f..0000000
--- a/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/ResultUpdaterTest.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.mylar.tests.xml;
-
-import java.io.IOException;
-import java.util.Collection;
-import java.util.List;
-
-import junit.framework.TestCase;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.mylar.core.tests.support.ResourceHelper;
-import org.eclipse.mylar.core.tests.support.search.ISearchPluginTest;
-import org.eclipse.mylar.internal.core.CompositeContext;
-import org.eclipse.mylar.internal.core.MylarContext;
-import org.eclipse.mylar.internal.core.MylarContextRelation;
-import org.eclipse.mylar.internal.core.search.IMylarSearchOperation;
-import org.eclipse.mylar.internal.java.JavaStructureBridge;
-import org.eclipse.mylar.internal.xml.XmlReferencesProvider;
-import org.eclipse.mylar.java.tests.search.ActiveSearchNotifier;
-import org.eclipse.mylar.java.tests.search.SearchPluginTestHelper;
-import org.eclipse.mylar.java.tests.search.WorkspaceSetupHelper;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-
-public class ResultUpdaterTest extends TestCase implements ISearchPluginTest {
-	private IType type1;
-
-	private IFile plugin1;
-
-	private IJavaProject jp1;
-
-	private static final String SOURCE_ID = "XMLSearchResultUpdaterTest";
-
-	private SearchPluginTestHelper helper;
-
-	@Override
-	protected void setUp() throws Exception {
-		// TODO: clear the relationship providers?
-		WorkspaceSetupHelper.setupWorkspace();
-		jp1 = WorkspaceSetupHelper.getProject1();
-		type1 = WorkspaceSetupHelper.getType(jp1, "org.eclipse.mylar.tests.project1.views.SampleView");
-		plugin1 = WorkspaceSetupHelper.getFile(jp1, "plugin.xml");
-
-		MylarContext t = WorkspaceSetupHelper.getContext();
-		MylarPlugin.getContextManager().activateContext(t.getHandleIdentifier());// ,
-																					// t.getId());
-		helper = new SearchPluginTestHelper(this);
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		WorkspaceSetupHelper.clearWorkspace();
-		WorkspaceSetupHelper.clearDoiModel();
-	}
-
-	public void testRemoveFile() throws Exception {
-
-		int dos = 4;
-
-		CompositeContext t = (CompositeContext) MylarPlugin.getContextManager().getActiveContext();
-		ActiveSearchNotifier notifier = new ActiveSearchNotifier(t, SOURCE_ID);
-		IMylarElement searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-
-		//
-		// we should get all results since we are searching the entire workspace
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, searchNode, dos, 3);
-		//
-		//
-
-		Collection<MylarContextRelation> edges = searchNode.getRelations();
-		assertEquals(3, edges.size());
-
-		ResourceHelper.delete(plugin1);
-
-		Collection<MylarContextRelation> edgesAfterRemove = searchNode.getRelations();
-		assertEquals(0, edgesAfterRemove.size());
-	}
-
-	public void testRemoveProject() throws Exception {
-		int dos = 4;
-
-		CompositeContext t = (CompositeContext) MylarPlugin.getContextManager().getActiveContext();
-		ActiveSearchNotifier notifier = new ActiveSearchNotifier(t, SOURCE_ID);
-		IMylarElement searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-
-		//
-		// we should get all results since we are searching the entire workspace
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, searchNode, dos, 3);
-		//
-		//
-
-		Collection<MylarContextRelation> edges = searchNode.getRelations();
-		assertEquals(3, edges.size());
-
-		ResourceHelper.deleteProject(jp1.getProject().getName());
-
-		Collection<MylarContextRelation> edgesAfterRemove = searchNode.getRelations();
-		assertEquals(0, edgesAfterRemove.size());
-		;
-	}
-
-	public List<?> search(int dos, IMylarElement node) throws IOException, CoreException {
-		if (node == null)
-			return null;
-
-		// test with each of the sepatations
-		XmlReferencesProvider prov = new XmlReferencesProvider();
-
-		IMylarSearchOperation o = prov.getSearchOperation(node, 0, dos);
-		if (o == null)
-			return null;
-
-		XMLResultUpdaterSearchListener l = new XMLResultUpdaterSearchListener(prov, node, dos);
-		SearchPluginTestHelper.search(o, l);
-
-		return l.getResults();
-	}
-}
diff --git a/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/XMLResultUpdaterSearchListener.java b/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/XMLResultUpdaterSearchListener.java
deleted file mode 100644
index af90aae..0000000
--- a/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/XMLResultUpdaterSearchListener.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-package org.eclipse.mylar.tests.xml;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import org.eclipse.core.internal.resources.File;
-import org.eclipse.mylar.core.tests.support.search.TestActiveSearchListener;
-import org.eclipse.mylar.internal.xml.XmlNodeHelper;
-import org.eclipse.mylar.internal.xml.XmlReferencesProvider;
-import org.eclipse.mylar.internal.xml.pde.PdeStructureBridge;
-import org.eclipse.mylar.provisional.core.AbstractRelationProvider;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.IMylarStructureBridge;
-import org.eclipse.mylar.provisional.core.InteractionEvent;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.search.internal.ui.text.FileSearchResult;
-import org.eclipse.search.ui.text.Match;
-import org.eclipse.ui.part.FileEditorInput;
-
-public class XMLResultUpdaterSearchListener extends TestActiveSearchListener {
-
-	private List<IMylarElement> results = null;
-
-	private IMylarElement node;
-
-	private int degreeOfSeparation;
-
-	public XMLResultUpdaterSearchListener(AbstractRelationProvider prov, IMylarElement searchNode,
-			int degreeOfSeparation) {
-		super(prov);
-		this.node = searchNode;
-		this.degreeOfSeparation = degreeOfSeparation;
-	}
-
-	private boolean gathered = false;
-
-	@Override
-	public void searchCompleted(List<?> l) {
-		results = new ArrayList<IMylarElement>();
-
-		if (l.isEmpty())
-			return;
-
-		Map<String, String> nodes = new HashMap<String, String>();
-
-		if (l.get(0) instanceof FileSearchResult) {
-			FileSearchResult fsr = (FileSearchResult) l.get(0);
-
-			Object[] far = fsr.getElements();
-			for (int i = 0; i < far.length; i++) {
-				Match[] mar = fsr.getMatches(far[i]);
-
-				if (far[i] instanceof File) {
-					File f = (File) far[i];
-
-					// change the file into a document
-					FileEditorInput fei = new FileEditorInput(f);
-
-					for (int j = 0; j < mar.length; j++) {
-						Match m = mar[j];
-						try {
-							XmlNodeHelper xnode = new XmlNodeHelper(fei.getFile().getFullPath().toString(), m
-									.getOffset());
-							IMylarStructureBridge bridge = MylarPlugin.getDefault().getStructureBridge(f.getName());
-							String handle = xnode.getHandle();
-							Object o = bridge.getObjectForHandle(handle);
-							String name = bridge.getName(o);
-							if (o != null) {
-								nodes.put(handle, name);
-								results.add(node);
-							}
-						} catch (Exception e) {
-							e.printStackTrace();
-						}
-					}
-				}
-			}
-		}
-
-		for (String handle : nodes.keySet()) {
-			incrementInterest(node, PdeStructureBridge.CONTENT_TYPE, handle, degreeOfSeparation);
-		}
-		gathered = true;
-	}
-
-	protected void incrementInterest(IMylarElement node, String elementKind, String elementHandle,
-			int degreeOfSeparation) {
-		int predictedInterest = 1;// (7-degreeOfSeparation) *
-									// TaskscapeManager.getScalingFactors().getDegreeOfSeparationScale();
-		InteractionEvent event = new InteractionEvent(InteractionEvent.Kind.PREDICTION, elementKind, elementHandle,
-				XmlReferencesProvider.SOURCE_ID, XmlReferencesProvider.SOURCE_ID, null, predictedInterest);
-		MylarPlugin.getContextManager().handleInteractionEvent(event);
-
-	}
-
-	@Override
-	public boolean resultsGathered() {
-		return gathered;
-	}
-
-	@Override
-	public List<?> getResults() {
-		return results;
-	}
-
-}
diff --git a/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/XMLSearchPluginTest.java b/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/XMLSearchPluginTest.java
deleted file mode 100644
index 7b031f7..0000000
--- a/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/XMLSearchPluginTest.java
+++ /dev/null
@@ -1,324 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-package org.eclipse.mylar.tests.xml;
-
-import java.io.IOException;
-import java.util.List;
-
-import junit.framework.TestCase;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.mylar.core.tests.support.search.ISearchPluginTest;
-import org.eclipse.mylar.internal.core.CompositeContext;
-import org.eclipse.mylar.internal.core.MylarContext;
-import org.eclipse.mylar.internal.core.search.IMylarSearchOperation;
-import org.eclipse.mylar.internal.ide.ResourceStructureBridge;
-import org.eclipse.mylar.internal.java.JavaStructureBridge;
-import org.eclipse.mylar.internal.xml.XmlReferencesProvider;
-import org.eclipse.mylar.internal.xml.pde.PdeStructureBridge;
-import org.eclipse.mylar.java.tests.search.ActiveSearchNotifier;
-import org.eclipse.mylar.java.tests.search.SearchPluginTestHelper;
-import org.eclipse.mylar.java.tests.search.WorkspaceSetupHelper;
-import org.eclipse.mylar.provisional.core.IMylarElement;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-
-/*
- * TEST CASES TO HANDLE 1. all dos - with and without results TODO - in both the
- * plugin.xml and the build.xml 2. different type of xml file with and without
- * reference - shouldn't have result
- * 
- * DEGREE OF SEPARATIONS 1 xml landmark files 2 projects of any landmark 3
- * workspace 4 workspace 5 NONE
- */
-
-public class XMLSearchPluginTest extends TestCase implements ISearchPluginTest {
-
-	private IType type1;
-
-	private IType type2;
-
-	private IFile plugin1;
-
-	private IFile plugin2;
-
-	private IFile tocRefs;
-
-	private IFile tocNoRefs;
-
-	private IJavaProject jp1;
-
-	private IJavaProject jp2;
-
-	private static final String SOURCE_ID = "XMLSearchTest";
-
-	private SearchPluginTestHelper helper;
-
-	@Override
-	protected void setUp() throws Exception {
-		// TODO: clear the relationship providers?
-		WorkspaceSetupHelper.setupWorkspace();
-		jp1 = WorkspaceSetupHelper.getProject1();
-		jp2 = WorkspaceSetupHelper.getProject2();
-		type1 = WorkspaceSetupHelper.getType(jp1, "org.eclipse.mylar.tests.project1.views.SampleView");
-		type2 = WorkspaceSetupHelper.getType(jp2,
-				"org.eclipse.mylar.tests.project2.builder.SampleBuilder.SampleResourceVisitor");
-		plugin1 = WorkspaceSetupHelper.getFile(jp1, "plugin.xml");
-		tocRefs = WorkspaceSetupHelper.getFile(jp1, "toc-refs.xml");
-		tocNoRefs = WorkspaceSetupHelper.getFile(jp1, "toc-no-refs.xml");
-		plugin2 = WorkspaceSetupHelper.getFile(jp2, "plugin.xml");
-
-		MylarContext t = WorkspaceSetupHelper.getContext();
-		MylarPlugin.getContextManager().activateContext(t.getHandleIdentifier());
-		helper = new SearchPluginTestHelper(this);
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		WorkspaceSetupHelper.clearDoiModel();
-		MylarPlugin.getContextManager().deactivateContext(WorkspaceSetupHelper.getContext().getHandleIdentifier());
-		assertFalse(MylarPlugin.getContextManager().isContextActive());
-	}
-
-	public void testXMLSearchDOS1() throws IOException, CoreException {
-
-		int dos = 1;
-
-		CompositeContext t = (CompositeContext) MylarPlugin.getContextManager().getActiveContext();
-		ActiveSearchNotifier notifier = new ActiveSearchNotifier(t, SOURCE_ID);
-		IMylarElement searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-
-		//
-		// results should be null since the scope would be null.
-		// There are no landmarks to search over
-		helper.searchResultsNull(notifier, searchNode, dos);
-		//
-		//
-
-		//
-		// add an element to the taskscape, results should still be null
-		// There is a landmark, but not one that is an xml file that we care
-		// about
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNull(notifier, type1.getHandleIdentifier(), ResourceStructureBridge.CONTENT_TYPE,
-				searchNode, dos);
-
-		//
-		//
-
-		//
-		// add an element to the taskscape, results should still be null
-		// There is a landmark that has references in it, but not one that is an
-		// xml file that we care about
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNull(notifier, tocRefs.getFullPath().toString(), ResourceStructureBridge.CONTENT_TYPE,
-				searchNode, dos);
-		//
-		//
-
-		//
-		// add an element to the taskscape, results should still be null
-		// There is a landmark, but not one that is an xml file that we care
-		// about
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNull(notifier, tocNoRefs.getFullPath().toString(), ResourceStructureBridge.CONTENT_TYPE,
-				searchNode, dos);
-		//
-		//
-
-		//
-		// add the plugin.xml from a different project to the taskscape, should
-		// have non null results, but 0 size
-		// There is a lanmark that can be added to create a scope with the
-		// proper xml file type
-		// but it is in the wrong project and shouldn't have any references
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, plugin2.getFullPath().toString(), PdeStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 0);
-		//
-		//
-
-		//
-		// add the plugin.xml to the taskscape, should have results now
-		// We should get the results now since we have the proper xml file as
-		// the landmark now
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, plugin1.getFullPath().toString(), PdeStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 3);
-		//
-		//
-	}
-
-	public void testXMLSearchDOS2() throws IOException, CoreException {
-
-		int dos = 2;
-
-		CompositeContext t = (CompositeContext) MylarPlugin.getContextManager().getActiveContext();
-		ActiveSearchNotifier notifier = new ActiveSearchNotifier(t, SOURCE_ID);
-		IMylarElement searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-
-//		// results should be null since the scope would be null.
-//		// There are no landmarks and therefore no projects to search over
-//		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-//		helper.searchResultsNull(notifier, searchNode, dos);
-//
-//		// add an element to the taskscape, results should not be null
-//		// There is a landmark with references in it, but not one that is an xml
-//		// file that we care about
-//		// therefore, we still only get 3 references - landmark is in the same
-//		// project
-//		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-//		helper.searchResultsNotNull(notifier, tocRefs.getFullPath().toString(), ResourceStructureBridge.CONTENT_TYPE,
-//				searchNode, dos, 3);
-//
-//		// add an element to the taskscape, results should not be null, but only
-//		// 3
-//		// There is a landmark, but not one that is an xml file that we care
-//		// about - landmark is in the same project
-//		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-//		helper.searchResultsNotNull(notifier, tocNoRefs.getFullPath().toString(), ResourceStructureBridge.CONTENT_TYPE,
-//				searchNode, dos, 3);
-//
-//		// add the plugin.xml from a different project to the taskscape, should
-//		// have non null results, but 0 size
-//		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-//		helper.searchResultsNotNull(notifier, plugin2.getFullPath().toString(), PdeStructureBridge.CONTENT_TYPE,
-//				searchNode, dos, 0);
-//
-//		// add java element from the same project, should get result since we
-//		// are looking at the projects
-//		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-//		helper.searchResultsNotNull(notifier, type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE,
-//				searchNode, dos, 3);
-
-		// add a java element from a different project, should get non null
-		// result, but 0 size
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, type2.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 0);
-
-		// add the plugin.xml from the same project to the taskscape, should
-		// have results
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, plugin1.getFullPath().toString(), PdeStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 3);
-	}
-
-	public void testXMLSearchDOS3() throws IOException, CoreException {
-
-		int dos = 3;
-
-		CompositeContext t = (CompositeContext) MylarPlugin.getContextManager().getActiveContext();
-		ActiveSearchNotifier notifier = new ActiveSearchNotifier(t, SOURCE_ID);
-		IMylarElement searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-
-		//
-		// add an element to the taskscape, results should not be null
-		// There is a landmark with references in it, but not one that is an xml
-		// file that we care about
-		// therefore, we still only get 3 references
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, tocRefs.getFullPath().toString(), ResourceStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 3);
-		//
-		//
-
-		//
-		// add an element to the taskscape, results should still be null
-		// There is a landmark, but not one that is an xml file that we care
-		// about
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, tocNoRefs.getFullPath().toString(), ResourceStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 3);
-		//
-		//
-
-		//
-		// we should get all results since we are searching the entire workspace
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, searchNode, dos, 3);
-		//
-		//
-
-		//
-		// we should get 0 results since there should be no references to the
-		// type we are looking at
-		searchNode = notifier.getElement(type2.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, searchNode, dos, 0);
-		//
-		//
-	}
-
-	public void testXMLSearchDOS4() throws IOException, CoreException {
-		// right now, dos 3 and 4 are exactly the same, workspace scope
-
-		int dos = 4;
-
-		CompositeContext t = (CompositeContext) MylarPlugin.getContextManager().getActiveContext();
-		ActiveSearchNotifier notifier = new ActiveSearchNotifier(t, SOURCE_ID);
-		IMylarElement searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-
-		//
-		// add an element to the taskscape, results should not be null
-		// There is a landmark with references in it, but not one that is an xml
-		// file that we care about
-		// therefore, we still only get 3 references
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, tocRefs.getFullPath().toString(), ResourceStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 3);
-		//
-		//
-
-		//
-		// add an element to the taskscape, results should still be null
-		// There is a landmark, but not one that is an xml file that we care
-		// about
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, tocNoRefs.getFullPath().toString(), ResourceStructureBridge.CONTENT_TYPE,
-				searchNode, dos, 3);
-		//
-		//
-
-		//
-		// we should get all results since we are searching the entire workspace
-		searchNode = notifier.getElement(type1.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, searchNode, dos, 3);
-		//
-		//
-
-		//
-		// we should get 0 results since there should be no references to the
-		// type we are looking at
-		searchNode = notifier.getElement(type2.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE);
-		helper.searchResultsNotNull(notifier, searchNode, dos, 0);
-		//
-		//
-	}
-
-	public List<?> search(int dos, IMylarElement node) throws IOException, CoreException {
-		if (node == null)
-			return null;
-
-		// test with each of the sepatations
-		XmlReferencesProvider prov = new XmlReferencesProvider();
-
-		IMylarSearchOperation o = prov.getSearchOperation(node, 0, dos);
-		if (o == null)
-			return null;
-
-		XMLTestActiveSearchListener l = new XMLTestActiveSearchListener(prov);
-		SearchPluginTestHelper.search(o, l);
-
-		return l.getResults();
-	}
-}
diff --git a/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/XMLTestActiveSearchListener.java b/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/XMLTestActiveSearchListener.java
deleted file mode 100644
index ac46191..0000000
--- a/org.eclipse.mylyn.resources.tests/src/org/eclipse/mylyn/tests/xml/XMLTestActiveSearchListener.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004 - 2006 University Of British Columbia 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:
- *     University Of British Columbia - initial API and implementation
- *******************************************************************************/
-package org.eclipse.mylar.tests.xml;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.eclipse.core.internal.resources.File;
-import org.eclipse.mylar.core.tests.support.search.TestActiveSearchListener;
-import org.eclipse.mylar.internal.xml.XmlNodeHelper;
-import org.eclipse.mylar.provisional.core.AbstractRelationProvider;
-import org.eclipse.mylar.provisional.core.IMylarStructureBridge;
-import org.eclipse.mylar.provisional.core.MylarPlugin;
-import org.eclipse.search.internal.ui.text.FileSearchResult;
-import org.eclipse.search.ui.text.Match;
-
-public class XMLTestActiveSearchListener extends TestActiveSearchListener {
-
-	private List<?> results = null;
-
-	public XMLTestActiveSearchListener(AbstractRelationProvider prov) {
-		super(prov);
-	}
-
-	private boolean gathered = false;
-
-	@Override
-	public void searchCompleted(List<?> l) {
-
-		results = l;
-
-		// deal with File
-		if (l.isEmpty()) {
-			gathered = true;
-			return;
-		}
-
-		if (l.get(0) instanceof FileSearchResult) {
-			FileSearchResult fsr = (FileSearchResult) l.get(0);
-			List<Object> nodes = new ArrayList<Object>();
-			Object[] far = fsr.getElements();
-			for (int i = 0; i < far.length; i++) {
-				Match[] mar = fsr.getMatches(far[i]);
-
-				if (far[i] instanceof File) {
-					File f = (File) far[i];
-
-					for (int j = 0; j < mar.length; j++) {
-						Match m = mar[j];
-						try {
-
-							IMylarStructureBridge bridge = MylarPlugin.getDefault().getStructureBridge(f.getName());
-
-							String handle = bridge.getHandleForOffsetInObject(f, m.getOffset());
-
-							XmlNodeHelper node = new XmlNodeHelper(handle);
-							if (node != null) {
-								nodes.add(node);
-							}
-						} catch (Exception e) {
-							e.printStackTrace();
-							// don't care
-						}
-					}
-				}
-			}
-			results = nodes;
-		}
-		gathered = true;
-	}
-
-	@Override
-	public boolean resultsGathered() {
-		return gathered;
-	}
-
-	@Override
-	public List<?> getResults() {
-		return results;
-	}
-
-}
