For preferences with combo boxes - Use the drop-down arrow to make a selection. Alternately, to cycle through and select a setting, double-click on the option. If you're using keyboard shortcuts, you can toggle a combo box up and down using F4 or Alt+Up and Alt+Down, respectively, and then use the Up and Down keys to make a selection.

For preferences with numeric text boxes - Click on the option and type directly in the text box to change the value. If you're using keyboard shortcuts, use one of the keys Right, Space, or F4 to enable the text box.

For color preferences - Double-click on the color block or press F4, and the color picker is displayed.

For file and directory path preferences - Double-click on the value or press F4, and a directory picker is displayed. If you have specified a file name or directory in a field and wish to change it back to the default, press the Delete key. This clears the value and SlickEdit® Core will use the default setting.

Each time the dialog is displayed, the focus is in the Search box at the top left of the dialog. Use Tab to navigate through the elements on the dialog.

Use the Right and Left keys to expand and collapse nodes in the tree.

Prefix matching is supported for tree nodes and in property sheets. For example, if the Appearance node category is expanded and focus is in the tree, you can type "F" and the first node beginning with that letter is selected (Fonts). Likewise, if focus is at the top of the Window → SlickEdit Preferences → Appearance → General property sheet, you can type "C" and the first option beginning with "C" is selected (Cursor style). Note that only the current visible hierarchy of the tree is searched, and on property sheets, property group headings are not included in the search.

Use Alt+O to jump from the option tree to the option panel.

On property sheets, use F4 to toggle combo boxes up and down, enable numeric text boxes, and display color and directory pickers.

Press Enter to save changes and close the Preferences dialog, or Esc to prompt for changes before closing the dialog.

General - These color preferences are for syntactic elements displayed in editor windows. They correspond to items defined in the language's Color Coding specification. For more information, see Color Coding.

Selections - These color preferences are for text selections and the current line in the editor control.

Comments - These colors are used to highlight different comment types defined in the Color Coding specification for the current language. For more information, see Color Coding.

Strings - These colors are used to highlight different string types defined in the Color Coding specification for the current language. For more information, see Color Coding.

Numbers - These colors are used to highlight different numeric types defined in the Color Coding specification for the current language. For more information, see Color Coding.

HTML and XML -

Modifications - These color are used to show change bars in the left margin, as well as in DIFFzilla® to highlight changes.

Highlighting - These color are used for various types of text highlighting used to display search results.

Margins - These colors are used for various marker lines and the left-hand indicator margin.

Application Colors - The following colors are used to configure specific elements of the GUI displayed outside of the editor windows themselves.

Scheme - Specify the symbol coloring scheme to use from the drop-down list. Several predefined schemes are available or you can define your own. See Selecting a Symbol Coloring Scheme for more information.

Rule list - The symbol coloring rules are presented in order of precedence. Symbol coloring rules are matched in order from the top to bottom. For a symbol to match a rule, it must be the first rule in the symbol coloring scheme that matches all of the requirements. See Color Rules for detailed descriptions of each of the standard symbol coloring rules shipped with SlickEdit® Core.

Rule name - This is the name of the rule. Press Tab or Enter to apply your changes after editing the name of the currently selected symbol coloring rule.

Color and font attributes - Use this panel to select how symbols which match the current symbol coloring rule will be rendered in the editor.

Symbol types - A matching symbol's type must be one of the specified types. The special *SYMBOL NOT FOUND* type is used to identify symbols which Context Tagging® can not locate. See Symbol types for detailed descriptions of each symbol type.

Symbol attributes - The attributes can be either required, ignored, or disallowed. A matching symbol must have all the required attributes, and none of the disallowed attributes. See Symbol attributes for detailed descriptions of each symbol attribute.

Regular expression matching - In addition to the symbol type and attribute specifications, you can further refine a symbol coloring rule by adding a Class name or Symbol name regular expression, using the regular expression syntax of your choice. The class name regular expression is matched against the name of the scope (class, package, struct) which a symbol is defined in. Do not confuse this with the name of the scope in which the symbol is used. The symbol name regular expression is matched against the name of the symbol. For example, a Wildcards expression of "vs*" would match all symbols starting with the characters "vs". Case sensitivity for the regular expression matching is regulated by the language's case-sensitivity. See Color Coding for more information.

*SYMBOL NOT FOUND* - This is a special symbol type used when a symbol found in the editor is not recognized by Context Tagging®. This type is useful to have in a single rule as a rudimentary form of error checking.

Annotation or attribute instance - This is metadata. Examples include the use of a Java annotation or C# attribute in code.

Annotation or attribute type - This is the definition of a metadata type. Examples include a Java annotation type or C# attribute class.

Class constructor - This is a constructor for a class in an object-oriented language. Note that in some languages, constructors are treated as functions with a Constructor symbol attirbute.

Class destructor - This is the destructor for a class in an object-oriented language. Note that in some languages, destructors are treated as functions with a Destructor symbol attirbute.

Class property - This is a property variable within a class type, as found in C#, Visual Basic .NET, and Managed C++.

Class type - This type is used for classes in object oriented languages.

Constant - This is a named literal constant.

Container variable - This is used for a container (or group) variable, as found in COBOL data sections. A container variable is like an transparent structure type.

Control or widget - This is used for a control type in languages that have built-in support for user interfaces, such as Slick-C®.

Database - This type is used for the name of a database. It only applies to SQL dialects.

Database column - This type is used for the column name of a database table. It only applies to SQL dialects.

Database cursor - This type is used for a database cursor type. It only applies to SQL dialects.

Database index - This type is used for a database index name. It only applies to SQL dialects.

Database table - This type is used for a database table name. It only applies to SQL dialects.

Database trigger - This type is used for a database trigger definition. It only applies to SQL dialects.

Database view - This type is used for a database view name. It only applies to SQL dialects.

Enumerated type - This type is used for type names of enumerated types.

Enumeration value - This type is used for the names of the constants defined in an enumerated type.

Event table - This type is used for event tables, as found in languages that have built-in support for graphical user interfaces, such as Slick-C®.

File descriptor - This is a COBOL file descriptor declaration.

Form - This type is used for form or dialog names, as found in languages that have built-in support for graphical user interfaces, such as Slick-C®.

Friend relationship - This type is used for friend relationships. Note that friend relationships refer to other symbols, so a symbol coloring rule that colored friend relationships would only color the actual friend relationship declaration, not uses of the symbol that depended on the friend relationship.

Function - This type is used for function names, both global functions and class member functions.

Function prototype - This type is used for a function declaration, both global and abstract class member functions.

Global variable - This type is used for global variables and variables declared at the namespace or package level. It does not apply to local variables or member variables.

Interface type - This is a class interface declaration, as found in most object-oriented languages.

Library - This is a library module type, as found in Pascal.

Local variable - This is a local variable, that is, a variable declared within the scope of a function.

Member variable - This is a class member variable or the member of a structured or record type or variable declared in a COBOL data section.

Menu - This type is used for menu names, as found in languages that have built-in support for graphical user interfaces, such as Slick-C®.

Mixin construct - This type is used for class mixin statements, as found in the D Programming Language. Note that, like friends, mixin's are only detected at the point of use. A function or variable pulled into a class through a mixin will not be considered as a mixin type.

Nested function - This type is used for functions which are nested inside of other functions or procedures, as found in Pascal, Ada, and other languages.

Nested procedure or paragraph - This type is used for procedures which are nested inside of other functions or procedures. It is also used for COBOL paragraphs.

Package import or using statement - This type is used for an import or using statement. Note that that imports are only detected at point of use. A class or function pulled into a module through an import will not be considered as an import type.

Package, module, or namespace - This type is used for package, module, or namespace names used to divide code into logical boundaries.

Parameter - This type is used for the names of formal parameters to a function or procedure. It can also be used for template parameter names in class templates.

Preprocessor include - This type is used for a preprocessor include statement or COBOL copy book.

Preprocessor macro - This type is used for a preprocessor macro (for example, a #define in C and C++).

Procedure or command - This type is used for procedure names, both global and class members. It is also used for command names in languages that support command types.

Procedure prototype - Type type is used for procedure declarations, that is, forward declarations of procedures.

Program - This type is used for program names, as found in Pascal, Cobol, and other languages.

Statement label - This type is used for statement labels within functions or in assembly language code.

Structure type - This type is used for struct types or record types.

Task - This type is used for tasks, as found in Ada and Verilog dialects.

Type alias - This type is used for a type definition name, or type alias.

Union type - This type is used for union types, also known as variant types.

01 level in Cobol linkage section - Variables at the 01 level in COBOL data sections are given this flag to indicate that they are at the top-most level of the data section. This may be a very useful attribute to configure specialized coloring for if you are a Cobol programmer.

Abstract - This attribute is set for abstract classes as well as pure-virtual methods or abstract methods within a class definition.

Ambiguous prototype/var declaration - In C and C++ and some other languages, there is an ambiguity in syntax between function prototype declarations and variable declarations with initializers. See the example below, not knowning type information, it could either be the prototype for a function named ambiguousDeclaration which returns a ClassName and takes one parameter of type Argument, or a variable named the same thing which is of type ClassName and is initialized with Argument.

                ClassName ambiguousDeclaration(Argument);
            

Class constructor - This attribute is set for functions or procedures which act as a class constructor or static initalizer for a class type.

Class destructor - This attribute is set for class destructors.

Const - This attribute is set for variables which are declared with a const return type, meaning that they can not be modified, or that they point to data which can not be modified. It is also set for class member functions that are declared as const, meaning that the function is not allowed to modify members of the class or call other non-const functions.

Created by preprocessor macro - This attribute is set for symbols which are declared in a section of code that was expanded from a preprocessor macro, for exmaple, in C++ where it is common to use preprocessor macros to generate code.

External function or data - This attribute is set for functions or global variables which are declared as extern, meaning that they are defined in another module.

Final - This attribute is set for functions which can not be overridden in derived classes. It is also set for variables, for example, in Java, which are initialized only once and do not change.

Forward declaration - This attribute is set for a forward declaration of a symbol. Since there is a separate symbol type for function prototypes, this attribute is primarily used for forward declarations of classes and structured types.

Ignore/placeholder - This attribute is set for symbols which are merely placeholders, and should be ignored by symbol searches.

Inline function - This attribute is set for functions which are marked as inline, meaning that instead of being compiled into separate functions, their function bodies may be pulled inline at the point where the function is called.

Member of class or package - This attribute is set for symbols which are declared inside a class, package, namespace, or other structured type.

Mutable - This attribute is set for variables which are declared as mutable in, for example, C++.

Native code function - This attribute is set for functions which are implemented in native code, for example, in Java, where certain functions are implemented in DLLs for better performance.

Opaque enumerated type - In C++, the constants declared in an enumerated type do not need to be qualified with the name of the enumerated type. In this sense, they are transparent. In certain other languages, enumeration constants need to be qualified with the name of the enumerated type. These are considered as opaque. This attribute is set for enumerated types whose constants are opaque.

Overloaded operator - This attribute is set for functions whose purpose is to overload standard language operators, such as multiplication, division, assignment.

Package scope - This attribute is set for symbols which are scoped at the package or namespace level. They are visible within the package they are declared in, but considered as private outside of that package. Package scope is the default scope in Java if no other scope (public, protected, or private) is specified.

Part of an external file - This attribute is set for symbols which are declared in an external file which was parsed as part of the process of parsing the current file. For example, this attribute is set for symbols in COBOL copy books.

Partial class - This attribute is set for classes which are marked as partial, meaning that the complete class definition may be spread across several modules.

Private scope - This attribute is set for symbols declared in classes which have private scope. These symbols are visible within the class they are declared in, but not in derived classes, and not outside of the declaring class.

Protected scope - This attribute is set for symbols declared in classes which have protected scope. These symbols are visible within the the class they are declared in, derived classes, but not outside of the declaring class.

Public scope - This attribute is set for symbols declared in classes which have public scope. These symbols are visible everywhere. Note that in many languages, public scope is the default scope if none is otherwise specified (private, protected, or package).

Static - This attribute is set for symbols which are marked as static. The static attribute can be applied in several contexts:

Synchronized - The synchronized attribute is set for functions which are marked as synchronized, meaning that the function is not re-entrant and can not allow two threads to enter it at the same time.

Template or generic - The template attribute is set for class and function templates, also known as generic functions or generic classes.

Transient data - The transient attribute is set for variables which contain non-persistent data. This is a Java-specific attribute.

Unnamed structure - This attribute is used for anonymous structure types and other anonymous (unnamed) types.

Virtual function - This attribute is used for virtual functions in class definitions.

Volatile - This attribute is used for variables and functions which are marked as volatile. A volatile variable is one whose value can change unpredictably, such as a memory address that echos the value of the system clock. A volatile function is one that accesses a volatile variable.

Local variable - This rule matches local variables within a function, excluding static local variables. In most schemes, variable types are colored green, mirroring the color used for variables in the Defs view.

Static local variable - This rule matches static local variables. It is colored slightly more blue that the variable rule, in order to indicate the static (or frozen) nature of the local variable.

Parameter - This rule matches function parameter names and template argument names. Like local variables, they are colored green, matching the color used for variables in the Defs view.

Public member variable - This rule matches public member variables. In most schemes, variable types are colored green, mirroring the color used for variables in the Defs view.

Package member variable - This rule matches package scope member variables. In most schemes, variable types are colored green, mirroring the color used for variables in the Defs view.

Protected member variable - This rule matches protected member variables. In most schemes, variable types are colored green, mirroring the color used for variables in the Defs view. Protected and private members are shown in italic in order to indicate their limited scope.

Private member variable - This rule matches private member variables. In most schemes, variable types are colored green, mirroring the color used for variables in the Defs view. Protected and private members are shown in italic in order to indicate their limited scope.

Public static member variable - This rule matches public member variables. In most schemes, variable types are colored green, mirroring the color used for variables in the Defs view. It is colored slightly more blue, in order to indicate the static nature of the variable.

Package static member variable - This rule matches package scope member variables. In most schemes, variable types are colored green, mirroring the color used for variables in the Defs view. It is colored slightly more blue, in order to indicate the static nature of the variable.

Protected static member variable - This rule matches protected static member variables. In most schemes, variable types are colored green, mirroring the color used for variables in the Defs view. It is colored slightly more blue, in order to indicate the static nature of the variable. Protected and private members are shown in italic in order to indicate their limited scope.

Private static member variable - This rule matches private static member variables. In most schemes, variable types are colored green, mirroring the color used for variables in the Defs view. It is colored slightly more blue, in order to indicate the static nature of the variable. Protected and private members are shown in italic in order to indicate their limited scope.

Global variable - This rule matches global variables. In most schemes, variable types are colored green, mirroring the color used for variables in the Defs view.

Static global variable - This rule matches static global variables, which are visible only within the current module. In most schemes, variable types are colored green, mirroring the color used for variables in the Defs view. It is colored slightly more blue, in order to indicate the static nature of the variable.

Global function - This rule matches global functions and functions declared within namespaces and packages. In most schemes, functions are colored magenta, mirroring the color used for functions, procedures, and prototypes in the Defs view.

Static global function - This rule matches static global functions. In most schemes, functions are colored magenta, mirroring the color used for functions, procedures, and prototypes in the Defs view. It is colored slightly more blue, in order to indicate the static nature of the function.

Class constructor - This rule matches class constructors. Class constructors, destructots, and class names are colored blue, mirroring the color used for Class constructors and destructors in the Defs view.

Class destructor - This rule matches class destructors. Class constructors, destructots, and class names are colored blue, mirroring the color used for Class constructors and destructors in the Defs view.

Public member function - This rule matches public class member functions. In most schemes, functions are colored magenta, mirroring the color used for functions, procedures, and prototypes in the Defs view.

Package member function - This rule matches package scope class member functions. In most schemes, functions are colored magenta, mirroring the color used for functions, procedures, and prototypes in the Defs view.

Protected member function - This rule matches protected scope class member functions. In most schemes, functions are colored magenta, mirroring the color used for functions, procedures, and prototypes in the Defs view. Protected and private members are shown in italic in order to indicate their limited scope.

Private member function - This rule matches private scope class member functions. In most schemes, functions are colored magenta, mirroring the color used for functions, procedures, and prototypes in the Defs view. Protected and private members are shown in italic in order to indicate their limited scope.

Public static member function - This rule matches public static class member functions. In most schemes, functions are colored magenta, mirroring the color used for functions, procedures, and prototypes in the Defs view. It is colored slightly more blue, in order to indicate the static nature of the function.

Package static member function - This rule matches package scope static lass member functions. In most schemes, functions are colored magenta, mirroring the color used for functions, procedures, and prototypes in the Defs view. It is colored slightly more blue, in order to indicate the static nature of the function.

Protected static member function - This rule matches protected static class member functions. In most schemes, functions are colored magenta, mirroring the color used for functions, procedures, and prototypes in the Defs view. It is colored slightly more blue, in order to indicate the static nature of the function. Protected and private members are shown in italic in order to indicate their limited scope.

Private static member function - This rule matches private static class member functions. In most schemes, functions are colored magenta, mirroring the color used for functions, procedures, and prototypes in the Defs view. It is colored slightly more blue, in order to indicate the static nature of the function. Protected and private members are shown in italic in order to indicate their limited scope.

Public class property - This rule matches public class property names. In most schemes, properties are colored cyan, mirorring the color used for properties in the Defs view.

Package class property - This rule matches package scope class property names. In most schemes, properties are colored cyan, mirorring the color used for properties in the Defs view.

Protected class property - This rule matches protected class property names. In most schemes, properties are colored cyan, mirorring the color used for properties in the Defs view. Protected and private members are shown in italic in order to indicate their limited scope.

Private class property - This rule matches private class property names. In most schemes, properties are colored cyan, mirorring the color used for properties in the Defs view. Protected and private members are shown in italic in order to indicate their limited scope.

Class - This rule matches Class names. Class names are colored blue, mirroring the color used for class constructors in the Defs view.

Template class - This rule matches template or generic class names. Class names are colored blue, mirroring the color used for class constructors in the Defs view.

Abstract class - This rule matches an abstract class name. Class names are colored blue, mirroring the color used for class constructors in the Defs view.

Interface class - This rule matches class interface names. Class and interface names are colored blue, mirroring the color used for class constructors in the Defs view.

Struct - This rule matches a structured type, such as a struct in C/C++ or a record type in Pascal or Modula. Structure types are colore blue-green.

Union or variant type - This rule matches union types or variant record types in Pascal. They are colored yellow, mirroring the color used for union types in the Defs view.

Type definition or alias - This rule matches type definitions or type aliases.

Preprocessor macro - This rule matches preprocessor macro names. The color inherits it's color from the preprocessor keyword color of the base color scheme.

Package or namespace - This rule matches a package or namespace name. In most schemes, they are colored red, mirroring the color used for package, namespace, and programs in the Defs view.

Symbolic constant - This rule matches symbol constants used to give names to constant literal values. In most schemes, they are colored gray, mirroring the color used for constants in the Defs view.

Enumerated type or constant - This rule matches enumerated types and constants defined in enumerated types. In most schemes, they are colored cyan, mirroring the color used for enums in the Defs view.

Statement label - This rule matches statement labels. They are colored blue, matching the color used for labels in the Defs view.

Symbol not found - This rule is present as a catch-all for the case where a symbol is not found by Context Tagging®. It is colored bright red in order to indicate that there is a fair likelihood that the source file contains an error.

Command - This field shows the command that you have selected to bind.

Key Sequence - This field is used to enter the key sequence or mouse event that you want bound to the command. For example, to enter the key sequence Ctrl+W, literally press the Ctrl and W keys together. It accepts literal keyboard/mouse input, so you cannot edit the text or use key functions such as backspacing or tabbing in and out of the field. You must use the red X button to clear the filter.

Mouse Event button - Click this button located next to the red X button to pick a mouse event to use for the binding. If the event involves pressing a modifier key or keys, such as Ctrl, Alt, Shift, Cmd, Ctrl+Alt, etc., in conjunction with a mouse click, for example, Ctrl+RButtonDn, press the modifier key(s) when clicking the Mouse Event button. Then the Select Mouse Event dialog shows a list of modifier-prefixed mouse events. After selecting the mouse event you want to look up, click OK. The Key Sequence field updates to show the selected mouse event.

Bind - After entering the key sequence or mouse event, click this button to save the binding and close the dialog. Prior to clicking Bind, you may want to assign the binding to a specific language editing mode (see below).

Cancel - Click this button to cancel the binding operation and close the dialog.

Advanced - Click this button to expand the language editing mode settings. By default, all new bindings are assigned to the "default" language editing mode, which means that the binding will work in all modes. To assign the binding to a specific language editing mode, select Bind to mode and click the language editing mode from the drop-down list.

Edit - click this button to edit the language for the specified file.

Add - click this button to add a new file to the list.

Delete - click this button to remove the selected file from the list.

Edit - click this button to edit the selected pattern.

Add filename - click this button to add a pattern that matches a filename. You will be prompted for the filename and the language it should be associated with.

Add path - click this button to add a pattern that matches a path. You will be prompted for the path and the language it should be associated with.

Add pattern - click this button to add a pattern on your own. You will be prompted for the painter and the language it should be associated with. You can use this button to add patterns for filenames or paths, but it is easier to enter them using the buttons described, above.

Delete - click this button to remove the selected pattern from the list.

Move up - click this button to move the selected pattern higher in the list.

Move down - click this button to move the selected pattern lower the list.

Radio buttons - When all languages do not have the same setting for a radio button set, then none of the radio buttons will be selected.

Check boxes - A check box option will be filled in with a square to indicate that all languages do not have the same value for the setting.

Text boxes - Text boxes will be left blank to indicate that all languages do not share the same value.

Combo boxes - When all languages do not have the same value for a combo box setting, the combo box will say Languages Differ in the text area.

Property Sheet Preferences - If an option found in a property sheet does not have the same setting for all languages, then the property value will say Languages Differ.

First line is top - When this option is selected, the first line of the text selection is used as the first line of the comment. The top border is not drawn. Otherwise the open comment characters will appear on their own line.

If this option is selected for the preceding code sample, the comment will instead be formatted as follows:

/*             if (!enabled) {
                  tabState = TIS_DISABLED;
               }
*/

Last line is bottom - When this option is selected, the last line of the text selection is used as the last line of the comment. The bottom border is not drawn. Otherwise the open comment characters appear on their own line.

Using the same example, if this option is selected, the comment will be formatted as follows:

/*
               if (!enabled) {
                  tabState = TIS_DISABLED;
               }                           */

Left and Right - Characters that you specify in these boxes are literally inserted to the left and right of the text on each line of the selection when you use SlickEdit® Core to create a line comment. The placement of the Left characters can be controlled through the Location preferences below. Characters specified in the Right box are placed and aligned vertically at the end of the longest line of text in the selection. For example, if the Left and Right boxes both contain the characters //, clicking Format → Comment Line comments out the example code as follows:

//             if (!enabled) {            //
//                tabState = TIS_DISABLED;//
//             }                          //

Location - Mutually exclusive location preferences control where characters specified in the Left box are placed:

             //if (!enabled) {
             //   tabState = TIS_DISABLED;
             //}

Automatically expand doc comments - When this option is selected, SlickEdit® Core automatically inserts a skeleton doc comment when you type comment start characters and then press Enteron a line directly above a function, class, or variable. The type of skeleton that is inserted is based on your start characters and style settings.

Edit expansion - Click this button to open the Doc Comment Editor, where you can define and edit the templates that are inserted when doc comments are expanded. See Modifying Doc Comment Templates for more information.

Extend leading border - Put a check in this box to precede each line with the leading characters from the previous line. This is useful if you like to have an asterisk in the first column of your doc comments, for example.

Split line comments - If selected, when you press Enter in the middle of a line comment, a new line comment will automatically be started on the new line. For example:

// The quick brown fox [CURSOR_HERE]jumped over the lazy dog.

Pressing Enter will result in:

// The quick brown fox
// [CURSOR_HERE]jumped over the lazy dog.

Extend line comments - If selected, when you press Enter at the end of a line containing a line comment, and there is also an aligned line comment on the line before or after the current line, a new line comment will automatically be started on the new line. For example:

// The quick brown fox
// jumped over the lazy dog.[CURSOR_HERE]

Pressing Enter will result in:

// The quick brown fox
// jumped over the lazy dog.
// [CURSOR_HERE]

Join comments when joining lines - If selected, when you press Delete at the end of a line containing a line comment to join the current line with the next line, and the next line is also a line comment, the line comment characters will automatically be deleted. For example:

// The quick brown fox [CURSOR_HERE]
// jumped over the lazy dog.

Pressing Delete will result in:

// The quick brown fox[CURSOR_HERE] jumped over the lazy dog.

Auto-list members - If selected, typing a member access operator (for example, "." or "->" in C++) will trigger SlickEdit® Core to display a list of the members for the corresponding type. To access this feature on demand, press Alt+Dot. If you use this feature on demand, and you are not in a member expression, this feature will display a list of locals, global variables, current class members, etc.

Show comments - If selected, the comments are displayed for the currently selected symbol in the list displayed by List Members. When a symbol has multiple definitions or overloads, and multiple sets of comments, the comments will indicate that you are looking at item "< 1 of n >". Click on the arrows or use Ctrl+PgUp and Ctrl+PgDn to cycle through the comment sets.

Completion on space - If selected, pressing the spacebar when List Members is displayed will insert the longest unique matching prefix from the symbols in the list. For example, if the list contains FLAG_CHAR and FLAG_LONG, then typing FL<Alt+Dot><spacebar> completes the line of code up to FLAG_. If this option is not selected, use Ctrl+Space when List Members is displayed to perform completion.

Space always inserts space - If selected, pressing the spacebar when List Members is displayed will insert the current item and a space in the list after the current item. If this option is not selected, pressing the spacebar will only insert the current item with no extra space.

Insert open parenthesis - If selected, selecting an item in the list inserts the current item in the list and any extra characters that are required by the symbol. For example, an open parenthesis is inserted after a function name for languages that require an open parenthesis after a function name. For C++, the less-than symbol (<) is inserted after a template class name.

Preserve identifier to right of cursor - When set to Preserve, only the identifier characters before the cursor are replaced with an item selected from a List Members dialog, while identifier characters after the cursor are preserved. When this option is set to Replace, identifier characters following the cursor are replaced with the item selected from a list members dialog. When this option is set to Preserve for auto list members only, trailing identifier characters are preserved for auto list members but not when listing members on demand by pressing Alt+Dot.

For example, if List Members is active and the current line is as follows:

this->foo<cursor_here>Bar

Then if this option is set to Preserve and you choose a symbol named "foodForThought" from the List Members list, the line will be changed to:

this->foodForThought<cursor here>Bar

If this option is set to Replace, doing the same would result in:

this->foodForThoughtBar<cursor here>

Auto-list compatible values - If selected, compatible variables are automatically listed after you press the spacebar after assignment operators and return statements. Global (non-module) variables are not listed. This only affects C, C++, and Java. To access this feature on demand, press Alt+Comma.

Use strict case-sensitivity rules - if checked, matches symbols with the same case as what was entered.

Auto-display parameter information - If selected, the prototype and comments for a function are automatically displayed when a function operator such as the open parenthesis is typed, and the current argument is highlighted within the displayed prototype. To access this feature on demand, press Alt+Comma.

Show comments - If selected, comments are displayed when Parameter Info is displayed. When a symbol has multiple definitions, and multiple sets of comments, the comments will indicate that you are looking at item "< 1 of n >". Click on the arrows or use Ctrl+PgUp and Ctrl+PgDn to cycle through the comment sets.

Auto-insert matching parameter - If selected, when Parameter Info is displayed and the name of the current formal parameter matches the name of a symbol in the current scope of the appropriate type or class, the name is automatically inserted. When the name is inserted, it is also selected so that you can type over it, or you can type Comma, Space, Tab, or a closing parenthesis to use the automatically inserted parameter.

Auto-list compatible parameters - If selected, compatible variables are automatically listed when parameter info is active and typing the arguments to a function call. Global (non-module) variables are not listed. This only affects C, C++, and Java. To access this feature on demand, press Alt+Comma. See Auto List Compatible Parameters for more information.

Pad parentheses - If selected, a space is inserted after the open parenthesis when a parameter name is automatically inserted. In addition, if you type a close parenthesis after an automatically inserted parameter, it will insert a space before the close parenthesis.

Insert space after comma - If selected, a space is inserted after the comma when a parameter name is automatically inserted, such as myfun(a, b, c).

Prioritize navigation to - Here you can specify if you prefer to navigate directly to a symbol's definition (proc) or declaration (proto). If Prompt is selected, the Select Symbol Dialog is displayed, prompting you for both definitions and declarations. In any case, if you use Ctrl+Dot to jump to a symbol, you can cycle through the alternate symbols by pressing Ctrl+Dot repeatedly. You can step backwards through the list of matches by pressing Ctrl+Comma. However, once you reach the first match, Ctrl+Comma will then pop you back to your original location, where you were before you pressed Ctrl+Dot.

Independent of the settings for these preferences, in the following circumstances, SlickEdit® Core will jump directly to the definition or declaration.

This behavior is particularly convenient for C++ programmers to navigate from a function to its prototype and vice versa. See Symbol Navigation for more information about navigating through your code.

Ignore forward class declarations - When this option is enabled, Go to Definition filters out forward class declarations, and only shows the actual class definitions and declarations.

Use strict case-sensitivity rules - when selected, factors upper/lowercase letters as part of the matching criteria.

Attempt to filter out non-matching function overloads (expensive and slow) - when selected, SlickEdit Core attempts to filter out functions with the same name but with different function signatures. As stated, this can slow down the matching.

Show info for symbol under mouse - When selected, as the mouse cursor floats over a symbol, the information and comments for that symbol are displayed.

Highlight matching symbols under cursor - When selected, all occurrences of the current symbol under the cursor in the buffer are highlighted. The highlight color is controlled by the Symbol Highlight screen element (Window → SlickEdit Preferences → Appearance → Colors). Advanced configuration preferences are available. See Cursor on Symbol Shows All Uses in File for more information.

Use strict case sensitivity when completing identifiers - when selected, factors upper/lowercase letters into the matching criteria.

Token type - Select from the following token types:

Identifiers - All Context Tagging® operations use this set of characters to find identifiers in the code that is being analyzed. Therefore, it is important to set the start and follow characters in a manner that is consistent with the language specification. In most languages, identifiers can contain digits, but they cannot start with them. For example, in C/C++, start characters are "a-zA-Z_$" and follow characters are "0-9".

New - Click this button on the Tokens tab to add one or more words. Separate each word with a space.

Delete - Deletes selected items in a list box.

Get - Click this button to add words by selecting the file that contains the keywords that you want to add.

Hex numbers

Octal and binary numbers

Floating point numbers

Do not color code numbers (HTML) - When this option is selected, text such as 123.4E24 and 123ABC is not color coded in number color. By default (for most languages set in the Language tab), 123.4E24 and 123ABC is color coded in number color.

Allow underscores in integers (Ada) - When this option is selected, text such as 12_34 is color coded in number color.

Double quoted strings

Single quotes

Backquoted strings (Perl, Bourne shell, C shell) - When this option is selected, backquoted shell expansion strings such as ~ls -d /home/~ are color coded in string color.

Language specific - To avoid requiring complicated BNF for defining color-coding, some hardware language-specific adjustments have been added. You may be able to use one of these language-specific settings for another language, but there's no guarantee it will work.

Color Code Line Numbers (Basic/COBOL) - When this option is selected, indicates that leading line numbers should be color-coded in line number color.

Backslash escapes next character (Bourne Shell) - Backslash escapes the character that follows. This is useful for UNIX shell scripts which use \" to indicate that the double quote is not the start a string.

Here Document (UNIX Shells/Perl) - Activates support for HERE documents. Note that if you prefix your terminator with one of our lexer names, you will get embedded language color-coding. Example of a HERE document in Perl, where HTMLEOF is used as the terminator to get HTML embedded language color-coding:

print <<HTMLEOF;
<HTML><HEAD><TITLE>...</TITLE></HEAD>
<BODY>
...
</BODY>
</HTML>
HTMLEOF

Unknown languages are color-coded in string color. Embedded language colors are user-definable.

Color identifiers followed by '(' as a function - For language such as C++, Java, and Slick-C®, an identifier followed by a parenthesis always indicates a function.

Special coloring for 'package' and 'import' statements (Java) - When this option is selected, the Java syntax package and import statements are supported. This option is forced on for the lexer name Java. You must add the package and/or import keywords to your keyword list in order for this option to have any effect.

Preprocessing keywords can appear anywhere - When this option is selected, preprocessing keywords are color-coded even if they are not only preceded by white space.

Identifiers may start with a number (COBOL) - When this option is selected, identifiers may start with one or more decimal digits. By default, leading decimal digits indicate a number.

@''####'' Unicode strings (C#) - When this option is selected, text in the form of @"any text" is coded as a string.

Treat everything after 0x1a as comments (end of file) - Historically, DOS used 0x1a to mark the end of the file. When checked, SlickEdit Core will treat all characters after 0x1a as comments.

Color inactive code regions (C/C++ Preprocessing, eg. #if 0) - When checked, uses a single color for inactive code regions, instead of applying normal color coding.

New Line comment - Click this button to define new single-line comments.

New Multi-line comment - Click this button to define new multi-line comments.

Delete - Click this button to remove the selected comment definition from the list.

MultiLine comment - The following preferences apply to multi-line comments:

Line Comment - The following preferences apply to single-line comments:

Tag names - List box containing tags for HTML or XML. To add or delete tags, use the New and Delete buttons below this list box.

>>Attributes - List box containing attributes that belong to the tag selected in the Tag names list box. To add or delete attributes, use the New Attr and Delete buttons below this list box.

Attribute values - List box contains the values for the specified tag and attribute. To add or delete a value, use the New Value and Delete buttons below this list box.

For all tags - When this option is selected, the values in the Attribute valuelist box are applied to all tags that have the specified attribute.