diff --git a/org.eclipse.zest.examples.layouts/.settings/org.eclipse.jdt.core.prefs b/org.eclipse.zest.examples.layouts/.settings/org.eclipse.jdt.core.prefs index 62ef3488c..1efecd74b 100644 --- a/org.eclipse.zest.examples.layouts/.settings/org.eclipse.jdt.core.prefs +++ b/org.eclipse.zest.examples.layouts/.settings/org.eclipse.jdt.core.prefs @@ -1,9 +1,534 @@ eclipse.preferences.version=1 +org.eclipse.jdt.core.builder.annotationPath.allLocations=disabled +org.eclipse.jdt.core.compiler.annotation.inheritNullAnnotations=disabled +org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation=ignore +org.eclipse.jdt.core.compiler.annotation.nonnull=org.eclipse.jdt.annotation.NonNull +org.eclipse.jdt.core.compiler.annotation.nonnull.secondary= +org.eclipse.jdt.core.compiler.annotation.nonnullbydefault=org.eclipse.jdt.annotation.NonNullByDefault +org.eclipse.jdt.core.compiler.annotation.nonnullbydefault.secondary= +org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable +org.eclipse.jdt.core.compiler.annotation.nullable.secondary= +org.eclipse.jdt.core.compiler.annotation.nullanalysis=disabled +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate org.eclipse.jdt.core.compiler.codegen.targetPlatform=17 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve org.eclipse.jdt.core.compiler.compliance=17 +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.doc.comment.support=enabled +org.eclipse.jdt.core.compiler.problem.APILeak=warning +org.eclipse.jdt.core.compiler.problem.annotatedTypeArgumentToUnannotated=info +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.comparingIdentical=warning +org.eclipse.jdt.core.compiler.problem.deadCode=warning +org.eclipse.jdt.core.compiler.problem.deprecation=ignore +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.enablePreviewFeatures=disabled org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning +org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore +org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled +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.includeNullInfoFromAsserts=disabled +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.invalidJavadoc=warning +org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled +org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=disabled +org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=disabled +org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=protected +org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore +org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning +org.eclipse.jdt.core.compiler.problem.missingDefaultCase=ignore +org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=info +org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault=disabled +org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=ignore +org.eclipse.jdt.core.compiler.problem.missingJavadocComments=ignore +org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=enabled +org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=protected +org.eclipse.jdt.core.compiler.problem.missingJavadocTags=ignore +org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled +org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=protected +org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=warning +org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation=enabled +org.eclipse.jdt.core.compiler.problem.missingSerialVersion=ignore +org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod=ignore +org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning +org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning +org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=warning +org.eclipse.jdt.core.compiler.problem.nonnullParameterAnnotationDropped=warning +org.eclipse.jdt.core.compiler.problem.nonnullTypeVariableFromLegacyInvocation=warning +org.eclipse.jdt.core.compiler.problem.nullAnnotationInferenceConflict=error +org.eclipse.jdt.core.compiler.problem.nullReference=warning +org.eclipse.jdt.core.compiler.problem.nullSpecViolation=error +org.eclipse.jdt.core.compiler.problem.nullUncheckedConversion=warning +org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning +org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore +org.eclipse.jdt.core.compiler.problem.pessimisticNullAnalysisForFreeTypeVariables=warning +org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=warning +org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore +org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable=ignore +org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning +org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning +org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore +org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=ignore +org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=ignore +org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=warning +org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=warning org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled +org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning +org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors=disabled +org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled +org.eclipse.jdt.core.compiler.problem.suppressWarningsNotFullyAnalysed=info +org.eclipse.jdt.core.compiler.problem.syntacticNullAnalysisForFields=disabled +org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore +org.eclipse.jdt.core.compiler.problem.terminalDeprecation=warning +org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning +org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems=enabled +org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning +org.eclipse.jdt.core.compiler.problem.unclosedCloseable=warning +org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore +org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning +org.eclipse.jdt.core.compiler.problem.unlikelyCollectionMethodArgumentType=warning +org.eclipse.jdt.core.compiler.problem.unlikelyCollectionMethodArgumentTypeStrict=disabled +org.eclipse.jdt.core.compiler.problem.unlikelyEqualsArgumentType=info +org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore +org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=warning +org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore +org.eclipse.jdt.core.compiler.problem.unstableAutoModuleName=warning +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=warning +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled +org.eclipse.jdt.core.compiler.problem.unusedExceptionParameter=ignore +org.eclipse.jdt.core.compiler.problem.unusedImport=warning +org.eclipse.jdt.core.compiler.problem.unusedLabel=warning +org.eclipse.jdt.core.compiler.problem.unusedLocal=warning +org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation=ignore +org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore +org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled +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.unusedTypeParameter=ignore +org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning +org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning org.eclipse.jdt.core.compiler.release=enabled org.eclipse.jdt.core.compiler.source=17 +org.eclipse.jdt.core.formatter.align_assignment_statements_on_columns=false +org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines=2147483647 +org.eclipse.jdt.core.formatter.align_selector_in_method_invocation_on_expression_first_line=true +org.eclipse.jdt.core.formatter.align_type_members_on_columns=false +org.eclipse.jdt.core.formatter.align_variable_declarations_on_columns=false +org.eclipse.jdt.core.formatter.align_with_spaces=false +org.eclipse.jdt.core.formatter.alignment_for_additive_operator=16 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_enum_constant=49 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_field=49 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_local_variable=49 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_method=49 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_package=49 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_parameter=0 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_type=49 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_assertion_message=16 +org.eclipse.jdt.core.formatter.alignment_for_assignment=0 +org.eclipse.jdt.core.formatter.alignment_for_bitwise_operator=16 +org.eclipse.jdt.core.formatter.alignment_for_compact_if=16 +org.eclipse.jdt.core.formatter.alignment_for_compact_loops=16 +org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80 +org.eclipse.jdt.core.formatter.alignment_for_conditional_expression_chain=0 +org.eclipse.jdt.core.formatter.alignment_for_enum_constants=16 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_for_loop_header=0 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_switch_case_with_arrow=16 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_switch_case_with_colon=16 +org.eclipse.jdt.core.formatter.alignment_for_logical_operator=16 +org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0 +org.eclipse.jdt.core.formatter.alignment_for_module_statements=16 +org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16 +org.eclipse.jdt.core.formatter.alignment_for_multiplicative_operator=16 +org.eclipse.jdt.core.formatter.alignment_for_parameterized_type_references=0 +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_permitted_types_in_type_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_record_components=16 +org.eclipse.jdt.core.formatter.alignment_for_relational_operator=0 +org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=80 +org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16 +org.eclipse.jdt.core.formatter.alignment_for_shift_operator=0 +org.eclipse.jdt.core.formatter.alignment_for_string_concatenation=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_record_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_switch_case_with_arrow=20 +org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_type_annotations=0 +org.eclipse.jdt.core.formatter.alignment_for_type_arguments=0 +org.eclipse.jdt.core.formatter.alignment_for_type_parameters=0 +org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16 +org.eclipse.jdt.core.formatter.blank_lines_after_imports=1 +org.eclipse.jdt.core.formatter.blank_lines_after_last_class_body_declaration=0 +org.eclipse.jdt.core.formatter.blank_lines_after_package=1 +org.eclipse.jdt.core.formatter.blank_lines_before_abstract_method=1 +org.eclipse.jdt.core.formatter.blank_lines_before_field=0 +org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0 +org.eclipse.jdt.core.formatter.blank_lines_before_imports=1 +org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1 +org.eclipse.jdt.core.formatter.blank_lines_before_method=1 +org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1 +org.eclipse.jdt.core.formatter.blank_lines_before_package=0 +org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1 +org.eclipse.jdt.core.formatter.blank_lines_between_statement_group_in_switch=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_lambda_body=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_record_constructor=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_record_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.align_tags_descriptions_grouped=true +org.eclipse.jdt.core.formatter.comment.align_tags_names_descriptions=false +org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false +org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false +org.eclipse.jdt.core.formatter.comment.count_line_length_from_starting_position=true +org.eclipse.jdt.core.formatter.comment.format_block_comments=true +org.eclipse.jdt.core.formatter.comment.format_header=false +org.eclipse.jdt.core.formatter.comment.format_html=true +org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true +org.eclipse.jdt.core.formatter.comment.format_line_comments=true +org.eclipse.jdt.core.formatter.comment.format_source_code=true +org.eclipse.jdt.core.formatter.comment.indent_parameter_description=false +org.eclipse.jdt.core.formatter.comment.indent_root_tags=false +org.eclipse.jdt.core.formatter.comment.indent_tag_description=false +org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert +org.eclipse.jdt.core.formatter.comment.insert_new_line_between_different_tags=do not insert +org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=do not insert +org.eclipse.jdt.core.formatter.comment.javadoc_do_not_separate_block_tags=false +org.eclipse.jdt.core.formatter.comment.line_length=80 +org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true +org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true +org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments=false +org.eclipse.jdt.core.formatter.compact_else_if=true +org.eclipse.jdt.core.formatter.continuation_indentation=2 +org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2 +org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off +org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on +org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false +org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=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_record_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true +org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true +org.eclipse.jdt.core.formatter.indent_empty_lines=false +org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true +org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true +org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true +org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=false +org.eclipse.jdt.core.formatter.indentation.size=4 +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_enum_constant=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_after_additive_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert +org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_case=insert +org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_default=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_bitwise_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=do not 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_permitted_types=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_record_components=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_switch_case_expressions=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert +org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow=insert +org.eclipse.jdt.core.formatter.insert_space_after_logical_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_multiplicative_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_not_operator=do not 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_record_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_relational_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources=insert +org.eclipse.jdt.core.formatter.insert_space_after_shift_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_string_concatenation=insert +org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_additive_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert +org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_case=insert +org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_default=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_bitwise_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_record_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_permitted_types=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_record_components=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_switch_case_expressions=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow=insert +org.eclipse.jdt.core.formatter.insert_space_before_logical_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_multiplicative_operator=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_record_constructor=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_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_record_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert +org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert +org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert +org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_relational_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_shift_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_string_concatenation=insert +org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.join_lines_in_comments=true +org.eclipse.jdt.core.formatter.join_wrapped_lines=true +org.eclipse.jdt.core.formatter.keep_annotation_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_anonymous_type_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_code_block_on_one_line=one_line_never +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_enum_constant_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_enum_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_if_then_body_block_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false +org.eclipse.jdt.core.formatter.keep_lambda_body_block_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_loop_body_block_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_method_body_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_record_constructor_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_record_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_simple_do_while_body_on_same_line=false +org.eclipse.jdt.core.formatter.keep_simple_for_body_on_same_line=false +org.eclipse.jdt.core.formatter.keep_simple_getter_setter_on_one_line=false +org.eclipse.jdt.core.formatter.keep_simple_while_body_on_same_line=false +org.eclipse.jdt.core.formatter.keep_switch_body_block_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_switch_case_with_arrow_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false +org.eclipse.jdt.core.formatter.keep_type_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.lineSplit=120 +org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false +org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false +org.eclipse.jdt.core.formatter.number_of_blank_lines_after_code_block=0 +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_code_block=0 +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0 +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_code_block=0 +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_method_body=0 +org.eclipse.jdt.core.formatter.number_of_blank_lines_before_code_block=0 +org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1 +org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_catch_clause=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_enum_constant_declaration=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_for_statment=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_if_while_statement=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_lambda_declaration=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_method_delcaration=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_record_declaration=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_switch_statement=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_try_clause=common_lines +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.text_block_indentation=0 +org.eclipse.jdt.core.formatter.use_on_off_tags=true +org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false +org.eclipse.jdt.core.formatter.wrap_before_additive_operator=true +org.eclipse.jdt.core.formatter.wrap_before_assertion_message_operator=true +org.eclipse.jdt.core.formatter.wrap_before_assignment_operator=false +org.eclipse.jdt.core.formatter.wrap_before_bitwise_operator=true +org.eclipse.jdt.core.formatter.wrap_before_conditional_operator=true +org.eclipse.jdt.core.formatter.wrap_before_logical_operator=true +org.eclipse.jdt.core.formatter.wrap_before_multiplicative_operator=true +org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true +org.eclipse.jdt.core.formatter.wrap_before_relational_operator=true +org.eclipse.jdt.core.formatter.wrap_before_shift_operator=true +org.eclipse.jdt.core.formatter.wrap_before_string_concatenation=true +org.eclipse.jdt.core.formatter.wrap_before_switch_case_arrow_operator=false +org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true +org.eclipse.jdt.core.javaFormatter=org.eclipse.jdt.core.defaultJavaFormatter diff --git a/org.eclipse.zest.examples.layouts/.settings/org.eclipse.jdt.ui.prefs b/org.eclipse.zest.examples.layouts/.settings/org.eclipse.jdt.ui.prefs new file mode 100644 index 000000000..6c3baf9ca --- /dev/null +++ b/org.eclipse.zest.examples.layouts/.settings/org.eclipse.jdt.ui.prefs @@ -0,0 +1,154 @@ +eclipse.preferences.version=1 +editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true +formatter_profile=org.eclipse.jdt.ui.default.eclipse_profile +formatter_settings_version=23 +internal.default.compliance=default +org.eclipse.jdt.ui.ignorelowercasenames=true +org.eclipse.jdt.ui.importorder=java;org.eclipse.swt;org.eclipse;org.eclipse.draw2d;org.eclipse.gef;org.eclipse.gef.examples; +org.eclipse.jdt.ui.javadoc=false +org.eclipse.jdt.ui.ondemandthreshold=999 +org.eclipse.jdt.ui.staticondemandthreshold=99 +org.eclipse.jdt.ui.text.custom_code_templates= +sp_cleanup.add_all=true +sp_cleanup.add_default_serial_version_id=true +sp_cleanup.add_generated_serial_version_id=false +sp_cleanup.add_missing_annotations=true +sp_cleanup.add_missing_deprecated_annotations=true +sp_cleanup.add_missing_methods=false +sp_cleanup.add_missing_nls_tags=false +sp_cleanup.add_missing_override_annotations=true +sp_cleanup.add_missing_override_annotations_interface_methods=true +sp_cleanup.add_serial_version_id=false +sp_cleanup.also_simplify_lambda=false +sp_cleanup.always_use_blocks=true +sp_cleanup.always_use_parentheses_in_expressions=false +sp_cleanup.always_use_this_for_non_static_field_access=false +sp_cleanup.always_use_this_for_non_static_method_access=false +sp_cleanup.array_with_curly=true +sp_cleanup.arrays_fill=false +sp_cleanup.bitwise_conditional_expression=false +sp_cleanup.boolean_literal=true +sp_cleanup.boolean_value_rather_than_comparison=false +sp_cleanup.break_loop=false +sp_cleanup.collection_cloning=true +sp_cleanup.comparing_on_criteria=true +sp_cleanup.comparison_statement=false +sp_cleanup.controlflow_merge=false +sp_cleanup.convert_functional_interfaces=true +sp_cleanup.convert_to_enhanced_for_loop=true +sp_cleanup.convert_to_enhanced_for_loop_if_loop_var_used=false +sp_cleanup.convert_to_switch_expressions=true +sp_cleanup.correct_indentation=true +sp_cleanup.do_while_rather_than_while=false +sp_cleanup.double_negation=false +sp_cleanup.else_if=false +sp_cleanup.embedded_if=false +sp_cleanup.evaluate_nullable=true +sp_cleanup.extract_increment=true +sp_cleanup.format_source_code=true +sp_cleanup.format_source_code_changes_only=false +sp_cleanup.hash=false +sp_cleanup.if_condition=false +sp_cleanup.insert_inferred_type_arguments=false +sp_cleanup.instanceof=true +sp_cleanup.instanceof_keyword=false +sp_cleanup.invert_equals=false +sp_cleanup.join=true +sp_cleanup.lazy_logical_operator=false +sp_cleanup.make_local_variable_final=false +sp_cleanup.make_parameters_final=false +sp_cleanup.make_private_fields_final=true +sp_cleanup.make_type_abstract_if_missing_method=false +sp_cleanup.make_variable_declarations_final=true +sp_cleanup.map_cloning=false +sp_cleanup.merge_conditional_blocks=false +sp_cleanup.multi_catch=false +sp_cleanup.never_use_blocks=false +sp_cleanup.never_use_parentheses_in_expressions=true +sp_cleanup.no_string_creation=true +sp_cleanup.no_super=true +sp_cleanup.number_suffix=false +sp_cleanup.objects_equals=false +sp_cleanup.on_save_use_additional_actions=true +sp_cleanup.one_if_rather_than_duplicate_blocks_that_fall_through=false +sp_cleanup.operand_factorization=false +sp_cleanup.organize_imports=true +sp_cleanup.overridden_assignment=false +sp_cleanup.overridden_assignment_move_decl=false +sp_cleanup.plain_replacement=false +sp_cleanup.precompile_regex=false +sp_cleanup.primitive_comparison=false +sp_cleanup.primitive_parsing=false +sp_cleanup.primitive_rather_than_wrapper=false +sp_cleanup.primitive_serialization=false +sp_cleanup.pull_out_if_from_if_else=false +sp_cleanup.pull_up_assignment=true +sp_cleanup.push_down_negation=false +sp_cleanup.qualify_static_field_accesses_with_declaring_class=false +sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true +sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true +sp_cleanup.qualify_static_member_accesses_with_declaring_class=false +sp_cleanup.qualify_static_method_accesses_with_declaring_class=false +sp_cleanup.reduce_indentation=true +sp_cleanup.redundant_comparator=false +sp_cleanup.redundant_falling_through_block_end=false +sp_cleanup.remove_private_constructors=true +sp_cleanup.remove_redundant_modifiers=false +sp_cleanup.remove_redundant_semicolons=true +sp_cleanup.remove_redundant_type_arguments=true +sp_cleanup.remove_trailing_whitespaces=true +sp_cleanup.remove_trailing_whitespaces_all=true +sp_cleanup.remove_trailing_whitespaces_ignore_empty=false +sp_cleanup.remove_unnecessary_array_creation=true +sp_cleanup.remove_unnecessary_casts=true +sp_cleanup.remove_unnecessary_nls_tags=false +sp_cleanup.remove_unused_imports=true +sp_cleanup.remove_unused_local_variables=false +sp_cleanup.remove_unused_method_parameters=false +sp_cleanup.remove_unused_private_fields=true +sp_cleanup.remove_unused_private_members=false +sp_cleanup.remove_unused_private_methods=true +sp_cleanup.remove_unused_private_types=true +sp_cleanup.replace_deprecated_calls=false +sp_cleanup.return_expression=true +sp_cleanup.simplify_lambda_expression_and_method_ref=true +sp_cleanup.single_used_field=false +sp_cleanup.sort_members=false +sp_cleanup.sort_members_all=false +sp_cleanup.standard_comparison=false +sp_cleanup.static_inner_class=false +sp_cleanup.strictly_equal_or_different=false +sp_cleanup.stringbuffer_to_stringbuilder=false +sp_cleanup.stringbuilder=false +sp_cleanup.stringbuilder_for_local_vars=false +sp_cleanup.stringconcat_stringbuffer_stringbuilder=false +sp_cleanup.stringconcat_to_textblock=true +sp_cleanup.substring=false +sp_cleanup.switch=true +sp_cleanup.system_property=false +sp_cleanup.system_property_boolean=false +sp_cleanup.system_property_file_encoding=false +sp_cleanup.system_property_file_separator=false +sp_cleanup.system_property_line_separator=false +sp_cleanup.system_property_path_separator=false +sp_cleanup.ternary_operator=false +sp_cleanup.try_with_resource=false +sp_cleanup.unlooped_while=false +sp_cleanup.unreachable_block=false +sp_cleanup.use_anonymous_class_creation=false +sp_cleanup.use_autoboxing=false +sp_cleanup.use_blocks=true +sp_cleanup.use_blocks_only_for_return_and_throw=false +sp_cleanup.use_directly_map_method=true +sp_cleanup.use_lambda=true +sp_cleanup.use_parentheses_in_expressions=false +sp_cleanup.use_string_is_blank=false +sp_cleanup.use_this_for_non_static_field_access=false +sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=true +sp_cleanup.use_this_for_non_static_method_access=false +sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=true +sp_cleanup.use_unboxing=false +sp_cleanup.use_var=false +sp_cleanup.useless_continue=true +sp_cleanup.useless_return=true +sp_cleanup.valueof_rather_than_instantiation=true diff --git a/org.eclipse.zest.examples.layouts/META-INF/MANIFEST.MF b/org.eclipse.zest.examples.layouts/META-INF/MANIFEST.MF index 128519257..85783c60f 100644 --- a/org.eclipse.zest.examples.layouts/META-INF/MANIFEST.MF +++ b/org.eclipse.zest.examples.layouts/META-INF/MANIFEST.MF @@ -10,6 +10,7 @@ Bundle-ActivationPolicy: lazy Bundle-RequiredExecutionEnvironment: JavaSE-17 Export-Package: org.eclipse.zest.layouts.exampleStructures;x-internal:=true, org.eclipse.zest.layouts.exampleUses;x-internal:=true -Require-Bundle: org.eclipse.zest.layouts;bundle-version="2.0.0", +Require-Bundle: org.eclipse.zest.core;bundle-version="1.14.0", + org.eclipse.zest.layouts;bundle-version="2.0.0", org.eclipse.jface;bundle-version="3.35.0", org.eclipse.core.runtime;bundle-version="3.31.100" diff --git a/org.eclipse.zest.examples.layouts/build.properties b/org.eclipse.zest.examples.layouts/build.properties index 34d2e4d2d..aa1a00826 100644 --- a/org.eclipse.zest.examples.layouts/build.properties +++ b/org.eclipse.zest.examples.layouts/build.properties @@ -1,4 +1,5 @@ source.. = src/ output.. = bin/ bin.includes = META-INF/,\ - . + .,\ + plugin.properties diff --git a/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleFilter.java b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleFilter.java index 8b38d6baf..2b2f3c1b1 100644 --- a/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleFilter.java +++ b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleFilter.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright 2005 CHISEL Group, University of Victoria, Victoria, BC, + * Copyright 2005, 2024 CHISEL Group, University of Victoria, Victoria, BC, * Canada. * * This program and the accompanying materials are made available under the @@ -12,21 +12,21 @@ *******************************************************************************/ package org.eclipse.zest.layouts.exampleStructures; -import org.eclipse.zest.layouts.Filter; -import org.eclipse.zest.layouts.LayoutItem; +import org.eclipse.zest.core.widgets.GraphItem; +import org.eclipse.zest.core.widgets.LayoutFilter; /** * A very simple example of a filter. This filter never filters any object. * * @author Casey Best */ -public class SimpleFilter implements Filter { +public class SimpleFilter implements LayoutFilter { /** * Doesn't filter anything */ @Override - public boolean isObjectFiltered(LayoutItem object) { + public boolean isObjectFiltered(GraphItem item) { return false; } } diff --git a/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleGraph.java b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleGraph.java index 456a0ed76..294606bf1 100644 --- a/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleGraph.java +++ b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleGraph.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright 2005 CHISEL Group, University of Victoria, Victoria, BC, + * Copyright 2005, 2024 CHISEL Group, University of Victoria, Victoria, BC, * Canada. * * This program and the accompanying materials are made available under the @@ -13,14 +13,23 @@ package org.eclipse.zest.layouts.exampleStructures; import java.util.ArrayList; -import java.util.HashMap; -import java.util.Iterator; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; -import org.eclipse.zest.layouts.LayoutEntity; -import org.eclipse.zest.layouts.LayoutGraph; -import org.eclipse.zest.layouts.LayoutRelationship; +import org.eclipse.zest.layouts.LayoutAlgorithm; +import org.eclipse.zest.layouts.dataStructures.DisplayIndependentRectangle; +import org.eclipse.zest.layouts.interfaces.ContextListener; +import org.eclipse.zest.layouts.interfaces.EntityLayout; +import org.eclipse.zest.layouts.interfaces.ExpandCollapseManager; +import org.eclipse.zest.layouts.interfaces.GraphStructureListener; +import org.eclipse.zest.layouts.interfaces.LayoutContext; +import org.eclipse.zest.layouts.interfaces.LayoutListener; +import org.eclipse.zest.layouts.interfaces.NodeLayout; +import org.eclipse.zest.layouts.interfaces.PruningListener; +import org.eclipse.zest.layouts.interfaces.SubgraphLayout; + +import org.eclipse.draw2d.EventListenerList; /** * Create a very simple graph that can be used in the layout algorithms @@ -28,14 +37,20 @@ * @author Casey Best * @author Chris Callendar */ -public class SimpleGraph implements LayoutGraph { +public class SimpleGraph implements LayoutContext { - Map objectsToNodes; - List relationships; + Map objectsToNodes; + List relationships; + LayoutAlgorithm algorithm; + ExpandCollapseManager expandCollapseManager; + EventListenerList listeners; + DisplayIndependentRectangle bounds; public SimpleGraph() { - objectsToNodes = new HashMap(); - relationships = new ArrayList(); + objectsToNodes = new LinkedHashMap<>(); + relationships = new ArrayList<>(); + listeners = new EventListenerList(); + bounds = new DisplayIndependentRectangle(); } /** @@ -43,24 +58,15 @@ public SimpleGraph() { * * @param node The node to add. */ - @Override - public void addEntity(LayoutEntity node) { - if (node instanceof SimpleNode) { - objectsToNodes.put(((SimpleNode) node).getRealObject(), node); - } + public void addEntity(SimpleNode node) { + objectsToNodes.put(node.getRealObject(), node); } /** * Creates a LayoutEntity containing an object. */ - public LayoutEntity addObjectNode(Object object) { - SimpleNode simpleNode = (SimpleNode) objectsToNodes.get(object); - if (simpleNode == null) { - simpleNode = new SimpleNode(object); - objectsToNodes.put(object, simpleNode); - } - return simpleNode; - + public SimpleNode addObjectNode(Object object) { + return objectsToNodes.computeIfAbsent(object, ignore -> new SimpleNode(object, this)); } /** @@ -68,7 +74,7 @@ public LayoutEntity addObjectNode(Object object) { * whether a relationship is one way or bi-directional. This method assumes that * all relationships are bi-direcional and have the same weight. */ - public void addObjectRelationship(Object sourceNode, Object destinationNode) { + public void addObjectRelationship(SimpleNode sourceNode, SimpleNode destinationNode) { addObjectRelationship(sourceNode, destinationNode, true, 1); } @@ -80,44 +86,25 @@ public void addObjectRelationship(Object sourceObject, Object destinationObject, int weight) { addObjectNode(sourceObject); addObjectNode(destinationObject); - SimpleNode sourceNode = (SimpleNode) objectsToNodes.get(sourceObject); - SimpleNode destinationNode = (SimpleNode) objectsToNodes.get(destinationObject); + SimpleNode sourceNode = objectsToNodes.get(sourceObject); + SimpleNode destinationNode = objectsToNodes.get(destinationObject); SimpleRelationship simpleRelationship = new SimpleRelationship(sourceNode, destinationNode, bidirectional, weight); relationships.add(simpleRelationship); } - /* - * (non-Javadoc) - * - * @see ca.uvic.cs.chisel.layouts.LayoutGraph#addRelationship(ca.uvic.cs.chisel. - * layouts.LayoutEntity, ca.uvic.cs.chisel.layouts.LayoutEntity) - */ - public void addRelationship(LayoutEntity srcNode, LayoutEntity destNode) { + public void addRelationship(SimpleNode srcNode, SimpleNode destNode) { addRelationship(srcNode, destNode, true, 1); } - /* - * (non-Javadoc) - * - * @see ca.uvic.cs.chisel.layouts.LayoutGraph#addRelationship(ca.uvic.cs.chisel. - * layouts.LayoutEntity, ca.uvic.cs.chisel.layouts.LayoutEntity, boolean, int) - */ - public void addRelationship(LayoutEntity srcNode, LayoutEntity destNode, boolean bidirectional, int weight) { + public void addRelationship(SimpleNode srcNode, SimpleNode destNode, boolean bidirectional, int weight) { addEntity(srcNode); addEntity(destNode); SimpleRelationship rel = new SimpleRelationship(srcNode, destNode, bidirectional, weight); relationships.add(rel); } - /* - * (non-Javadoc) - * - * @see ca.uvic.cs.chisel.layouts.LayoutGraph#addRelationship(ca.uvic.cs.chisel. - * layouts.LayoutRelationship) - */ - @Override - public void addRelationship(LayoutRelationship relationship) { + public void addRelationship(SimpleRelationship relationship) { relationships.add(relationship); } @@ -127,8 +114,8 @@ public void addRelationship(LayoutRelationship relationship) { * SimpleNodes, not the real objects. You must still manipulate them yourself. */ @Override - public List getEntities() { - return new ArrayList(objectsToNodes.values()); + public SimpleNode[] getNodes() { + return objectsToNodes.values().toArray(SimpleNode[]::new); } /** @@ -136,25 +123,124 @@ public List getEntities() { * this graph using addRelationship. */ @Override - public List getRelationships() { - return relationships; + public SimpleRelationship[] getConnections() { + return relationships.toArray(SimpleRelationship[]::new); } - /** - * Checks the relationships to see if they are all bidirectional. - * - * @return boolean if all edges are bidirectional. - */ @Override - public boolean isBidirectional() { - boolean isBidirectional = true; - for (Iterator iter = relationships.iterator(); iter.hasNext();) { - SimpleRelationship rel = (SimpleRelationship) iter.next(); - if (!rel.isBidirectionalInLayout()) { - isBidirectional = false; - break; + public SimpleRelationship[] getConnections(EntityLayout layoutEntity1, EntityLayout layoutEntity2) { + List relationships = new ArrayList<>(); + for (SimpleRelationship relationship : this.relationships) { + if (relationship.getSource() == layoutEntity1 && relationship.getTarget() == layoutEntity2) { + relationships.add(relationship); } } - return isBidirectional; + return relationships.toArray(SimpleRelationship[]::new); + } + + public void setBounds(double x, double y, double width, double height) { + bounds.x = x; + bounds.y = y; + bounds.width = width; + bounds.height = height; + } + + @Override + public DisplayIndependentRectangle getBounds() { + return bounds; + } + + @Override + public boolean isBoundsExpandable() { + return false; + } + + @Override + public SubgraphLayout[] getSubgraphs() { + return new SubgraphLayout[0]; + } + + @Override + public SubgraphLayout createSubgraph(NodeLayout[] nodes) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean isPruningEnabled() { + return false; + } + + @Override + public boolean isBackgroundLayoutEnabled() { + return false; + } + + @Override + public void flushChanges(boolean animationHint) { + } + + @Override + public void setMainLayoutAlgorithm(LayoutAlgorithm algorithm) { + this.algorithm = algorithm; + } + + @Override + public LayoutAlgorithm getMainLayoutAlgorithm() { + return algorithm; + } + + @Override + public void setExpandCollapseManager(ExpandCollapseManager expandCollapseManager) { + this.expandCollapseManager = expandCollapseManager; + } + + @Override + public ExpandCollapseManager getExpandCollapseManager() { + return expandCollapseManager; + } + + @Override + public void addLayoutListener(LayoutListener listener) { + listeners.addListener(LayoutListener.class, listener); + } + + @Override + public void removeLayoutListener(LayoutListener listener) { + listeners.removeListener(LayoutListener.class, listener); + } + + @Override + public void addGraphStructureListener(GraphStructureListener listener) { + listeners.addListener(GraphStructureListener.class, listener); + } + + @Override + public void removeGraphStructureListener(GraphStructureListener listener) { + listeners.removeListener(GraphStructureListener.class, listener); + } + + @Override + public void addContextListener(ContextListener listener) { + listeners.addListener(ContextListener.class, listener); + } + + @Override + public void removeContextListener(ContextListener listener) { + listeners.removeListener(ContextListener.class, listener); + } + + @Override + public void addPruningListener(PruningListener listener) { + listeners.addListener(PruningListener.class, listener); + } + + @Override + public void removePruningListener(PruningListener listener) { + listeners.removeListener(PruningListener.class, listener); + } + + @Override + public SimpleNode[] getEntities() { + return getNodes(); } } diff --git a/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleNode.java b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleNode.java index 46f5180ba..6cfdee512 100644 --- a/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleNode.java +++ b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleNode.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright 2005 CHISEL Group, University of Victoria, Victoria, BC, + * Copyright 2005, 2024 CHISEL Group, University of Victoria, Victoria, BC, * Canada. * * This program and the accompanying materials are made available under the @@ -12,18 +12,16 @@ *******************************************************************************/ package org.eclipse.zest.layouts.exampleStructures; -import java.util.Comparator; -import java.util.HashMap; +import java.util.ArrayList; import java.util.LinkedList; import java.util.List; -import java.util.Map; -import java.util.TreeSet; -import org.eclipse.zest.layouts.LayoutEntity; -import org.eclipse.zest.layouts.constraints.BasicEntityConstraint; -import org.eclipse.zest.layouts.constraints.EntityPriorityConstraint; -import org.eclipse.zest.layouts.constraints.LabelLayoutConstraint; -import org.eclipse.zest.layouts.constraints.LayoutConstraint; +import org.eclipse.swt.widgets.Item; + +import org.eclipse.zest.layouts.dataStructures.DisplayIndependentDimension; +import org.eclipse.zest.layouts.dataStructures.DisplayIndependentPoint; +import org.eclipse.zest.layouts.interfaces.NodeLayout; +import org.eclipse.zest.layouts.interfaces.SubgraphLayout; /** * Rerpresents a simple node that can be used in the layout algorithms. @@ -32,7 +30,7 @@ * @author Casey Best (Version 1 by Rob Lintern) * @version 2 */ -public class SimpleNode implements LayoutEntity { +public class SimpleNode implements NodeLayout { private static Object NODE_NORMAL_COLOR; private static Object NODE_SELECTED_COLOR; private static Object NODE_ADJACENT_COLOR; @@ -43,12 +41,8 @@ public class SimpleNode implements LayoutEntity { private static final int BORDER_NORMAL_STROKE = 1; private static final int BORDER_STROKE_SELECTED = 2; - /** - * A list of layout dependent attributes - */ - private Map attributes; - - protected double x, y, width, height; + protected DisplayIndependentPoint location; + protected DisplayIndependentDimension size; protected Object realObject; private boolean ignoreInLayout = false; @@ -56,37 +50,18 @@ public class SimpleNode implements LayoutEntity { private Object borderColor = null; private int borderWidth; - private TreeSet listOfRels = null; - - private Object internalNode; + private final SimpleGraph graph; + private boolean minimized; /** * Constructs a new SimpleNode. */ - public SimpleNode(Object realObject) { - this(realObject, -1, -1, 110, 110); - } - - class UniqueCompare implements Comparator { - @Override - public int compare(Object o1, Object o2) { - // TODO this may not always be a unique comparison - return o1.toString().compareTo(o2.toString()); - } - } - - /** - * Constructs a new SimpleNode. - */ - public SimpleNode(Object realObject, double x, double y, double width, double height) { + public SimpleNode(Object realObject, SimpleGraph graph) { this.realObject = realObject; - this.x = x; - this.y = y; - this.width = width; - this.height = height; - this.attributes = new HashMap(); + this.graph = graph; + location = new DisplayIndependentPoint(-1, -1); + size = new DisplayIndependentDimension(110, 110); this.borderWidth = BORDER_NORMAL_STROKE; - listOfRels = new TreeSet(new UniqueCompare()); this.colour = NODE_NORMAL_COLOR; this.borderColor = BORDER_NORMAL_COLOR; } @@ -101,31 +76,15 @@ public static void setNodeColors(Object nodeNormalColor, Object borderNormalColo BORDER_ADJACENT_COLOR = borderAdjacentColor; } - public void addRelationship(SimpleRelationship rel) { - listOfRels.add(rel); - } - - public SimpleRelationship[] getRelationships() { - int size = listOfRels.size(); - return (SimpleRelationship[]) this.listOfRels.toArray(new SimpleRelationship[size]); - } - - public List getRelatedEntities() { - int size = listOfRels.size(); - SimpleRelationship[] a_listOfRels = (SimpleRelationship[]) this.listOfRels - .toArray(new SimpleRelationship[size]); - LinkedList listOfRelatedEntities = new LinkedList(); - for (SimpleRelationship rel : a_listOfRels) { - if (rel.sourceEntity != this && rel.destinationEntity != this) { - throw new RuntimeException("Problem, we have a relationship and we are not the source or the dest"); + public List getRelatedEntities() { + List listOfRelatedEntities = new LinkedList<>(); + for (SimpleRelationship rel : graph.getConnections()) { + if (rel.getSource() != this) { + listOfRelatedEntities.add(rel.getSource()); } - if (rel.sourceEntity != this) { - listOfRelatedEntities.add(rel.sourceEntity); + if (rel.getTarget() != this) { + listOfRelatedEntities.add(rel.getTarget()); } - if (rel.destinationEntity != this) { - listOfRelatedEntities.add(rel.destinationEntity); - } - } return listOfRelatedEntities; } @@ -143,73 +102,58 @@ public Object getRealObject() { return realObject; } - public boolean hasPreferredLocation() { - return this.ignoreInLayout; - } - /** * Gets the x position of this SimpleNode. */ public double getX() { - return x; + return getLocation().x; } /** * Gets the y position of this SimpleNode. */ public double getY() { - return y; + return getLocation().y; } /** * Get the size of this node */ public double getWidth() { - return width; + return getSize().width; } /** * Get the size of this node */ public double getHeight() { - return height; + return getSize().height; } @Override - public void setSizeInLayout(double width, double height) { - if (!ignoreInLayout) { - this.width = width; - this.height = height; - } - } - - public void setLocation(double x, double y) { - this.x = x; - this.y = y; + public DisplayIndependentDimension getSize() { + return size; } @Override - public void setLocationInLayout(double x, double y) { + public void setSize(double width, double height) { if (!ignoreInLayout) { - this.x = x; - this.y = y; + this.size.width = width; + this.size.height = height; } } - /** - * An algorithm may require a place to store information. Use this structure for - * that purpose. - */ - public void setAttributeInLayout(Object attribute, Object value) { - attributes.put(attribute, value); + @Override + public DisplayIndependentPoint getLocation() { + return location; } - /** - * An algorithm may require a place to store information. Use this structure for - * that purpose. - */ - public Object getAttributeInLayout(Object attribute) { - return attributes.get(attribute); + @Override + public void setLocation(double x, double y) { + if (!ignoreInLayout) { + this.location.x = x; + this.location.y = y; + } } @Override @@ -226,12 +170,6 @@ public int hashCode() { return realObject.hashCode(); } - // all objects are equal - @Override - public int compareTo(Object arg0) { - return 0; - } - @Override public String toString() { return realObject.toString(); @@ -267,70 +205,106 @@ public Object getBorderColor() { return borderColor; } - /* - * (non-Javadoc) - * - * @see ca.uvic.cs.chisel.layouts.LayoutEntity#getInternalEntity() - */ @Override - public Object getLayoutInformation() { - return internalNode; + public double getPreferredAspectRatio() { + return 0; } - /* - * (non-Javadoc) - * - * @see - * ca.uvic.cs.chisel.layouts.LayoutEntity#setInternalEntity(java.lang.Object) - */ @Override - public void setLayoutInformation(Object internalEntity) { - this.internalNode = internalEntity; + public boolean isResizable() { + return true; } - /** - * Populate the specified layout constraint - */ @Override - public void populateLayoutConstraint(LayoutConstraint constraint) { - if (constraint instanceof LabelLayoutConstraint labelConstraint) { - labelConstraint.label = realObject.toString(); - labelConstraint.pointSize = 18; - } else if (constraint instanceof BasicEntityConstraint) { - // noop - } else if (constraint instanceof EntityPriorityConstraint priorityConstraint) { - priorityConstraint.priority = Math.random() * 10 + 1; - } + public boolean isMovable() { + return true; } @Override - public double getHeightInLayout() { - return this.height; + public SimpleNode[] getSuccessingEntities() { + return getSuccessingNodes(); } @Override - public double getWidthInLayout() { - return this.width; + public SimpleNode[] getPredecessingEntities() { + return getPredecessingNodes(); } @Override - public double getXInLayout() { - return this.x; + public Item[] getItems() { + return null; } @Override - public double getYInLayout() { - return this.y; + public boolean isPrunable() { + return false; } @Override - public Object getGraphData() { + public boolean isPruned() { + return false; + } + + @Override + public SubgraphLayout getSubgraph() { return null; } @Override - public void setGraphData(Object o) { + public void prune(SubgraphLayout subgraph) { + } + @Override + public SimpleNode[] getSuccessingNodes() { + List successors = new ArrayList<>(); + for (SimpleRelationship relationship : graph.getConnections()) { + if (relationship.getSource() == this) { + successors.add(relationship.getTarget()); + } + } + return successors.toArray(SimpleNode[]::new); } + @Override + public SimpleNode[] getPredecessingNodes() { + List predecessors = new ArrayList<>(); + for (SimpleRelationship relationship : graph.getConnections()) { + if (relationship.getTarget() == this) { + predecessors.add(relationship.getSource()); + } + } + return predecessors.toArray(SimpleNode[]::new); + } + + @Override + public void setMinimized(boolean minimized) { + this.minimized = minimized; + } + + @Override + public boolean isMinimized() { + return minimized; + } + + @Override + public SimpleRelationship[] getIncomingConnections() { + List relationships = new ArrayList<>(); + for (SimpleRelationship relationship : graph.getConnections()) { + if (relationship.getTarget() == this) { + relationships.add(relationship); + } + } + return relationships.toArray(SimpleRelationship[]::new); + } + + @Override + public SimpleRelationship[] getOutgoingConnections() { + List relationships = new ArrayList<>(); + for (SimpleRelationship relationship : graph.getConnections()) { + if (relationship.getSource() == this) { + relationships.add(relationship); + } + } + return relationships.toArray(SimpleRelationship[]::new); + } } diff --git a/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleRelationship.java b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleRelationship.java index 34c129768..15f530b08 100644 --- a/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleRelationship.java +++ b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleStructures/SimpleRelationship.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright 2005 CHISEL Group, University of Victoria, Victoria, BC, + * Copyright 2005, 2024 CHISEL Group, University of Victoria, Victoria, BC, * Canada. * * This program and the accompanying materials are made available under the @@ -12,16 +12,7 @@ *******************************************************************************/ package org.eclipse.zest.layouts.exampleStructures; -import java.util.HashMap; -import java.util.Map; - -import org.eclipse.zest.layouts.LayoutBendPoint; -import org.eclipse.zest.layouts.LayoutEntity; -import org.eclipse.zest.layouts.LayoutRelationship; -import org.eclipse.zest.layouts.constraints.BasicEdgeConstraints; -import org.eclipse.zest.layouts.constraints.LabelLayoutConstraint; -import org.eclipse.zest.layouts.constraints.LayoutConstraint; -import org.eclipse.zest.layouts.dataStructures.BendPoint; +import org.eclipse.zest.layouts.interfaces.ConnectionLayout; /** * The SimpleRelation class describes the relationship between two objects: @@ -33,7 +24,7 @@ * @author Casey Best (version 1.0 by Jingwei Wu) * @author Chris Bennett */ -public class SimpleRelationship implements LayoutRelationship { +public class SimpleRelationship implements ConnectionLayout { private static int DEFAULT_REL_LINE_WIDTH = 1; private static int DEFAULT_REL_LINE_WIDTH_SELECTED = DEFAULT_REL_LINE_WIDTH + 2; @@ -46,20 +37,15 @@ public class SimpleRelationship implements LayoutRelationship { /** The color for this relationship. */ private Object color = DEFAULT_RELATIONSHIP_COLOR; - /** - * A list of layout dependent attributes - */ - private Map attributes; - /** * The sourceEntity of this SimpleRelation. */ - protected LayoutEntity sourceEntity; + protected SimpleNode sourceEntity; /** * The object of this SimpleRelation. */ - protected LayoutEntity destinationEntity; + protected SimpleNode destinationEntity; /** * If directional, algorithms must note the direction of the relationship. If @@ -73,11 +59,10 @@ public class SimpleRelationship implements LayoutRelationship { */ private double weight; - private Object internalRelationship; - - private LayoutBendPoint[] bendPoints; - - private String label; + /** + * Whether this relation is visible. + */ + private boolean visible; /** * Constructor. @@ -91,7 +76,7 @@ public class SimpleRelationship implements LayoutRelationship { * or destinationEntity is * null. */ - public SimpleRelationship(LayoutEntity sourceEntity, LayoutEntity destinationEntity, boolean bidirectional) { + public SimpleRelationship(SimpleNode sourceEntity, SimpleNode destinationEntity, boolean bidirectional) { this(sourceEntity, destinationEntity, bidirectional, 1); } @@ -100,20 +85,13 @@ public SimpleRelationship(LayoutEntity sourceEntity, LayoutEntity destinationEnt * * @param sourceEntity The sourceEntity of this SimpleRelation. * @param destinationEntity The destinationEntity of this SimpleRelation. - * @param exchangeable Determines if the sourceEntity and - * destinationEntity are - * equal(exchangeable). - * @throws java.lang.NullPointerException If either sourceEntity - * or destinationEntity is - * null. */ - public SimpleRelationship(LayoutEntity sourceEntity, LayoutEntity destinationEntity, boolean bidirectional, + public SimpleRelationship(SimpleNode sourceEntity, SimpleNode destinationEntity, boolean bidirectional, double weight) { this.destinationEntity = destinationEntity; this.sourceEntity = sourceEntity; this.bidirectional = bidirectional; this.weight = weight; - this.attributes = new HashMap(); this.lineWidth = DEFAULT_REL_LINE_WIDTH; this.color = DEFAULT_RELATIONSHIP_COLOR; } @@ -125,7 +103,7 @@ public SimpleRelationship(LayoutEntity sourceEntity, LayoutEntity destinationEnt * @return The sourceEntity. */ @Override - public LayoutEntity getSourceInLayout() { + public SimpleNode getSource() { return sourceEntity; } @@ -136,7 +114,7 @@ public LayoutEntity getSourceInLayout() { * @return The destinationEntity of this SimpleRelation. */ @Override - public LayoutEntity getDestinationInLayout() { + public SimpleNode getTarget() { return destinationEntity; } @@ -146,38 +124,24 @@ public LayoutEntity getDestinationInLayout() { * layout algorithms need to take into account the direction of the * relationship. The direction is based on the source and destination entities. */ - public boolean isBidirectionalInLayout() { + @Override + public boolean isDirected() { return bidirectional; } - public void setWeightInLayout(double weight) { + public void setWeight(double weight) { this.weight = weight; } - public double getWeightInLayout() { + @Override + public double getWeight() { return weight; } - /** - * An algorithm may require a place to store information. Use this structure for - * that purpose. - */ - public void setAttributeInLayout(String attribute, Object value) { - attributes.put(attribute, value); - } - - /** - * An algorithm may require a place to store information. Use this structure for - * that purpose. - */ - public Object getAttributeInLayout(String attribute) { - return attributes.get(attribute); - } - @Override public String toString() { - String arrow = (isBidirectionalInLayout() ? " <-> " : " -> "); - return "(" + sourceEntity + arrow + destinationEntity + ")"; + String arrow = (isDirected() ? " <-> " : " -> "); //$NON-NLS-1$ //$NON-NLS-2$ + return "(" + sourceEntity + arrow + destinationEntity + ")"; //$NON-NLS-1$ //$NON-NLS-2$ } public int getLineWidth() { @@ -223,75 +187,13 @@ public static void setDefaultHighlightColor(Object c) { DEFAULT_RELATIONSHIP_HIGHLIGHT_COLOR = c; } - /* - * (non-Javadoc) - * - * @see ca.uvic.cs.chisel.layouts.LayoutRelationship#getInternalRelationship() - */ @Override - public Object getLayoutInformation() { - return internalRelationship; + public void setVisible(boolean visible) { + this.visible = visible; } - /* - * (non-Javadoc) - * - * @see - * ca.uvic.cs.chisel.layouts.LayoutRelationship#setInternalRelationship(java. - * lang.Object) - */ @Override - public void setLayoutInformation(Object layoutInformation) { - this.internalRelationship = layoutInformation; + public boolean isVisible() { + return visible; } - - @Override - public void setBendPoints(LayoutBendPoint[] bendPoints) { - this.bendPoints = bendPoints; - } - - public LayoutBendPoint[] getBendPoints() { - return this.bendPoints; - } - - @Override - public void clearBendPoints() { - this.bendPoints = new BendPoint[0]; - } - - public void setDestinationInLayout(LayoutEntity destination) { - this.destinationEntity = destination; - } - - /** - * Set the label for this edge (available in the label layout constraint). - */ - public void setLabel(String label) { - this.label = label; - } - - /** - * Populate the specified layout constraint - */ - @Override - public void populateLayoutConstraint(LayoutConstraint constraint) { - if (constraint instanceof LabelLayoutConstraint labelConstraint) { - labelConstraint.label = this.label; - labelConstraint.pointSize = 18; - } else if (constraint instanceof BasicEdgeConstraints) { - // noop - - } - } - - @Override - public Object getGraphData() { - return null; - } - - @Override - public void setGraphData(Object o) { - - } - } diff --git a/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/Messages.java b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/Messages.java new file mode 100644 index 000000000..cd02f6c0a --- /dev/null +++ b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/Messages.java @@ -0,0 +1,34 @@ +/******************************************************************************* + * Copyright (c) 2024 IBM Corporation and others. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License 2.0 which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ + +package org.eclipse.zest.layouts.exampleUses; + +import java.util.MissingResourceException; +import java.util.ResourceBundle; + +public class Messages { + private static final String BUNDLE_NAME = Messages.class.getPackageName() + ".messages"; //$NON-NLS-1$ + + private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle.getBundle(BUNDLE_NAME); + + private Messages() { + } + + public static String getString(String key) { + try { + return RESOURCE_BUNDLE.getString(key); + } catch (MissingResourceException e) { + return '!' + key + '!'; + } + } +} diff --git a/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/SimpleSWTExample.java b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/SimpleSWTExample.java index 68f8884b3..5aad50c7d 100644 --- a/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/SimpleSWTExample.java +++ b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/SimpleSWTExample.java @@ -12,22 +12,18 @@ ******************************************************************************/ package org.eclipse.zest.layouts.exampleUses; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Date; -import java.util.Iterator; import java.util.List; import org.eclipse.swt.SWT; import org.eclipse.swt.SWTError; +import org.eclipse.swt.events.ControlAdapter; import org.eclipse.swt.events.ControlEvent; -import org.eclipse.swt.events.ControlListener; +import org.eclipse.swt.events.MouseAdapter; import org.eclipse.swt.events.MouseEvent; -import org.eclipse.swt.events.MouseListener; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; +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.GC; import org.eclipse.swt.graphics.Image; @@ -39,31 +35,21 @@ import org.eclipse.swt.widgets.Canvas; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Label; import org.eclipse.swt.widgets.Shell; import org.eclipse.swt.widgets.ToolBar; import org.eclipse.swt.widgets.ToolItem; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.jface.dialogs.ProgressMonitorDialog; -import org.eclipse.zest.layouts.InvalidLayoutConfiguration; import org.eclipse.zest.layouts.LayoutAlgorithm; -import org.eclipse.zest.layouts.LayoutBendPoint; -import org.eclipse.zest.layouts.LayoutEntity; -import org.eclipse.zest.layouts.LayoutRelationship; -import org.eclipse.zest.layouts.LayoutStyles; -import org.eclipse.zest.layouts.algorithms.AbstractLayoutAlgorithm; +import org.eclipse.zest.layouts.algorithms.BoxLayoutAlgorithm; import org.eclipse.zest.layouts.algorithms.GridLayoutAlgorithm; -import org.eclipse.zest.layouts.algorithms.HorizontalLayoutAlgorithm; -import org.eclipse.zest.layouts.algorithms.HorizontalTreeLayoutAlgorithm; import org.eclipse.zest.layouts.algorithms.RadialLayoutAlgorithm; import org.eclipse.zest.layouts.algorithms.SpringLayoutAlgorithm; import org.eclipse.zest.layouts.algorithms.TreeLayoutAlgorithm; -import org.eclipse.zest.layouts.algorithms.VerticalLayoutAlgorithm; +import org.eclipse.zest.layouts.exampleStructures.SimpleGraph; import org.eclipse.zest.layouts.exampleStructures.SimpleNode; import org.eclipse.zest.layouts.exampleStructures.SimpleRelationship; -import org.eclipse.zest.layouts.progress.ProgressEvent; -import org.eclipse.zest.layouts.progress.ProgressListener; /** * @author Rob Lintern @@ -100,35 +86,32 @@ public class SimpleSWTExample { private static final double INITIAL_NODE_WIDTH = 20; private static final double INITIAL_NODE_HEIGHT = 15; - protected static ArrayList algorithms = new ArrayList<>(Arrays.asList( - new SpringLayoutAlgorithm.Zest1(LayoutStyles.NO_LAYOUT_NODE_RESIZING), - new TreeLayoutAlgorithm.Zest1(LayoutStyles.NONE), new HorizontalTreeLayoutAlgorithm(LayoutStyles.NONE), - new RadialLayoutAlgorithm.Zest1(LayoutStyles.NONE), new GridLayoutAlgorithm.Zest1(LayoutStyles.NONE), - new HorizontalLayoutAlgorithm(LayoutStyles.NONE), new VerticalLayoutAlgorithm(LayoutStyles.NONE))); - - @SuppressWarnings("nls") - protected static ArrayList algorithmNames = new ArrayList<>( - Arrays.asList("Spring", "Fade", "Tree - V", "Tree - H", "Radial", "Grid", "Horizontal", "Vertical")); - - protected static ArrayList algorithmAnimates = new ArrayList<>(Arrays.asList(Boolean.TRUE, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, Boolean.FALSE, Boolean.FALSE, Boolean.FALSE, Boolean.FALSE)); - + protected static List algorithms = List.of(new SpringLayoutAlgorithm(), // + new TreeLayoutAlgorithm(), // + new TreeLayoutAlgorithm(TreeLayoutAlgorithm.LEFT_RIGHT), // + new RadialLayoutAlgorithm(), // + new GridLayoutAlgorithm(), // + new BoxLayoutAlgorithm(SWT.HORIZONTAL), // + new BoxLayoutAlgorithm(SWT.VERTICAL)); + + protected static List algorithmNames = List.of(Messages.getString("SimpleSWTExample.SpringLayout"), //$NON-NLS-1$ + Messages.getString("SimpleSWTExample.TreeVLayout"), //$NON-NLS-1$ + Messages.getString("SimpleSWTExample.TreeHLayout"), //$NON-NLS-1$ + Messages.getString("SimpleSWTExample.RadialLayout"), //$NON-NLS-1$ + Messages.getString("SimpleSWTExample.GridLayout"), //$NON-NLS-1$ + Messages.getString("SimpleSWTExample.HorizontalLayout"), //$NON-NLS-1$ + Messages.getString("SimpleSWTExample.VerticalLayout")); //$NON-NLS-1$ // private long updateGUICount = 0; - private boolean animate = true; - private static boolean continuous = false; - private static boolean asynchronously = false; private final Shell mainShell; private Composite mainComposite; - private List entities; - private List relationships; private final ToolBar toolBar; - private final Label lblProgress; - private LayoutAlgorithm.Zest1 currentLayoutAlgorithm; + private LayoutAlgorithm currentLayoutAlgorithm; protected SimpleNode selectedEntity; protected SimpleNode hoverEntity; + private SimpleGraph graph; protected Point mouseDownPoint; protected Point selectedEntityPositionAtMouseDown; @@ -136,106 +119,41 @@ public class SimpleSWTExample { public SimpleSWTExample(Display display) { mainShell = new Shell(display); - mainShell.addControlListener(new ControlListener() { - @Override - public void controlMoved(ControlEvent e) { - } - + mainShell.addControlListener(new ControlAdapter() { @Override public void controlResized(ControlEvent e) { mainShell.layout(true); } }); - GridLayout gridLayout = new GridLayout(1, true); - mainShell.setLayout(gridLayout); - GridData toolbarGridData = new GridData(GridData.HORIZONTAL_ALIGN_CENTER, GridData.VERTICAL_ALIGN_BEGINNING, - true, true); + mainShell.setLayout(new GridLayout()); toolBar = new ToolBar(mainShell, SWT.HORIZONTAL); - toolBar.setLayoutData(toolbarGridData); + toolBar.setLayoutData(new GridData(SWT.CENTER, SWT.BEGINNING, true, false)); toolBar.setLayout(new FillLayout(SWT.HORIZONTAL)); - GridData progressGridData = new GridData(GridData.HORIZONTAL_ALIGN_CENTER, GridData.VERTICAL_ALIGN_END, true, - false); - progressGridData.widthHint = 300; - lblProgress = new Label(mainShell, SWT.NONE); - lblProgress.setLayoutData(progressGridData); - lblProgress.setText("Progress: "); //$NON-NLS-1$ - for (int i = 0; i < algorithms.size(); i++) { - final LayoutAlgorithm.Zest1 algorithm = algorithms.get(i); + final LayoutAlgorithm algorithm = algorithms.get(i); String algorithmName = algorithmNames.get(i); - final boolean algorithmAnimate = algorithmAnimates.get(i).booleanValue(); ToolItem algorithmButton = new ToolItem(toolBar, SWT.PUSH); algorithmButton.setText(algorithmName); new ToolItem(toolBar, SWT.SEPARATOR); - algorithmButton.addSelectionListener(new SelectionListener() { + algorithmButton.addSelectionListener(new SelectionAdapter() { @Override public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) { currentLayoutAlgorithm = algorithm; - algorithm.setEntityAspectRatio((double) mainComposite.getClientArea().width - / (double) mainComposite.getClientArea().height); - animate = algorithmAnimate; performLayout(false); } - - @Override - public void widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent e) { - } }); } ToolItem redrawButton = new ToolItem(toolBar, SWT.PUSH); - redrawButton.setText("Redraw"); //$NON-NLS-1$ - redrawButton.addSelectionListener(new SelectionListener() { + redrawButton.setText(Messages.getString("SimpleSWTExample.Redraw")); //$NON-NLS-1$ + redrawButton.addSelectionListener(new SelectionAdapter() { @Override public void widgetSelected(SelectionEvent e) { mainComposite.redraw(); } - - @Override - public void widgetDefaultSelected(SelectionEvent e) { - } - }); - - ToolItem stopButton = new ToolItem(toolBar, SWT.PUSH); - stopButton.setText("Stop"); //$NON-NLS-1$ - stopButton.addSelectionListener(new SelectionListener() { - @Override - public void widgetSelected(SelectionEvent e) { - currentLayoutAlgorithm.stop(); - } - - @Override - public void widgetDefaultSelected(SelectionEvent e) { - } - }); - - ToolItem continuousButton = new ToolItem(toolBar, SWT.CHECK); - continuousButton.setText("Continuous"); //$NON-NLS-1$ - continuousButton.addSelectionListener(new SelectionListener() { - @Override - public void widgetSelected(SelectionEvent e) { - setContinuous(); - } - - @Override - public void widgetDefaultSelected(SelectionEvent e) { - } - }); - - ToolItem asynchronousButton = new ToolItem(toolBar, SWT.CHECK); - asynchronousButton.setText("Asynchronous"); //$NON-NLS-1$ - asynchronousButton.addSelectionListener(new SelectionListener() { - @Override - public void widgetSelected(SelectionEvent e) { - setAsynchronously(); - } - - @Override - public void widgetDefaultSelected(SelectionEvent e) { - } }); createMainPanel(); @@ -248,160 +166,21 @@ public void widgetDefaultSelected(SelectionEvent e) { // mainShell.setSize(INITIAL_PANEL_WIDTH + 100, INITIAL_PANEL_HEIGHT + 200); } - public void setAsynchronously() { - if (asynchronously) { - asynchronously = false; - } else { - asynchronously = true; - } - - } - - public void setContinuous() { - if (continuous) { - continuous = false; - } else { - continuous = true; - } - } - IProgressMonitor progressMonitor = null; ProgressMonitorDialog pmd = null; boolean GUI_UPDATING = false; private void performLayout(boolean placeRandomly) { - - if (!continuous) { - } - - if (currentLayoutAlgorithm.isRunning()) { - throw new RuntimeException("Layout is already running"); //$NON-NLS-1$ - } if (placeRandomly) { placeRandomly(); } - ProgressListener progressListener = new ProgressListener() { - - int lastStep = 0; - - class progressSync implements Runnable { - - public static final int PROGRESS_UPDATED = 1; - public static final int PROGRESS_STARTED = 2; - public static final int PROGRESS_ENDED = 3; - public static final int UPDATE_GUI = 4; - private int progressState = -1; - private final ProgressEvent e; + Rectangle bounds = mainComposite.getClientArea(); + graph.setBounds(bounds.x, bounds.y, bounds.width, bounds.height); - public progressSync(int progressState, final ProgressEvent e) { - this.progressState = progressState; - this.e = e; - - } - - @Override - public void run() { - - switch (progressState) { - case PROGRESS_STARTED: - if (!continuous) { - pmd = new ProgressMonitorDialog(getShell()); - progressMonitor = pmd.getProgressMonitor(); - pmd.open(); - progressMonitor.beginTask("Layout Running...", e.getTotalNumberOfSteps()); //$NON-NLS-1$ - } - break; - - case PROGRESS_UPDATED: - if (!continuous) { - progressMonitor.worked(e.getStepsCompleted() - lastStep); - lastStep = e.getStepsCompleted(); - } - break; - - case PROGRESS_ENDED: - if (!continuous) { - progressMonitor.done(); - pmd.close(); - } - updateGUI(); - mainShell.redraw(); - break; - case UPDATE_GUI: - updateGUI(); - GUI_UPDATING = false; - break; - } - mainComposite.redraw(); - - } - - } - - @Override - public void progressUpdated(final ProgressEvent e) { - if (asynchronously) { - if (!mainComposite.isDisposed()) { - Display.getDefault().asyncExec(new progressSync(progressSync.PROGRESS_UPDATED, e)); - if (!GUI_UPDATING) { - GUI_UPDATING = true; - Display.getDefault().asyncExec(new progressSync(progressSync.UPDATE_GUI, e)); - } - } - } else { - if (!mainComposite.isDisposed()) { - new progressSync(progressSync.PROGRESS_UPDATED, e).run(); - } - } - - } - - @Override - public void progressStarted(ProgressEvent e) { - if (asynchronously) { - if (!mainComposite.isDisposed()) { - Display.getDefault().asyncExec(new progressSync(progressSync.PROGRESS_STARTED, e)); - } - } else { - if (!mainComposite.isDisposed()) { - new progressSync(progressSync.PROGRESS_STARTED, e).run(); - } - } - - } - - @Override - public void progressEnded(ProgressEvent e) { - if (asynchronously) { - if (!mainComposite.isDisposed()) { - Display.getDefault().asyncExec(new progressSync(progressSync.PROGRESS_ENDED, e)); - } - } else { - if (!mainComposite.isDisposed()) { - new progressSync(progressSync.PROGRESS_ENDED, e).run(); - } - } - currentLayoutAlgorithm.removeProgressListener(this); - Display.getDefault().asyncExec(new progressSync(progressSync.PROGRESS_UPDATED, e)); - } - }; - currentLayoutAlgorithm.addProgressListener(progressListener); - - try { - LayoutEntity[] layoutEntities = new LayoutEntity[entities.size()]; - entities.toArray(layoutEntities); - LayoutRelationship[] layoutRelationships = new LayoutRelationship[relationships.size()]; - relationships.toArray(layoutRelationships); - currentLayoutAlgorithm.applyLayout(layoutEntities, layoutRelationships, 0, 0, - mainComposite.getClientArea().width - 30, mainComposite.getClientArea().height - 17, asynchronously, - continuous); - if (!animate) { - updateGUI(); - } - } catch (InvalidLayoutConfiguration e) { - e.printStackTrace(); - } + currentLayoutAlgorithm.setLayoutContext(graph); + currentLayoutAlgorithm.applyLayout(true); + updateGUI(); } private Shell getShell() { @@ -410,7 +189,7 @@ private Shell getShell() { private void createMainPanel() { mainComposite = new Canvas(mainShell, SWT.NO_BACKGROUND); - GridData mainGridData = new GridData(GridData.HORIZONTAL_ALIGN_FILL, GridData.VERTICAL_ALIGN_FILL, true, true); + GridData mainGridData = new GridData(GridData.FILL, GridData.FILL, true, true); mainGridData.widthHint = INITIAL_PANEL_WIDTH; mainGridData.heightHint = INITIAL_PANEL_HEIGHT; mainComposite.setLayoutData(mainGridData); @@ -426,8 +205,7 @@ private void createMainPanel() { SimpleNode oldEntity = hoverEntity; hoverEntity = null; - for (Iterator iter = entities.iterator(); iter.hasNext() && selectedEntity == null;) { - SimpleNode entity = (SimpleNode) iter.next(); + for (SimpleNode entity : graph.getNodes()) { double x = entity.getX(); double y = entity.getY(); double w = entity.getWidth(); @@ -447,18 +225,12 @@ private void createMainPanel() { } }); - mainComposite.addMouseListener(new MouseListener() { - - @Override - public void mouseDoubleClick(MouseEvent e) { - } - + mainComposite.addMouseListener(new MouseAdapter() { @Override public void mouseDown(MouseEvent e) { selectedEntity = null; hoverEntity = null; - for (Iterator iter = entities.iterator(); iter.hasNext() && selectedEntity == null;) { - SimpleNode entity = (SimpleNode) iter.next(); + for (SimpleNode entity : graph.getNodes()) { double x = entity.getX(); double y = entity.getY(); double w = entity.getWidth(); @@ -466,6 +238,7 @@ public void mouseDown(MouseEvent e) { Rectangle rect = new Rectangle((int) x, (int) y, (int) w, (int) h); if (rect.contains(e.x, e.y)) { selectedEntity = entity; + break; } } if (selectedEntity != null) { @@ -478,6 +251,7 @@ public void mouseDown(MouseEvent e) { mouseDownPoint = null; selectedEntityPositionAtMouseDown = null; } + mainComposite.redraw(); } @Override @@ -485,13 +259,14 @@ public void mouseUp(MouseEvent e) { if (selectedEntity != null) { selectedEntity.ignoreInLayout(false); selectedEntity.setUnSelected(); - List relatedNodes = selectedEntity.getRelatedEntities(); - for (Object relatedNode : relatedNodes) { - SimpleNode element = (SimpleNode) relatedNode; + List relatedNodes = selectedEntity.getRelatedEntities(); + for (SimpleNode element : relatedNodes) { element.setUnSelected(); } - SimpleRelationship[] rels = selectedEntity.getRelationships(); - for (SimpleRelationship rel : rels) { + for (SimpleRelationship rel : selectedEntity.getOutgoingConnections()) { + rel.resetLineWidth(); + } + for (SimpleRelationship rel : selectedEntity.getIncomingConnections()) { rel.resetLineWidth(); } } @@ -501,23 +276,27 @@ public void mouseUp(MouseEvent e) { } }); - // stops the algorithm when the window is closed - mainComposite.addDisposeListener(e -> { - if (currentLayoutAlgorithm != null) { - currentLayoutAlgorithm.stop(); - } - }); - mainComposite.addMouseMoveListener(e -> { if (selectedEntity != null && mouseDownPoint != null) { double dx = e.x - mouseDownPoint.x; double dy = e.y - mouseDownPoint.y; + selectedEntity.ignoreInLayout(false); selectedEntity.setLocation(selectedEntityPositionAtMouseDown.x + dx, selectedEntityPositionAtMouseDown.y + dy); + selectedEntity.ignoreInLayout(true); mainComposite.redraw(); } }); + + mainComposite.addControlListener(new ControlAdapter() { + @Override + public void controlResized(ControlEvent e) { + if (currentLayoutAlgorithm != null) { + performLayout(false); + } + } + }); } static int lastUpdateCall = 0; @@ -531,28 +310,23 @@ public void mouseUp(MouseEvent e) { * maxChildren) */ private void createTreeGraph(int maxLevels, int maxChildren, boolean random) { - entities = new ArrayList(); - relationships = new ArrayList(); + graph = new SimpleGraph(); // ccallendar - testing out having 2 roots SimpleNode root = createSimpleNode(getNextID()); - entities.add(root); + graph.addEntity(root); SimpleNode root2 = createSimpleNode(getNextID()); - entities.add(root2); + graph.addEntity(root2); // end SimpleNode currentParent = createSimpleNode(getNextID()); - entities.add(currentParent); + graph.addEntity(currentParent); // ccallendar - adding relationships from the parent to the 2 roots SimpleRelationship rel = new SimpleRelationship(root, currentParent, false); - root.addRelationship(rel); - currentParent.addRelationship(rel); - relationships.add(rel); + graph.addRelationship(rel); rel = new SimpleRelationship(root2, currentParent, false); - root2.addRelationship(rel); - currentParent.addRelationship(rel); - relationships.add(rel); + graph.addRelationship(rel); // end int levels = random ? (int) (Math.random() * maxLevels + 1) : maxLevels; @@ -568,11 +342,9 @@ private void createTreeGraphRecursive(SimpleNode currentParentNode, int maxChild int numChildren = random ? (int) (Math.random() * maxChildren + 1) : maxChildren; for (int child = 0; child < numChildren; child++) { SimpleNode childNode = createSimpleNode(getNextID()); - entities.add(childNode); + graph.addEntity(childNode); SimpleRelationship rel = new SimpleRelationship(currentParentNode, childNode, false); - childNode.addRelationship(rel); - currentParentNode.addRelationship(rel); - relationships.add(rel); + graph.addRelationship(rel); SimpleRelationship.setDefaultSize(2); createTreeGraphRecursive(childNode, maxChildren, maxLevel, level + 1, random); } @@ -601,11 +373,10 @@ private String getNextID() { /** Places nodes randomly on the screen **/ private void placeRandomly() { - for (Object element : entities) { - SimpleNode simpleNode = (SimpleNode) element; + for (SimpleNode simpleNode : graph.getNodes()) { double x = Math.random() * INITIAL_PANEL_WIDTH - INITIAL_NODE_WIDTH; double y = Math.random() * INITIAL_PANEL_HEIGHT - INITIAL_NODE_HEIGHT; - simpleNode.setLocationInLayout(x, y); + simpleNode.setLocation(x, y); } } @@ -616,9 +387,9 @@ private void placeRandomly() { * @return SimpleNode */ private SimpleNode createSimpleNode(String name) { - SimpleNode simpleNode = new SimpleNode(name); + SimpleNode simpleNode = new SimpleNode(name, graph); int w = name.length() * 8; // an initial approximation of the width - simpleNode.setSizeInLayout(Math.max(w, INITIAL_NODE_WIDTH), INITIAL_NODE_HEIGHT); + simpleNode.setSize(Math.max(w, INITIAL_NODE_WIDTH), INITIAL_NODE_HEIGHT); return simpleNode; } @@ -650,20 +421,11 @@ public static void main(String[] args) { */ private class GraphPaintListener implements PaintListener { - long lastPaint; - @Override public void paintControl(PaintEvent e) { - Date date = new Date(); - long currentTime = date.getTime(); - if (currentTime - lastPaint < 40) { - return; - } - lastPaint = currentTime; if (Display.getDefault() == null || e.width == 0 || e.height == 0) { return; } - long startTime = date.getTime(); // do a bit of our own double-buffering to stop flickering Image imageBuffer; @@ -683,10 +445,9 @@ public void paintControl(PaintEvent e) { GC gcBuffer = new GC(imageBuffer); // paint the relationships - for (Object relationship : relationships) { - SimpleRelationship rel = (SimpleRelationship) relationship; - SimpleNode src = (SimpleNode) rel.getSourceInLayout(); - SimpleNode dest = (SimpleNode) rel.getDestinationInLayout(); + for (SimpleRelationship rel : graph.getConnections()) { + SimpleNode src = rel.getSource(); + SimpleNode dest = rel.getTarget(); // highlight the adjacent nodes if one of the nodes is selected if (src.equals(selectedEntity)) { @@ -699,11 +460,6 @@ public void paintControl(PaintEvent e) { rel.setUnSelected(); } - // Add bend points if required - if ((rel).getBendPoints() != null && (rel).getBendPoints().length > 0) { - src = drawBendPoints(rel, gcBuffer); // change source to last bendpoint - } - double srcX = src.getX() + src.getWidth() / 2.0; double srcY = src.getY() + src.getHeight() / 2.0; double destX = dest.getX() + dest.getWidth() / 2.0; @@ -713,9 +469,7 @@ public void paintControl(PaintEvent e) { } // paint the nodes - for (Object element : entities) { - SimpleNode entity = (SimpleNode) element; - + for (SimpleNode entity : graph.getNodes()) { String name = entity.toString(); Point textSize = gcBuffer.stringExtent(name); int entityX = (int) entity.getX(); @@ -739,10 +493,6 @@ public void paintControl(PaintEvent e) { e.gc.drawImage(imageBuffer, 0, 0); imageBuffer.dispose(); gcBuffer.dispose(); - - long time = date.getTime() - startTime; - if (time > 200) { - } } /** @@ -761,36 +511,6 @@ private void drawEdge(double srcX, double srcY, double destX, double destY, Simp gcBuffer.setLineWidth(rel.getLineWidth()); gcBuffer.drawLine((int) srcX, (int) srcY, (int) destX, (int) destY); } - - /** - * Draws a set of lines between bendpoints TODO - This does not always draw - * outside the node. - * - * @param relationship - * @param bendNodes - * @param bendEdges - * @return the last bendpoint entity or null if there are no bendpoints - */ - private SimpleNode drawBendPoints(SimpleRelationship rel, GC gcBuffer) { - final String DUMMY_TITLE = "dummy"; //$NON-NLS-1$ - LayoutBendPoint[] bendPoints = (rel).getBendPoints(); - LayoutBendPoint bp; - SimpleNode startEntity = (SimpleNode) rel.getSourceInLayout(); - SimpleNode destEntity = null; - - double srcX = startEntity.getX() + startEntity.getWidth() / 2.0; - double srcY = startEntity.getY() + startEntity.getHeight() / 2.0; - for (int i = 1; i < bendPoints.length - 1; i++) { - bp = bendPoints[i]; - destEntity = new SimpleNode(DUMMY_TITLE, bp.getX(), bp.getY(), 0.01, 0.01); - drawEdge(srcX, srcY, bp.getX(), bp.getY(), rel, gcBuffer); - startEntity = destEntity; - srcX = startEntity.getX(); - srcY = startEntity.getY(); - } - return destEntity; - } - } } diff --git a/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/SimpleSwingExample.java b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/SimpleSwingExample.java index 9f5b28b29..d2f745221 100644 --- a/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/SimpleSwingExample.java +++ b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/SimpleSwingExample.java @@ -15,7 +15,6 @@ import java.awt.BasicStroke; import java.awt.BorderLayout; import java.awt.Color; -import java.awt.Cursor; import java.awt.Dimension; import java.awt.Graphics; import java.awt.Graphics2D; @@ -25,44 +24,35 @@ import java.awt.Shape; import java.awt.Stroke; import java.awt.Toolkit; +import java.awt.event.ComponentAdapter; +import java.awt.event.ComponentEvent; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; -import java.awt.event.MouseMotionListener; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.awt.geom.AffineTransform; -import java.awt.geom.GeneralPath; import java.awt.geom.Point2D; import java.awt.geom.Rectangle2D; import java.lang.reflect.InvocationTargetException; import java.util.ArrayList; -import java.util.Iterator; import java.util.List; -import org.eclipse.zest.layouts.InvalidLayoutConfiguration; +import org.eclipse.swt.SWT; + import org.eclipse.zest.layouts.LayoutAlgorithm; -import org.eclipse.zest.layouts.LayoutBendPoint; -import org.eclipse.zest.layouts.LayoutEntity; -import org.eclipse.zest.layouts.LayoutRelationship; -import org.eclipse.zest.layouts.LayoutStyles; +import org.eclipse.zest.layouts.algorithms.BoxLayoutAlgorithm; import org.eclipse.zest.layouts.algorithms.GridLayoutAlgorithm; -import org.eclipse.zest.layouts.algorithms.HorizontalLayoutAlgorithm; -import org.eclipse.zest.layouts.algorithms.HorizontalTreeLayoutAlgorithm; import org.eclipse.zest.layouts.algorithms.RadialLayoutAlgorithm; import org.eclipse.zest.layouts.algorithms.SpringLayoutAlgorithm; import org.eclipse.zest.layouts.algorithms.TreeLayoutAlgorithm; -import org.eclipse.zest.layouts.algorithms.VerticalLayoutAlgorithm; +import org.eclipse.zest.layouts.exampleStructures.SimpleGraph; import org.eclipse.zest.layouts.exampleStructures.SimpleNode; import org.eclipse.zest.layouts.exampleStructures.SimpleRelationship; -import org.eclipse.zest.layouts.progress.ProgressEvent; -import org.eclipse.zest.layouts.progress.ProgressListener; import javax.swing.JButton; import javax.swing.JFrame; -import javax.swing.JLabel; import javax.swing.JPanel; import javax.swing.JScrollPane; -import javax.swing.JToggleButton; import javax.swing.JToolBar; import javax.swing.SwingUtilities; @@ -75,26 +65,22 @@ public class SimpleSwingExample { private static final Color NODE_NORMAL_COLOR = new Color(225, 225, 255); private static final Color NODE_SELECTED_COLOR = new Color(255, 125, 125); - // private static final Color NODE_ADJACENT_COLOR = new Color (255, 200, 125); private static final Color BORDER_NORMAL_COLOR = new Color(0, 0, 0); private static final Color BORDER_SELECTED_COLOR = new Color(255, 0, 0); - // private static final Color BORDER_ADJACENT_COLOR = new Color (255, 128, 0); private static final Stroke BORDER_NORMAL_STROKE = new BasicStroke(1.0f); private static final Stroke BORDER_SELECTED_STROKE = new BasicStroke(2.0f); private static final Color RELATIONSHIP_NORMAL_COLOR = Color.BLUE; - // private static final Color RELATIONSHIP_HIGHLIGHT_COLOR = new Color (255, - // 200, 125); - public static SpringLayoutAlgorithm.Zest1 SPRING = new SpringLayoutAlgorithm.Zest1(LayoutStyles.NONE); - public static TreeLayoutAlgorithm.Zest1 TREE_VERT = new TreeLayoutAlgorithm.Zest1(LayoutStyles.NONE); - public static HorizontalTreeLayoutAlgorithm TREE_HORIZ = new HorizontalTreeLayoutAlgorithm(LayoutStyles.NONE); - public static RadialLayoutAlgorithm.Zest1 RADIAL = new RadialLayoutAlgorithm.Zest1(LayoutStyles.NONE); - public static GridLayoutAlgorithm.Zest1 GRID = new GridLayoutAlgorithm.Zest1(LayoutStyles.NONE); - public static HorizontalLayoutAlgorithm HORIZ = new HorizontalLayoutAlgorithm(LayoutStyles.NONE); - public static VerticalLayoutAlgorithm VERT = new VerticalLayoutAlgorithm(LayoutStyles.NONE); + public static SpringLayoutAlgorithm SPRING = new SpringLayoutAlgorithm(); + public static TreeLayoutAlgorithm TREE_VERT = new TreeLayoutAlgorithm(); + public static TreeLayoutAlgorithm TREE_HORIZ = new TreeLayoutAlgorithm(TreeLayoutAlgorithm.LEFT_RIGHT); + public static RadialLayoutAlgorithm RADIAL = new RadialLayoutAlgorithm(); + public static GridLayoutAlgorithm GRID = new GridLayoutAlgorithm(); + public static BoxLayoutAlgorithm HORIZ = new BoxLayoutAlgorithm(SWT.HORIZONTAL); + public static BoxLayoutAlgorithm VERT = new BoxLayoutAlgorithm(SWT.VERTICAL); - private final List algorithms = new ArrayList(); - private final List algorithmNames = new ArrayList(); + private final List algorithms = new ArrayList<>(); + private final List algorithmNames = new ArrayList<>(); private static final int INITIAL_PANEL_WIDTH = 700; private static final int INITIAL_PANEL_HEIGHT = 500; @@ -112,21 +98,14 @@ public class SimpleSwingExample { private static final Color ARROW_HEAD_FILL_COLOR = new Color(125, 255, 125); private static final Color ARROW_HEAD_BORDER_COLOR = Color.BLACK; - public static final String DEFAULT_NODE_SHAPE = "oval"; - - private long updateGUICount = 0; + public static final String DEFAULT_NODE_SHAPE = "oval"; //$NON-NLS-1$ private JFrame mainFrame; private JPanel mainPanel; - private List entities; - private List relationships; + private SimpleGraph graph; private JToolBar toolBar; - private JLabel lblProgress; - private JToggleButton btnContinuous; - private JToggleButton btnAsynchronous; - private JButton btnStop; - private LayoutAlgorithm.Zest1 currentLayoutAlgorithm; + private LayoutAlgorithm currentLayoutAlgorithm; protected String currentLayoutAlgorithmName; protected SimpleNode selectedEntity; protected Point mouseDownPoint; @@ -134,55 +113,31 @@ public class SimpleSwingExample { private long idCount; protected String currentNodeShape = DEFAULT_NODE_SHAPE; // e.g., oval, rectangle - public SimpleSwingExample() { - - } - - protected void addAlgorithm(LayoutAlgorithm.Zest1 algorithm, String name, boolean animate) { + protected void addAlgorithm(LayoutAlgorithm algorithm, String name, boolean animate) { algorithms.add(algorithm); algorithmNames.add(name); } public void start() { - mainFrame = new JFrame("Simple Swing Layout Example"); + mainFrame = new JFrame(Messages.getString("SimpleSwingExample.Title")); //$NON-NLS-1$ toolBar = new JToolBar(); mainFrame.getContentPane().setLayout(new BorderLayout()); mainFrame.getContentPane().add(toolBar, BorderLayout.NORTH); - lblProgress = new JLabel("Progress: "); - mainFrame.getContentPane().add(lblProgress, BorderLayout.SOUTH); createMainPanel(); mainFrame.addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent e) { - stop(); mainFrame.dispose(); - } }); - btnContinuous = new JToggleButton("continuous", false); - btnAsynchronous = new JToggleButton("asynchronous", false); - - toolBar.add(btnContinuous); - toolBar.add(btnAsynchronous); - - btnStop = new JButton("Stop"); - btnStop.addActionListener(e -> stop()); - toolBar.add(btnStop); - - JButton btnCreateGraph = new JButton("New graph"); - btnCreateGraph.addActionListener(e -> { - stop(); - createGraph(true); - }); + JButton btnCreateGraph = new JButton(Messages.getString("SimpleSwingExample.NewGraph")); //$NON-NLS-1$ + btnCreateGraph.addActionListener(e -> createGraph(true)); toolBar.add(btnCreateGraph); - JButton btnCreateTree = new JButton("New tree"); - btnCreateTree.addActionListener(e -> { - stop(); - createGraph(false); - }); + JButton btnCreateTree = new JButton(Messages.getString("SimpleSwingExample.NewTree")); //$NON-NLS-1$ + btnCreateTree.addActionListener(e -> createGraph(false)); toolBar.add(btnCreateTree); createGraph(false); @@ -196,128 +151,56 @@ public void windowClosing(WindowEvent e) { try { SwingUtilities.invokeAndWait(() -> { - SPRING = new SpringLayoutAlgorithm.Zest1(LayoutStyles.NONE); - TREE_VERT = new TreeLayoutAlgorithm.Zest1(LayoutStyles.NONE); - TREE_HORIZ = new HorizontalTreeLayoutAlgorithm(LayoutStyles.NONE); - RADIAL = new RadialLayoutAlgorithm.Zest1(LayoutStyles.NONE); - GRID = new GridLayoutAlgorithm.Zest1(LayoutStyles.NONE); - HORIZ = new HorizontalLayoutAlgorithm(LayoutStyles.NONE); - VERT = new VerticalLayoutAlgorithm(LayoutStyles.NONE); - - SPRING.setIterations(1000); // initialize layouts - TREE_VERT.setComparator((o1, o2) -> { - if (o1 instanceof Comparable && o2 instanceof Comparable) { - return ((Comparable) o1).compareTo(o2); - } - return 0; - }); + SPRING.setResizing(true); + TREE_VERT.setResizing(true); + TREE_HORIZ.setResizing(true); + RADIAL.setResizing(true); GRID.setRowPadding(20); - addAlgorithm(SPRING, "Spring", false); - addAlgorithm(TREE_VERT, "Tree-V", false); - addAlgorithm(TREE_HORIZ, "Tree-H", false); - addAlgorithm(RADIAL, "Radial", false); - addAlgorithm(GRID, "Grid", false); - addAlgorithm(HORIZ, "Horiz", false); - addAlgorithm(VERT, "Vert", false); + GRID.setResizing(true); + HORIZ.setResizing(true); + VERT.setResizing(true); + addAlgorithm(SPRING, Messages.getString("SimpleSwingExample.SpringLayout"), false); //$NON-NLS-1$ + addAlgorithm(TREE_VERT, Messages.getString("SimpleSwingExample.TreeVLayout"), false); //$NON-NLS-1$ + addAlgorithm(TREE_HORIZ, Messages.getString("SimpleSwingExample.TreeHLayout"), false); //$NON-NLS-1$ + addAlgorithm(RADIAL, Messages.getString("SimpleSwingExample.RadialLayout"), false); //$NON-NLS-1$ + addAlgorithm(GRID, Messages.getString("SimpleSwingExample.GridLayout"), false); //$NON-NLS-1$ + addAlgorithm(HORIZ, Messages.getString("SimpleSwingExample.HorizontalLayout"), false); //$NON-NLS-1$ + addAlgorithm(VERT, Messages.getString("SimpleSwingExample.VerticalLayout"), false); //$NON-NLS-1$ for (int i = 0; i < algorithms.size(); i++) { - final LayoutAlgorithm.Zest1 algorithm = (LayoutAlgorithm.Zest1) algorithms.get(i); - final String algorithmName = (String) algorithmNames.get(i); - // final boolean algorithmAnimate = - // ((Boolean)algorithmAnimates.get(i)).booleanValue(); + final LayoutAlgorithm algorithm = algorithms.get(i); + final String algorithmName = algorithmNames.get(i); JButton algorithmButton = new JButton(algorithmName); algorithmButton.addActionListener(e -> { currentLayoutAlgorithm = algorithm; currentLayoutAlgorithmName = algorithmName; - algorithm.setEntityAspectRatio( - (double) mainPanel.getWidth() / (double) mainPanel.getHeight()); - // animate = algorithmAnimate; performLayout(); }); toolBar.add(algorithmButton); } }); - } catch (InterruptedException e1) { - // TODO Auto-generated catch block - e1.printStackTrace(); - } catch (InvocationTargetException e1) { + } catch (InterruptedException | InvocationTargetException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } } - private void stop() { - if (currentLayoutAlgorithm != null && currentLayoutAlgorithm.isRunning()) { - currentLayoutAlgorithm.stop(); - } - } - protected void performLayout() { - stop(); - final Cursor cursor = mainFrame.getCursor(); - updateGUICount = 0; placeRandomly(); - final boolean continuous = btnContinuous.isSelected(); - final boolean asynchronous = btnAsynchronous.isSelected(); - ProgressListener progressListener = new ProgressListener() { - @Override - public void progressUpdated(final ProgressEvent e) { - // if (asynchronous) { - updateGUI(); - // } - lblProgress.setText( - "Progress: " + e.getStepsCompleted() + " of " + e.getTotalNumberOfSteps() + " completed ..."); - lblProgress.paintImmediately(0, 0, lblProgress.getWidth(), lblProgress.getHeight()); - } - - @Override - public void progressStarted(ProgressEvent e) { - if (!asynchronous) { - mainFrame.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR)); - } - lblProgress.setText("Layout started ..."); - lblProgress.paintImmediately(0, 0, lblProgress.getWidth(), lblProgress.getHeight()); - } - @Override - public void progressEnded(ProgressEvent e) { - lblProgress.setText("Layout completed ..."); - lblProgress.paintImmediately(0, 0, lblProgress.getWidth(), lblProgress.getHeight()); - currentLayoutAlgorithm.removeProgressListener(this); - if (!asynchronous) { - mainFrame.setCursor(cursor); - } - } - }; - - currentLayoutAlgorithm.addProgressListener(progressListener); + Dimension size = mainPanel.getSize(); + Point location = mainPanel.getLocation(); + graph.setBounds(location.x, location.y, size.width, size.height); - try { - final LayoutEntity[] layoutEntities = new LayoutEntity[entities.size()]; - entities.toArray(layoutEntities); - final LayoutRelationship[] layoutRelationships = new LayoutRelationship[relationships.size()]; - relationships.toArray(layoutRelationships); - SwingUtilities.invokeLater(() -> { - try { - currentLayoutAlgorithm.applyLayout(layoutEntities, layoutRelationships, 0, 0, - mainPanel.getWidth(), mainPanel.getHeight(), asynchronous, continuous); - } catch (InvalidLayoutConfiguration e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - - }); - // if (!animate) { + SwingUtilities.invokeLater(() -> { + currentLayoutAlgorithm.setLayoutContext(graph); + currentLayoutAlgorithm.applyLayout(true); updateGUI(); - // } - // reset - currentNodeShape = DEFAULT_NODE_SHAPE; - } catch (StackOverflowError e) { - e.printStackTrace(); - } finally { - } + }); + // reset + currentNodeShape = DEFAULT_NODE_SHAPE; } private void createMainPanel() { @@ -332,8 +215,7 @@ private void createMainPanel() { @Override public void mousePressed(MouseEvent e) { selectedEntity = null; - for (Iterator iter = entities.iterator(); iter.hasNext() && selectedEntity == null;) { - SimpleNode entity = (SimpleNode) iter.next(); + for (SimpleNode entity : graph.getEntities()) { double x = entity.getX(); double y = entity.getY(); double w = entity.getWidth(); @@ -341,6 +223,7 @@ public void mousePressed(MouseEvent e) { Rectangle2D.Double rect = new Rectangle2D.Double(x, y, w, h); if (rect.contains(e.getX(), e.getY())) { selectedEntity = entity; + break; } } if (selectedEntity != null) { @@ -363,7 +246,7 @@ public void mouseReleased(MouseEvent e) { } }); - mainPanel.addMouseMotionListener(new MouseMotionListener() { + mainPanel.addMouseMotionListener(new MouseAdapter() { @Override public void mouseDragged(MouseEvent e) { // if (selectedEntity != null) { @@ -373,16 +256,20 @@ public void mouseDragged(MouseEvent e) { // updateGUI(); // } } + }); + mainPanel.addComponentListener(new ComponentAdapter() { @Override - public void mouseMoved(MouseEvent e) { + public void componentResized(ComponentEvent e) { + if (currentLayoutAlgorithm != null) { + performLayout(); + } } }); } private void createGraph(boolean addNonTreeRels) { - entities = new ArrayList(); - relationships = new ArrayList(); + graph = new SimpleGraph(); selectedEntity = null; createTreeGraph(2, 4, 2, 5, true, true, addNonTreeRels); @@ -402,15 +289,14 @@ private void createGraph(boolean addNonTreeRels) { */ private void createTreeGraph(int minChildren, int maxChildren, int minLevels, int maxLevels, boolean randomNumChildren, boolean randomLevels, boolean addNonTreeRels) { - LayoutEntity currentParent = createSimpleNode(getNextID()); - entities.add(currentParent); + SimpleNode currentParent = new SimpleNode(getNextID(), graph); + graph.addEntity(currentParent); createTreeGraphRecursive(currentParent, minChildren, maxChildren, minLevels, maxLevels, 1, randomNumChildren, randomLevels, addNonTreeRels); } - private void createTreeGraphRecursive(LayoutEntity currentParentNode, int minChildren, int maxChildren, - int minLevel, int maxLevel, int level, boolean randomNumChildren, boolean randomLevels, - boolean addNonTreeRels) { + private void createTreeGraphRecursive(SimpleNode currentParentNode, int minChildren, int maxChildren, int minLevel, + int maxLevel, int level, boolean randomNumChildren, boolean randomLevels, boolean addNonTreeRels) { if (level > maxLevel) { return; } @@ -425,15 +311,15 @@ private void createTreeGraphRecursive(LayoutEntity currentParentNode, int minChi int numChildren = randomNumChildren ? Math.max(minChildren, (int) (Math.random() * maxChildren + 1)) : maxChildren; for (int i = 0; i < numChildren; i++) { - LayoutEntity newNode = createSimpleNode(getNextID()); - entities.add(newNode); - if (addNonTreeRels && entities.size() % 5 == 0) { - int index = (int) (Math.random() * entities.size()); - LayoutRelationship rel = new SimpleRelationship((LayoutEntity) entities.get(index), newNode, false); - relationships.add(rel); + SimpleNode newNode = new SimpleNode(getNextID(), graph); + graph.addEntity(newNode); + if (addNonTreeRels && graph.getNodes().length % 5 == 0) { + int index = (int) (Math.random() * graph.getNodes().length); + SimpleRelationship rel = new SimpleRelationship(graph.getNodes()[index], newNode, false); + graph.addRelationship(rel); } - LayoutRelationship rel = new SimpleRelationship(currentParentNode, newNode, false); - relationships.add(rel); + SimpleRelationship rel = new SimpleRelationship(currentParentNode, newNode, false); + graph.addRelationship(rel); createTreeGraphRecursive(newNode, minChildren, maxChildren, minLevel, maxLevel, level + 1, randomNumChildren, randomLevels, addNonTreeRels); } @@ -452,37 +338,23 @@ private void createTreeGraphRecursive(LayoutEntity currentParentNode, int minChi * relationships.add(new SimpleRelationship (_1, A, false)); } */ private String getNextID() { - String id = "" + idCount; + String id = Long.toString(idCount); idCount++; return id; } /** Places nodes randomly on the screen **/ private void placeRandomly() { - for (Object element : entities) { - SimpleNode simpleNode = (SimpleNode) element; + for (SimpleNode simpleNode : graph.getNodes()) { double x = Math.random() * INITIAL_PANEL_WIDTH - INITIAL_NODE_WIDTH; double y = Math.random() * INITIAL_PANEL_HEIGHT - INITIAL_NODE_HEIGHT; - simpleNode.setLocationInLayout(x, y); - simpleNode.setSizeInLayout(INITIAL_NODE_WIDTH, INITIAL_NODE_HEIGHT); + simpleNode.setLocation(x, y); + simpleNode.setSize(INITIAL_NODE_WIDTH, INITIAL_NODE_HEIGHT); } } - /** - * Creates a SimpleNode - * - * @param name - * @return - */ - private SimpleNode createSimpleNode(String name) { - return new SimpleNode(name); - } - private void updateGUI() { - updateGUICount++; - if (updateGUICount > 0) { - mainPanel.paintImmediately(0, 0, mainPanel.getWidth(), mainPanel.getHeight()); - } + mainPanel.paintImmediately(0, 0, mainPanel.getWidth(), mainPanel.getHeight()); } private static Point2D.Double getEllipseIntersectionPoint(double theta, double ellipseWidth, double ellipseHeight) { @@ -524,20 +396,20 @@ protected void paintChildren(Graphics g) { } // paint the nodes - for (Object element : entities) { - paintEntity((SimpleNode) element, g); + for (SimpleNode element : graph.getNodes()) { + paintEntity(element, g); } // paint the relationships - for (Object relationship : relationships) { - paintRelationship((LayoutRelationship) relationship, g); + for (SimpleRelationship relationship : graph.getConnections()) { + paintRelationship(relationship, g); } } private void paintEntity(SimpleNode entity, Graphics g) { boolean isSelected = selectedEntity != null && selectedEntity.equals(entity); g.setColor(isSelected ? NODE_SELECTED_COLOR : NODE_NORMAL_COLOR); - if (currentNodeShape.equals("rectangle")) { + if (currentNodeShape.equals("rectangle")) { //$NON-NLS-1$ g.fillRect((int) entity.getX(), (int) entity.getY(), (int) entity.getWidth(), (int) entity.getHeight()); } else { // default g.fillOval((int) entity.getX(), (int) entity.getY(), (int) entity.getWidth(), (int) entity.getHeight()); @@ -553,35 +425,29 @@ private void paintEntity(SimpleNode entity, Graphics g) { if (g instanceof Graphics2D) { ((Graphics2D) g).setStroke(isSelected ? BORDER_SELECTED_STROKE : BORDER_NORMAL_STROKE); } - if (currentNodeShape.equals("rectangle")) { + if (currentNodeShape.equals("rectangle")) { //$NON-NLS-1$ g.drawRect((int) entity.getX(), (int) entity.getY(), (int) entity.getWidth(), (int) entity.getHeight()); } else { // default g.drawOval((int) entity.getX(), (int) entity.getY(), (int) entity.getWidth(), (int) entity.getHeight()); } } - private void paintRelationship(LayoutRelationship rel, Graphics g) { - - SimpleNode src = (SimpleNode) rel.getSourceInLayout(); - SimpleNode dest = (SimpleNode) rel.getDestinationInLayout(); - - // Add bend points if required - if (((SimpleRelationship) rel).getBendPoints() != null - && ((SimpleRelationship) rel).getBendPoints().length > 0) { - drawBendPoints(rel, g); - } else { - double srcX = src.getX() + src.getWidth() / 2.0; - double srcY = src.getY() + src.getHeight() / 2.0; - double destX = dest.getX() + dest.getWidth() / 2.0; - double destY = dest.getY() + dest.getHeight() / 2.0; - double dx = getLength(srcX, destX); - double dy = getLength(srcY, destY); - double theta = Math.atan2(dy, dx); - drawRelationship(src, dest, theta, srcX, srcY, destX, destY, g); - - // draw an arrow in the middle of the line - drawArrow(theta, srcX, srcY, dx, dy, g); - } + private void paintRelationship(SimpleRelationship rel, Graphics g) { + + SimpleNode src = rel.getSource(); + SimpleNode dest = rel.getTarget(); + + double srcX = src.getX() + src.getWidth() / 2.0; + double srcY = src.getY() + src.getHeight() / 2.0; + double destX = dest.getX() + dest.getWidth() / 2.0; + double destY = dest.getY() + dest.getHeight() / 2.0; + double dx = getLength(srcX, destX); + double dy = getLength(srcY, destY); + double theta = Math.atan2(dy, dx); + drawRelationship(src, dest, theta, srcX, srcY, destX, destY, g); + + // draw an arrow in the middle of the line + drawArrow(theta, srcX, srcY, dx, dy, g); } /** @@ -644,77 +510,5 @@ private double getLength(double start, double end) { } return length; } - - /** - * Draw a line from specified source to specified destination - */ - private void drawCurvedRelationship(double srcX, double srcY, double control1X, double control1Y, - double control2X, double control2Y, double destX, double destY, Graphics g) { - GeneralPath shape = new GeneralPath(); - shape.moveTo((float) srcX, (float) srcY); - shape.curveTo((float) control1X, (float) control1Y, (float) control2X, (float) control2Y, (float) destX, - (float) destY); - g.setColor(RELATIONSHIP_NORMAL_COLOR); - ((Graphics2D) g).draw(shape); - } - - /** - * Draws a set of lines between bendpoints, returning the last bendpoint drawn. - * Note that this assumes the first and last bendpoints are actually the source - * node and destination node centre points. - * - * @param relationship - * @param bendNodes - * @param bendEdges - * @return the last bendpoint entity or null if there are no bendpoints - */ - private void drawBendPoints(LayoutRelationship rel, Graphics g) { - final String DUMMY_TITLE = "dummy"; - LayoutBendPoint bp; - - SimpleNode startEntity = (SimpleNode) rel.getSourceInLayout(); - SimpleNode destEntity = (SimpleNode) rel.getDestinationInLayout(); - double srcX = startEntity.getX(); - double srcY = startEntity.getY(); - - // Transform the bendpoints to this coordinate system - LayoutBendPoint[] bendPoints = ((SimpleRelationship) rel).getBendPoints(); - - srcX = bendPoints[1].getX(); - srcY = bendPoints[1].getY(); - int bpNum = 2; - while (bpNum < bendPoints.length - 1) { // ignore first and last bendpoints (src and dest) - int currentBpNum = bpNum; - bp = bendPoints[bpNum]; - if (bp.getIsControlPoint()) { - if (bendPoints[bpNum + 1].getIsControlPoint()) { - destEntity = new SimpleNode(DUMMY_TITLE, bendPoints[bpNum + 2].getX(), - bendPoints[bpNum + 2].getY(), 0.01, 0.01); - drawCurvedRelationship(srcX, srcY, bp.getX(), bp.getY(), bendPoints[bpNum + 1].getX(), - bendPoints[bpNum + 1].getY(), bendPoints[bpNum + 2].getX(), - bendPoints[bpNum + 2].getY(), g); - bpNum += 4; - } else { - destEntity = new SimpleNode(DUMMY_TITLE, bp.getX(), bp.getY(), 0.01, 0.01); - } - } else { - drawRelationship(srcX, srcY, bp.getX(), bp.getY(), g); - bpNum++; - destEntity = new SimpleNode(DUMMY_TITLE, bp.getX(), bp.getY(), 0.01, 0.01); - } - startEntity = destEntity; - if (currentBpNum == bendPoints.length - 2) { // last point - // draw an arrow in the middle of the line - double dx = getLength(srcX, destEntity.getX()); - double dy = getLength(srcY, destEntity.getY()); - double theta = Math.atan2(dy, dx); - drawArrow(theta, srcX, srcY, dx, dy, g); - } else { - srcX = startEntity.getX(); - srcY = startEntity.getY(); - } - } - - } } } diff --git a/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/messages.properties b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/messages.properties new file mode 100644 index 000000000..37d28eacf --- /dev/null +++ b/org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/messages.properties @@ -0,0 +1,18 @@ +SimpleSwingExample.GridLayout=Grid +SimpleSwingExample.HorizontalLayout=Horiz +SimpleSwingExample.NewGraph=New graph +SimpleSwingExample.NewTree=New tree +SimpleSwingExample.RadialLayout=Radial +SimpleSwingExample.SpringLayout=Spring +SimpleSwingExample.Title=Simple Swing Layout Example +SimpleSwingExample.TreeHLayout=Tree-H +SimpleSwingExample.TreeVLayout=Tree-V +SimpleSwingExample.VerticalLayout=Vert +SimpleSWTExample.GridLayout=Grid +SimpleSWTExample.HorizontalLayout=Horizontal +SimpleSWTExample.RadialLayout=Radial +SimpleSWTExample.Redraw=Redraw +SimpleSWTExample.SpringLayout=Spring +SimpleSWTExample.TreeHLayout=Tree - H +SimpleSWTExample.TreeVLayout=Tree - V +SimpleSWTExample.VerticalLayout=Vertical diff --git a/org.eclipse.zest.tests/META-INF/MANIFEST.MF b/org.eclipse.zest.tests/META-INF/MANIFEST.MF index 51d154466..710b1921c 100644 --- a/org.eclipse.zest.tests/META-INF/MANIFEST.MF +++ b/org.eclipse.zest.tests/META-INF/MANIFEST.MF @@ -15,7 +15,6 @@ Require-Bundle: org.eclipse.ui, org.eclipse.zest.cloudio, org.eclipse.zest.core, org.eclipse.zest.examples, - org.eclipse.zest.examples.layouts, org.eclipse.zest.layouts, org.junit, org.eclipse.swtbot.swt.finder;bundle-version="4.2.1" diff --git a/org.eclipse.zest.tests/src/org/eclipse/zest/tests/LayoutAlgorithmTest.java b/org.eclipse.zest.tests/src/org/eclipse/zest/tests/LayoutAlgorithmTest.java index 121873a98..717257912 100644 --- a/org.eclipse.zest.tests/src/org/eclipse/zest/tests/LayoutAlgorithmTest.java +++ b/org.eclipse.zest.tests/src/org/eclipse/zest/tests/LayoutAlgorithmTest.java @@ -23,7 +23,6 @@ import org.eclipse.zest.layouts.LayoutEntity; import org.eclipse.zest.layouts.LayoutRelationship; import org.eclipse.zest.layouts.algorithms.GridLayoutAlgorithm; -import org.eclipse.zest.layouts.exampleStructures.SimpleNode; import org.eclipse.zest.layouts.progress.ProgressEvent; import org.eclipse.zest.layouts.progress.ProgressListener; @@ -84,7 +83,7 @@ public void progressEnded(ProgressEvent e) { } private void testWith(ProgressListener progressListener) throws InvalidLayoutConfiguration { - LayoutEntity[] nodes = { new SimpleNode(new Object()) }; + LayoutEntity[] nodes = {}; layoutAlgorithm.addProgressListener(progressListener); layoutAlgorithm.addProgressListener(new ProgressListener.Stub());