|
Revised October 31, 2002 |
|
This document explains our (high level) plan for
the future of Eclipse's external tools and Ant support. It explains how
external tools will be created, configured, executed, and used as project
builders. For the purposes of this document, Ant scripts are considered
a kind of external tool. However, Ant will have additional first class
integration in the Eclipse IDE.
Items are marked with priorities - P1, P2, P3.
Items marked as P1 are items that we plan to implement for Eclipse 2.1.
Items marked as P2 are likely to be implemented. Items marked as P3 are
not committed, or are investigation items.
|
| Presentation |
|
External Tools |
|
- (P1) The external tools drop down menu in the
toolbar will remain. It will contain a history of recently launched
external tools, and an option to configure external tools.
- (P1) When the "Configure..." action
is invoked, a dialog will open that looks much like the "Launch
Configuration Dialog" - except it will be named the "External
Tools" Dialog. It will have a tree on the left hand side with root
nodes representing types of external tools, and leaf nodes representing
instances of external tools. The right hand portion of the dialog will
contain tabs used for displaying/editing the attributes of the selected
external tool.
- (P1) By default, two types of external tools are provided - Programs
and Ant Scripts.
- (P1) The user can create a new instanceof a program/ant script by
selecting the external tool type (root node), and pressing "new".
- (P1) External tools will appear in the debug view when launched (as
processes), with console history.
- (P1) An external tool can be executed from the "External Tools"
dialog, or from the external tools history.
|
|
Ant |
|
- (P1) In addition to being able to create/execute
an Ant script for the "External Tools" dialog, an Ant View
will be provided. The Ant View will display the structural outline of
one or more Ant scripts
- (P1) The Ant View will support the execution
of one or more selected targets.
- (P1) An Ant script may be added to the Ant View
via a pop-up menu action in the navigator - i.e. select an Ant file
and use the "Show in Ant View" action (although we need to
do this carefully so the action does not appear for all XML files).
- (P2) An Ant script may be added to the Ant View
via drag & drop.
- (P1) An Ant script may be added to the Ant View,
by invoking the "Find Ant Scripts" action in the Ant View.
This will search the workspace for Ant scripts, and allow the user to
select Ant Scripts to add to the view.
- (P3) An editor will be provided for Ant scripts,
with syntax coloring, code assist, and an outliner.
- (P3) Ant scripts will always be run in verbose
mode (behind the scences), such that the user can obtain extra information
after the fact. The console will filter the verbose output unless the
user decides to look at it.
- (P1) From the Ant view, the user will be allowed
to edit the properties of the script via a "Properties..."
action. This will open the External Tools dialog on the Ant script,
such that its attributes can be modified.
- (P2) As a possible enhancement, a specialized
version of the "External Tools" dialog may be created that
displays only one external tool (i.e. no tree on the left hand side
where all tools are displayed). This could be used for the "Properties..."
action.
|
|
Console |
|
- (P1) The existing External Tools "Log Console"
will be integrated with the debugger's "Console View". The
"Console View" will be enhanced with an API such that clients
may implement "content providers" for the console, allowing
arbitray streams of output to be displayed in the console, with custom
coloring. As well, the console will support keyboard input, which is
written to an input stream.
- (P2) The debug console will be enhanced to support
the notion of "structured output". A content provider that
provides "structured output" will be responsible for a tree
content provider to populate a tree/index that corresponds to its textual
output. When a node in the tree is selected, corresponding output will
be highlighted in the console view.
- (P2) The debug console can be toggled between
three modes - text output only, structured output only, or a combination
of strucutred/textual output.
- (P2) The console API will support the notion
of hyperlinks. Clients will be able to add hyperlinks to a console document
(character ranges). The console will perform mouse tracking, and notify
clients when a link is activated (the implementation of which, is up
to the client).
|
|
Project Builders |
|
- (P1) Currently, a (*new*) tool may be configured
as a project builder, which is invoked when a project is built. We will
maintain this fuctionality.
- (P2) In addition, we'd like to allow the user
to choose from existing external tools, when adding a builder to a project.
- (P2) An external tool, registered as a builder
can be edited with the specialized "External Tools" dialog
that supports the editing of a single external tool.
|
| Implementation |
|
Launch configurations |
|
- (P1) The implementation of external tool objects
is very similar to launch configurations (a set of attributes that are
interpreted by a launcher). We intend to implement/persist external
tools as a new launch configuration type.
- (P1) Existing launch configuration extension points will be used to
define types of external tools and UIs (tabs) for editing their properties
- launchConfigurationTypes, and launchConfigurationTabGroups.
- (P1) A special version of the launch config
dialog will be used to display external tool launch cofigurations.
- (P2) The debug platform may add new API to allow
this specializatoin of the launch configuration dialog.
- (P1) External tools will not appear in the regular
launch configuration dialog.
- (P2) We may add the notion of "variables" to
the launch configuration framework. This code currently exists in the
external tools framework, but we believe it would make sense in the
launch config framework and thus plan to push it down. This feature
should improve our shared launch configuration story. Even better, we
would like variables to be part of the platform.
- (P1) When the user selects "Run Ant..."
from the navigator, any existing launch configuration for the selected
Ant script will be run. Otherwise, a default Ant launch configiuration
will be created and run.
|
|
Debug view |
|
- (P1) When an external tool is run, it will appear
in the debug view.
- (P2) We may provide the ability to terminate
running tools from this view (it depends on the implementation of the
external tool).
|
|
Project Builders |
|
- (P1) External tool project builders are stored
by translating a launch configuration into an ICommand.
- (P3) If possible the ICommand should reference
the associated launch configuration handle, rather than duplicating
the storage of all of the launch configuration attributes. There are
issues here that need investigation - i.e. sharing project builders.
This would require the launch configuration to also be shared (and of
course, the ant script that it points to).
|
| Future Enhancements |
|
Debugging Ant Scripts |
|
- (P3) Debugging Ant scripts - breakpoint and
stepping support.
- (P3) Debugging Ant tasks under development.
|
