| readonly.occurences.found=Occurrences found in read-only files |
| progress.text=Looking for Usages |
| usageView.tabText=Refactoring Preview |
| usageView.usagesText=usages |
| usageView.need.reRun=Cannot perform refactoring operation.\nThere were changes in code after usages have been found.\nPlease perform usage search again. |
| usageView.doAction=&Do Refactor |
| statusBar.refactoring.result={0, choice, 1#1 occurrence|2#{0,number} occurrences} changed |
| statusBar.noUsages=No occurrences found |
| anonymousToInner.refactoring.name=Convert Anonymous to Inner |
| anonymousToInner.no.inner.class.name=Class name should be specified |
| inner.class.exists=Inner class named ''{0}'' is already defined\nin class ''{1}'' |
| anonymousToInner.class.name.label.text=Class name: |
| anonymousToInner.make.class.static.checkbox.text=Make class &static |
| anonymousToInner.parameters.panel.border.title=Constructor Parameters |
| error.wrong.caret.position.method=Caret should be positioned inside method to be refactored |
| error.wrong.caret.position.constructor=Caret should be positioned inside constructor to be refactored |
| error.wrong.caret.position.method.or.class.name=Caret should be positioned at the name of method or class to be refactored |
| error.wrong.caret.position.method.or.variable.name=Caret should be positioned at the name of method or variable to be refactored |
| error.wrong.caret.position.anonymous=Caret should be positioned inside anonymous class to be refactored |
| error.wrong.caret.position.class=Caret should be positioned inside class to be refactored |
| error.wrong.caret.position.method.or.local.name=Caret should be positioned at the name of element to be refactored |
| error.wrong.caret.position.local.name=Caret should be positioned at the name of local variable to be refactored |
| error.wrong.caret.position.local.or.expression.name=Caret should be positioned at the name of local variable or expression to be refactored |
| error.wrong.caret.position.symbol.to.rename=Caret should be positioned at symbol to be renamed |
| error.wrong.caret.position.symbol.to.refactor=Caret should be positioned at symbol to be refactored |
| error.out.of.project.element=Selected {0} is not located inside project. |
| error.in.injected.lang.prefix.suffix=Selected {0} is located in the read-only part of injected language document |
| error.cannot.be.renamed=This element cannot be renamed |
| to.refactor=to refactor |
| error.cannot.resolve=Cannot resolve {0} |
| error.incorrect.data=Incorrect Data |
| error.wrong.name.input=Wrong name: {0} |
| error.not.supported.for.jsp={0} refactoring is not supported for JSP |
| changeClassSignature.refactoring.name=Change Class Signature |
| changeClassSignature.no.type.parameters=Class cannot have type parameters |
| changeClassSignature.parameters.panel.border.title=Parameters |
| changeClassSignature.bad.default.value=Wrong default value: ''{0}'' for parameter ''{1}'' |
| changeClassSignature.class.label.text=Change signature of {0} |
| changeSignature.no.type.for.parameter=Specify type for parameter ''{0}'' |
| changeSignature.no.type.for.exception=Specify type for exception |
| changeSignature.refactoring.name=Change Signature |
| column.name.name=Name: |
| changeSignature.default.value.column=Default Value |
| parameters.border.title=Parameters |
| changeSignature.exceptions.panel.border.title=Exceptions |
| changeSignature.propagate.parameters.title=Propa&gate Parameters... |
| changeSignature.propagate.exceptions.title=Propagate E&xceptions... |
| changeSignature.parameter.caller.chooser=Select Methods To Propagate New Parameters |
| changeSignature.exception.caller.chooser=Select Methods To Propagate New Exceptions |
| changeSignature.return.type.prompt=Return &type: |
| changeSignature.name.prompt=&Name: |
| name.prompt=&Name |
| signature.preview.border.title=Signature Preview |
| changeSignature.parameters.wont.propagate=Recursive propagation of parameter changes won't be performed |
| changeSignature.exceptions.wont.propagate=Recursive propagation of exception changes won't be performed |
| changeSignature.wrong.return.type=Wrong return type: ''{0}'' |
| changeSignature.no.return.type=Return type is not specified |
| changeSignature.cannot.resolve.return.type=Return type ''{0}'' cannot be resolved.\nContinue? |
| changeSignature.wrong.type.for.parameter=Wrong type: ''{0}'' for parameter ''{1}'' |
| changeSignature.wrong.type.for.exception=Wrong type: ''{0}'' for exception |
| changeSignature.vararg.not.last=Vararg parameter should be the last in method signature |
| changeSignature.no.default.value=New parameter ''{0}'' has been added.\nSpecify default value to be used in all existing calls of this method. |
| changeSignature.not.throwable.type=Wrong type ''{0}'' for exception, should extend java.lang.Throwable |
| changeSignature.cannot.resolve.parameter.type=Type ''{0}'' for parameter ''{1}'' cannot be resolved.\nContinue? |
| search.in.comments.and.strings=Search in &comments and strings |
| search.for.text.occurrences=Search for &text occurrences |
| visibility.as.is=&As is |
| visibility.escalate=&Escalate |
| visibility.public=Pu&blic |
| visibility.protected=Pr&otected |
| visibility.private=Pri&vate |
| visibility.package.local=Pac&kage local |
| visibility.border.title=Visibility |
| visibility.combo.title=&Visibility: |
| moveInstanceMethod.select.an.instance.parameter=Select an &instance parameter: |
| destination.package=Destination &package: |
| choose.destination.package=Choose Destination Package |
| interface.name.prompt=&Interface name: |
| package.for.new.interface=&Package for new interface: |
| turnRefsToSuper.change.usages.to=&Change usages of {0} to: |
| turnRefsToSuper.use.superclass.in.instanceof=&Use interface/superclass in instanceof |
| class.name.prompt=Class &name: |
| parameter.name.prompt=Parameter na&me\: |
| no.class.name.specified=No class name specified |
| no.parameter.name.specified=No parameter name specified |
| pass.outer.class.instance.as.parameter=Pass &outer class' instance as a parameter |
| pull.up.members.to=P&ull up members of {0} to: |
| members.to.be.pulled.up=Mem&bers to be pulled up |
| make.abstract=Make abstract |
| javadoc.for.abstracts=JavaDoc for abstracts |
| extractIncludeFile.name=Extract Include File |
| file.already.exist=File {0} already exists |
| file.already.exist.title=Extract Include File |
| name.for.extracted.include.file=&Name for extracted include file (default extension: {0}) |
| extract.to.directory=Extract to &directory: |
| select.target.directory=Select target directory |
| select.target.directory.description=The file will be created in this directory |
| create.directory=Create directory |
| replace.inheritance.from=&Replace with delegation inheritance from: |
| field.name=&Field name: |
| inner.class.name=&Inner class name: |
| superclass.name=&Super class name: |
| delegate.members=Delegate mem&bers |
| generate.getter.for.delegated.component=Generate &getter for delegated component |
| package.for.new.superclass=&Package for new superclass: |
| package.for.original.class=&Package for original class: |
| package.for.original.interface=&Package for original interface: |
| ExtractSuperClass.superclass=Superclass |
| members.to.form.superclass=Mem&bers to form superclass |
| no.superclass.name.specified=No superclass name specified |
| extract.superclass.from=Extract superclass from: |
| extractSuper.extract=E&xtract {0} |
| extractSuper.rename.original.class=R&ename original class and use {0} where possible |
| extractSuper.rename.original.class.to=&Rename original class to: |
| extractSuperInterface.interface=Interface |
| members.to.form.interface=Mem&bers to form interface |
| extract.interface.from=Extract interface from: |
| rename.implementation.class.to=Rename implementation class to: |
| rename.original.interface.to=Rename original interface to: |
| extractSuperInterface.javadoc=JavaDoc |
| no.interface.name.specified=No interface name specified |
| replace.all.occurences=Replace &all occurrences ({0} occurrences) |
| declare.final=Declare &final |
| introduce.parameter.title=Extract Parameter |
| parameter.of.type=Parameter of &type: |
| use.variable.initializer.to.initialize.parameter=Use variable &initializer to initialize parameter |
| replace.fields.used.in.expressions.with.their.getters=Replace fields used in expressions with their getters |
| do.not.replace=Do ¬ replace |
| replace.fields.inaccessible.in.usage.context=Replace fields &inaccessible in usage context |
| replace.all.fields=&Replace all fields |
| class.does.not.exist.in.the.project=Class does not exist in project. Do you want to create it? |
| no.field.name.specified=No field name specified |
| field.exists=Field with name {0}\nalready exists in class ''{1}''.\nContinue? |
| choose.destination.class=Choose Destination Class |
| replace.write.access.occurrences=Rep&lace write access occurrences |
| |
| # introduce variable |
| introduce.variable.title=Extract Variable |
| refactoring.introduce.context.error=Cannot perform refactoring in this context |
| refactoring.introduceVariable=Extract Variable refactoring |
| refactoring.introduce.selection.error=Cannot perform refactoring using selected element(s) |
| refactoring.introduce.name.error=Incorrect name |
| refactoring.introduce.name.used.error=This name is already used |
| refactoring.introduce.variable.scope.error=Name clashes with existing variable |
| refactoring.introduce.placing.error=Cannot extract {0} variable |
| |
| variable.of.type=Variable of &type: |
| convert.to.instance.method.title=Convert To Instance Method |
| convertToInstanceMethod.method.is.not.static=Cannot perform the refactoring\nMethod {0} is not static |
| convertToInstanceMethod.no.parameters.with.reference.type=There are no parameters that have reference type |
| convertToInstanceMethod.all.reference.type.parametres.have.unknown.types=All reference type parameters have unknown types |
| convertToInstanceMethod.all.reference.type.parameters.are.not.in.project=All reference type parameters have types that are not in project |
| cannot.perform.refactoring=Cannot perform refactoring. |
| move.instance.method.title=Move Instance Method |
| move.method.is.not.supported.for.constructors=Move method is not supported for constructors |
| move.method.is.not.supported.for.generic.classes=Move method is not supported for generic classes |
| move.method.is.not.supported.when.method.is.part.of.inheritance.hierarchy=Move method is not supported when method is a part of inheritance hierarchy |
| synthetic.jsp.class.is.referenced.in.the.method=Synthetic jsp class is referenced in method |
| there.are.no.variables.that.have.reference.type=There are no variables that have reference type |
| all.candidate.variables.have.unknown.types=All candidate variables have unknown types |
| all.candidate.variables.have.types.not.in.project=All candidate variables have types that are not in project |
| use.interface.where.possible.title=Use Interface Where Possible |
| interface.does.not.have.base.interfaces=Interface {0} does not have base interfaces |
| the.field.should.be.declared.in.a.class=The field should be declared in a class |
| encapsulate.fields.title=Encapsulate Fields |
| fields.to.be.refactored.should.belong.to.the.same.class=Fields to be refactored should belong to the same class |
| encapsulate.fields.refactoring.cannot.be.applied.to.interface=Encapsulate fields refactoring cannot be applied to interface |
| extract.interface.title=Extract Interface |
| extract.interface.command.name=Extracting interface {0} from {1} |
| extract.method.title=Extract Method |
| selected.block.contains.invocation.of.another.class.constructor=Selected block contains invocation of another class constructor |
| selected.block.should.represent.a.set.of.statements.or.an.expression=Selected block should represent a set of statements or an expression |
| press.escape.to.remove.the.highlighting=Press Escape to remove the highlighting |
| extract.superclass.title=Extract Superclass |
| extract.superclass.command.name=Extracting superclass {0} from {1} |
| superclass.cannot.be.extracted.from.an.interface=Superclass cannot be extracted from interface |
| superclass.cannot.be.extracted.from.an.enum=Superclass cannot be extracted from enum |
| replace.inheritance.with.delegation.title=Replace Inheritance With Delegation |
| class.is.interface={0} is an interface. |
| class.does.not.have.base.classes.or.interfaces=Class {0} does not have base classes or interfaces |
| inline.title=Inline |
| introduce.constant.title=Extract Constant |
| introduce.selection.error=Cannot perform refactoring using selected element(s) |
| selected.expression.cannot.be.a.constant.initializer=Selected expression cannot be a constant initializer |
| variable.does.not.have.an.initializer=Variable {0} does not have an initializer. |
| initializer.for.variable.cannot.be.a.constant.initializer=Initializer for variable {0} cannot be a constant initializer |
| cannot.introduce.field.in.interface=Cannot extract field in the interface |
| introduce.field.title=Extract Field |
| selected.block.should.represent.an.expression=Selected block should represent an expression |
| is.not.supported.in.the.current.context={0} is not supported in current context |
| type.of.the.selected.expression.cannot.be.determined=Type of selected expression cannot be determined. |
| selected.expression.has.void.type=Selected expression has void type. |
| to.rename=to rename |
| to.delete.with.usage.search=to delete (with usage search) |
| unknown.expression.type=Unknown expression type. |
| invalid.expression.context=Invalid expression context. |
| refactoring.is.not.supported.in.the.current.context={0} refactoring is not supported in the current context |
| cannot.introduce.variable.in.super.constructor.call=Cannot extract variable in super constructor call |
| is.modified.in.loop.body={0} is modified in loop body |
| introducing.variable.may.break.code.logic=Introducing variable may break code logic |
| no.selection=No selection. |
| selection.does.not.form.a.fragment.for.extraction=Selection does not form a fragment for extraction |
| cannot.extract.selected.elements.into.include.file=Cannot extract selected elements into include file |
| the.language.for.selected.elements.has.no.associated.file.type=The language for selected elements has no associated file type |
| extract.include.file.title=Extract include file |
| replace.fragment=Replace Fragment |
| idea.has.found.fragments.that.can.be.replaced.with.include.directive={0} has found fragments that can be replaced with include directive\nDo you want to review them? |
| remove.duplicates.command=Remove Duplicates |
| make.method.static.title=Make Method Static |
| constructor.cannot.be.made.static=Constructor cannot be made static |
| this.member.does.not.seem.to.belong.to.any.class=This member does not seem to belong to any class |
| member.is.already.static=Member is already static |
| cannot.make.abstract.method.static=Cannot make abstract method static |
| inner.classes.cannot.have.static.members=Inner classes cannot have static members |
| pull.members.up.title=Pull Members Up |
| the.caret.should.be.positioned.inside.a.class.to.pull.members.from=Caret should be positioned inside a class to pull members from |
| class.does.not.have.base.classes.interfaces.in.current.project={0} does not have base classes/interfaces in current project |
| pullUp.command=Pulling members up from {0} |
| push.members.down.title=Push Members Down |
| the.caret.should.be.positioned.inside.a.class.to.push.members.from=Caret should be positioned inside a class to push members from |
| move.title=Move |
| the.caret.should.be.positioned.at.the.class.method.or.field.to.be.refactored=Caret should be positioned at the class, method or field to be refactored |
| select.refactoring.title=Select Refactoring |
| what.would.you.like.to.do=What would you like to do? |
| move.packages.to.another.package=Move {0} &packages to another package |
| move.package.to.another.package=Move &package ''{0}'' to another package |
| move.directories.to.another.source.root=Move {0} directories to &another source root |
| move.directory.to.another.source.root=Move directory {0} to &another source root |
| move.inner.class.to.upper.level=Move &inner class {0} to upper level |
| move.inner.class.to.another.class=&Move inner class {0} to another class |
| move.nonstatic.class.from.jsp.not.supported = Moving non-static classes from JSP page is not supported |
| package.occurs.in.package.prefixes.of.the.following.source.folders.n=Package {0} occurs in package prefixes of the following source folders:\n |
| these.package.prefixes.will.be.changed=These package prefixes will be changed. |
| rename.title=Rename |
| rename.not.supported=Operation is not supported |
| multiple.directories.correspond.to.package=Multiple directories correspond to package\n |
| directories.and.all.references.to.package.will.be.renamed=\n\nDo you want to rename the whole package or directory \n{0} only? |
| rename.package.button.text=Rename &package |
| rename.directory.button.text=Rename &directory |
| rename.directories= Rename &all |
| rename.current.directory= Rename ¤t |
| move.current.directory= Move ¤t |
| move.directories= Move &all |
| warning.title=Warning |
| replace.constructor.with.factory.method.title=Replace Constructor With Factory Method |
| class.does.not.have.implicit.default.constructor=Class {0} does not have implicit default constructor |
| would.you.like.to.replace.default.constructor.of.0.with.factory.method=Would you like to replace default constructor of {0} with factory method? |
| refactoring.is.not.supported.for.local.and.jsp.classes=Refactoring is not supported for local and JSP classes |
| refactoring.is.not.supported.for.jsp.classes=Refactoring is not supported for JSP classes |
| class.is.abstract={0} is abstract. |
| method.is.not.a.constructor=Method is not a constructor |
| safe.delete.title=Safe Delete |
| replace.temp.with.query.title=Replace Temp with Query |
| cannot.replace.temp.with.query.in.interface=Cannot replace temp with query in interface |
| variable.has.no.initializer=Variable {0} has no initializer |
| variable.has.no.dominating.definition=Cannot find a single definition to inline |
| variable.is.never.used=Variable {0} is never used |
| variable.is.accessed.for.writing=Variable ''{0}'' is accessed for writing |
| variable.is.accessed.for.writing.and.used.with.inlined=Another variable ''{0}'' definition is used together with inlined one |
| only.fields.variables.of.methods.of.valid.type.can.be.considered=Only fields, variables, method parameters\u00A0or methods of valid type can be considered. |
| unable.to.start.type.migration=Unable to start type migration |
| replace.method.code.duplicates.title=Replace Code Duplicates |
| locate.caret.inside.a.method=Locate caret inside a member |
| replace.with.method.call.does.not.work.for.constructors=Replace With Method Call does not work for constructors |
| method.does.not.have.a.body=Method {0} does not have a body |
| method.has.an.empty.body=Method {0} has an empty body. |
| idea.has.not.found.any.code.that.can.be.replaced.with.method.call={0} has not found any duplicates |
| method.duplicates.found.message={0, choice, 1#1 code fragment|2#{0,number} code fragments} found |
| 0.with.1.visibility.is.not.accessible.from.2={0} with {1} visibility won''t be accessible from {2} |
| 0.contains.call.with.null.argument.for.parameter.1={0} contains call with null argument for parameter {1} |
| no.members.selected=No members selected |
| 0.already.exists.in.the.target.class={0} already exists in the target class. |
| 0.is.1.and.will.not.be.accessible.from.2.in.the.target.class={0} is {1} and will not be accessible from {2}. |
| renamed.class.will.hide.0.in.1=Renamed class will hide {0} in {1} |
| there.is.already.a.0.it.will.conflict.with.the.renamed.1=There is already a {0}. It will conflict with the renamed {1} |
| 0.will.override.renamed.1={0} will override renamed {1} |
| 0.will.hide.renamed.1={0} will hide renamed {1} |
| local.will.be.hidden.renamed=renamed field will hide {0} |
| there.is.already.a.0.in.the.1.it.will.conflict.with.the.renamed.parameter=There is already a {0} in the {1}. It will conflict with the renamed parameter. |
| do.you.want.to.process.overriding.methods.with.covariant.return.type=Do you want to process overriding methods\nwith covariant return type? |
| changing.signature.of.0=Changing signature of {0} |
| there.is.already.a.0.in.1.it.will.conflict.with.the.new.parameter=There is already a {0} in {1}. It will conflict with the new parameter. |
| 0.to.change.signature={0} to change signature |
| New.name.of.method.is.not.java.identifier=New name of method is not Java identifier |
| references.to.be.changed=References to be changed {0} |
| source.folder.0.has.package.prefix.1=Source folder {0} has package prefix ''{1}''\nPackage ''{2}'' cannot be created there. |
| javadoc.as.is=&As is |
| javadoc.copy=&Copy |
| javadoc.move=&Move |
| replace.instance.qualifiers.with.class.references=Replace instance qualifiers with class references |
| make.0.static=Make {0} Static |
| 0.already.has.parameter.named.1.use.this.name.anyway={0} already has a parameter named ''{1}''.\nUse this name anyway? |
| this.method=This method |
| add.object.as.a.parameter.with.name=Add &object as a parameter with name: |
| add.object.as.a.parameter.to.constructors.with.name=Add &object as a parameter to constructors with name: |
| add.parameters.for.fields=Add parameters for &fields: |
| add.parameters.for.fields.to.constructors=Add parameters for &fields to constructors: |
| 0.already.contains.field.1={0} already contains field {1} |
| 0.is.already.overridden.in.1={0} is already overridden in {1}. Method will not be pushed down to that class. |
| 0.already.contains.inner.class.named.1={0} already contains inner class named {1} |
| 0.uses.1.which.is.pushed.down={0} uses {1}, which is pushed down |
| refactoring.cannot.be.performed=Refactoring cannot be performed |
| there.is.already.a.0.it.will.conflict.with.an.introduced.parameter=There is already a {0}. It will conflict with the introduced parameter |
| introduce.parameter.command=Extracting parameter to {0} |
| parameter.initializer.contains.0.but.not.all.calls.to.method.are.in.its.class=Parameter initializer contains {0}, but not all calls to method are in its class |
| 0.is.not.accessible.from.1.value.for.introduced.parameter.in.that.method.call.will.be.incorrect={0} is not accessible from {1}. Value for introduced parameter in that method call will be incorrect. |
| use.interface.superclass.in.instanceof=Use interface/superclass in instanceof |
| introduce.parameter.to.method=Extract parameter to method: |
| introduced.variable.will.conflict.with.0=Introduced variable will conflict with {0} |
| column.name.type=Type: |
| column.name.any.var=Any var |
| column.name.default.value=Default value |
| caller.chooser.caller.method=Caller Method |
| caller.chooser.callee.method=Callee Method |
| caller.chooser.looking.for.callers=Looking For Callers... |
| copy.class.clone.0.1=Clone {0} {1} |
| copy.class.copy.0.1=Copy {0} {1} |
| invalid.target.package.name.specified=Invalid target package name specified |
| invalid.target.package.name.default.package=Cannot move classes to default package |
| error.title=Error |
| cannot.create.directory=Cannot create directory |
| no.target.directory.specified=No target directory specified |
| copy.files.new.name.label=&New name: |
| no.new.name.specified=No new name specified |
| copy.files.copy.specified.files.label=Copy specified files |
| copy.files.copy.specified.directories.label=Copy specified directories |
| copy.files.copy.specified.mixed.label=Copy specified files and directories |
| copy.files.to.directory.label=To &directory: |
| the.file.will.be.copied.to.this.directory=File will be copied to this directory |
| copy.files.clone.title=Clone |
| copy.files.copy.title=Copy |
| copy.files.clone.file.0=Clone file {0} |
| copy.files.copy.file.0=Copy file {0} |
| copy.files.clone.directory.0=Clone directory {0} |
| copy.files.copy.directory.0=Copy directory {0} |
| copy.handler.copy.class=Copy Class |
| copy.handler.clone.class=Clone Class |
| copy,handler.clone.files.directories=Clone files/directories |
| copy.handler.copy.files.directories=Copy files/directories |
| encapsulate.fields.get.access.checkbox=&Get access |
| encapsulate.fields.set.access.checkbox=&Set access |
| encapsulate.fields.use.accessors.even.when.field.is.accessible.checkbox=&Use accessors even when field is accessible |
| encapsulate.fields.private.radio=Pr&ivate |
| encapsulate.fields.protected.radio=Pro&tected |
| encapsulate.fields..package.local.radio=Package lo&cal |
| encapsulate.fields.encapsulate.border.title=Encapsulate |
| encapsulate.fields.options.border.title=Options |
| encapsulate.fields..encapsulated.fields.visibility.border.title=Encapsulated Fields' Visibility |
| encapsulate.fields.accessors.visibility.border.title=Accessors' Visibility |
| encapsulate.fields.fields.to.encapsulate.border.title=Fields to Encapsulate |
| encapsulate.fields.field.column.name=Field |
| encapsulate.fields.getter.column.name=Getter |
| encapsulate.fields.setter.column.name=Setter |
| encapsulate.fields.no.fields.selected=No fields selected |
| encapsulate.fields.command.name=Encapsulating fields in {0} |
| encapsulate.fields.getter.exists=There is already method {0} which differs from getter {1} by return type only |
| encapsulate.fields.setter.exists=There is already method {0} which differs from setter {1} by return type only |
| encapsulate.fields.fields.to.be.encapsulated=Fields to be encapsulated |
| invocations.to.be.inlined=Invocations to be inlined {0} |
| classes.to.push.down.members.to=Classes to push down members to {0} |
| references.in.code.to.elements.from.migration.map=References in code to elements from migration map "{0}" {1} |
| press.the.do.migrate.button=Press the "Do Migrate" button at the bottom of the search results panel\nto migrate using the migration map "{0}"\n |
| declaration.s.to.be.generified=Declaration(s) to be generified {0} |
| occurences.to.be.migrated=Occurrences to be migrated {0} |
| references.in.code=References in code {0} |
| safe.delete.comment.occurences.header=Occurrences found in comments, strings and non-code files {0}. Those occurrences will not be changed |
| move.single.element.elements.header={0} to be moved to {1} |
| references.in.code.to.0.1=References in code to {0} {1} |
| move.classes.elements.header=Classes to be moved to {0} |
| move.packages.elements.header=Packages to be moved to {0} |
| references.found.in.code=References found in code |
| references.found.in.generated.code=References found in generated code |
| comments.elements.header=Occurrences found in comments, strings and non-code files {0} |
| move.files.elements.header=Files to be moved to {0} |
| move.directories.elements.header=Directories to be moved to {0} |
| make.static.description.label=Make {0} {1} static |
| there.is.already.a.0.in.1=There is already a {0} in {1} |
| 0.uses.non.static.1.which.is.not.passed.as.a.parameter={0} uses non-static {1}, which is not passed as a parameter |
| 0.uses.1.which.needs.class.instance={0} uses {1}, which needs class instance |
| method.0.is.overridden.by.1=Method {0} is overridden by {1} |
| make.static.command=Making {0} static |
| introduce.parameter.elements.header=Adding parameter to a method |
| annotate.field.as.nonnls.checkbox=Annotate &field as @NonNls |
| replace.all.occurences.checkbox=Replace &all occurrences |
| introduce.constant.introduce.to.class=Extract to &class (fully qualified name)\: |
| introduce.field.static.field.of.type=Static field of &type: |
| introduce.field.field.of.type=Field of &type: |
| replace.all.occurrences.of.expression.0.occurrences=Replace &all occurrences ({0}) |
| delete.variable.declaration=&Delete variable declaration |
| initialize.in.border.title=Initialize in |
| setup.method.radio=&setUp method |
| current.method.radio=Current &method |
| field.declaration.radio=Field &declaration |
| class.constructors.radio=Class &constructor(s) |
| convert.local.to.field.title=Convert Local to Field |
| introduce.constant.field.of.type=Constant (static final field) of &type: |
| extract.subclass.command=Extract Subclass |
| extract.superclass.elements.header=Extract superclass with members to directory |
| declare.static.checkbox=Declare &static |
| declare.varargs.checkbox=Declare v&arargs |
| declare.folded.parameters=&Fold parameters |
| extract.method.method.panel.border=Method |
| there.are.multiple.exit.points.in.the.selected.code.fragment=There are multiple exit points in the selected code fragment |
| move.members.elements.header=Members to be moved |
| move.members.move.members.from.label=Move members from: |
| move.members.to.fully.qualified.name.label=To (fully qualified name): |
| move.members.members.to.be.moved.border.title=Mem&bers to be moved (static only) |
| no.destination.class.specified=No destination class specified |
| 0.is.not.a.legal.fq.name=''{0}'' is not a legal FQ-name |
| create.class.command=Create class {0} |
| source.and.destination.classes.should.be.different=Source and destination classes should be different |
| cannot.move.inner.class.0.into.itself=Cannot move inner class {0} into itself |
| class.0.does.not.exist=Class {0} does not exist.\nDo you want to create it? |
| move.members.title=Move Members |
| members.to.be.moved.should.belong.to.the.same.class=Members to be moved should belong to the same class |
| field.0.is.not.static=Field {0} is not static.\n{1} refactoring is supported for static members only. |
| 0.refactoring.cannot.be.applied.to.constructors={0} refactoring cannot be applied to constructors |
| method.0.is.not.static=Method {0} is not static.\n{1} refactoring is supported for static members only. |
| inner.class.0.is.not.static=Inner class {0} is not static.\n{1} refactoring is supported for static members only. |
| inline.field.title=Inline Field |
| 0.refactoring.is.supported.only.for.final.fields={0} refactoring is supported only for final fields |
| no.initializer.present.for.the.field=No initializer present for the field |
| field.0.is.never.used=Field {0} is never used |
| inline.field.command=Inline field {0} |
| 0.is.used.for.writing.in.1={0} is used for writing in {1} |
| 0.will.not.be.accessible.from.1.after.inlining={0} will not be accessible from {1} after inlining |
| inline.field.field.name.label=Field {0} |
| inline.field.border.title=Inline |
| all.references.and.remove.the.field=Inline &all references and remove the field |
| all.references.and.remove.the.local=Inline &all references and remove the variable |
| this.reference.only.and.keep.the.field=Inline this reference only and &keep the field |
| all.references.and.remove.super.class=Inline &all references and remove the class |
| this.reference.only.and.keep.super.class=Inline this reference only and &keep the super class |
| inline.variable.title=Inline Variable |
| variable.is.referenced.in.multiple.files=Variable {0} is referenced in multiple files |
| variable.is.never.used.before.modification=Variable {0} is never used before modification |
| inline.command=Inline {0} |
| inline.local.variable.prompt=Inline local variable ''{0}''? |
| inline.local.variable.definition.prompt=Inline local variable ''{0}'' definition? |
| occurences.string=({0,choice,1#1 occurrence|2#{0,number} occurrences}) |
| occurrences.string=({0,choice,1#1 occurrence|2#{0,number} occurrences}) |
| inline.method.title=Inline Method |
| inline.method.method.label=Method {0} |
| inline.method.border.title=Inline |
| all.invocations.and.remove.the.method=Inline &all invocations and remove the method |
| all.invocations.in.project=&All invocations in project |
| this.invocation.only.and.keep.the.method=Inline this invocation only and &keep the method |
| refactoring.cannot.be.applied.to.abstract.methods={0} refactoring cannot be applied to abstract methods |
| refactoring.cannot.be.applied.no.sources.attached={0} refactoring cannot be applied: no sources attached |
| refactoring.is.not.supported.when.return.statement.interrupts.the.execution.flow={0} refactoring is not supported when return statement interrupts the execution flow |
| refactoring.is.not.supported.for.recursive.methods={0} refactoring may not be applied to remove recursive methods.\nYou can inline only individual method calls. |
| refactoring.cannot.be.applied.to.vararg.constructors={0} refactoring cannot be applied to vararg constructors |
| refactoring.cannot.be.applied.to.inline.non.chaining.constructors={0} refactoring cannot be applied to inline non-chaining constructors |
| inline.method.command=Inlining method {0} |
| inlined.method.implements.method.from.0=Inlined method implements method from {0} |
| inlined.method.overrides.method.from.0=Inlined method overrides method from {0} |
| 0.that.is.used.in.inlined.method.is.not.accessible.from.call.site.s.in.1={0} that is used in inlined method is not accessible from call site(s) in {1} |
| inline.method.elements.header=Method to inline |
| inline.field.elements.header=Field to inline |
| inline.class.elements.header=Class to inline |
| inline.vars.elements.header=Variable to inline |
| interface.has.been.successfully.created=Interface {0} has been successfully created |
| class.has.been.successfully.created=Class {0} has been successfully created |
| use.super.references.prompt=At this stage {0} can analyze usages of {1} \nand replace them with usages of {2} where possible.\nDo you want to proceed? |
| analyze.and.replace.usages=Analyze and Replace Usages |
| there.are.multiple.output.values.for.the.selected.code.fragment=There are multiple output values for the selected code fragment: |
| expression.result=expression result |
| boolean.method.result=boolean method result |
| instances.of.0.upcasted.to.1.were.found=Instances of {0} upcasted to {1} were found. If you continue, they will be shown in a separate Find tab. |
| 0.uses.1.of.an.instance.of.a.2={0} uses {1} of an instance of a {2} |
| 0.upcasts.an.instance.of.1.to.2={0} upcasts an instance of {1} to {2} |
| 0.will.no.longer.override.1={0} will no longer override {1} |
| replacing.inheritance.with.delegation=Replacing inheritance with delegation |
| instances.casted.to.java.lang.object=Instances casted to java.lang.Object |
| instances.upcasted.to.object=Instances upcasted to Object |
| instances.upcasted.to.java.lang.object.found=Instances upcasted to java.lang.Object found |
| replace.inheritance.with.delegation.command=Replacing inheritance with delegation in {0} |
| replace.inheritance.with.delegation.elements.header=Replace inheritance with delegation |
| # Inline included file |
| inline.included.file.title=Inline included file |
| the.caret.should.be.positioned.on.the.included.file.to.inline=Caret should be positioned on the included file reference to inline |
| |
| inline.the.contents.include.prompt=Inline the contents of ''{0}''? |
| remove.include.prompt=Included file is no longer used. Remove it? |
| delete.include.command=Delete {0} |
| make.static.elements.header={0} to be made static |
| field.0.is.not.accessible=Field {0} is not accessible from {1} |
| fields.0.are.not.accessible=Fields {0} are not accessible from {1} |
| 0.is.not.static.it.cannot.be.moved.to.the.interface={0} is not static. It cannot be moved to the interface |
| 0.is.not.initialized.in.declaration.such.fields.are.not.allowed.in.interfaces={0} is not initialized in declaration. Such fields are not allowed in interfaces. |
| 0.already.contains.a.1={0} already contains a {1} |
| 0.uses.1.which.is.not.accessible.from.the.superclass={0} uses {1}, which is not accessible from the superclass |
| 0.uses.1.which.is.not.moved.to.the.superclass={0} uses {1}, which is not moved to the superclass |
| push.members.from.0.down.label=Push members from {0} down |
| members.to.be.pushed.down.panel.title=Mem&bers to be pushed down |
| keep.abstract.column.header=Keep abstract |
| push.down.javadoc.panel.title=JavaDoc for abstracts |
| push.down.members.elements.header=Push down members from |
| interface.0.does.not.have.inheritors=Interface {0} does not have inheritors |
| functional.interface.broken=Functional expression demands functional interface to have exact one method |
| class.0.does.not.have.inheritors=Class {0} does not have inheritors |
| push.down.will.delete.members=Pushing members down will result in them being deleted. Would you like to create a new subclass? |
| edit.migration.map.title=Edit Migration Map |
| migration.map.name.prompt=Map name: |
| migration.map.description.label=Map description: |
| migration.add.button=Add... |
| migration.edit.button=Edit... |
| migration.remove.button=Remove |
| migration.move.up.button=Move Up |
| migration.move.down.button=Move Down |
| migration.type.column.header=Type |
| migration.old.name.column.header=Old name |
| migration.new.name.column.header=New name |
| migration.package.with.subpackages=Package with subpackages |
| migration.package=Package |
| migration.class=Class |
| edit.migration.entry.title=Edit Class/Package Migration Description |
| migration.entry.package=Package |
| migration.entry.class=Class |
| migration.entry.old.name=Old name: |
| migration.entry.new.name=New name: |
| select.migration.map=Select migration map: |
| migration.new.button=New... |
| migration.dialog.title=Package and Class Migration |
| migration.dialog.ok.button.text=Run |
| migration.map.set.migration.maps=Migration maps |
| migration.no.usages.found.in.the.project=No Usages Found in the Project |
| migration.title=Migration |
| move.classes.move.to.another.source.folder=Move to another source &folder |
| move.specified.classes=Move specified classes |
| move.specified.packages=Move specified packages |
| move.single.class.or.package.name.label=Move {0} {1} |
| please.enter.a.valid.target.package.name=Please enter a valid target package name |
| package.does.not.exist=Package {0} does not exist.\nDo you want to create it? |
| move.package.refactoring.cannot.be.applied.to.default.package=Move Package refactoring cannot be applied to default package |
| move.class.refactoring.cannot.be.applied.to.anonymous.classes=Move Class refactoring cannot be applied to anonymous classes |
| moving.local.classes.is.not.supported=Moving local classes is not supported |
| there.are.going.to.be.multiple.destination.files.with.the.same.name=There are going to be multiple destination files with the same name |
| do.you.wish.to.continue=Do you wish to continue? |
| all.these.directories.will.be.moved.and.all.references.to.0.will.be.changed=All these directories will be moved, and all references to {0} \nwill be changed. |
| select.source.root.chooser.title=Select Source Root |
| moving.directories.command=Moving directories |
| 0.uses.a.package.local.1={0} uses package-local {1} |
| a.package.local.class.0.will.no.longer.be.accessible.from.1=Package-local class {0} will no longer be accessible from {1} |
| element.will.no.longer.be.accessible={0} will no longer be accessible from {1} |
| move.instance.method.command=Move Instance method |
| move.instance.method.elements.header=Move instance method |
| move.method.this.parameter.label=Select a name for ''{0}.this'' parameter |
| move.method.enter.a.valid.name.for.parameter=Please Enter a Valid name for Parameter |
| 0.is.an.interface.that.has.no.implementing.classes={0} is an interface that has no implementing classes |
| 0.is.an.interface.method.implementation.will.be.added.to.all.directly.implementing.classes={0} is an interface. \nMethod implementation will be added to all directly implementing classes.\n Proceed? |
| move.inner.to.upper.level.title=Move Inner to Upper Level |
| move.inner.class.command=Moving inner class {0} |
| 0.will.become.inaccessible.from.1={0} will become inaccessible from {1} |
| move.specified.files=Move specified files |
| move.specified.directories=Move specified directories |
| move.file.0=Move file {0} |
| move.directory.0=Move directory {0} |
| move.files.to.directory.label=To directory: |
| the.file.will.be.moved.to.this.directory=File will be moved to this directory |
| searching.for.variables=Searching for variables |
| no.usages.can.be.replaced=No usages of {0} \ncan be replaced with usages of {1} |
| turn.refs.to.super.command=Replacing usages of {0} with {1} |
| references.to.0.to.be.replaced.with.references.to.1=References to ''{0}'' to be replaced with references to ''{1}'' |
| factory.method.name.label=Factory method name: |
| replace.constructor.with.factory.target.fq.name=In (fully qualified name): |
| class.0.not.found=Class {0} not found. |
| class.0.is.not.accessible.from.target.1=Class {0} is not accessible from target {1} |
| target.0.is.not.accessible.from.1=Target {0} is not accessible from {1} |
| constructor.being.refactored.is.used.in.initializer.of.0=Constructor being refactored is used in initializer of {0}. Non-static factory of inner class{1} cannot be used in this context. Resulting code will not compile. |
| replace.constructor.0.with.a.factory.method=Replace constructor {0} with a factory method |
| replace.default.constructor.of.0.with.a.factory.method=Replace default constructor of {0} with a factory method |
| replace.constructor.with.factory.method=Replace constructor with factory method |
| replace.default.constructor.with.factory.method=Replace default constructor with factory method |
| occurrences.found.in.comments.strings.and.non.java.files=Occurrences found in comments, strings and non-code files |
| occurrences.found.in.comments.strings.non.java.files.and.generated.code=Occurrences found in comments, strings, non-code files and generated code |
| 0.referenced.in.1.will.not.be.accessible.in.module.2={0}, referenced in {1}, will not be accessible in module {2} |
| 0.referenced.in.1.will.not.be.accessible.from.module.2={0}, referenced in {1}, will not be accessible from module {2} |
| 0.referenced.in.1.will.not.be.accessible.from.production.of.module.2={0}, referenced in {1}, will not be accessible from the production sources of module {2} |
| choose.destination.directory=Choose Destination Directory |
| directory.chooser.hide.non.existent.checkBox.text=&Hide non-existent |
| 0.will.be.inaccessible.from.1={0} will be inaccessible from {1} |
| move.classes.command=Moving {0} to package {1} |
| safe.delete.command=Deleting {0} |
| select.all.button=Select &all |
| unselect.all.button=&Unselect all |
| automatic.renamer.enity.name.column={0} name |
| automatic.renamer.rename.to.column=Rename To |
| rename.0.and.its.usages.to=Rename {0} and its usages to: |
| rename.variables=Rename &variables |
| rename.inheritors=Rename &inheritors |
| rename.tests=Rename t&ests |
| rename.parameters.hierarchy=Rename parameters in hier&archy |
| rename.bound.forms=Rename bound &forms |
| inner.class.0.is.already.defined.in.class.1=Inner class {0} is already defined in class {1}.\nContinue anyway? |
| class.0.already.exists=Class {0} already exists |
| renaming.something=Renaming something |
| renaming.0.1.to.2=Renaming {0} {1} to {2} |
| renaming.command.name=Renaming {0} |
| 0.to.be.renamed.to.1.2={0} to be renamed to {1}{2} |
| references.in.code.to.0=References in code to {0} |
| rename.variables.title=Rename Variables |
| rename.variables.with.the.following.names.to=Rename variables with the following names to: |
| entity.name.variable=Variable |
| rename.bound.forms.title=Rename bound forms |
| rename.forms.with.the.following.names.to=Rename forms with the following names to: |
| entity.name.form=Form |
| rename.inheritors.title=Rename Inheritors |
| rename.tests.title=Rename Tests |
| rename.inheritors.with.the.following.names.to=Rename inheritors with the following names to: |
| rename.tests.with.the.following.names.to=Rename tests with the following names to: |
| entity.name.inheritor=Inheritor |
| entity.name.test=Test |
| unused.overriding.methods.title=Unused Overriding Methods |
| there.are.unused.methods.that.override.methods.you.delete=There are unused methods that override methods you delete |
| choose.the.ones.you.want.to.be.deleted=Choose the ones you want to be deleted |
| method.column=Method |
| 0.implements.1={0} implements {1}. |
| attempting.to.delete.targets.node.text=Attempting to delete |
| retry.command=Retry |
| rerun.safe.delete=&Rerun Safe Delete |
| delete.title=Delete |
| items.to.be.deleted=Items to be deleted |
| usages.detected=Usages Detected |
| delete.anyway.button=&Delete Anyway |
| ignore.button=Ignore |
| the.following.problems.were.found=The following problems were found: |
| cancel.button=Ca&ncel |
| view.usages=&View usages |
| anonymous.class.text=Anonymous class |
| problems.detected.title=Problems Detected |
| continue.button=&Continue |
| do.you.wish.to.ignore.them.and.continue=Do you wish to ignore them and continue? |
| delegation.panel.method.calls.label=Method calls: |
| delegation.panel.modify.radio=&Modify |
| delegation.panel.delegate.via.overloading.method=De&legate via overloading method |
| information.title=Information |
| ok.button=OK |
| do.not.show.this.message.in.the.future=&Do not show this message in the future |
| member.column=Member |
| refactor.button=&Refactor |
| preview.button=&Preview |
| yes.button=&Yes |
| no.button=&No |
| preview.usages.to.be.changed=&Preview usages to be changed |
| replace.this.code.fragment=Replace this code fragment? |
| replace.this.code.fragment.and.make.method.static= (Method will be made static) |
| replace.this.code.fragment.and.make.method.static.visible= (Method will be made static and {0}) |
| replace.this.code.fragment.and.make.method.visible= (Method will be made {0}) |
| replace.this.code.fragment.and.change.signature=\nMethod signature will be changed to \n{0} |
| process.duplicates.title=Process Duplicate {0} of {1} |
| process.methods.duplicates.title=Process Method {2} Duplicate ({0} of {1}) |
| 0.has.detected.1.code.fragments.in.this.file.that.can.be.replaced.with.a.call.to.extracted.method={0} has detected {1} code {1,choice,1#fragment|2#fragments} in this file that can be replaced with a call to extracted method. Would you like to review and replace {1,choice,1#it|2#them}? |
| replace.button=Replace |
| method.duplicates.method.label=Method {0} |
| usages.detected.title=Usages Detected |
| generify.title=Generify |
| interface.member.dependency.required.by.interfaces=required by {0,choice,1#interface|2#interfaces} |
| member.info.implements.0=implements {0} |
| member.info.extends.0=extends {0} |
| used.by.0=used by {0} |
| uses.0=uses {0} |
| field.description=field {0} |
| constructor.description=constructor {0} |
| method.description=method {0} |
| parameter.description=parameter {0} |
| local.variable.description=local variable {0} |
| package.description=package {0} |
| class.description=class {0} |
| static.initializer.description=static initializer of class {0} |
| instance.initializer.description=instance initializer of class {0} |
| file.description=File {0} |
| directory.description=Directory {0} |
| 0.is.located.in.a.jar.file={0} is located in a JAR file.\n |
| 0.is.read.only={0} is read-only.\n |
| 0.is.not.a.legal.java.identifier=''{0}'' is not a legal java identifier |
| method.0.is.already.defined.in.the.1=Method {0} is already defined in the {1} |
| method.0.will.hide.method.of.the.base.class=Method {0} will hide \nthe method of the base class {1} |
| method.0.will.implement.method.of.the.base.class=Method {0} will implement \na method of the base class {1} |
| method.0.will.override.a.method.of.the.base.class=Method {0} will override \na method of the base class {1} |
| current.class=current class |
| field.0.is.already.defined.in.the.1=Field {0} is already defined in the {1} |
| field.0.will.hide.field.1.of.the.base.class=Field {0} will hide \na field {1} of the base class {2} |
| directory.0.already.contains.1.named.2=Directory {0} \nalready contains {1} named ''{2}'' |
| directory.0.already.contains.a.file.named.1=Directory {0} \nalready contains a file named ''{1}'' |
| getter.and.setter.methods.found.for.the.field.0=Getter and setter methods found for the field {0}. \n{1} them as well? |
| getter.method.found.for.the.field.0=Getter method found for the field {0}. \n{1} the getter as well? |
| setter.method.found.for.the.field.0=Setter method found for the field {0}. \n{1} the setter as well? |
| 0.has.1.usages.that.are.not.safe.to.delete={0} has {1,choice,1#1 usage that is|2#{1,number} usages that are} not safe to delete. |
| safe.delete.of.those.0.in.comments.strings.non.code=Of those {0,choice,1#1 usage is|2#{0,number} usages are} in strings, comments, non-code files or generated code. |
| type.cook.drop.obsolete.casts=&Drop obsolete casts |
| type.cook.preserve.raw.arrays=Preserve raw &arrays |
| type.cook.leave.object.parameterized.types.raw=&Leave Object-parameterized types raw |
| type.cook.perform.exhaustive.search=Perform &exhaustive search |
| type.cook.generify.objects=Generify &Objects |
| type.cook.produce.wildcard.types=Produce &wildcard types |
| type.cook.command=Generify |
| type.cook.elements.header=Scope(s) to generify |
| type.cook.report=Items generified: {0}, casts removed: {1} |
| type.cook.ratio.generified={0,choice,-1#not calculated|0#{0,number} of {1}} |
| extract.method.control.flow.analysis.failed=Code contains syntax errors. Cannot perform necessary analysis. |
| pushed.members.will.not.be.visible.from.certain.call.sites=Pushed members will not be visible from certain call sites |
| invert.boolean.title=Invert Boolean |
| invert.boolean.wrong.type=Return type of the method or type of the variable to be refactored should be boolean |
| invert.boolean.refs.to.invert=References to be inverted {0} |
| invert.boolean.elements.header={0} to invert |
| please.enter.a.valid.name.for.inverted.element=Please enter a valid name for inverted {0} |
| invert.boolean.name.of.inverted.element=&Name of inverted {0}: |
| invert.0.1=Invert {0} {1} and its usages |
| 0.is.a.part.of.method.hierarchy.do.you.want.to.delete.multiple.parameters={0} is a part of method hierarchy. Do you want to delete multiple parameters? |
| move.inner.class.to.be.moved=Class to be moved |
| move.specified.classes.to=Move specified classes to: |
| destination.directory.does.not.correspond.to.any.package=The destination directory does not correspond to any package |
| cannot.find.or.create.destination.directory=Cannot find or create destination directory |
| cannot.move=Cannot Move |
| cannot.move.package.into.itself=Cannot move package into itself |
| rename.constructor.parameters.title=Rename Constructor Parameters |
| rename.constructor.parameters.with.the.following.names.to=Rename parameters with the following names to: |
| entity.name.constructor.parameter=Parameter |
| replace.method.duplicates.scope.chooser.title=Specify {0} Scope |
| replace.method.duplicates.scope.chooser.message=Analysis scope |
| remove.parameter.0.no.longer.used=Remove parameter ''{0}'' no longer used |
| inline.to.anonymous.refactoring=Inline to Anonymous Class |
| inline.to.anonymous.no.abstract=Abstract classes cannot be inlined |
| inline.to.anonymous.no.inheritors=Classes which have subclasses cannot be inlined |
| inline.to.anonymous.no.multiple.interfaces=Classes which implement multiple interfaces cannot be inlined |
| inline.to.anonymous.no.superclass.and.interface=Classes which have a superclass and implement an interface cannot be inlined |
| move.class.to.inner.command.name=Move {0} to {1} |
| move.classes.destination.to.package=To packa&ge |
| move.classes.destination.make.inner=&Make inner class of |
| move.to.inner.duplicate.inner.class=Class {0} already contains an inner class named {1} |
| inline.to.anonymous.command.name=Inline class {0} |
| class.is.never.used=Class is never used |
| all.references.and.remove.the.class=Inline &all references and remove the class |
| this.reference.only.and.keep.the.class=Inline this reference only and &keep the class |
| inline.to.anonymous.name.label=Class {0} |
| inline.to.anonymous.border.title=Inline |
| move.class.to.inner.nonstatic.error=It is not allowed to move a class into a non-static inner class |
| move.class.to.inner.move.to.self.error=It is not allowed to move a class into itself |
| unsupported.refs.found=Unsupported references found in {0} files |
| inline.method.checking.tail.calls.progress=Checking tail call usages |
| extract.chained.constructor.checkbox=Extract &chained constructor |
| inline.parameter.refactoring=Inline Parameter |
| inline.parameter.confirmation=Inline parameter ''{0}'' with initializer ''{1}''? |
| inline.parameter.command.name=Inline Parameter {0} |
| inline.parameter.error.hierarchy=Inline parameter is not supported when method is a part of inheritance hierarchy |
| inline.parameter.error.varargs=Inline for varargs parameters is not supported |
| inline.parameter.replace.with.local.checkbox=R&eplace with local variable |
| type.migration.rerun.button.text=&Rerun Type Migration |
| type.migration.migrate.button.text=&Migrate |
| type.migration.exclude.action.text=&Exclude |
| type.migration.include.action.text=&Include |
| introduce.constant.enum.cb=Extract as &enum constant |
| move.enum.constant.cb=Move as &enum constants if possible |
| move.to.different.language=Target class {2} has different language than {0} {1} |
| dont.support.inner.classes=Refactoring ''Make inner class of'' is not available in {0} |
| move.specified.elements=Move specified elements |
| rename.directory.title=Rename &Directory |
| rename.module.title=Rename &Module |
| |
| # extract method |
| refactoring.extract.method.dialog.title=Extract Method |
| refactoring.extract.method.dialog.method.name=Method name: |
| refactoring.extract.method.dialog.parameters=Parameters |
| refactoring.extract.method.dialog.output.variables=Output variables |
| refactoring.extract.method.dialog.signature.preview=Signature preview |
| refactoring.extract.method.dialog.empty=Empty |
| change.signature.leave.blank.default.value=Leave &blank |
| change.signature.feel.lucky=Feel &lucky |
| change.signature.use.selected.value=Use selected &value |
| |
| search.for.references=Search for re&ferences |
| 0.is.not.an.identifier=<b><code>{0}</code></b> is not a correct identifier to use in <b><code>{1}</code></b> |
| refactoring.is.not.supported.for.language={0} is not supported for {1} |
| rename.directory.command.name=Rename directory |
| rename.directories.command.name=Rename directories |
| target.destination.folder=Target &destination directory: |
| move.method.is.not.supported.for.0=Move instance method is not supported for {0} |
| detecting.possible.conflicts=Detecting possible conflicts... |
| path.completion.shortcut=Use {0} for path completion |
| |
| rename.project.action.title=Rename Project... |
| rename.project.handler.title=Rename &project |
| enter.new.project.name=Enter new project name: |
| rename.project=Rename Project |
| renames.project=Renames project |
