From edd9fc97ff731713e6b69b8920933d7e0433a2af Mon Sep 17 00:00:00 2001 From: Patrick Ziegler Date: Fri, 27 Sep 2024 17:34:30 +0200 Subject: [PATCH] [Zest 2.0] Refactor Layouts example to Zest 2.0 API This adapts the SimpleNode, SimpleConnection and SimpleGraph classes of the example project to implement the NodeLayout, ConnectionLayout and LayoutContext interface, respectively, replacing the old Zest 1.0 interfaces. Those classes are used by the SimpleSwingExample and SimpleSWTExample snippets to layout randomly generated graphs. Both examples have been updated to support the new layouts. Most noticeably, the nodes and connections are now exclusively stored in the layout context. Furthermore, those classes have been cleaned up, including: - Removal of empty stub methods in favor of using the adapter classes for listeners. Example: SelectionListener -> SelectionAdapter - Layout reacts to changes to the shell/frame size. - Typification of generic fields. - Internationalization of UI-specific strings. --- .../.settings/org.eclipse.jdt.core.prefs | 525 ++++++++++++++++++ .../.settings/org.eclipse.jdt.ui.prefs | 154 +++++ .../META-INF/MANIFEST.MF | 3 +- .../build.properties | 3 +- .../exampleStructures/SimpleFilter.java | 10 +- .../exampleStructures/SimpleGraph.java | 218 +++++--- .../layouts/exampleStructures/SimpleNode.java | 256 ++++----- .../exampleStructures/SimpleRelationship.java | 146 +---- .../zest/layouts/exampleUses/Messages.java | 34 ++ .../layouts/exampleUses/SimpleSWTExample.java | 426 +++----------- .../exampleUses/SimpleSwingExample.java | 404 ++++---------- .../layouts/exampleUses/messages.properties | 18 + org.eclipse.zest.tests/META-INF/MANIFEST.MF | 1 - .../zest/tests/LayoutAlgorithmTest.java | 3 +- 14 files changed, 1204 insertions(+), 997 deletions(-) create mode 100644 org.eclipse.zest.examples.layouts/.settings/org.eclipse.jdt.ui.prefs create mode 100644 org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/Messages.java create mode 100644 org.eclipse.zest.examples.layouts/src/org/eclipse/zest/layouts/exampleUses/messages.properties 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());