Mac Os End Key Binfind Not Working For Eclipse

Last revised Wednesday, June 2, 2004 ( marks interesting changes since the previous draft of April 28, 2004)
Please send comments about this draft plan to the [email protected]developer mailing list.

  • Bind Ctrl+C to Copy function for eclipse on mac os x doesn't work I'm just moving my coding work from Windows to mac os x. It's really difficult to get used to the ctrl and command key behavior at beginning.
  • Keyboard shortcuts and menu accelerator — On Apple machines, the role of the control key on PC's is traditionally performed by the Command key - positioned where the ALT or META keys are found on PC keyboards. Users have cited this as a reason for switching to Eclipse - CTRL-based shortcuts simply feel unnatural to Mac users.

This document lays out the feature and API set for the next feature releaseof Eclipse after 2.1, designated release 3.0 (WhyEclipse '3.0'?).

Plans do not materialize out of nowhere, nor are they entirely static. Toensure the planning process is transparent and open to the entire Eclipsecommunity, we (the Eclipse PMC) post plans in an embryonic form and revise themthroughout the release cycle.

Allow user customizable key bindings. Eclipse 2.0 supports configurable key bindings, but only for editor key bindings, and only configured by a plug-in. The user should be able to interactively customize the key bindings for all workbench actions. There are additional customization possibilities including visible actions and perspective layout. In shell-mode, the C-up and C-down key-bindings do not work as expected to browse the history ring. The problem is that Terminal.app does not properly send these control sequences. To fix this behavior, open Terminal.app PreferencesSettingsKeyboard.

The first part of the plan deals with the important matters of releasedeliverables, release milestones, target operating environments, andrelease-to-release compatibility. These are all things that need to be clear forany release, even if no features were to change.

The remainder of the plan consists of plan items for the various Eclipsesubprojects. Each plan item covers a feature or API that is to be added toEclipse, or some aspect of Eclipse that is to be improved. Each plan item hasits own entry in the Eclipse bugzilla database, with a title and a concisesummary (usually a single paragraph) that explains the work item at a suitablyhigh enough level so that everyone can readily understand what the work item iswithout having to understand the nitty-gritty detail.

Not all plan items represent the same amount of work; some may be quitelarge, others, quite small. Some plan items may involve work that is localizedto a single Platform component; others may involve coordinated changes toseveral components; other may pervade the entire Platform. Although some planitems are for work that is more pressing that others, the plan items appear inno particular order.

With the previous release as the starting point, this is the plan for how wewill enhance and improve it. Fixing bugs, improving test coverage,documentation, examples, performance, usability, etc. are considered routineongoing maintenance activities and are not included in this plan unless theywould also involve a significant change to the API or feature set, or involve asignificant amount of work. All interesting feature work is accounted for inthis plan.

The current status of each plan item is noted:

  • Committed plan item - A committed plan item is one that we have decided to address for the release.
  • Proposed plan item - A proposed plan item is one that we are considering addressing for the release. Although we are actively investigating it, we are not yet in a position to commit to it, or to say that we won't be able to address it. After due consideration, a proposal will either be committed, deferred, or rejected.
  • Deferred plan item - A reasonable proposal that will not make it in to this release for some reason is marked as deferred with a brief note as to why it was deferred. Deferred plan items may resurface as committed plan items at a later point.
  • Rejected plan item - Plan items that were proposed but judged unworkable are marked as rejected plan items, with an accompanying summary of why they were dismissed. Keeping track of rejected items avoids repeating the discussion.

Release deliverables

The release deliverables have the same form as previous releases, namely:

  • Source code release for Eclipse Project, available as versions tagged 'R3_0' in the Eclipse Project CVS repository.
  • Eclipse Project SDK (includes Platform, JDT, and PDE source zips) (downloadable).
  • Eclipse Platform runtime binary distribution (downloadable).
  • JDT runtime binary distribution (downloadable).
  • Eclipse SDK Examples (downloadable).
  • SWT distribution (downloadable).

Release milestones

Release milestone occurring at roughly 6 week intervals exist to facilitatecoarse-grained planning and staging. The milestones are:

  • Friday June 6, 2003 - Milestone 1 (3.0 M1) - stable build reflecting progress
  • Friday July 18, 2003 - Milestone 2 (3.0 M2) - stable build reflecting progress
  • Friday August 29, 2003 - Milestone 3 (3.0 M3) - stable build reflecting progress
  • Friday October 10, 2003 - Milestone 4 (3.0 M4) - stable build reflecting progress
  • Friday November 21, 2003 - Milestone 5 (3.0 M5) - initial API freeze for breaking changes - stable build reflecting progress
  • Friday December 19, 2003 - Milestone 6 (3.0 M6) - API freeze for breaking changes - stable build with focus on reducing the bug backlog and fixing memory leaks
  • Friday February 13, 2004 - Milestone 7 (3.0 M7) - stable build reflecting progress
  • Friday March 26, 2004 - Milestone 8 (3.0 M8) - stable build reflecting progress
  • Friday May 21, 2004 - Milestone 9 (3.0 M9) - stable build - feature complete - development freeze - lock down and testing begins

Lock down and testing then begins with M9, and progress through a series of test-fix passes against candidates releases. Release candidate builds are planned as follows (M9 is release candidate 0):

  • Friday May 28, 2004 - Release Candidate 1 - (3.0 RC1)
  • Friday June 11, 2004 - Release Candidate 2 - (3.0 RC2)
  • Friday June 18, 2004 - Release Candidate 3 - (3.0 RC3)
  • Friday June 25, 2004 - Release Candidate 4 - (3.0 RC4)

Depending on the circumstances, we may add additional release candidate builds or fine-tune the schedule. The 3.0 release is targeted for the week of June 28, 2004. See the Eclipse 3.0 Endgame Plan for further details. All release deliverables will be available for download as soon as the release has been tested and validated in the target operating configurations listed below.

Target Operating Environments

In order to remain current, each Eclipse release targets reasonably currentversions of the underlying operating environments.

Most of the Eclipse SDK is 'pure' Java™ code and has no directdependence on the underlying operating system. The chief dependence is thereforeon the Java 2 Platform itself. The 3.0 release of the Eclipse Project is writtenand compiled against version 1.4 of the Java 2 Platform APIs, and targeted torun on version 1.4 of the Java 2 Runtime Environment, Standard Edition.

There are many different implementations of the Java 2 Platform running atopa variety of operating systems. We focus Eclipse testing on a handful of popularcombinations of operating system and Java 2 Platform; theseare our reference platforms. Eclipse undoubtedly runs fine in manyoperating environments beyond the reference platforms we test. However, since wedo not systematically test them we cannot vouch for them. Problems encounteredwhen running Eclipse on non-reference platform that cannot be recreated on anyreference platform will be given lower priority than problems with runningEclipse on a reference platform.

Eclipse SDK 3.0 is tested and validated on the following reference platforms(this list is updated over the course of the release cycle):

Working
Operating systemProcessor architectureWindow systemJava 2 Platform
Microsoft Windows XPIntel x86Win32Sun Java 2 SDK, Standard Edition, version 1.4.2_03 for Microsoft Windows
Microsoft Windows XPIntel x86Win32

IBM 32-bit SDK for Windows, Java 2 Technology Edition, Version 1.4.1

Red Hat Enterprise Linux WS 3Intel x86GTKSun Java 2 SDK, Standard Edition, 1.4.2_03 for Linux x86
Red Hat Enterprise Linux WS 3Intel x86GTKIBM 32-bit SDK for Linux on Intel architecture, Java 2 Technology Edition, Version 1.4.1
SuSE Linux 8.2Intel x86GTKSun Java 2 SDK, Standard Edition, 1.4.2_03 for Linux x86
SuSE Linux 8.2Intel x86GTKIBM 32-bit SDK for Linux on Intel architecture, Java 2 Technology Edition, Version 1.4.1
Sun Solaris 8SPARCMotifSun Java 2 SDK, Standard Edition, 1.4.2_03 for Solaris SPARC
HP HP-UX 11ihp9000
PA-RISC
MotifHP-UX SDK for the Java 2 platform, version 1.4.2.00 for hp9000 PA-RISC
IBM AIX 5L Version 5.2PowerPCMotif

IBM 32-bit SDK for AIX, Java 2 Technology Edition, Version 1.4.1

Apple Mac OS X 10.3PowerPCCarbonJava 2 Standard Edition 1.4.1 for Mac OS X

Although untested, Eclipse should work fine on other OSes that support the same window system. For Win32: Windows 98, ME, NT, 2000, and Server 2003; SWT HTML viewer requires Internet Explorer 5 (or higher). For GTK on other Linux systems: version 2.2.1 of the GTK+ widget toolkit and associated librares (GLib, Pango); SWT HTML viewer requires Mozilla 1.4GTK2. For Motif on other Linux systems: Open Motif 2.1 (included); SWT HTML viewer requires Mozilla 1.4GTK2.

An early access version of Eclipse is available for 64-bit Linux GTK. Testing has been limited to early access 64-bit J2SEs running on AMD64 processors.

SWT is also supported on the QNX Neutrino operating system, x86 processor, Photon window system, and IBM J9 VM version 2.0. Eclipse 3.0 on Windows or Linux can be used cross develop QNX applications. (Eclipse 3.0 is unavailable on QNX because there is currently no 1.4 J2SE for QNX.)

Internationalization

The Eclipse Platform is designed as the basis for internationalized products.The user interface elements provided by the Eclipse SDK components, includingdialogs and error messages, are externalized. The English strings are providedas the default resource bundles.

Latin-1 locales are supported by the Eclipse SDK on all of the aboveoperating environments; DBCS locales are supported by the Eclipse SDK on theWindows, GTK, and Motif window systems; BIDI locales are supported by theEclipse SDK only on Windows operating environments.

The Eclipse SDK supports GB 18030, the new Chinese code page standard, onWindows XP and 2000, and Linux.

German and Japanese locales are tested.

BIDI support

SWT fully supports BIDI on Windows (only). On Linux GTK, SWT supports entering and displaying BIDI text.

The Eclipse SDK is a development environment targeted at technicalprofessionals - not an end user application. However, the Eclipse SDK tools willpermit technical professionals who are working in English to build Hebrew/Arabicend user Java programs which are themselves not based on the Eclipse SDK. TheBIDI support in the Eclipse SDK allows a Java programmer to work with BIDIstrings, code comments, etc. but the Eclipse SDK itself is not designed to belocalized for BIDI locales and its widget orientation can not be changed.

Compatibility with Previous Releases

Eclipse 3.0 will be compatible with Eclipse 2.0 and 2.1 to the greatestextent possible.

Compatibility of Release 3.0 with 2.0 and 2.1

Eclipse 3.0 will be compatible with Eclipse 2.0 and 2.1 to the greatest extent possible. The nature and scope of some of the key plan items are such that the only feasible solutions would break compatibility. Since breaking changes are a disruption to the Eclipse community, they cannot be taken lightly. We (the Eclipse PMC) will have an open discussion with the community before approving a proposed breaking change for inclusion in 3.0. In other regards, Eclipse 3.0 will be compatible with 2.0 and 2.1. We also aim to minimize the effort required to port an existing plug-in to the 3.0 APIs. We will provide a comprehensive Eclipse 3.0 Porting Guide that covers all areas of breaking API changes, and describes how to port existing 2.1 plug-ins to 3.0. Up-to-date drafts of the Eclipse 3.0 Porting Guide will be included with milestone builds so that it's possible to climb aboard the 3.0 release wagon at the early stages, or to estimate the amount of effort that will be involved in eventually porting existing plug-ins to 3.0.

API Contract Compatibility: Eclipse SDK 3.0 will be upwards contract-compatible with Eclipse SDK 2.0 and 2.1 except in those areas noted in the Eclipse 3.0 Porting Guide. Programs that use affected APIs and extension points will need to be ported to Eclipse SDK 3.0 APIs. Downward contract compatibility is not supported. There is no guarantee that compliance with Eclipse SDK 3.0 APIs would ensure compliance with Eclipse SDK 2.0 or 2.1 APIs. Refer to Evolving Java-based APIs for a discussion of the kinds of API changes that maintain contract compatibility.

Binary (plug-in) Compatibility: Eclipse SDK 3.0 will be upwards binary-compatible with Eclipse SDK 2.0 and 2.1 except in those areas noted in the Eclipse 3.0 Porting Guide. Eclipse 3.0 will include additional runtime compatibility mechanisms to provide effective binary API compatibility. Downward plug-in compatibility is not supported. Plug-ins for Eclipse SDK 3.0 will not be usable in Eclipse SDK 2.0 or 2.1. Refer to Evolving Java-based APIs for a discussion of the kinds of API changes that maintain binary compatibility.

Source Compatibility: Eclipse SDK 3.0 will be upwards source-compatible with Eclipse SDK 2.0 or 2.1 except in the areas noted in the Eclipse 3.0 Porting Guide. This means that source files written to use Eclipse SDK 2.0 or 2.1 APIs might successfully compile and run against Eclipse SDK 3.0 APIs, although this is not guaranteed. Downward source compatibility is not supported. If source files use new Eclipse SDK APIs, they will not be usable with an earlier version of the Eclipse SDK.

Workspace Compatibility: Eclipse SDK 3.0 will be upwardsworkspace-compatible with Eclipse SDK 2.0 or 2.1 unless noted. This means thatworkspaces and projects created with Eclipse SDK 2.0 or 2.1 can be successfullyopened by Eclipse SDK 3.0 and upgraded to a 3.0 workspace. This includes bothhidden metadata, which is localized to a particular workspace, as well asmetadata files found within a workspace project (e.g., the .project file), whichmay propagate between workspaces via file copying or team repositories.Individual plug-ins developed for Eclipse SDK 3.0 should provide similar upwardscompatibility for their hidden and visible workspace metadata created by earlierversions; 3.0 plug-in developers are responsible for ensuring that theirplug-ins recognize 3.0, 2.1, and 2.0 metadata and process it appropriately. Userinterface session state may be discarded when a workspace is upgraded. Downwardworkspace compatibility is not supported. A workspace created (or opened) by aproduct based on Eclipse 3.0 will be unusable with a product based an earlierversion of Eclipse. Visible metadata files created (or overwritten) by Eclipse3.0 will generally be unusable with earlier versions of Eclipse.

Non-compliant usage of API's: All non-API methods and classes, andcertainly everything in a package with 'internal' in its name, areconsidered implementation details which may vary between operating environmentand are subject to change without notice. Client plug-ins that directly dependon anything other than what is specified in the Eclipse SDK API are inherentlyunsupportable and receive no guarantees about compatibility within a singlerelease much less with an earlier releases. Refer to Howto Use the Eclipse API for information about how to write compliantplug-ins.

Eclipse Project Subprojects

The Eclipse Project consists of 3 subprojects. Each subproject is covered in itsown section:

For each subproject, the items listed reflect new features of the EclipsePlatform, or areas where existing features will be significantly reworked. Eachitem indicates the components likely affected by that work item (many itemsinvolve coordinated changes to several components). Numbers in parentheses linkto bugzilla problem reports for that plan item (querybugzilla for all 3.0 plan items).

Eclipse Platform subproject

The Eclipse Platform provides the most fundamental building blocks. Planitems reflect new features of the Eclipse Platform, or areas where existingfeatures will be significantly reworked. Many of the changes under considerationfor the next release of the Eclipse Platform address three major themes. Sinceeach theme has a number of items, the committed, proposed, and deferred planitems are grouped in sections by theme:

  • User experience theme - Improving Eclipse from the point of view of the end user.
  • Responsive UI theme - Making it easier to write Eclipse plug-ins that keep the UI responsive.
  • Rich client platform theme - Generalizing Eclipse into a platform for building non-IDE applications.

In addition, there are important Eclipse Platform improvements that do notnaturally fit into any of the above themes.

Theme: User Experience

Improving Eclipse from the point of view of the end user. This includesimproving both the 'out of the box' experience so that new users areproductive faster, and finding better ways to scale up to large numbers ofplug-ins without overwhelming the user.

Committed Items (Eclipse Platform subproject, User Experience theme)

Improve UI scalability. Despite efforts to ensure UI scalability with a large base of available tools, the Eclipse workbench still intimidates many users with long menus, wide toolbars, and lengthy flat lists of preferences. This problem is acute in large Eclipse-based products. The Platform should provide additional ways for controlling workbench clutter, such as further menu and toolbar customizability, distinguishing between novice and advanced functions, supporting different developer roles, and more specific object contributions for particular file types. [Platform UI, Platform Debug, JDT UI] [Theme: User experience] (37929) Work completed

Improve initial user experience. Users who are new to an Eclipse-based product can find their first experiences with it overwhelming, even daunting. The initial experience would be improved if a product could preconfigure the workbench to show only the subset of function that a new user really needs; welcome pages could be personalized for particular users roles or levels of experience. [Platform UI] [Theme: User experience] (37664) Work completed

Improve UI affordances. There are a number of areas of the UI where Eclipse is not providing enough cues to the user (e.g., no cue for available help, no cue for maximize/restore view, no cue for mandatory/optional fields in wizards). Make a systematic pass though the UI to improve its affordances. [Platform UI] [Theme: User experience] (37667) Work completed

Improve file encoding support. Eclipse 2.1 uses a single global file encoding setting for reading and writing files in the workspace. This is problematic; for example, when Java source files in the workspace use OS default file encoding while XML files in the workspace use UTF-8 file encoding. The Platform should support non-uniform file encodings. [Platform Core, Platform UI, Text, Search, Compare, JDT UI, JDT Core] [Theme: User experience] (37933) Work completed

Evolve the Eclipse user experience. Eclipse 3.0 should have a new look that makes more effective use of the capabilities of current desktop computers. This includes allowing the user to customize the workbench by creating floating toolbars and views, and supporting tear-off views and dockable toolbars where supported by the underlying window system. [Platform UI, JDT UI, SWT] [Theme: User experience] (37997) Work completed

Improve keyboard bindings. Several things should be done to improve keyboard bindings. First, custom key bindings currently work only in the main Eclipse window, and not in secondary windows like dialogs, wizards, and floating views (another plan item). For example, custom editor key bindings do not work in a text control in a preference dialog. Eclipse should support custom key bindings in the places where the user reasonably expects. Second, the key customization dialog should be improved. Finally, make a systematic pass through the UI to rationalize the initial set of key bindings. [Platform UI, SWT] [Theme: User experience] (37934) Work completed

Improve editor management. The current mechanism for switching between editors using tabs does not scale to having many open editors. Eclipse should provide a more scalable and stable, yet efficient, UI for switching between editors. [Platform UI] [Theme: User experience] (37670) Work completed

Improve text editor interaction. The text editor should support folding of text regions, which can be leveraged by the Java editor to collapse regions, such as an individual method's body or Javadoc comment, or the import declarations of a compilation unit. [Platform Text, JDT UI] [Theme: User experience] (37671) Work completed

Improve text editor presentation. The text editor should support an optional marginal change bar that can show how the current document differs from another of its states, such as a local history state or a repository version. Also, text editors should support for emphasizing a text region by changing its background color. [Platform Text, JDT UI] [Theme: User Experience] (37672) Work completed

Improve text editor typing. The set of key actions available in the text editor should be enriched with additional common operations like insert line, duplicate line, transpose, and convert to uppercase. The current JDT editor support for templates with variables should be generalized and pushed down so that it is available in all text editors. [Platform Text, JDT UI] [Theme: User experience] (37674) Work completed

Improve global text search/replace. Global text search should allow regular expressions in search patterns. The replace action should be more visible in the UI, and be easier to use in the case of bulk changes. [Platform Search] [Theme: User Experience] (37675) Work completed

Allow dynamic help content. Existing help content consists entirely of static HTML pages. Additional flexibility would be provided by allowing help content to include JSPs, possibly with access to the user's Eclipse environment. [Platform Help] [Theme: User experience] (37676) Work completed

Simplify update manager UI. User feedback indicates that the update manager UI is too powerful and occasionally confusing to users. It should be simplified in order to provide a clear path for the common tasks, embrace progressively disclosure, separate update search from platform configuration tasks, and make more economical use of screen real estate for properties. [Platform Update] [Theme: User experience] (37678) Work completed

Display HTML in a widget. In Eclipse 2.0 and 2.1, the only supported option for rendering HTML in the workbench is to use OLE to link to IE. This support is Windows only; there is no such option in other operating environments. Even on Windows, this only works for IE and not other browsers. There are already several Eclipse components that could benefit from HTML display functionality in a widget: welcome pages; update manager update site overview; hovers that show Javadoc. The Platform should provide a portable way to display HTML in a widget and support it in all operating environments. [Platform UI, SWT] [Themes: User experience] (36952) Work completed

Allow editors to open files outside workspace. A common request is to be able to use Eclipse to open a file that is not part of the workspace, or perhaps even one on a remote system. The operations and capabilities available on these 'outside of the workspace' files would need to be defined. [Platform UI] [Themes: User experience] (37935) Work completed

Improve workspace synchronization with file system. A file resource in the workspace gets out of sync when the underlying file in the file system is created, deleted, or rewritten outside of Eclipse. File resources usually remains out of sync until the user explicitly hits Refresh. The Eclipse Platform should provide ways to keep the in-memory representation in sync with the file system; for example, by hooking OS file system callbacks where available, and by polling for file system changes in a background thread. [Platform Core, Platform UI] [Theme: User experience] (36962) Work completed

Content-type-based infrastructure. The choice of editor is currently based on file name patterns. This is not very flexible, and breaks down when fundamentally different types of content are found in files with undistinguished file names or internal formats. For example, many different models with specialized editors get stored in XML format files named *.xml. Eclipse should provide infrastructure support for a notion of content type for files and resources. [Platform Core, Platform UI] [Theme: User experience] (60291) Work completed

Improve support for opening workspaces. Many users use multiple workspaces as a way to keep their different projects or work items separate. Currently, this requires launching Eclipse multiple times with different command line arguments, which is not particularly convenient for users. Moreover, when the command line argument is not specified, the workspace location defaults to a directory inside where the code for Eclipse is installed. Eclipse should improve how workspaces get opened, use a user-specific default workspace location more suitable for shared multi-user Eclipse installs, and facilitate switching between workspaces. [Platform Core, Platform UI] [Themes: User experience] (37681) Work completed

Add cheat sheets. A cheat sheet is an instance of a simple kind of workflow support used to help the user carry out a sequence of steps. For example, 'create and deploy a plug-in' is a multi-step process that could be made easier to follow if there was a guide, similar to a recipe that would track the user's progress and provide both descriptive text that explains the steps involved and integration with Eclipse to automate the process. The Welcome Page editor is a simple example of a cheat sheet. Provide a standard API for creating cheat sheets. [Platform UI] [Theme: User experience] (36946) Work completed

Proposed Items (Eclipse Platform subproject, User Experience theme)

None at this time.

Deferred Items (Eclipse Platform subproject, User Experience theme)

Launch Eclipse editor from outside Eclipse (60289)
Content-type-based editor lookup (37668)
Add table of contents support to wizards (36947)
Add project templates (36960)
Allow automation of common tasks (37936)
Support workspace checkpoint and rollback (36958)
Display HTML help infopops (37677)
Add capabilities (36959)
Improve local history (37679)
Add Eclipse automation (37680)
Aid ongoing learning (37666)
Provide a general purpose navigator (36961)

Theme: Responsive UI

Making it easier to write Eclipse plug-ins that keep the UI responsive. Areasfor improvement run the gamut from the UI becoming sluggish (or temporarilyfreezing) when blocking operations are done in the UI thread, to long-runningoperations like builds and searches which could be performed in the backgroundwhile the user continues to work.

Committed Items (Eclipse Platform subproject, Responsive UI theme)

Support concurrent activities. In Eclipse 2.0 and 2.1, certain operations like builds and searches always run synchronously and block the user at the UI from doing work until the build has completed. The Eclipse Platform should support operations running asynchronously in the background, so that the user is not forced to be entirely idle while long-running operations are in progress. This will likely require an improved concurrency architecture with more explicit rules. [Platform UI, Platform Core, Platform Text, JDT Core, JDT UI, PDE] [Theme: Responsive UI] (36957) Work completed

Improve update manager search. Update manager searches for new and updated features are done in the Eclipse client. These searches, which can be time- consuming, are done only on request, and the user cannot do anything in Eclipse until the search has completed. There are several ways update manager searches could be improved: provide update search APIs; allow searches to run asynchronously in the background; allow background searches to be scheduled periodically, or on startup; allow searches to be done on the server, thereby enabling sites to provide custom search implementations. [Platform Update] [Theme: Responsive UI] (37684) Work completed

Improve scalability for large help books. Improve scalability for large help books. Although the help system does deal well with large collections of topics distributed across many books, browser performance degrades severely when a large number of topics (2000+) are concentrated in a single book. This performance problem needs to be addressed, possibly by lazily loading navigation information. [Platform Help] [Theme: Responsive UI] (37685) Work completed

( recently committed item) Address platform-specific UI performance problems. There is a noticeable UI performance and responsiveness difference between Eclipse running on Windows and Eclipse running on Linux GTK, Linux Motif, or QNX Photon, all on the same hardware, with Windows clearly outperforming the others. Improvements made to SWT alone have not reduced this 'performance gap' enough. In order to improve Eclipse performance in the other operating environments, we need to make a concerted effort to determine the root causes (suspects include low-level thread scheduling and synchronization), and then take steps to address them. [SWT, Platform UI] [Theme: Responsive UI] (37683) Work completed

Proposed Items (Eclipse Platform subproject, Responsive UI theme)

The following work items are being actively investigated, but we are not yetable to promise any solution for this release:

Deferred Items (Eclipse Platform subproject, Responsive UI theme)

( recently de-committed item) Establish UI responsiveness targets. Eclipse should establish quantitative responsiveness targets for key user actions, such as opening an editor, popping up a view context menu, switching perspectives, etc. These guidelines should be supported by automated benchmarks that allow the responsiveness of the Eclipse UI to be measured and tracked. [Platform, JDT, PDE] [Theme: Responsive UI] (37682)

Theme: Rich client platform

Eclipse was designed as a universal tool integration platform. However, manyfacets and components of Eclipse are not particularly specific to IDEs and makeequal sense in non-IDE applications (e.g., window-based GUI, plug-ins, helpsystem, update manager). Certain changes, like factoring out IDE-specificfacilities, would allow the Eclipse Platform to be generalized into a richclient platform for building non-IDE applications.

Committed Items (Eclipse Platform subproject, Rich Client Platform theme)

Enable Eclipse to be used as a rich client platform. Eclipse was designed as a universal tool integration platform. However, many facets and components of Eclipse are not particularly specific to IDEs and would make equal sense in non-IDE applications (e.g., window-based GUI, plug-ins, help system, update manager). The Eclipse Platform should factor out and segregate IDE-specific facilities (e.g., everything having to do with workspace resources) so that a subset of it can be used as a rich client platform for building applications. [Platform Core, Platform UI, Platform Update] [Theme: Rich client platform] (36967) Work completed

Provide user settings. It should be possible to store user settings (preferences, compiler settings, repositories lists, etc.) that are not specific to a workspace separate from the workspace, so that they can be used in other workspaces or by other users. [Platform Core] [Themes: Rich client platform] (36965) Work completed

Remove configuration state from workspace metadata area. Feature and plug-in configuration state is currently stored in the metadata subdirectory of each workspace. This has the drawback that product configuration actions done in one workspace do not carry over to other workspaces. Configuration state should be moved out of the workspace into the install directory (single-user installs) or to a dedicated read-write product configuration area (shared multi-user installs). This would mean that configuration states would be in a known location for external tools to find. Different workspaces might still have different configurations, which could be achieved by referencing a named configuration state stored centrally. [Platform Update] [Theme: Rich client platform] (37686) Work completed

Provide update manager operations API. Most of the logic currently in the update manager UI should be pushed into a new operations layer. This operations layer would be to Update Core what JFace is to SWT. The APIs would enable update tasks to run headless, and would enable updates to be scripted. [Platform Update] [Theme: Rich client platform] (37688) Work completed

Allow uninstalling features. The update manager can disable features and plug- ins, but this is done without deleting their files. The update manager should keep track of the features and plug-ins that it installs, and fully support uninstalling them. [Platform Update] [Theme: Rich client platform] (37689) Work completed

Support adding and removing plug-ins dynamically. Installation and configuration of features and plug-ins currently only happens during Eclipse Platform startup. The plug-in registry should be made dynamic so that features and plug-ins can be added or removed without necessarily having to restart Eclipse. This will also entail adding mechanisms for handling the arrival and departure of extensions and extension points. Additional mechanisms such as services will be added to support the dynamic programming model. Alternative runtimes (e.g., OSGi) which offer explicit support for dynamic components will also be investigated and used as appropriate. Plug-in developers will likely require additional support from PDE in writing and debugging well-behaved dynamic plug-ins. [Platform Core, PDE] [Theme: Rich client platform] (37687) Work completed

Support product branding. Eclipse-based products need the ability to adopt a product-specific look and/or apply corporate branding. Eclipse should provide mechanisms to allow such customization. This must be done in such a way that plug-ins can be developed independent of any particular look, and can be shared across products with different looks. [Platform UI, SWT] [Theme: Rich client platform] (37693) Work completed

Allow plug-in deactivation. In order to scale to a large number of plug-ins, Eclipse does not activate a plug-in until its code is actually needed. However, once activated a plug-in remains active for the remainder of the session. Unfortunately, this means that an active plug-in will occupy memory space for its code and objects even if it is only used occasionally. Many users have sessions lasting days or weeks, and this bloat taxes processor memory and JVM performance. The analogy is a long play where the actors enter the stage on cue, but cannot leave it until the play is over. The Eclipse Platform should support plug-ins that can be safely deactivated when the user needs to recover valuable memory space. Another alternative is to provide a way to quietly shutdown and restart the Platform. [Platform Core, Platform UI] [Theme: Rich client platform] (36956) Work completed

Proposed Items (Eclipse Platform subproject, Rich Client Platform theme)

None at this time.

Deferred Items (Eclipse Platform subproject, Rich Client Platform theme)

Add a security model (37692)

Other Eclipse Platform Items

Committed Items (Eclipse Platform subproject, no theme)

Improve SWT accessibility support. In Eclipse 2.1, SWT controls tap in to the MSAA 1.3 accessibility support, allowing accessible UIs to be built with SWT on Windows. SWT accessibility support should be extended to GTK operating environments, and updated on Windows for MSAA 2.0. [SWT] (37694) Work completed

Improve SWT support for right-to-left languages. Allow the appropriate widget orientation for right-to-left languages. [SWT] (36951) Work completed

Remove dependency on Xerces. The Xerces plug-in currently provides XML support for the Eclipse platform. XML support is now incorporated into J2SE 1.4, and the presence of the Xerces plug-in can create conflicts. Eclipse Platform should consistently use the built-in XML support that ships with JDK 1.4, or possibly an alternative XML parser such as XMLPull which has a much smaller footprint. [Platform Core] (37696) Work completed

Improve Ant. Eclipse should allow the option of running Ant in a separately-specified JVM. [Ant Core, Ant UI] (37697) Work completed

Support HTML help pages in archives. A JAR or zip file is a convenient way to keep the large number of HTML files of a Javadoc web together. The Eclipse help system should also plug-ins to contribute (and refer to) HTML pages located in archives. [Platform Help] (37698) Work completed

Improve organizational control over product updates. In organizations where there are many users and installs of the same Eclipse product, the local administrator should have ways of managing how the product installs gets updated. For example, the local administrator should be able to proxy a remote update site and serve up supported updates hosted locally within the organization, thereby conserving bandwidth, minimizing download failures, and keeping things inside the organization's firewall. [Platform Update] (37702) Work completed

Provide working sets for help infocenter. Persistent help working sets were added in Eclipse 2.1. This support is not available is infocenters, where the user must still rely on searches (which are not persisted). Persistent working set support should be added to infocenters as well. [Platform Help] (37703) Work completed

Provide Swing interoperability. Eclipse plug-in developers often have existing Swing-based UIs that they would like to integrate with Eclipse. Eclipse should provide a wrapper that allows Swing widgets to be embedded within a SWT UI. [SWT] (37724) Work completed for Windows, Linux

Support multi-instance views. The workbench should support multi-instance views. A multi-instance view allows multiple instances to be opened side-by-side in a workbench window. [Platform UI] (50814) Work completed

Provide forms-based UI toolkit. Eclipse should provide a toolkit for building UIs similar to web page forms (a mixture of text, graphics, and simple controls like combo boxes, buttons, and entry fields). This style of UI is currently used for the GUI pages of PDE editors and for the Update Manager view. This toolkit would be an optional component suitable for use with the generic workbench in RCP configurations. [Platform UI] (50815) Work completed

Provide improved table and table tree widgets. Eclipse customers are finding that the existing table and table tree custom SWT widgets lacks required functionality, exhibit undesirable layout and resizing behavior, and are generally ill-suited for presenting large data models. Their largely unsuccessful attempts to define their own custom table tree widget have shown it to be a very challenging task requiring expert-level knowledge of SWT. SWT should provide improved table and table tree widgets. [SWT, Platform UI] (37998) Work completed

Port SWT to 64-bit operating environments. SWT currently only runs on 32-bit operating environments. SWT should be ported to run on current 64-bit operating environments. [SWT] (37721) Work completed

Make workspace builds more scalable. Owing to the build-all-projects-one-project-at-a-time nature of incremental project builders, large workspaces can take a long time to build when there are extensive inter-project dependencies. The build mechanism needs to be more scalable in such cases, possibly by introducing builds scoped to working sets. [Platform Core, Platform UI, JDT] (50816) Work completed

Support GUI test tools. SWT should provide common facilties and APIs so that GUI test tools can integrate with SWT-based UIs. [SWT] (37704) Work completed

Proposed Items (Eclipse Platform subproject, no theme)

None at this time.

Deferred Items (Eclipse Platform subproject, no theme)

Improve team control over resource operations (37722)
Support logical resources (37723)
Improve structure of existing documentation (36964)
Improve update manager downloading (37699)
Provide one-click update for Eclipse builds (37701)
Improve team API (37705)
Support native skinning in SWT (37706)
Make SWT work in a browser (37707)
Complete Mac OS X port (37708)
Support OpenGL (37709)
Support MDI (37710)
Improve message bundles (37712)
Allow infocenter to run on existing app server (37714)
Improve plug-in registry (37715)
Provide common command infrastructure (37716)
Provide better examples and snippets (37717)
Improve support for multi-page editors (37718)
Unify editors and views (37719)
Improve action contributions (36968)
Improve UI guidelines (37695)

Rejected Items (Eclipse Platform subproject)

None at this time.

(End of items for Eclipse Platform subproject.)

Java development tools (JDT) subproject

Java development tools (JDT)implements a Java IDE based on the Eclipse Platform. The following work itemsreflect new features of JDT, or areas where existing features will besignificantly reworked. The kinds of changes under consideration for the nextrelease of JDT address two general themes. The committed, proposed, and deferredplan items are grouped in sections by theme:

  • Extended Java family theme - Generalizing JDT to handle more than just Java source files.
  • User experience theme - Improving JDT from the point of view of the end user writing Java code.

In addition, there are important Eclipse Platform improvements that do notnaturally fit into either of the above themes.

Theme: Extended Java Family

Generalize JDT to handle more members of the Java family than just Javasource files. This includes widening to handle Java-like languages (such as JSPand SQLj), and embracing non-Java files containing references to Java languageelements (such as plug-in manifest files and J2EE deployment descriptors).

Committed Items (Eclipse JDT subproject, Extended Java Family theme)

Improve support for Java-like source files. JSP and SQLj are two instances of languages that use Java syntax. Eclipse should provide better support for Java-like source files. For instance, it should be possible to index these files so that Java search can find the Java declarations and references within; it should be possible to use Java code assist on the Java passages; refactoring should be able to take these files into account; the debugger should be able to step through the Java passages (JSR-045); error highlighting should be supported across sections; etc. [JDT Core, JDT UI, JDT Debug] [Theme: Extended Java family] (36939) Work completed

Support Java references outside Java code. References to Java elements in particular classes can show up in specific kinds of non-Java source files, such as plug-in manifest files (plugin.xml), extension point schema files, and Java launch configurations in the workspace. These references should also participate in Java operations like search, move, rename, and other refactoring operations. JDT will surface APIs that enable other plug-ins to contribute to and participate in these operations. [JDT Core, JDT UI, JDT Debug, PDE] [Theme: Extended Java family] (37937) Work completed

Proposed Items (Eclipse JDT subproject, Extended Java Family theme)

None at this time.

Deferred Items (Eclipse JDT subproject, Extended Java Family theme)

None at this time.

Theme: User Experience

Improve JDT from the point of view of the end user reading, writing, andnavigating in Java code.

Committed Items (Eclipse JDT subproject, User Experience theme)

Present logical view of Java objects in debugger. The current debugger always presents the internal structure of Java objects. For instances of standard data structures like java.util.HashMap, the Java debugger should be able to present a higher level logical view of the object (i.e., to show it as a table of key-to-value mappings). [JDT Debug] [Theme: User experience] (36942) Work completed

Improve refactoring. JDT should add new refactorings, such as add parameter, convert constructor to factory method, and extract superclass. JDT should also allow other plug-ins to contribute specialized refactoring operations, and provide refactoring APIs and infrastructure to make it possible for them to do so. [JDT Core, JDT UI] [Theme: User experience] (36943) Work completed

Improve code formatter. JDT should provide a new code formatter implementation that is more flexible and supports many more styles. [JDT Core] [Theme: User experience] (37657) Work completed

Mac Os End Key Binding Not Working For Eclipse Occurs

Improve editor code navigation. The Java editor should allow the user to navigate in the type hierarchy from a selected element. For instance, the editor should show override indicators (currently shown only in the outliner view), and allow direct navigation to the declaration of the overridden method. [JDT UI] [Theme: User experience] (37658) Work completed

Proposed Items (Eclipse JDT subproject, User Experience theme)

None at this time.

Deferred Items (Eclipse JDT subproject, User Experience theme)

None at this time.

Other JDT Items

Committed Items (Eclipse JDT subproject, no theme)

Improve shared working copies. There is mechanism that allows working copies of source files to be analyzed in the context of the rest of the Java model. Currently, shared working copies are hard to manage. Eclipse should simplify the management of working copies so that they can be used more transparently. [JDT Core] (37659) Work completed

Proposed Items (Eclipse JDT subproject, no theme)

None at this time.

Deferred Items (Eclipse JDT subproject, no theme)

Add early support for J2SE 1.5 features. The next feature release of J2SE is version 1.5 ('Tiger'), targeted to ship in the first half of 2004. While the contents of this release are still under discussion (JSR-176), this release is expected to contain extensions to the Java language, including generic types (JSR-014), enumerations, autoboxing, enhanced for loops, static imports (all JSR-201), metadata facility (JSR-175), and compiler APIs (JSR-199). Supporting these new language and compiler features will require major changes to the Eclipse Java compiler, JDT Core APIs, and JDT UI, and may suggest new Java 1.5-specific refactorings. Although Eclipse 3.0 might ship before J2SE 1.5 does, Eclipse should contain early support for J2SE 1.5 features wherever possible [JDT Core, JDT UI, JDT Debug] (36938) NOTE: We will continue to make available early access support for J2SE 1.5 in the form of replacement JDT plug-ins that can be installed into Eclipse 3.0 (Cheetah download page). Although this item is no longer under consideration for the 3.0 release, the item is still high-priority and the work is ongoing.

Harmonize Java source manipulation. The Java model is currently implemented in terms of JDOM, an early precursor of the AST facility added in 2.0. JDT will move to an AST-based implementation of the Java model, and deprecate JDOM. [JDT Core] (36941)

Rejected Items (Eclipse JDT subproject)

None at this time.

Gamegita for all made easygame

(End of items for Eclipse JDT subproject.)

Mac Os End Key Binding Not Working For Eclipse Without

Plug-in development environment (PDE) subproject

The plug-in developmentenvironment (PDE) consists of tools for developing plug-ins for theEclipse Platform. The following work items reflect new features of PDE, or areaswhere existing features will be significantly reworked.

Committed Items (Eclipse PDE subproject)

Add JUnit support for testing plug-ins. PDE should include JUnit-based support for testing plug-ins (an early version of this support is found in the optional org.eclipse.pde.junit plug-in). (37663) Work completed

Add support for new plug-in format. PDE should provide support for developing and deploying plug-ins with explicit OSGI bundle manifests. The goal is provide a seamless experience for developers working with a mix of traditional and new style plug-ins. (50921) Work completed

Improve PDE model implementation. PDE lazily builds detailed models of plug- ins, plug-in fragments, features, extension point schemas. Once loaded, these models are kept in memory until shut down. This approach does not scale up to working with large numbers (1000s) of plug-ins. PDE model elements should be changed to use a more lightweight representation. (37660) Work completed

Proposed Items (Eclipse PDE subproject)

None at this time.

Deferred Items (Eclipse PDE subproject)

Help developers tune plug-in performance (36944)
Support context-sensitive help for plug-ins (36945)
Improve PDE editors (37661)
Improve plug-in debugging (37662)

Rejected Items (Eclipse PDE subproject)

None at this time.

(End of items for Eclipse PDE subproject.)

I’ve been using Mac OS X daily since 2001 when I purchased my Titanium PowerBook and I still can’t get used the home and end key behavior.

If, like me, you want Home to send you to the start of the line and not to the top of the document then create a file called DefaultKeyBinding.dict in your ~/Library/KeyBindings folder (might need to create that folder too) with the following contents:

This remapping does the following in most Mac apps including Chrome (some apps do their own key handling):

  • Home and End will go to start and end of line
  • ShiftHome and ShiftEnd will select to start and end of line
  • CtrlHome and CtrlEnd will go to start and end of document
  • ShiftCtrlHome and ShiftCtrlEnd will select to start and end of document

Note that you will need to reboot after creating this file for it to take effect.

If you have a PC keyboard with LED back-lighting and would like the scroll-lock, num-lock or caps-lock LEDs on when using your Mac check out my free SetLEDs for Mac

[)amien