| ############################################################################### |
| # Copyright (c) 2000, 2004 IBM Corporation and others. |
| # All rights reserved. This program and the accompanying materials |
| # are made available under the terms of the Common Public License v1.0 |
| # which accompanies this distribution, and is available at |
| # http://www.eclipse.org/legal/cpl-v10.html |
| # |
| # Contributors: |
| # IBM Corporation - initial API and implementation |
| ############################################################################### |
| |
| |
| WhiteSpaceTabPage.assignments=Assignments |
| WhiteSpaceTabPage.assignments.before_assignment_operator=before assignment operator |
| WhiteSpaceTabPage.assignments.after_assignment_operator=after assignment operator |
| |
| WhiteSpaceTabPage.operators=Operators |
| WhiteSpaceTabPage.operators.before_binary_operators=before binary operators |
| WhiteSpaceTabPage.operators.after_binary_operators=after binary operators |
| WhiteSpaceTabPage.operators.before_unary_operators=before unary operators |
| WhiteSpaceTabPage.operators.after_unary_operators=after unary operators |
| WhiteSpaceTabPage.operators.before_prefix_operators=before prefix operators |
| WhiteSpaceTabPage.operators.after_prefix_operators=after prefix operators |
| WhiteSpaceTabPage.operators.before_postfix_operators=before postfix operators |
| WhiteSpaceTabPage.operators.after_postfix_operators=after postfix operators |
| |
| WhiteSpaceTabPage.classes=Classes |
| WhiteSpaceTabPage.classes.before_opening_brace_of_a_class=before opening brace of a class |
| WhiteSpaceTabPage.classes.before_opening_brace_of_anon_class=before opening brace of an anonymous class |
| WhiteSpaceTabPage.classes.before_comma_implements=before comma in implements clause |
| WhiteSpaceTabPage.classes.after_comma_implements=after comma in implements clause |
| |
| WhiteSpaceTabPage.methods=Methods |
| WhiteSpaceTabPage.constructors=Constructors |
| |
| WhiteSpaceTabPage.fields=Fields |
| WhiteSpaceTabPage.fields.before_comma=before comma in multiple field declarations |
| WhiteSpaceTabPage.fields.after_comma=after comma in multiple field declarations |
| |
| WhiteSpaceTabPage.localvars=Local variables |
| WhiteSpaceTabPage.localvars.before_comma=before comma in multiple local declarations |
| WhiteSpaceTabPage.localvars.after_comma=after comma in multiple local declarations |
| |
| WhiteSpaceTabPage.arrayinit=Array initializers |
| WhiteSpaceTabPage.arraydecls=Array declarations |
| WhiteSpaceTabPage.arrayelem=Array element access |
| WhiteSpaceTabPage.arrayalloc=Array allocation |
| |
| WhiteSpaceTabPage.calls=Function invocations |
| |
| WhiteSpaceTabPage.calls.before_comma_in_method_args=before comma in method arguments |
| WhiteSpaceTabPage.calls.after_comma_in_method_args=after comma in method arguments |
| WhiteSpaceTabPage.calls.before_comma_in_alloc=before comma in object allocation arguments |
| WhiteSpaceTabPage.calls.after_comma_in_alloc=after comma in object allocation arguments |
| WhiteSpaceTabPage.calls.before_comma_in_qalloc=before comma in explicit constructor call |
| WhiteSpaceTabPage.calls.after_comma_in_qalloc=after comma in explicit constructor call |
| |
| WhiteSpaceTabPage.statements=Control statements |
| |
| WhiteSpaceTabPage.blocks=Blocks |
| |
| WhiteSpaceTabPage.switch='switch' |
| WhiteSpaceTabPage.switch.before_case_colon=before colon in case |
| WhiteSpaceTabPage.switch.before_default_colon=before colon in default |
| |
| WhiteSpaceTabPage.do='while' & 'do while' |
| |
| WhiteSpaceTabPage.synchronized='synchronized' |
| |
| WhiteSpaceTabPage.try='catch' |
| |
| WhiteSpaceTabPage.if='if else' |
| WhiteSpaceTabPage.assert='assert' |
| |
| WhiteSpaceTabPage.for='for' |
| WhiteSpaceTabPage.for.before_comma_init=before comma in initialization |
| WhiteSpaceTabPage.for.after_comma_init=after comma in initialization |
| WhiteSpaceTabPage.for.before_comma_inc=before comma in increments |
| WhiteSpaceTabPage.for.after_comma_inc=after comma in increments |
| |
| |
| WhiteSpaceTabPage.labels=Labels |
| WhiteSpaceTabPage.annotations=Annotations |
| WhiteSpaceTabPage.annotation_types=Annotation types |
| WhiteSpaceTabPage.enums=Enum types |
| WhiteSpaceTabPage.wildcardtype=Wildcard type |
| WhiteSpaceTabPage.param_type_ref=Type reference |
| WhiteSpaceTabPage.type_arguments=Type arguments |
| WhiteSpaceTabPage.type_parameters=Type parameters |
| |
| WhiteSpaceTabPage.conditionals=Conditionals |
| |
| WhiteSpaceTabPage.typecasts=Type casts |
| |
| WhiteSpaceTabPage.parenexpr=Parenthesized expressions |
| WhiteSpaceTabPage.declarations=Declarations |
| WhiteSpaceTabPage.expressions=Expressions |
| WhiteSpaceTabPage.arrays=Arrays |
| WhiteSpaceTabPage.parameterized_types=Parameterized types |
| |
| WhiteSpaceTabPage.category.label.text=&Category: |
| WhiteSpaceTabPage.checktable.label.text=Ins&ert white space: |
| |
| WhiteSpaceTabPage.after_opening_brace=after opening brace |
| WhiteSpaceTabPage.after_closing_brace=after closing brace |
| WhiteSpaceTabPage.before_opening_brace=before opening brace |
| WhiteSpaceTabPage.before_closing_brace=before closing brace |
| WhiteSpaceTabPage.between_empty_braces=between empty braces |
| |
| |
| WhiteSpaceTabPage.after_opening_paren=after opening parenthesis |
| WhiteSpaceTabPage.after_closing_paren=after closing parenthesis |
| WhiteSpaceTabPage.before_opening_paren=before opening parenthesis |
| WhiteSpaceTabPage.before_closing_paren=before closing parenthesis |
| WhiteSpaceTabPage.between_empty_parens=between empty parenthesis |
| |
| WhiteSpaceTabPage.after_opening_bracket=after opening bracket |
| WhiteSpaceTabPage.after_closing_bracket=after closing bracket |
| WhiteSpaceTabPage.before_opening_bracket=before opening bracket |
| WhiteSpaceTabPage.before_closing_bracket=before closing bracket |
| WhiteSpaceTabPage.between_empty_brackets=between empty brackets |
| |
| WhiteSpaceTabPage.before_comma_in_params=before comma in parameters |
| WhiteSpaceTabPage.after_comma_in_params=after comma in parameters |
| WhiteSpaceTabPage.before_comma_in_throws=before comma in 'throws' clause |
| WhiteSpaceTabPage.after_comma_in_throws=after comma in 'throws' clause |
| |
| WhiteSpaceTabPage.before_comma=before comma |
| WhiteSpaceTabPage.after_comma=after comma |
| |
| WhiteSpaceTabPage.after_semicolon=after semicolon |
| WhiteSpaceTabPage.before_semicolon=before semicolon |
| |
| WhiteSpaceTabPage.before_colon=before colon |
| WhiteSpaceTabPage.after_colon=after colon |
| |
| WhiteSpaceTabPage.before_question=before question mark |
| WhiteSpaceTabPage.after_question=after question mark |
| |
| WhiteSpaceTabPage.before_at=before @ |
| WhiteSpaceTabPage.after_at=after @ |
| |
| WhiteSpaceTabPage.after_opening_angle_bracket=after opening angle bracket |
| WhiteSpaceTabPage.after_closing_angle_bracket=after closing angle bracket |
| WhiteSpaceTabPage.before_opening_angle_bracket=before opening angle bracket |
| WhiteSpaceTabPage.before_closing_angle_bracket=before closing angle bracket |
| |
| WhiteSpaceTabPage.before_and_list=before '&' in type bounds |
| WhiteSpaceTabPage.after_and_list=after '&' in type bounds |
| |
| WhiteSpaceTabPage.enum_decl.before_opening_brace=before opening brace in declaration |
| WhiteSpaceTabPage.enum_decl.before_comma=before comma between constants |
| WhiteSpaceTabPage.enum_decl.after_comma=after comma between constants |
| |
| WhiteSpaceTabPage.enum_const_arg.before_opening_paren=before opening parenthesis in constant arguments |
| WhiteSpaceTabPage.enum_const_arg.after_opening_paren=after opening parenthesis in constant arguments |
| WhiteSpaceTabPage.enum_const_arg.between_empty_parens=between empty parenthesis in constant arguments |
| WhiteSpaceTabPage.enum_const_arg.before_comma=before comma in constant arguments |
| WhiteSpaceTabPage.enum_const_arg.after_comma=after comma in constant arguments |
| WhiteSpaceTabPage.enum_const_arg.before_closing_paren=before closing parenthesis in constant arguments |
| |
| WhiteSpaceTabPage.enum_const.before_opening_brace=before opening brace of constant body |
| |
| WhiteSpaceTabPage.annot_type_method.before_opening_paren=before opening parenthesis in annotation type members |
| WhiteSpaceTabPage.annot_type_method.between_empty_parens=between parenthesis in annotation type members |
| |
| |
| WhiteSpaceOptions.before=Before |
| WhiteSpaceOptions.after=After |
| WhiteSpaceOptions.between=Between |
| |
| WhiteSpaceOptions.operator=Operator |
| WhiteSpaceOptions.assignment_operator=Assignment operator |
| WhiteSpaceOptions.binary_operator=Binary operator |
| WhiteSpaceOptions.unary_operator=Unary operator |
| WhiteSpaceOptions.prefix_operator=Prefix operator |
| WhiteSpaceOptions.postfix_operator=Postfix operator |
| |
| |
| WhiteSpaceOptions.opening_paren=Opening parenthesis |
| WhiteSpaceOptions.catch='catch' |
| WhiteSpaceOptions.for='for' |
| WhiteSpaceOptions.if='if' |
| WhiteSpaceOptions.switch='switch' |
| WhiteSpaceOptions.synchronized='synchronized' |
| WhiteSpaceOptions.while='while' |
| WhiteSpaceOptions.assert='assert' |
| WhiteSpaceOptions.member_function_declaration=Member function declaration |
| WhiteSpaceOptions.constructor=Constructor |
| WhiteSpaceOptions.method=Method |
| WhiteSpaceOptions.method_call=Method call |
| WhiteSpaceOptions.paren_expr=Parenthesized expression |
| WhiteSpaceOptions.enum_constant_body=Enum constant body |
| WhiteSpaceOptions.enum_constant_arguments=Enum constant arguments |
| WhiteSpaceOptions.enum_declaration=Enum declaration |
| WhiteSpaceOptions.annotation_modifier=Annotation |
| WhiteSpaceOptions.annotation_modifier_args=Annotation arguments |
| WhiteSpaceOptions.annotation_type_member=Annotation type member |
| WhiteSpaceOptions.annotation_type=Annotation type |
| |
| WhiteSpaceOptions.type_cast=Type cast |
| WhiteSpaceOptions.parameterized_type=Parameterized type |
| WhiteSpaceOptions.type_arguments=Type arguments |
| WhiteSpaceOptions.type_parameters=Type parameters |
| |
| WhiteSpaceOptions.closing_paren=Closing parenthesis |
| WhiteSpaceOptions.method_call=Method call |
| |
| WhiteSpaceOptions.opening_brace=Opening brace |
| WhiteSpaceOptions.closing_brace=Closing brace |
| WhiteSpaceOptions.opening_bracket=Opening bracket |
| WhiteSpaceOptions.closing_bracket=Closing bracket |
| WhiteSpaceOptions.opening_angle_bracket=Opening angle bracket |
| WhiteSpaceOptions.closing_angle_bracket=Closing angle bracket |
| WhiteSpaceOptions.class_decl=Type declaration |
| WhiteSpaceOptions.anon_class_decl=Anonymous type declaration |
| WhiteSpaceOptions.initializer=Array initializer |
| WhiteSpaceOptions.block=Block |
| WhiteSpaceOptions.switch='switch' |
| |
| WhiteSpaceOptions.array_decl=Array declaration |
| WhiteSpaceOptions.array_element_access=Array element access |
| WhiteSpaceOptions.array_alloc=Array allocation |
| WhiteSpaceOptions.array_init=Array initializer |
| |
| WhiteSpaceOptions.arguments=Arguments |
| WhiteSpaceOptions.initialization=Initialization |
| WhiteSpaceOptions.incrementation=Incrementation |
| WhiteSpaceOptions.parameters=Parameters |
| |
| WhiteSpaceOptions.explicit_constructor_call=Explicit constructor call |
| WhiteSpaceOptions.alloc_expr=Allocation expression |
| WhiteSpaceOptions.throws='throws' clause |
| WhiteSpaceOptions.mult_decls=Multiple declarations |
| WhiteSpaceOptions.local_vars=Local variables |
| WhiteSpaceOptions.fields=Fields |
| WhiteSpaceOptions.implements_clause='extends'/'implements' clause |
| WhiteSpaceOptions.colon=Colon |
| WhiteSpaceOptions.conditional=Conditional |
| WhiteSpaceOptions.wildcard=Wildcard type |
| WhiteSpaceOptions.label=Label |
| WhiteSpaceOptions.comma=Comma |
| |
| WhiteSpaceOptions.semicolon=Semicolon |
| WhiteSpaceOptions.question_mark=Question mark |
| WhiteSpaceOptions.at=@ |
| WhiteSpaceOptions.and=& |
| WhiteSpaceOptions.between_empty_parens=Between empty parenthesis |
| WhiteSpaceOptions.between_empty_braces=Between empty braces |
| WhiteSpaceOptions.between_empty_brackets=Between empty brackets |
| WhiteSpaceOptions.constructor_decl=Constructor declaration |
| WhiteSpaceOptions.method_decl=Method declaration |
| WhiteSpaceOptions.case='case' |
| WhiteSpaceOptions.default='default' |
| WhiteSpaceOptions.statements=Statements |
| |
| |
| |
| WhiteSpaceOptions.before_opening_paren=Before opening parenthesis |
| WhiteSpaceOptions.after_opening_paren=After opening parenthesis |
| WhiteSpaceOptions.before_closing_paren=Before closing parenthesis |
| |
| WhiteSpaceOptions.after_closing_paren=After closing parenthesis |
| WhiteSpaceOptions.between_empty_parens=Between empty parenthesis |
| WhiteSpaceOptions.before_opening_brace=Before opening brace |
| WhiteSpaceOptions.after_opening_brace=After opening brace |
| WhiteSpaceOptions.after_closing_brace=After closing brace |
| WhiteSpaceOptions.before_closing_brace=Before closing brace |
| WhiteSpaceOptions.between_empty_braces=Between empty braces |
| WhiteSpaceOptions.before_opening_bracket=Before opening bracket |
| WhiteSpaceOptions.after_opening_bracket=After opening bracket |
| WhiteSpaceOptions.between_empty_brackets=Between empty brackets |
| WhiteSpaceOptions.before_closing_bracket=Before closing bracket |
| |
| WhiteSpaceOptions.before_opening_angle_bracket=Before opening angle bracket |
| WhiteSpaceOptions.after_opening_angle_bracket=After opening angle bracket |
| WhiteSpaceOptions.before_closing_angle_bracket=Before closing angle bracket |
| WhiteSpaceOptions.after_closing_angle_bracket=After closing angle bracket |
| |
| WhiteSpaceOptions.before_operator=Before operator |
| WhiteSpaceOptions.after_operator=After operator |
| WhiteSpaceOptions.before_comma=Before comma |
| WhiteSpaceOptions.after_comma=After comma |
| WhiteSpaceOptions.after_colon=After colon |
| WhiteSpaceOptions.before_colon=Before colon |
| WhiteSpaceOptions.before_semicolon=Before semicolon |
| WhiteSpaceOptions.after_semicolon=After semicolon |
| WhiteSpaceOptions.before_question_mark=Before question mark |
| WhiteSpaceOptions.after_question_mark=After question mark |
| WhiteSpaceOptions.before_at=Before @ |
| WhiteSpaceOptions.after_at=After @ |
| |
| WhiteSpaceOptions.before_and=Before & list |
| WhiteSpaceOptions.after_and=After & list |
| |
| WhiteSpaceTabPage.insert_space=&Insert space: |
| |
| |
| LineWrappingTabPage.compact_if_else=Compact 'if else' |
| LineWrappingTabPage.extends_clause='extends' clause |
| LineWrappingTabPage.enum_arguments=Constant list |
| LineWrappingTabPage.implements_clause='implements' clause |
| LineWrappingTabPage.parameters=Parameters |
| LineWrappingTabPage.arguments=Arguments |
| LineWrappingTabPage.qualified_invocations=Qualified invocations |
| LineWrappingTabPage.throws_clause='throws' clause |
| LineWrappingTabPage.object_allocation=Object allocation arguments |
| LineWrappingTabPage.qualified_object_allocation=Qualified object allocation arguments |
| LineWrappingTabPage.array_init=Array initializers |
| LineWrappingTabPage.explicit_constructor_invocations=Explicit constructor invocations |
| LineWrappingTabPage.conditionals=Conditionals |
| LineWrappingTabPage.binary_exprs=Binary expressions |
| LineWrappingTabPage.indentation.default=Default indentation |
| LineWrappingTabPage.indentation.on_column=Indent on column |
| LineWrappingTabPage.indentation.by_one=Indent by one |
| LineWrappingTabPage.class_decls=Class Declarations |
| LineWrappingTabPage.method_decls=Method Declarations |
| LineWrappingTabPage.constructor_decls=Constructor declarations |
| LineWrappingTabPage.function_calls=Function Calls |
| LineWrappingTabPage.expressions=Expressions |
| LineWrappingTabPage.statements=Statements |
| LineWrappingTabPage.enum_decls='enum' declaration |
| LineWrappingTabPage.category.label.text=&Category: |
| LineWrappingTabPage.wrapping_policy.label.text=Lin&e wrapping policy: |
| LineWrappingTabPage.indentation_policy.label.text=Indent&ation policy: |
| LineWrappingTabPage.force_split.checkbox.text=&Force split |
| LineWrappingTabPage.line_width_for_preview.label.text=&Set line width for preview window: |
| LineWrappingTabPage.group=Settings for |
| LineWrappingTabPage.splitting.do_not_split=Do not wrap |
| LineWrappingTabPage.splitting.wrap_when_necessary=Wrap only when necessary |
| LineWrappingTabPage.splitting.always_wrap_first_others_when_necessary=Always wrap first element, others when necessary |
| LineWrappingTabPage.splitting.wrap_always=Wrap all elements, every element on a new line |
| LineWrappingTabPage.splitting.wrap_always_indent_all_but_first=Wrap all elements, indent all but the first element |
| LineWrappingTabPage.splitting.wrap_always_except_first_only_if_necessary=Wrap all elements, except first element if not necessary |
| LineWrappingTabPage.width_indent=Line width and indentation levels |
| LineWrappingTabPage.width_indent.option.max_line_width=Ma&ximum line width: |
| LineWrappingTabPage.width_indent.option.default_indent_wrapped=Defa&ult indentation for wrapped lines: |
| LineWrappingTabPage.width_indent.option.default_indent_array=Default indentation for arra&y initializers: |
| LineWrappingTabPage.line_wrapping_group=Line wrapping settings |
| LineWrappingTabPage.error.invalid_value=The key ''{0}'' contained an invalid value; resetting to defaults. |
| LineWrappingTabPage.enum_superinterfaces='implements' clause |
| |
| |
| AlreadyExistsDialog.message.profile_already_exists=A profile with this name already exists. |
| AlreadyExistsDialog.message.profile_name_empty=Profile name is empty |
| AlreadyExistsDialog.dialog.title=Load Profile |
| AlreadyExistsDialog.dialog.label=A profile with the name ''{0}'' already exists in this workspace. What would you like to do? |
| AlreadyExistsDialog.rename_radio_button.desc=&Rename the imported profile: |
| AlreadyExistsDialog.overwrite_radio_button.desc=&Overwrite the existing profile. |
| |
| |
| BlankLinesTabPage.preview.header=Blank Lines |
| BlankLinesTabPage.compilation_unit.group.title=Blank lines in compilation unit |
| BlankLinesTabPage.compilation_unit.option.before_package=Before p&ackage declaration: |
| BlankLinesTabPage.compilation_unit.option.after_package=After packa&ge declaration: |
| BlankLinesTabPage.compilation_unit.option.before_import=&Before import declaration: |
| BlankLinesTabPage.compilation_unit.option.after_import=After import de&claration: |
| BlankLinesTabPage.compilation_unit.option.between_type_declarations=Between class declarat&ions: |
| |
| BlankLinesTabPage.class.group.title=Blank lines within class declarations |
| BlankLinesTabPage.class.option.before_first_decl=Before &first declaration: |
| BlankLinesTabPage.class.option.before_decls_of_same_kind=Before declarations of the same &kind: |
| BlankLinesTabPage.class.option.before_member_class_decls=Before member cla&ss declarations: |
| BlankLinesTabPage.class.option.before_field_decls=B&efore field declarations: |
| BlankLinesTabPage.class.option.before_method_decls=Before met&hod declarations: |
| BlankLinesTabPage.class.option.at_beginning_of_method_body= At beginning of method bod&y: |
| |
| BlankLinesTabPage.blank_lines.group.title=Existing blank lines |
| BlankLinesTabPage.blank_lines.option.empty_lines_to_preserve=N&umber of empty lines to preserve: |
| |
| BracesTabPage.preview.header=Braces |
| BracesTabPage.position.same_line=Same line |
| BracesTabPage.position.next_line=Next line |
| BracesTabPage.position.next_line_indented=Next line indented |
| BracesTabPage.position.next_line_on_wrap=Next line on wrap |
| |
| BracesTabPage.group.brace_positions.title=Brace positions |
| BracesTabPage.option.class_declaration=&Class declaration: |
| BracesTabPage.option.anonymous_class_declaration=Anon&ymous class declaration: |
| BracesTabPage.option.method_declaration=Met&hod declaration: |
| BracesTabPage.option.constructor_declaration=Constr&uctor declaration: |
| BracesTabPage.option.blocks=&Blocks: |
| BracesTabPage.option.blocks_in_case=Bloc&ks in case statement: |
| BracesTabPage.option.switch_case='&switch' statement: |
| BracesTabPage.option.array_initializer=Array initiali&zer: |
| BracesTabPage.option.keep_empty_array_initializer_on_one_line=Keep empty array &initializer on one line |
| BracesTabPage.option.enum_declaration=&Enum declaration: |
| BracesTabPage.option.enumconst_declaration=Enum c&onstant body: |
| BracesTabPage.option.annotation_type_declaration=&Annotation type declaration: |
| CodingStyleConfigurationBlock.save_profile.dialog.title=Export Profile |
| CodingStyleConfigurationBlock.save_profile.error.title=Export Profile |
| CodingStyleConfigurationBlock.save_profile.error.message=Could not export the profiles. |
| CodingStyleConfigurationBlock.load_profile.dialog.title=Import Profile |
| CodingStyleConfigurationBlock.load_profile.error.title=Import Profile |
| CodingStyleConfigurationBlock.load_profile.error.message=Import failed. Not a valid profile. |
| CodingStyleConfigurationBlock.load_profile.error_too_new.title=Importing Profile |
| CodingStyleConfigurationBlock.load_profile.error_too_new.message=This profile has been created with \ |
| a more recent Eclipse build than the one you are using. Due to changes in the code formatter, \ |
| some older settings might be reset to their default values and newer settings are ignored. Please note \ |
| that upgrading profiles from older to newer builds is fully supported. |
| CodingStyleConfigurationBlock.preview.title=A sample source file for the code formatter preview |
| |
| CodingStyleConfigurationBlock.edit_button.desc=&Edit... |
| CodingStyleConfigurationBlock.show_button.desc=&Show... |
| CodingStyleConfigurationBlock.rename_button.desc=Re&name... |
| CodingStyleConfigurationBlock.remove_button.desc=&Remove |
| CodingStyleConfigurationBlock.new_button.desc=Ne&w... |
| CodingStyleConfigurationBlock.load_button.desc=I&mport... |
| CodingStyleConfigurationBlock.save_button.desc=E&xport... |
| CodingStyleConfigurationBlock.preview_label.text=Prev&iew: |
| CodingStyleConfigurationBlock.error.reading_xml.message=Problems reading profiles from XML |
| CodingStyleConfigurationBlock.error.serializing_xml.message=Problems serializing the profiles to XML |
| CodingStyleConfigurationBlock.delete_confirmation.title=Confirm Remove |
| CodingStyleConfigurationBlock.delete_confirmation.question=Are you sure you want to remove profile ''{0}''? |
| |
| |
| CommentsTabPage.group1.title=General settings |
| CommentsTabPage.enable_comment_formatting=Enable &comment formatting |
| CommentsTabPage.format_header=Format &header comment |
| CommentsTabPage.format_html=Format HTML ta&gs |
| CommentsTabPage.format_code_snippets=Format &Java code snippets |
| |
| CommentsTabPage.group2.title=Javadoc comment settings |
| CommentsTabPage.clear_blank_lines=Clear &blank lines in comments |
| CommentsTabPage.blank_line_before_javadoc_tags=Blan&k line before Javadoc tags |
| CommentsTabPage.indent_javadoc_tags=Indent Javadoc tag&s |
| CommentsTabPage.indent_description_after_param=Indent description a&fter @param |
| CommentsTabPage.new_line_after_param_tags=New line &after @param tags |
| CommentsTabPage.group3.title=Line width |
| CommentsTabPage.line_width=Ma&ximum line width for comments: |
| |
| |
| ControlStatementsTabPage.preview.header=If...else |
| ControlStatementsTabPage.general_group.title=General |
| ControlStatementsTabPage.general_group.insert_new_line_before_else_statements=Insert new line before '&else' in an 'if' statement |
| ControlStatementsTabPage.general_group.insert_new_line_before_catch_statements=Insert new line before '&catch' in a 'try' statement |
| ControlStatementsTabPage.general_group.insert_new_line_before_finally_statements=Insert new line before '&finally' in a 'try' statement |
| ControlStatementsTabPage.general_group.insert_new_line_before_while_in_do_statements=Insert new line before 'whil&e' in a 'do' statement |
| |
| ControlStatementsTabPage.if_else_group.title='if else' |
| ControlStatementsTabPage.if_else_group.keep_then_on_same_line=Keep 't&hen' statement on same line |
| ControlStatementsTabPage.if_else_group.keep_simple_if_on_one_line=Keep &simple 'if' on one line |
| ControlStatementsTabPage.if_else_group.keep_else_on_same_line=Keep 'else' st&atement on same line |
| ControlStatementsTabPage.if_else_group.keep_else_if_on_one_line=&Keep 'else if' on one line |
| ControlStatementsTabPage.if_else_group.keep_guardian_clause_on_one_line=Keep 'return' or 'throw' cla&use on one line |
| |
| CreateProfileDialog.status.message.profile_with_this_name_already_exists=A profile with this name already exists. |
| CreateProfileDialog.status.message.profile_name_is_empty=Profile name is empty |
| CreateProfileDialog.dialog.title=New Code Formatter Profile |
| CreateProfileDialog.profile_name.label.text=&Profile name: |
| CreateProfileDialog.base_profile.label.text=I&nitialize settings with the following profile: |
| CreateProfileDialog.open_edit_dialog.checkbox.text=&Open the edit dialog now |
| |
| IndentationTabPage.preview.header=Indentation |
| |
| IndentationTabPage.general_group.title=General settings |
| IndentationTabPage.general_group.option.tab_size=Tab si&ze: |
| IndentationTabPage.general_group.option.use_tab_char=U&se tab character |
| |
| IndentationTabPage.field_alignment_group.title=Alignment of fields in class declarations |
| IndentationTabPage.field_alignment_group.align_fields_in_columns=&Align fields in columns |
| |
| IndentationTabPage.indent_group.title=Indent |
| |
| IndentationTabPage.class_group.title=Class body |
| IndentationTabPage.class_group.option.indent_declarations_within_class_body=Declarations within class &body |
| IndentationTabPage.class_group.option.indent_declarations_within_enum_const=Declarations within en&um constants |
| IndentationTabPage.class_group.option.indent_declarations_within_enum_decl=De&clarations within enum declaration |
| IndentationTabPage.block_group.title=Block body |
| IndentationTabPage.block_group.option.indent_statements_compare_to_body=Stat&ements within method/constructor body |
| IndentationTabPage.block_group.option.indent_statements_compare_to_block=Statements within bl&ocks |
| |
| IndentationTabPage.switch_group.title=Switch statement |
| IndentationTabPage.switch_group.option.indent_statements_within_switch_body=Statements wit&hin 'switch' body |
| IndentationTabPage.switch_group.option.indent_statements_within_case_body=Statements within 'case' bod&y |
| IndentationTabPage.switch_group.option.indent_break_statements='brea&k' statements |
| |
| ModifyDialog.dialog.title=Edit Profile ''{0}'' |
| ModifyDialog.dialog.show.title=Show Profile ''{0}'' |
| ModifyDialog.dialog.show.warning.builtin=This is a built-in profile, you will be prompted to enter a new name after closing this dialog. |
| ModifyDialog.tabpage.braces.title=B&races |
| ModifyDialog.tabpage.indentation.title=In&dentation |
| ModifyDialog.tabpage.whitespace.title=&White Space |
| ModifyDialog.tabpage.blank_lines.title=Bla&nk Lines |
| ModifyDialog.tabpage.new_lines.title=New &Lines |
| ModifyDialog.tabpage.control_statements.title=Con&trol Statements |
| ModifyDialog.tabpage.line_wrapping.title=Line Wra&pping |
| ModifyDialog.tabpage.comments.title=Co&mments |
| ModifyDialogTabPage.preview.label.text=Pre&view: |
| |
| |
| NewLinesTabPage.preview.header=New Lines |
| NewLinesTabPage.newlines_group.title=Insert new line |
| NewLinesTabPage.newlines_group.option.empty_class_body=in empty &class body |
| NewLinesTabPage.newlines_group.option.empty_anonymous_class_body=in empty &anonymous class body |
| NewLinesTabPage.newlines_group.option.empty_enum_declaration=in empty &enum declaration |
| NewLinesTabPage.newlines_group.option.empty_enum_constant=in empty enum c&onstant body |
| NewLinesTabPage.newlines_group.option.empty_method_body=in empt&y method body |
| NewLinesTabPage.newlines_group.option.empty_block=in empty &block |
| NewLinesTabPage.empty_statement_group.title=Empty statements |
| NewLinesTabPage.emtpy_statement_group.option.empty_statement_on_new_line=Put empty &statement on new line |
| NewLinesTabPage.existing_breaks_group.title=Existing line breaks |
| NewLinesTabPage.existing_breaks_group.preserve_existing_line_breaks=Preserve e&xisting line breaks |
| |
| NewLinesTabPage.arrayInitializer_group.title=Array Initializers |
| NewLinesTabPage.array_group.option.after_opening_brace_of_array_initializer=Insert new line after openin&g brace of array initializer |
| NewLinesTabPage.array_group.option.before_closing_brace_of_array_initializer=Insert new line be&fore closing brace of array initializer |
| |
| |
| ProfileManager.default_profile.name=Eclipse 2.1 [built-in] |
| ProfileManager.java_conventions_profile.name=Java Conventions [built-in] |
| |
| RenameProfileDialog.status.message.profile_with_this_name_already_exists=A profile with this name already exists. |
| RenameProfileDialog.status.message.profile_name_empty=Profile name is empty |
| RenameProfileDialog.dialog.title=Rename Profile |
| RenameProfileDialog.dialog.label.enter_a_new_name=Please &enter a new name: |
| |
| |
| ModifyDialogTabPage.error_msg.values_text_unassigned=Values and text must be assigned. |
| ModifyDialogTabPage.error_msg.values_items_text_unassigned=Values, items and text must be assigned. |
| |
| ModifyDialogTabPage.NumberPreference.error.invalid_key=The key {0} does not yield a valid integer value. |
| ModifyDialogTabPage.NumberPreference.error.invalid_value=Invalid value: Please enter a number between {0} and {1}. |
| JavaPreview.formatter_exception=The formatter threw an unhandled exception while formatting the preview. |
| WhiteSpaceTabPage.sort_by_java_element=Sort options by Java element |
| WhiteSpaceTabPage.sort_by_syntax_element=Sort options by Syntax element |
