JComponent getContentComponent();
/**
- * Return <code>true</code> if editor show valid image.
+ * Return {@code true} if editor show valid image.
*
- * @return <code>true</code> if editor show valid image.
+ * @return {@code true} if editor show valid image.
*/
boolean isValid();
/**
- * Return <code>true</code> if editor is already disposed.
+ * Return {@code true} if editor is already disposed.
*
- * @return <code>true</code> if editor is already disposed.
+ * @return {@code true} if editor is already disposed.
*/
boolean isDisposed();
* Extract current editor from event context.
*
* @param e Action event
- * @return Current {@link ImageEditor} or <code>null</code>
+ * @return Current {@link ImageEditor} or {@code null}
*/
//public static ImageEditor getValidEditor(AnActionEvent e) {
// ImageEditor editor = getEditor(e);
* Check that file is image.
*
* @param file File to check
- * @return Return <code>true</code> if image file is file with Images file type
+ * @return Return {@code true} if image file is file with Images file type
*/
public abstract boolean isImage(VirtualFile file);
*
* @param name Name of option
* @param value Value
- * @return <code>true</code> if option is matched and setted.
+ * @return {@code true} if option is matched and setted.
*/
boolean setOption(String name, Object value);
}
* Extract current thumbnail view from event context.
*
* @param e Action event
- * @return Current {@link org.intellij.images.thumbnail.ThumbnailView} or <code>null</code>
+ * @return Current {@link org.intellij.images.thumbnail.ThumbnailView} or {@code null}
*/
public static ThumbnailView getVisibleThumbnailView(AnActionEvent e) {
ThumbnailView thumbnailView = getThumbnailView(e);
boolean isTransparencyChessboardVisible();
/**
- * Return <code>true</code> if this decorator is enabled for this action place.
+ * Return {@code true} if this decorator is enabled for this action place.
*
* @param place Action place
- * @return <code>true</code> is decorator is enabled
+ * @return {@code true} is decorator is enabled
*/
boolean isEnabledForActionPlace(String place);
* Validates that specified class represents {@link javax.swing.JComponent} with
* empty constructor.
*
- * @return descriptive human readable error message or <code>null</code> if
+ * @return descriptive human readable error message or {@code null} if
* no errors were detected.
*/
public static String validateJComponentClass(final ClassLoader loader, final String className, final boolean validateConstructor) {
void putClientProperty(Object key, Object value);
/**
- * @return name of the field (in bound class). Returns <code>null</code>
+ * @return name of the field (in bound class). Returns {@code null}
* if the component is not bound to any field.
*/
String getBinding();
*/
private final String myClassName;
/**
- * Parent LwContainer. This field is always not <code>null</code>
+ * Parent LwContainer. This field is always not {@code null}
* is the component is in hierarchy. But the root of hierarchy
- * has <code>null</code> parent indeed.
+ * has {@code null} parent indeed.
*/
private LwContainer myParent;
/**
- * never <code>null</code>
+ * never {@code null}
*/
private final GridConstraints myConstraints;
/**
* @return component's constraints in XY layout. This method rever
- * returns <code>null</code>.
+ * returns {@code null}.
*/
public final Rectangle getBounds(){
return (Rectangle)myBounds.clone();
/**
* @return component's constraints in GridLayoutManager. This method never
- * returns <code>null</code>.
+ * returns {@code null}.
*/
public final GridConstraints getConstraints(){
return myConstraints;
}
/**
- * @return <code>null</code> only if component class is not valid.
+ * @return {@code null} only if component class is not valid.
* Class validation is performed with {@link com.intellij.uiDesigner.compiler.Utils#validateJComponentClass(ClassLoader,String,boolean)}
*/
public final Element getErrorComponentProperties(){
*/
private final ArrayList myComponents;
/**
- * Describes border's type. This member is never <code>null</code>
+ * Describes border's type. This member is never {@code null}
*/
private BorderType myBorderType;
/**
* Border's title. If border doesn't have any title then
- * this member is <code>null</code>.
+ * this member is {@code null}.
*/
private StringDescriptor myBorderTitle;
private int myBorderTitleJustification;
/**
* @param component component to be added.
*
- * @exception IllegalArgumentException if <code>component</code> is <code>null</code>
- * @exception IllegalArgumentException if <code>component</code> already exist in the
+ * @exception IllegalArgumentException if {@code component} is {@code null}
+ * @exception IllegalArgumentException if {@code component} already exist in the
* container
*/
public final void addComponent(final LwComponent component){
}
/**
- * @return border's type. The method never return <code>null</code>.
+ * @return border's type. The method never return {@code null}.
*
* @see BorderType
*/
/**
* @see BorderType
*
- * @exception IllegalArgumentException if <code>type</code>
- * is <code>null</code>
+ * @exception IllegalArgumentException if {@code type}
+ * is {@code null}
*/
public final void setBorderType(final BorderType type){
if(type==null){
/**
* @return border's title. If the container doesn't have any title then the
- * method returns <code>null</code>.
+ * method returns {@code null}.
*/
public final StringDescriptor getBorderTitle(){
return myBorderTitle;
}
/**
- * @param title new border's title. <code>null</code> means that
+ * @param title new border's title. {@code null} means that
* the containr doesn't have have titled border.
*/
public final void setBorderTitle(final StringDescriptor title){
/**
* @param element element that contains serialized property data. This element was
* written by {@link com.intellij.uiDesigner.propertyInspector.IntrospectedProperty#write(Object, com.intellij.uiDesigner.XmlWriter)}
- * method. So <code>read</code> and <code>write</code> methods should be consistent.
+ * method. So {@code read} and {@code write} methods should be consistent.
*
- * @return property value. Should never return <code>null</code>. For example,
- * value can be <code>java.lang.Integer</code> for <code>IntroIntProperty</code>.
+ * @return property value. Should never return {@code null}. For example,
+ * value can be {@code java.lang.Integer} for {@code IntroIntProperty}.
*
*/
public abstract Object read(Element element) throws Exception;
}
/**
- * @return can be <code>null</code>.
+ * @return can be {@code null}.
*/
public static Element getChild(final Element element, final String childName) {
return element.getChild(childName, element.getNamespace());
}
/**
- * @return never <code>null</code>.
+ * @return never {@code null}.
*/
public static Element getRequiredChild(final Element element, final String childName) {
final Element child = getChild(element, childName);
}
/**
- * @return <code>null</code> or trimmed attribute value.
+ * @return {@code null} or trimmed attribute value.
*/
public static String getString(final Element element, final String attributeName){
final String value = element.getAttributeValue(attributeName);
}
/**
- * @return never <code>null</code> trimmed attribute value.
+ * @return never {@code null} trimmed attribute value.
*/
public static String getRequiredString(final Element element, final String attributeName) {
final String value = getString(element, attributeName);
}
/**
- * @return not <code>null</code> value if this is "trivial" StringDescriptor.
+ * @return not {@code null} value if this is "trivial" StringDescriptor.
* If StringDescriptor is "trivial" then {@link #getBundleName()} and {@link #getKey()}
- * return <code>null</code>.
+ * return {@code null}.
*/
public String getValue(){
return myValue;
}
/**
- * @return not <code>null</code> value if this is non "trivial" StringDescriptor.
+ * @return not {@code null} value if this is non "trivial" StringDescriptor.
*/
public String getBundleName() {
return myBundleName;
}
/**
- * @return not <code>null</code> value if this is non "trivial" StringDescriptor.
+ * @return not {@code null} value if this is non "trivial" StringDescriptor.
*/
public String getKey() {
return myKey;
}
/**
- * @return semicolon-separated names of not-null annotations to be instrumented. Example: <code>"org.jetbrains.annotations.NotNull;javax.annotation.Nonnull"</code>
+ * @return semicolon-separated names of not-null annotations to be instrumented. Example: {@code "org.jetbrains.annotations.NotNull;javax.annotation.Nonnull"}
*/
public String getNotNullAnnotations() {
return myNotNullAnnotations;
}
/**
- * @param notNullAnnotations semicolon-separated names of not-null annotations to be instrumented. Example: <code>"org.jetbrains.annotations.NotNull;javax.annotation.Nonnull"</code>
+ * @param notNullAnnotations semicolon-separated names of not-null annotations to be instrumented. Example: {@code "org.jetbrains.annotations.NotNull;javax.annotation.Nonnull"}
*/
public void setNotNullAnnotations(String notNullAnnotations) {
myNotNullAnnotations = notNullAnnotations;
/**
* Is intended to hold specific java formatting tests for alignment settings (
- * <code>Project Settings - Code Style - Alignment and Braces</code>).
+ * {@code Project Settings - Code Style - Alignment and Braces}).
*
* @author Denis Zhdanov
* @since Apr 27, 2010 6:42:00 PM
/**
* Is intended to hold specific java formatting tests for 'braces placement' settings (
- * <code>Project Settings - Code Style - Alignment and Braces</code>).
+ * {@code Project Settings - Code Style - Alignment and Braces}).
*
* @author Denis Zhdanov
* @since Apr 27, 2010 6:39:24 PM
import com.intellij.util.IncorrectOperationException;
/**
- * Is intended to hold specific java formatting tests for <code>'Place on New Line'</code> settings (
- * <code>Project Settings - Code Style - Alignment and Braces - Place on New Line</code>).
+ * Is intended to hold specific java formatting tests for {@code 'Place on New Line'} settings (
+ * {@code Project Settings - Code Style - Alignment and Braces - Place on New Line}).
*
* @author Denis Zhdanov
* @since Apr 28, 2010 12:12:13 PM
* !!!WARNING!!! PSI element types should be unambiguously determined by AST node element types.
* You can not produce different PSI elements from AST nodes of the same types (e.g. based on AST node content).
* Typically, your code should be as simple as that:
- * <code>
+ * {@code
* if (node.getElementType == MY_ELEMENT_TYPE) {
* return new MyPsiElement(node);
* }
- * </code>
+ * }
*
* @param node the node for which the PSI element should be returned.
* @return the PSI element matching the element type of the AST node.
/**
* Calculates minimum spacing, allowed by formatting model (in columns) for a block starting at given offset,
* relative to its previous sibling block.
- * Returns <code>-1</code>, if required block cannot be found at provided offset,
+ * Returns {@code -1}, if required block cannot be found at provided offset,
* or spacing cannot be calculated due to some other reason.
*/
public int getSpacing(@NotNull PsiFile file, int offset) {
/**
* Calculates minimum number of line feeds that should precede block starting at given offset, as dictated by formatting model.
- * Returns <code>-1</code>, if required block cannot be found at provided offset,
+ * Returns {@code -1}, if required block cannot be found at provided offset,
* or spacing cannot be calculated due to some other reason.
*/
public int getMinLineFeeds(@NotNull PsiFile file, int offset) {
}
/**
- * Ensures that the given argument doesn't contain <code>\</code> separators.
+ * Ensures that the given argument doesn't contain {@code \} separators.
* <p>
- * The violations are reported via the <code>LOG.error</code>.
+ * The violations are reported via the {@code LOG.error}.
* <p>
* TODO SystemIndependentInstrumentingBuilder now embeds assertions directly, so we can remove this method.
*
import java.lang.annotation.*;
/**
- * Designates a system-dependent path, which can contain <code>\</code> separators.
+ * Designates a system-dependent path, which can contain {@code \} separators.
* <p>
* This annotation doesn't add any bytecode instrumentation.
*
import java.lang.annotation.*;
/**
- * Designates a system-independent path, with <code>/</code> separators.
+ * Designates a system-independent path, with {@code /} separators.
* <p>
- * Corresponding bytecode instrumentation is added by
<code>SystemIndependentInstrumentingBuilder</code>.<p>
+ * Corresponding bytecode instrumentation is added by
{@code SystemIndependentInstrumentingBuilder}.<p>
*
* @see PathUtil#toSystemIndependentName(String)
* @see PathUtil#toSystemDependentName(String)
import com.sun.jna.win32.StdCallLibrary;
/** Base type for most W32 API libraries. Provides standard options
- * for unicode/ASCII mappings. Set the system property <code>w32.ascii</code>
- * to <code>true</code> to default to the ASCII mappings.
+ * for unicode/ASCII mappings. Set the system property {@code w32.ascii}
+ * to {@code true} to default to the ASCII mappings.
*/
@SuppressWarnings("serial")
public interface W32API extends StdCallLibrary {
* This method is called from a background thread.
*
* @param progress to check if highlighting process is cancelled. Pass is to check progress.isCanceled() as often as possible and
- * throw {@link com.intellij.openapi.progress.ProcessCanceledException} if <code>true</code> is returned.
+ * throw {@link com.intellij.openapi.progress.ProcessCanceledException} if {@code true} is returned.
* See also {@link com.intellij.openapi.progress.ProgressIndicator#checkCanceled()}.
*/
void collectInformation(@NotNull ProgressIndicator progress);
* @param children the list of child nodes according to the default project structure.
* Elements of the collection are of type {@link ProjectViewNode}.
* @param settings the current project view settings.
- * @return the modified collection of child nodes, or <code>children</code> if no modifications
+ * @return the modified collection of child nodes, or {@code children} if no modifications
* are required.
*/
@NotNull
* @param fileEditor the editor to which the structure view is linked.
* @param treeModel the model defining the data shown in the structure view.
* @param project the project containing the file for which the structure view is requested.
- * @param showRootNode pass <code>false</code> if root node of the structure built should not actually be shown in result tree.
+ * @param showRootNode pass {@code false} if root node of the structure built should not actually be shown in result tree.
* @return the structure view instance.
*/
@NotNull
}
/**
- * Override returning <code>false</code> if root node created by {@link #createStructureViewModel(Editor editor)} shall not be visible
- * @return <code>false</code> if root node shall not be visible in structure tree.
+ * Override returning {@code false} if root node created by {@link #createStructureViewModel(Editor editor)} shall not be visible
+ * @return {@code false} if root node shall not be visible in structure tree.
*/
public boolean isRootNodeShown() {
return true;
import java.util.EventListener;
/**
- * A listener for <code>UISettings</code> changes.
+ * A listener for {@code UISettings} changes.
* <p/>
- * <em>NOTE: </em>The main <code>UISettings</code> instance pushes its events down
- * the UI components hierarchy so there's no need to add a <code>JComponent</code> as a listener.
+ * <em>NOTE: </em>The main {@code UISettings} instance pushes its events down
+ * the UI components hierarchy so there's no need to add a {@code JComponent} as a listener.
*
* @see UISettings#fireUISettingsChanged()
* @see com.intellij.util.ComponentTreeEventDispatcher
private Boolean myDumbAware;
/**
- * Creates a new <code>ActionGroup</code> with shortName set to <code>null</code> and
+ * Creates a new {@code ActionGroup} with shortName set to {@code null} and
* popup set to false.
*/
public ActionGroup(){
}
/**
- * Creates a new <code>ActionGroup</code> with the specified shortName
+ * Creates a new {@code ActionGroup} with the specified shortName
* and popup.
*
* @param shortName Text that represents a short name for this action group
*
- * @param popup <code>true</code> if this group is a popup, <code>false</code>
+ * @param popup {@code true} if this group is a popup, {@code false}
* otherwise
*/
public ActionGroup(String shortName, boolean popup){
/**
* Returns the type of the group.
*
- * @return <code>true</code> if the group is a popup, <code>false</code> otherwise
+ * @return {@code true} if the group is a popup, {@code false} otherwise
*/
public boolean isPopup(){
return myPopup;
/**
* Sets the type of the group.
*
- * @param popup If <code>true</code> the group will be shown as a popup in menus
+ * @param popup If {@code true} the group will be shown as a popup in menus
*/
public final void setPopup(boolean popup){
boolean oldPopup = myPopup;
/**
* Returns the children of the group.
*
- * @return An array representing children of this group. All returned children must be not <code>null</code>.
+ * @return An array representing children of this group. All returned children must be not {@code null}.
*/
@NotNull
public abstract AnAction[] getChildren(@Nullable AnActionEvent e);
}
/**
- * Factory method that creates an <code>ActionPopupMenu</code> from the
+ * Factory method that creates an {@code ActionPopupMenu} from the
* specified group. The specified place is associated with the created popup.
*
* @param place Determines the place that will be set for {@link AnActionEvent} passed
*
* @param group Group from which the actions for the menu are taken.
*
- * @return An instance of <code>ActionPopupMenu</code>
+ * @return An instance of {@code ActionPopupMenu}
*/
public abstract ActionPopupMenu createActionPopupMenu(@NonNls String place, @NotNull ActionGroup group);
/**
- * Factory method that creates an <code>ActionToolbar</code> from the
+ * Factory method that creates an {@code ActionToolbar} from the
* specified group. The specified place is associated with the created toolbar.
*
* @param place Determines the place that will be set for {@link AnActionEvent} passed
*
* @param horizontal The orientation of the toolbar (true - horizontal, false - vertical)
*
- * @return An instance of <code>ActionToolbar</code>
+ * @return An instance of {@code ActionToolbar}
*/
public abstract ActionToolbar createActionToolbar(@NonNls String place, @NotNull ActionGroup group, boolean horizontal);
*
* @param actionId Id of the registered action
*
- * @return Action associated with the specified actionId, <code>null</code> if
+ * @return Action associated with the specified actionId, {@code null} if
* there is no actions associated with the specified actionId
*
- * @exception java.lang.IllegalArgumentException if <code>actionId</code> is <code>null</code>
+ * @exception java.lang.IllegalArgumentException if {@code actionId} is {@code null}
*
* @see com.intellij.openapi.actionSystem.IdeActions
*/
/**
* Returns actionId associated with the specified action.
*
- * @return id associated with the specified action, <code>null</code> if action
+ * @return id associated with the specified action, {@code null} if action
* is not registered
*
- * @exception java.lang.IllegalArgumentException if <code>action</code> is <code>null</code>
+ * @exception java.lang.IllegalArgumentException if {@code action} is {@code null}
*/
public abstract String getId(@NotNull AnAction action);
/**
* Returns the list of all registered action IDs with the specified prefix.
*
- * @return all action <code>id</code>s which have the specified prefix.
+ * @return all action {@code id}s which have the specified prefix.
* @since 5.1
*/
public abstract String[] getActionIds(@NotNull String idPrefix);
void setLayoutPolicy(int layoutPolicy);
/**
- * If the value is <code>true</code> then the all button on toolbar are
+ * If the value is {@code true} then the all button on toolbar are
* the same size. It very useful when you create "Outlook" like toolbar.
* Currently this method can be considered as hot fix.
*/
* at toolbar has 25x25 pixels size.
*
* @throws IllegalArgumentException
- * if <code>size</code>
- * is <code>null</code>
+ * if {@code size}
+ * is {@code null}
*/
void setMinimumButtonSize(@NotNull Dimension size);
private final boolean myIsActionToolbar;
/**
- * @throws IllegalArgumentException if <code>dataContext</code> is <code>null</code> or
- * <code>place</code> is <code>null</code> or <code>presentation</code> is <code>null</code>
+ * @throws IllegalArgumentException if {@code dataContext} is {@code null} or
+ * {@code place} is {@code null} or {@code presentation} is {@code null}
*
* @see ActionManager#getInstance()
*/
}
/**
- * @throws IllegalArgumentException if <code>dataContext</code> is <code>null</code> or
- * <code>place</code> is <code>null</code> or <code>presentation</code> is <code>null</code>
+ * @throws IllegalArgumentException if {@code dataContext} is {@code null} or
+ * {@code place} is {@code null} or {@code presentation} is {@code null}
*
* @see ActionManager#getInstance()
*/
}
/**
- * Returns the <code>InputEvent</code> which causes invocation of the action. It might be
- * <code>KeyEvent</code>, <code>MouseEvent</code>.
- * @return the <code>InputEvent</code> instance.
+ * Returns the {@code InputEvent} which causes invocation of the action. It might be
+ * {@code KeyEvent}, {@code MouseEvent}.
+ * @return the {@code InputEvent} instance.
*/
public InputEvent getInputEvent() {
return myInputEvent;
/**
* Allows a component hosting actions to provide context information to the actions. When a specific
* data item is requested, the component hierarchy is walked up from the currently focused component,
- * and every component implementing the <code>DataProvider</code> interface is queried for the data
+ * and every component implementing the {@code DataProvider} interface is queried for the data
* until one of them returns the data. Data items can also be mapped to each other - for example,
* if a data provider provides an item for {@link CommonDataKeys#NAVIGATABLE}, an item for
* {@link CommonDataKeys#NAVIGATABLE_ARRAY} can be generated from it automatically.
private final KeyStroke mySecondKeyStroke;
/**
- * @throws IllegalArgumentException if <code>firstKeyStroke</code> is <code>null</code>
+ * @throws IllegalArgumentException if {@code firstKeyStroke} is {@code null}
*/
public KeyboardShortcut(@NotNull KeyStroke firstKeyStroke, @Nullable KeyStroke secondKeyStroke) {
myFirstKeyStroke = firstKeyStroke;
/**
* Returns the state of this action.
*
- * @return <code>true</code> if action is enabled, <code>false</code> otherwise
+ * @return {@code true} if action is enabled, {@code false} otherwise
*/
public boolean isEnabled() {
return myEnabled;
* won't be called. In case when action represents a button or a menu item, the
* representing button or item will be greyed out.
*
- * @param enabled <code>true</code> if you want to enable action, <code>false</code> otherwise
+ * @param enabled {@code true} if you want to enable action, {@code false} otherwise
*/
public void setEnabled(boolean enabled) {
boolean oldEnabled = myEnabled;
*/
public interface ShortcutSet {
/**
- * @return array of keyboard <code>Shortcut</code>s that are in the set.
- * The method returns an empty array if there are no keyboard <code>Shortcuts</code>
+ * @return array of keyboard {@code Shortcut}s that are in the set.
+ * The method returns an empty array if there are no keyboard {@code Shortcuts}
*/
@NotNull
Shortcut[] getShortcuts();
void beforeActionPerformed(AnAction action, DataContext dataContext, AnActionEvent event);
/**
- * Note that using <code>dataContext</code> in implementing methods is unsafe - it could have been invalidated by the performed action.
+ * Note that using {@code dataContext} in implementing methods is unsafe - it could have been invalidated by the performed action.
*/
default void afterActionPerformed(AnAction action, DataContext dataContext, AnActionEvent event) {
}
void moveToVisualPosition(@NotNull VisualPosition pos);
/**
- * Short hand for calling {@link #moveToOffset(int, boolean)} with <code>'false'</code> as a second argument.
+ * Short hand for calling {@link #moveToOffset(int, boolean)} with {@code 'false'} as a second argument.
*
* @param offset the offset to move to
*/
* <p/>
* Current method allows to check that.
*
- * @return <code>true</code> if caret position is up-to-date for now; <code>false</code> otherwise
+ * @return {@code true} if caret position is up-to-date for now; {@code false} otherwise
*/
boolean isUpToDate();
* System selection will be updated, if such feature is supported by current editor.
*
* @param startOffset start selection offset
- * @param endPosition end visual position of the text range to select (<code>null</code> argument means that
+ * @param endPosition end visual position of the text range to select ({@code null} argument means that
* no specific visual position should be used)
* @param endOffset end selection offset
*/
* <p>
* System selection will be updated, if such feature is supported by current editor.
*
- * @param startPosition start visual position of the text range to select (<code>null</code> argument means that
+ * @param startPosition start visual position of the text range to select ({@code null} argument means that
* no specific visual position should be used)
- * @param endPosition end visual position of the text range to select (<code>null</code> argument means that
+ * @param endPosition end visual position of the text range to select ({@code null} argument means that
* no specific visual position should be used)
* @param startOffset start selection offset
* @param endOffset end selection offset
* <p/>
* Also, in column mode this method allows to create selection spanning virtual space after the line end.
*
- * @param startPosition start visual position of the text range to select (<code>null</code> argument means that
+ * @param startPosition start visual position of the text range to select ({@code null} argument means that
* no specific visual position should be used)
- * @param endPosition end visual position of the text range to select (<code>null</code> argument means that
+ * @param endPosition end visual position of the text range to select ({@code null} argument means that
* no specific visual position should be used)
* @param startOffset start selection offset
* @param endOffset end selection offset
* Clones the current caret and positions the new one right above or below the current one. If current caret has selection, corresponding
* selection will be set for the new caret.
*
- * @param above if <code>true</code>, new caret will be created at the previous line, if <code>false</code> - on the next line
- * @return newly created caret instance, or <code>null</code> if the caret cannot be created because it already exists at the new location
+ * @param above if {@code true}, new caret will be created at the previous line, if {@code false} - on the next line
+ * @return newly created caret instance, or {@code null} if the caret cannot be created because it already exists at the new location
* or caret model doesn't support multiple carets.
*/
@Nullable
Caret clone(boolean above);
/**
- * Returns <code>true</code> if caret is located in RTL text fragment. In that case visual column number is inversely related
+ * Returns {@code true} if caret is located in RTL text fragment. In that case visual column number is inversely related
* to offset and logical column number in the vicinity of caret.
*/
boolean isAtRtlLocation();
/**
- * Returns <code>true</code> if caret is located at a boundary between different runs of bidirectional text.
+ * Returns {@code true} if caret is located at a boundary between different runs of bidirectional text.
* This means that text fragments at different sides of the boundary are non-adjacent in logical order.
* Caret can located at any side of the boundary,
* exact location can be determined from directionality flags of caret's logical and visual position
void moveToVisualPosition(@NotNull VisualPosition pos);
/**
- * Short hand for calling {@link #moveToOffset(int, boolean)} with <code>'false'</code> as a second argument.
+ * Short hand for calling {@link #moveToOffset(int, boolean)} with {@code 'false'} as a second argument.
*
* @param offset the offset to move to
*/
* <p/>
* Current method allows to check that.
*
- * @return <code>true</code> if caret position is up-to-date for now; <code>false</code> otherwise
+ * @return {@code true} if caret position is up-to-date for now; {@code false} otherwise
*/
boolean isUpToDate();
List<Caret> getAllCarets();
/**
- * Returns a caret at the given position in the document, or <code>null</code>, if there's no caret there.
+ * Returns a caret at the given position in the document, or {@code null}, if there's no caret there.
*/
@Nullable
Caret getCaretAt(@NotNull VisualPosition pos);
/**
- * Same as {@link #addCaret(VisualPosition, boolean)} with <code>true</code> as a <code>makePrimary</code> boolean parameter value.
+ * Same as {@link #addCaret(VisualPosition, boolean)} with {@code true} as a {@code makePrimary} boolean parameter value.
*/
@Nullable
Caret addCaret(@NotNull VisualPosition pos);
/**
* Adds a new caret at the given position, and returns corresponding {@link Caret} instance. Locations outside of possible values
* for the given document are trimmed automatically.
- * Newly added caret will become a primary caret if and only if <code>makePrimary</code> value is <code>true</code>.
+ * Newly added caret will become a primary caret if and only if {@code makePrimary} value is {@code true}.
* Does nothing if multiple carets are not supported, a caret already exists at specified location or selection of existing caret
- * includes the specified location, <code>null</code> is returned in this case.
+ * includes the specified location, {@code null} is returned in this case.
*/
@Nullable
Caret addCaret(@NotNull VisualPosition pos, boolean makePrimary);
/**
- * Removes a given caret if it's recognized by the model and is not the only existing caret in the document, returning <code>true</code>.
- * <code>false</code> is returned if any of the above condition doesn't hold, and the removal cannot happen.
+ * Removes a given caret if it's recognized by the model and is not the only existing caret in the document, returning {@code true}.
+ * {@code false} is returned if any of the above condition doesn't hold, and the removal cannot happen.
*/
boolean removeCaret(@NotNull Caret caret);
* selection boundaries will mean that corresponding caret's position and/or selection won't be changed.
* <p>
* System selection will be updated, if such feature is supported by current editor
- * and corresponding invocation parameter is set to <code>true</code>.
+ * and corresponding invocation parameter is set to {@code true}.
*
* @throws IllegalArgumentException if {@code caretStates} list is empty, or if it contains more than one element and editor doesn't
* support multiple carets
List<CaretState> getCaretsAndSelections();
/**
- * Same as {@link #runForEachCaret(CaretAction, boolean)} with <code>reverseOrder</code> set to <code>false</code>
+ * Same as {@link #runForEachCaret(CaretAction, boolean)} with {@code reverseOrder} set to {@code false}
*/
void runForEachCaret(@NotNull CaretAction action);
* At the end, merging of carets and selections is performed, so that no two carets will occur at the same logical position and
* no two selection will overlap after this method is finished.
* <p>
- * Carets are iterated in position order (top-to-bottom) if <code>reverseOrder</code> is <code>false</code>, and in reverse order
- * if it's <code>true</code>.
+ * Carets are iterated in position order (top-to-bottom) if {@code reverseOrder} is {@code false}, and in reverse order
+ * if it's {@code true}.
*/
void runForEachCaret(@NotNull CaretAction action, boolean reverseOrder);
* Maps an offset in the document to a logical position.
* <p>
* It's assumed that original position is associated with character immediately preceding given offset, so target logical position will
- * have {@link LogicalPosition#leansForward leansForward} value set to <code>false</code>.
+ * have {@link LogicalPosition#leansForward leansForward} value set to {@code false}.
*
* @param offset the offset in the document.
* @return the corresponding logical position.
* Maps an offset in the document to a visual position.
*
* @param offset the offset in the document.
- * @param leanForward if <code>true</code>, original position is associated with character after given offset, if <code>false</code> -
+ * @param leanForward if {@code true}, original position is associated with character after given offset, if {@code false} -
* with character before given offset. This can make a difference in bidirectional text (see {@link LogicalPosition},
* {@link VisualPosition})
- * @param beforeSoftWrap if <code>true</code>, visual position at line preceeding the wrap will be returned, otherwise - visual position
+ * @param beforeSoftWrap if {@code true}, visual position at line preceeding the wrap will be returned, otherwise - visual position
* at line following the wrap.
* @return the corresponding visual position.
*/
* Set up a header component for this text editor. Please note this is used for textual find feature so your component will most
* probably will be reset once the user presses Ctrl+F.
*
- * @param header a component to setup as header for this text editor or <code>null</code> to remove one.
+ * @param header a component to setup as header for this text editor or {@code null} to remove one.
*/
void setHeaderComponent(@Nullable JComponent header);
/**
- * @return <code>true</code> if this editor has active header component set up by {@link #setHeaderComponent(JComponent)}
+ * @return {@code true} if this editor has active header component set up by {@link #setHeaderComponent(JComponent)}
*/
boolean hasHeaderComponent();
/**
- * @return a component set by {@link #setHeaderComponent(JComponent)} or <code>null</code> if no header currently installed.
+ * @return a component set by {@link #setHeaderComponent(JComponent)} or {@code null} if no header currently installed.
*/
@Nullable
JComponent getHeaderComponent();
/**
* Returns a registered id of action group, which is to be used for displaying context menu for the given custom element.
- * If <code>null</code> is returned, standard editor's context menu will be displayed upon corresponding mouse event.
+ * If {@code null} is returned, standard editor's context menu will be displayed upon corresponding mouse event.
*/
@Nullable
default String getContextMenuGroupId() {
* @param startLine logical line where target indent guide is started
* @param endLine logical line where target indent guide is ended
* @return indent guide descriptor registered for the given lines at the current model previously if any;
- * <code>null</code> otherwise
+ * {@code null} otherwise
*/
@Nullable
IndentGuideDescriptor getDescriptor(int startLine, int endLine);
public interface InlayModel {
/**
* Introduces an inline visual element at a given offset, its width and appearance is defined by the provided renderer. With respect to
- * document changes, created element behaves in a similar way to a zero-range {@link RangeMarker}. This method returns <code>null</code>
+ * document changes, created element behaves in a similar way to a zero-range {@link RangeMarker}. This method returns {@code null}
* if requested element cannot be created, e.g. if corresponding functionality is not supported by current editor instance.
*/
@Nullable
/**
* Return a custom visual element at given coordinates in editor's coordinate space,
- * or <code>null</code> if there's no element at given point.
+ * or {@code null} if there's no element at given point.
*/
@Nullable
Inlay getElementAt(@NotNull Point point);
* @param startOffset start offset to use with the given text holder (exclusive)
* @param endOffset end offset to use with the given text holder (exclusive)
* @param maxPreferredOffset this method is expected to do its best to return offset that belongs to
- * <code>(startOffset; maxPreferredOffset]</code> interval. However, it's allowed
- * to return value from <code>(maxPreferredOffset; endOffset)</code> interval
- * unless <code>'allowToBeyondMaxPreferredOffset'</code> if <code>'false'</code>
+ * {@code (startOffset; maxPreferredOffset]} interval. However, it's allowed
+ * to return value from {@code (maxPreferredOffset; endOffset)} interval
+ * unless {@code 'allowToBeyondMaxPreferredOffset'} if {@code 'false'}
* @param allowToBeyondMaxPreferredOffset indicates if it's allowed to return value from
- * <code>(maxPreferredOffset; endOffset]</code> interval in case of inability to
- * find appropriate offset from <code>(startOffset; maxPreferredOffset]</code> interval
+ * {@code (maxPreferredOffset; endOffset]} interval in case of inability to
+ * find appropriate offset from {@code (startOffset; maxPreferredOffset]} interval
* @param virtual identifies if current request is for virtual wrap (soft wrap) position
- * @return offset from <code>(startOffset; endOffset)</code> interval where
- * target line should be wrapped OR <code>-1</code> if no wrapping should be performed
+ * @return offset from {@code (startOffset; endOffset)} interval where
+ * target line should be wrapped OR {@code -1} if no wrapping should be performed
*/
int calculateWrapPosition(
@NotNull Document document, @Nullable Project project, int startOffset, int endOffset, int maxPreferredOffset,
* {@link #softWrapLinesBeforeCurrentLogicalLine}, {@link #softWrapColumnDiff} etc during {@code 'visual position' -> 'logical position'} conversion
* in order to be able to easy match it back to visual position.
*
- * @deprecated Always <code>false</code> in {@link LogicalPosition} instances returned by platform code since 2016.1.
+ * @deprecated Always {@code false} in {@link LogicalPosition} instances returned by platform code since 2016.1.
* Will be removed in future.
*/
public final boolean visualPositionAware;
* Number of virtual soft wrap-introduced lines before the current logical line.
*
* @see #visualPositionAware
- * @deprecated Always <code>0</code> in {@link LogicalPosition} instances returned by platform code since 2016.1.
+ * @deprecated Always {@code 0} in {@link LogicalPosition} instances returned by platform code since 2016.1.
* Will be removed in future.
*/
public final int softWrapLinesBeforeCurrentLogicalLine;
* it will work regardless of whether current {@code LogicalPosition} instance is {@link #visualPositionAware}.
*
* @see #visualPositionAware
- * @deprecated Always <code>0</code> in {@link LogicalPosition} instances returned by platform code since 2016.1.
+ * @deprecated Always {@code 0} in {@link LogicalPosition} instances returned by platform code since 2016.1.
* Will be removed in future.
*/
public final int softWrapLinesOnCurrentLogicalLine;
* Number to add to the {@link #column logical column} in order to get soft wrap-introduced visual column offset.
*
* @see #visualPositionAware
- * @deprecated Always <code>0</code> in {@link LogicalPosition} instances returned by platform code since 2016.1.
+ * @deprecated Always {@code 0} in {@link LogicalPosition} instances returned by platform code since 2016.1.
* Will be removed in future.
*/
public final int softWrapColumnDiff;
* Number of folded line feeds before the current position.
*
* @see #visualPositionAware
- * @deprecated Always <code>0</code> in {@link LogicalPosition} instances returned by platform code since 2016.1.
+ * @deprecated Always {@code 0} in {@link LogicalPosition} instances returned by platform code since 2016.1.
* Will be removed in future.
*/
public final int foldedLines;
* Number to add to the {@link #column logical column} in order to get folding-introduced visual column offset.
*
* @see #visualPositionAware
- * @deprecated Always <code>0</code> in {@link LogicalPosition} instances returned by platform code since 2016.1.
+ * @deprecated Always {@code 0} in {@link LogicalPosition} instances returned by platform code since 2016.1.
* Will be removed in future.
*/
public final int foldingColumnDiff;
* This field provides the value of {@link VisualPosition#leansRight} field of visual position corresponding to current position.
* It has meaning only if {@link #visualPositionAware} is set.
*
- * @deprecated Always <code>false</code> in {@link LogicalPosition} instances returned by platform code since 2016.1.
+ * @deprecated Always {@code false} in {@link LogicalPosition} instances returned by platform code since 2016.1.
* Will be removed in future.
*/
public final boolean visualPositionLeansRight;
String getSelectedText();
/**
- * If <code>allCarets</code> is <code>true</code>, returns the concatenation of selections for all carets, or <code>null</code> if there
- * are no selections. If <code>allCarets</code> is <code>false</code>, works just like {@link #getSelectedText}.
+ * If {@code allCarets} is {@code true}, returns the concatenation of selections for all carets, or {@code null} if there
+ * are no selections. If {@code allCarets} is {@code false}, works just like {@link #getSelectedText}.
*/
@Nullable
String getSelectedText(boolean allCarets);
boolean hasSelection();
/**
- * Checks if a range of text is currently selected. If <code>anyCaret</code> is <code>true</code>, check all existing carets in
- * the document, and returns <code>true</code> if any of them has selection, otherwise checks only the current caret.
+ * Checks if a range of text is currently selected. If {@code anyCaret} is {@code true}, check all existing carets in
+ * the document, and returns {@code true} if any of them has selection, otherwise checks only the current caret.
*
* @return true if a range of text is selected, false otherwise.
*/
* That is the case for soft wraps-aware processing where the whole soft wraps virtual space is matched to the same offset.
*
* @param startOffset start selection offset
- * @param endPosition end visual position of the text range to select (<code>null</code> argument means that
+ * @param endPosition end visual position of the text range to select ({@code null} argument means that
* no specific visual position should be used)
* @param endOffset end selection offset
*/
* <p/>
* That is the case for soft wraps-aware processing where the whole soft wraps virtual space is matched to the same offset.
*
- * @param startPosition start visual position of the text range to select (<code>null</code> argument means that
+ * @param startPosition start visual position of the text range to select ({@code null} argument means that
* no specific visual position should be used)
- * @param endPosition end visual position of the text range to select (<code>null</code> argument means that
+ * @param endPosition end visual position of the text range to select ({@code null} argument means that
* no specific visual position should be used)
* @param startOffset start selection offset
* @param endOffset end selection offset
void removeSelection();
/**
- * Removes the selection in the editor. If <code>allCarets</code> is <code>true</code>, removes selections from all carets in the
+ * Removes the selection in the editor. If {@code allCarets} is {@code true}, removes selections from all carets in the
* editor, otherwise, does this just for the current caret.
*/
void removeSelection(boolean allCarets);
package com.intellij.openapi.editor;
/**
- * Defines common interface for <code>'soft wrap'</code>, i.e. for virtual line break that doesn't present at actual file on a disk
+ * Defines common interface for {@code 'soft wrap'}, i.e. for virtual line break that doesn't present at actual file on a disk
* but is used exclusively during document representation.
*
* @author Denis Zhdanov
import java.util.List;
/**
- * Defines contract for the services that bring <code>'soft wrapping'</code> to the editor.
+ * Defines contract for the services that bring {@code 'soft wrapping'} to the editor.
* <p/>
- * <code>'Soft wrap'</code> here means representation of the line that exceeds right component viewport margin as if it is wrapped.
- * No changes are introduced to the actual document/file system during that, i.e. it's a pure <code>'view'</code> facility.
+ * {@code 'Soft wrap'} here means representation of the line that exceeds right component viewport margin as if it is wrapped.
+ * No changes are introduced to the actual document/file system during that, i.e. it's a pure {@code 'view'} facility.
* <p/>
* <b>Example:</b>
* <p/>
* </pre>
* <p/>
* Another important soft wrap feature is that as soon as the user starts typing on a line which representation is affected by
- * soft wrap (e.g. starts adding new call argument after <code>"test6"</code> at example above), that soft wraps becomes
- * <code>'hard wrap'</code>, i.e. virtual changes introduced by it are flushed to the underlying document.
+ * soft wrap (e.g. starts adding new call argument after {@code "test6"} at example above), that soft wraps becomes
+ * {@code 'hard wrap'}, i.e. virtual changes introduced by it are flushed to the underlying document.
* <p/>
* <b>Note:</b> soft wrap is assumed to provide as user-friendly indentation for those wrapped line as possible
- * (note that <code>"test6"</code> at example below is aligned to the parameters start).
+ * (note that {@code "test6"} at example below is aligned to the parameters start).
* <p/>
* Implementations of this interface are not obliged to be thread-safe.
*
public interface SoftWrapModel {
/**
- * Allows to answer if <code>'soft wrap'</code> feature is enabled.
+ * Allows to answer if {@code 'soft wrap'} feature is enabled.
*
- * @return <code>true</code> if <code>'soft wraps'</code> are enabled; <code>false</code> otherwise
+ * @return {@code true} if {@code 'soft wraps'} are enabled; {@code false} otherwise
*/
boolean isSoftWrappingEnabled();
* Asks current model for the soft wrap registered for the given document offset if any.
*
* @param offset target document offset
- * @return soft wrap registered for the given offset within the current model if any; <code>null</code> otherwise
+ * @return soft wrap registered for the given offset within the current model if any; {@code null} otherwise
*/
@Nullable
SoftWrap getSoftWrap(int offset);
* The soft wrap may be not shown if it's located, for example, inside collapsed folding region.
*
* @param softWrap soft wrap to check
- * @return <code>true</code> if given soft wrap is visible; <code>false</code> otherwise
+ * @return {@code true} if given soft wrap is visible; {@code false} otherwise
*/
boolean isVisible(SoftWrap softWrap);
* Allows to answer if given visual position points to soft wrap-introduced virtual space.
*
* @param position target visual position to check
- * @return <code>true</code> if given visual position points to soft wrap-introduced virtual space;
- * <code>false</code> otherwise
+ * @return {@code true} if given visual position points to soft wrap-introduced virtual space;
+ * {@code false} otherwise
*/
boolean isInsideSoftWrap(@NotNull VisualPosition position);
* Allows to answer if given visual position points to soft wrap-introduced virtual space or points just before soft wrap.
*
* @param visual target visual position to check
- * @return <code>true</code> if given visual position points to soft wrap-introduced virtual space;
- * <code>false</code> otherwise
+ * @return {@code true} if given visual position points to soft wrap-introduced virtual space;
+ * {@code false} otherwise
*/
boolean isInsideOrBeforeSoftWrap(@NotNull VisualPosition visual);
public final int line;
public final int column;
/**
- * If <code>true</code>, this position is associated with succeeding character (in visual order), otherwise it's associated with
+ * If {@code true}, this position is associated with succeeding character (in visual order), otherwise it's associated with
* preceding character. This can make difference in bidirectional text, where visual positions which differ only in this flag's value
* can correspond to a different logical positions.
* <p>
- * This field has no impact on equality and comparison relationships between <code>VisualPosition</code> instances.
+ * This field has no impact on equality and comparison relationships between {@code VisualPosition} instances.
*/
public final boolean leansRight;
* </pre>
*
* @param other visual position to compare with the current one
- * @return <code>true</code> if current position is 'after' the given one; <code>false</code> otherwise
+ * @return {@code true} if current position is 'after' the given one; {@code false} otherwise
*/
public boolean after(@NotNull VisualPosition other) {
if (line == other.line) {
}
/**
- * Constructs a new <code>VisualPosition</code> instance with a given value of {@link #leansRight} flag.
+ * Constructs a new {@code VisualPosition} instance with a given value of {@link #leansRight} flag.
*/
public VisualPosition leanRight(boolean value) {
return new VisualPosition(line, column, value);
import org.jetbrains.annotations.Nullable;
/**
- * Builds an empty editor color palette. The constructed palette can be filled with <code>EditorColorPalette.with...()</code> methods.
+ * Builds an empty editor color palette. The constructed palette can be filled with {@code EditorColorPalette.with...()} methods.
* @see EditorColorPalette#withBackgroundColors()
* @see EditorColorPalette#withForegroundColors()
*/
* @param fontSize target font size
* @param fallbackScheme colors scheme to use for fallback fonts retrieval (if necessary);
* @return fallback font family to use if font family with the given name is not registered at current environment;
- * <code>null</code> if font family with the given name is registered at the current environment
+ * {@code null} if font family with the given name is registered at the current environment
*/
@Nullable
public static String getFallbackName(@NotNull String fontName, int fontSize, @Nullable EditorColorsScheme fallbackScheme) {
import javax.swing.text.html.StyleSheet;
/**
- * Enumerates common font size values (inspired by CSS <code>'font-size'</code> property values).
+ * Enumerates common font size values (inspired by CSS {@code 'font-size'} property values).
* <p/>
* Note that such elements selection (and this enum existence at all) is based on the fact that standard Swing {@link JEditorPane}
* used by IJ for providing quick doc works only with predefined set of font sizes (see {@link StyleSheet#sizeMapDefault}).
* Looks for explicitly specified attributes either in the scheme or its parent scheme. No fallback keys are used.
*
* @param key The key to use for search.
- * @return Explicitly defined attribute or <code>null</code> if not found.
+ * @return Explicitly defined attribute or {@code null} if not found.
*/
@Nullable
public TextAttributes getDirectlyDefinedAttributes(@NotNull TextAttributesKey key) {
*
* @param changedFileOrDirPath changed file/dir path
* @param project current project
- * @return <code>null</code> if target change should not trigger external project refresh;
+ * @return {@code null} if target change should not trigger external project refresh;
* path to config file of an external project which should be refreshed
*/
@Nullable
private final int myProcessingWeight;
/**
- * Creates new <code>Key</code> object.
+ * Creates new {@code Key} object.
*
* @param dataClass class of the payload data which will be associated with the current key
* @param processingWeight there is a possible case that when a {@link DataNode} object has children of more than on type (children
@NotNull private final String myRootPath;
/**
- * Creates new <code>GradleContentRootImpl</code> object.
+ * Creates new {@code GradleContentRootImpl} object.
*
* @param rootPath path to the root directory
*/
/**
* Strategy for mapping {@link LibraryPathType external library path types} to {@link OrderRootType ide library path types}.
* <p/>
- * Is introduced because <code>'JavadocOrderRootType.getInstance()'</code> assumes that project IoC is setup thus
+ * Is introduced because {@code 'JavadocOrderRootType.getInstance()'} assumes that project IoC is setup thus
* make it ineligible for unit testing.
* <p/>
* Implementations of this interface are expected to be thread-safe.
* And should not include any 'heavy' tasks like not trivial code generations.
* It is supposed to be fast.
* @param settings settings to use for the project resolving;
- * <code>null</code> as indication that no specific settings are required
+ * {@code null} as indication that no specific settings are required
* @param listener callback to be notified about the execution
* @return object-level representation of the target external system project;
- * <code>null</code> if it's not possible to resolve the project due to the objective reasons
+ * {@code null} if it's not possible to resolve the project due to the objective reasons
* @throws ExternalSystemException in case when unexpected exception occurs during project info construction
* @throws IllegalArgumentException if given path is invalid
* @throws IllegalStateException if it's not possible to resolve target project info
* Un-links given external project from the current ide project.
*
* @param linkedProjectPath path of external project to be unlinked
- * @return <code>true</code> if there was an external project with the given config path linked to the current
+ * @return {@code true} if there was an external project with the given config path linked to the current
* ide project;
- * <code>false</code> otherwise
+ * {@code false} otherwise
*/
public boolean unlinkExternalProject(@NotNull String linkedProjectPath) {
PS removed = myLinkedProjectsSettings.remove(linkedProjectPath);
*
* @param ideProject target ide project
* @param projectData target external project
- * @return <code>true</code> if given ide project has 1-1 mapping to the given external project;
- * <code>false</code> otherwise
+ * @return {@code true} if given ide project has 1-1 mapping to the given external project;
+ * {@code false} otherwise
*/
public static boolean isOneToOneMapping(@NotNull Project ideProject, @NotNull ProjectData projectData) {
String linkedExternalProjectPath = null;
* @param externalSystemId target external system
* @param project target ide project
* @return root external project's path if given path is considered to point to a known sub-project's config;
- * <code>null</code> if it's not possible to find a root project's config path on the basis of the
+ * {@code null} if it's not possible to find a root project's config path on the basis of the
* given path
*/
@Nullable
*
* @param externalSystemId target external system
*
- * @return <code>true</code> if the ide is configured to work with external system api from the ide process;
- * <code>false</code> otherwise
+ * @return {@code true} if the ide is configured to work with external system api from the ide process;
+ * {@code false} otherwise
*/
public static boolean isInProcessMode(ProjectSystemId externalSystemId) {
return Registry.is(externalSystemId.getId() + ExternalSystemConstants.USE_IN_PROCESS_COMMUNICATION_REGISTRY_KEY_SUFFIX, false);
* <p/>
* It's also possible that particular implementation of {@link ParametersEnhancer} is compiled using dependency to classes
* which are provided by the {@link ParametersEnhancer#enhanceLocalProcessing(List) expanded classpath}. E.g. a class
- * <code>'A'</code> might use method of class <code>'B'</code> and 'A' is located at the current (system/plugin) classpath but
- * <code>'B'</code> is not. We need to reload <code>'A'</code> using its expanded classpath then, i.e. create new class loaded
- * with that expanded classpath and load <code>'A'</code> by it.
+ * {@code 'A'} might use method of class {@code 'B'} and 'A' is located at the current (system/plugin) classpath but
+ * {@code 'B'} is not. We need to reload {@code 'A'} using its expanded classpath then, i.e. create new class loaded
+ * with that expanded classpath and load {@code 'A'} by it.
* <p/>
* This method allows to do that.
*
};
/**
- * Exposes <code>'resolve external system project'</code> service that works at another process.
+ * Exposes {@code 'resolve external system project'} service that works at another process.
*
- * @return <code>'resolve external system project'</code> service
+ * @return {@code 'resolve external system project'} service
* @throws RemoteException in case of unexpected I/O exception during processing
* @throws IllegalStateException in case of inability to create the service
*/
RemoteExternalSystemProjectResolver<S> getResolver() throws RemoteException, IllegalStateException;
/**
- * Exposes <code>'run external system task'</code> service which works at another process.
+ * Exposes {@code 'run external system task'} service which works at another process.
*
* @return external system build manager
* @throws RemoteException in case of inability to create the service
* Allows to check if any task of the given type is being executed at the moment.
*
* @param type target task type
- * @return <code>true</code> if any task of the given type is being executed at the moment;
- * <code>false</code> otherwise
+ * @return {@code true} if any task of the given type is being executed at the moment;
+ * {@code false} otherwise
*/
public boolean hasTaskOfTypeInProgress(@NotNull ExternalSystemTaskType type, @NotNull Project project) {
String projectId = ExternalSystemTaskId.getProjectId(project);
* Allows to check if current service executes the target task.
*
* @param id target task's id
- * @return <code>true</code> if a task with the given id is executed at the moment by the current service;
- * <code>false</code> otherwise
+ * @return {@code true} if a task with the given id is executed at the moment by the current service;
+ * {@code false} otherwise
* @throws RemoteException as required by RMI
*/
boolean isTaskInProgress(@NotNull ExternalSystemTaskId id) throws RemoteException;
*
*
* @param id target task's id
- * @return <code>true</code> if a task was successfully canceled;
- * <code>false</code> otherwise
+ * @return {@code true} if a task was successfully canceled;
+ * {@code false} otherwise
* @throws RemoteException as required by RMI
*/
boolean cancelTask(@NotNull ExternalSystemTaskId id) throws RemoteException;
* Allows to register given listener to listen events from all tasks.
*
* @param listener listener to register
- * @return <code>true</code> if given listener was not registered before for the given key;
- * <code>false</code> otherwise
+ * @return {@code true} if given listener was not registered before for the given key;
+ * {@code false} otherwise
*/
boolean addNotificationListener(@NotNull ExternalSystemTaskNotificationListener listener);
*
* @param taskId target task's id
* @param listener listener to register
- * @return <code>true</code> if given listener was not registered before for the given key;
- * <code>false</code> otherwise
+ * @return {@code true} if given listener was not registered before for the given key;
+ * {@code false} otherwise
*/
boolean addNotificationListener(@NotNull ExternalSystemTaskId taskId, @NotNull ExternalSystemTaskNotificationListener listener);
* Allows to de-register given listener from the current manager
*
* @param listener listener to de-register
- * @return <code>true</code> if given listener was successfully de-registered;
- * <code>false</code> if given listener was not registered before
+ * @return {@code true} if given listener was successfully de-registered;
+ * {@code false} if given listener was not registered before
*/
boolean removeNotificationListener(@NotNull ExternalSystemTaskNotificationListener listener);
}
import org.jetbrains.annotations.Nullable;
/**
- * Defines common interface for resolving gradle project, i.e. building object-level representation of <code>'build.gradle'</code>.
+ * Defines common interface for resolving gradle project, i.e. building object-level representation of {@code 'build.gradle'}.
*
* @author Denis Zhdanov
* @since 8/8/11 10:58 AM
*
* @param settings target system settings
* @return a control for managing given system-level settings;
- * <code>null</code> if current external system doesn't have system-level settings (only project-level settings)
+ * {@code null} if current external system doesn't have system-level settings (only project-level settings)
*/
@Nullable
protected abstract ExternalSystemSettingsControl<SystemSettings> createSystemSettingsControl(@NotNull SystemSettings settings);
* project if it's already linked.
* <p/>
* This property helps us to achieve that - when an ide project is defined, that means that new modules are being imported
- * to that ide project from external project; when this property is <code>null</code> that means that new ide project is being
+ * to that ide project from external project; when this property is {@code null} that means that new ide project is being
* created on the target external project basis.
*
* @param currentProject current ide project (if any)
*
* @param settings target system settings
* @return a control for managing given system-level settings;
- * <code>null</code> if current external system doesn't have system-level settings (only project-level settings)
+ * {@code null} if current external system doesn't have system-level settings (only project-level settings)
*/
@Nullable
protected abstract ExternalSystemSettingsControl<SystemSettings> createSystemSettingsControl(@NotNull SystemSettings settings);
void reset();
/**
- * @return <code>true</code> if settings exposed by the current control have been modified; <code>false</code> otherwise
+ * @return {@code true} if settings exposed by the current control have been modified; {@code false} otherwise
*/
boolean isModified();
* @param projectSettings settings of the external project to link
* @param project target ide project to link external project to
* @param executionResultCallback it might take a while to resolve external project info, that's why it's possible to provide
- * a callback to be notified on processing result. It receives <code>true</code> if an external
+ * a callback to be notified on processing result. It receives {@code true} if an external
* project has been successfully linked to the given ide project;
- * <code>false</code> otherwise (note that corresponding notification with error details is expected
+ * {@code false} otherwise (note that corresponding notification with error details is expected
* to be shown to the end-user then)
* @param isPreviewMode flag which identifies if missing external project binaries should be downloaded
* @param progressExecutionMode identifies how progress bar will be represented for the current processing
}
/**
- * @return <code>true</code> if and only if specified <code>psiFile</code> has
- * <code>TodoItem</code>s accepted by the filter.
+ * @return {@code true} if and only if specified {@code psiFile} has
+ * {@code TodoItem}s accepted by the filter.
*/
public boolean accept(PsiTodoSearchHelper searchHelper, PsiFile psiFile) {
for (Iterator<TodoPattern> i = iterator(); i.hasNext(); ) {
}
/**
- * @return filter's name. That is not <code>null</code> string.
+ * @return filter's name. That is not {@code null} string.
*/
public String getName() {
return myName;
}
/**
- * @return <code>true</code> if and only if filters contains specified <code>pattern</code>.
+ * @return {@code true} if and only if filters contains specified {@code pattern}.
*/
public boolean contains(TodoPattern pattern) {
return myTodoPatterns.contains(pattern);
}
/**
- * Adds specified <code>pattern</code> to the set of containing patterns.
+ * Adds specified {@code pattern} to the set of containing patterns.
*/
public void addTodoPattern(TodoPattern pattern) {
LOG.assertTrue(!myTodoPatterns.contains(pattern));
}
/**
- * Adds specified <code>pattern</code> from the set of containing patterns.
+ * Adds specified {@code pattern} from the set of containing patterns.
*/
public void removeTodoPattern(TodoPattern pattern) {
LOG.assertTrue(myTodoPatterns.contains(pattern));
}
/**
- * @return <code>true</code> if and only if filter contains no <code>TodoPattern</code>s.
+ * @return {@code true} if and only if filter contains no {@code TodoPattern}s.
*/
public boolean isEmpty() {
return myTodoPatterns.isEmpty();
/**
* Asks current panel to switch to the next drawing iteration
*
- * @return <code>true</code> if there are more iterations
+ * @return {@code true} if there are more iterations
*/
public boolean nextIteration() {
int widthToUse = getImageWidthToUse();
/**
* For auto-generated regions (created by {@link com.intellij.lang.folding.FoldingBuilder}s), returns their 'collapsed by default'
- * status, for other regions returns <code>null</code>.
+ * status, for other regions returns {@code null}.
*/
@Nullable
public abstract Boolean isCollapsedByDefault(@NotNull FoldRegion region);
/**
* Calculates minimum spacing, allowed by formatting model (in columns) for a block starting at given offset,
* relative to its previous sibling block.
- * Returns <code>-1</code>, if required block cannot be found at provided offset,
+ * Returns {@code -1}, if required block cannot be found at provided offset,
* or spacing cannot be calculated due to some other reason.
*/
public abstract int getSpacingForBlockAtOffset(FormattingModel model, int offset);
/**
* Calculates minimum number of line feeds that should precede block starting at given offset, as dictated by formatting model.
- * Returns <code>-1</code>, if required block cannot be found at provided offset,
+ * Returns {@code -1}, if required block cannot be found at provided offset,
* or spacing cannot be calculated due to some other reason.
*/
public abstract int getMinLineFeedsBeforeBlockAtOffset(FormattingModel model, int offset);
boolean isShowExcludedFiles();
/**
- * If <code>true</code> then {@link com.intellij.ide.projectView.impl.NestingTreeStructureProvider} will modify the tree presentation
+ * If {@code true} then {@link com.intellij.ide.projectView.impl.NestingTreeStructureProvider} will modify the tree presentation
* according to the rules managed by {@link com.intellij.ide.projectView.impl.ProjectViewFileNestingService}: some peer files will be
- * shown as nested, for example generated <code>foo.js</code> and <code>foo.js.map</code> file nodes will be shown as children of the
- * original <code>foo.ts</code> node in the Project View.
+ * shown as nested, for example generated {@code foo.js} and {@code foo.js.map} file nodes will be shown as children of the
+ * original {@code foo.ts} node in the Project View.
*/
default boolean isUseFileNestingRules() {return true;}
}
/**
* Allows to postpone first start of validation
*
- * @return <code>false</code> if start validation in {@link ProjectSettingsStepBase#registerValidators()} method
+ * @return {@code false} if start validation in {@link ProjectSettingsStepBase#registerValidators()} method
*/
public boolean postponeValidation() {
return true;
/**
* Finds an executable file with the specified base name, that is located in a directory
* listed in an original PATH environment variable.
- * Original PATH environment variable value is a value returned by <code>System.getenv("PATH")</code>.
+ * Original PATH environment variable value is a value returned by {@code System.getenv("PATH")}.
*
* @param fileBaseName file base name
* @return {@link File} instance or null if not found
public abstract class FrameStateManager {
/**
- * Returns the global <code>FrameStateManager</code> instance.
+ * Returns the global {@code FrameStateManager} instance.
*
* @return the component instance.
*/
public interface DnDTargetChecker {
/**
* @param event Drag-n-Drop event
- * @return <code>true</code> - if this target is unable to handle the event and parent component should be asked to process it.
- * <code>false</code> - if this target is unable to handle the event and parent component should NOT be asked to process it.
+ * @return {@code true} - if this target is unable to handle the event and parent component should be asked to process it.
+ * {@code false} - if this target is unable to handle the event and parent component should NOT be asked to process it.
*
* @see DnDEvent#setDropPossible(boolean, String)
* @see DnDEvent#setDropPossible(String, DropActionHandler)
/**
* If you are interested in listening UI changes you have to
- * use this listener instead of registening <code>PropertyChangeListener</code>
- * into <code>UIManager</code>
+ * use this listener instead of registening {@code PropertyChangeListener}
+ * into {@code UIManager}
*
* @author Vladimir Kondratyev
*/
*/
void _commit(boolean finishChosen) throws CommitStepException;
/**
- * @return step's icon. This method can return <code>null</code>.
+ * @return step's icon. This method can return {@code null}.
*/
Icon getIcon();
/**
* @return {@link JComponent} that represents step's UI in the wizard. This
- * method should not return <code>null</code>.
+ * method should not return {@code null}.
*/
JComponent getComponent();
}
/**
- * Copies template presentation and shortcuts set to <code>targetAction</code>.
+ * Copies template presentation and shortcuts set to {@code targetAction}.
*
- * @param targetAction cannot be <code>null</code>
+ * @param targetAction cannot be {@code null}
*/
public final void initAction(@NotNull AnAction targetAction) {
Presentation sourcePresentation = getTemplatePresentation();
}
/**
- * Get all necessary data from event's DataContext to be used in <code>performUpdate()</code>, which is called asynchronously.
+ * Get all necessary data from event's DataContext to be used in {@code performUpdate()}, which is called asynchronously.
* @param e action event original update() method have been called with.
* @return prepared data for {@link #performUpdate} method.
*/
protected abstract void performUpdate(Presentation presentation, T data);
/**
- * Override this method to return <code>true</code> value if update method cannot be called asynchronously for whatever reason.
+ * Override this method to return {@code true} value if update method cannot be called asynchronously for whatever reason.
* @param e action event original update() method have been called with.
- * @return <code>false</code> if async update is possible and <code>false</code> otherwise.
+ * @return {@code false} if async update is possible and {@code false} otherwise.
*/
protected boolean forceSyncUpdate(AnActionEvent e) {
return false;
/**
* Returns Boolean.TRUE if action is executed in modal context and
* Boolean.FALSE if action is executed not in modal context. If context
- * is unknown then the value of this data constant is <code>null</code>.
+ * is unknown then the value of this data constant is {@code null}.
*
* @deprecated use {@link PlatformDataKeys#IS_MODAL_CONTEXT} instead
*/
* cases you will be using this implementation but note that there are
* cases (for example "Recent files" dialog) where children are determined
* on rules different than just positional constraints, that's when you need
- * to implement your own <code>ActionGroup</code>.
+ * to implement your own {@code ActionGroup}.
*
* @see Constraints
*
}
/**
- * Copies content from <code>group</code>.
+ * Copies content from {@code group}.
* @param other group to copy from
*/
public void copyFromGroup(@NotNull DefaultActionGroup other) {
/**
* Returns Boolean.TRUE if action is executed in modal context and
* Boolean.FALSE if action is executed not in modal context. If context
- * is unknown then the value of this data constant is <code>null</code>.
+ * is unknown then the value of this data constant is {@code null}.
*/
public static final DataKey<Boolean> IS_MODAL_CONTEXT = DataKey.create("isModalContext");
public static final DataKey<DiffViewer> DIFF_VIEWER = DataKey.create("diffViewer");
/**
* Pastes from clipboard into editor at caret(s) position.
*
- * @return ranges of text in the document, corresponding to pasted fragments, if paste succeeds, or <code>null</code> otherwise
+ * @return ranges of text in the document, corresponding to pasted fragments, if paste succeeds, or {@code null} otherwise
*/
@Nullable
public abstract TextRange[] pasteFromClipboard(@NotNull Editor editor);
/**
* Pastes given Transferable instance into editor at caret(s) position.
*
- * @return ranges of text in the document, corresponding to pasted fragments, if paste succeeds, or <code>null</code> otherwise
+ * @return ranges of text in the document, corresponding to pasted fragments, if paste succeeds, or {@code null} otherwise
*/
@Nullable
public abstract TextRange[] pasteTransferable(@NotNull Editor editor, @NotNull Transferable content);
}
/**
- * Inserts given string at each caret's position. Effective caret shift will be equal to <code>caretShift</code> for each caret.
+ * Inserts given string at each caret's position. Effective caret shift will be equal to {@code caretShift} for each caret.
*/
public static void typeInStringAtCaretHonorMultipleCarets(final Editor editor, @NotNull final String str, final boolean toProcessOverwriteMode, final int caretShift)
throws ReadOnlyFragmentModificationException
* The general idea is that it's possible to prefer position with lower offset if it's weight is more than the one from
* position with higher offset and distance between them is not too big.
* <p/>
- * Current algorithm uses the <code>'weight'</code> in a following manner:
+ * Current algorithm uses the {@code 'weight'} in a following manner:
* <p/>
* <pre>
* <ol>
* </pre>
* <p/>
* <b>Example</b>
- * Suppose we have two positions that define lines of length 30 and 10 symbols. Suppose that the weights are <code>'1'</code>
- * and <code>'4'</code> correspondingly.Position with greater weight is preferred because it's product is higher
+ * Suppose we have two positions that define lines of length 30 and 10 symbols. Suppose that the weights are {@code '1'}
+ * and {@code '4'} correspondingly.Position with greater weight is preferred because it's product is higher
* ({@code 10 * 4 > 30 * 1})
*/
public final double weight;
*
* @param actionId the ID of the action for which the handler is requested. Possible
* IDs are defined in the {@link com.intellij.openapi.actionSystem.IdeActions} class
- * by constants starting with <code>ACTION_EDITOR_</code>.
+ * by constants starting with {@code ACTION_EDITOR_}.
* @return the handler currently defined for the action.
*/
public abstract EditorActionHandler getActionHandler(@NonNls @NotNull String actionId);
*
* @param actionId the ID of the action for which the handler is set. Possible
* IDs are defined in the {@link com.intellij.openapi.actionSystem.IdeActions} class
- * by constants starting with <code>ACTION_EDITOR_</code>.
+ * by constants starting with {@code ACTION_EDITOR_}.
* @return the handler previously defined for the action.
*/
public abstract EditorActionHandler setActionHandler(@NonNls @NotNull String actionId, @NotNull EditorActionHandler handler);
private volatile boolean myReadyToCombine = true;
/**
- * Creates new <code>KillRingTransferable</code> object.
+ * Creates new {@code KillRingTransferable} object.
*
* @param data target text to transfer
* @param document document that contained given text
}
/**
- * @return <code>true</code> if current object can be combined with adjacent text; <code>false</code> otherwise.
- * Default value is <code>true</code>
+ * @return {@code true} if current object can be combined with adjacent text; {@code false} otherwise.
+ * Default value is {@code true}
*/
public boolean isReadyToCombine() {
return myReadyToCombine;
/**
* Allows to define if current object can be combined with adjacent text.
*
- * @param readyToCombine <code>true</code> if current object can be combined with adjacent text; <code>false</code> otherwise
+ * @param readyToCombine {@code true} if current object can be combined with adjacent text; {@code false} otherwise
*/
public void setReadyToCombine(boolean readyToCombine) {
myReadyToCombine = readyToCombine;
String[] getActionIds();
/**
- * @return all keyboard shortcuts for the action with the specified <code>actionId</code>
+ * @return all keyboard shortcuts for the action with the specified {@code actionId}
* or an empty array if the action doesn't have any keyboard shortcut.
*/
// 60 external usages - actionId cannot be marked as NotNull
}
/**
- * Factory method. It parses passed string and creates <code>MouseShortcut</code>.
+ * Factory method. It parses passed string and creates {@code MouseShortcut}.
*
* @param keystrokeString target keystroke
* @return shortcut for the given keystroke
- * @throws InvalidDataException if <code>keystrokeString</code> doesn't represent valid <code>MouseShortcut</code>.
+ * @throws InvalidDataException if {@code keystrokeString} doesn't represent valid {@code MouseShortcut}.
*/
public static MouseShortcut parseMouseShortcut(String keystrokeString) throws InvalidDataException {
if (Registry.is("ide.mac.forceTouch") && keystrokeString.startsWith("Force touch")) {
/**
* @return string representation of passed mouse shortcut. This method should
- * be used only for serializing of the <code>MouseShortcut</code>
+ * be used only for serializing of the {@code MouseShortcut}
*/
public static String getMouseShortcutString(MouseShortcut shortcut) {
if (Registry.is("ide.mac.forceTouch") && shortcut instanceof PressureShortcut) {
/**
* @param component target component to reassign previously mapped action (if any)
* @param oldKeyStroke previously mapped keystroke (e.g. standard one that you want to use in some different way)
- * @param newKeyStroke new keystroke to be assigned. <code>null</code> value means 'just unregister previously mapped action'
+ * @param newKeyStroke new keystroke to be assigned. {@code null} value means 'just unregister previously mapped action'
* @param condition one of
* <ul>
* <li>JComponent.WHEN_FOCUSED,</li>
* <li>JComponent.WHEN_IN_FOCUSED_WINDOW</li>
* <li>JComponent.UNDEFINED_CONDITION</li>
* </ul>
- * @return <code>true</code> if the action is reassigned successfully
+ * @return {@code true} if the action is reassigned successfully
*/
public static boolean reassignAction(@NotNull JComponent component,
@NotNull KeyStroke oldKeyStroke,
/**
* @param component target component to reassign previously mapped action (if any)
* @param oldKeyStroke previously mapped keystroke (e.g. standard one that you want to use in some different way)
- * @param newKeyStroke new keystroke to be assigned. <code>null</code> value means 'just unregister previously mapped action'
+ * @param newKeyStroke new keystroke to be assigned. {@code null} value means 'just unregister previously mapped action'
* @param condition one of
* <ul>
* <li>JComponent.WHEN_FOCUSED,</li>
* <li>JComponent.WHEN_IN_FOCUSED_WINDOW</li>
* <li>JComponent.UNDEFINED_CONDITION</li>
* </ul>
- * @param muteOldKeystroke if <code>true</code> old keystroke wouldn't work anymore
- * @return <code>true</code> if the action is reassigned successfully
+ * @param muteOldKeystroke if {@code true} old keystroke wouldn't work anymore
+ * @return {@code true} if the action is reassigned successfully
*/
public static boolean reassignAction(@NotNull JComponent component,
@NotNull KeyStroke oldKeyStroke,
*/
public abstract class SchemeExporter<T extends Scheme> {
/**
- * Writes a scheme to a given <code>outputStream</code>.
+ * Writes a scheme to a given {@code outputStream}.
*
* @param scheme The scheme to export.
* @param outputStream The output stream to write to.
}
/**
- * Adds specified <code>listener</code> to the browse button.
+ * Adds specified {@code listener} to the browse button.
*/
public void addActionListener(ActionListener listener){
myBrowseButton.addActionListener(listener);
public static final int NEXT_USER_EXIT_CODE = 2;
/**
- * If your action returned by <code>createActions</code> method has non
- * <code>null</code> value for this key, then the button that corresponds to the action will be the
+ * If your action returned by {@code createActions} method has non
+ * {@code null} value for this key, then the button that corresponds to the action will be the
* default button for the dialog. It's true if you don't change this behaviour
- * of <code>createJButtonForAction(Action)</code> method.
+ * of {@code createJButtonForAction(Action)} method.
*/
@NonNls public static final String DEFAULT_ACTION = "DefaultAction";
private static final Color BALLOON_BACKGROUND = new JBColor(new Color(0xf5e6e7), new Color(0x593d41));
/**
- * Creates modal <code>DialogWrapper</code>. The currently active window will be the dialog's parent.
+ * Creates modal {@code DialogWrapper}. The currently active window will be the dialog's parent.
*
* @param project parent window for the dialog will be calculated based on focused window for the
- * specified <code>project</code>. This parameter can be <code>null</code>. In this case parent window
+ * specified {@code project}. This parameter can be {@code null}. In this case parent window
* will be suggested based on current focused window.
* @param canBeParent specifies whether the dialog can be parent for other windows. This parameter is used
- * by <code>WindowManager</code>.
+ * by {@code WindowManager}.
* @throws IllegalStateException if the dialog is invoked not on the event dispatch thread
*/
protected DialogWrapper(@Nullable Project project, boolean canBeParent) {
}
/**
- * Creates modal <code>DialogWrapper</code> that can be parent for other windows.
+ * Creates modal {@code DialogWrapper} that can be parent for other windows.
* The currently active window will be the dialog's parent.
*
* @param project parent window for the dialog will be calculated based on focused window for the
- * specified <code>project</code>. This parameter can be <code>null</code>. In this case parent window
+ * specified {@code project}. This parameter can be {@code null}. In this case parent window
* will be suggested based on current focused window.
* @throws IllegalStateException if the dialog is invoked not on the event dispatch thread
* @see DialogWrapper#DialogWrapper(Project, boolean)
}
/**
- * Creates modal <code>DialogWrapper</code>. The currently active window will be the dialog's parent.
+ * Creates modal {@code DialogWrapper}. The currently active window will be the dialog's parent.
*
* @param canBeParent specifies whether the dialog can be parent for other windows. This parameter is used
- * by <code>WindowManager</code>.
+ * by {@code WindowManager}.
* @throws IllegalStateException if the dialog is invoked not on the event dispatch thread
*/
protected DialogWrapper(boolean canBeParent) {
/**
* @param parent parent component which is used to calculate heavy weight window ancestor.
- * <code>parent</code> cannot be <code>null</code> and must be showing.
+ * {@code parent} cannot be {@code null} and must be showing.
* @param canBeParent can be parent
* @throws IllegalStateException if the dialog is invoked not on the event dispatch thread
*/
/**
* Allows to postpone first start of validation
*
- * @return <code>false</code> if start validation in <code>init()</code> method
+ * @return {@code false} if start validation in {@code init()} method
*/
protected boolean postponeValidation() {
return true;
}
/**
- * Validates user input and returns <code>null</code> if everything is fine
+ * Validates user input and returns {@code null} if everything is fine
* or validation description with component where problem has been found.
*
- * @return <code>null</code> if everything is OK or validation descriptor
+ * @return {@code null} if everything is OK or validation descriptor
*/
@Nullable
protected ValidationInfo doValidate() {
}
/**
- * Validates user input and returns <code>List<ValidationInfo></code>.
+ * Validates user input and returns {@code List<ValidationInfo>}.
* If everything is fine the returned list is empty otherwise
* the list contains all invalid fields with error messages.
* This method should preferably be used when validating forms with multiply
* fields that require validation.
*
- * @return <code>List<ValidationInfo></code> of invalid fields. List
+ * @return {@code List<ValidationInfo>} of invalid fields. List
* is empty if no errors found.
*/
@NotNull
/**
* Creates border for dialog's content pane. By default content
- * pane has has empty border with <code>(8,12,8,12)</code> insets. Subclasses can
- * return <code>null</code> for no border.
+ * pane has has empty border with {@code (8,12,8,12)} insets. Subclasses can
+ * return {@code null} for no border.
*
* @return content pane border
*/
/**
* Creates panel located at the south of the content pane. By default that
- * panel contains dialog's buttons. This default implementation uses <code>createActions()</code>
- * and <code>createJButtonForAction(Action)</code> methods to construct the panel.
+ * panel contains dialog's buttons. This default implementation uses {@code createActions()}
+ * and {@code createJButtonForAction(Action)} methods to construct the panel.
*
* @return south panel
*/
}
/**
- * Creates <code>JButton</code> for the specified action. If the button has not <code>null</code>
- * value for <code>DialogWrapper.DEFAULT_ACTION</code> key then the created button will be the
+ * Creates {@code JButton} for the specified action. If the button has not {@code null}
+ * value for {@code DialogWrapper.DEFAULT_ACTION} key then the created button will be the
* default one for the dialog.
*
* @param action action for the button
/**
* Factory method. It creates the panel located at the
- * north of the dialog's content pane. The implementation can return <code>null</code>
+ * north of the dialog's content pane. The implementation can return {@code null}
* value. In this case there will be no input panel.
*
* @return north panel
/**
* Factory method. It creates panel with dialog options. Options panel is located at the
- * center of the dialog's content pane. The implementation can return <code>null</code>
+ * center of the dialog's content pane. The implementation can return {@code null}
* value. In this case there will be no options panel.
*
* @return center panel
/**
* Dispose the wrapped and releases all resources allocated be the wrapper to help
* more efficient garbage collection. You should never invoke this method twice or
- * invoke any method of the wrapper after invocation of <code>dispose</code>.
+ * invoke any method of the wrapper after invocation of {@code dispose}.
*
* @throws IllegalStateException if the dialog is disposed not on the event dispatch thread
*/
/**
* This method is invoked by default implementation of "Cancel" action. It just closes dialog
- * with <code>CANCEL_EXIT_CODE</code>. This is convenient place to override functionality of "Cancel" action.
+ * with {@code CANCEL_EXIT_CODE}. This is convenient place to override functionality of "Cancel" action.
* Note that the method does nothing if "Cancel" action isn't enabled.
*/
public void doCancelAction() {
/**
* You can use this method if you want to know by which event this actions got triggered. It is called only if
- * the cancel action was triggered by some input event, <code>doCancelAction</code> is called otherwise.
+ * the cancel action was triggered by some input event, {@code doCancelAction} is called otherwise.
*
* @param source AWT event
* @see #doCancelAction
/**
* This method is invoked by default implementation of "OK" action. It just closes dialog
- * with <code>OK_EXIT_CODE</code>. This is convenient place to override functionality of "OK" action.
+ * with {@code OK_EXIT_CODE}. This is convenient place to override functionality of "OK" action.
* Note that the method does nothing if "OK" action isn't enabled.
*/
protected void doOKAction() {
/**
* @return whether the native window cross button closes the window or not.
- * <code>true</code> means that cross performs hide or dispose of the dialog.
+ * {@code true} means that cross performs hide or dispose of the dialog.
*/
public boolean shouldCloseOnCross() {
return myCrossClosesWindow;
* By default "OK" and "Cancel" actions are returned. The "Help" action is automatically added if
* {@link #getHelpId()} returns non-null value.
* <p/>
- * Each action is represented by <code>JButton</code> created by {@link #createJButtonForAction(Action)}.
+ * Each action is represented by {@code JButton} created by {@link #createJButtonForAction(Action)}.
* These buttons are then placed into {@link #createSouthPanel() south panel} of dialog.
*
* @return dialog actions
/**
* @return default implementation of "OK" action. This action just invokes
- * <code>doOKAction()</code> method.
+ * {@code doOKAction()} method.
* @see #doOKAction
*/
@NotNull
/**
* @return default implementation of "Cancel" action. This action just invokes
- * <code>doCancelAction()</code> method.
+ * {@code doCancelAction()} method.
* @see #doCancelAction
*/
@NotNull
/**
* @return default implementation of "Help" action. This action just invokes
- * <code>doHelpAction()</code> method.
+ * {@code doHelpAction()} method.
* @see #doHelpAction
*/
@NotNull
/**
* Returns key for persisting dialog dimensions.
* <p/>
- * Default implementation returns <code>null</code> (no persisting).
+ * Default implementation returns {@code null} (no persisting).
*
* @return dimension service key
*/
/**
* @return horizontal stretch of the dialog. It means that the dialog's horizontal size is
* the product of horizontal stretch by horizontal size of packed dialog. The default value
- * is <code>1.0f</code>
+ * is {@code 1.0f}
*/
public final float getHorizontalStretch() {
return myHorizontalStretch;
/**
* @return vertical stretch of the dialog. It means that the dialog's vertical size is
* the product of vertical stretch by vertical size of packed dialog. The default value
- * is <code>1.0f</code>
+ * is {@code 1.0f}
*/
public final float getVerticalStretch() {
return myVerticalStretch;
* Sets horizontal alignment of dialog's buttons.
*
* @param alignment alignment of the buttons. Acceptable values are
- * <code>SwingConstants.CENTER</code> and <code>SwingConstants.RIGHT</code>.
- * The <code>SwingConstants.RIGHT</code> is the default value.
- * @throws IllegalArgumentException if <code>alignment</code> isn't acceptable
+ * {@code SwingConstants.CENTER} and {@code SwingConstants.RIGHT}.
+ * The {@code SwingConstants.RIGHT} is the default value.
+ * @throws IllegalArgumentException if {@code alignment} isn't acceptable
*/
protected final void setButtonsAlignment(@MagicConstant(intValues = {SwingConstants.CENTER, SwingConstants.RIGHT}) int alignment) {
if (SwingConstants.CENTER != alignment && SwingConstants.RIGHT != alignment) {
}
/**
- * @return <code>true</code> if and only if visible
+ * @return {@code true} if and only if visible
* @see Component#isVisible
*/
public boolean isVisible() {
}
/**
- * @return <code>true</code> if and only if showing
+ * @return {@code true} if and only if showing
* @see Window#isShowing
*/
public boolean isShowing() {
/**
* Dispose the wrapped and releases all resources allocated be the wrapper to help
* more efficient garbage collection. You should never invoke this method twice or
- * invoke any method of the wrapper after invocation of <code>dispose</code>.
+ * invoke any method of the wrapper after invocation of {@code dispose}.
*/
protected abstract void dispose();
}
/**
- * Creates the <code>FixedSizeButton</code> with specified size.
+ * Creates the {@code FixedSizeButton} with specified size.
*
* @throws IllegalArgumentException
- * if <code>size</code> isn't
+ * if {@code size} isn't
* positive integer number.
*/
public FixedSizeButton(int size) {
}
/**
- * Creates the <code>FixedSizeButton</code> which size is equals to
- * <code>component.getPreferredSize().height</code>. It is very convenient
+ * Creates the {@code FixedSizeButton} which size is equals to
+ * {@code component.getPreferredSize().height}. It is very convenient
* way to create "browse" like button near the text fields.
*/
public FixedSizeButton(@NotNull JComponent component) {
*/
public interface InputValidator {
/**
- * Checks whether the <code>inputString</code> is valid. It is invoked each time
+ * Checks whether the {@code inputString} is valid. It is invoked each time
* input changes.
*
* @param inputString the input to check
/**
* This method is invoked just before message dialog is closed with OK code.
- * If <code>false</code> is returned then then the message dialog will not be closed.
+ * If {@code false} is returned then then the message dialog will not be closed.
*
* @param inputString the input to check
* @return true if the dialog could be closed, false otherwhise.
}
/**
- * @return trimmed input string or <code>null</code> if user cancelled dialog.
+ * @return trimmed input string or {@code null} if user cancelled dialog.
*/
@Nullable
public static String showPasswordDialog(@Nls String message, @Nls(capitalization = Nls.Capitalization.Title) String title) {
}
/**
- * @return trimmed input string or <code>null</code> if user cancelled dialog.
+ * @return trimmed input string or {@code null} if user cancelled dialog.
*/
@Nullable
public static String showPasswordDialog(Project project, @Nls String message, @Nls(capitalization = Nls.Capitalization.Title) String title, @Nullable Icon icon) {
}
/**
- * @return trimmed input string or <code>null</code> if user cancelled dialog.
+ * @return trimmed input string or {@code null} if user cancelled dialog.
*/
@Nullable
public static String showPasswordDialog(@Nullable Project project,
}
/**
- * @return trimmed input string or <code>null</code> if user cancelled dialog.
+ * @return trimmed input string or {@code null} if user cancelled dialog.
*/
@Nullable
public static String showInputDialog(@Nullable Project project, String message, @Nls(capitalization = Nls.Capitalization.Title) String title, @Nullable Icon icon) {
}
/**
- * @return trimmed input string or <code>null</code> if user cancelled dialog.
+ * @return trimmed input string or {@code null} if user cancelled dialog.
*/
@Nullable
public static String showInputDialog(@NotNull Component parent, String message, @Nls(capitalization = Nls.Capitalization.Title) String title, @Nullable Icon icon) {
}
/**
- * @return <code>true</code> if splitter has vertical orientation, <code>false</code> otherwise
+ * @return {@code true} if splitter has vertical orientation, {@code false} otherwise
*/
public boolean getOrientation() {
return myVerticalSplit;
}
/**
- * @param verticalSplit <code>true</code> means that splitter will have vertical split
+ * @param verticalSplit {@code true} means that splitter will have vertical split
*/
public void setOrientation(boolean verticalSplit) {
myVerticalSplit = verticalSplit;
* The popup has a right to decide if its further processing should be continued (method return value).
*
* @param e new key event being processed
- * @return <code>true</code> if the event is completely dispatched, i.e. no further processing is necessary;
- * <code>false</code> otherwise
+ * @return {@code true} if the event is completely dispatched, i.e. no further processing is necessary;
+ * {@code false} otherwise
*/
boolean dispatchKeyEvent(@NotNull KeyEvent e);
}
@Nullable String actionPlace);
/**
- * @deprecated use {@link #createListPopup(ListPopupStep)} instead (<code>step</code> must be a ListPopupStep in any case)
+ * @deprecated use {@link #createListPopup(ListPopupStep)} instead ({@code step} must be a ListPopupStep in any case)
*/
@NotNull
public abstract ListPopup createWizardStep(@NotNull PopupStep step);
/**
* @param key a String key to perform a query for.
- * @return point stored under the specified <code>key</code>. The method returns
- * <code>null</code> if there is no stored value under the <code>key</code>. If point
- * is outside of current screen bounds then the method returns <code>null</code>. It
+ * @return point stored under the specified {@code key}. The method returns
+ * {@code null} if there is no stored value under the {@code key}. If point
+ * is outside of current screen bounds then the method returns {@code null}. It
* properly works in multi-monitor configuration.
- * @throws java.lang.IllegalArgumentException if <code>key</code> is <code>null</code>.
+ * @throws java.lang.IllegalArgumentException if {@code key} is {@code null}.
*/
@Nullable
public synchronized Point getLocation(String key) {
}
/**
- * Store specified <code>point</code> under the <code>key</code>. If <code>point</code> is
- * <code>null</code> then the value stored under <code>key</code> will be removed.
+ * Store specified {@code point} under the {@code key}. If {@code point} is
+ * {@code null} then the value stored under {@code key} will be removed.
*
* @param key a String key to store location for.
* @param point location to save.
- * @throws java.lang.IllegalArgumentException if <code>key</code> is <code>null</code>.
+ * @throws java.lang.IllegalArgumentException if {@code key} is {@code null}.
*/
public synchronized void setLocation(String key, Point point) {
setLocation(key, point, guessProject());
/**
* @param key a String key to perform a query for.
- * @return point stored under the specified <code>key</code>. The method returns
- * <code>null</code> if there is no stored value under the <code>key</code>.
- * @throws java.lang.IllegalArgumentException if <code>key</code> is <code>null</code>.
+ * @return point stored under the specified {@code key}. The method returns
+ * {@code null} if there is no stored value under the {@code key}.
+ * @throws java.lang.IllegalArgumentException if {@code key} is {@code null}.
*/
@Nullable
public synchronized Dimension getSize(@NotNull @NonNls String key) {
}
/**
- * Store specified <code>size</code> under the <code>key</code>. If <code>size</code> is
- * <code>null</code> then the value stored under <code>key</code> will be removed.
+ * Store specified {@code size} under the {@code key}. If {@code size} is
+ * {@code null} then the value stored under {@code key} will be removed.
*
* @param key a String key to to save size for.
* @param size a Size to save.
- * @throws java.lang.IllegalArgumentException if <code>key</code> is <code>null</code>.
+ * @throws java.lang.IllegalArgumentException if {@code key} is {@code null}.
*/
public synchronized void setSize(@NotNull @NonNls String key, Dimension size) {
setSize(key, size, guessProject());
}
/**
- * Copies all files matching the <code>filter</code> from <code>fromDir</code> to <code>toDir</code>.
+ * Copies all files matching the {@code filter} from {@code fromDir} to {@code toDir}.
* Symlinks end special files are ignored.
*
* @param requestor any object to control who called this method. Note that
- * it is considered to be an external change if <code>requestor</code> is <code>null</code>.
+ * it is considered to be an external change if {@code requestor} is {@code null}.
* See {@link VirtualFileEvent#getRequestor}
* @param fromDir the directory to copy from
* @param toDir the directory to copy to
}
/**
- * Makes a copy of the <code>file</code> in the <code>toDir</code> folder and returns it.
+ * Makes a copy of the {@code file} in the {@code toDir} folder and returns it.
* Handles both files and directories.
*
* @param requestor any object to control who called this method. Note that
- * it is considered to be an external change if <code>requestor</code> is <code>null</code>.
+ * it is considered to be an external change if {@code requestor} is {@code null}.
* See {@link VirtualFileEvent#getRequestor}
* @param file file or directory to make a copy of
* @param toDir directory to make a copy in
* Note that this method currently tested only for "file" and "jar" protocols under Unix and Windows
*
* @param url the URL to find file by
- * @return <code>{@link VirtualFile}</code> if the file was found, <code>null</code> otherwise
+ * @return <code>{@link VirtualFile}</code> if the file was found, {@code null} otherwise
*/
@Nullable
public static VirtualFile findFileByURL(@NotNull URL url) {
/**
* For virtual files containing meta information in the path. Like,
- * <code>x=3746374;y=738495;size=45\id=6729304\id=34343\id=656543</code>
+ * {@code x=3746374;y=738495;size=45\id=6729304\id=34343\id=656543}
* To wrap such a path into compact form implement getPresentablePath and it
- * will be used instead of <code>VirtualFile.getPath()</code>
+ * will be used instead of {@code VirtualFile.getPath()}
*
* @author Konstantin Bulenkov
* @see VirtualFile#getPath()
/**
* Tests whether the file passed to constructor exists.
*
- * @return <code>true</code> if and only if the file passed to constructor
- * exists; <code>false</code> otherwise
+ * @return {@code true} if and only if the file passed to constructor
+ * exists; {@code false} otherwise
*
* @throws SecurityException
* If a security manager exists and its <code>{@link
import java.util.Arrays;
/**
- * The container class for focus requests for <code>IdeFocusManager</code>
+ * The container class for focus requests for {@code IdeFocusManager}
* @see IdeFocusManager
*/
public abstract class FocusCommand extends ActiveRunnable implements Expirable {
import java.awt.*;
/**
- * Basic interface for requesting sending focus commands to <code>IdeFocusManager</code>
+ * Basic interface for requesting sending focus commands to {@code IdeFocusManager}
*/
public interface FocusRequestor extends Disposable {
*
* This class is also responsible for delivering key events while focus transferring is in progress.
* <p>
- * <code>IdeFocusManager</code> instance can be received per project or the global instance. The preferred way is
- * to use instance <code>IdeFocusManager.getInstance(project)</code>. If no project instance is available, then
- * <code>IdeFocusManager.getGlobalInstance()</code> can be used.
+ * {@code IdeFocusManager} instance can be received per project or the global instance. The preferred way is
+ * to use instance {@code IdeFocusManager.getInstance(project)}. If no project instance is available, then
+ * {@code IdeFocusManager.getGlobalInstance()} can be used.
*/
public abstract class IdeFocusManager implements FocusRequestor {
/**
* Reports of focus transfer is enabled right now. It can be disabled if app is inactive. In this case
- * all focus requests will be either postponed or executed only if <code>FocusCommand</code> can be executed on an inaactive app.
+ * all focus requests will be either postponed or executed only if {@code FocusCommand} can be executed on an inaactive app.
* @see com.intellij.openapi.wm.FocusCommand#canExecuteOnInactiveApp()
*/
public abstract boolean isFocusTransferEnabled();
/**
- * Returns <code>Expirable</code> instance for the given counter of focus commands. As any new <code>FocusCommand</code>
- * is emitted to execute, the counter increments thus making the returned <code>Expirable</code> objects expired.
+ * Returns {@code Expirable} instance for the given counter of focus commands. As any new {@code FocusCommand}
+ * is emitted to execute, the counter increments thus making the returned {@code Expirable} objects expired.
*/
@NotNull
public abstract Expirable getTimestamp(boolean trackOnlyForcedCommands);
/**
- * Returns <code>FocusRequestor</code> object which will emit focus requests unless expired.
+ * Returns {@code FocusRequestor} object which will emit focus requests unless expired.
* @see #getTimestamp(boolean)
*/
@NotNull
public abstract Component getFocusOwner();
/**
- * Runs runnable for which <code>DataContext</code> will no be computed from the current focus owner,
+ * Runs runnable for which {@code DataContext} will no be computed from the current focus owner,
* but used the given one
*/
public abstract void runOnOwnContext(@NotNull DataContext context, @NotNull Runnable runnable);
/**
- * Returns last focused component for the given <code>IdeFrame</code>
+ * Returns last focused component for the given {@code IdeFrame}
*/
@Nullable
public abstract Component getLastFocusedFor(@Nullable IdeFrame frame);
/**
- * Returns last focused <code>IdeFrame</code>
+ * Returns last focused {@code IdeFrame}
*/
@Nullable
public abstract IdeFrame getLastFocusedFrame();
/**
* Put the container window to front. May not execute of the app is inactive or under some other conditions. This
- * is the preferred way to finding the container window and unconditionally calling <code>window.toFront()</code>
+ * is the preferred way to finding the container window and unconditionally calling {@code window.toFront()}
*/
public abstract void toFront(JComponent c);
public abstract class WindowManager {
/**
- * @return <code>true</code> is and only if current OS supports alpha mode for windows and
+ * @return {@code true} is and only if current OS supports alpha mode for windows and
* all native libraries were successfully loaded.
*/
public abstract boolean isAlphaModeSupported();
/**
- * Sets alpha (transparency) ratio for the specified <code>window</code>.
+ * Sets alpha (transparency) ratio for the specified {@code window}.
* If alpha mode isn't supported by underlying windowing system then the method does nothing.
- * The method also does nothing if alpha mode isn't enabled for the specified <code>window</code>.
+ * The method also does nothing if alpha mode isn't enabled for the specified {@code window}.
*
- * @param window <code>window</code> which transparency should be changed.
- * @param ratio ratio of transparency. <code>0</code> means absolutely non transparent window.
- * <code>1</code> means absolutely transparent window.
- * @throws IllegalArgumentException if <code>window</code> is not displayable or not showing,
- * or if <code>ration</code> isn't in <code>[0..1]</code> range.
+ * @param window {@code window} which transparency should be changed.
+ * @param ratio ratio of transparency. {@code 0} means absolutely non transparent window.
+ * {@code 1} means absolutely transparent window.
+ * @throws IllegalArgumentException if {@code window} is not displayable or not showing,
+ * or if {@code ration} isn't in {@code [0..1]} range.
*/
public abstract void setAlphaModeRatio(Window window, float ratio);
/**
- * @return <code>true</code> if specified <code>window</code> is currently is alpha mode.
+ * @return {@code true} if specified {@code window} is currently is alpha mode.
*/
public abstract boolean isAlphaModeEnabled(Window window);
/**
- * Sets whether the alpha (transparent) mode is enabled for specified <code>window</code>.
+ * Sets whether the alpha (transparent) mode is enabled for specified {@code window}.
* If alpha mode isn't supported by underlying windowing system then the method does nothing.
*
* @param window window which mode to be set.
* Gets first window (starting from the active one) that can be parent for other windows.
* Note, that this method returns only subclasses of dialog or frame.
*
- * @return <code>null</code> if there is no currently active window or there are any window
+ * @return {@code null} if there is no currently active window or there are any window
* that can be parent.
*/
@Nullable
public abstract void removeListener(WindowManagerListener listener);
/**
- * @return <code>true</code> if full screen mode is supported in current OS.
+ * @return {@code true} if full screen mode is supported in current OS.
*/
public abstract boolean isFullScreenSupportedInCurrentOS();
import com.intellij.openapi.vfs.VirtualFile;
/**
- * Very often both methods <code>canNavigate</code> and <code>canNavigateToSource</code>
- * return <code>true</code>. This adapter class lets focus on navigation
+ * Very often both methods {@code canNavigate} and {@code canNavigateToSource}
+ * return {@code true}. This adapter class lets focus on navigation
* routine only.
*
* @author Konstantin Bulenkov
* Should be implemented by concrete implementations.
* This method is invoked only for customization of component.
* All component attributes are cleared when this method is being invoked.
- * Note that in general case <code>value</code> is not an instance of CheckedTreeNode.
+ * Note that in general case {@code value} is not an instance of CheckedTreeNode.
*/
public void customizeRenderer(JTree tree,
Object value,
/**
* Dialog was closed
- * @param color resulting color or <code>null</code> if dialog was cancelled
+ * @param color resulting color or {@code null} if dialog was cancelled
*/
void closed(@Nullable Color color);
}
import org.jetbrains.annotations.Nullable;
/**
- * Major difference between the parent class and <code>JBSplitter</code> is an ability to save proportion
+ * Major difference between the parent class and {@code JBSplitter} is an ability to save proportion
*
* @author Konstantin Bulenkov
* @see Splitter
/**
* Splitter proportion unique key
*
- * @return non empty unique String or <code>null</code> if splitter does not require proportion saving
+ * @return non empty unique String or {@code null} if splitter does not require proportion saving
*/
@Nullable
public final String getSplitterProportionKey() {
/**
* Sets proportion key
*
- * @param key non empty unique String or <code>null</code> if splitter does not require proportion saving
+ * @param key non empty unique String or {@code null} if splitter does not require proportion saving
*/
public final void setSplitterProportionKey(@Nullable String key) {
mySplitterProportionKey = key;
private TIntIntHashMap myFragmentAlignment;
/**
- * Component's icon. It can be <code>null</code>.
+ * Component's icon. It can be {@code null}.
*/
private Icon myIcon;
/**
/**
* This is the border around the text. For example, text can have a border
* if the component represents a selected item in a focused JList.
- * Border can be <code>null</code>.
+ * Border can be {@code null}.
*/
private Border myBorder;
/**
* Appends string fragments to existing ones. Appended string
- * will have specified <code>attributes</code>.
+ * will have specified {@code attributes}.
*
* @param fragment text fragment
* @param attributes text attributes
/**
* Appends string fragments to existing ones. Appended string
- * will have specified <code>attributes</code>.
+ * will have specified {@code attributes}.
*
* @param fragment text fragment
* @param attributes text attributes
}
/**
- * Clear all special attributes of <code>SimpleColoredComponent</code>.
+ * Clear all special attributes of {@code SimpleColoredComponent}.
* They are icon, text fragments and their attributes, "paint focus border".
*/
public void clear() {
}
/**
- * @return component's icon. This method returns <code>null</code>
+ * @return component's icon. This method returns {@code null}
* if there is no icon.
*/
public final Icon getIcon() {
* Sets a new gap between icon and text
*
* @param iconTextGap the gap between text and icon
- * @throws IllegalArgumentException if the <code>iconTextGap</code>
+ * @throws IllegalArgumentException if the {@code iconTextGap}
* has a negative value
*/
public void setIconTextGap(final int iconTextGap) {
/**
* Sets whether focus border is painted or not
*
- * @param paintFocusBorder <code>true</code> or <code>false</code>
+ * @param paintFocusBorder {@code true} or {@code false}
*/
protected final void setPaintFocusBorder(final boolean paintFocusBorder) {
myPaintFocusBorder = paintFocusBorder;
* Sets whether focus border extends to icon or not. If so then
* component also extends the selection.
*
- * @param focusBorderAroundIcon <code>true</code> or <code>false</code>
+ * @param focusBorderAroundIcon {@code true} or {@code false}
*/
protected final void setFocusBorderAroundIcon(final boolean focusBorderAroundIcon) {
myFocusBorderAroundIcon = focusBorderAroundIcon;
* <p>2. Truncated strings in the combobox popup if column width is less than text value width
* <p>
* <b>How to use:</b>
- * <p>1. In get <code>getTableCellEditorComponent</code> method create or use existent
- * <code>JBComboBoxTableCellEditorComponent</code> instance<br/>
- * <p>2. Init component by calling <code>setCell</code>, <code>setOptions</code>,
- * <code>setDefaultValue</code> methods
+ * <p>1. In get {@code getTableCellEditorComponent} method create or use existent
+ * {@code JBComboBoxTableCellEditorComponent} instance<br/>
+ * <p>2. Init component by calling {@code setCell}, {@code setOptions},
+ * {@code setDefaultValue} methods
* <p>3. Return the instance
*
* @author Konstantin Bulenkov
* It allows to add them into the LEFT, CENTER, or RIGHT group, which are aligned separately.
* Every group can contain any amount of components. The specified gap is added between components,
* and the double gap is added between groups of components.
- * <p><b>NB!: this class must be modified together with the <code>VerticalLayout</code> class accordingly</b></p>
+ * <p><b>NB!: this class must be modified together with the {@code VerticalLayout} class accordingly</b></p>
*
* @author Sergey.Malenkov
* @see VerticalLayout
* It allows to add them into the TOP, CENTER, or BOTTOM group, which are aligned separately.
* Every group can contain any amount of components. The specified gap is added between components,
* and the double gap is added between groups of components.
- * <p><b>NB!: this class must be modified together with the <code>HorizontalLayout</code> class accordingly</b></p>
+ * <p><b>NB!: this class must be modified together with the {@code HorizontalLayout} class accordingly</b></p>
*
* @author Sergey.Malenkov
* @see HorizontalLayout
}
/**
- * Returns true if <code>mouseX</code> falls
+ * Returns true if {@code mouseX} falls
* in the area of row that is used to expand/collapse the node and
- * the node at <code>row</code> does not represent a leaf.
+ * the node at {@code row} does not represent a leaf.
*/
protected boolean isLocationInExpandControl(@Nullable TreePath path, int mouseX) {
if (path == null) return false;
}
/**
- * This is overriden to set <code>updatingListSelectionModel</code>
+ * This is overriden to set {@code updatingListSelectionModel}
* and message super. This is the only place DefaultTreeSelectionModel
* alters the ListSelectionModel.
*/
}
/**
- * If <code>updatingListSelectionModel</code> is false, this will
+ * If {@code updatingListSelectionModel} is false, this will
* reset the selected paths from the selected rows in the list
* selection model.
*/
int getColumnCount();
/**
- * Returns the name for column number <code>column</code>.
+ * Returns the name for column number {@code column}.
*/
String getColumnName(int column);
/**
- * Returns the type for column number <code>column</code>.
+ * Returns the type for column number {@code column}.
*/
Class getColumnClass(int column);
/**
- * Returns the value to be displayed for node <code>node</code>,
- * at column number <code>column</code>.
+ * Returns the value to be displayed for node {@code node},
+ * at column number {@code column}.
*/
Object getValueAt(Object node, int column);
/**
- * Indicates whether the value for node <code>node</code>,
- * at column number <code>column</code> is editable.
+ * Indicates whether the value for node {@code node},
+ * at column number {@code column} is editable.
*/
boolean isCellEditable(Object node, int column);
/**
- * Sets the value for node <code>node</code>,
- * at column number <code>column</code>.
+ * Sets the value for node {@code node},
+ * at column number {@code column}.
*/
void setValueAt(Object aValue, Object node, int column);
/**
* Constructs a QueueProcessor with the given processor and autostart setting.
- * By default QueueProcessor starts processing when it receives the first element. Pass <code>false</code> to alternate its behavior.
+ * By default QueueProcessor starts processing when it receives the first element. Pass {@code false} to alternate its behavior.
*
* @param processor processor of queue elements.
- * @param autostart if <code>true</code> (which is by default), the queue will be processed immediately when it receives the first element.
- * If <code>false</code>, then it will wait for the {@link #start()} command.
+ * @param autostart if {@code true} (which is by default), the queue will be processed immediately when it receives the first element.
+ * If {@code false}, then it will wait for the {@link #start()} command.
* After QueueProcessor has started once, autostart setting doesn't matter anymore: all other elements will be processed immediately.
*/
}
/**
- * Compute the value to be returned by the <code>get</code> method.
+ * Compute the value to be returned by the {@code get} method.
*/
public abstract Object construct();
/**
* Called on the event dispatching thread (not on the worker thread)
- * after the <code>construct</code> method has returned.
+ * after the {@code construct} method has returned.
*/
public void finished() {
/**
* Called in the worker thread in case a RuntimeException or Error occurred
- * if the <code>construct</code> method has thrown an uncaught Throwable.
+ * if the {@code construct} method has thrown an uncaught Throwable.
*/
public void onThrowable() {
}
}
/**
- * Return the value created by the <code>construct</code> method.
+ * Return the value created by the {@code construct} method.
* Returns null if either the constructing thread or the current
* thread was interrupted before a value was produced.
*
- * @return the value created by the <code>construct</code> method
+ * @return the value created by the {@code construct} method
*/
public Object get() {
}
/**
- * Start a thread that will call the <code>construct</code> method
+ * Start a thread that will call the {@code construct} method
* and then exit.
*/
public class ReadOnlyAttributeUtil {
/**
- * Sets specified read-only status for the spcified <code>file</code>.
+ * Sets specified read-only status for the spcified {@code file}.
* This method can be performed only for files which are in local file system.
*
* @param file file which read-only attribute to be changed.
* @param readOnlyStatus new read-only status.
* @throws java.lang.IllegalArgumentException
- * if passed <code>file</code> doesn't
+ * if passed {@code file} doesn't
* belong to the local file system.
- * @throws IOException if some <code>IOException</code> occurred.
+ * @throws IOException if some {@code IOException} occurred.
*/
public static void setReadOnlyAttribute(VirtualFile file, boolean readOnlyStatus) throws IOException {
if (file.getFileSystem().isReadOnly()) {
/**
* Show the dialog
- * @return <code>true</code> if "Try Again" button pressed and <code>false</code> if "Cancel" button pressed
+ * @return {@code true} if "Try Again" button pressed and {@code false} if "Cancel" button pressed
*/
public static boolean showErrorDialog(final String title, final String text) {
final Ref<Boolean> ok = Ref.create(false);
}
/**
- * @param y <code>y</code> coordinate in layered pane coordinate system.
+ * @param y {@code y} coordinate in layered pane coordinate system.
*/
@Nullable
public static LightweightHint showEditorFragmentHintAt(Editor editor,
/**
* @param userMessage user-friendly message description (short, single line if possible)
* @param details technical details (exception stack trace etc.)
- * @param title text to show in Event Log tool window entry (it comes before 'more'), use <code>null</code> to reuse <code>userMessage</code>
- * @param notificationText text to show in the error balloon that is popped up automatically. Default is <code>com.intellij.diagnostic.IdeMessagePanel#INTERNAL_ERROR_NOTICE</code>
+ * @param title text to show in Event Log tool window entry (it comes before 'more'), use {@code null} to reuse {@code userMessage}
+ * @param notificationText text to show in the error balloon that is popped up automatically. Default is {@code com.intellij.diagnostic.IdeMessagePanel#INTERNAL_ERROR_NOTICE}
* @param attachments attachments that will be suggested to include to the report
*/
public static IdeaLoggingEvent createEvent(final String userMessage,
/**
* @param userMessage user-friendly message description (short, single line if possible)
* @param details technical details (exception stack trace etc.)
- * @param title text to show in Event Log tool window entry (it comes before 'more'), use <code>null</code> to reuse <code>userMessage</code>
- * @param notificationText text to show in the error balloon that is popped up automatically. Default is <code>com.intellij.diagnostic.IdeMessagePanel#INTERNAL_ERROR_NOTICE</code>
+ * @param title text to show in Event Log tool window entry (it comes before 'more'), use {@code null} to reuse {@code userMessage}
+ * @param notificationText text to show in the error balloon that is popped up automatically. Default is {@code com.intellij.diagnostic.IdeMessagePanel#INTERNAL_ERROR_NOTICE}
* @param attachment attachment that will be suggested to include to the report
*/
public static IdeaLoggingEvent createEvent(String userMessage,
*
* @param newData new data to merge
* @param oldData old data to merge
- * @return merge result of the given data if possible; <code>null</code> otherwise
+ * @return merge result of the given data if possible; {@code null} otherwise
* @throws IOException as defined by {@link Transferable#getTransferData(DataFlavor)}
* @throws UnsupportedFlavorException as defined by {@link Transferable#getTransferData(DataFlavor)}
*/
}
/**
- * This is the "rule" method constructs <code>ID</code> of the action for activating tool window
- * with specified <code>ID</code>.
+ * This is the "rule" method constructs {@code ID} of the action for activating tool window
+ * with specified {@code ID}.
*
- * @param id <code>id</code> of tool window to be activated.
+ * @param id {@code id} of tool window to be activated.
*/
@NonNls
public static String getActionIdForToolWindow(String id) {
/**
* @return mnemonic for action if it has Alt+digit/Meta+digit shortcut.
- * Otherwise the method returns <code>-1</code>. Meta mask is OK for
+ * Otherwise the method returns {@code -1}. Meta mask is OK for
* Mac OS X user, because Alt+digit types strange characters into the
* editor.
*/
/**
* Updates LAF of all windows. The method also updates font of components
- * as it's configured in <code>UISettings</code>.
+ * as it's configured in {@code UISettings}.
*/
@Override
public void updateUI() {
* Paints additional buttons decorations
* @param g Graphics
* @param c button component
- * @return <code>true</code> if it is allowed to continue painting,
- * <code>false</code> if painting should be stopped
+ * @return {@code true} if it is allowed to continue painting,
+ * {@code false} if painting should be stopped
*/
protected boolean paintDecorations(Graphics2D g, JComponent c) {
int w = c.getWidth();
}
/**
- * Uninstalls the previously installed <code>LayoutManager</code>.
+ * Uninstalls the previously installed {@code LayoutManager}.
*
* @param root Root pane.
*/
/**
* Installs the necessary state onto the JRootPane to render client
- * decorations. This is ONLY invoked if the <code>JRootPane</code> has a
- * decoration style other than <code>JRootPane.NONE</code>.
+ * decorations. This is ONLY invoked if the {@code JRootPane} has a
+ * decoration style other than {@code JRootPane.NONE}.
*
* @param root Root pane.
*/
/**
* @return button's icon. Icon depends on action's state. It means that the method returns
- * disabled icon if action is disabled. If the action's icon is <code>null</code> then it returns
+ * disabled icon if action is disabled. If the action's icon is {@code null} then it returns
* an empty icon.
*/
public Icon getIcon() {
projects / idea / community.git / commitdiff