Where can I find a complete list of keywords (of the form ${ ... } ) that can be used in netbeans "code template"

Question

The complete list of keywords that are legal in creating code templates in Netbeans would be accompanied by some documentation, making the "list" a reference. A line from the reference might look like:

    ${cursor}       says to put the cursor at this point in the generated line

---

Working examples might be included in the reference, such as:

    User-defined word to invoke the template:         edfold

The template as it would appear in the Netbeans 8.2 RC > Tools > Options > Editor > Code templates tab:

    ${no-indent}//
    //  <editor-fold  desc="***** ${cursor} *****" >
    //

How it works: When I type edfold and hit the Tab key, the template is pasted into my document at the cursor position and looks like the following:

    //
    //  <editor-fold  desc="***** @ *****" >
    //

The cursor is positioned between the 5th and 6th asterisks that follow desc, so that I can then type whatever brief documentation that I wish, if any.

---

So where is the list of such keywords and their syntax and meaning? Such as:

${cursor} ${selection} ${no-indent} ${arg} ${Type} and who knows how many more

It just hit me that there are OTHER keywords, two of which I unwittingly used above (I noticed them in someone else's code template and figured out how to use them):

    desc
    editor-fold

Surely there are other such identifiers to include in the reference.

---

By the way, the code template above is cute (or not) but is useless without a companion code template:

keypress: endfold

Code template in editor:

// </editor-fold> ---------------- ${cursor} -------------------

Wherever the first inserted code template is located in your code, the second template must be below it. There is a "collapse" symbol "-" at the left of the first template. Clicking it collapses the code between the two templates. The symbol then changes to "+" and will expand the collapsed code when clicked.

---

EDIT I just found this equivalent code template to the edfold and endfold pair just completed. Easier to code, up to a point, and harder to learn to use, but worth it, in the long run. Just highlight text to "hide" by folding, look for the line with the "Light Bulb", click Alt+Enter, and click "Code Folding". (Ctrl+Z to undo!)

But please see my (much better) Answer than this (was a) Question below.

Answer 1

Egg on my face... Googled topic, scanned all hits WAY too fast. In particular, "netbeans 8.2 code templates" pointed to this page involving PHP (think Java), which contained a lot of invaluable info about PHP that applies directly to Code Templates in Netbeans 8.2.

So, that link is part of a manual of sorts for learning how to create Code Templates for Netbeans 8.2 (in particular, and PHP in general).

The reference that I asked for--complete list of keywords (of the form ${ … } )--implies a list of all keywords or reserved words, like ${cursor} and ${selection} that permeate the list of provided Code Templates. But in a sense, that is the list. It is exactly those two Reserved Names. There are no others. Short list.

In the list of provided Netbeans Code Templates, there are a LOT of words that share the same $(...) syntax, but most are placeholder names or parameters that you decide the name and (probably-simple) meaning of.

If a code template contains, for example, class ${className}, the word class is Java code and ${className} is a parameter or placeholder. When the IDE expands the template, class is entered and ${className} turns into class_name, which the IDE automatically selects for editing, suggesting for you to enter the name of the new Java class being defined.

This non-trivial, but understandable, code template and much of what follows it explains much of the process for creating Code Templates. The heading Inserting the code template with code completion ends the explanation, but here is a sort of note of summary from further down:

    The syntax of a "code template parameter" is a dollar sign, $, followed by the
    parameter's definition between curly brackets {...}. Within this syntax, template 
    parameters have one of four forms:

    * A reserved name that gives processing instructions to IDE (cursor or selection, only)
    * An arbitrary placeholder name, such as ${SomeName}
    * A descriptive parameter name [that hints at its meaning]
    * Pre-defined parameters (??)