[cdt-ui-dev] Discussion: the outline view

[Magnus Ihse <magnus.ihse@xxxxxxxxx>]

I've written down some of my thoughts about the outline view in CDT into a 
wish-list. (http://bugs.eclipse.org/bugs/show_bug.cgi?id=26482)
I think the overview is a important area where CDT has one of its greatest 
chances to prove its superiority over other IDEs and editors. Since this 
list has been rather quiet, I thought perhaps I could start a discussion of 
what kinds of features that would be interesting and nice to have in the 
outline view.

This is my current, personal wish-list (directly copied from the feature 
request on bugzilla):

The outline view is one of the absolute strength of the JDT, which I've 
been using a lot. I'd really love to see a outline view as good as the JDT 
one in CDT. (Note: I'm using C so not all of this is relevant to C++).

Some things that I'm missing:
 * The icons from JDT. Perhaps I'm biased by using the JDT for so long, 
but I find the JDT icons much more expressive, easier to understand and 
(sorry to say) more aesthetically pleasing to look at. Some features of the 
JDT icons I miss:
   - The distinction red square/green circle between public/private 
(corresponding to static/non static in C).
   - The distinction between fields/methods (variables/functions in C) by 
using a "hole" in the icon.

 * It would be nice to have different icons for different kinds of 
declarations (not only struct and union), such as:
  - variable definition
  - typedef definition
  - variables defined within a struct or union
Also, having different icons for "pure" defines and macro definitions would 
be helpful, since they often have different purposes.

 * Also, in JDT, when a method declared in an interface is implemented, a 
small triangle appears as a icon "decoration". Even though the concept of 
implementation in Java doesn't exist in C, a definition of a previously 
declared function is similar to "implementation" in Java. I believe that 
showing this "implementation triangle" on functions in the CDT overview 
would be very helpful. (It helps you catch declaration problems, such as 
non-static methods not declared in the corresponding .h file, or when you 
by mistake name a function the same as a function already declared in a 
included .h file.)

 * In JDT, the type of a variable is shown in the outline, e.g. "foo : 
int". I miss this in the CDT outline view. Also, the type of the arguments 
to a function is shown in the declaration. In Java, this is more or less 
required, since you can overload the same method name with different 
arguments, which you can't in C (ignoring C++ for now :)). But it would 
still be very informative and useful in the CDT view.

 * In JDT, declaration attributes such as "static", "synchronized" etc are 
shown as icon "decorations". It would be great if C attributes such as 
"volatile" etc are represented in the same way.

 * The #include icon is, imho, really ugly and not especially 
representative, in contrast to the clear and slick import icon in JDT. 
(Includes are not so important, and should not draw the users attention, as 
the big blue icon does.)
Also, it would be nice if the common practice import statements at the top 
of the source code could be grouped together, similar to the JDT outline. 
(Even if this is a language requirement in Java, but not in C, making it 
easier to represent in the JDT.) Perhaps also showing slightly different 
icons for system includes (<...>) and user includes ("...").

In short, the overview should give the user a clear, concise view of all 
relevant structural features of the code.


/Magnus