Hello!

As the topic states I have been using eclipse most of my professional life and only started using netbeans in february, I'm really liking it overall, not least how absolutely gorgeous the IDE is to look at, but I have one issue I would really love to get "resolved".

I [b]really[/b] miss the way that code completion works in eclipse, and have been unable to find any setting for my particular issue with the completion in NetBeans. This is in spite of the fact that NetBeans sometimes behave exactly the way I want - something which leads me to believe that the type of functionality I am after could potentially only be a matter of editing the right configuration file.

To elaborate...

What I am after does not have a formal "name" (afaik), so I think it is best to just describe how it works with the one usecase where NetBeans behaves as I prefer. In my examples below I use $c to indicate where the cursor is currently located.

Starting up NetBeans and creating a new class with a main() method, followed by typing:
[code]System.out.println$c[/code]
...continuing with Ctrl+Space for intellisense selection options and picking the first one which has an argument [b](Object x)[/b]. Following up by pressing Enter expands the written expression to the following
[code]System.out.println(<marked argument-stub to overwrite $c>);[/code]

One can now write whichever argument is preferred to replace the argument-stub, which followed by Enter this results in:

[code]System.out.println(myVar);$c[/code]

The key points here are in the details.
1) On selecting an intellisense alternative - the line is completed including a trailing semicolon, and it only needs my input for replacing the autocompleted argument-stubs [b]c[/b].
2) When I have overwritten the argument-stubs I can smoothly continue with pressing Enter, but (and this is important) [b]without[/b] breaking the line up - my cursor is placed [b]after[/b] the semicolon at the end of the row, meaning I can press Enter again and continue with a new statement on the next row. 

All of these things provide me with a very smooth user experience, greatly appreciated! 
Basically I would like this type of code-completion [i]behaviour[/i] in many more places of NetBeans. Specifically being able to hit Enter efter a method- / functioncall to complete my statement, without breaking the line into two rows. Not least I would also like it in both JavaScript and HTML editor.

Here are the problems I'm currently presented with, due to not having the desired behaviour.

[u]Issue 1[/u]
The only issue with the Java-aspect of this functionality is if one [b]doesn't[/b] trigger the intellisense to select one of the overloaded methods. If instead we write the opening parentheses (autocompleting the closing parentheses, placing the cursor inside) and enter a string, followed by pressing Enter, instead of the Enter-keypress moving us smoothly out of the method-call as before, NetBeans now breaks the line to the next row, leaving me with the following:

[code]
System.out.println("testing"
						+ "$c")
[/code]

I would greatly prefer if it instead interpreted my Enter keypress as me being done with the argument/methodcall, and placed me after the method parentheses as when I had picked an intellisense alternative (but without [b];[/b] ) like so:

[code]System.out.println("testing")$c[/code]

[u]Issue 2[/u]
Same issue but when coding JavaScript. If i write a function-call, including the parentheses for it, then input an argument for it, followed by pressing [b]Enter[/b] or [b]Tab[/b], I would like the cursor to jump out of the parentheses without breaking the line into two rows.

Current result:
[code]		console.log("just testing\n\
$c")[/code]

Expected result:
[code]		console.log("just testing")$c[/code]

[u]Issue 3[/u]
This is basically the same issue, but in its HTML-editing representation. If I begin by writing:
[code]<sp$c[/code]
.. intellisense kicks in and shows me the option of inserting a <span> tag. On pressing selecting the span-tag from intellisense I would expect the following:

[code]
<span>$c</span>[/code]
..which followed by [b]Enter or Tab[/b] should result in
[code]<span>"text written after picking the span-tag"</span>$c
[/code]

.. instead, after the intellisense-selection, I end up with this

[code]<span$c[/code]

Like I wrote in the beginning, I have a strong feeling all of this is achievable in NetBeans, perhaps by simply editing the correct configuration-file?

I apologize for the long post, but since I have been unable to find a solution and don't know exactly what to call this functionality, I felt I had to describe it thoroughly so as to not be misunderstood.

Sincerely,
Cole.