• M-x command execution
• Emacs style selection
• A kill ring for deleted text
• Balanced expression (s-expression) commands
• Split editor windows via keystrokes
• Tags search (without tags)
• Transposition of characters, words, lines and s-expressions
• Space and blank line handling
• Simple text manipulation commands
• End-of-line comment operations

STAN encourages developers in visualizing their design, understanding code, measuring quality and reporting design flaws. STAN supports a set of carefully selected metrics, suitable to cover the most important aspects of structural quality. Special focus has been set on visual dependency analysis, a key to structure analysis. STAN provides its own perspective, showing various dependency graphs, ranking metric violations, generating HTML reports, etc.

STAN is also available as an standalone RCP application.

You may install and use STAN without a license key (community license option). However, structure analysis will be limited to 100 classes.

Excelsior JET is a compliant Java SE 6 implementation (JVM) powered by the Ahead-Of-Time compilation technology.

Excelsior JET, Enterprise Edition enables you to compile your Eclipse RCP application to a native code executable and distribute it without the original class/jar files.

Compilation to native code substantially improves the security and IP protection of Eclipse RCP applications, as the sensitive code and data get protected from reverse engineering, and tampering with the OSGi bundles becomes impossible. It makes all those Java decompilers useless to the malicious programmers and attackers simply because Java classes are not included in the end user installations.

Learn more,

see it in action or download your free trial now!

• runtime functions like start, stop & reload context
• configuration functions like removing or disabling a context
• management funcions like opening and edition of context's web.xml, context definitions, and even server.xml and users.xml

Programming language

The Object Teams Development Tooling embeds the role-based and aspect-oriented language ObjectTeams/Java into the Eclipse IDE. ObjectTeams/Java is an extension to the Java language, allowing for intuitive, role-based system modularization, as well as non-invasive adaptations of existing (Java-) software. By grouping roles into so-called teams, scalability is significantly better than in pure object-oriented languages.

Development environment

The IDE is in development since 2003 and is based on the Eclipse Java Development Tools (JDT). It seamlessly supports and extends all features of the JDT like incremental compilation, code completion, quick-fixes, refactoring, debugging, etc.

Components

It is also possible to develop Eclipse plug-ins with ObjectTeams/Java and adapt existing plug-ins by hooking aspects into them. This technology — called OT/Equinox — can be used for all kinds of OSGi bundles including RCP components.

We eat our dog food

The OTDT itself has been developed using OT/Equinox thus showcasing the power of this technology in terms of unanticipated adaptations while sustaining a clear design that is easy to maintain.

Supported platforms

The OTDT has been tested on Linux, Windows and MacOS, but should run on any OS running a recent (≥1.5) JRE.

Further reading

• Full list of features
• New&Noteworthy
• Download

Requirement: Eclipse 3.5

• Wizard:
• Now Plugins are grouped by their Features
• Also all 'dependent' Plugins can be selected automatically
• Show only selected Plugins
• Plugins with buddy-policy are highlighted

• Editor:
• Reload diagram after changing dependencies in workspace
• Cyledetection and their visualisation in diagram
• Collapse all features after diagram creation
• All plugins with buddy-policy are marked red
• All dependent plugins are calculated and printed out in properties-view

• Select any Plugin from your targetplatform and let eDependency generate a dependency-diagram
• Dependency-Visualization in a Graphical-Editor
• Dependencies between Bundles and/or Features

Download

Now fully supports GWT 1.6 - GWT Designer is a powerful and easy to use bi-directional GUI creator that supports the Google Web Toolkit (GWT). With GWT Designer, you can use the visual designer and Java code will be generated for you. You can easily add controls using drag-and-drop, add event handlers to your controls, change various properties of controls using a property editor and much more. You have complete freedom to change and refactor its generated code and see your changes immediately reflected in the visual designer. GWT Designer's powerful parser can also reverse engineer code created by hand. GWT Designer is built as a plug-in to Eclipse, JBuilder MyEclipse and Rational IDEs. The plug-in builds an Abstract Syntax Tree (AST) to navigate the source code and uses GEF to display and manage the visual presentation. Using WYSIWYG layout tools, you don't need to write any lines of Java code - the designer will generate the code for you.

Generated code doesn't require any additional custom libraries to compile and run beyond GWT itself: all of the generated code can be used without having GWT Designer installed. GWT Designer can read and write almost any format. It also supports free form code editing (make changes anywhere, not just in special areas) and most user refactorings (you can move, rename and subdivide methods without a problem).

Key Features:

• True Bi-directional Code Generation
  Directly generates Java code which can be changed in the graphical editor or directly in source. All changes made directly to the source code will be reflected in the graphical designer

• True WYSIWYG
  Design view shows real GWT/HTML controls (not fake mockups) so all properties are reflected graphically

• CSS Support
  GWT Designer can apply CSS to the design view, so you can see an exact rendering of how your screen will look in the browser. Edit CSS files using CSS Editor and edit CSS properties from within graphical designer

• Extremely Fast
  GWT Designer opens a design in a couple seconds - several times faster than launching the GWT application itself (mostly due to our *proprietary* technique of using ASM for fast bytecode modification). All subsequent edit actions update the Design view in just 300-400 milliseconds

• Rich Editing Experience
  Support for all panel types with convenient and appropriate layout edit policies. AbsolutePanels provide Matisse-like widget snapping and alignment. Graphically layout Grids, FlexTables and TabPanels.

• Wizards & Builders
  Wizards for creating new PopupPanels, DialogBoxes and Composites. Wizards for creating new GWT projects and RemoteServices. A Builder for the automatic creation of the "async" parts of a service is also included

• GWT Application Launching
  GWT Application launch configuration including launch shortcut for fast launching using popup menu or hot key in editor

• Intelligent Refactoring
  Renaming or moving a module class or remote service updates the the module XML file and renames any associated *Async and *Impl classes

• Internationalization (i18n)
  Extract hard coded strings to resource bundles and automatically manage multiple locales

• Easy Build & Deployment
  One-click deployment tool automatically creates a project WAR file and uploads it to your server. An ANT script is generated for an easy, repeatable build process
  
  

  GWT Developer is available through an annual subscription of $59 (USD) per seat. Two and three year subscriptions are also offered for $99 and $139 (USD). A perpetual license is available for $124 with one year of support & upgrades. A two-week trial copy is also available at http://www.instantiations.com/gwtdesigner/download.html

RCP Developer is an Eclipse-based software development product that accelerates the creation of Eclipse Rich Client Platform (RCP) applications by providing tools for constructing and testing graphical user interfaces, documenting and packaging rich client applications for deployment. RCP Developer harnesses the powerful services of Eclipse RCP to put Java back o?n the desktop by reducing development time, increasing performance, and assuring consistent application look-and-feel. RCP Developer is comprised of four component products SWT Designer, WindowTester SWT, Help Composer and RCP Packager.

----------------------------------------------------------------------------------------------------------------
SWT Designer empowers developers to quickly create the views, editors, perspective, preference pages and other user interface elements that comprise Eclipse RCP applications. SWT Designer gives developers complete control over user interface construction through intuitive visual design, native look-and-feel, and access to the high performance SWT GUI framework of Eclipse RCP.

WindowTester SWT assures application quality through automated testing of the graphical user interfaces that comprise Eclipse RCP applications. WindowTester minimizes the need for developers to hand-code GUI test cases through automated recording, test generation, code coverage and playback facilities.

Help Composer streamlines the creation of documentation that is fully compatible with the Eclipse Help system. It assists in linking the logical and physical structure of Help files to the application in a consistent way. It also enables the quick translation of Help files into Web pages using generic or custom website templates and style sheets to provide easy navigation for customers.

RCP Packager streamlines the build and deployment process for Eclipse RCP applications by assembling application elements together into a single package for easy deployment. RCP Packager helps developers reliably create and maintain high-quality Eclipse RCP installations while reducing development time.
------------------------------------------------------------------------------------------------

White Paper: Harnessing the Power of Eclipse RCP to Put Java Back o?n the Desktop
Case Study: BEA Uses RCP Developer to Improve Quality and to Save Time & Money
View webcast: Bring Java Back to the Desktop: Eclipse Rich Client Platform

New!! WindowTester Runner - for executing test created by full WindowTester product WindowTester Pro is an Eclipse-based software development product that automates testing of Java graphical user interfaces (GUI) by providing tools that automate recording, test generation, code coverage, and playback of GUI interactions that can occur within an application. WindowTester seamlessly integrates with the native Eclipse testing framework and generates code that is 100% JUnit compatible to deliver a high quality and consistent user experience. WindowTester Pro provides automated testing support for both popular Java graphical user interface frameworks, Swing and SWT.

KEY FEATURES

-- Click & Record
Quickly and easily record GUI tests. Interact with your application as you normally would and let WindowTester watch your actions and generate a test case automatically. These generated tests are pure Java and easily customized using all the power available in the Java language.

-- Automatic Playback
WindowTester test cases automatically exercise your application's GUI, boosting your confidence that your application meets its specifications.

-- Continuous Test
Test case execution is easily integrated into a continuous build system so that the correctness of your application is tested each and every time that your application is built.

?-- Code Coverage
Understand what parts of your application are exercised when one or more WindowTester tests are executed.

-- Rich GUI Test Library
WindowTester provides a Rich GUI Test Library, hiding the complexities and threading issues of GUI test execution and facilitating test case customization to meet the needs of your particular situation.
* Test cases are based on the JUnit standard
* Pure Java GUI test cases are easy to read
* Test cases are customizable
* You can refactor GUI test cases
* You can create new GUI test case

PRODUCT CONFIGURATIONS
* WindowTester Pro (Swing and SWT)
* WindowTester SWT
* WindowTester Swing

NEW! UI Factories, Nebula widget integration, Swing data-binding (JSR 295), GWT-Ext support, and much more! WindowBuilder Pro (SWT/Swing/GWT Designer) is a powerful and easy to use bi-directional Java GUI designer that supports Eclipse SWT, Sun Swing and Google GWT technology. It is very easy to create Java GUI, Eclipse RCP and GWT/Ajax applications without spending a lot of time writing code to display simple forms. Support for the popular JGoodies FormLayout that enables creation of precise and flexible Swing form windows. With WindowBuilder you can create complicated windows in minutes. Use the visual designer and Java code will be generated for you. You can easily add controls using drag-and-drop, add event handlers to your controls, change various properties of controls using a property editor and much more. You have complete freedom to change and refactor its generated code and see your changes immediately reflected in the visual designer. WindowBuilder's powerful parser can also reverse engineer code created by hand or by other popular GUI builders like JBuilder, NetBeans, VisualAge and the Eclipse VE.
Open source, non-commercial and academic licenses are available! A free limited-function version is also available.

Common Features o Basic Features - WYSIWYG Editing - Graphical Menu Editing - Create Nested Composites & Panels - Cut / Copy / Paste - Multi-Level Undo & Redo - Instant Test Button - Change Z-Order via Drag & Drop - No Special Libraries Required - Zero Runtime Overhead - Seamless Eclipse Integration - Eclipse-Based Help - Control Editor Layout o Advanced Features - Reverse engineer hand-written code - Supports user code refactoring - Free-form code editing - Support for non-visual Beans - Intelligent Layout Assist - Create & Use Custom Composites & Panels - Define Custom Widget Templates - Widget Morphing - Graphical Table & Toolbar Editing - Multi-Widget Select & Edit - Populate Custom Control Palette o Code Generation Features - Bi-Directional Code Generation - Read & write almost any style - Block mode & Flat mode - Prefix component creation - Share variables - Control variable declaration - Create event handler stubs - Define default variable names - Make selected widgets fields by default - Make all widgets fields by default - Generate accessors for all fields - Internationalization tools & wizards o Platforms - Windows - Linux/GTK - Mac (limited, unsupported, SWT o?nly)

SWT Features o Basic Features - Supports All SWT Widgets - SWT Application Wizard - SWT Project Wizard o Advanced Features - Visual Inheritance - Support for Eclipse Forms - Dynamic FormLayout Snap Points - Extract Frame Refactoring - Gradient Editor for CLabels - ScrolledComposites ScrolledComposites - SWT Frame Wizard - Eclipse ViewPart Wizard - Eclipse PreferencePage Wizard - Eclipse PropertyPage Wizard - FieldEditorPreferencePage Support o Full JFace Support - Supports all JFace viewers - JFace Wizard Page Wizard - JFace Dialog Wizard - JFace Application Wizard o Supported Layout Managers - GroupLayout - Null/Absolute - FillLayout - RowLayout - GridLayout - FormLayout - StackLayout - Swing FlowLayout - Swing BorderLayout - Swing GridLayout o SWT/JFace Data Binding

Swing Features o Basic Features - Supports All Swing & AWT Widgets - Swing Application Wizard - JFrame Wizard o Advanced Features - Visual Inheritance - Custom look & feel support - Graphical GridBagLayout Support - Create BoxLayout struts & glue - Dynamic SpringLayout Snap Points - JPanel Wizard - JApplet Wizards - JInternalFrame Wizard o Supported Layout Managers - GroupLayOut - Null/Absolute - FlowLayout - BorderLayout - GridLayout - CardLayout - GridBagLayout - BoxLayout - SpringLayout GWT Features o Bi-directional Code Generation o True WYSIWYG Design o CSS Support o Extremely Fast o Rich Editing Experience o Wizards & Builders o GWT Application Launching o Intelligent Refactoring o Internationalization (i18n) o Easy Build & Deployment