Proposal to plan for "Milestone Releases" on the way to KDE4

[Carsten Pfeiffer]

On Thursday 26 January 2006 01:08, Zack Rusin wrote:

> Once you start
> working absolutely without a mouse you just can't go back. It's so much
> more convenient and less tiring.

Can't stress this enough! This is also what the Eclipse guys figured out, so 
they made almost everything accessible with a shortcut.

So here's my list of favourite Eclipse features (speaking of the Java IDE part 
of Eclipse):

Filemanagement:
============
- you can open any class simply by entering its name in an "Open Type" dialog 
(Ctrl-Shift-T)
  - the dialog does auto-completion, so entering just a few characters is 
usually sufficient
  - auto-completion even supports wildcards (enter e.g. I*LabelPro to get 
IViewerLabelProvider)
- open any file in the same way with Ctrl-Shift-R
- switch between open files with Ctrl-E (small dropdown listing all open 
files, enter the filename to select, again with auto-completion)
- Alt-Arrow-Left and Alt-Arrow-Right work like a webbrowser history, allowing 
you to navigate between previous edit-locations in different files.


Editor:
=====
- move lines up and down with Alt-Arrow keys. Note, they will automatically be 
indented according to the current block.
- delete a single line with Ctrl-D
- F3 jumps to the declaration of a field, class, method, variable, parameter
- show the structure of the class in a quick-outline dialog with Ctrl-O, 
allowing you to quickly navigate to a certain member (selectable via 
auto-completion). E.g. to go to method doFooSomething(int), you just press 
Ctrl-O doFo [return]
- Ctrl-T on a type declaration, type reference, method declaration or method 
reference shows you a quick type hierarchy dialog.
  E.g. to know which classes inherit from a class, just put the cursor 
anywhere on the class name and press Ctrl-T. Select one of them with 
auto-completion to go to its definition.
  Press Ctrl-T again in the dialog to get the supertype hierarchy including 
implemented interfaces
  When pressing Ctrl-T on a method (decl/ref), the quick type hierarchy will 
show you the class hierarchy with only those subclasses enabled that have 
reimplemented that method, allowing you to quickly jump to reimplementations 
(Ctrl-T again for the supertype hierarchy)
- Ctrl-Shift-G on an identifier finds all references to this field, method, 
type, ... anywhere in all your open projects.


Completion in Editor:
===============
- Ctrl-Space on an identifier offers completions for that element (types, 
methods, fields, ... , even showing the documentation of those in a tooltip)

Completion with code templates (relieves you of tedious typing):
- Ctrl-Space in the class body offers a list of all methods from superclasses 
that can be reimplemented, selectable via auto-completion. The result would 
look like
    public boolean equals(Object obj)
    {
        // TODO Auto-generated method stub
        return super.equals(obj);
    }
  The creation of get- and set-methods is offered in the same way.

Templates can be user-defined, lots of predefined ones are available, e.g. 
"for" to generate a for loop, looping over an array or collection or 
"toArray", leading to this nice construct

toA[Ctrl-Space] (arrow down to select "toArray" -> return)
	(type[]) collection.toArray(new type[collection.size()])


QuickFixes:
========
When having a compilation error in the code, you can have Eclipse 
automatically fix that error by pressing Ctrl-1 and choosing one of the 
proposed fixes (if any).

E.g when writing new code, you can focus on the current method body while 
having eclipse create stubs for all related things that you need:

private int doSomething()
{
	MyOtherClass other = new MyOtherClass();
(Eclipse would now complain that MyOtherClass does not exist => Press Ctrl-1 
in that line and select "Create class 'MyOtherClass'", opening the New-Class 
wizard. After having created the class, go on.

	int myResult = other.calculateSomething(Math.PI);
(Press Ctrl-1 and select "Create method calculateSomething(double) in 
MyOtherClass.java'" to have that method generated automatically as

    public void calculateSomething(double pi)
    {
        // TODO Auto-generated method stub
        
    }

Other options are e.g. to cast to float or change the method signature of the 
method if it would already exist with a float-parameter instead of double.


I could go on with automated refactorings, the call hierarchy view etc. but 
the list is long enough already. To bad all this is only available for 
Java...

Cheers,
Carsten
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 447 bytes
Desc: not available
URL: <http://mail.kde.org/pipermail/kde-core-devel/attachments/20060126/235e4236/attachment.sig>