Configuration & Customization

Index

• Splash Banner at Startup
• Views Automatically Opened on Startup
• Language Setting
• Mouse Button Definition
• Keyboard Mappings
  • Auxiliary Numeric Keypad
  • National Characters
    • Compose Key Sequences
    • Dead Key Processing
    • Special Characters Dialog
  • Alt and Command Keys
  • Keyboard Commands
  • Default Keyboard Command Setup
  • Function Keys
• Changing the View Style Appearance
  • Existing Stylesheets
  • The Default Style
  • Creating your own Stylesheet
  • What's in a StyleSheet
• Color Allocation Strategy
• Host specific Setup
  • Printer Setup
• Other Configuration Settings
  • Autoloaded Classes
  • Lazy Loading
  • Compiler Switches
  • Logging doIt Execution
  • Changing Transcript's Buffer Size
  • Turning off Messages
  • Tooltips (Fly-By-Help)

Splash Banner at Startup

To show a different splash image, invoke Smalltalk/X with a "--banner fileName" argument. The "fileName" argument must be the name of a bmp-bitmap file with 8-bit depth.

Standalone applications can show a different splashscreen (if programmed to do so), by defining the name of the bitmap file in their ProjectDefinition class.

Views Automatically Opened on Startup

You can add additional expressions to start any other view or application automatically; for example, if you like a System Browser to come up automatically, add a line such as:

    SystemBrowser open.
    !

    UserPreferences current systemBrowserClass open.
    !

In previous versions, all setup was done in a single "smalltalk.rc" startup file.
For easier customization this has been split into a bunch of individual files: all display specific startup has been extracted into a file called "display.rc", all host specific things are now found in "host.rc", and the keyoard mapping is defined in "keyboard.rc".
Finally, a file called "private.rc" is read which should open initial applications.
This separation allows the use of global startup files, combined with per-user-private additional definitions. If you installed "smalltalk.rc" in a standard place, the changes made there will affect all ST/X users. Therefore, it is wise to add private things to either a local "smalltalk.rc" or to your local "private.rc". (see "installing Smalltalk/X").

Notice:

these files consists of Smalltalk expressions in fileOut format. This means, that expressions have to be separated by period (".") characters. Also, groups of expressions (so called chunks) have to be separated by an exclamation mark ("!") character, and any exclamation mark inside a chunk needs to be duplicated (also inside string constants).
The text within a chunk must be a syntactically valid methods code (i.e. an optional local variable declaration, followed by statements).
Exclamation marks within such a chunk (also in strings or comments) have to be escaped by doubling them.

Language Settings

Resourcefiles are package or class specific; for every package, a corresponding resource file is present in its "resources" folder, but individual classes may provide additional translations in their own <className.rs-file.

Because most translations are shared between classes (think of the text for the "Cancel"-Button), shared translations are collected in package-specific resource files (for example, one resource file contains all translations for all classes in the "stx:libview" package). Class specific resources may overwrite those, in case there are conflicts or multiple meanings. Sometimes, a single word can be used in english, whereas a non-english language may use different wrds depending on the context; for example, the english word "change" may need different translations depending on wether the verb or the subject is meant.

The classes initialization methods read those translations and keeps the mappings in a class variable named "classResources". When an instance is created, it copies those into its "resources" instance variable. From this, appropriate substitution strings are retrieved upon request. (see the ResourcePack class for more details).

The choosen translation is controlled by Smalltalk expressions as embedded in the resource file itself (not in the program). Typically, these expressions check for the value of the Smalltalk language-setting and translate as appropriate (actually, the resource file dispatches to a language specific resource file)(**).

This language setting is initialized at startup time from the setting of the shell environment variable LANG (or whatever the OperatingSystems mechanism for the language setting is).

To start ST/X in german under unix, you have to:

    setenv LANG de

    LANG=de
    export LANG

You can change the strings and/or add additional translations by editing the corresponding resource files, which are found in "resources" directories below the corresponding widget class package directories.
As an example, the resource definition for the ModalBoxes ok-Button is:

    #if Language == #de
    'ok'    'ok'
    'abort' 'Abbruch'
    #endif

    #if Language == #fr
    'ok'    'd''accord'
    'abort' 'canceler'
    #endif

    ... and so on ...

If you add new definitions for languages which are not yet included, or can give better translations, please help the author by sending (mailing) changed resource files back.
You will help the author, others and yourself (since your strings will be present in the next upgrade and you don't have to change things again).

Fonts

For non-western languages, you need a font which is able to represent those characters - of course.
Most other languages should work with a standard ISO8859 font (but watch out, some standard X fonts only include the 7bit ascii subset, missing national characters).

You will be warned if you switch to (say) japanese and your display does not provide a corresponding font. In this case, you should get at least one JIS or Unicode encoded font and perform whatever installation is required to add it to the display's supported font list.

The way fonts are added is very system specific.
Under Unix, using the X-Window system, you have to:

	xset +fp directory-name
	xset fp rehash

The newest ST/X version also supports nice looking XFT fonts (these are scalable TrueType fonts). The ST/X package includes a number of usable free fonts, in case your system lacks those. Please take a look at the "support/fonts" folder, and possibly add it to your XFT font folder path.

Under older Windows systems, you had to install an appropriate language pack - if you still use one of those, please refer to Microsoft documentation for more information.

Notes:

(*) national strings

some classes may still contain untranslated strings, and translations for many other languages are still to be added. Expect more in upcoming versions.

(**) conditional resources

nothing prevents you from controlling the translation by any other condition. You can, for example, translate strings depending on the user's name, hostname or whatever.

Mouse Button Definition

    #( #select #menu #menu)

To change the classes default, use:

    Screen buttonTranslation:#(menu #menu #select)

    Screen current buttonTranslation:(#menu #menu #select)

• #select for selection (text, button-vies etc)
• #menu for the middleButtonMenu
• #paste to paste the contents of the copyBuffer

    Screen current buttonTranslation:#(select #menu #paste)

Later versions of ST/X (or your application) may offer more choices.

Be aware that portable applications should not depend on multiple mouse buttons to exist; always write your application to be controllable with 2 buttons. (even the assumtion that 2 buttons exist is not true for all machines. ST/X will be changed to allow emulation of additional buttons with shift/control or alt-key modifiers).

Your "display.rc" file contains a default button translation and (commented) alternatives.

Notice that "Screen current" is equivalent to "Display" iff only a single display connection is active. In the above and all following examples, these two can be used interchangable in single screen setups (which is the default anyway).

Keyboard Mappings

Since keyboards are very display (-hardware) specific, different mappings are required for different workstation types. Therefore, the "display.rc" file tries to find out the type of display the system is running on (using the display's name) and dispatches to "keyboard.rc" and one of the "d_xxx.rc" files.
Both files manipulate the keyboardMap:

• "display.rc"
  defines common commands which are valid on all keyboards. For example, the binding of CMD-X to the cut edit function is done here.

• "d_xxx.rc"
  sets mappings for extra keys. For example, on sun keyboards you will find keys labeled copy or paste. Binding of those extra keys to corresponding edit functions in done here.

To create your own "d_xxx.rc" file, take any existing as a template and copy it to "d_displayname.rc".
For example, if your display is marvin:0, you have to call your file "d_marvin.rc".
(use "echo $DISPLAY" to find out what the display name is). If DISPLAY is something like ":0", ":0.0" or "local:0", you should take your hostname instead.

In general, the keyboardMap is modified using expressions like:

    |map|

    map := Display keyboardMap.
    map bindValue:$[ to:#Alt8.
    map bindValue:#Find to:#Cmds.
    ...
    !

Keyboard modifiers (i.e. "ALT", "CMD" or "CTRL" are included in the raw name;
for example, pressing "ALT" together with the "a" alpha key, gives you the "#Alta" key event.
If shift is pressed in addition, you will get "#AltA".

Take the expressions found in existing files as a template. If you are not certain, what the names of the raw keys are (i.e. what to use after to:), open an EventMonitor, which traces events and prints them on the standard output (give it some input and see).

Example

To acomplish this, add the following to your "private.rc":

    |map|

    map := Display keyboardMap.
    map bindValue:#BeginOfLine to:#Home.
    map bindValue:#EndOfLine   to:#End.
    !

Currently, the following symbolic key functions are implemented
(but not all are bound to keys by default):

    key-name              function                                implemented in

    Paste                 paste the contents of the copyBuffer    EditTextView
    Insert                paste the contents of the copyBuffer    EditTextView
    Copy                  copy the selection into the copyBuffer  TextView
    Cut                   cut the selection                       EditTextView
    Again                 repeat last cut or replace              EditTextView
    Replace               replace selection by copyBuffer         EditTextView

    PreviousPage          previous page                           ListView
    NextPage              next page                               ListView
    HalfPageUp            scroll up half of a page                ListView
    HalfPageDown          scroll down half of a page              ListView

    ScrollUp              scroll up one line                      ListView
    ScrollDown            scroll down one line                    ListView

    Find                  open a box for pattern to search        TextView
    FindNext              search forward (selection or pattern)   TextView
    FindPrevious          search backward (selection or pattern)  TextView
    SearchMatchingParent  position cursor on matching parenthesis EditTextView

    BeginOfText           position to begin of text               ListView, EditTextView
    EndOfText             position end of text                    ListView, EditTextView
    BeginOfLine           position cursor to begin of line        EditTextView
    EndOfLine             position cursor to end of line          EditTextView
    NextWord              position cursor on next word            EditTextView
    GotoLine              open box to query for lineNumber        EditTextView

    SelectWord            select word under cursor                EditTextView
    SelectMatchingParents select area between cursor and matching EditTextView
    SelectAll             select the whole text                   TextView
    SelectToEnd           select from cursor to end of text       EditTextView
    SelectFromBeginning   select from start of text to cursor     EditTextView
    SelectFromBeginning   select from start of text to cursor     EditTextView
    SelectLine            select line of cursor                   EditTextView
    ExpandSelectByLine    expand selection by one line            EditTextView

    DeleteLine            delete the cursor line                  EditTextView

    Backspace             delete selection or char before curs.   EditTextView
    Delete                delete selection or char under curs.    EditTextView

    FlushInput            flush any typeAhead input               WindowSensor
    UserInterrupt         interrupt the underlying view process   WindowSensor
    UserAbort             abort the underlying view process       WindowSensor

    DoIt                  execute selection as ST-expression      CodeView
    PrintIt               DoIt and paste printstring of result    CodeView
    InspectIt             DoIt and open inspector on result       CodeView

    CommentSelection      place ST-comments around selection      CodeView
    UncommentSelection    remove Smalltalk comment                CodeView

    FocusNext             focus to next field                     WindowGroup
    FocusPrevious         focus to previous field                 WindowGroup

    Display keyboardMap

If you change these methods to add more functions, please use symbolic keys (i.e. never hard-code any Ctrl or Alt key sequences), since this makes redefinition via the keyboard map impossible).
For example, if you want to add a function to insert a blank line, add code such as:

    ...
    (key == #InsertLine)    ifTrue:[
	self makeCursorVisible.
	self unselect. self insertLine:nil before:cursorLine. ^self
    ].
    ...

    |map|

    map := Display keyboardMap.
    map bindValue:#InsertLine to:#Ctrli.

Notice, that not all of the above functions are available on all keyboards; missing functions can be put onto a function key (such as "F1") with:

    map bindValue:#Again to:#F1

Auxiliary Numeric Keypad

    |map|
    map := Display keyboardMap.
    map bindValue:$0 to:#'KP_Insert'.
    map bindValue:$1 to:#'KP_End'.
    map bindValue:$2 to:#'KP_Down'.
    map bindValue:$3 to:#'KP_Next'.
    map bindValue:$4 to:#'KP_Left'.
    map bindValue:$5 to:#'KP_Begin'.
    map bindValue:$6 to:#'KP_Right'.
    map bindValue:$7 to:#'KP_Home'.
    map bindValue:$8 to:#'KP_Up'.
    map bindValue:$9 to:#'KP_Prior'.
    map bindValue:#Return to:#'KP_Enter'.
    map bindValue:#Backspace to:#'KP_Delete'.

National Characters

If your keyboard has national character keycaps on it, these should produce the expected keypress events iff your display has been configured correctly (i.e. if your xserver's keyboard modifier table is correctly set).
If in doubt, consult the manual page of the xmodmap command, and/or have a look at the output of the event monitor (in the launcher's "tools-monitors" menu).

To enter national characters on an international keyboard, or for an alien language, there are 3 possibilities:

• using the compose key
• using dead keys
• using the "Special Characters" dialog

Compose Key Sequences

Enter a compose key sequence consisting of the "Compose" key followed by the two characters which are to form the real character.
For example, the spanish "ñ" (n-tilde) is entered via "Compose-n-~", the german "ü" u-diaeresis or Umlaut-u via "Compose-u-"" and the french "æ" ae-ligature via "Compose-a-e".
Notice that the "Compose" key is not a modifier key, but a prefix; i.e. it has to be released before the other two characters are pressed.

Here is a list of the most common sequences:

    diaeresis  : Compose-<character>-"
    tilde         : Compose-<character>-~
    acute       : Compose-<character>-'
    grave       : Compose-<character>-`
    circumflex: Compose-<character>-^
    cedille      : Compose-<character>-,
    ring          : Compose-<character>-*
    © (copyright) : Compose-O-C
    ß (sz)       : Compose-s-s

For a full list of supported sequences, inspect the array as returned by:

    WindowSensor composeTable

    WindowSensor class»initializeComposeKeyTable

If any sequence is missing or you don't like the settings, change this method, or add new entries by:

    |table newTable|

    table := WindowSensor composeTable.
    newTable := table , #(
			    ($O $/ 16rD8)
			    ($o $/ 16rF8)
			 ).
    WindowSensor composeTable:newTable.

Any changes should be done in the "display.rc" or (preferably) the "private.rc" file.

If your keyboard has no "Compose" key, you can remap one of the "Control" keys; as with:

    Display keyboardMap bindValue:#Compose to:#Control_R

Non-typist left handers may prefer the right control key; good typers may choose any other (function-) key; finally, those used to ST-80 may want to map "Ctrl-a".

Dead Key Processing

If dead keys are enabled, some characters act as "Dead Key, these are not printed but will modify the next character typed.

Typical dead key sequences are:

• " (double quote) followed by a vowel, to get German Umlaut characters ä, ö, ü
  or other language's diacritical characters with two dots above (ÿ, ë etc.).
• French accents are entered by ' (quote), ` (backquote) or ^, followed by the character, to get é, è, ê etc.
  The c-cedille is entered with , (comma) followed by c.
• Spanish "ñ" (n-tilde) by ~ followed by n.

Dead key handling can be enabled locally via the code editor's menu ("More" - "Misc" - "Dead Keys") or globally via the settings dialog (in "keyboard settings"). In some apps (Workspace and System Browser), this may also be found in the lower-right info&status area, as a popup of the edit mode field (the one, which shows "I" for "insert mode").

Global dead key enablement is a session flag and defaults to false, because most programmers will be hindered by them, when entering program code.

To enable it by default for all views, add the following line to your "display.rc" or "private.rc" file:

    WindowSensor deadKeysEnabled:true

    WindowSensor deadKeysEnabled:false

Dead Key followed by Space

Special Characters Dialog

Alt and Command Keys

If you encounter trouble with "Alt" or "Cmd" key sequences, you should either fix the settings with the xmodmap command, or change ST/X's settings.
If ST/X settings are changed, do this in the "display.rc" or the "private.rc" file.
For example:

    Display altModifiers:#( #Alt_R ).
    Display metaModifiers:#( #Alt_L ).
    Display altModifierMask:(Display modifier1Mask).
    Display metaModifierMask:(Display modifier2Mask).

Keyboard Commands

    |map|

    map := Display keyboardMap.
    map bindValue:#FindNext   to:#Ctrlf.

If you add new features to the text editing classes or want to add support for keyboard commands in your own classes, please do so using symbolic keys too.
We repeat: Never hardcode any control or meta sequences into your programs.
Using symbolic keys allows better use of the system for those lucky people owning many function keys (with keys labeled "copy", "cut", "paste" and so on) and key functions to be changed without recompilation.

The definition of such a translation can use combination keys, such as #CtrlX, where X stands for the unmodified key - case is important here.
Thus, to specify "SHIFT-CTRL-f", use #CtrlF as second argument to the bindValue:to:. To specify unshifted "CTRL-f", use #Ctrlf.

You can use control-key ("Ctrl") or command-key ("Cmd") modifiers.
You may have to put the keys symbol in quotes; for example to define a mapping for control-underscore, use #'Ctrl_'. (this is pure Smalltalk syntax; no magic at all).

On some keyboards, the command key is labeled "Meta" or "Alt".

Default Keyboard Command Setup

  CMD-c    copy
  CMD-x    cut
  CMD-v    paste

  CMD-a    accept

  CMD-d    doIt
  CMD-p    printInt
  CMD-i    inspectIt

  CMD-s    search
  CMD-f    search again forward
  CMD-b    search again backward

  CMD-g    goto line

  CMD-w    select word
  CMD-m    select to matching parentesis

  CMD-z    open popUp menu

  CTRL-m   match parentesis
  CTRL-w   word forward

  CTRL-f   page forward
  CTRL-b   page backward
  CTRL-d   half page forward
  CTRL-u   half page backward

  CTRL-a   move to begin of line
  CTRL-e   move to end of line

  CTRL-x   flush typeahead input
  CTRL-c   interrupt window process & open debugger
  CTRL-y   interrupt window process & abort operation

  CTRL-CursorUp     Scroll up
  CTRL-CursorDown   Scroll Down
  CTRL-CursorRight  cursor-word forward
  CTRL-CursorLeft   cursor-word backward

  CMD-CursorRight   focus to next field
  CMD-CursorLeft    focus to previous field

  Tab        focus to next field (in textViews, spaces is inserted)

  Shift-Tab  focus to previous field (in textViews, its a ``nonInserting tab'')

  Esc        cancel dialog box (in textViews, its a ``selectFromBeginning'')

Please have a look at those files, for the actual settings; the above list may not be up to date or valid for your particular system.

Default KeyboardMap

CMD-c    copy
CMD-x    cut
CMD-v    paste

CTRL-c   interrupt window process & open debugger

CTRL-c   copy
CTRL-x   cut
CTRL-v   paste

BREAK    interrupt window process & open debugger

    |map|

    map := Display keyboardMap.
    map bindValue:#Again   to:#F1.

    View defaultStyle:styleName

    button.foregroundColor    Color red

    myForegroundColor        Color red
    myBackgroundColor        Color yellow
     ...
    button.foregroundColor   =myForegroundColor
    button.backgroundColor   =myBackgroundColor
     ...
    menu.foregroundColor     =myForegroundColor
    menu.backgroundColor     =myBackgroundColor
     ...
    shadowColor              =myBackgroundColor darkened

    #if Display hasColors
    button.foregroundColor    Color red
    #else
    button.foregroundColor    Color grey
    #endif

    ; this is a comment
    ;
    ; first, read motif style
    ;
    #include 'motif.style'

    ;
    ; then redefine highlightBackgroundColor of menus
    ;
    menu.highlightBackgroundColor    Color red

    Color getColorsRed:6 green:6 blue:4 on:Display.

    Smalltalk installAutoloadedClasses.

    className autoload

    Autoload compileLazy:true.

    Compiler warnSTXSpecials:false

    Compiler allowUnderscoreInIdentifier:true

    Compiler warnUnderscoreInIdentifier:false

    Compiler warnings:false

    Smalltalk logDoits:true

    Transcript lineLimit:numberOfLines

    TextCollector newTranscript

    stx -noDebugPrint -noInfoPrint ...