diff options
| author | Alexander Kurtakov | 2019-02-14 15:33:35 +0000 |
|---|---|---|
| committer | Alexander Kurtakov | 2019-02-14 15:45:48 +0000 |
| commit | 62a4a631630ed77cfdd1e27333cafae0a7cbcf27 (patch) | |
| tree | 07093d13fc2718ae6d7b9ed1ca9a392449c8377c | |
| parent | 2341d0c7e25069e795fafd9d027acec7f99c8884 (diff) | |
| download | eclipse.platform.debug-62a4a631630ed77cfdd1e27333cafae0a7cbcf27.tar.gz eclipse.platform.debug-62a4a631630ed77cfdd1e27333cafae0a7cbcf27.tar.xz eclipse.platform.debug-62a4a631630ed77cfdd1e27333cafae0a7cbcf27.zip | |
Bug 543933 - Build javadocs with Java 11I20190215-0630I20190215-0055I20190214-1800
Fix javadoc warnings catched by Java 11 tool with XDoclint:html.
Change-Id: I99061cad4e8a9e3eb18bfc97143fa893715a58f8
Signed-off-by: Alexander Kurtakov <akurtako@redhat.com>
44 files changed, 689 insertions, 573 deletions
diff --git a/org.eclipse.core.variables/META-INF/MANIFEST.MF b/org.eclipse.core.variables/META-INF/MANIFEST.MF index 93be34167..7b3e2de4c 100644 --- a/org.eclipse.core.variables/META-INF/MANIFEST.MF +++ b/org.eclipse.core.variables/META-INF/MANIFEST.MF @@ -2,7 +2,7 @@ Manifest-Version: 1.0 Bundle-ManifestVersion: 2 Bundle-Name: %pluginName Bundle-SymbolicName: org.eclipse.core.variables; singleton:=true -Bundle-Version: 3.4.300.qualifier +Bundle-Version: 3.4.400.qualifier Bundle-Activator: org.eclipse.core.variables.VariablesPlugin Bundle-Vendor: %providerName Bundle-Localization: plugin diff --git a/org.eclipse.core.variables/pom.xml b/org.eclipse.core.variables/pom.xml index 1cd8996f2..63fa0a644 100644 --- a/org.eclipse.core.variables/pom.xml +++ b/org.eclipse.core.variables/pom.xml @@ -18,6 +18,6 @@ </parent> <groupId>org.eclipse.core</groupId> <artifactId>org.eclipse.core.variables</artifactId> - <version>3.4.300-SNAPSHOT</version> + <version>3.4.400-SNAPSHOT</version> <packaging>eclipse-plugin</packaging> </project> diff --git a/org.eclipse.core.variables/src/org/eclipse/core/variables/IDynamicVariable.java b/org.eclipse.core.variables/src/org/eclipse/core/variables/IDynamicVariable.java index 7a8c2ac67..80efe9b58 100644 --- a/org.eclipse.core.variables/src/org/eclipse/core/variables/IDynamicVariable.java +++ b/org.eclipse.core.variables/src/org/eclipse/core/variables/IDynamicVariable.java @@ -16,11 +16,14 @@ package org.eclipse.core.variables; import org.eclipse.core.runtime.CoreException; /** - * A dynamic variable is a variable whose value is computed dynamically - * by a resolver at the time a string substitution is performed. A dynamic - * variable is contributed by an extension. + * A dynamic variable is a variable whose value is computed dynamically by a + * resolver at the time a string substitution is performed. A dynamic variable + * is contributed by an extension. * <p> - * The following is a definition of a dynamic variable that resolves to the name of the selected resource: + * The following is a definition of a dynamic variable that resolves to the name + * of the selected resource: + * </p> + * * <pre> * <extension point="org.eclipse.core.variables.dynamicVariables"> * <variable @@ -31,11 +34,11 @@ import org.eclipse.core.runtime.CoreException; * </variable> * </extension> * </pre> - * </p> * <p> * Clients contributing a dynamic variable provide an implementation of * {@link org.eclipse.core.variables.IDynamicVariableResolver}. * </p> + * * @since 3.0 * @noimplement This interface is not intended to be implemented by clients. */ diff --git a/org.eclipse.core.variables/src/org/eclipse/core/variables/IStringVariable.java b/org.eclipse.core.variables/src/org/eclipse/core/variables/IStringVariable.java index 62e99640b..72d52fdfa 100644 --- a/org.eclipse.core.variables/src/org/eclipse/core/variables/IStringVariable.java +++ b/org.eclipse.core.variables/src/org/eclipse/core/variables/IStringVariable.java @@ -15,28 +15,31 @@ package org.eclipse.core.variables; /** - * A variable that can be referenced in an expression, which resolves to a string - * value. Variables are referenced in expressions via their name, in the following - * format. + * A variable that can be referenced in an expression, which resolves to a + * string value. Variables are referenced in expressions via their name, in the + * following format. + * * <pre> * ${varname} or ${varname:argument} * </pre> * <p> - * A variable is identified by its name, and optionally accepts an argument. When an - * argument is present, a colon separates the variable name from its argument. + * A variable is identified by its name, and optionally accepts an argument. + * When an argument is present, a colon separates the variable name from its + * argument. * </p> * <p> * Variables can be contributed by extensions or programmatically. There are two * kinds of variables. + * </p> * <ul> - * <li><code>IValueVariable</code> - variables that have a value (with getter and setter), and - * accept no arguments. The value of this type of variable is resolved at the time - * its value is set via its setter API.</li> - * <li><code>IDynamicVariable</code> - variables whose value is resolved at the time - * a string substitution is performed by a contributed resolver. Dynamic variables - * may accept an argument.</li> + * <li><code>IValueVariable</code> - variables that have a value (with getter + * and setter), and accept no arguments. The value of this type of variable is + * resolved at the time its value is set via its setter API.</li> + * <li><code>IDynamicVariable</code> - variables whose value is resolved at the + * time a string substitution is performed by a contributed resolver. Dynamic + * variables may accept an argument.</li> * </ul> - * </p> + * * @since 3.0 * @noimplement This interface is not intended to be implemented by clients. */ diff --git a/org.eclipse.core.variables/src/org/eclipse/core/variables/IValueVariable.java b/org.eclipse.core.variables/src/org/eclipse/core/variables/IValueVariable.java index fb9d37262..ef076b1bc 100644 --- a/org.eclipse.core.variables/src/org/eclipse/core/variables/IValueVariable.java +++ b/org.eclipse.core.variables/src/org/eclipse/core/variables/IValueVariable.java @@ -14,19 +14,23 @@ package org.eclipse.core.variables; /** - * A variable with a value that can be set and retrieved. The context in which - * a value variable is referenced does not affect the value of the variable. - * A value variable can be contributed by an extension or created programmatically. - * A contributor may optionally specify an initial value for a variable, or - * provide a delegate that will initialize the variable with a value. + * A variable with a value that can be set and retrieved. The context in which a + * value variable is referenced does not affect the value of the variable. A + * value variable can be contributed by an extension or created + * programmatically. A contributor may optionally specify an initial value for a + * variable, or provide a delegate that will initialize the variable with a + * value. * <p> - * Since 3.3, a variable can be specified as a "read only" preventing users from changing - * the value after it has been initialized. Furthermore, a read only variable that is - * contributed by an extension will always load the value from the extension. + * Since 3.3, a variable can be specified as a "read only" preventing users from + * changing the value after it has been initialized. Furthermore, a read only + * variable that is contributed by an extension will always load the value from + * the extension. * </p> * <p> * Example of a value variable contribution with an initial value, the specified * variable is created with the initial value "/usr/local/foo". + * </p> + * * <pre> * <extension point="org.eclipse.core.variables.valueVariables"> * <variable @@ -35,11 +39,12 @@ package org.eclipse.core.variables; * </variable> * </extension> * </pre> - * </p> * <p> * Example of a value variable contribution with an initializer class, the class * "com.example.FooLocator" will be used to initialize the value the first time * it's requested. + * </p> + * * <pre> * <extension point="org.eclipse.core.variables.valueVariables"> * <variable @@ -48,7 +53,7 @@ package org.eclipse.core.variables; * </variable> * </extension> * </pre> - * </p> + * * @since 3.0 * @noimplement This interface is not intended to be implemented by clients. */ diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugEvent.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugEvent.java index d0eaefe5f..313d3218e 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugEvent.java +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugEvent.java @@ -19,124 +19,136 @@ import java.util.EventObject; import org.eclipse.debug.internal.core.DebugCoreMessages; /** - * A debug event describes an event in a program being debugged or - * in a running process. Debug models and process implementations - * are required to generate debug events as specified by this class. + * A debug event describes an event in a program being debugged or in a running + * process. Debug models and process implementations are required to generate + * debug events as specified by this class. * <p> - * The following list defines the events generated for each debug - * model element. - * The <code>getSource()</code> method of a debug event - * returns the element associated with the event. - * Creation events are guaranteed to occur in a top - * down order - that is, parents are created before children. - * Termination events are guaranteed to occur in a bottom up order - - * that is, children before parents. However, termination events are not guaranteed - * for all elements that are created. That is, terminate events can be coalesced - a - * terminate event for a parent signals that all children have been terminated. + * The following list defines the events generated for each debug model element. + * The <code>getSource()</code> method of a debug event returns the element + * associated with the event. Creation events are guaranteed to occur in a top + * down order - that is, parents are created before children. Termination events + * are guaranteed to occur in a bottom up order - that is, children before + * parents. However, termination events are not guaranteed for all elements that + * are created. That is, terminate events can be coalesced - a terminate event + * for a parent signals that all children have been terminated. * </p> * <p> * A debug model may define model specific events by specifying a debug event - * kind of <code>MODEL_SPECIFIC</code>. A model specific event is identified by the - * event source (i.e. by the debug model that generated the event). The detail of - * a model specific event is client defined. Note that model specific events are - * not understood by the debug platform, and are thus ignored. + * kind of <code>MODEL_SPECIFIC</code>. A model specific event is identified by + * the event source (i.e. by the debug model that generated the event). The + * detail of a model specific event is client defined. Note that model specific + * events are not understood by the debug platform, and are thus ignored. * </p> * <p> - * The generic <code>CHANGE</code> event can be fired at any time by any element. - * Generally, a client of a debug model, such as as a UI, can get sufficient - * information to update by listening/responding to the other event kinds. However, - * if a debug model needs to inform clients of a change that is not specified - * by create/terminate/suspend/resume, the <code>CHANGE</code> event may be used. - * For example, generally, the only way a thread or any of its children can change - * state between a suspend and resume operation, is if the thread or owning debug - * target is terminated. However, if a debug model supports some other operation - * that would allow a debug element to change state while suspended, the debug model - * would fire a change event for that element. The valid detail codes for a - * change event are:<ul> - * <li><code>STATE</code> - indicates the state of an element has changed, but its - * children are not affected. A client would use a state change event to update - * a label of the affected element, but would not update any children.</li> - * <li><code>CONTENT</code> - indicates that a debug element's value or contents have - * changed in some way. For example, when the value of a variable is changed - * explicitly, the variable should fire a content change event.</li> - * </ul> + * The generic <code>CHANGE</code> event can be fired at any time by any + * element. Generally, a client of a debug model, such as as a UI, can get + * sufficient information to update by listening/responding to the other event + * kinds. However, if a debug model needs to inform clients of a change that is + * not specified by create/terminate/suspend/resume, the <code>CHANGE</code> + * event may be used. For example, generally, the only way a thread or any of + * its children can change state between a suspend and resume operation, is if + * the thread or owning debug target is terminated. However, if a debug model + * supports some other operation that would allow a debug element to change + * state while suspended, the debug model would fire a change event for that + * element. The valid detail codes for a change event are: * </p> * <ul> + * <li><code>STATE</code> - indicates the state of an element has changed, but + * its children are not affected. A client would use a state change event to + * update a label of the affected element, but would not update any + * children.</li> + * <li><code>CONTENT</code> - indicates that a debug element's value or contents + * have changed in some way. For example, when the value of a variable is + * changed explicitly, the variable should fire a content change event.</li> + * </ul> + * + * <ul> * <li><code>IProcess</code> - * <ul> - * <li><code>CREATE</code> - a process has been created and is executing.</li> - * <li><code>TERMINATE</code> - a process has terminated.</li> - * </ul> + * <ul> + * <li><code>CREATE</code> - a process has been created and is executing.</li> + * <li><code>TERMINATE</code> - a process has terminated.</li> + * </ul> * <li><code>IDebugTarget</code> - * <ul> - * <li><code>CREATE</code> - a debug target has been created and is ready - * to begin a debug session.</li> - * <li><code>TERMINATE</code> - a debug target has terminated and the debug - * session has ended.</li> - * <li><code>SUSPEND</code> - a debug target has suspended. Event detail provides - * the reason for the suspension:<ul> - * <li><code>STEP_END</code> - a request to step has completed</li> - * <li><code>BREAKPOINT</code> - a breakpoint has been hit</li> - * <li><code>CLIENT_REQUEST</code> - a client request has caused the target to suspend - * (i.e. an explicit call to <code>suspend()</code>)</li> - * <li><code>UNSPECIFIED</code> - the reason for the suspend is not specified</li> - * </ul> - * </li> - * <li><code>RESUME</code> - a debug target has resumed. Event detail provides - * the reason for the resume:<ul> - * <li><code>STEP_INTO</code> - a target is being resumed because of a request to step into</li> - * <li><code>STEP_OVER</code> - a target is being resumed because of a request to step over</li> - * <li><code>STEP_RETURN</code> - a target is being resumed because of a request to step return</li> - * <li><code>CLIENT_REQUEST</code> - a client request has caused the target to be resumed - * (i.e. an explicit call to <code>resume()</code>)</li> - * <li><code>UNSPECIFIED</code> - The reason for the resume is not specified</li> - * </ul> - * </li> - * </ul> + * <ul> + * <li><code>CREATE</code> - a debug target has been created and is ready to + * begin a debug session.</li> + * <li><code>TERMINATE</code> - a debug target has terminated and the debug + * session has ended.</li> + * <li><code>SUSPEND</code> - a debug target has suspended. Event detail + * provides the reason for the suspension: + * <ul> + * <li><code>STEP_END</code> - a request to step has completed</li> + * <li><code>BREAKPOINT</code> - a breakpoint has been hit</li> + * <li><code>CLIENT_REQUEST</code> - a client request has caused the target to + * suspend (i.e. an explicit call to <code>suspend()</code>)</li> + * <li><code>UNSPECIFIED</code> - the reason for the suspend is not + * specified</li> + * </ul> * </li> - * <li><code>IThread</code> - * <ul> - * <li><code>CREATE</code> - a thread has been created in a debug target.</li> - * <li><code>TERMINATE</code> - a thread has terminated.</li> - * <li><code>SUSPEND</code> - a thread has suspended execution. Event detail provides - * the reason for the suspension:<ul> - * <li><code>STEP_END</code> - a request to step has completed</li> - * <li><code>BREAKPOINT</code> - a breakpoint has been hit</li> - * <li><code>CLIENT_REQUEST</code> - a client request has caused the thread to suspend - * (i.e. an explicit call to <code>suspend()</code>)</li> - * <li><code>EVALUATION</code> - an expression evaluation has ended that may - * have had side effects in the debug target.</li> - * <li><code>EVALUATION_IMPLICIT</code> - an expression evaluation has ended that - * had no side effects in the debug target.</li> - * <li><code>UNSPECIFIED</code> - the reason for the suspend is not specified</li> - * </ul> - * </li> - * <li><code>RESUME</code> - a thread has resumed execution. Event detail provides - * the reason for the resume:<ul> - * <li><code>STEP_INTO</code> - a thread is being resumed because of a request to step into</li> - * <li><code>STEP_OVER</code> - a thread is being resumed because of a request to step over</li> - * <li><code>STEP_RETURN</code> - a thread is being resumed because of a request to step return</li> - * <li><code>CLIENT_REQUEST</code> - a client request has caused the thread to be resumed - * (i.e. an explicit call to <code>resume()</code>)</li> - * <li><code>EVALUATION</code> - an expression evaluation has started that may - * have side effects in the debug target.</li> - * <li><code>EVALUATION_IMPLICIT</code> - an expression evaluation has started that - * will have no side effects in the debug target.</li> - * <li><code>UNSPECIFIED</code> - The reason for the resume is not specified</li> - * </ul> - * </li> - * </ul> + * <li><code>RESUME</code> - a debug target has resumed. Event detail provides + * the reason for the resume: + * <ul> + * <li><code>STEP_INTO</code> - a target is being resumed because of a request + * to step into</li> + * <li><code>STEP_OVER</code> - a target is being resumed because of a request + * to step over</li> + * <li><code>STEP_RETURN</code> - a target is being resumed because of a request + * to step return</li> + * <li><code>CLIENT_REQUEST</code> - a client request has caused the target to + * be resumed (i.e. an explicit call to <code>resume()</code>)</li> + * <li><code>UNSPECIFIED</code> - The reason for the resume is not + * specified</li> + * </ul> + * </li> + * </ul> * </li> - * <li><code>IStackFrame</code> - no events are specified for stack frames. - * When a thread is suspended, it has stack frames. When a thread resumes, - * stack frames are unavailable. + * <li><code>IThread</code> + * <ul> + * <li><code>CREATE</code> - a thread has been created in a debug target.</li> + * <li><code>TERMINATE</code> - a thread has terminated.</li> + * <li><code>SUSPEND</code> - a thread has suspended execution. Event detail + * provides the reason for the suspension: + * <ul> + * <li><code>STEP_END</code> - a request to step has completed</li> + * <li><code>BREAKPOINT</code> - a breakpoint has been hit</li> + * <li><code>CLIENT_REQUEST</code> - a client request has caused the thread to + * suspend (i.e. an explicit call to <code>suspend()</code>)</li> + * <li><code>EVALUATION</code> - an expression evaluation has ended that may + * have had side effects in the debug target.</li> + * <li><code>EVALUATION_IMPLICIT</code> - an expression evaluation has ended + * that had no side effects in the debug target.</li> + * <li><code>UNSPECIFIED</code> - the reason for the suspend is not + * specified</li> + * </ul> * </li> - * <li><code>IVariable</code> - no events are specified for variables. - * When a thread is suspended, stack frames have variables. When a thread resumes, - * variables are unavailable. + * <li><code>RESUME</code> - a thread has resumed execution. Event detail + * provides the reason for the resume: + * <ul> + * <li><code>STEP_INTO</code> - a thread is being resumed because of a request + * to step into</li> + * <li><code>STEP_OVER</code> - a thread is being resumed because of a request + * to step over</li> + * <li><code>STEP_RETURN</code> - a thread is being resumed because of a request + * to step return</li> + * <li><code>CLIENT_REQUEST</code> - a client request has caused the thread to + * be resumed (i.e. an explicit call to <code>resume()</code>)</li> + * <li><code>EVALUATION</code> - an expression evaluation has started that may + * have side effects in the debug target.</li> + * <li><code>EVALUATION_IMPLICIT</code> - an expression evaluation has started + * that will have no side effects in the debug target.</li> + * <li><code>UNSPECIFIED</code> - The reason for the resume is not + * specified</li> + * </ul> * </li> - * <li><code>IValue</code> - no events are specified for values. + * </ul> * </li> + * <li><code>IStackFrame</code> - no events are specified for stack frames. When + * a thread is suspended, it has stack frames. When a thread resumes, stack + * frames are unavailable.</li> + * <li><code>IVariable</code> - no events are specified for variables. When a + * thread is suspended, stack frames have variables. When a thread resumes, + * variables are unavailable.</li> + * <li><code>IValue</code> - no events are specified for values.</li> * </ul> * */ diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointManager.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointManager.java index dccc366c4..8f99d3937 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointManager.java +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointManager.java @@ -332,8 +332,9 @@ public interface IBreakpointManager { * Revisit all the trigger points to activate/deactivate trigger points. * * @param triggerPoints list of trigger points to be deactivated or - * <code>null<code> to deactivate all trigger points - * @param enable enable if <code>true</code> or disable if <code>false</code> + * <code>null</code> to deactivate all trigger points + * @param enable enable if <code>true</code> or disable if + * <code>false</code> * @since 3.11 */ void enableTriggerPoints(IBreakpoint[] triggerPoints, boolean enable); diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointManagerListener.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointManagerListener.java index 8d2a34586..d10763248 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointManagerListener.java +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointManagerListener.java @@ -40,7 +40,7 @@ public interface IBreakpointManagerListener { * Notifies the listener that the breakpoint manager's trigger point has * changed. * - * @param triggerBreakpoint new trigger breakpoint or <code>null<code> + * @param triggerBreakpoint new trigger breakpoint or <code>null</code> * @since 3.11 */ default void breakpointManagerTriggerPointChanged(IBreakpoint triggerBreakpoint) { diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchConfiguration.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchConfiguration.java index e40503486..6c850fc68 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchConfiguration.java +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchConfiguration.java @@ -29,35 +29,33 @@ import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IProgressMonitor; /** - * A launch configuration describes how to launch an application. - * Each launch configuration is an instance of a type of launch - * configuration as described by a launch configuration type - * extension. Each launch configuration has a launch configuration - * delegate which performs the actual launching of a + * A launch configuration describes how to launch an application. Each launch + * configuration is an instance of a type of launch configuration as described + * by a launch configuration type extension. Each launch configuration has a + * launch configuration delegate which performs the actual launching of a * configuration. * <p> - * A launch configuration may be shared in a repository via - * standard VCM mechanisms, or may be stored locally, essentially - * making the launch configuration private for a single user. - * Thus, a launch configuration may stored as a file in the - * workspace (shared), or as a file in the debug plug-in's state - * location. + * A launch configuration may be shared in a repository via standard VCM + * mechanisms, or may be stored locally, essentially making the launch + * configuration private for a single user. Thus, a launch configuration may + * stored as a file in the workspace (shared), or as a file in the debug + * plug-in's state location. * </p> - * A launch configuration is a handle to its underlying storage. - * Methods annotated as "handle-only" do not require a configuration - * to exist. Methods that require an underlying configuration to exist - * throw a <code>CoreException</code> when an underlying configuration - * is missing. + * <p> + * A launch configuration is a handle to its underlying storage. Methods + * annotated as "handle-only" do not require a configuration to exist. Methods + * that require an underlying configuration to exist throw a + * <code>CoreException</code> when an underlying configuration is missing. * </p> * <p> - * A launch configuration is modified by obtaining a working copy - * of a launch configuration, modifying the working copy, and then - * saving the working copy. + * A launch configuration is modified by obtaining a working copy of a launch + * configuration, modifying the working copy, and then saving the working copy. * </p> * <p> * Clients that define a launch configuration delegate extension implement the * <code>ILaunchConfigurationDelegate</code> interface. * </p> + * * @see ILaunchConfigurationType * @see org.eclipse.debug.core.model.ILaunchConfigurationDelegate * @see ILaunchConfigurationWorkingCopy diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchConfigurationType.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchConfigurationType.java index 199bf1bcd..2b0070e4b 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchConfigurationType.java +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchConfigurationType.java @@ -24,13 +24,13 @@ import org.eclipse.debug.core.model.ILaunchConfigurationDelegate; import org.eclipse.debug.core.sourcelookup.ISourcePathComputer; /** - * Describes and creates instances of a specific type of - * launch configuration. Launch configuration types are - * defined by extensions. + * Describes and creates instances of a specific type of launch configuration. + * Launch configuration types are defined by extensions. * <p> * A launch configuration type extension is defined in <code>plugin.xml</code>. - * Following is an example definition of a launch configuration - * type extension. + * Following is an example definition of a launch configuration type extension. + * </p> + * * <pre> * <extension point="org.eclipse.debug.core.launchConfigurationTypes"> * <launchConfigurationType @@ -43,42 +43,48 @@ import org.eclipse.debug.core.sourcelookup.ISourcePathComputer; * </launchConfigurationType> * </extension> * </pre> + * * The attributes are specified as follows: * <ul> - * <li><code>id</code> specifies a unique identifier for this launch configuration - * type.</li> - * <li><code>delegate</code> specifies the fully qualified name of the java class - * that implements <code>ILaunchConfigurationDelegate</code>. Launch configuration - * instances of this type will delegate to instances of this class - * to perform launching.</li> + * <li><code>id</code> specifies a unique identifier for this launch + * configuration type.</li> + * <li><code>delegate</code> specifies the fully qualified name of the java + * class that implements <code>ILaunchConfigurationDelegate</code>. Launch + * configuration instances of this type will delegate to instances of this class + * to perform launching.</li> * <li><code>modes</code> specifies a comma separated list of the modes this - * type of launch configuration supports - <code>"run"</code> and/or <code>"debug"</code>.</li> - * <li><code>name</code> specifies a human readable name for this type - * of launch configuration.</li> + * type of launch configuration supports - <code>"run"</code> and/or + * <code>"debug"</code>.</li> + * <li><code>name</code> specifies a human readable name for this type of launch + * configuration.</li> * <li><code>category</code> is an optional attribute that specifies a category * for this launch configuration type. Categories are client defined. This * attribute was added in the 2.1 release.</li> - * <li><code>sourceLocatorId</code> an optional unique identifier of a sourceLocator extension that - * is used to create the source locator for sessions launched using launch configurations - * of this type. This attribute was added in the 3.0 release.</li> - * <li><code>sourcePathComputerId</code> an optional unique identifier of a sourcePathComputer extension - * that is used to compute a default source lookup path for launch configurations of this type. - * This attribute was added in the 3.0 release.</li> + * <li><code>sourceLocatorId</code> an optional unique identifier of a + * sourceLocator extension that is used to create the source locator for + * sessions launched using launch configurations of this type. This attribute + * was added in the 3.0 release.</li> + * <li><code>sourcePathComputerId</code> an optional unique identifier of a + * sourcePathComputer extension that is used to compute a default source lookup + * path for launch configurations of this type. This attribute was added in the + * 3.0 release.</li> * </ul> - * </p> + * * <p> - * The <code>category</code> attribute has been added in release 2.1, such that other - * tools may re-use the launch configuration framework for purposes other than - * the standard running and debugging of programs under development. Such that - * clients may access arbitrary attributes specified in launch configuration type - * extension definitions, the method <code>getAttribute</code> has also been - * added. Launch configurations that are to be recognized as standard run/debug - * launch configurations should not specify the <code>category</code> attribute. + * The <code>category</code> attribute has been added in release 2.1, such that + * other tools may re-use the launch configuration framework for purposes other + * than the standard running and debugging of programs under development. Such + * that clients may access arbitrary attributes specified in launch + * configuration type extension definitions, the method + * <code>getAttribute</code> has also been added. Launch configurations that are + * to be recognized as standard run/debug launch configurations should not + * specify the <code>category</code> attribute. * </p> * <p> * Clients that define a launch configuration delegate extension implement the * <code>ILaunchConfigurationDelegate</code> interface. * </p> + * * @see ILaunchConfiguration * @since 2.0 * @noimplement This interface is not intended to be implemented by clients. diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchMode.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchMode.java index b97da8770..5d09836ad 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchMode.java +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchMode.java @@ -14,13 +14,15 @@ package org.eclipse.debug.core; /** - * A launch mode. The debug platform contributes launch modes - * for run, debug, and profile. Clients may contribute additional launch - * modes in plug-in XML via the <code>launchModes</code> extension point. + * A launch mode. The debug platform contributes launch modes for run, debug, + * and profile. Clients may contribute additional launch modes in plug-in XML + * via the <code>launchModes</code> extension point. * <p> - * Following is an example launch mode contribution for profiling. A launch - * mode has an unique identifier specified by the <code>mode</code> attribute - * and a human readable label specified by the <code>label</code> attribute. + * Following is an example launch mode contribution for profiling. A launch mode + * has an unique identifier specified by the <code>mode</code> attribute and a + * human readable label specified by the <code>label</code> attribute. + * </p> + * * <pre> * <extension point="org.eclipse.debug.core.launchModes"> * <launchMode @@ -29,7 +31,7 @@ package org.eclipse.debug.core; * </launchMode> * </extension> * </pre> - * </p> + * * @since 3.0 * @noimplement This interface is not intended to be implemented by clients. * @noextend This interface is not intended to be extended by clients. diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/ILogicalStructureProvider.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILogicalStructureProvider.java index 47e0e829f..0526f1927 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/ILogicalStructureProvider.java +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILogicalStructureProvider.java @@ -16,10 +16,12 @@ package org.eclipse.debug.core; import org.eclipse.debug.core.model.IValue; /** - * Provides logical structure types applicable to a raw implementation value from - * a debug model. Associated with a logical structure provider extension. + * Provides logical structure types applicable to a raw implementation value + * from a debug model. Associated with a logical structure provider extension. * <p> * The following is an example of a logical structure provider extension: + * </p> + * * <pre> * <extension point="org.eclipse.debug.core.logicalStructureProviders"> * <logicalStructureProvider @@ -28,15 +30,17 @@ import org.eclipse.debug.core.model.IValue; * </logicalStructureProvider> * </extension> * </pre> - * </p> - * In the example above, the specified logical structure provider will be consulted for - * alternative logical structures for values from the <code>com.example.debug.model</code> - * debug model as they are displayed in the variables view. + * <p> + * In the example above, the specified logical structure provider will be + * consulted for alternative logical structures for values from the + * <code>com.example.debug.model</code> debug model as they are displayed in the + * variables view. * </p> * <p> * Clients contributing logical structure providers must implement this * interface. * </p> + * * @since 3.1 * @see org.eclipse.debug.core.ILogicalStructureType */ diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/ILogicalStructureType.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILogicalStructureType.java index c6f4b3153..ff45b549e 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/ILogicalStructureType.java +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILogicalStructureType.java @@ -17,14 +17,16 @@ import org.eclipse.debug.core.model.ILogicalStructureTypeDelegate; import org.eclipse.debug.core.model.ILogicalStructureTypeDelegate2; /** - * Provides a value representing the logical structure of a raw implementation value - * from a debug model. Logical structures are useful for navigating complex data - * structures. Logical structure types are contributed via extensions in plug-in XML, - * and provide a delegate for performing logical value computation. Logical - * structure types can be retrieved from the <code>DebugPlugin</code>. + * Provides a value representing the logical structure of a raw implementation + * value from a debug model. Logical structures are useful for navigating + * complex data structures. Logical structure types are contributed via + * extensions in plug-in XML, and provide a delegate for performing logical + * value computation. Logical structure types can be retrieved from the + * <code>DebugPlugin</code>. * <p> * Following is example plug-in XML to define a logical structure type. * </p> + * * <pre> * <extension point="org.eclipse.debug.core.logicalStructureTypes"> * <logicalStructureType @@ -37,23 +39,25 @@ import org.eclipse.debug.core.model.ILogicalStructureTypeDelegate2; * </pre> * <p> * The attributes are specified as follows: + * </p> * <ul> * <li>id - unique identifier for this logical structure type</li> * <li>class - fully qualified name of class that implements - * <code>ILogicalStructureTypeDelegate</code></li> + * <code>ILogicalStructureTypeDelegate</code></li> * <li>modelIdentifier - identifier of the debug model this logical structure - * type is associated with</li> + * type is associated with</li> * <li>description - description of the logical structure provided</li> * </ul> - * </p> * <p> - * Clients contributing logicalStructureType extensions are not intended to implement - * this interface. Rather, they provide an <code>ILogicalStructureTypeDelegate</code> - * that optionally implements <code>ILogicalStructureTypeDelegate2</code> to provide - * dynamic descriptions of logical structures. - * Since 3.1, clients contributing logicalStructureProviders extensions may implement this - * interface to return a collection of logical structure types applicable to a value. + * Clients contributing logicalStructureType extensions are not intended to + * implement this interface. Rather, they provide an + * <code>ILogicalStructureTypeDelegate</code> that optionally implements + * <code>ILogicalStructureTypeDelegate2</code> to provide dynamic descriptions + * of logical structures. Since 3.1, clients contributing + * logicalStructureProviders extensions may implement this interface to return a + * collection of logical structure types applicable to a value. * </p> + * * @since 3.0 * @see org.eclipse.debug.core.model.ILogicalStructureTypeDelegate * @see org.eclipse.debug.core.ILogicalStructureProvider diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/IProcessFactory.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/IProcessFactory.java index 553c41cca..468b8ca17 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/IProcessFactory.java +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/IProcessFactory.java @@ -21,13 +21,15 @@ import org.eclipse.debug.core.model.IProcess; * A process factory is used to override default process (<code>IProcess</code>) * creation by the debug plug-in, and can be contributed via plug-in XML. When a * new process is created via <code>DebugPlugin.newProcess(..)</code>, the - * launch configuration associated with the specified launch is consulted for - * a process factory attribute (<code>DebugPlugin.ATTR_PROCESS_FACTORY_ID</code>). If - * present, the associated process factory is consulted to create a process for - * the launch. If not present a default process implementation is created and - * returned by the debug plug-in. + * launch configuration associated with the specified launch is consulted for a + * process factory attribute (<code>DebugPlugin.ATTR_PROCESS_FACTORY_ID</code>). + * If present, the associated process factory is consulted to create a process + * for the launch. If not present a default process implementation is created + * and returned by the debug plug-in. * <p> * Following is example plug-in XML that contributes a process factory. + * </p> + * * <pre> * <extension point="org.eclipse.debug.core.processFactories"> * <processFactory @@ -36,16 +38,18 @@ import org.eclipse.debug.core.model.IProcess; * </processFactory> * </extension> * </pre> + * * The attributes are specified as follows: * <ul> * <li>id - a unique identifier for this extension point</li> * <li>class - the fully qualified name of a class the implements - * <code>IProcessFactory</code></li> + * <code>IProcessFactory</code></li> * </ul> - * </p> * <p> - * Clients contributing a process factory are intended to implement this interface. + * Clients contributing a process factory are intended to implement this + * interface. * </p> + * * @since 3.0 */ diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/IStatusHandler.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/IStatusHandler.java index 601496a27..b955afa00 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/IStatusHandler.java +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/IStatusHandler.java @@ -18,24 +18,25 @@ import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IStatus; /** - * A status handler registers to handle a specific status - error - * or otherwise. Provides a mechanism for separating core (headless) - * function from UI interaction. The debug plug-in provides a - * status handlers extension point, against which handlers can - * register for specific status codes - identified by plug-in - * identifier and plug-in specific status code. The interaction between - * an object requiring a status handler (source), and the status handler - * is defined by the source and handler. + * A status handler registers to handle a specific status - error or otherwise. + * Provides a mechanism for separating core (headless) function from UI + * interaction. The debug plug-in provides a status handlers extension point, + * against which handlers can register for specific status codes - identified by + * plug-in identifier and plug-in specific status code. The interaction between + * an object requiring a status handler (source), and the status handler is + * defined by the source and handler. * <p> - * For example, a launch configuration delegate might encounter a timeout - * while launching an application. In this case the delegate could abort - * or, via the use of a status handler, prompt the user to continue. This - * allows the launcher to be implemented in a plug-in that does not require - * UI support, and allows another (UI) plug-in to register a handler. + * For example, a launch configuration delegate might encounter a timeout while + * launching an application. In this case the delegate could abort or, via the + * use of a status handler, prompt the user to continue. This allows the + * launcher to be implemented in a plug-in that does not require UI support, and + * allows another (UI) plug-in to register a handler. * </p> * <p> - * A status handler extension is defined in <code>plugin.xml</code>. - * Following is an example definition of a status handler extension. + * A status handler extension is defined in <code>plugin.xml</code>. Following + * is an example definition of a status handler extension. + * </p> + * * <pre> * <extension point="org.eclipse.debug.core.statusHandlers"> * <statusHandler @@ -46,21 +47,23 @@ import org.eclipse.core.runtime.IStatus; * </statusHandler> * </extension> * </pre> + * * The attributes are specified as follows: * <ul> - * <li><code>id</code> specifies a unique identifier for this status handler.</li> + * <li><code>id</code> specifies a unique identifier for this status + * handler.</li> * <li><code>class</code> specifies the fully qualified name of the Java class - * that implements <code>IStatusHandler</code>.</li> - * <li><code>plugin</code> plug-in identifier that corresponds to the - * plug-in of the status this handler is registered for (i.e. - * <code>IStatus.getPlugin()</code>).</li> - * <li><code>code</code> specifies the status code this handler - * is registered for.</li> + * that implements <code>IStatusHandler</code>.</li> + * <li><code>plugin</code> plug-in identifier that corresponds to the plug-in of + * the status this handler is registered for (i.e. + * <code>IStatus.getPlugin()</code>).</li> + * <li><code>code</code> specifies the status code this handler is registered + * for.</li> * </ul> - * </p> * <p> * Clients may implement this interface. * </p> + * * @see DebugPlugin#getStatusHandler(IStatus) * @since 2.0 */ diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IBreakpointImportParticipant.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IBreakpointImportParticipant.java index 5bf3e818c..a986fc6fb 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IBreakpointImportParticipant.java +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IBreakpointImportParticipant.java @@ -21,24 +21,26 @@ import org.eclipse.debug.core.IBreakpointManager; /** * This interface defines a breakpoint import participant. * <p> - * Participants are used during a breakpoint import operation - * to specify how breakpoints of the associated marker type should be compared - * and how the breakpoint should be validated once it is decided it will be imported. + * Participants are used during a breakpoint import operation to specify how + * breakpoints of the associated marker type should be compared and how the + * breakpoint should be validated once it is decided it will be imported. * </p> * <p> * A breakpoint import participant it contributed via the - * <code>org.eclipse.debug.core.breakpointImportParticipants</code> extension point. + * <code>org.eclipse.debug.core.breakpointImportParticipants</code> extension + * point. * </p> * <p> * Following is an example of a breakpoint participant extension: * </p> + * * <pre> - * <extension point="org.eclipse.debug.core.breakpointImportParticipants"> - * <importParticipant + * <extension point="org.eclipse.debug.core.breakpointImportParticipants"> + * <importParticipant * participant="x.y.z.BreakpointImportParticipant" - * type="org.eclipse.jdt.debug.javaLineBreakpointMarker"> - * </importParticipant> - * </extension> + * type="org.eclipse.jdt.debug.javaLineBreakpointMarker"> + * </importParticipant> + * </extension> * </pre> * <p> * Clients may implement this interface. diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IPersistableSourceLocator.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IPersistableSourceLocator.java index 7c36c7c2c..c2bd3ea89 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IPersistableSourceLocator.java +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IPersistableSourceLocator.java @@ -18,13 +18,14 @@ import org.eclipse.core.runtime.CoreException; import org.eclipse.debug.core.ILaunchConfiguration; /** - * A source locator that can be persisted and restored, - * to be used with a specific launch configuration. - * The debug plug-in defines a source locator extension - * point for persistable source locators. + * A source locator that can be persisted and restored, to be used with a + * specific launch configuration. The debug plug-in defines a source locator + * extension point for persistable source locators. * <p> - * A source locator extension is defined in <code>plugin.xml</code>. - * Following is an example definition of a source locator extension. + * A source locator extension is defined in <code>plugin.xml</code>. Following + * is an example definition of a source locator extension. + * </p> + * * <pre> * <extension point="org.eclipse.debug.core.sourceLocators"> * <sourceLocator @@ -34,18 +35,20 @@ import org.eclipse.debug.core.ILaunchConfiguration; * </sourceLocator> * </extension> * </pre> + * * The attributes are specified as follows: * <ul> - * <li><code>id</code> specifies a unique identifier for this source locator.</li> + * <li><code>id</code> specifies a unique identifier for this source + * locator.</li> * <li><code>class</code> specifies the fully qualified name of the Java class - * that implements <code>IPersistableSourceLocator</code>.</li> - * <li><code>name</code> a human readable name, describing the type of - * this source locator.</li> + * that implements <code>IPersistableSourceLocator</code>.</li> + * <li><code>name</code> a human readable name, describing the type of this + * source locator.</li> * </ul> - * </p> * <p> * Clients may implement this interface. * </p> + * * @see org.eclipse.debug.core.ILaunch * @see IStackFrame * @since 2.0 diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStepFilter.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStepFilter.java index 1fb05fb3d..4183815f5 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStepFilter.java +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStepFilter.java @@ -16,6 +16,7 @@ package org.eclipse.debug.core.model; * * <p> * The following is an example of a step filter extension: + * </p> * * <pre> * <extension point="org.eclipse.debug.core.stepFilters"> @@ -25,10 +26,10 @@ package org.eclipse.debug.core.model; * </stepFilters> * </extension> * </pre> - * - * </p> + * <p> * In the example above, the specified step filter will be used for the - * <code>com.example.debug.model</code> debug model. </p> + * <code>com.example.debug.model</code> debug model. + * </p> * * <p> * Clients contributing step filters must implement this interface. diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/package.html b/org.eclipse.debug.core/core/org/eclipse/debug/core/package.html index 069ad320f..34937cab9 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/package.html +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/package.html @@ -44,7 +44,6 @@ and debug events.</p> Expressions are not automatically persisted, but a client could persist its own expressions if required.</li> </ul> -<p></p> <h4>Launch Configurations</h4> diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/sourcelookup/ISourceContainerType.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/sourcelookup/ISourceContainerType.java index a81c864ef..49053aad3 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/sourcelookup/ISourceContainerType.java +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/sourcelookup/ISourceContainerType.java @@ -16,14 +16,17 @@ package org.eclipse.debug.core.sourcelookup; /** - * A source container type represents a kind of container of source code. - * For example, a source container type may be a project or a directory. A specific - * project or directory is represented by an instance of a source container type, - * which is called a source container (<code>ISourceContainer</code>). + * A source container type represents a kind of container of source code. For + * example, a source container type may be a project or a directory. A specific + * project or directory is represented by an instance of a source container + * type, which is called a source container (<code>ISourceContainer</code>). * <p> - * A source container type is contributed via the <code>sourceContainerTypes</code> - * extension point, providing a delegate to the work specific to the contributed - * type. Following is an example contribution. + * A source container type is contributed via the + * <code>sourceContainerTypes</code> extension point, providing a delegate to + * the work specific to the contributed type. Following is an example + * contribution. + * </p> + * * <pre> * <extension point="org.eclipse.debug.core.sourceContainerTypes"> * <sourceContainerType @@ -34,11 +37,11 @@ package org.eclipse.debug.core.sourcelookup; * </sourceContainerType> * </extension> * </pre> - * </p> * <p> * Clients contributing a source container type implement * {@link org.eclipse.debug.core.sourcelookup.ISourceContainerTypeDelegate}. * </p> + * * @see org.eclipse.debug.core.sourcelookup.ISourceContainer * @see org.eclipse.debug.core.sourcelookup.ISourceContainerTypeDelegate * @since 3.0 diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/sourcelookup/ISourcePathComputer.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/sourcelookup/ISourcePathComputer.java index 6577880de..357b96217 100644 --- a/org.eclipse.debug.core/core/org/eclipse/debug/core/sourcelookup/ISourcePathComputer.java +++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/sourcelookup/ISourcePathComputer.java @@ -20,9 +20,11 @@ import org.eclipse.debug.core.DebugPlugin; * containers that should be considered) for a launch configuration. * <p> * A source path computer is contributed in plug-in XML via the - * <code>sourcePathComputers</code> extension point, that provides a delegate - * to compute the path specific to a launch configuration. Following - * is an example contribution. + * <code>sourcePathComputers</code> extension point, that provides a delegate to + * compute the path specific to a launch configuration. Following is an example + * contribution. + * </p> + * * <pre> * <extension point="org.eclipse.debug.core.sourcePathComputers"> * <sourcePathComputer @@ -31,18 +33,18 @@ import org.eclipse.debug.core.DebugPlugin; * </sourcePathComputer> * </extension> * </pre> - * </p> * <p> - * A source path computer can be associated with a launch configuration type - * via the <code>sourcePathComputerId</code> attribute of a launch configuration - * type extension. As well, a launch configuration can specify its own - * source path computer to use via the <code>ATTR_SOURCE_PATH_COMPUTER_ID</code> + * A source path computer can be associated with a launch configuration type via + * the <code>sourcePathComputerId</code> attribute of a launch configuration + * type extension. As well, a launch configuration can specify its own source + * path computer to use via the <code>ATTR_SOURCE_PATH_COMPUTER_ID</code> * attribute. * </p> * <p> * Clients contributing a source path computer provide an implementation of * {@link org.eclipse.debug.core.sourcelookup.ISourcePathComputerDelegate}. * </p> + * * @since 3.0 * @noimplement This interface is not intended to be implemented by clients. * @noextend This interface is not intended to be extended by clients. diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IBreakpointOrganizerDelegate.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IBreakpointOrganizerDelegate.java index 30b25297b..81679e6a5 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IBreakpointOrganizerDelegate.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IBreakpointOrganizerDelegate.java @@ -19,16 +19,18 @@ import org.eclipse.debug.internal.ui.DebugUIPlugin; import org.eclipse.jface.util.IPropertyChangeListener; /** - * A breakpoint organizer is used to categorize breakpoints and provides - * change notification when categorization has changed. Categories are represented - * as arbitrary adaptable objects. For example, projects could be used to - * categorize breakpoints. Images and labels for categories are generated - * via workbench adapters. + * A breakpoint organizer is used to categorize breakpoints and provides change + * notification when categorization has changed. Categories are represented as + * arbitrary adaptable objects. For example, projects could be used to + * categorize breakpoints. Images and labels for categories are generated via + * workbench adapters. * <p> * Organizers may optionally support breakpoint recategorization. * </p> * <p> * Following is example plug-in XML for contributing a breakpoint organizer. + * </p> + * * <pre> * <extension point="org.eclipse.debug.ui.breakpointOrganizers"> * <breakpointOrganizer @@ -38,6 +40,7 @@ import org.eclipse.jface.util.IPropertyChangeListener; * icon="icons/full/obj16/example_org.png"/> * </extension> * </pre> + * * The attributes are specified as follows: * <ul> * <li><code>class</code> Fully qualified name of a Java class that implements @@ -48,11 +51,11 @@ import org.eclipse.jface.util.IPropertyChangeListener; * <li><code>icon</code> Optional path to an icon which can be shown for this * organizer</li> * </ul> - * </p> * <p> - * Clients contributing a breakpoint organizer are intended to implement - * this interface. + * Clients contributing a breakpoint organizer are intended to implement this + * interface. * </p> + * * @since 3.1 */ public interface IBreakpointOrganizerDelegate { diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IDebugModelPresentation.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IDebugModelPresentation.java index d42da9e52..072cb2981 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IDebugModelPresentation.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IDebugModelPresentation.java @@ -19,16 +19,18 @@ import org.eclipse.jface.viewers.ILabelProvider; import org.eclipse.swt.graphics.Image; /** - * A debug model presentation is responsible for providing labels, images, - * and editors associated with debug elements in a specific debug model. - * Extensions of type <code>org.eclipse.debug.ui.debugModelPresentations</code> implement + * A debug model presentation is responsible for providing labels, images, and + * editors associated with debug elements in a specific debug model. Extensions + * of type <code>org.eclipse.debug.ui.debugModelPresentations</code> implement * this interface. Generally, a debug model implementation will also provide a - * debug model presentation extension to render and display its elements. A debug - * model presentation is registered for a specific debug model, and is responsible - * for the presentation elements defined/implemented by that model. + * debug model presentation extension to render and display its elements. A + * debug model presentation is registered for a specific debug model, and is + * responsible for the presentation elements defined/implemented by that model. * <p> * A debug model presentation extension is defined in <code>plugin.xml</code>. * Following is an example definition of a debug model presentation extension. + * </p> + * * <pre> * <extension point="org.eclipse.debug.ui.debugModelPresentations"> * <debugModelPresentation @@ -38,48 +40,53 @@ import org.eclipse.swt.graphics.Image; * </debugModelPresentation> * </extension> * </pre> + * * The attributes are specified as follows: * <ul> - * <li><code>id</code> specifies the identifier of the debug model this presentation - * is responsible for. Corresponds to the model identifier returned from a debug - * element - see <code>IDebugElement.getModelIndentifier</code></li> + * <li><code>id</code> specifies the identifier of the debug model this + * presentation is responsible for. Corresponds to the model identifier returned + * from a debug element - see + * <code>IDebugElement.getModelIndentifier</code></li> * <li><code>class</code> specifies the fully qualified name of the Java class - * that implements this interface.</li> - * <li><code>detailsViewerConfiguration</code> optionally specifies the fully qualified name of the Java class - * that is an instance of <code>org.eclipse.jface.text.source.SourceViewerConfiguration</code>. - * When specified, the source viewer configuration will be used in the "details" area of the - * variables and expressions view when displaying the details of an element from the - * debug model associated with this debug model presentation. When unspecified, - * a default configuration is used.</li> + * that implements this interface.</li> + * <li><code>detailsViewerConfiguration</code> optionally specifies the fully + * qualified name of the Java class that is an instance of + * <code>org.eclipse.jface.text.source.SourceViewerConfiguration</code>. When + * specified, the source viewer configuration will be used in the "details" area + * of the variables and expressions view when displaying the details of an + * element from the debug model associated with this debug model presentation. + * When unspecified, a default configuration is used.</li> * </ul> - * </p> * <p> - * To allow for an extensible configuration, this interface defines - * a <code>setAttribute</code> method. The debug UI plug-in defines - * one presentation attribute: + * To allow for an extensible configuration, this interface defines a + * <code>setAttribute</code> method. The debug UI plug-in defines one + * presentation attribute: * <ul> - * <li><code>DISPLAY_VARIABLE_TYPE_NAMES</code> - This is a boolean attribute - * indicating whether variable elements should be rendered with the declared - * type of a variable. For example, a Java debug model presentation would render - * an integer as <code>"int x = 3"</code> when true, and <code>"x = 3"</code> - * when false.</li> + * <li><code>DISPLAY_VARIABLE_TYPE_NAMES</code> - This is a boolean attribute + * indicating whether variable elements should be rendered with the declared + * type of a variable. For example, a Java debug model presentation would render + * an integer as <code>"int x = 3"</code> when true, and <code>"x = 3"</code> + * when false.</li> * </ul> - * </p> + * * <p> - * Clients may define new presentation attributes. For example, a client may wish - * to define a "hexadecimal" property to display numeric values in hexadecimal. Implementations - * should honor the presentation attributes defined by this interface where possible, - * but do not need to honor presentation attributes defined by other clients. - * To access the debug model presentation for a debug view, clients should use + * Clients may define new presentation attributes. For example, a client may + * wish to define a "hexadecimal" property to display numeric values in + * hexadecimal. Implementations should honor the presentation attributes defined + * by this interface where possible, but do not need to honor presentation + * attributes defined by other clients. To access the debug model presentation + * for a debug view, clients should use * <code>IDebugView#getPresentation(String)</code>. * </p> * <p> - * Since 3.1, debug model presentations may optionally implement <code>IColorProvider</code> - * and <code>IFontProvider</code> to override default fonts and colors for debug elements. + * Since 3.1, debug model presentations may optionally implement + * <code>IColorProvider</code> and <code>IFontProvider</code> to override + * default fonts and colors for debug elements. * </p> * <p> * Clients may implement this interface. * </p> + * * @see org.eclipse.debug.core.model.IDebugElement * @see org.eclipse.jface.viewers.ILabelProvider * @see org.eclipse.debug.ui.IDebugView diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IDetailPaneFactory.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IDetailPaneFactory.java index 935690734..0d2ebf204 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IDetailPaneFactory.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IDetailPaneFactory.java @@ -20,8 +20,11 @@ import org.eclipse.jface.viewers.IStructuredSelection; /** * A detail pane factory creates one or more types of detail panes. * <p> - * Detail pane factories are contributed via the <code>org.eclipse.debug.ui.detailPaneFactories</code> - * extension point. Following is an example of a detail pane factory extension: + * Detail pane factories are contributed via the + * <code>org.eclipse.debug.ui.detailPaneFactories</code> extension point. + * Following is an example of a detail pane factory extension: + * </p> + * * <pre> * <extension point="org.eclipse.debug.ui.detailPaneFactories"> * <detailFactories @@ -30,10 +33,10 @@ import org.eclipse.jface.viewers.IStructuredSelection; * </detailFactories> * </extension> * </pre> - * </p> - * <p> - * <p> - * Clients contributing a detail pane factory are intended to implement this interface. + * + * Clients contributing a detail pane factory are intended to implement this + * interface. + * * @see IDetailPane * @since 3.3 * diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IInstructionPointerPresentation.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IInstructionPointerPresentation.java index 0f1888d79..4db95a9ce 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IInstructionPointerPresentation.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/IInstructionPointerPresentation.java @@ -19,42 +19,49 @@ import org.eclipse.swt.graphics.Image; import org.eclipse.ui.IEditorPart; /** - * A debug model presentation may implement this interface to override - * standard annotations used to display instruction pointers for stack frames. + * A debug model presentation may implement this interface to override standard + * annotations used to display instruction pointers for stack frames. * <p> * A client has several options when overriding default instruction pointer - * annotations, and the debug platform uses the following prioritized order - * when computing an annotation for a stack frame. + * annotations, and the debug platform uses the following prioritized order when + * computing an annotation for a stack frame. + * </p> * <ol> - * <li>Specify the annotation object to use. This is done by returning a non-<code>null</code> - * value from <code>getInstructionPointerAnnotation(..)</code>.</li> - * <li>Specify an <code>annotationType</code> extension to use. - * This is done by returning a non-<code>null</code> value from - * <code>getInstructionPointerAnnotationType(..)</code>. When specified, the annotation - * type controls the image displayed via its associated - * <code>markerAnnotationSpecification</code>.</li> - * <li>Specify the image to use. This is done by returning a non-<code>null</code> - * value from <code>getInstructionPointerImage(..)</code>.</li> + * <li>Specify the annotation object to use. This is done by returning a + * non-<code>null</code> value from + * <code>getInstructionPointerAnnotation(..)</code>.</li> + * <li>Specify an <code>annotationType</code> extension to use. This is done by + * returning a non-<code>null</code> value from + * <code>getInstructionPointerAnnotationType(..)</code>. When specified, the + * annotation type controls the image displayed via its associated + * <code>markerAnnotationSpecification</code>.</li> + * <li>Specify the image to use. This is done by returning a + * non-<code>null</code> value from + * <code>getInstructionPointerImage(..)</code>.</li> * </ol> - * Additionally, when specifying an annotation type or image the text - * for the instruction pointer may be specified by returning a non-<code>null</code> + * <p> + * Additionally, when specifying an annotation type or image the text for the + * instruction pointer may be specified by returning a non-<code>null</code> * value from <code>getInstructionPointerText(..)</code>. * </p> * <p> * These methods are called when the debugger has opened an editor to display - * source for the given stack frame. The image will be positioned based on stack frame - * line number and character ranges. + * source for the given stack frame. The image will be positioned based on stack + * frame line number and character ranges. * </p> * <p> * By default, the debug platform uses different annotations for top stack * frames and non-top stack frames in a thread. The default platform annotations - * are contributed as <code>annotationType</code> extensions with - * the identifiers <code>IDebugUIConstants.ANNOTATION_INSTRUCTION_POINTER_CURRENT</code> - * and <code>IDebugUIConstants.ANNOTAION_INSTRUCTION_POINTER_SECONDARY</code>. + * are contributed as <code>annotationType</code> extensions with the + * identifiers + * <code>IDebugUIConstants.ANNOTATION_INSTRUCTION_POINTER_CURRENT</code> and + * <code>IDebugUIConstants.ANNOTAION_INSTRUCTION_POINTER_SECONDARY</code>. * </p> * <p> - * Clients implementing a debug model presentation may also implement this interface. + * Clients implementing a debug model presentation may also implement this + * interface. * </p> + * * @since 3.2 */ public interface IInstructionPointerPresentation extends IDebugModelPresentation { diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ILaunchConfigurationTabGroup.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ILaunchConfigurationTabGroup.java index 7deb97411..1de9f4bbf 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ILaunchConfigurationTabGroup.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ILaunchConfigurationTabGroup.java @@ -19,44 +19,46 @@ import org.eclipse.debug.core.ILaunchConfiguration; import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; /** - * A launch configuration tab group is used to edit/view attributes - * of a specific type of launch configuration. Launch - * configurations are presented in a dialog, with a tab folder. - * Each tab manipulates one or more attributes of a launch - * configuration. The tab group controls which tabs are - * displayed for a specific type of launch configuration, - * and provides a mechanism for overriding configuration - * initialization performed by tabs. + * A launch configuration tab group is used to edit/view attributes of a + * specific type of launch configuration. Launch configurations are presented in + * a dialog, with a tab folder. Each tab manipulates one or more attributes of a + * launch configuration. The tab group controls which tabs are displayed for a + * specific type of launch configuration, and provides a mechanism for + * overriding configuration initialization performed by tabs. * <p> * A tab group has the following lifecycle methods: + * </p> * <ul> - * <li><code>createTabs(ILaunchConfigurationDialog, String)</code> - - * this is the first method called on a tab group after it is instantiated.</li> - * <li><code>initializeFrom(ILaunchConfiguration)</code> - called when a - * launch configuration is selected to be displayed.</li> + * <li><code>createTabs(ILaunchConfigurationDialog, String)</code> - this is the + * first method called on a tab group after it is instantiated.</li> + * <li><code>initializeFrom(ILaunchConfiguration)</code> - called when a launch + * configuration is selected to be displayed.</li> * <li><code>performApply(ILaunchConfigurationWorkingCopy)</code> - called when - * a tab group's values are to be written to a launch configuration.</li> - * <li><code>dispose()</code> - the last method called on a tab group, when it is - * to perform any required cleanup. Note that a tab can be disposed before its control - * has been created.</li> + * a tab group's values are to be written to a launch configuration.</li> + * <li><code>dispose()</code> - the last method called on a tab group, when it + * is to perform any required cleanup. Note that a tab can be disposed before + * its control has been created.</li> * </ul> - * The method <code>setDefaults(ILaunchConfigurationWorkingCopy)</code> - * can be called before a tab's controls are created. + * <p> + * The method <code>setDefaults(ILaunchConfigurationWorkingCopy)</code> can be + * called before a tab's controls are created. * </p> * <p> * The launch tab framework was originally designed to handle inter tab - * communication by applying attributes from the active tab to a launch configuration - * being edited, when a tab is exited, and by initializing a tab when activated. - * In 3.0, the addition of the methods <code>activated</code> and <code>deactivated</code> - * allow tabs to determine the appropriate course of action. The default implementation - * in <code>AbstractLaunchConfigurationTab</code> is to call the old methods - * (<code>initializeFrom</code> and <code>performApply</code>). Tabs should override - * the new methods as required. + * communication by applying attributes from the active tab to a launch + * configuration being edited, when a tab is exited, and by initializing a tab + * when activated. In 3.0, the addition of the methods <code>activated</code> + * and <code>deactivated</code> allow tabs to determine the appropriate course + * of action. The default implementation in + * <code>AbstractLaunchConfigurationTab</code> is to call the old methods + * (<code>initializeFrom</code> and <code>performApply</code>). Tabs should + * override the new methods as required. * </p> * <p> * A launch configuration group extension is defined in <code>plugin.xml</code>. - * Following is an example definition of a launch configuration - * group extension. + * Following is an example definition of a launch configuration group extension. + * </p> + * * <pre> * <extension point="org.eclipse.debug.ui.launchConfigurationTabGroups"> * <launchConfigurationTabGroup @@ -66,20 +68,21 @@ import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; * </launchConfigurationTabGroup> * </extension> * </pre> + * * The attributes are specified as follows: * <ul> - * <li><code>id</code> specifies a unique identifier for this launch configuration - * tab group.</li> - * <li><code>type</code> specifies launch configuration type that this tab - * group is applicable to (corresponds to the id of a launch configuration type - * extension).</li> - * <li><code>class</code> specifies a fully qualified name of a Java class - * that implements <code>ILaunchConfigurationTabGroup</code>.</li> + * <li><code>id</code> specifies a unique identifier for this launch + * configuration tab group.</li> + * <li><code>type</code> specifies launch configuration type that this tab group + * is applicable to (corresponds to the id of a launch configuration type + * extension).</li> + * <li><code>class</code> specifies a fully qualified name of a Java class that + * implements <code>ILaunchConfigurationTabGroup</code>.</li> * </ul> - * </p> * <p> * This interface is intended to be implemented by clients. * </p> + * * @see org.eclipse.debug.core.ILaunchConfigurationType * @see org.eclipse.debug.core.ILaunchConfiguration * @see org.eclipse.debug.ui.ILaunchConfigurationTab diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ILaunchGroup.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ILaunchGroup.java index 9dc2d4ef1..ca208a779 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ILaunchGroup.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ILaunchGroup.java @@ -16,13 +16,14 @@ package org.eclipse.debug.ui; import org.eclipse.jface.resource.ImageDescriptor; /** - * A launch group identifies a group of launch configurations by a launch - * mode and category. The launch configuration dialog can be opened on - * a launch group, and a launch history is maintained for each group. - * A launch group is defined in plug-in XML via the <code>launchGroups</code> - * extension point. + * A launch group identifies a group of launch configurations by a launch mode + * and category. The launch configuration dialog can be opened on a launch + * group, and a launch history is maintained for each group. A launch group is + * defined in plug-in XML via the <code>launchGroups</code> extension point. * <p> * Following is an example of a launch group contribution: + * </p> + * * <pre> * <extension point="org.eclipse.debug.ui.launchGroups"> * <launchGroup @@ -33,16 +34,16 @@ import org.eclipse.jface.resource.ImageDescriptor; * </launchGroup> * </extension> * </pre> - * </p> * <p> * The debug platform defines constants for the identifiers of the launch groups * provided by the debug platform: + * </p> * <ul> * <li>IDebugUIConstants.ID_DEBUG_LAUNCH_GROUP</li> * <li>IDebugUIConstants.ID_RUN_LAUNCH_GROUP</li> * <li>IDebugUIConstants.ID_PROFILE_LAUNCH_GROUP</li> * </ul> - * </p> + * * @since 3.0 * @noimplement This interface is not intended to be implemented by clients. * @noextend This interface is not intended to be extended by clients. diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ILaunchShortcut.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ILaunchShortcut.java index b96dba546..c3adfdcf9 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ILaunchShortcut.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ILaunchShortcut.java @@ -18,22 +18,21 @@ import org.eclipse.jface.viewers.ISelection; import org.eclipse.ui.IEditorPart; /** - * A launch shortcut is capable of launching a selection - * or active editor in the workbench. The delegate is responsible for - * interpreting the selection or active editor (if it applies), and launching - * an application. This may require creating a new launch configuration - * with default values, or re-using an existing launch configuration. + * A launch shortcut is capable of launching a selection or active editor in the + * workbench. The delegate is responsible for interpreting the selection or + * active editor (if it applies), and launching an application. This may require + * creating a new launch configuration with default values, or re-using an + * existing launch configuration. * <p> - * A launch shortcut is defined as an extension - * of type <code>org.eclipse.debug.ui.launchShortcuts</code>. - * A shortcut specifies the perspectives in which is should be available - * from the "Run/Debug" cascade menus. + * A launch shortcut is defined as an extension of type + * <code>org.eclipse.debug.ui.launchShortcuts</code>. A shortcut specifies the + * perspectives in which is should be available from the "Run/Debug" cascade + * menus. * </p> * <p> - * A launch shortcut extension is defined in <code>plugin.xml</code>. - * Following is an example definition of a launch shortcut extension. + * A launch shortcut extension is defined in <code>plugin.xml</code>. Following + * is an example definition of a launch shortcut extension. * </p> - * <br> * <pre> * <extension point="org.eclipse.debug.ui.launchShortcuts"> * <shortcut @@ -78,50 +77,61 @@ import org.eclipse.ui.IEditorPart; * </shortcut> * </extension> * </pre> - * <br> * <p> * The attributes are specified as follows: + * </p> * <ul> - * <li><code>id</code> specifies a unique identifier for this launch shortcut.</li> - * <li><code>modes</code> specifies a comma separated list of modes this shortcut - * supports.</li> - * <li><code>class</code> specifies a fully qualified name of a Java class - * that implements <code>ILaunchShortcut</code>.</li> + * <li><code>id</code> specifies a unique identifier for this launch + * shortcut.</li> + * <li><code>modes</code> specifies a comma separated list of modes this + * shortcut supports.</li> + * <li><code>class</code> specifies a fully qualified name of a Java class that + * implements <code>ILaunchShortcut</code>.</li> * <li><code>label</code> specifies a label used to render this shortcut.</li> * <li><code>icon</code> specifies a plug-in relative path to an icon used to - * render this shortcut.</li> - * <li><code>category</code> specifies the launch configuration type category this shortcut is applicable for. - * When unspecified, the category is <code>null</code> (default).</li> - * <li><code>path</code> an optional menu path used to group launch shortcuts in menus. - * Launch shortcuts are grouped alphabetically based on the <code>path</code> attribute, - * and then sorted alphabetically within groups based on the <code>label</code> attribute. - * When unspecified, a shortcut appears in the last group. This attribute was added in the 3.0.1 release.</li> + * render this shortcut.</li> + * <li><code>category</code> specifies the launch configuration type category + * this shortcut is applicable for. When unspecified, the category is + * <code>null</code> (default).</li> + * <li><code>path</code> an optional menu path used to group launch shortcuts in + * menus. Launch shortcuts are grouped alphabetically based on the + * <code>path</code> attribute, and then sorted alphabetically within groups + * based on the <code>label</code> attribute. When unspecified, a shortcut + * appears in the last group. This attribute was added in the 3.0.1 + * release.</li> * <li><code>helpContextId</code> optional attribute specifying the help context * identifier to associate with the launch shortcut action in a menu.</li> - * <li><code>description</code> Provides a human readable description of what the shortcut does (or will do) - * if the user selects it. A Description provided in this field will apply as the default description for all - * of the modes listed in the modes attribute.</li> + * <li><code>description</code> Provides a human readable description of what + * the shortcut does (or will do) if the user selects it. A Description provided + * in this field will apply as the default description for all of the modes + * listed in the modes attribute.</li> * <li><code>perspective</code> has been <b>deprecated</b> in the 3.1 release. - * The top level Run/Debug/Profile cascade menus now support contextual (selection sensitive) - * launching, and clients should provide a <code>contextualLaunch</code> element instead.</li> - * <li><code>contextualLaunch</code> holds all descriptions for adding shortcuts to the selection sensitive - * Run/Debug/Profile cascade menus. Only objects that provide an <code>org.eclipse.debug.ui.actions.ILaunchable</code> - * adapter are considered for the cascade menus. The <code>org.eclipse.debug.ui.actions.ILaunchable</code> - * interface is simply used to tag objects that support contextual launching.</li> - * <li><code>contextLabel</code> zero or more context menu labels. For - * shortcuts that pass their filter tests, the specified label will appear - * in the "Run ->" context menu and be bound to a launch action of the - * specified mode (e.g. run,debug,profile).</li> - * <li><code>configurationType</code> allows more that one associated launch configuration type to be - * specified for this launch shortcut. That way consumers of launch shortcut information can know what kinds - * of launch configurations your short is associated with/creates</li> - * <li><code>description</code> allows a mode specific description(s) to be provided for this launch shortcut.</li> + * The top level Run/Debug/Profile cascade menus now support contextual + * (selection sensitive) launching, and clients should provide a + * <code>contextualLaunch</code> element instead.</li> + * <li><code>contextualLaunch</code> holds all descriptions for adding shortcuts + * to the selection sensitive Run/Debug/Profile cascade menus. Only objects that + * provide an <code>org.eclipse.debug.ui.actions.ILaunchable</code> adapter are + * considered for the cascade menus. The + * <code>org.eclipse.debug.ui.actions.ILaunchable</code> interface is simply + * used to tag objects that support contextual launching.</li> + * <li><code>contextLabel</code> zero or more context menu labels. For shortcuts + * that pass their filter tests, the specified label will appear in the "Run ->" + * context menu and be bound to a launch action of the specified mode (e.g. + * run,debug,profile).</li> + * <li><code>configurationType</code> allows more that one associated launch + * configuration type to be specified for this launch shortcut. That way + * consumers of launch shortcut information can know what kinds of launch + * configurations your short is associated with/creates</li> + * <li><code>description</code> allows a mode specific description(s) to be + * provided for this launch shortcut.</li> * </ul> - * </p> * <p> * <br> - * Clients contributing a launch shortcut are intended to implement this interface. + * Clients contributing a launch shortcut are intended to implement this + * interface. * </p> + * * @since 2.0 */ public interface ILaunchShortcut { diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ISourcePresentation.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ISourcePresentation.java index 6823154e8..77659434a 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ISourcePresentation.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/ISourcePresentation.java @@ -17,34 +17,33 @@ package org.eclipse.debug.ui; import org.eclipse.ui.IEditorInput; /** - * A source presentation is used to resolve an editor in - * which to display a debug model element, breakpoint, or - * source element. By default, a debug model presentation - * (which implements this interface) is used to resolve - * editors when performing source lookup. However, a source - * locator may override default editor resolution by implementing - * this interface. + * A source presentation is used to resolve an editor in which to display a + * debug model element, breakpoint, or source element. By default, a debug model + * presentation (which implements this interface) is used to resolve editors + * when performing source lookup. However, a source locator may override default + * editor resolution by implementing this interface. * <p> - * Source lookup consists of the following steps:<ol> - * <li>Locating a source element - the source locator associated - * with a launch is queried for the source element associated - * with a stack frame.</li> - * <li>Resolving an editor in which to display a source element - - * by default, the debug model presentation associated with the - * debug model being debugged is queried for an editor input - * and editor id in which to display a source element. However, - * clients may override editor resolution by specifying a source - * locator that is an instance of <code>ISourcePresentation</code>. - * When a source presentation is specified as a source locator, - * the source presentation is used to resolve an editor, rather - * than the default debug model presentation.</li> - * </ol> + * Source lookup consists of the following steps: * </p> + * <ol> + * <li>Locating a source element - the source locator associated with a launch + * is queried for the source element associated with a stack frame.</li> + * <li>Resolving an editor in which to display a source element - by default, + * the debug model presentation associated with the debug model being debugged + * is queried for an editor input and editor id in which to display a source + * element. However, clients may override editor resolution by specifying a + * source locator that is an instance of <code>ISourcePresentation</code>. When + * a source presentation is specified as a source locator, the source + * presentation is used to resolve an editor, rather than the default debug + * model presentation.</li> + * </ol> + * * <p> * Clients may implement this interface as part of an * {@link org.eclipse.debug.ui.IDebugModelPresentation} or as an optional * extension to an {@link org.eclipse.debug.core.model.ISourceLocator}. * </p> + * * @since 2.0 */ public interface ISourcePresentation { diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/BreakpointTypesContribution.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/BreakpointTypesContribution.java index 3eed46a72..8c2340e5e 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/BreakpointTypesContribution.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/BreakpointTypesContribution.java @@ -37,14 +37,17 @@ import org.eclipse.ui.menus.IWorkbenchContribution; import org.eclipse.ui.services.IServiceLocator; /** - * Breakpoint ruler pop-up action that creates a sub-menu to select the currently - * active breakpoint type. This menu contribution can be added to an editor - * with the <code>org.eclipse.ui.menus</code> extension point. The breakpoint - * types are calculated based on the toggle breakpoint target factories - * contributed through the <code>toggleBreakpointsTargetFactories</code> extension point. + * Breakpoint ruler pop-up action that creates a sub-menu to select the + * currently active breakpoint type. This menu contribution can be added to an + * editor with the <code>org.eclipse.ui.menus</code> extension point. The + * breakpoint types are calculated based on the toggle breakpoint target + * factories contributed through the + * <code>toggleBreakpointsTargetFactories</code> extension point. * <p> - * Following is example plug-in XML used to contribute this action to an editor's - * vertical ruler context menu. + * Following is example plug-in XML used to contribute this action to an + * editor's vertical ruler context menu. + * </p> + * * <pre> * <extension point="org.eclipse.ui.menus"> * <menuContribution @@ -60,11 +63,12 @@ import org.eclipse.ui.services.IServiceLocator; * </menu> * </menuContribution> * </pre> - * </p> + * * <p> - * Clients may refer to this class in plug-in XML. This class - * is not intended to be sub-classed. + * Clients may refer to this class in plug-in XML. This class is not intended to + * be sub-classed. * </p> + * * @since 3.8 * @noextend This class is not intended to be sub-classed by clients. */ diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/IAddMemoryRenderingsTarget.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/IAddMemoryRenderingsTarget.java index 418b9ec5b..e33c28e1c 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/IAddMemoryRenderingsTarget.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/IAddMemoryRenderingsTarget.java @@ -21,24 +21,29 @@ import org.eclipse.ui.IWorkbenchPart; /** * Adapter for the platform's retargettable "add memory rendering" action. - * Clients implementing this adapter are expected to add the necessary memory blocks - * and renderings when the adapter is invoked. + * Clients implementing this adapter are expected to add the necessary memory + * blocks and renderings when the adapter is invoked. * <p> * Typically, to add a memory rendering, client needs to do the following: + * </p> * <ol> * <li>Create a new memory block</li> - * <li>Add the new memory block to the Memory Block Manager. (<code>IMemoryBlockManager</code>)</li> - * <li>Create the new rendering from <code>IMemoryRenderingTypeDelegate</code></li> - * <li>Bring the required memory view to the top. (<code>IMemoryRenderingSite</code>)</li> + * <li>Add the new memory block to the Memory Block Manager. + * (<code>IMemoryBlockManager</code>)</li> + * <li>Create the new rendering from + * <code>IMemoryRenderingTypeDelegate</code></li> + * <li>Bring the required memory view to the top. + * (<code>IMemoryRenderingSite</code>)</li> * <li>Find the container from the memory view to host the new memory rendering. - * (<code>IMemoryRenderingContainer</code>)</li> - * <li>Initialize the new rendering with the appropriate memory block and container.</li> + * (<code>IMemoryRenderingContainer</code>)</li> + * <li>Initialize the new rendering with the appropriate memory block and + * container.</li> * <li>Add the new rendering to the container.</li> * </ol> - * </p> * <p> * Clients may implement this interface. * </p> + * * @since 3.2 * @see AddMemoryRenderingActionDelegate */ diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/ILaunchable.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/ILaunchable.java index fd68c9e07..a24060803 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/ILaunchable.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/ILaunchable.java @@ -14,56 +14,60 @@ package org.eclipse.debug.ui.actions; /** - * Interface used to tag objects as launchable. Objects that provide - * an adapter of this type will be considered by the contextual - * launch support. + * Interface used to tag objects as launchable. Objects that provide an adapter + * of this type will be considered by the contextual launch support. * <p> * The debug platform uses the {@link ILaunchable} interface as a tag for * objects that can be launched via the context menu 'Run As / Debug As' actions * and run/debug tool bar buttons. The platform checks if an {@link ILaunchable} * adapter is available from the selection/active editor to determine if it * should be considered for launching. However, the platform never actually - * retrieves the adapter or calls any methods on it (the interface is, in fact, empty). + * retrieves the adapter or calls any methods on it (the interface is, in fact, + * empty). + * </p> + * <p> + * The debug platform performs the following test: * </p> - * <p>The debug platform performs the following test:</p> * <ul> * <li> * <code>Platform.getAdapterManager().hasAdapter(X, ILaunchable.class.getName());</code> * </li> * </ul> * <p> - * Thus objects that can be launched need to register {@link ILaunchable} adapters, but - * don't have to provide implementations. There is also no harm in implementing the interface - * or providing the adapter. For example, JDT contributes an adapter as follows. Although - * no adapter is actually provided the platform will answer <code>true</code> to - * <code>hasAdapter(...)</code>. + * Thus objects that can be launched need to register {@link ILaunchable} + * adapters, but don't have to provide implementations. There is also no harm in + * implementing the interface or providing the adapter. For example, JDT + * contributes an adapter as follows. Although no adapter is actually provided + * the platform will answer <code>true</code> to <code>hasAdapter(...)</code>. * </p> + * * <pre> - * <extension point="org.eclipse.core.runtime.adapters"> - * <factory + * <extension point="org.eclipse.core.runtime.adapters"> + * <factory * class="" - * adaptableType="org.eclipse.jdt.core.IJavaElement"> - * <adapter type="org.eclipse.debug.ui.actions.ILaunchable"/> - * </factory> + * adaptableType="org.eclipse.jdt.core.IJavaElement"> + * <adapter type="org.eclipse.debug.ui.actions.ILaunchable"/> + * </factory> + * </extension> * </pre> * <p> - * Clients may contribute an adapter of this type for launchable objects - * via the <code>org.eclipse.core.runtime.adapters</code> extension - * point. A factory and implementation of this interface are not actually - * required. + * Clients may contribute an adapter of this type for launchable objects via the + * <code>org.eclipse.core.runtime.adapters</code> extension point. A factory and + * implementation of this interface are not actually required. * </p> * <p> - * Clients that need to check for presence of launchable adapter using - * standard expression mechanism, should use a property tester as follows: + * Clients that need to check for presence of launchable adapter using standard + * expression mechanism, should use a property tester as follows: + * </p> + * * <pre> - * <with variable="selection"> - * <iterator operator="and" ifEmpty="false"> - * <test property="org.eclipse.debug.core.launchable" value="debug"/> - * </iterator> - * </with> + * <with variable="selection"> + * <iterator operator="and" ifEmpty="false"> + * <test property="org.eclipse.debug.core.launchable" value="debug"/> + * </iterator> + * </with> * </pre> * - * </p> * @see org.eclipse.debug.ui.actions.ContextualLaunchAction * @since 3.0 */ diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/IToggleBreakpointsTargetFactory.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/IToggleBreakpointsTargetFactory.java index a69f37a40..6b7a25b79 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/IToggleBreakpointsTargetFactory.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/IToggleBreakpointsTargetFactory.java @@ -21,14 +21,16 @@ import org.eclipse.ui.IWorkbenchPart; /** * A toggle breakpoints target factory creates one or more toggle breakpoint - * targets. The toggle breakpoints targets are used by toggle breakpoint actions - * to create breakpoints appropriate for the active editor, debug session, project, - * or selection. + * targets. The toggle breakpoints targets are used by toggle breakpoint actions + * to create breakpoints appropriate for the active editor, debug session, + * project, or selection. * * <p> * Toggle breakpoints target factories are contributed via the - * <code>org.eclipse.debug.ui.toggleBreakpointsTargetFactories</code> - * extension point. Following is an example of a detail pane factory extension: + * <code>org.eclipse.debug.ui.toggleBreakpointsTargetFactories</code> extension + * point. Following is an example of a detail pane factory extension: + * </p> + * * <pre> * <extension point="org.eclipse.debug.ui.toggleBreakpointsTargetFactories"> * <toggleTargetFactory @@ -54,12 +56,11 @@ import org.eclipse.ui.IWorkbenchPart; * </toggleTargetFactory> * </extension> * </pre> - * </p> - * <p> - * <p> + * * Clients contributing a toggle breakpoints target factory are intended to * implement this interface. * + * * @see IToggleBreakpointsTarget * @see IToggleBreakpointsTargetExtension * @see org.eclipse.debug.ui.actions.IToggleBreakpointsTargetManager diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/IVariableValueEditor.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/IVariableValueEditor.java index 2e234c9d3..b6f7c962e 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/IVariableValueEditor.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/IVariableValueEditor.java @@ -17,11 +17,13 @@ import org.eclipse.debug.core.model.IVariable; import org.eclipse.swt.widgets.Shell; /** - * A variable value editor allows the user to edit a variable's value. - * Variable value editors are contributed for a debug model via the + * A variable value editor allows the user to edit a variable's value. Variable + * value editors are contributed for a debug model via the * <code>org.eclipse.debug.ui.variableValueEditors</code> extension point. * <p> * Following is example plug-in XML for contributing a variable value editor. + * </p> + * * <pre> * <extension point="org.eclipse.debug.ui.variableValueEditors"> * <variableEditor @@ -29,6 +31,7 @@ import org.eclipse.swt.widgets.Shell; * class="com.examples.variables.MyVariableValueEditor"/> * </extension> * </pre> + * * The attributes are specified as follows: * <ul> * <li><code>modelId</code> the debug model identifier for which the given @@ -36,10 +39,10 @@ import org.eclipse.swt.widgets.Shell; * <li><code>class</code> fully qualified name of a class that implements * {@link IVariableValueEditor}</li> * </ul> - * </p> * <p> * Clients may implement this interface. * </p> + * * @since 3.1 */ public interface IVariableValueEditor { diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerBreakpointTypesActionDelegate.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerBreakpointTypesActionDelegate.java index 744acc057..eb72e8932 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerBreakpointTypesActionDelegate.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerBreakpointTypesActionDelegate.java @@ -42,16 +42,19 @@ import org.eclipse.ui.texteditor.ITextEditor; import org.eclipse.ui.texteditor.ITextEditorExtension; /** - * Breakpoint ruler pop-up action that creates a sub-menu to select the currently - * active breakpoint type. This action delegate can be contributed to an editor - * with the <code>editorActions</code> extension point. The breakpoint types are - * calculated based on the toggle breakpoint target factories contributed through - * the <code>toggleBreakpointsTargetFactories</code> extension point. + * Breakpoint ruler pop-up action that creates a sub-menu to select the + * currently active breakpoint type. This action delegate can be contributed to + * an editor with the <code>editorActions</code> extension point. The breakpoint + * types are calculated based on the toggle breakpoint target factories + * contributed through the <code>toggleBreakpointsTargetFactories</code> + * extension point. * <p> - * Following is example plug-in XML used to contribute this action to an editor's - * vertical ruler context menu. It uses the <code>popupMenus</code> extension - * point, by referencing the ruler's context menu identifier in the + * Following is example plug-in XML used to contribute this action to an + * editor's vertical ruler context menu. It uses the <code>popupMenus</code> + * extension point, by referencing the ruler's context menu identifier in the * <code>targetID</code> attribute. + * </p> + * * <pre> * <extension point="org.eclipse.ui.popupMenus"> * <viewerContribution @@ -65,11 +68,11 @@ import org.eclipse.ui.texteditor.ITextEditorExtension; * </action> * </viewerContribution> * </pre> - * </p> * <p> - * Clients may refer to this class as an action delegate in plug-in XML. This class - * is not intended to be subclassed. + * Clients may refer to this class as an action delegate in plug-in XML. This + * class is not intended to be subclassed. * </p> + * * @see IToggleBreakpointsTargetManager * @see IToggleBreakpointsTargetFactory * @noextend This class is not intended to be subclassed by clients. diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerEnableDisableBreakpointActionDelegate.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerEnableDisableBreakpointActionDelegate.java index e11712b41..e27e253ab 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerEnableDisableBreakpointActionDelegate.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerEnableDisableBreakpointActionDelegate.java @@ -37,7 +37,6 @@ import org.eclipse.ui.texteditor.ITextEditor; * </action> * </viewerContribution> * </pre> - * </p> * <p> * Clients may refer to this class as an action delegate in plug-in XML. * </p> diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerRunToLineActionDelegate.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerRunToLineActionDelegate.java index dee514460..f3abc61fe 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerRunToLineActionDelegate.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerRunToLineActionDelegate.java @@ -29,6 +29,7 @@ import org.eclipse.ui.texteditor.ITextEditor; * Following is example plug-in XML used to contribute this action to an editor. * Note that the label attribute of this action is not displayed in the editor. * Instead, the label of the created action is displayed. + * </p> * * <pre> * <extension point="org.eclipse.ui.editorActions"> @@ -44,11 +45,11 @@ import org.eclipse.ui.texteditor.ITextEditor; * </editorContribution> * </extension> * </pre> - * </p> * <p> * This action can also be contributed to a vertical ruler context menu via the * <code>popupMenus</code> extension point, by referencing the ruler's context * menu identifier in the <code>targetID</code> attribute. + * </p> * * <pre> * <extension point="org.eclipse.ui.popupMenus"> @@ -63,7 +64,6 @@ import org.eclipse.ui.texteditor.ITextEditor; * </action> * </viewerContribution> * </pre> - * </p> * <p> * Clients may refer to this class as an action delegate in plug-in XML. * </p> diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerToggleBreakpointActionDelegate.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerToggleBreakpointActionDelegate.java index 5734d194e..5469fa3cb 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerToggleBreakpointActionDelegate.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RulerToggleBreakpointActionDelegate.java @@ -13,27 +13,26 @@ *******************************************************************************/ package org.eclipse.debug.ui.actions; -import org.eclipse.swt.widgets.Event; - import org.eclipse.jface.action.IAction; - import org.eclipse.jface.text.source.IVerticalRulerInfo; - +import org.eclipse.swt.widgets.Event; import org.eclipse.ui.IActionDelegate2; import org.eclipse.ui.IEditorPart; import org.eclipse.ui.texteditor.AbstractRulerActionDelegate; import org.eclipse.ui.texteditor.ITextEditor; /** - * Toggles a breakpoint when ruler is double-clicked. This action delegate can be - * contributed to an editor with the <code>editorActions</code> extension point. - * This action is as a factory that creates another action that performs the - * actual breakpoint toggling. The created action acts on the editor's + * Toggles a breakpoint when ruler is double-clicked. This action delegate can + * be contributed to an editor with the <code>editorActions</code> extension + * point. This action is as a factory that creates another action that performs + * the actual breakpoint toggling. The created action acts on the editor's * <code>IToggleBreakpointsTagret</code> to toggle breakpoints. * <p> * Following is example plug-in XML used to contribute this action to an editor. * Note that the label attribute of this action is not displayed in the editor. * Instead, the label of the created action is displayed. + * </p> + * * <pre> * <extension point="org.eclipse.ui.editorActions"> * <editorContribution @@ -48,11 +47,12 @@ import org.eclipse.ui.texteditor.ITextEditor; * </editorContribution> * </extension> * </pre> - * </p> * <p> * This action can also be contributed to a vertical ruler context menu via the * <code>popupMenus</code> extension point, by referencing the ruler's context * menu identifier in the <code>targetID</code> attribute. + * </p> + * * <pre> * <extension point="org.eclipse.ui.popupMenus"> * <viewerContribution @@ -66,10 +66,10 @@ import org.eclipse.ui.texteditor.ITextEditor; * </action> * </viewerContribution> * </pre> - * </p> * <p> * Clients may refer to this class as an action delegate in plug-in XML. * </p> + * * @since 3.1 * @noextend This class is not intended to be subclassed by clients. * @noinstantiate This class is not intended to be instantiated by clients. diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RunAction.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RunAction.java index 775d8a990..06753e5e2 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RunAction.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/actions/RunAction.java @@ -22,7 +22,6 @@ import org.eclipse.debug.ui.IDebugUIConstants; * Action to launch the last launch configuration that was successfully * launched, in run mode. If no configurations have been launched, the launch * configuration dialog is opened. - * </p> * <p> * This class may be instantiated. * </p> diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/console/IConsoleColorProvider.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/console/IConsoleColorProvider.java index 724e9cd70..c0531a590 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/console/IConsoleColorProvider.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/console/IConsoleColorProvider.java @@ -27,8 +27,9 @@ import org.eclipse.swt.graphics.Color; * <code>IProcess. ATTR_PROCESS_TYPE</code>. * <p> * A console color provider extension is defined in <code>plugin.xml</code>. - * Following is an example definition of a console color - * provider extension. + * Following is an example definition of a console color provider extension. + * </p> + * * <pre> * <extension point="org.eclipse.debug.ui.consoleColorProviders"> * <consoleColorProvider @@ -38,19 +39,21 @@ import org.eclipse.swt.graphics.Color; * </consoleColorProvider> * </extension> * </pre> + * * The attributes are specified as follows: * <ul> - * <li><code>id</code> specifies a unique identifier for this color provider.</li> - * <li><code>class</code> specifies a fully qualified name of a Java class - * that implements <code>IConsoleColorProvider</code>.</li> + * <li><code>id</code> specifies a unique identifier for this color + * provider.</li> + * <li><code>class</code> specifies a fully qualified name of a Java class that + * implements <code>IConsoleColorProvider</code>.</li> * <li><code>processType</code> specifies the identifier of the process type * this content provider is associated with (which corresponds to the * <code>ATTR_PROCESS_TYPE</code> attribute on a process).</li> * </ul> - * </p> * <p> * Clients may implement this interface. * </p> + * * @since 2.1 */ diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/memory/IMemoryRendering.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/memory/IMemoryRendering.java index 13d632c42..67785cc9f 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/memory/IMemoryRendering.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/memory/IMemoryRendering.java @@ -25,6 +25,8 @@ import org.eclipse.swt.widgets.Control; * via the <code>memoryRenderings</code> extension point. * <p> * Following is an example definition of a memory renderings extension. + * </p> + * * <pre> * <extension point="org.eclipse.debug.ui.memoryRenderings"> * <memoryRenderingType @@ -34,38 +36,41 @@ import org.eclipse.swt.widgets.Control; * </memoryRenderingType> * </extension> * </pre> + * * The attributes are specified as follows: * <ul> - * <li><code>id</code> specifies a unique identifier for a type of memory rendering</li> - * <li><code>name</code> specifies a human readable label for a rendering type</li> + * <li><code>id</code> specifies a unique identifier for a type of memory + * rendering</li> + * <li><code>name</code> specifies a human readable label for a rendering + * type</li> * <li><code>class</code> specifies the fully qualified name of the Java class - * that implements <code>IMemoryRenderingTypeDelegate</code>. Renderings are created - * via this factory.</li> + * that implements <code>IMemoryRenderingTypeDelegate</code>. Renderings are + * created via this factory.</li> * </ul> - * </p> * <p> - * A rendering provides an image and label. To support dynamic labels and images, property - * change notification is used with the following property constants defined in - * <code>IBasicPropertyConstants</code>: + * A rendering provides an image and label. To support dynamic labels and + * images, property change notification is used with the following property + * constants defined in <code>IBasicPropertyConstants</code>: + * </p> * <ul> * <li><code>P_TEXT</code> - indicates a label change</li> * <li><code>P_IMAGE</code> - indicates a image change</li> * </ul> - * </p> * <p> * Renderings needing to synchronize with other renderings are intended to use - * property change notifications via its synchronization service. For example, when a - * rendering becomes visible, it can register for property change events with its rendering - * site's synchronization service, and when it becomes hidden it can unregister. When a - * rendering is activated, it should set itself as the synchrnoization provider in its - * rendering site and fire property change events to communicate information to - * interested listeners. + * property change notifications via its synchronization service. For example, + * when a rendering becomes visible, it can register for property change events + * with its rendering site's synchronization service, and when it becomes hidden + * it can unregister. When a rendering is activated, it should set itself as the + * synchrnoization provider in its rendering site and fire property change + * events to communicate information to interested listeners. * </p> * <p> - * Clients contributing a memory rendering type are intended to implement this interface - * and <code>IMemoryRenderingTypeDelegate</code>. The factory will be used to create instances - * of <code>IMemoryRendering</code>. + * Clients contributing a memory rendering type are intended to implement this + * interface and <code>IMemoryRenderingTypeDelegate</code>. The factory will be + * used to create instances of <code>IMemoryRendering</code>. * </p> + * * @since 3.1 */ public interface IMemoryRendering extends IAdaptable{ diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/memory/IMemoryRenderingSynchronizationService.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/memory/IMemoryRenderingSynchronizationService.java index 351b0dfc1..dbcd2e94b 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/memory/IMemoryRenderingSynchronizationService.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/memory/IMemoryRenderingSynchronizationService.java @@ -66,10 +66,10 @@ public interface IMemoryRenderingSynchronizationService { void setSynchronizationProvider(IMemoryRendering rendering); /** - * Returns the rendering currently providing synchronization information for - * this synchronization service, or <code>null</code if none. - * - * @return rendering providing synchronization information or <code>null</code> - */ + * Returns the rendering currently providing synchronization information for + * this synchronization service, or <code>null</code> if none. + * + * @return rendering providing synchronization information or <code>null</code> + */ IMemoryRendering getSynchronizationProvider(); } diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/sourcelookup/ISourceContainerBrowser.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/sourcelookup/ISourceContainerBrowser.java index 86c154a3b..e6d7be9cb 100644 --- a/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/sourcelookup/ISourceContainerBrowser.java +++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/ui/sourcelookup/ISourceContainerBrowser.java @@ -19,13 +19,15 @@ import org.eclipse.swt.widgets.Shell; /** - * Creates and edits source containers for a source lookup director. - * Contributed via a source container presentation extension for - * a specific type of source container. + * Creates and edits source containers for a source lookup director. Contributed + * via a source container presentation extension for a specific type of source + * container. * <p> - * Following is an example source container presentation definition - * that contributes a source container browser via the - * <code>browserClass</code> attribute. + * Following is an example source container presentation definition that + * contributes a source container browser via the <code>browserClass</code> + * attribute. + * </p> + * * <pre> * <extension point="org.eclipse.debug.ui.sourceContainerPresentations"> * <sourceContainerPresentation @@ -36,7 +38,7 @@ import org.eclipse.swt.widgets.Shell; * </sourceContainerPresentation> * </extension> * </pre> - * </p> + * * @since 3.0 */ public interface ISourceContainerBrowser { diff --git a/org.eclipse.ui.console/src/org/eclipse/ui/console/TextConsole.java b/org.eclipse.ui.console/src/org/eclipse/ui/console/TextConsole.java index 02170dd2a..e847c23fa 100644 --- a/org.eclipse.ui.console/src/org/eclipse/ui/console/TextConsole.java +++ b/org.eclipse.ui.console/src/org/eclipse/ui/console/TextConsole.java @@ -522,7 +522,7 @@ public abstract class TextConsole extends AbstractConsole { * Called by this console's pattern matcher when matching is complete. * <p> * Clients should not call this method. - * <p> + * </p> */ public void matcherFinished() { fMatcherFinished = true; |