GNU Info
(idlwave)Completion
Completion
==========
IDLWAVE offers completion for class names, routine names and
keywords. As in many programming modes, completion is bound to
`M-<TAB>'. Completion uses the same internal information as routine
info, so when necessary it can be updated with `C-c C-i'
(`idlwave-update-routine-info').
The completion function is context sensitive and figures out what to
complete at point. Here are example lines and what `M-<TAB>' would try
to complete when the cursor is on the position marked with a `*'.
plo* Procedure
x = a* Function
plot,xra* Keyword of `plot' procedure
plot,x,y,/x* Keyword of `plot' procedure
plot,min(* Keyword of `min' function
obj -> a* Object method (procedure)
a(2,3) = obj -> a* Object method (function)
x = obj_new('IDL* Class name
x = obj_new('MyCl',a* Keyword to `Init' method in class `MyCl'
pro A* Class name
pro * Fill in `Class::' of first method in this file
!v* System variable
!version.t* Structure tag of system variable
self.g* Class structure tag in methods
If the list of completions is too long to fit in the `*Completions*'
window, the window can be scrolled by pressing `M-<TAB>' repeatedly.
Online help (if installed) for each possible completion is available by
clicking with `Mouse-3' on the item. Items for which system online
help (from the IDL manual) is available will be displayed in a
different font. For other items, the corresponding source code or
DocLib header is available as help text.
The case of the completed words is determined by what is already in
the buffer. When the partial word being completed is all lower case,
the completion will be lower case as well. If at least one character is
upper case, the string will be completed in upper case or mixed case.
The default is to use upper case for procedures, functions and keywords,
and mixed case for object class names and methods, similar to the
conventions in the IDL manuals. These defaults can be changed with the
variable `idlwave-completion-case'.
- User Option: idlwave-completion-case
Association list setting the case (UPPER/lower/Capitalized/...) of
completed words.
- User Option: idlwave-completion-force-default-case (`nil')
Non-`nil' means, completion will always honor the settings in
`idlwave-completion-case'. When nil (the default), lower case
strings will be completed to lower case.
- User Option: idlwave-complete-empty-string-as-lower-case (`nil')
Non-`nil' means, the empty string is considered lower case for
completion.
- User Option: idlwave-keyword-completion-adds-equal (`t')
Non-`nil' means, completion automatically adds `=' after completed
keywords.
- User Option: idlwave-function-completion-adds-paren (`t')
Non-`nil' means, completion automatically adds `(' after completed
function. A value of `2' means, also add the closing parenthesis
and position cursor between the two.
- User Option: idlwave-completion-restore-window-configuration (`t')
Non-`nil' means, restore window configuration after successful
completion.
- User Option: idlwave-highlight-help-links-in-completion (`t')
Non-nil means, highlight completions for which system help is
available.
Object Method Completion and Class Ambiguity
............................................
An object method is not uniquely determined without the object's
class. Since the class part is usually omitted in the source code,
IDLWAVE considers all available methods in all classes as possible
completions of an object method name. For keywords, the combined
keywords of the current method in all available classes will be
considered. In the `*Completions*' buffer, the classes allowed for
each completion will be shown next to the item (see option
`idlwave-completion-show-classes'). As a special case, the class of an
object called `self' object is always the class of the current routine.
All classes it inherits from are considered as well where appropriate.
You can also call `idlwave-complete' with a prefix arg: `C-u
M-<TAB>'. IDLWAVE will then prompt you for the class in order to
narrow down the number of possible completions. The variable
`idlwave-query-class' can be configured to make this behavior the
default (not recommended). After you have specified the class for a
particular statement (e.g. when completing the method), IDLWAVE can
remember it for the rest of the editing session. Subsequent
completions in the same statement (e.g. keywords) can then reuse this
class information. Remembering the class works by placing a text
property in the object operator `->'. This is not enabled by default -
the variable `idlwave-store-inquired-class' can be used to turn it on.
- User Option: idlwave-support-inheritance (`t')
Non-`nil' means, treat inheritance with completion, online help
etc.
- User Option: idlwave-completion-show-classes (`1')
Non-`nil' means, show classes in `*Completions*' buffer when
completing object methods and keywords.
- User Option: idlwave-completion-fontify-classes (`t')
Non-`nil' means, fontify the classes in completions buffer.
- User Option: idlwave-query-class (`nil')
Association list governing query for object classes during
completion.
- User Option: idlwave-store-inquired-class (`nil')
Non-`nil' means, store class of a method call as text property on
`->'.
- User Option: idlwave-class-arrow-face
Face to highlight object operator arrows `->' which carry a class
text property.
automatically generated by info2www version 1.2.2.9