ST-Computer Leser 2002 January/STC_CD_01_2002.iso/APP/CLIX372.TOS/Clix/Doc/UDO/cxmain.ui

Text File | 1998-10-30 | 123.2 KB | 2,915 lines

#{{{}}}

#*****************************************************************
!newpage
!node Copyright
#{{{

  (!PRG) ist (!B)nicht(!b) Public Domain!

  (!PRG) ist Shareware, das hei₧t, da₧ (!PRG) frei kopiert und weitergegeben
  werden darf. Dabei müssen alle zu (!PRG) gehörenden Dateien vollständig
  kopiert werden.

  Der kommerzielle Vertrieb von (!PRG) ist nur mit meiner schriftlichen
  Zustimmung erlaubt, dies schlie₧t die Aufnahme auf
  Public-Domain-Disketten ein.

  Wer (!PRG) regelmä₧ig benutzt, mu₧ die Registrierungsgebühr zahlen.
  Dafür bekommt man dann einen Schlüssel, um (!PRG) ohne Einschränkungen
  verwenden zu können.

  (!B)Der Registrierungsschlüssel darf nicht weitergegeben werden.(!b)

  Die Registrierungsgebühr für (!PRG) beträgt DM 50,-.

  Die registrierte Version erhalten Sie bei:

      Steffen Engel (!nl)
      Wiesenstr. 11 (!nl)
      38102 Braunschweig (!nl)

      Dresdner Bank Braunschweig (!nl)
      BLZ 27080060 (!nl)
      Konto-Nr. 1400277 (!nl)

      E-Mail  : [e-mail] (!nl)
      MausNet : Steffen Engel @ SZ

  Denken Sie daran, da₧ ich Ihren vollen Namen und Ihre Anschrift benötige.
#}}}


#*****************************************************************
!newpage
!node Einleitung
#{{{

Text-Editoren gibt es auf dem Atari reichlich. Wozu dann ein weiterer?

Clix gibt es bereits eine ganze Weile, er war nur ziemlich unbekannt.
Primär als zentraler Editor für das Hänisch Modula-2 Entwicklungssystem
entstanden und gepflegt, ist es selbstverständlich ein vollwertiger,
leistungsfähiger ASCII-Editor.

Aus der Masse der anderen Editoren hebt er sich durch die folgenden
Fähigkeiten hervor:

!begin_itemize
!item Falten von Texten
!item freie Belegung der Tastatur (welcher Editor kann schon alle
      Funktionen über die Tastatur erreichen?)
!item umfangreiche Makrofunktionen
!item Texthervorhebungen zur besseren Erkennung der Textstrukturen
!end_itemize


(!T)Clix(!t) ist ein vollständig in GEM eingebundener ASCII-Editor. Er ist
daher unter sämtlichen Auflösungen lauffähig, sofern sie eine Breite von
mindestens 80 Zeichen bieten. Er wurde vollständig in Modula-2
implementiert. Clix bietet zahlreiche Funktionen, die weit über die eines
normalen Editors hinausgehen. Clix dient daher auch als Entwicklungsumgebung
für das HM-Entwicklungssystem.

Sämtliche Parameter, wie die Anzahl und
Position der geöffneten Fenster, die zuletzt geöffneten Dateien, die Pfade
der verschiedenen Dateikommandos usw., sichert Clix in einer Datei namens
(!REF)Clix.par(!ref).
#}}}


#*****************************************************************
!newpage
!node Konfiguration
#{{{
Clix besitzt umfangreiche Möglichkeiten zur Konfiguration.
Diese mögen anfänglich völlig überwältigend wirken, allerdings braucht sie
das nicht zu irritieren: die meisten Dinge braucht man nicht sofort und
lediglich bei intensiverem Gebrauch von Clix wird es interessant, die
Möglichkeiten genauer kennen zu lernen.

Um sich einen groben Überblick zu verschaffen, sollte man die Möglichkeiten
zumindest überfliegen, später fällt einem dann eventuell der persönliche
Nutzen auf, und man liest es sich dann noch einmal genauer durch.

!index Environmentvariable !! CLIX
!index Environmentvariable !! CLIXPAR
!index Clix.ind
!index Clix.rsc
!index Clix.str
!index Clix.mak
!index Clix.par
!index Clix.pik
Falls eine Environmentvariable (!REF)CLIX(!ref) definiert ist, so wird
versucht, die Hilfsdateien (!REF)Clix.rsc(!ref), (!REF)Clix.str(!ref),
(!REF)Clix.ind(!ref), (!REF)Clix.pik(!ref) und (!REF)Clix.par(!ref) über den
danach angegebenen Pfad zu laden. Clix sucht (!REF)Clix.par(!ref) zuerst im
aktuellen Ordner, dann über eine weitere Environmentvariable namens
(!REF)CLIXPAR(!ref), und zuletzt über die Environmentvariable
(!REF)CLIX(!ref).
Die Möglichkeiten, die (!REF)CLIXPAR(!ref) bieten, sind interessant, wenn man
Clix für sehr unterschiedliche Anwendungen gebraucht und dafür verschiedene
(!REF)Clix.par(!ref) verwenden will.


Die einzelnen Dateien haben folgende Aufgabe:

!begin_description
!item [Clix.par] Die zentrale Parameterdatei. Darin sind auch Namen und Pfad
der zu verwendenden 'geladene Texte'-Datei (!REF) Clix.pik (!ref) und der
Makro-Datei (!REF) Clix.mak (!ref) enthalten.

!item [Clix.pik] ist die Texte-Datei, in der die Liste der zuletzt geladenen
Texte und der verschiedenen Lade-Pfade eingetragen sind. Dies ist die Liste, die
Sie in dem 'Alt-Q' Dialog aufgelistet bekommen.

!item [Clix.mak] ist eine Makrodatei. In ihr sind die Tastaturmakros
abgelegt. Name und Pfad der Makro-Datei sind in Clix.par abgespeichert.
Damit lassen sich verschiedene Umgebungen schaffen.

!item [Clix.rsc] GEM-Resource-Datei

!item [Clix.str] Deutschsprachige Bildschirmmeldungen(!N)wie auch die RSC-Datei auch in Englisch verfügbar(!n)

!item [Clix.ext] enthält die Text-Makros sowie die Texthervorhebungen.
Zu einer genaueren Erklärung dieser Datei lesen Sie bitte den Abschnitt
über die Extension-Datei.

!item [Clix.ind] enthält eine Liste von Schlüsselworten (hier für
Modula-Quelltexte), mit der automatische Ein- und Ausrückungen
durchgeführt werden können.

!item [Clix.reg] Tja, diese Datei gibt es nur, wenn Sie Clix registriert
haben. Hier werden die Registrierungsinformationen abgelegt.
!end_description

Besonders sollten Sie dabei die Dateien (!REF) Clix.par (!ref), (!REF)
Clix.pik (!ref) und (!REF) Clix.mak (!ref) beachten, mit denen Sie Clix auf
vielfältige Weise auf unterschiedliche Aufgaben anpassen können.
#**************************************************************************
#**************************************************************************
#**************************************************************************
#**************************************************************************




!index Hilfe !! zu Clix
Die vorliegende Version von Clix können Sie dem Infodialog entnehmen, den Sie
über den Menüpunkt (!EM)Clix/Über Clix...(!em) erreichen. Au₧erdem kann man
im Dialog über den Button (!EM)Help(!em) oder über die Taste (!KEY)Shift
Help(!key) Informationen zu Clix im Online-Manual erhalten.
#}}}

!subnode Extension-Datei
#{{{

Clix hat die hervorragende Eigenschaft, in Abhängigkeit von der Endung
einer Datei (z.B. .tex, .m, .c etc.) verschiedene Steuerungen
durchzuführen.

Zur Zeit unterstützt Clix die folgenden Eigenschaften:
!begin_description
!item [Texthervorhebung] Schlüsselworte können farblich
und/oder durch Texteffekte ((!U)unterstrichen(!u), (!B)fett(!b),
(!I)kursiv(!i) oder light) hervorgehoben werden.

Dabei lassen sich beliebig viele verschiedene Markierungen angeben.
Beispiel (für Modula-Quelltexte):

!begin_verbatim
  # Darstellung in blau bzw. light
  KEYS {DarkBlue, Light} =
     CONST, TYPE, VAR, RECORD, ARRAY, PROCEDURE, BEGIN, END,
     IF, THEN, ELSE, ELSIF, WHILE, WITH, CASE, REPEAT, UNTIL,
     LOOP, FOR;

  # Ablaufrelevante Bewfehle in rot/fett
  KEYS {DarkRed, Bold} =
     RETURN, EXIT,
     BREAK, CONTINUE,
     "bkpt",
     illegal;

  # dunkelgrün/fett
  KEYS {DarkGreen, Bold} =
     BOOLEAN, SHORTINT, LONGINT, INTEGER, SHORTCARD, LONGCARD,
     CARDINAL, ADDRESS, BYTE, REAL, LONGREAL, SHORTREAL,
     POINTER, BITSET, LONGSET, CHARSET;

  # System-Libraries in Magenta/Bold
  KEYS {DarkMagenta, Bold} =
      SYSTEM, System;
!end_verbatim

!item [Kommentare] Sie sind eine weitere Variante der Texthervorhebung.
Diesmal gilt sie jedoch nicht nur für ein einzelnes Wort, sondern für
einen ganzen Bereich (Kommentare können sich ja z.B. über mehrere Zeilen
erstrecken).

Beispiel (wieder Modula):

!begin_verbatim
  # Kommentare in dunklem Cyan darstellen
  COMMENT {DarkCyan, Light} = "(*", "*)";
!end_verbatim

!item [Text-Makros] Hiermit lassen sich Text-Makros definieren. Der
Aufruf dieser Makros geschieht durch Eingabe des Textmakro-Namens,
gefolgt von der Tastenfolge ALT-Space (ja, die Leertaste bei gedrückt
gehaltener Alternate-Taste):

!begin_verbatim
  # Gerüst eines C-Programmes:
  SHORTCUT "mod" = {\
  rcs\e

  include\e

  init\e
  };
!end_verbatim

Dieses Beispiel gibt den Text (!V)rcs(!v) ein und expandiert ihn als Makro
(es handelt sich um einen Textkopf mit Informationen zum RCS-Revision Control
System), dann den Text (!V)include(!v) und expandiert auch diesen (ein Kopf
mit include-Bereich eines C-Programmes). Dann folgt noch der Rumpf eines
Library-Modules, ebenfalls als expandiertes Makro.

Wie man sehen kann, ist es einfach möglich, Makros zu erstellen, die wiederum
aus Bausteinen bestehen, um einfach pflegbare Makros zu erhalten.

Probieren Sie es doch am besten gleich aus: legen Sie eine Datei mit der
Endung (!T).C(!t) an, geben Sie den Text (!V)mod(!v) ein und drücken Sie
(!KEY)ALT-Space(!key).

!end_description

Die Extension-Datei enthält die nötigen Steuerungen zur Hervorhebung von
Texten und für Text-Makros.

Es stehen die folgenden Kommandos zur Verfügung:

!begin_description
 !item [INCLUDE] dient zur Angabe weiterer zu ladender Extensiondateien. Es
  sollten vollständige Pfade angegeben werden.
 !item [EXTENSION] Ein Parameterblock für eine Liste von Dateiendungen.
  Innerhalb eines EXTENSION-Blockes werden die Steuerkommandos für
  Hervorhebungen und Makros angegeben, die für alle Dateien angewendet werden
  sollen, die eine der Parameterliste entsprechende Endung haben.
 !item [SHORTCUT] Hiermit lassen sich die Textmakros für den aktuellen
   EXTENSION-Block definieren.
 !item [COMMENT] Angabe der Kommentarklammerung (Kommentar-Anfang und
  Kommentar-Ende). Gibt es kein eigenes Kommentarzeichen-Ende, dann wird
  einfach ein leerer String angegeben. Beispiele finden sich in den beigefügten
  EXT-Dateien.
!end_description

!ifdest [stg]
  @alabel "Grammatik der Extension-Datei"
!endif
Die Grammatik der Extension-Datei:
!begin_verbatim
ExtensionFile = { ExtensionRec | IncludeRec } .
ExtensionRec  = "EXTENSION" ExtensionList "=" "{" Definitions "}" .
IncludeRec    = "INCLUDE" String ";"
ExtensionList = StringList .
Definitions   = { Definition ";" } .
Definition    = Region | Keys | Shortcut .
Region        = ( "COMMENT" | "REGION" ) "{" AttribList "}" "="
                String "," String .
Keys          = "KEYS" "{" AttribList "}" "=" KeyList .
AttribList    = [ Attribut { "," Attribut } ] .
Attribut      = "White" | "Black" | "Red" | "Green" | "Blue" | "Cyan"
                | "Yellow" | "Magenta" | "Grey" | "DarkGrey"
                | "DarkRed" | "DarkGreen" | "DarkBlue" | "DarkCyan"
                | "DarkYellow" | "DarkMagenta" | "Light" | "Bold"
                | "Underlined" | "IgnoreCase" .
KeyList       = ListIdent { "," ListIdent } .
ListIdent     = Ident | String .
Ident         = Alpha { AlphaNum } .
Alpha         = "A" | "B" | ... | "Z" | "a" | "b" | ... | "z" | "_" .
AlphaNum      = Alpha | "0" | "1" | ... | "9" .
Shortcut      = "SHORTCUT" String "=" ( StringList | Verbatim ) .
StringList    = String { "," String } .
String        = ('"' { character } '"' ) | ("'" { character } "'" ) .
Verbatim      = "{" VerbatimText "}" .
!end_verbatim


In der EXT-Datei werden Kommentare durch zwei Striche ("--") oder Hash
("#") eingeleitet und gehen bis zum Zeilenende.


COMMENT- und REGION-Definitionen legen Clix-Klammernpaare fest. COMMENT
ist im wesentlichen identisch zu REGION. COMMENT sollte nur einmal
vorkommen, REGION kann mehrfach vorkommen. Der Unterschied liegt darin,
da₧ COMMENT das Klammernpaar festlegt, das Clix als Kommentar wertet.
Solange Clix nur einen Bereich mit Hervorhebung unterstützt, legt
COMMENT au₧erdem diesen Bereich fest.

N.B. REGION wird z.Zt. nicht ausgewertet.

Strings sind die üblichen Modulastrings, also innerhalb alles au₧er den
umschlie₧enden Quotes. Zusätzlich im String folgende Escapes mit
Backslash als Escapezichen (C-Syntax):
!begin_verbatim
   \\ Backslash
   \n Zeilenendezeichen
   \c ASCII 127 (Cursorposition in Makros)
   \<dreistellige Oktalzahl im Bereich 0-377>: ASCII-Zeichen
   \' Single Quote
   \" Double Quote
!end_verbatim

Innerhalb eines VerbatimText können beliebige Zeichen vorkommen. Beendet
wird der VerbatimText durch eine schlie₧ende geschweifte Klammer.
Backslash ist Escapezeichen. Zeilenenden werden in das Kürzel
übernommen, au₧er am Zeilenende steht ein Backslash.

Zulässige Escapes:
!begin_verbatim
   \<EOL> (also Backslash am Zeilenende): Zeilenende nicht übernehmen
   \\  Backslash
   \}  Schlie₧ende geschweifte Klammer
   \c  Cursor setzen (alternativ zu ASCII 127; Vorteil: druckbar)
   \e  Kürzelexpansion aufrufen (rekursive Makros)
   \n  Zeilenende
   \<dreistellige Oktalzahl im Bereich 0-377>: ASCII-Zeichen
!end_verbatim
#}}}

!subnode Environment
#{{{

Einige Verhaltensweisen von Clix können über Environmentvariablen
gesteuert werden.

!begin_description
  !item [HELP] Falls ein anderes Hilfesystem als ST-GUIDE verwendet
    wird, kann mit dieser Environmentvariable der Name des Hilfesystems
    festgelegt werden.
  !item [CLIXPAR] Clix sucht die Datei (!B)Clix.par(!b) zuerst im
    aktuellen Ordner, dann über eine weitere Environmentvariable namens
    (!B)CLIXPAR(!b).
  !item [CLIX] Falls eine Environmentvariable (!B)CLIX(!b) definiert
  ist, so wird versucht, die Hilfsdateien (!B)Clix.rsc(!b),
  (!B)Clix.str(!b), (!B)Clix.pik(!b), (!B)Clix.par(!b) und
  (!B)Clix.ext(!b) über den danach angegebenen Pfad zu laden.

  Clix sucht (!B)Clix.par(!b) zuerst im aktuellen Ordner, dann über
  eine weitere Environmentvariable namens (!B)CLIXPAR(!b).
  !item [GEMPLUS] Mit dieser Variablen kann das Aussehen und die
  Funktionsweise von GEMplus-Programmen beeinflu₧t werden (Clix ist in
  gro₧en Teilen mit GEMplus geschrieben). Zur bequemen Einrichtung
  dieser Environmentvariablen gibt es entsprechende Hilfsprogramme
  (siehe unter GEMplus).
!end_description
#}}}


#*****************************************************************
!newpage
!node Desktop
#{{{
!begin_center
(!IMAGE [Images/clixdesk])
!end_center

!index Clix !! Desktop
Auf dem Desktop von Clix werden die geladenen Texte als Icons abgelegt. Man
kann maximal 32 Texte zugleich laden, jedoch nur soviele Texte gleichzeitig
öffnen wie GEM Fenster zur Verfügung stellt. Die Text-Icons enthalten eine
laufende Nummer und in der oberen Zeile den Namen der Datei, die sie
repräsentieren. Sie lassen sich mit der Maus frei auf dem Bildschirm
positionieren. Um die Icons immer im Blickfeld zu haben, wird standardmä₧ig
ein oberer Rand freigehalten. Dies ist im Dialog (!EM) Allgemeine Optionen
(!em) abschaltbar.

!index Fenster !! öffnen und schlie₧en
Mittels Doppelklick auf ein Icon wird der zugehörige Text geöffnet bzw. in
den Vordergrund gebracht. Ein invertiertes Icon zeigt an, da₧ der Text gerade
geöffnet ist, ein deselektiertes Icon bedeutet, da₧ der Text im Augenblick
nicht in einem Fenster sichtbar ist. Mit (!KEY)Alternate(!key)-Doppelklick,
einem Klick auf den Close-Button des Fensters, (!KEY)Control U(!key) oder
(!KEY)Alternate UNDO(!key) wird dieses wieder geschlossen, ohne da₧ der Text
verloren geht.

Wurde ein Text inhaltlich geändert, so wird dies durch einen Stern vor dem
Dateinamen im Fenstertitel angezeigt.

!index Text !! aufgeben
Um einen Text aus dem Speicher zu entfernen, führt man einen Doppelklick auf
das zugehörige Icon aus, während (!KEY)Shift(!key) gedrückt ist. Dasselbe
lä₧t sich auch über einen Doppelklick bei gleichzeitig gedrückter rechter
Maustaste, einen Doppelklick der rechten Maustaste, die Tastenkombination
(!KEY)Alternate~A(!key) oder den Menüpunkt (!EM)Datei/Aufgeben(!em)
erreichen. Eine Sicherheitsabfrage erfolgt dabei nur, falls der Text geändert
worden ist.

Die Positionen der Icons werden gesichert, wenn die Option (!EM)Desktop beim
Verlassen abspeichern(!em) im Dialog (!EM)Optionen/Allg. Optionen...(!em)
aktiviert wurde.

Am rechten Rand der Menüleiste wird ständig die aktuelle Cursorposition im
obersten Fenster (Zeile/Spalte) angezeigt. Au₧erdem wird der Status des
Editor dargestellt.

!begin_center
!begin_table [|c|l|]
!hline
Anzeige !! Bedeutung
!hline
M !! Makro-Aufzeichnungs-Modus
!hline
S !! Spaltenblock
!hline
B !! Blockmarkierung innerhalb des aktuellen Fensters
!hline
b !! Blockmarkierung in einem Hintergrundfenster
!hline
C !! Klemmbrett verwenden
!hline
I !! Einfügemodus
!hline
O !! Überschreibmodus
!hline
A !! alternatives Manual aktiv
!hline
!end_table
!end_center

#}}}

#*****************************************************************
!newpage
!node Dateioperationen
#{{{
!subnode Datei öffnen

!index Text !! anlegen
(!KEY)Alternate N(!key) oder der Menüeintrag (!EM)Datei/Neu anlegen(!em)
öffnet eine Datei mit dem Namen (!EM)NAMENLOS(!em). Soll diese über
(!KEY)Control S(!key) oder den Menüpunkt (!EM)Datei/Sichern(!em) gesichert
werden, erscheint eine Dateiauswahl, über den ein Dateiname für die neue
Datei eingegeben wird. In diesem Fall entspricht das Kommando (!EM)Text
sichern(!em) dem Kommando (!EM)Text sichern als(!em).

##!subnode Datei öffnen

!index Text !! öffnen
(!KEY)Alternate O(!key) oder der Menüeintrag (!EM)Datei/Öffnen...(!em) öffnet eine
Datei. Dazu wird eine Dateiauswahlbox angezeigt, bei der die (!EM)erste(!em) im
Dialog (!EM)Datei/Auswählen...(!em) definierte Extension und der
entsprechende Pfad vorgewählt ist.

Ist die Datei auf dem Datenträger nicht auffindbar, so wird über eine
Alert-Box nachgefragt, ob sie neu angelegt werden soll. Versucht man, einen
Text zu öffnen, der bereits geladen wurde, so erscheint ein Auswahl-Dialog.

!begin_center
(!IMAGE [Images/clixover])
!end_center

Im Normalfall sollte man den Text höchstens im Modus (!EM)nicht editierbar(!em)
laden, um Inkonsistenzen zu vermeiden. Es ist jedoch dennoch möglich, den
Text über den Button (!EM)Laden(!em) mehrfach zu laden. Alternativ kann auch der
aktuelle Text neu aus der Datei gelesen werden.

Über (!KEY)Control Alternate O(!key) lä₧t sich eine Datei öffnen, deren
Zugriffspfad durch die letzte Extension (*.*) im
(!EM)Datei/Auswählen...(!em)-Dialog repräsentiert wird.

!subnode Datei auswählen

!index Text !! auswählen
(!KEY)Alternate Q(!key) oder der Menüpunkt (!EM)Datei/Auswählen...(!em) öffnet eine
Dialogbox, aus der man über einer Scroll-Liste einen der maximal sechzehn
zuletzt geöffneten Texte auswählen kann. Au₧erdem werden verschiedene
Extension-Gruppen gesichert. In der Titelzeile wird der Name der aktuellen
Dateiliste angezeigt. Hat sich der Inhalt des Dialoges geändert, so wird dies
durch einen Stern in der Titelleiste angezeigt.

!begin_center
(!IMAGE [Images/clixpick])
!end_center

!index Pick-Datei
Ein Klick auf den Pfad einer Datei selektiert diese. Mittels gedrückter
Shift-Taste können mehrere Einträge selektiert bzw. deselektiert werden.
Die Liste kann sowohl mittels Maus also auch über die Cursor-Tasten
gescrollt werden. (!KEY)Home(!key) bzw. (!KEY)Shift Home(!key) positioniert an den
Anfang bzw. das Ende der Liste. Die ausgewählten Dateien werden, falls der
Dialog über (!EM)OK(!em) verlassen wurde, von Clix geladen. Ein Text lä₧t sich
auch über (!KEY)Control 0..9(!key) (Ziffernblock) selektieren bzw. deselektieren.
Ein einzelner Text kann mittels Doppelklick, gedrückter (!KEY)Shift(!key)-Taste
und Einfachklick oder die Tasten (!KEY)Shift Control 0..9(!key) (Ziffernblock)
direkt ausgewählt werden. (!EM)Tilgen(!em) entfernt die Pfade der selektieren
Dateien aus der Liste.

!index Textoptionen
!index Optionen !! Text-
Unterhalb der Dateiliste befinden sich sechs Buttons (Alt A--F), von denen
die ersten fünf (Alt A--E) eine Liste von Suchmustern enthalten. Diese werden
aus der Dateiauswahlbox übernommen. Der sechste (Alt F) enthält immer
(!REF)*.*(!ref). Für jeden Button wird ein eigener Pfad gespeichert. Ein Klick auf
einen solchen Button öffnet eine Dateiauswahlbox mit dem entsprechenden Pfad
und dem definierten Suchmuster, über den man eine Datei öffnen kann.
!label DefaultTextOpt
Ein Mausklick bei gedrückter Shift-Taste oder ein Doppelklick auf einen
Button öffnet einen Dialog zur Einstellung der Default-Textoptionen der
entsprechenden Pfade (siehe auch Abschnitt (!link [Textoptionen] [AltTab])). Hier wird also auch
eingestellt, welche Optionen bei einem Text voreingestellt sind, der mittels
(!EM)Datei/Neu anlegen(!em) bzw. (!EM)Datei/Öffnen!..(!em) geöffnet wird.


Über dem Eintrag (!EM)Makedatei(!em) kann eine Make-Datei bestimmt werden,
die auf Wunsch beim Start des Editors sowie beim Wechsel der PIK-Datei vom
Compiler-Accessory geladen wird, falls dies noch nicht geschehen ist. Wurde
die aktuelle Make-Datei geändert, so kann über eine Dialogbox die Sicherung
veranla₧t werden. Auf diese Weise kann über die PIK-Datei das komplette
Projekt gewechselt werden. Wird Clix mit Dateinamen als Parameter aufgerufen,
wird nicht versucht, den Compiler ein Make einlesen zu lassen. Wird ein
leerer Dateinamen angegeben, so wird die ausgewählte Make-Datei entfernt.

(!EM)Sichern(!em) speichert den kompletten Inhalt des Auswahldialoges, d.h. die
Dateiliste und die eingestellten Extensions mit ihren zugehörigen Pfaden und
Textoptionen, in einer sogenannten Pick-Datei. Pick-Dateien sollten immer
auf (!REF)*.PIK(!ref) enden. Der Pfad der ausgewählten Pick-Datei wird in der
Parameterdatei (!REF)CLIX.PAR(!ref) gesichert. Über (!EM)Laden(!em) kann man eine andere
Pick-Datei laden. Somit ist ein leichter Wechsel zwischen verschiedenen
Projekten möglich.

Die Option (!EM)Bei Programmende sichern(!em) bestimmt, ob die Pick-Datei vor dem
Verlassen des Editors automatisch gesichert werden soll.

Au₧erdem kann die Anzahl der zu sichernden Pfade über eine Pfeilbox
festgelegt werden.

Bei Laden von Texten über die Kommandozeile werden diese zunächst in der
Pick-Datei-Liste gesucht. Ist der zu ladende Text bereits bekannt, werden
die zuletzt gesicherten Optionen beim erneuten Laden des Textes
berücksichtigt. Dies trifft jedoch nicht auf die Cursorposition zu.


!subnode Text überladen

!index Text !! überladen
(!KEY)Alternate L(!key) oder der Menüeintrag (!EM)Datei/Letzte Version(!em) ersetzt den
im Vordergrund befindlichen Text durch die Originalversion aus der Datei.
Wurde am Text eine Änderung vorgenommen, so erscheint vorher eine
Sicherheitsabfrage; wurde der Text neu angelegt und noch nicht gesichert, so
wird der Text komplett gelöscht.

!subnode Text speichern

!index Text !! speichern
(!KEY)Control S(!key) bzw. der Menüeintrag (!EM)Datei/Sichern(!em) sichert den im
Vordergrund befindlichen Text unter dem Pfad, der sich in der Kopfzeile des
Fensters befindet.

(!KEY)Alternate U(!key) bzw. der Menüeintrag (!EM)Datei/Sichern als...(!em)
sichert den im Vordergrund befindlichen Text unter einem neuen Namen. Dazu
wird eine Dateiauswahlbox geöffnet. Existiert die angegebene Datei bereits,
so erfolgt vor dem Überschreiben eine Sicherheitsabfrage.

(!KEY)Shift Alternate U(!key) sichert den im Vordergrund befindlichen Text unter
einem neuen Namen, ohne das Dateidatum zu verändern. Dazu wird eine
Dateiauswahlbox geöffnet.

!subnode Text aufgeben

!index Text !! aufgeben
(!KEY)Alternate A(!key) oder der Menüeintrag (!EM)Datei/Aufgeben(!em) verwirft den Text
im Vordergrund. Falls der Text seit dem Laden oder seit dem letzten
Speichern verändert wurde, wird vorher eine Warnung ausgegeben.

!subnode Fehlerdatei laden

(!KEY)Shift Alternate O(!key) und der Menüpunkt (!EM)Datei/Zuladen...(!em)
ermöglichen das Laden vom vom HM2-Compiler oder einem Utility erzeugten
Fehlerdateien. Es wird versucht eine Datei zu laden, deren Namen aus dem
Textnamen und der Extension (!REF)ERR(!ref) gebildet wurde. Ist eine solche nicht
auffindbar, so wird eine Dateiauswahlbox geöffnet. Eine solche Datei kann
für jede Textdatei vorhanden sein. Sie wird nicht als Icon angezeigt und
erscheint daher auch nicht im Auswahldialog. Sie ermöglicht es, den Cursor
automatisch auf die einzelnen Fehlerstellen zu positionieren.

!subnode Fehlerdatei entfernen

(!KEY)Shift Alternate A(!key) und der Menüpunkt (!EM)Datei/Entfernen(!em) entfernt
eine geladene Fehlerdatei.

#!subnode Block laden

#!index Block !! laden
#(!KEY)Shift Alternate V(!key) oder der Menüeintrag (!EM)Datei/Einlesen(!em) liest eine
#über eine Dateiauswahlbox spezifizierte ASCII-Datei an der
#Cursorposition ein und markieren diese als Block. Als Pfad wird der erste
#Pfadeintrag im Pick-Dialog benutzt; allerdings mit der Extension *.*.

#!subnode Block speichern

#!index Block !! speichern
#(!KEY)Shift Alternate C(!key) oder der Menüpunkt (!EM)Datei/Schreiben(!em) speichert
#einen markierten Block als ASCII-Datei ab. Der Name wird über eine
#Dateiauswahlbox spezifiziert. Die Tastenkombinationen (!KEY)Shift Alternate V(!key)
#und (!KEY)Shift Alternate C(!key) bedeuten (!EM)paste from file(!em) bzw. (!EM)copy to
#file(!em), und sind daher als Erweiterung der üblichen Cut/Copy/Paste-Kommandos
#anzusehen.


#}}}

#*****************************************************************
!newpage
!node Fenstermanipulation
#{{{
!index Fenster !! tauschen
!index Vertauschen !! Fenster
(!KEY)Control W(!key) bringt das nächste Fenster in den Vordergrund. Dabei wird
die fortlaufende Nummer der Fenster zugrunde gelegt.

!index Fenster !! anordnen
(!KEY)Control~,(!key) bzw. der Menüeintrag (!EM)Optionen/Überlappend(!em) ordnet die
geöffneten Fenster überlappend an.

(!KEY)Control~.(!key) bzw. der Menüeintrag (!EM)Optionen/Nebeneinander(!em) ordnet die
geöffneten Fenster so an, da₧ sie nebeneinander liegen und etwa jeweils die
gleiche Breite besitzen.

(!KEY)Control -(!key) bzw. der Menüeintrag (!EM)Optionen/Untereinander(!em) ordnet
die geöffneten Fenster so an, da₧ sie untereinander liegen und etwa jeweils
die gleiche Höhe besitzen.

(!KEY)Shift Control -(!key) ordnet die offenen Fenster zweispaltig untereinander
an und ermöglicht vor allem auf einem Gro₧bildschirm eine gute Übersicht über
alle geöffneten Texte.

!index Fenster !! öffnen und schlie₧en
(!KEY)Control (, ), /, *(!key) (Ziffernblock) öffnet die Fenster mit der
Nummer 0--3. Dies lä₧t sich auch über einen Doppelklick auf das entsprechende
Icon auf dem Desktop bewerkstelligen.

(!KEY)Shift Control (, ), /, *(!key) (Ziffernblock) öffnet die Fenster mit
der Nummer 4--7. Dies lä₧t sich auch über einen Doppelklick auf das
entsprechende Icon auf dem Desktop bewerkstelligen.

(!KEY)Alternate Undo(!key) bzw. (!KEY)Control U(!key) schlie₧t das im Vordergrund
befindliche Fenster. Dies lä₧t sich auch durch einen Mausklick auf den
Fenster-Closer erreichen.

(!KEY)Alternate (, ), /, *(!key) (Ziffernblock) schlie₧t die Fenster mit
der Nummer 0--3. Dies lä₧t sich auch durch einen Mausklick auf den
Fenster-Closer oder einen (!KEY)Alternate(!key)-Doppelklick auf das entsprechende
Icon erreichen.

(!KEY)Alternate Shift (, ), /, *(!key) (Ziffernblock) schlie₧t die Fenster
mit der Nummer 4--7. Dies lä₧t sich auch durch einen Mausklick auf den
Fenster-Closer oder (!KEY)Alternate(!key)-Doppelklick auf das entsprechende
Icon erreichen.

!index Fenster !! Grö₧e ändern
(!KEY)Alternate~,(!key) bringt das im Vordergrund befindliche Fenster auf die
maximale Grö₧e.

(!KEY)Shift Alternate~,(!key) bringt sämtliche offenen Fenster auf die maximale
Grö₧e.

(!KEY)Alternate~.(!key) bringt das im Vordergrund befindliche Fenster auf die
maximale Höhe, ohne die Breite zu ändern.

(!KEY)Alternate -(!key) bringt das im Vordergrund befindliche Fenster auf die
maximale Breite, ohne die Höhe zu ändern.

#}}}

#*****************************************************************
!newpage
!node Änderung des Fensterausschnitts
#{{{
In einem Fenster kann meist nur ein Teil des gesamten Textes dargestellt
werden. Daher ist es nötig, den Textausschnitt im Fenster verändern zu können.
Dies kann sowohl über die Fensterbedienungselemente als auch über die
Tastatur erfolgen. Die Manipulation des Dateiauschnitts über die
Fensterelemente funktioniert wie unter GEM üblich, die Tastatursteuerung
entspricht den ATARI-Richtlinien.

(!KEY)Echtzeit-Scrolling~(!key)
!index Echtzeit-Scrolling
Drückt man zusätzlich die
rechte Maustaste, wenn man den vertikalen Scrollbar anpackt, so wird der
Ausschnitt sofort mit der Mausbewegung mitverändert, und nicht erst, wenn
man die Maustaste wieder loslä₧t (ähnlich dem Slider in der Dateiauswahl).

!index Panning
(!KEY)Panning(!key)(!N)von engl. 'to pan' --- etwas (mit einer Kamera)
verfolgen; der Ausdruck wie das Verfahren stammen von der
X-Window-Umgebung.(!n) Klickt man in den Text, wobei die
Alternate- oder Control-Taste gedrückt sind, so wird die Maus zur (!EM)flat
hand(!em), der die darunterliegende Textzeile vertikal und horizontal folgt.
Diese Funktionalität wird noch dadurch erweitert, da₧ der Text zeilenweise in
die entsprechende Richtung scrollt, wenn man mit der Maus das Fenster am
oberen oder unteren Rand verlä₧t.

(!KEY)Shift Control Auf(!key) bewegt den Textausschnitt um eine Zeile nach oben,
ohne die Cursorposition zu verändern.

(!KEY)Shift Control Ab(!key) bewegt den Textausschnitt analog um eine Zeile nach
unten, ohne die Cursorposition zu verändern.

!index Springen !! zum Textanfang und -ende
(!KEY)Home(!key) springt an den Textanfang und setzt den Cursor in die linke,
obere Ecke.

(!KEY)Shift Home(!key) springt an das Textende und setzt den Cursor in die
linke, untere Ecke.

(!KEY)Control F2(!key) setzt den Fensterausschnitt um eine halbe Seite nach links.

(!KEY)Control F3(!key) setzt den Fensterausschnitt um eine halbe Seite nach rechts.

!begin_center
(!IMAGE [Images/clixline])
!end_center

!index Springen !! zu Zeile
(!KEY)Alternate Z(!key) oder der Menüeintrag (!EM)Mark/Zeile(!em) öffnet einen Dialog,
über den man eine beliebige Zeile bzw. Spalte anspringen kann. Alternativ
kann man eine Byte-Position angeben, die vom Textanfang ab gezählt wird.

!index Faltung !! Zeilennumerierung
Normalerweise wird ein gefalteter Block als (!EM)eine(!em) Zeile
gezählt. Mit aktivierter Option
(!EM)Blockfaltung ignorieren(!em) werden auch eingefaltete Zeilen mitgezählt. Ruft
man Clix in der Kommandozeile mit Textname plus Zeilennummer auf, wird dieser
Modus implizit verwendet. Das trifft auch zu, wenn man mit rechter Maustaste
plus Doppelklick auf eine Zahl in einem hinten liegenden Fenster
positioniert. Da solche Zeilenangaben zumeist von anderen Programmen
generiert werden, die keine Blockfaltung kennen oder sie einfach ignorieren
--- z.B. (!TeX), ONYX-Assembler ---, kann so eine korrekte Positionierung
ermöglicht werden.

(!KEY)Control 1..0(!key) (Hauptblock) oder der Menüpunkt (!EM)Mark/setze Marke(!em)
setzt eine der zehn Textmarken. Die aktuelle Zeilenposition im Dokument wird
gespeichert. Bei Operationen wie Zeile einfügen oder löschen werden die
Positionen der Marken entsprechend angepa₧t.

!index Springen !! zu Marke
(!KEY)Alternate 1..0(!key) (Hauptblock) oder der Menüpunkt (!EM)Mark/Marke(!em) springt
die über (!KEY)Control 1..0(!key) gesetzten Textmarken an. Der Cursor wird an den
Anfang der jeweils gespeicherten Zeile gesetzt.

!index Springen !! zu letzter Position
(!KEY)Alternate G(!key) oder der Menüpunkt (!EM)Mark/Letzte Pos.(!em) setzt den Cursor
an die zuletzt angesprungene Position im Text.

!index Springen !! zum Blockanfang und -ende
(!KEY)Alternate B(!key) oder der Menüeintrag (!EM)Mark/Blockstart(!em) setzt den Cursor
an den Anfang des Blocks. Ist kein Block markiert, so wird der Cursor an den
Anfang des Dokumentes bewegt.

(!KEY)Alternate K(!key) oder der Menüeeintrag (!EM)Mark/Blockende(!em) setzt den Cursor
an das Ende des Blocks. Ist kein Block markiert, so wird der Cursor an den
Anfang des Dokumentes bewegt.


#}}}

#*****************************************************************
!newpage
!node Cursorpositionierung
#{{{
Ein Klick mit der linken Maustaste innerhalb eines aktiven Fensters
positioniert den Cursor auf die gewünschte Position.

Hält man die rechte Maustaste gedrückt und klickt eine Zahl in einem nicht
aktiven Fenster an, so wird sie als Zeilennummer interpretiert, zu der im
obersten Fenster gesprungen wird. Folgt ein (!B)^(!b) und noch eine
Zahl, wird diese als Spalte interpretiert. (!B)10^20(!b) springt zur Zeile
10, in die Spalte 20.

(!KEY)Rechts(!key) bewegt den Cursor innerhalb einer Zeile um eine Spalte nach
rechts. Es spielt dabei keine Rolle, ob sich an dieser Position noch ein
Zeichen befindet oder nicht. Unter Clix ist der Cursor jederzeit frei
positionierbar.

(!KEY)Links(!key) bewegt den Cursor innerhalb einer Zeile um eine Spalte nach
links. Befindet sich der Cursor bereits am linken Rand, so wird das
Kommando ignoriert.

(!KEY)Auf(!key) bewegt den Cursor um eine Zeile nach oben. Befindet sich der
Cursor bereits in der ersten Zeile, so wird das Kommando ignoriert.

(!KEY)Ab(!key) bewegt den Cursor um eine Zeile nach unten. Befindet sich der
Cursor bereits in der letzten Zeile, so wird das Kommando ignoriert.

(!KEY)Shift Links(!key) setzt den Cursor an den Anfang der Zeile.

(!KEY)Shift Rechts(!key) setzt den Cursor an das Ende der Zeile.

(!KEY)Shift Auf(!key) bewegt den Cursor um eine Seite nach oben. Befindet sich
der Cursor bereits auf der ersten Seite, so wird das Kommando ignoriert.

(!KEY)Shift Ab(!key) bewegt den Cursor um eine Seite nach unten. Befindet sich
der Cursor bereits auf der letzten Seite, so wird das Kommando ignoriert.

(!KEY)Control Links(!key) setzt den Cursor auf das erste Zeichen des
vorausgehenden Wortes. Befinden sich zwischen dem ersten Wort der Zeile
und dem linken Rand noch Leerzeichen, so wird der Cursor an den Anfang der
Zeile gesetzt. Clix unterscheidet drei Gruppen von Zeichen, die als Wort
gelten: Leerzeichen, Buchstaben und Zahlen, sowie Satz-/ Trenn-/
Rechenzeichen. Beim Springen von Wort zu Wort wird also eigentlich von
Zeichengruppe zu Zeichengruppe gesprungen.

(!KEY)Control Rechts(!key) setzt den Cursor auf das erste Zeichen des nächsten
Wortes. Befindet sich der Cursor bereits innerhalb des letzten Wortes einer
Zeile, so wird er hinter das Wort gesetzt.

(!KEY)Control Auf(!key) setzt den Cursor unter Beibehaltung der Spalte in die
erste Zeile der Seite.

(!KEY)Control Ab(!key) setzt den Cursor unter Beibehaltung der Spalte in die
letzte Zeile der Seite.

(!KEY)Shift Control Links(!key) setzt den Cursor an den logischen Zeilenanfang.
Dies entspricht dem ersten Zeichen einer Zeile, das kein Leerzeichen ist.


#}}}

#*****************************************************************
!newpage
!node Editieren
#{{{
Clix stellt zahlreiche Operationen zur Verfügung, die das Editieren eines
Textes erleichtern:

!subnode Undo

!index Undo
!index Redo
Clix fügt eine vom Benutzer editierte Zeile erst dann in den gesamten Text
ein, wenn der Cursor diese verlä₧t. Über (!KEY)Undo(!key) oder den Menüpunkt
(!EM)Undo/Redo(!em) kann der ursprüngliche Zustand, auch wenn die Zeile
verlassen wurde, wiederhergestellt werden. Die Zeilennummer der zuletzt
modifizierten Zeile wird im Menü angezeigt. Wurde ein (!EM)Undo(!em)
durchgeführt, so erscheint im Menü (!EM)Redo(!em). (!EM)Redo(!em) stellt den Zustand
vor der (!EM)Undo(!em)-Operation wieder her und umgekehrt.

!subnode Zeile einfügen

!index Zeile !! einfügen
!index Einfügen !! Zeile
(!KEY)Insert(!key) oder (!KEY)Control N(!key) fügt an der aktuellen Cursorposition
eine Leerzeile ein. Der Cursor sitzt anschlie₧end am Zeilenanfang.

(!KEY)RETURN(!key) oder (!KEY)ENTER(!key) fügt unterhalb der Cursorposition eine
Leerzeile ein und setzen den Cursor an deren Anfang. Ist die allgemeine Option
(!EM)RETURN trennt Zeile(!em) aktiv, so wird die aktuelle Zeile ab der
Cursorposition umbrochen (siehe Zeile umbrechen). Im Flie₧textmodus wird
die aktuelle Zeile zusätzlich als Absatzende markiert.

!subnode Zeilen umbrechen

!index Zeile !! umbrechen
Über (!KEY)Alternate RETURN(!key) oder (!KEY)Alternate ENTER(!key) wird die Zeile ab der
Cursorposition getrennt. Dazu wird eine Leerzeile eingefügt, in die
der Rest der Zeile umbrochen wird. Ist die allgemeine Option
(!EM)RETURN trennt Zeile(!em) aktiv, so wird unterhalb
der Cursorposition eine Leerzeile eingefügt und der Cursor an deren Anfang
gesetzt (siehe Zeile einfügen).

!subnode Zeilen vereinigen

!index Zeile !! vereinigen
(!KEY)Alternate Backspace(!key) vereinigt, unabhängig von der aktuellen
Cursorposition, die Zeile, in der sich der Cursor befindet, mit der
darüberliegenden. Der Cursor wird an die Verbindungsstelle der beiden Zeilen
gesetzt.

(!KEY)Shift Backspace(!key) führt sooft das Kommando (!EM)Zeichen links löschen(!em)
aus, bis der Cursor an der vorigen Tabulatorposition steht. Steht der Cursor
am Zeilenanfang, so wird die aktuelle Zeile mit der darüberliegenden
vereinigt.

(!KEY)Alternate Delete(!key) vereinigt, unabhängig von der aktuellen
Cursorposition, die Zeile unterhalb des Cursors mit der darunterliegenden.
Der Cursor wird an die Verbindungsstelle der beiden Zeilen gesetzt.
!subnode Zeile sichern

!index Zeile !! sichern
(!KEY)Control S(!key) sichert den Inhalt der aktuellen Zeile in einen globalen
Zeilenpuffer.

!subnode Zeile löschen

!index Zeile !! löschen
!index Löschen !! Zeichen
(!KEY)Control Y(!key) löscht die aktuelle Zeile und setzt den Cursor an den
Zeilenanfang. Der Inhalt der gelöschten Zeile wird im Zeilenpuffer gesichert
und kann daher über (!KEY)Control E(!key) wieder restauriert werden.

!subnode Zeilenpuffer einfügen

!index Zeile !! aus Puffer einfügen
!index Einfügen !! aus Zeilenpuffer
(!KEY)Control E(!key) fügt in der aktuellen Zeile den Inhalt des Zeilenpuffers ein.
Der Zeilenpuffer enthält die zuletzt über (!KEY)Control Y(!key) gelöschte oder
mittels (!KEY)Control S(!key) zuletzt gesicherte Zeile.

!subnode Zeile duplizieren

!index Zeile !! duplizieren
(!KEY)Control Insert(!key) dupliziert die Zeile, in der sich der Cursor befindet,
und setzt den Cursor um eine Zeile tiefer.

!subnode Zeile auskommentieren

!index Zeile !! auskommentieren
(!KEY)Alternate H(!key) kommentiert die Zeile, in der sich der Cursor befindet aus.
Als Kommentarzeichen werden die über den Dialog
(!EM)Optionen/Sonderzeichen...(!em) ausgewählten Symbole verwendet. War eine
Zeile schon auskommentiert, so werden die Kommentarzeichen wieder entfernt.

!subnode Zeile formatieren

!index Zeile !! formatieren
!index Formatieren !! Zeile
(!KEY)Alternate W(!key) formatiert die Zeile neu, in der sich
der Cursor befindet. Dazu mu₧ die Textoption (!EM)Wortumbruch(!em) aktiv sein.
Ragt die Zeile über den rechten Fensterrand hinaus, so wird sie umbrochen.
Ist die Folgezeile eingerückt, so wird für sämtliche Folgezeilen die
Einrückung beibehalten.

!subnode Absatz formatieren

!index Formatieren !! Absatz
(!KEY)Shift Alternate W(!key) formatiert den
Absatz neu, in dem sich der Cursor befindet. Es werden nur solche Zeilen
formatiert, die über ein sogenanntes weiches Zeilenende verfügen. Ein weiches
Zielenende bedeutet, da₧ dem Zeilenende ein Leerzeichen vorausgeht. Absätze
werden durch ein hartes Zeilenende, dem kein Leerzeichen vorangeht,
voneinander getrennt. Dieses Verfahren, erlaubt die Sicherung von
Formatinformationen in einer normalen ASCII-Datei. Zu beachten ist, da₧
immer der (!EM)komplette(!em) Absatz neu formatiert wird.

!subnode Unformatierte ASCII-Texte formatieren

!index Formatieren !! ASCII-Texte
(!KEY)Control Alternate W(!key)  formatiert eine
Zeile auch dann, wenn sie ein Absatzende ist. Dies ist nützlich, wenn
unformatierte ASCII-Texte formatiert werden sollen

(!KEY)Shift Control Alternate W(!key)  erlaubt
die Formatierung von Dokumenten, die nur über harte Zeilenenden verfügen. Die
Trennung von Absätzen erfolgt in diesem Fall durch eine Leerzeile oder das
Textende. Duch die Formatierung werden harte in weiche Zeilenenden
konvertiert.

!subnode Zeichen aus darüberliegender Zeile kopieren

!index Zeichen !! kopieren
!index Kopieren !! Zeichen
(!KEY)Control D(!key) kopiert das Zeichen, das sich in der darüberliegenden Zeile
in der Cursorspalte befindet, an die aktuelle Cursorposition.
!subnode Wort aus darüberliegender Zeile kopieren

!index Wort !! kopieren
!index Kopieren !! Wort
(!KEY)Shift Control D(!key) kopiert das Wort, das sich in einer darüberliegenden
Zeile in der Cursorspalte befindet, an die aktuelle Cursorposition.
Bei der Suche nach dem zu kopierenden Wort wird solange um eine Zeile nach
oben gesprungen, bis ein Wort gefunden, oder der Textanfang erreicht wurde.
Der Cursor steht anschlie₧end hinter dem Wort.
!subnode Zeichen löschen

!index Zeichen !! löschen
!index Löschen !! Zeichen
(!KEY)Backspace(!key) löscht das Zeichen links neben dem Cursor. Befindet sich der
Cursor am Zeilenanfang, so wird das Kommando ignoriert.

(!KEY)Delete(!key) löscht das Zeichen unter dem Cursor.
!subnode Wort löschen

!index Wort !! löschen
!index Löschen !! Wort
(!KEY)F2(!key) oder (!KEY)Shift Control T(!key) löscht ab der aktuellen Cursorposition
die linke Worthälfte. Befindet sich der Cursor zwischen zwei Worten, so wird
das gesamte linke Wort entfernt (siehe auch wortweise
Cursor-Positionierung).

(!KEY)F3(!key) oder (!KEY)Control T(!key) löscht ab der aktuellen Cursorposition die
rechte Worthälfte. Befindet sich der Cursor zwischen zwei Worten, so wird
der Zwischenraum bis zum nächsten Wort entfernt (siehe auch wortweise
Cursor-Positionierung).
!subnode Bis Zeilenanfang/-ende löschen

!index Löschen !! bis Zeilenanfang/-ende
(!KEY)Shift F2(!key) löscht die aktuelle Zeile ab der Cursorposition bis zum
Zeilenanfang. Der Cursor steht anschlie₧end am Zeilenanfang.

(!KEY)Shift F3(!key) löscht die aktuelle Zeile ab der Cursorposition bis zum
Zeilenende. Der Cursor behält seine Position bei.
!subnode Leerzeichen einfügen

!index Einfügen !! Leerzeichen
(!KEY)Control Leertaste(!key) fügt ein Leerzeichen ein, ohne die Position des Cursors zu
verändern. Diese Funktion wird vor allem im Überschreibmodus benötigt.
!subnode Dateinamen einfügen
!index Einfügen !! Dateinamen
!index Dateilisten
!label InsFNames
(!KEY)Shift Control L(!key) oder der Menüpunkt (!EM)Edit/Filenamen...(!em) öffnet
die Dateiauswahlbox, in der man einen Dateinamen oder eine Dateimaske
eingeben kann --- etwa (!REF)*.TEX(!ref). Alle gefundenen Dateinamen werden mit
vollständigem Pfad an der Cursorposition eingefügt, pro Zeile ein Dateiname.
Dieses Kommando erweist sich als sinnvoll, um eine Dateiliste zu erstellen,
wenn man Suchen und Ersetzen in Dateien durchführen will.

!subnode ASCII-Zeichen einfügen

!begin_center
(!IMAGE [Images/clixasci])
!end_center

!index Einfügen !! ASCII-Zeichen
(!KEY)Control L(!key) oder der Menüpunkt (!EM)Edit/ASCII...(!em) öffnet eine
Dialogbox, die sämtliche ASCII-Zeichen enthält. Durch einen Mausklick über
dem gewünschten Zeichen wird dieses in die untere, editierbare Zeile
übernommen. Somit lassen sich normal erreichbare Zeichen mit Sonderzeichen
mischen. Beim Verlassen des Dialogs über (!EM)Einfügen(!em) wird der Inhalt der
Zeile an der aktuellen Cursorposition in den Text eingefügt.

Wird über einem Zeichen der Box ein Doppelklick ausgeführt, so wird das
gewählte Zeichen sofort an der Cursorposition in den Text eingefügt.

Die Zeichen (!REF)CR(!ref) und (!REF)0C(!ref) werden weder übernommen noch in den
Text eingefügt, (!REF)LF(!ref) bedeutet ein Zeilenende.

Sonstige ASCII-Zeichen können alternativ über ihren ASCII-Code, auch unter
TOS-Versionen kleiner als 2.05, direkt eingegeben werden. Dazu mu₧ die
(!KEY)Alternate(!key)-Taste gedrückt werden, während der ASCII-Code des
gewünschten Zeichens auf dem Ziffernblock eingegebn wird. Nach Loslassen der
(!KEY)Alternate(!key)-Taste erscheint das entsprechende Zeichen.

!subnode Tabulator anspringen

!index Tabulatoren
(!KEY)Control Tab(!key) setzt den Cursor auf die nächste, rechte Tabulatorposition.

(!KEY)Shift Control Tab(!key) oder (!KEY)Control Backspace(!key) setzt den Cursor auf die
nächste, linke Tabulatorposition.

(!KEY)Tab(!key) fügt soviele Leerzeichen ein, wie nötig sind, um den Cursor an die
nächste Tabulatorposition zu setzen.

(!KEY)Shift Tab(!key) führt sooft das Kommando (!EM)Zeichen links löschen(!em) aus,
bis der Cursor an der vorigen Tabulatorposition steht. Steht der Cursor
am Zeilenanfang, so wird das Kommando ignoriert.

(!KEY)Shift Backspace(!key) entspricht (!KEY)Shift Tab(!key), mit einer Ausnahme: Steht
der Cursor am Zeilenanfang, so wird die aktuelle Zeile mit der
darüberliegenden vereinigt.

!subnode Text einrücken

!index Verschieben !! Zeile
!index Zeile !! verschieben
!index Einrücken !! Zeile
!index Zeile !! einrücken
!label ZeileSchieben

(!KEY)Alternate <(!key) löscht am Zeilenanfang soviele Leerzeichen, wie als
Tabulatorweite für das jeweilige Fenster definiert sind. Der Zeileninhalt
wird also um (!EM)Tabulatorweite(!em) Zeichen nach links verschoben. Das Kommando
wird ignoriert, wenn der Cursor am Zeilenanfang steht. Anschlie₧end wird der
Cursor, unter Beibehaltung seiner Spaltenposition, eine Zeile tiefer gesetzt.

(!KEY)Shift Alternate <(!key) fügt am Zeilenanfang soviele Leerzeichen ein, wie
als Tabulatorweite für das jeweilige Fenster definiert sind. Der Zeileninhalt
wird also um (!EM)Tabulatorweite(!em) Zeichen nach rechts verschoben. Anschlie₧end
wird der Cursor, unter Beibehaltung seiner Spaltenposition, eine Zeile tiefer
gesetzt.

!subnode Zeile tauschen

!index Zeile !! tauschen
!index Vertauschen !! Zeilen
(!KEY)Alternate !~(!key) oder (!KEY)Alternate #(!key) vertauscht die Zeile, in der
sich der Cursor befindet, mit der darunterliegenden. Sitzt der Cursor in der
letzen Zeile, so wird das Kommando ignoriert.

(!KEY)Shift Alternate !~(!key) oder (!KEY)Shift Alternate #(!key) vertauscht die
Zeile, in der sich der Cursor befindet, mit der darüberliegenden. Sitzt der
Cursor in der ersten Zeile, so wird das Kommando ignoriert.
!subnode Zeichen wandeln

!index Zeichen !! wandeln
(!KEY)Alternate -(!key) (Ziffernblock) verwandelt das unter dem Cursor
befindliche Zeichen in Kleinschrift. Der Cursor wird um eine Position nach
rechts gesetzt.

(!KEY)Alternate +(!key) (Ziffernblock) verwandelt das unter dem Cursor
befindliche Zeichen in Gro₧schrift. Der Cursor wird um eine Position nach
rechts gesetzt.

!index Zeichen !! tauschen
!index Vertauschen !! Zeichen
(!KEY)Alternate~.(!key) (Ziffernblock) vertauscht die beiden Zeichen links
des Cursors.

#}}}

#*****************************************************************
!newpage
!node Suchen und Ersetzen
#{{{
!subnode Suchen

!index Suchen
(!KEY)Control F(!key) bzw. der Menüpunkt (!EM)Edit/Suchen(!em) dient zur Suche eines
Textmusters. Folgender Dialog ermöglicht die Eingabe von zehn verschiedenen
Suchmustern, die über eine Pfeilbox umgeschaltet werden
können. Wissenswert ist in diesem Zusammenhang, da₧ Clix Zeilenenden
intern als Linefeed abspeichert. Mit (!KEY)Control J(!key) kann man dieses in
GEM-Eingabefeldern eingeben, so da₧ Zeilenenden gesucht oder ersetzt werden
können.

(!KEY)Shift Control F(!key) startet die Suche eines Textmusters rückwärts.

!begin_center
(!IMAGE [Images/clixfind])
!end_center

Normalerweise wird die Suche ab der Cursorposition begonnen, ist jedoch der
Button (!EM)Ab Textanfang(!em) aktiviert, so wird die Suche ab dem Textanfang
durchgeführt.

Die Option (!EM)Gro₧/Klein ignorieren(!em) führt dazu, da₧ bei der Suche kein
Unterschied zwischen Gro₧- und Kleinbuchstaben gemacht wird. (!EM)Wort(!em) wäre
also gleichbedeutend mit (!EM)wort(!em).

Die Option (!EM)Einzelwort(!em) dient dazu, nur Einzelwörter zu finden. Will man
beispielsweise alle im Text stehenden (!EM)ein(!em) finden, so würden im normalen
Suchmodus auch Wörter gefunden, die (!EM)ein(!em) enthalten, wie etwa
(!EM)einmalig(!em) oder (!EM)Lateinisch(!em). Im Einzelwortmodus jedoch werden
tatsächlich nur die einzelnen Wörter (!EM)ein(!em) gefunden.

(!EM)In Blockfaltung(!em) bewirkt, da₧ sich die Suche auch auf gefaltete Blocks
erstreckt. Durch Abschalten dieser Option und Wegfalten bestimmter Textteile
lä₧t sich also der Suchbereich flexibel einschränken. Wird ein gefalteter
Block aufgeklappt, um eine Fundstelle anzuzeigen, so erscheint folgender
Alert:

!begin_center
(!IMAGE [Images/clixfoun])
!end_center

(!EM)Ja(!em) faltet den Block wieder ein sucht das nächste Vorkommen, (!EM)Nein(!em)
stoppt den Vorgang, und (!EM)Falten(!em) faltet den Block und sucht nach dessen
Ende weiter (bzw. vor seinem Anfang, je nach Suchrichtung).

Wurde ein Block markiert, so lä₧t sich die Suche auch auf den Blockbereich
begrenzen. Dazu mu₧ die Option (!EM)Blockbereich(!em) aktiviert werden.

Die Radiobuttons (!EM)Vorwärts(!em) bzw. (!EM)Rückwärts(!em) ermöglichen es
nachträglich, die Suchrichtung festzulegen.

Neben diesen Optionen kann noch ein sogenanntes Jokerzeichen definiert
werden. Im Normalfall ist dies ein Fragezeichen. Gibt man dieses Jokerzeichen
in einem Suchbegriff ein, so werden alle Stellen im Text angesprungen, die
mit dem Suchbegriff bis auf dieses Zeichen übereinstimmen. Sucht man
beispielsweise nach (!EM)M?st(!em), so würde sowohl das Wort (!EM)Mast(!em) als auch das
Wort (!EM)Most(!em) angesprungen.

(!EM)Manual(!em) sucht den eingegebenen Begriff im Online-Manual. Dies ist auch
dann möglich, wenn kein Text geöffnet ist. (!EM)Start(!em) beginnt die Suche nach
dem eingegebenen Begriff im aktuellen Text.

(!EM)OK(!em) übernimmt die Einstellungen des Dialoges, ohne eine Suche
durchzuführen, während (!EM)Abbruch(!em) alle Einstellungen unverändert lä₧t.

(!KEY)Alternate F(!key) oder der Menüpunkt (!EM)Edit/Weitersuchen(!em) setzt die Suche
nach dem zuletzt definierten Suchbegriff ab der Cursorposition vorwärts
fort, ohne den Dialog erneut zu öffnen.

(!KEY)Shift Alternate F(!key) sucht den zuletzt eingegebenen Begriff ab der
Cursorposition rückwärts, ohne den Dialog zu öffnen.

(!KEY)Control Alternate F(!key) sucht das erstmalige Vorkommen des eingegebenen
Suchbegriffs im Text, ohne den Dialog erneut zu öffnen.

(!KEY)Shift Control Alternate F(!key) sucht das letzte Vorkommen des eingegebenen
Begriffs im Text, ohne den Dialog zu öffnen.

Eine Blockoperation erleichtert die Übernahme eines Suchbegriffs aus dem
Text in die Dialogbox:

!index Block !! als Suchbegriff
!index Suchen !! Block als Suchbegriff
(!KEY)Alternate M(!key) übernimmt den markierten Block als Suchbegriff. Da die
Länge des Suchbegriffes begrenzt ist, wird, falls der markierten Block zu
lang ist, der Rest abgeschnitten.


!subnode Globale Suche
!index Suchen !! global

Um einen schnellen Zugriff auf alle Stellen eines Textes zu erhalten, die
einen bestimmten Begriff enthalten, kann man auf die sogenannte (!EM)globale
Suche(!em) zurückgreifen. (!KEY)Control G(!key) öffnet folgenden Dialog:

!begin_center
(!IMAGE [Images/clixgfin])
!end_center

Für die Suche stehen neun unabhänige Eingabefelder für den Suchbegriff zur
Verfügung. (!KEY)Suchen(!key) startet die globale Suche im aktuellen Text. In der
darüberliegenden Scroll-Liste werden die Zeilenanfänge aller gefundenen
Stellen aufgelistet. Um an eine der Stellen im Text zu springen wird der
Selektions-Balken mittels Cursor-Tasten auf die gewünschten Stelle
positioniert und über (!KEY)Return(!key) angesprungen. Alternativ kann auch ein
Doppelklick auf den gewünschten Eintrag erfolgen. (!KEY)Home(!key) bzw. (!KEY)Shift
Home(!key) positioniert den Selektions-Balken auf den Anfang bzw. das Ender der
Liste. Bei der Suche werden einige Optionen beürcksichtigt, die von normalen
Textsuche schon bekannt sind. Da maximal 256 Fundstellen verwaltet werden,
sollte der Suchbereich über diese Optionen sinnvoll eingeschränkt werden.


!subnode Inkrementelle Suche
!index Suchen !! inkrementell

(!KEY)Control O(!key) und der Menüpunkt (!EM)Edit/Inkrementell...(!em) erlauben eine
sogenannte inkrementelle Suche von Zeichenketten im Text. Es erscheint ein
Anzeige-Box mit dem aktuellen Suchbegriff und der Suchrichtung. Zunächst ist
der Suchbegriff leer und die Suche erfolgt nach unten. Wird nun ein Zeichen
eingegeben, so wird dieses an das Suchmuster angehängt und der Cursor wird an
die nächste passende Stelle im Text positioniert.

(!KEY)Return(!key) wird als Zeilenende interpretiert und ebenfalls angehängt.

(!KEY)Backspace(!key) löscht das letzte Zeichen im Suchtext und springt zur letzten
passenden Position zurück.

(!KEY)Esc(!key) löscht das komplette Suchmuster.

(!KEY)Auf/Ab(!key) kehrt die Suchrichtung um und startet den Suchvorgang erneut. In
Kombination mit (!KEY)Shift(!key) wird das erste bzw. letzte Vorkommen des Musters
gesucht. Die Taste (!KEY)Control(!key) beschränkt die Suche zusätzlich auf einzelne
Worte.

(!KEY)Undo(!key) beendet die inkrementelle Suche und schlie₧t die Anzeige-Box.

Bei einer erneuten inkrementellen Suche bleibt das Suchmuster erhalten. In
gefalteten Blöcken wird ebenfalls gesucht. Diese werden zu diesem Zweck
temporär aufgeklappt.

(!KEY)Shift Control O(!key) startet die inkrementelle Suche von der aktuellen
Cursorposition nach oben.

!subnode Ersetzen

!index Ersetzen
(!KEY)Control R(!key) oder der Menüpunkt (!EM)Edit/Ersetzen(!em) dient zur Suche und zur
Ersetzung von Textteilen.

(!KEY)Shift Control R(!key) startet die Operation rückwärts.

Es erscheint folgende Dialogbox:

!begin_center
(!IMAGE [Images/clixrepl])
!end_center

Der Dialog bietet jeweils zehn Such- und Ersetzungstexte, zwischen denen über
eine Pfeilbox  umgeschaltet werden kann. Wird für den Suchen- und den
Ersetzungstext dieselbe Zeichenkette ausgewählt, so werden beide
Editierfelder simultan bearbeitet. Die meisten Buttons entsprechen den
Optionen des Kommandos (!EM)Suchen(!em). Ist der Button (!EM)Fragen(!em) aktiv, so wird
vor jeder Ersetzung eine Sicherheitsabfrage durchgeführt. Dazu wird an der
betreffenden Stelle eine verschiebbare Dialogbox geöffnet, die vier
verschiedene Eingaben kennt:

!begin_center
(!IMAGE [Images/clixrequ])
!end_center

(!EM)Letztes(!em) ersetzt die zuletzt gefundene Stelle und bricht dann den
Suchvorgang ab. (!EM)Ja(!em) ersetzt die gefundene Stelle und fährt mit der Suche
fort. (!EM)Nein(!em) ersetzt die gefundene Stelle nicht, fährt aber mit der Suche
nach dem nächsten Begriff fort. (!EM)Abbruch(!em) bricht den Suchvorgang sofort
ab, ohne eine Ersetzung durchzuführen.

(!KEY)Alternate R(!key) setzt das Suchen und Ersetzen ab der Cursorposition mit den
zuletzt eingegebenen Begriffen fort, ohne den Dialog erneut zu öffnen.

(!KEY)Shift Alternate R(!key) setzt das Suchen und Ersetzen ab der Cursorposition
rückwärts fort, ohne den Dialog zu öffnen.

(!KEY)Control Alternate R(!key) setzt das Suchen und Ersetzen ab dem Textanfang mit
Nachfrage fort, ohne den Dialog zu öffnen.

(!KEY)Shift Control Alternate R(!key) setzt das Suchen und Ersetzen ab dem Textende
mit Nachfrage fort, ohne den Dialog zu öffnen.

Eine weitere Blockoperation erleichtert die Übernahme eines
Ersetzungsbegriffes aus dem Text in die Dialogbox:

!index Block !! als Ersetzungsbegriff
!index Ersetzen !! Block als Ersetzungsbegriff
(!KEY)Shift Alternate M(!key) übernimmt den markierten Block als
Ersetzungsbegriff. Da die Länge des Ersetzungsbegriffes begrenzt ist, wird
der Rest abgeschnitten, falls der markierte Block zu lang ist.

Beim Suchen und Ersetzen ohne Nachfragen wird die Anzahl der durchgeführten
Ersetzungen in der Menüleiste mitgezählt. Ist die Option (!EM)Nach
Suchen+Ersetzen Meldung(!em) aktiviert, zeigt am Ende des Kommandos ein Alert
die Anzahl der Ersetzungen an.

!subnode Mehrfaches Ersetzen
!index Ersetzen !! mehrfaches
!index Mehrfaches Ersetzen

Manchmal ist es nötig, in einem Text mehrere verschiedene Ersetzungen
durchzuführen, etwa wenn man zwei Begriffe A und B vertauschen will; dazu
ersetzt man A durch ein im Text sonst nicht vorkommendes Muster X, danach
B durch A, und schlie₧lich X durch B. Um diese und ähnliche
Operationen zu vereinfachen und beschleunigen, wurde die Option (!EM)Mehrfach(!em)
eingeführt. Sie beachtet die Optionen (!EM)Einzelwort(!em), (!EM)Gro₧/Klein
ignorieren(!em) sowie (!EM)Fragen(!em). Vor dem Start des Ersetzens erscheint
zusätzlich folgender Dialog:

!begin_center
(!IMAGE [Images/clixmult])
!end_center

In dem Eingabefeld kann man nochmals die Such- und Ersetzungsbegriffe ansehen
und verändern. Im unteren Teil kann man sechs Indexpaare der gewünschten
Begriffe in der Form (!EM)Suchindex -> Ersetzungsindex(!em) eingeben.
Leere Paare werden übersprungen. Erst wird die linke, dann die rechte Spalte
abgearbeitet --- die Spalten wiederum zeilenweise von oben nach unten. Im
obigen Beispiel wäre also (mit 0=A, 1=B, 2=X) folgendes einzugeben:
(!EM)0 -> 2, 1 -> 0, 2 -> 1(!em).

!subnode Suchen und Ersetzen in Dateien

!index Dateilisten
!label FileReplace
Um z.B. in grö₧eren Programmier- oder (!TeX)-Projekten, die aus vielen Dateien
bestehen, komfortabel das Vorkommen bestimmter Begriffe finden oder globale
Ersetzungen durchführen zu können, kann Clix diese Operationen auch auf
Dateien durchführen. Dazu wird eine Dateiliste benötigt --- das ist ein Text,
der zeilenweise ausschlie₧lich Dateinamen enthält. Solch eine Liste ist
leicht zu erzeugen, indem man einen neuen Text anlegt und mittels
(!EM)Edit/Dateinamen einfügen(!em) die gewünschten
Dateinamen in den Text einflie₧en lä₧t. Es wird immer der oberste Text als
Dateiliste verwendet.

Clix bearbeitet nur die Dateien, deren Namen direkt am Zeilenanfang beginnen.
Bereits abgearbeitete Dateien werden um eine Tabulatorposition eingerückt,
so da₧ bei einem etappenweisen Vorgehen nicht dieselben ersten paar Dateien
immer wieder von neuem bearbeitet werden.

Um alle Dateien wieder von neuem zu aktivieren, bietet es sich an, mittels
(!EM)Block/Markiere alles(!em) den Text zu markieren und mit (!KEY)Alternate <(!key)
wieder nach links auszurücken.


!index Suchen !! in Dateien
Au₧er der Dateiliste benötigt man zum Suchen noch
möglichst viele unbenutzte Texte, d.h. vor dem Starten der Aktion sollten
möglichst wenige Texte geöffnet sein. Clix lädt nun nacheinander die in der
Liste gefundenen Dateien. Texte, in denen der Suchbegriff nicht gefunden
wurde, werden sofort wieder aus dem Speicher entfernt. Die Operation bricht
ab, wenn keine Texte bzw. AES-Fenster mehr frei sind oder wenn die Liste
komplett abgearbeitet wurde. Konnte die Liste nicht komplett verarbeitet
werden, kann man nach Entfernen einiger Texte aus dem Speicher mit derselben
Liste fortfahren, um auch die restlichen Dateien zu durchsuchen.


!index Ersetzen !! in Dateien
Au₧er der Dateiliste benötigt man zum Ersetzen
noch einen unbenutzten Text. Die Dateien werden sukzessive geladen und die
Ersetzungen durchgeführt. Wurde (!EM)Fragen(!em) aktiviert, wird am Ende eines
Textes zusätzlich nachgefragt, ob er abgespeichert werden soll --- ist
(!EM)Fragen(!em) jedoch inaktiv, so wird ohne Nachfrage ersetzt und abgespeichert.


Noch einige Hinweise zu diesen doch recht komplexen Funktionen:
!begin_itemize
!item  Die Kombination mehrfaches Ersetzen auf Dateien ohne Nachfrage eignet
      sich besonders zu schnellen globalen Änderungen an einem Projekt.
!item  !.. oder zur globalen Verunstaltung desselben. Prüfen Sie daher
      sorgfältig Ihre Ersetzungspaare und deren Reihenfolge, damit nicht
      durch eine Flüchtigkeit ein --- dann ebenfalls globaler --- Fehler
      entsteht.
!item  die Texte, in denen der Suchbegriff nicht gefunden wurde sowie
      sämtliche beim Ersetzen geladenen Texte werden nicht in die Liste der
      letzten 10 Dateien übernommen.
!item  der Vorgang lä₧t sich durch Drücken von (!KEY)Shift(!key) oder (!KEY)Control(!key)
      unterbrechen.
!end_itemize


#}}}

#*****************************************************************
!newpage
!node Blockoperationen
#{{{
Um Textblöcke manipulieren zu können, existiert ein spezieller Blockpuffer,
dessen Grö₧e über den Dialog (!EM)Optionen/Allg. Optionen...(!em)
festgelegt werden kann. Um eine unnötige Speicherfragmentierung zu
vermeiden, ist dies nur möglich, wenn keine Texte geladen sind. Im
Blockpuffer werden beispielsweise gelöschte Textblöcke gesichert, um diese
bei Bedarf restaurieren zu können. Folgende Operationen beeinflussen bzw.
nutzen diesen Puffer: (!EM)Block ausschneiden(!em), (!EM)Block merken(!em), (!EM)Block
an Puffer anhängen(!em), (!EM)Block aus Puffer einfügen(!em), (!EM)Block
kopieren(!em)
und (!EM)Block verschieben(!em).

!index Klemmbrett
Alternativ lä₧t sich statt des internen Blockpuffers das sogenannte
GEM-Klemmbrett verwenden (das GEM-Klemmbrett ist ein Ordner, dessen Pfad
von GEM verwaltet wird --- meistens C:\CLIPBRD\; ist kein solcher
Ordner vorhanden, legt Clix ihn an, und als Blockpuffer wird die Datei
(!REF)SCRAP.TXT(!ref) im Klemmbrettordner verwendet). Zwischen den beiden
Möglichkeiten wird über (!KEY)Shift Control G(!key) oder den Menüpunkt
(!EM)Block/Verwenden(!em) umgeschaltet. Ist das Klemmbrett aktiv, so erscheint in
der Menüleiste das Zeichen ""C"". Ist der Blockspeicher für die Operationen
Merken, Kopieren oder Verschieben nicht gro₧ genug, so wird automatisch auf
das Klemmbrett umgeschaltet.

Ist das Clipboard-Accessory von Dieter und Jürgen Gei₧ angemeldet, so kann
man sich den Inhalt des Klemmbretts über den Menüpunkt (!EM)Block/Anzeigen(!em)
anzeigen lassen. Dazu wird vom Accessory ein Fenster geöffnet, das den Inhalt
des Klemmbretts enthält. Ist kein solches Accessory geladen, so erfolgt die
Anzeige des Klemmbretts (SCRAP.TXT) in einem nicht editierbaren Fenster des
Editors. Beim nächsten Ausschneiden eines genügend kleinen Textteils wird
diese Option automatisch ausgeschaltet.

!subnode Block markieren

!index Block !! markieren
Ein Block lä₧t sich sowohl über die Maus als auch über die Tastatur
markieren. Hält man die linke Maustaste gedrückt, so wird der überstrichene
Text markiert. Die Anzeige der Markierung erfolgt durch Invertierung des
entsprechenden Textbereiches. Überschreitet der Mauszeiger die Fenstergrenzen
an irgendeiner Seite, so wird der Fensterausschnitt entsprechend verändert.
Ein markierter Blockbereich lä₧t sich durch Gedrückthalten der rechten
Maustaste oder der (!KEY)SHIFT(!key)-Taste erweitern. Wird die linke Maustaste
vor dem markierten Blockbereich gedrückt, so lä₧t sich der Blockanfang
verändern. Befindet sich die Maus hinter der Blockmarkierung, so lä₧t sich
das Blockende verschieben. Falls der Benutzer einen Doppelklick auf einen
leeren Fensterbereich ausführt, so werden die Blockmarkierungen aufgehoben.

!index Spaltenblock
Neben der normalen Blockmarkierung, bei der der komplette Text zwischen dem
Blockanfang und -ende markiert wird, steht ein sogenannter Spaltenblock zur
Verfügung, der eine rechteckige Markierung von Textbereichen ermöglicht. Der
Blockanfang ist dann der linke obere und das Blockende die rechte untere Ecke
der Markierung. Die Erweiterung eines solchen Spaltenblocks geschieht analog
zur normalen Blockmarkierung. (!KEY)Control F4(!key) bzw. der Menüpunkt
(!EM)Optionen/Spaltenblock(!em) schaltet zwischen den beiden Blocktypen um.
Spaltenblöcke verhalten sich bei den Operationen Ausschneiden, Kopieren,
Einfügen oder Drucken wie normale Blöcke. Auch das Verschieben eines
Spaltenblocks innerhalb der Markierung ist möglich. Ist Spaltenblock aktiv,
dann erscheint in der Menüleiste der Buchstabe ""S"".

Editiert man eine Zeile, so bleibt der markierte Block erhalten. Es wird
jedoch dafür gesorgt, da₧ weder der Blockanfang noch das Blockende in der
aktuellen Zeile liegen. Die Markierung wird gegebenenfalls verändert. Die
editierte Zeile kann also nur komplett innerhalb oder komplett au₧erhalb der
Blockmarkierung liegen.

!index Text !! markieren
(!KEY)Control A(!key) oder der Menüeintrag (!EM)Block/Alles(!em) markiert den gesamten
Text als Block.

(!KEY)Control B(!key) oder der Menüeintrag (!EM)Block/Anfang(!em) markiert ebenfalls
den Blockanfang.

(!KEY)Control K(!key) oder der Menüeintrag (!EM)Block/Ende(!em) markiert ebenfalls das
Ende eines Blocks.

(!KEY)Control H(!key) oder der Menüpunkt (!EM)Block/Aufheben(!em) hebt die aktuelle
Blockmarkierung wieder auf. Dies lä₧t sich auch durch einen Doppelklick auf
ein Leerzeichen im Text bewirken. Ist kein Block markiert, stellt
(!KEY)Control H(!key) den vorherigen Block wieder her, falls möglich.

(!KEY)Shift Control H(!key) hebt die Blockmarkierung auf jeden Fall auf, sie ist
dann auch nicht mit (!KEY)Control H(!key) wiederherstellbar.

!subnode Klammerung oder Wort markieren

!index Wort !! markieren
Ein Doppelklick auf eine Klammer (öffnend oder schlie₧end) oder (!KEY)Control
M(!key) bzw. der Menüeintrag (!EM)Block/Wort(!em) markiert den eingeklammerten
Textbereich als Block. Dabei wird die logische Klammerhierarchie
berücksichtigt. Über den Dialog (!EM)Optionen/Sonderzeichen...(!em) lassen
sich maximal sechs Sequenzen als Klammersymbole anmelden. Auch eine mehrfache
Verschachtelung von Klammern wird richtig markiert.

Befindet sich unter dem Cursor bzw. Mauszeiger weder eine öffnende, noch
eine schlie₧ende Klammer, so wird versucht, an der Stelle ein Wort zu
markieren, das aus Buchstaben, Ziffern und dem Unterstrich bestehen darf. Ist
auch dies nicht möglich, so wird das Zeichen unter dem Cursor markiert.

Hält man beim Doppelklick auf ein Wort bzw. eine Klammer die
(!KEY)Control(!key)-Taste gedrückt, so wird der markierte Block an die aktuelle
Cursorposition kopiert. Drückt man (!KEY)Alternate(!key), so wird der markierte
Block verschoben.

!subnode Cursor-Positionierung

!index Springen !! zum Blockanfang und -ende
(!KEY)Alternate B(!key) setzt den Cursor an den Anfang des Blocks. Ist kein Block
markiert, so wird der Cursor an den Anfang des Dokumentes bewegt.

(!KEY)Alternate K(!key) setzt den Cursor an das Ende des Blocks. Ist kein Block
markiert, so wird der Cursor an den Anfang des Dokumentes bewegt.

!subnode Block wandeln

!index Block !! wandeln
(!KEY)Control Alternate - (Ziffernblock)(!key) verwandelt alle Zeichen des Blocks
in Kleinschrift. Ist kein Block markiert, so wird vorher versucht, an der
aktuellen Cursor-Position ein Wort oder eine Klammerung zu markieren.

(!KEY)Control Alternate + (Ziffernblock)(!key) verwandelt alle Zeichen des Blocks
in Gro₧schrift. Ist kein Block markiert, so wird vorher versucht, an der
aktuellen Cursor-Position ein Wort oder eine Klammerung zu markieren.


!subnode Block kopieren

!index Block !! kopieren
!index Kopieren !! Block
(!KEY)Alternate C(!key) oder der Menüeintrag (!EM)Block/Kopieren(!em) kopiert den
markierten Block an die aktuelle Cursorposition. Dies funktioniert auch
textübergreifend, d.h. man kann über diese Operation Textauschnitte von
einem Text in einen anderen übernehmen.

!subnode Block verschieben

!index Verschieben !! Block
!index Block !! verschieben
!index Einrücken !! Block
!index Block !! einrücken

(!KEY)Alternate V(!key) oder der Menüeintrag (!EM)Block/Verschieben(!em) verschiebt den
markierten Block an die aktuelle Cursorposition. Dies funktioniert ebenfalls
textübergreifend.

!label BlockSchieben
(!KEY)Control Alternate <(!key) bzw.
 (!KEY)Shift Control Alternate <(!key) verschiebt einen markierten Block in horizontaler Richtung um
eine Tabulatorweite nach links bzw. rechts. Dazu werden ggf. vorher die
Blockgrenzen auf die Zeilenanfänge gesetzt.

!subnode Block ausschneiden

!index Block !! ausschneiden
(!KEY)Control X(!key), (!KEY)Alternate Y(!key) oder der Menüeintrag
(!EM)Block/Ausschneiden(!em) entfernt den markierten Block aus dem Text, nachdem
er in den globalen Blockpuffer übernommen wurde. Der gelöschte Block kann
über die Operation (!EM)Block aus Puffer einfügen(!em) ((!KEY)Control V(!key))
wiederhergestellt werden.

!subnode Block löschen

!index Block !! löschen
!index Löschen !! Block
(!KEY)Control Alternate X(!key) löscht den markierten Block. Der gelöschte Text
wird (!B)nicht(!b) in den globalen Blockpuffer übernommen und kann daher nicht
mehr wiederhergestellt werden.

!subnode Block merken

!index Block !! merken
(!KEY)Control C(!key) bzw. der Menüpunkt (!EM)Block/Merken(!em) speichert den
markierten Block im globalen Blockpuffer bzw. sichert ihn auf dem
GEM-Klemmbrett.

Die Standardkommandos (!KEY)Control X/C/V(!key) hei₧en üblicherweise
(!EM)Ausschneiden(!em), (!EM)Kopieren(!em) und (!EM)Einsetzen(!em). Clix nennt dieses
(!EM)Kopieren(!em) allerdings (!EM)Merken(!em), um Verwechslungen mit der komfortablen
zusammengesetzten Operation (!EM)Kopieren(!em) = (!EM)Merken(!em) +
(!EM)Einsetzen(!em)
zu vermeiden, die auch verfügbar ist. (!EM)Verschieben(!em) entspricht übrigens
(!EM)Ausschneiden(!em) + (!EM)Einsetzen(!em).

!subnode Block an Puffer anhängen

(!KEY)Shift Control C(!key) oder der Menüpunkt (!EM)Block/Anhängen(!em) hängt den gerade
definierten Block an den Blockpuffer bzw. das GEM-Klemmbrett an.

!subnode Block aus Puffer einsetzen

!index Block !! einsetzen
(!KEY)Control V(!key) bzw. der Menüpunkt (!EM)Block/Einsetzen(!em) fügt den Inhalt des
globalen Blockpuffers bzw. den des GEM-Klemmbrettes an der aktuellen
Cursorposition ein.

!subnode Block als Suchbegriff übernehmen

!index Suchen !! Block
(!KEY)Alternate M(!key) übernimmt den markierten Block als Suchbegriff für das
Kommando (!EM)Suchen(!em). Da die Länge des Suchbegriffes begrenzt ist, wird der
Rest abgeschnitten, falls der markierte Block zu lang ist.

!subnode Block als Ersetzungsbegriff übernehmen

!index Ersetzen !! durch Block
(!KEY)Shift Alternate M(!key) übernimmt den markierten Block als
Ersetzungsbegriff für das Kommando (!EM)Ersetzen(!em). Da die Länge des
Ersetzungsbegriffes begrenzt ist, wird der Rest abgeschnitten, falls der
markierte Block zu lang ist.

!subnode Block auskommentieren

!index Block !! auskommentieren
(!KEY)Control Alternate H(!key) kommentiert einen markierten Block aus. Als
Kommentarzeichen werden die über den Dialog
(!EM)Optionen/Sonderzeichen...(!em) ausgewählten Symbole verwendet. Falls der
Block bereits auskommentiert war, werden die Kommentarzeichen wieder
entfernt.

!subnode Block laden

!index Block !! laden
(!KEY)Shift Alternate V(!key) liest eine über eine Dateiauswahlbox spezifizierte
ASCII-Datei an der Cursorposition ein und markiert sie als Block.

!subnode Block speichern

!index Block !! speichern
(!KEY)Shift Alternate C(!key) speichert einen markierten Block als ASCII-Datei ab.
Der Name wird über eine Dateiauswahlbox spezifiziert.

!subnode Block wegfalten

!index Block !! wegfalten
!index Faltung !! von Blöcken
(!KEY)Control J(!key) faltet einen markierten Block ein(!N)Aus technischen
Gründen wird dabei ggf. die Markierung so verkleinert, da₧ sich keine
Leerzeilen mehr am Anfang oder Ende des Blocks befinden.(!n) bzw. aus. Dies
bedeutet, da₧ nur noch seine erste Zeile zu sehen ist, der Rest bleibt
verborgen und wird durch eine gepunktete Linie angedeutet. Diese Zeile ist
nicht editierbar (und kann auch nur als Ganzes als Block markiert werden),
da sie ja einen ganzen Block repräsentiert. Für Änderungen mu₧ der Block
wieder aufgeklappt werden. Steht der Cursor über einer Blockfaltung, so kann
diese durch (!KEY)Control J(!key) aufgehoben werden.

Durch diese Möglichkeit kann man in einem Dokument etwa Kapitel, Prozeduren
oder (!TeX)-(!V)\section(!v)s verbergen, und es ist nur noch die Struktur des
Dokuments sichtbar. Nur die Stellen, an denen man arbeiten möchte, klappt man
jeweils auf.

Gefaltete Blöcke können auch zur Einschränkung des Suchbereichs verwendet
werden.

Die Faltung eines Blocks gilt nicht als Änderung eines Textes und kann daher
auch in einem (!EM)nicht editierbaren(!em) Dokument und dem Manual-Fenster
erfolgen.

!subnode Block aufklappen

!index Block !! aufklappen
(!KEY)Control J(!key) oder ein Doppelklick auf die Kopfzeile eines gefalteten
Blocks klappt diesen wieder aus; anschlie₧end ist der aufgeklappte Bereich
markiert, kann also mit (!KEY)Control J(!key) sofort wieder eingeklappt werden.

(!KEY)Shift Control J(!key) klappt alle eingeklappten Blöcke auf.

Wird ein gefalteter Block automatisch aufgeklappt, z.B. durch den Sprung auf
eine Zeile mit (!EM)Blockfaltung ignorieren(!em), so kann mit (!KEY)Control H(!key) der
aufgeklappte Bereich wieder markiert werden.


#}}}

#*****************************************************************
!newpage
!node Einrücken
#{{{
(!T)Clix(!t) bietet verschiedene Möglichkeiten, einzelne Zeilen oder ganze Blöcke
horizontal zu verschieben und um den Cursor beim Einfügen einer neuen Zeile
automatisch an eine bestimmte Stelle zu setzen.

Soll der Cursor beim Einfügen einer neuen Zeile automatisch
unter das erste Zeichen der vorhergehenden Zeile gesetzt werden,
so aktiviert man (!EM)Automatisches Einrücken(!em) unter den Textoptionen.

Daneben gibt es noch eine weitere Möglichkeit, automatisch einzurücken: das
""intelligente Einrücken"".

!label indentation
!index CLIX.IND
!index Einrücken !! intelligentes
!index Intelligentes Einrücken

In der Datei (!REF)CLIX.IND(!ref) befinden sich Definitionen von Schlüsselwörtern
für ""intelligentes Einrücken"" (indentation = [engl.] Einrückung).

Die Datei (!REF)CLIX.IND(!ref) wird im aktuellen Pfad von (!T)Clix(!t) bzw. in dem Pfad,
der über die Environment-Variablen (!REF)CLIXPAR(!ref) oder (!REF)CLIX(!ref) definiert
ist, geladen.

Jede Zeile definiert ein Schlüsselwort samt Einrückverhalten bei der Eingabe
von (!KEY)RETURN(!key), (!KEY)ENTER(!key) oder (!KEY)INSERT(!key) und startet mit

!begin_table [ll]
  (!V)->(!v) !! Folgezeile nach rechts rücken,
  (!V)<-(!v) !! diese Zeile zur voranstehenden Zeile nach links rücken,
  (!V)<>(!v) !! diese Zeile nach links rücken (!B)und(!b) Folgezeile nach rechts rücken,
!end_table

gefolgt vom Schlüsselwort.

Enthält die Datei (!REF)CLIX.IND(!ref) z.B. folgende Zeilen

!begin_verbatim
-> BEGIN
-> DEFINITION
-> CONST
-> FOR
-> IF
-> IMPLEMENTATION
-> LOOP
-> MODULE
-> RECORD
-> REPEAT
-> TYPE
-> VAR
-> WHILE
-> WITH
<> ELSE
<> ELSIF
<- END
<- UNTIL
!end_verbatim


so führt dies bei der Eingabe von Modula-2-Quelltexten zu Einrückungen
in der Form

!begin_verbatim
        IF Bedingung THEN
          ...
        ELSIF bedingung THEN
          ...
        ELSE
          ...
        END
!end_verbatim

und analog für REPEAT-UNTIL, WHILE-END usw.

Die Datei wird jeweils beim Starten von (!T)Clix(!t) geladen. Man kann ihren Inhalt
im Dialog (!EM)Text-Optionen(!em) über den Knopf (!EM)Einrückungen(!em) kontrollieren.

Ist ein intelligentes Einrücken nicht erwünscht, kann man eine leere Datei
(!REF)CLIX.IND(!ref) hinterlegen oder die Datei (!REF)CLIX.IND(!ref) löschen;
eine Fehlermeldung von (!T)Clix(!t) erfolgt hierbei nicht.

#}}}

#*****************************************************************
!newpage
!node Makros
#{{{
Clix unterstützt drei verschiedene Arten von Makros, nämlich Text-,
Tastatur- und makros.

!index Makrodatei
(!KEY)Alternate F5(!key) oder der Menüpunkt (!EM)Edit/Lesen-Sichern(!em) lädt bzw.
speichert die Makrodefinitionen. Es erscheint eine Dialogbox, über die man
auswählen kann, ob man die definierten Makros speichern oder eine andere
Makrodefinition laden will. Bei Start von Clix wird versucht, die
zuletzt benutzte Makrodatei wieder einzulesen.

Das Utility (!T)MAK.TTP(!t) ist in der Lage, den Inhalt einer solchen Makrodatei
anzuzeigen.
#}}}

!subnode Textmakros
#{{{
!index Makro !! Text
Textmakros bieten die Möglichkeit, häufig benötigte Zeichenfolgen per Taste
automatisch in den laufenden Text einfügen zu lassen. Daher werden sie auch
häufig Floskeln
!index Floskeln
genannt. Ein definierter Block kann über
(!KEY)F5(!key) oder den Menüpunkt (!EM)Edit/Definieren(!em) als Textmakro übernommen
werden. Jedem Makro ist ein bestimmtes Zeichen zugeordnet, über das es
aufgerufen werden kann. Mit (!KEY)Esc(!key), gefolgt von diesem Zeichen, wird der
zugehörige Makrotext an der Cursorposition eingefügt.

Eine Sonderstellung nimmt das Zeichen (!Delta) sowie einige $-Sequenzen
ein. Die Eingabe dieses Zeichens kann über den Sonderzeichendialog oder den
Ziffernblock bei gedrückter (!KEY)Alternate(!key)-Taste erfolgen (ASCII 127). Es
symbolisiert innerhalb eines Textmakros die Position des Cursors nach
Einfügen des Makrotextes. Hat man beispielsweise (!T)IF (!Delta) THEN(!t) als
Textmakro definiert, so wird (!T)IF  THEN(!t) in den Text eingefügt. Der Cursor
steht dann zwischen (!T)IF(!t) und (!T)THEN(!t).

Folgende $-Sequenzen werden innerhalb eines Textmakros expandiert:

!begin_center
!begin_table [|c|l|]
!hline
$H !! Stunden (2-stellig)
$M !! Minuten (2-stellig)
$S !! Sekunden (2-stellig)
!hline
$d !! Tag (2-stellig)
$m !! Monat (2-stellig)
$y !! Jahreszahl (2-stellig)
$Y !! Jahreszahl (4-stellig)
!hline
$B !! Zeichen links der Cursorposition löschen (Backspace)
$D !! Zeichen an Cursorposition löschen (Delete)
$C !! Cursorposition nach Ausführung des Makros (enspricht (!Delta))
$$ !! Dollarzeichen ($)
!hline
!end_table
!end_center

Ist kein Block markiert, so hat man über (!KEY)F5(!key) oder den Menüpunkt
(!EM)Edit/Löschen(!em) die Möglichkeit, ein definiertes Makro zu löschen.
#}}}

!subnode Tastaturmakros
#{{{
!index Makro !! Tastatur
Um eine Folge von Tastatureingaben als Makro zusammenzufassen, bedient man
sich eines Tastaturmakros. Die Definition eines solchen Makros wird über
(!KEY)Control Esc(!key) eingeleitet. Den Lernmodus erkennt man daran, da₧ die Maus
als Biene dargestellt wird, der Cursor nicht blinkt und ein ""M"" in der
Menüleiste erscheint. Die jetzt eingegebene Tastenfolge wird solange
aufgezeichnet, bis entweder der Makrospeicher voll ist, oder die
Makrodefinition über (!KEY)Control Esc(!key) beendet wurde. Eine aufgezeichnete
Sequenz kann über (!KEY)Alternate Esc(!key) aktiviert werden. Sie wird nicht in
der Makrodatei gesichert, dazu ist sie einer Taste zuzuordnen (s.u.). Wurde
zum Beispiel folgendes Makro definiert,

(!V)      Control Esc , Shift Rechts , F2 , Cursor Ab , Control Esc (!v)

so wird beim Aufruf das letzte Wort einer Zeile gelöscht und der Cursor um
eine Zeile nach unten gesetzt, ohne da₧ eine Dialogbox geöffnet wird.
Innerhalb von Tastaturmakros sind übrigens auch Textmakros möglich.

Mit (!KEY)Shift F5(!key) oder dem Menüpunkt (!EM)Edit/Tastenmakro(!em) kann ein
solcherma₧en aufgenommenes Makro einer beliebige Taste (samt
Sondertastenstatus) zugeordnet werden, oder eine solche Zuweisung
aufgehoben und damit das Makro gelöscht werden. Es werden nur Makros, die
einer Taste zugewiesen sind, in der Makrodatei gesichert

Mit dieser Zuweisung kann man auch vorgegebene Funktionen überdecken, wie
z.B. (!KEY)Alternate H(!key). Dies ist sinnvoll, wenn man die originale Funktion
nie oder nur selten benötigt. Um sie dennoch zu erreichen, ist zuvor
(!KEY)Shift Esc(!key) zu drücken. (!KEY)Shift Esc -- Alternate H(!key) kommentiert also
(!EM)immer(!em) eine Zeile ein.

Durch die Überladung von Bedeutungen besteht die Gefahr, aus Versehen
rekursive Makros zu definieren. Definiert man einen Tastaturmakro, werden
deshalb definierte Makros (!EM)nicht(!em) expandiert, d.h. es wird immer die
Originalfunktion ausgeführt. Wünscht man den Aufruf eines anderen Makros
tatsächlich, so wirkt (!KEY)Shift Esc(!key) hier im umgekehrten Sinne: (!KEY)Shift
Esc -- Alternate H(!key) während der Makroeingabe versucht also, einen der
Tastenkombination (!KEY)Alternate H(!key) zugewiesenen Makro
auszuführen. Damit sind also auch rekursive Makros möglich, das
hei₧t solche, die sich selbst aufrufen. Die Rekursionstiefe ist hier zur
Sicherheit auf 20 begrenzt! Dialoge können mit Tastenmakros nicht gesteuert
werden.


#}}}

!subnode Extension-Makros
#{{{
!ifdest [stg]
  @alabel QED-Makros
!endif
Vom Editor (!link [QED] [aip.hyp/QED]) her sind auch Makros bekannt, die
durch Expansion des vor dem Cursor stehenden Wortes gebildet werden.
Damit sind aussagekräftige und umfangreiche Makrodefinitionen möglich,
da das zu expandierende Wort natürlich einfacher verständlich ist, als
ein einfaches Tastenmakro.

Dieses Prinzip findet auch in Clix Anwendung. Die Makros werden in der
Extension-Datei definiert.

Entsprechende Makros werden einfach per (!KEY)Alt Space(!key) expandiert.

Um dies auszuprobieren, sollten Sie einfach die Datei (!T)Readme.1st(!t)
laden und durchlesen.
#}}}



#*****************************************************************
!newpage
!node Sonstige Funktionen
#{{{
!subnode Bildschirm-Redraw

(!KEY)Control Home(!key) führt einen kompletten Redraw des Bildschirms
durch.
!subnode Clix verlassen

!label savetext
(!KEY)Control Q(!key) oder der Menüpunkt (!EM)Datei/Beenden(!em) verlä₧t Clix. Dazu
werden alle Fenster geschlossen. Befinden sich noch ungesicherte Texte im
Speicher und ist die Option (!EM)Texte automatisch sichern(!em) nicht aktiv, so erscheint
ein Dialog, in dem die Pfade der entsprechenden Dateien angezeigt werden.

!begin_center
(!IMAGE [Images/clixsave])
!end_center

Nun kann man für jede Datei entscheiden, ob sie vor dem Programmende
gesichert werden soll. Der Button (!EM)Keinen(!em) beendet (!EM)Clix(!em) ohne
jegliche Sicherung. (!EM)OK(!em) sichert die ausgewählten Dateien und
(!KEY)Abbruch(!key) bricht den Vorgang ab.

Beim Verlassen werden die meisten Parameter und Optionen in der
Parameterdatei (!REF)CLIX.PAR(!ref) gesichert.

!index CLIX.PAR
(!KEY)Shift Control Q(!key) bzw. der Menüpunkt (!EM)Datei/Abbrechen(!em) verlä₧t den
Editor, wie (!KEY)Control Q(!key), jedoch ohne die Parameterdatei (!REF)CLIX.PAR(!ref) zu
aktualisieren.

!subnode Drucken

!index Drucken
(!KEY)Control P(!key) bzw. der Menüpunkt (!EM)Datei/Drucken(!em) dient zum Ausdruck
eines markierten Blocks. Nach einer Sicherheitsabfrage wird der gesamte Block
auf einem Drucker gedruckt. Dabei werden keinerlei Steuerzeichen ausgegeben
oder irgendwelche Zeichen konvertiert.

(!KEY)Control Alternate P(!key) verhält sich wie (!KEY)Control P(!key), nur da₧ der
Ausdruck über einen externen Druckertreiber erfolgt, den man über den
Pfadedialog anmelden mu₧. Die Kommunikation zwischen Clix und dem
Druckertreiber erfolgt über einen speziellen Parameterblock, dessen Adresse beim Start über die Kommandozeile
mitgeteilt wird. Die im Kommandozeilendialog unter PRINT angegebene
Kommandozeile wird angehängt.

!subnode Tabulatoren komprimieren/expandieren

!index Tabulatoren !! komprimieren
(!KEY)Alternate T(!key) bzw. der Menüpunkt (!EM)Edit/Komprimieren(!em) komprimiert die
im Text enthaltenen Leerzeichen in Tabulatoren.

!index Tabulatoren !! expandieren
(!KEY)Shift Alternate T(!key) bzw. der Menüpunkt (!EM)Edit/Komprimieren(!em) expandiert
die im Text enthaltenen Tabulatoren in Leerzeichen.

!subnode Textvergleich

!index Textvergleich

(!KEY)Alternate D(!key) bzw. der Menüpunkt (!EM)Edit/Textvergleich(!em) vergleicht zwei
geöffnete Texte ab der jeweiligen Cursorposition. In Abhängigkeit der
allgemeinen Einstellung ""Vergleich berücksichtigt Formatierung"" wird das
mehrfache Auftreten von Leerzeichen und Zeilenenden unterschieden oder nicht.
Diese Operation ist nur ausführbar, wenn genau zwei Texte geöffnet sind.

Konnte bei einem Textvergleich kein Unterschied zwischen den beiden Texten
festgestellt werden, so erscheint ein entsprechender Hinweis.

!subnode Redundanz

!index Redundanz
(!KEY)Alternate X(!key) bzw. der Menüpunkt (!EM)Edit/Redundanz(!em) entfernt im
aktuellen Text alle überflüssigen Leerzeichen am Ende einer Zeile.

(!EM)Achtung!(!em) Im Flie₧textmodus gehen dabei sämtliche weichen Zeilenenden
verloren.

!subnode Externe Programme starten

##!index Programme starten|(
Aus Clix heraus kann man auf komfortabelste Weise Programme starten.

(!KEY)Alternate E(!key) bzw. der Menüeintrag (!EM)Tools/Start...(!em) dient zum
Start von Programmen. Über eine Dateiauswahlbox wird das
gewünschte Programm ausgewählt. Anschlie₧end kann man dem Programm über
folgenden Dialog noch Parameter übergeben.

!begin_center
(!IMAGE [Images/clixparm])
!end_center

Es stehen über zwanzig umschaltbare Kommandozeilen zur Verfügung, wobei bei
diesem Kommando immer die erste Kommandozeile (!REF)- - -(!ref) erscheint.

(!EM)GEM(!em) entscheidet darüber, ob es sich um ein GEM- oder ein TOS-Programm
handelt.

Wurde Clix über Hänisch Modula-2c oder die ClixShell (!EM)CS(!em) gestartet, so ist die
Option (!EM)END(!em) aktivierbar. Diese bewirkt, da₧ Clix verlassen wird. Somit
hat das zu startende Programm mehr Arbeitsspeicher zur Verfügung. Nachdem das
nachgeladene Programm terminiert wurde, startet HMCache bzw. (!EM)CS(!em)
automatisch Clix wieder.

Die Option (!EM)Warten(!em) bewirkt, da₧ nach der Terminierung des nachgeladenen
Programms auf einen Tastendruck oder Mausklick gewartet wird, bevor man zu
Clix zurückgelangt.



Um die Übernahme von Dateipfaden in die Kommandozeile zu erleichtern, stehen
zwei weitere Buttons zur Verfügung. (!EM)Text(!em) fügt den Pfad der im
Vordergrund befindlichen Datei an der Cursorposition in die Kommandozeile
ein. (!EM)Datei(!em) öffnet eine Dateiauswahlbox, über die eine Datei spezifiziert
werden kann, deren Pfad in die Kommandozeile eingefügt wird. Die Einfügung
erfolgt jeweils an der aktuellen Cursor-Position.

!label CmdExp
Darüberhinaus stehen einige $-Sequenzen zur Verfügung, die auf folgende
Weise expandiert werden:

!begin_description
!item [$N]  kompletter Name der aktuellen Textdatei
!item [$P]  reiner Pfad der Textdatei
!item [$F]  Name der Textdatei (ohne Pfad)
!item [$B]  Basisname der Textdatei (ohne Extension)
!item [$E]  Extension der Textdatei
!item [$C]  Pfad und Name der Klemmbrett-Datei ohne Extension
!item [$$]  Dollarzeichen ($)
!end_description

Die Kommandozeile darf durch die Expandierung bis zu 255 Zeichen lang werden.

(!EM)OK(!em) verlä₧t den Dialog und übernimmt die eingegebene Kommandozeile für
das ausgewählte Programm, während (!EM)Start(!em) das Programm mit der
eingegebenen Kommandozeile startet.

Soll ein externes Programm gestartet werden und sind nicht gesicherte Texte
vorhanden, so erscheint ein Dialog, in dem die Pfade der entsprechenden
Dateien angezeigt werden. Nun kann man für
jede Datei entscheiden, ob sie vor dem Programmstart gesichert werden soll.
Der Button (!EM)Keinen(!em) startet das Programm, ohne jegliche Sicherung. (!EM)OK(!em)
sichert die ausgewählten Dateien und (!EM)Abbruch(!em) bricht den Startvorgang
ab.

Es gibt noch eine weitere Möglichkeit, Programme zu starten. Man
kann über (!KEY)Alternate P(!key) oder den Menüeintrag (!EM)Tools/Pfade...(!em)
einen Dialog öffnen und bis zu zwanzig Tools fest anmelden.

!begin_center
(!IMAGE [Images/clixpath])
!end_center

Links oben befindet sich ein editierbarer Name, der das angemeldete Programm
repräsentiert und in der Menüleiste unter dem Titel (!EM)Tools(!em) erscheint.
Darunter wird der Zugriffspfad des Programms dargestellt. Links daneben
befindet sich eine Pfeilbox, über die zwischen den einzelnen Tools
umgeschaltet werden kann. Will man ein neues Programm anmelden, so öffnet man
durch einen Einfachklick auf den Pfadeintrag oder (!KEY)Alternate P(!key) eine
Dateiauswahlbox, über die man das Tool auswählen kann. Die Abmeldung eines
Utilities geschieht über einen Leereintrag im Namensfeld. Für jedes Programm
lassen sich acht Optionen setzen:

(!EM)GEM-Applikation(!em) zeigt an, ob es sich bei dem Tool um ein GEM- oder
TOS-Programm handelt.

(!EM)nach Ausführung warten(!em) bewirkt, da₧ nach der Ausführung des Tools auf
einen Tastendruck oder Mausklick gewartet wird, bevor man zu Clix
zurückgelangt.

Ist die Option (!EM)Clix beenden(!em) aktiv, so wird Clix vor dem Start des
Tools beendet. Dies ist jedoch nur möglich, falls der HMCache oder CS aktiv
ist. Dieser startet nach Beendigung des Tools Clix neu.

(!EM)Bearbeitet Text(!em) dient zur Unterstützung von Programmen, die den im
Vordergrund befindlichen Text verändern sollen. Dazu wird der aktuelle Text
abgespeichert und sein Zugriffspfad als Kommandozeile übergeben. Dies ist
jedoch nur dann der Fall, wenn bei den Kommandozeilenoptionen (!EM)Nein(!em)
gewählt wurde. Besonders interessant ist diese Option im Zusammenhang mit
der Expandierung von $-Sequenzen in der Kommandozeile. Auf diese Weise kann man externen Tools beliebige
Optionen übergeben, ohne ständig die entsprechende Kommandozeile editieren
zu müssen.

Über (!EM)HMC-Speicher freigeben(!em) lä₧t sich zusätzlich noch der Puffer des
HMCache freigeben.

(!EM)Fenster offen lassen(!em) ermöglicht es, beim Start eines Utilities, die
Fenster des Editor geöffnet zu lassen. Diese Option macht vor allem bei
Programmen Sinn, die keine Redraws erzeugen.

(!EM)Textspeicher freigeben(!em) hat zur Folge, da₧ vor dem Start des Programms
der Textspeicher von Clix freigegeben wird, nachdem die Texte gesichert
wurden.

(!EM)Aktuellen Text überladen(!em) führt dazu, da₧ nach der Terminierung des Tools
der aktuelle Text neu geladen wird.

Au₧erdem kann für jedes Programm festgelegt werden, ob eine Kommandozeile
übergeben werden soll.

(!EM)Nein(!em) bewirkt, da₧ das angemeldete Programm ohne Kommandozeile gestartet
wird.

Ist (!EM)Ja(!em) gesetzt, so wird vor dem Programmstart der Kommandozeilendialog
aufgerufen.

(!EM)Fest(!em) übergibt eine eingestellte Kommandozeile, die sich über
(!EM)Eingabe(!em) konfigurieren lä₧t.

Ein besonderer Punkt ist die Input/Output-Redirection.

Es besteht die Möglichkeit, einen markierten Block als Standard-Input in ein
Programm einzufüttern, und auch die Möglichkeit die Ausgaben eines Programmes in
den Text einzufügen.

Dabei gelten folgende Regeln:

!begin_itemize
  !item Wenn 'Block In' aktiviert ist wird der aktuell markierte Block als Input
  genommen (auch wenn er nicht im aktuellen Fenster liegt!)
  !item Wenn 'Block Out' aktiviert ist, wird die Ausgabe des Programmes an der
  aktuellen Cursorposition im aktuellen Fenster eingefügt.
  !item ist beides aktiviert ('Block In / Block Out'), wird zusätzlich
  selektierte Block nach dem Programmlauf gelöscht.
!end_itemize

Wer z.B. die externen Tools awk und sed kennt, wird dieses Feature sicherlich zu
schätzen wissen.

Mittels 'Dateipfad setzen' wird vor dem Programmstart der Pfad eingestellt, in
dem der aktuelle Text liegt.

Dies ist z.B. dann interessant, wenn man 'make' benutzt, das das makefile aus
dem aktuellen Pfad liest.



Neben den zwanzig anmeldbaren Programmen, sind folgende Utilities
vorgesehen, deren Pfade vom Benutzer separat angemeldet werden können:

!label DefineTestProgram

!begin_itemize
  !item  BFISH, Babelfisch
  !item  ONYX, der Assembler-Präprozessor
  !item  PMD, der Post Mortem Debugger
  !item  RTD, der Runtime Debugger
  !item  PRINT, ein nachladbarer Druckertreiber
  !index Exception
  !item  TEST, ein frei wählbares Programm. Es empfiehlt sich, das gerade in
        Entwicklung befindliche Programm anzumelden, um es über (!KEY)F7(!key)
        direkt aufrufen zu können. Dabei wird im Fileselektor automatisch
        das Programm vorgeschlagen, das als nächstes gelinkt werden würde.
        Ist die Option (!EM)bei TEST-Programm Exceptions abfangen(!em) aktiv, so
        werden bei der Ausführung auftretende Exceptions abgefangen (siehe
        Kapitel PMD).
!end_itemize

Au₧er PMD verfügt jedes der erwähnten Tools über eine eigene
Kommandozeile.

Gestartet wird ein angemeldetes Tool entweder über den entsprechenden
Menüeintrag unter dem Titel (!EM)Tools(!em) oder die Tasten (!KEY)Control 0..9(!key),
bzw. die Tasten (!KEY)Shift Control 0..9(!key) auf dem Ziffernblock. Im Menü
sind maximal neun Programme sichtbar. Über Pfeile, die als erster
bzw. letzter Eintrag erscheinen, wird die Programmliste im Menü gescrollt.

!index Druckertreiber
!index Print Control Block
!label PrintParamBlock
Der nachladbare Druckertreiber kann unter PRINT angemeldet werden und erhält
beim Start als ersten Parameter in der Kommandozeile den Dezimalwert (adr)
eines Zeigers auf den (!EM)Print Control Block (PCB)(!em) in der Form
(!REF)HMPRINT[adr](!ref). Auf diese Weise hat der Treiber Zugriff auf den
auszudruckenden Text(-block). Es darf dabei jedoch keiner der Werte im PCB
verändert werden, und auch ein schreibender Zugriff auf den Dateinamen oder
den Text selbst ist nicht erlaubt!

!begin_verbatim
  TYPE
    tPCB = RECORD
      FName: ADDRESS;   (* Zeiger auf Dateinamen              *)
      TAdr : ADDRESS;   (* Startadresse des Textes            *)
      TLen : LONGCARD;  (* Länge des Textes                   *)
      PVon : LONGCARD;  (* Druckanfang, Offset vom Textanfang *)
      PBis : LONGCARD;  (* Druckende, Offset vom Textanfang   *)
    END;
!end_verbatim
!index Programme starten


#}}}

#*****************************************************************
!newpage
!node HM-Operationen
#{{{
!label ClixHMKey

!subnode Tastaturkürzelübersicht

Da Clix auch als Entwicklungsumgebung dient, sind einige Kommandos
vorhanden, die z.B. den direkten Aufruf des Compiler-Accessories
ermöglichen.

(!KEY)F10(!key) bzw. der Menüeintrag (!EM)Modula/Compile(!em) compiliert die
Datei, die im Vordergrund liegt. Das Modul mu₧ in der Makedatei des
Accessories angemeldet sein. War die Übersetzung erfolgreich, wird der Text
abgespeichert. Ist die im Vordergrund liegende Datei ein Assemblermodul,
dann wird (!T)Babelfisch(!t) aufgerufen und versucht die Datei zu assemblieren.

(!KEY)Control F10(!key) compiliert die im Vordergund befindliche Datei und
linkt das ausgewählte Hauptmodul.

!index Testprogramm
(!KEY)Control Alternate F10(!key) wirkt wie (!KEY)Control F10(!key), jedoch wird nach
erfolgreichem Linken das Testprogramm gestartet.

!index Testprogramm
(!KEY)Shift Control Alternate F10(!key) wirkt wie (!KEY)Control Alternate F10(!key),
jedoch wird das Testprogramm über RTD gestartet.

(!KEY)Shift F10(!key) oder der Menüeintrag (!EM)Modula/ONYX(!em) ruft den
Präprozessor-Assembler (!EM)ONYX(!em) für den obersten Text auf. Der Zugriffspfad
für den Assembler wird über den Dialog (!EM)Tools/Pfade(!em) festgelegt.

Im Falle eines Fehlers während des Compilierens wird eine Box mit einer
entsprechenden Fehlermeldung ausgegeben. Diese wird über einen Mausklick
oder eine beliebige Taste geschlossen. Es ist jedoch zu beachten, da₧ die
gedrückte Taste von Clix gleichzeitig als Eingabe gewertet wird.

(!KEY)F9(!key) bzw. der Menüeintrag (!EM)Modula/Link(!em) aktiviert den
Make-Mechanismus. Inkonsistente Module werden compiliert. Anschlie₧end wird
das ausgewählte Hauptmodul gelinkt.

(!KEY)Shift F9(!key) bzw. der Menüeintrag (!EM)Modula/Make(!em) compiliert zum
Hauptmodul gehörende, inkonsistente Module neu.

!index Testprogramm
(!KEY)Alternate F9(!key) wirkt wie (!KEY)F9(!key), jedoch wird nach erfolgreichem
Linken das Testprogramm gestartet.

!index Testprogramm
(!KEY)Shift Alternate F9(!key) wirkt wie (!KEY)Alternate F9(!key), jedoch wird
das Testprogramm über RTD gestartet.

!index Testprogramm
(!KEY)F6(!key) oder der Menüpunkt (!EM)Test/RTD(!em) startet RTD mit dem Namen
des Testprogramms als Kommandozeile.

(!KEY)Shift F6(!key) oder der Menüeintrag (!EM)Modula/RTD(!em) ruft den
Runtime Debugger RTD auf. Der Zugriffspfad für den Debugger wird über
den Dialog (!EM)Tools/Pfade(!em) festgelegt. RTD verfügt über eine eigene
Kommandozeile.

!index Testprogramm
(!KEY)F7(!key) oder der Menüeintrag (!EM)Modula/Test(!em) ruft das über den
Pfadedialog als Testprogramm angemeldete Programm auf.

(!KEY)Shift F7(!key) oder der Menüeintrag (!EM)Modula/PMD(!em) ruft den
Post Mortem Debugger (!EM)PMD(!em) auf. Der Zugriffspfad für den Debugger wird
über den Dialog (!EM)Tools/Pfade(!em) festgelegt.

(!KEY)F8(!key) bzw. der Menüeintrag (!EM)Modula/Modul-Liste(!em) öffnet das
HMplus-Accessory, falls ein AES-Fenster frei ist.

(!KEY)Shift F8(!key) öffnet den Optionendialog des HMplus-Accessory.

(!KEY)Control F8(!key) und der Menüpunkt (!EM)Modula/Anmelden(!em) speichern die
aktuelle Datei ab und melden sie beim HM2-System an.

Die kombinierten Aktionen Compilieren + Linken, Linken + Starten
sowie Compilieren + Linken + Starten können durch Drücken einer der
Tasten (!KEY)Shift(!key), (!KEY)Control(!key) oder (!KEY)Alternate(!key) abgebrochen werden.

!subnode Fehlersprung

!index Fehlersprung

Sowohl für den HM2-Compiler als auch für externe Utilities, wie
(!T)Babelfisch(!t) und (!EM)Onyx(!em), steht ein Mechanismus zur Verfügung, der den
Sprung von einem Fehler zum nächten erlaubt.

(!KEY)Alternate J(!key) setzt den Cursor auf den nächsten Fehler.

(!KEY)Shift Alternate J(!key) setzt den Cursor auf den vorherigen Fehler.

(!KEY)Control Alternate J(!key) setzt den Cursor auf die erste Fehlerposition.

(!KEY)Shift Control Alternate J(!key) setzt den Cursor auf die letzte
Fehlerposition.


#}}}

#*****************************************************************
!newpage
!node Optionen
#{{{
!subnode Einfüge- und Überschreibmodus

!index Einfügemodus
!index Überschreibmodus
(!KEY)F4(!key) oder der Menüeintrag (!EM)Optionen/Einfügemodus(!em) schaltet zwischen
dem Einfüge- und Überschreibmodus um. Ist der Überschreibmodus aktiv, so
wird dies durch das Zeichen ""O"" in der Menüleiste angezeigt. Ist der
Einfügemodus aktiv, so wird dies durch das Zeichen ""I"" in der Menüleiste
angezeigt.

!subnode Spaltenblock

!index Spaltenblock
(!KEY)Control F4(!key) und der Menüpunkt (!EM)Spaltenblock(!em) schaltet den
Spaltenblock an bzw. aus.

!subnode Allgemeine Optionen

!index Optionen !! allgemeine
(!KEY)Shift F4(!key) oder der Menüeintrag (!EM)Optionen/Allg. Optionen...(!em)
öffnet folgenden Dialog:

!begin_center
(!IMAGE [Images/clixopt])
!end_center

(!EM)GDOS Zeichensätze laden(!em) entscheidet darüber, ob die GEM-Zeichensätze
bei installiertem GDOS von Clix geladen werden.

!label DumpOption
!index Testprogramm
(!EM)Dump-Option für Test-Programm(!em) bestimmt, ob bei dem
Testprogramm auftretende Exceptions abgefangen werden und ggf. ein
Speicherdump geschrieben werden soll. Zum Testprogramm muß dann das Modul
(!REF)Rts(!ref) gelinkt werden.

(!EM)Oberen Rand reservieren(!em) bestimmt, ob auf dem Bildschirm immer
ein oberer Rand reserviert wird, um die Text-Icons sichtbar zu machen.

(!EM)Maximale Fensterbreite(!em) begrenzt die Fensterbreite auf den in der
Pfeilbox angegebenen Wert. Dies ist vor allem für Gro₧bildschirme
gedacht, um nach dem Öffnen eines Textes nicht jedesmal das Fenster
verkleinern zu müssen.

(!EM)RETURN trennt Zeile(!em) bestimmt die Funktion der Tasten (!KEY)Return(!key) und
(!KEY)Enter(!key). Ist die Option nicht aktiv, so wird eine Leerzeile unterhalb
der Cursorposition eingefügt, andernfalls wird der Rest einer Zeile ab der
Cursorposition in eine neue umbrochen.

(!EM)Zeilenende(!em) legt das Zeichen fest, das das Ende einer Zeile markiert. Auf
diese Weise lassen sich eventuelle am Zeilenende vorhandene Leerzeichen
sichtbar machen. Sind keine Markierungen erwünscht, so wählt man ein
Leerzeichen als Symbol (ASCII-Wert 32).

(!EM)Absatzende(!em) legt, analog zur Zeilenendemarkierung ein Zeichen zur
Absatzmarkeriung fest. Die Markierung eines Absatzes erfolgt jedoch nur im
Wortumbruch-Modus, da nur in diesem Fall eine Einteilung des Textes in
Absätze erfolgt.

!label TextAutoSave
(!EM)Texte automatisch sichern(!em) bewirkt, da₧ vor dem Start eines Programms
und beim Verlassen von Clix die veränderten Texte ohne Nachfrage
automatisch gesichert werden.

(!EM)Desktop bei Verlassen speichern(!em) bewirkt, da₧ die Position der Icons und
die geöffneten Fenster gesichert werden.

(!EM)Nach Suchen+Ersetzen Meldung(!em) dient dazu, nach der
Suchen-Ersetzen-Operation eine Meldung auszugeben, die die Anzahl der
Ersetzungen anzeigt.

(!EM)Vergleich berücksichtigt Formatierung(!em) bestimmt, ob bei Textvergleich
auf identischem Text bestanden wird, oder zusätzliche Leerzeichen oder
Leerzeilen toleriert werden.

(!EM)Blöcke vor dem Cursor einfügen(!em) bestimmt die Cursorposition nach dem
Einfügen eines Blocks. Ist diese Option aktiv, so wird nach dem Einfügen
der Cursor an das Ende des Blocks gesetzt.

(!EM)Zusätzlicher Textspeicher(!em) legt die Grö₧e des Speichers fest, der
zusätzlich beim Laden eines Textes alloziert wird. Die Grö₧e dieses
Speichers begrenzt die maximal eingebbaren Zeichen.

(!EM)Blockspeicher(!em) legt die Grö₧e des globalen Blockpuffers fest. Diese
lä₧t sich jedoch nur ändern, wenn alle Fenster geschlossen sind.

(!EM)PAR Sichern(!em) sichert die aktuellen Parameter in der Datei (!REF)CLIX.PAR(!ref).

!subnode Klammernpaare

(!KEY)Alternate I(!key) oder der Menüpunkt (!EM)Optionen/Klammernpaare...(!em)
öffnet folgenden Dialog:

!begin_center
(!IMAGE [Images/clixspec])
!end_center

Dieser Dialog bietet die Möglichkeit, sechs verschiedene Zeichensequenzen
zu definieren, die als Klammerung gewertet werden sollen(!N)Die in
älteren Versionen von Clix hier angebotene Umlautersetzung ist entfallen, da
sie flexibler durch die frei programmierbaren Makros ersetzt werden kann.(!n).
Diese Definition ist wichtig für die Markierung von geklammerten
Textauschnitten als Block. Über die rechten Radio-Buttons lä₧t sich die
Kommentarsequenz festlegen, die verwendet wird, um eine Zeile bzw. einen
Block auszukommentieren. Die Auswahl kann auch über die Tasten
(!KEY)Alternate 0..5(!key) erfolgen.

In der linken Radio-Button-Leiste oder die Tasten (!KEY)Alternate A..F(!key) kann
man das Klammernpaar bestimmen, für die ein Hierarchietest über den gesamten
Text ausgeführt werden soll. Der Button (!EM)Test(!em) startet den
Hierarchietest. Falls die Klammerung nicht korrekt ist, erfolgt eine
Meldung, und die (vermutlich) fehlerhafte Stelle wird angezeigt.

!subnode Textoptionen
!label AltTab

!begin_center
(!IMAGE [Images/clixtopt])
!end_center

(!KEY)Alternate Tab(!key) oder der Menüeintrag
(!EM)Optionen/Textoptionen...(!em) ermöglicht die Einstellung
verschiedener Optionen, die sich nur auf den im Vordergrund befindlichen
Text beziehen. Über eine Pfeilbox kann die Tabulatorweite festgelegt
werden.

Die Default-Einstellung der Textoptionen erfolgt unter dem Menüpunkt
(!EM)Datei/Auswählen...(!em).

(!EM)Text in PIK-Datei übernehmen(!em) legt fest, ob der Pfad der im Vordergrund
befindliche Text nach der Bearbeitung in die PIK-Datei aufgenommen werden
soll oder nicht. Auf diese Weise lä₧t sich die Konsistenz einer PIK-Datei
erhöhen.

(!EM)Backup(!em) öffnet einen PopUp-Selektor, der die Namensgebung einer
Backup-Datei steuert. Auf Wunsch kann die Erzeugung einer Backup-Datei auch
abgeschaltet werden.

Es stehen drei unterschiedliche Modi für die Erzeugung einer Sicherung zur
Verfügung, die die Namensgebung der Backup-Datei beeinflussen:

!begin_description
!item [Standard] führt dazu, da₧ das letzte Zeichen verändert wird. Aus
  (!REF).DOC(!ref) wird beispielsweise (!REF).DOB(!ref), aus (!REF).TXT(!ref) wird (!REF).TXS(!ref).
  Ist die Extension kürzer als drei Zeichen, so wird sie mit ""+""-Zeichen
  aufgefüllt, aus (!REF).M(!ref) wird also (!REF).M++(!ref).
!item [Lang => DUP] verhält sich wie der Standard-Modus, nur wird aus einer
  3-Zeichen-Extension die Extension (!REF).DUP(!ref).
!item [immer DUP] erzeugt ausschlie₧lich (!REF).DUP(!ref)-Backups.
!end_description

(!EM)Tabulatoren expandieren/komprimieren(!em) führt dazu, da₧ beim Sichern
versucht wird, so viele Leerzeichen wie möglich in Tabulatorzeichen
umzuwandeln. Beim Laden eines Textes werden Tabulatoren immer in Leerzeichen
gewandelt.

!index Zeilenendezeichen
Die Radio-Buttons (!EM)CR+LF(!em), (!EM)CR(!em), (!EM)LF(!em) und (!EM)0C(!em) entscheiden
darüber, welche(s) Zeichen als Markierung für das Zeilenende verwendet
werden soll: (!EM)CR+LF(!em) ist unter TOS- bzw. MS-DOS, (!EM)CR(!em) unter RTOS und
OS/9, (!EM)LF(!em) unter UNIX üblich, und (!EM)0C(!em) schlie₧lich ist für die
Verarbeitung reiner Stringlisten gedacht. (!EM)LF(!em) wird aber auch von vielen
Programmen unter TOS akzepiert, so von dem (!TeX)-Compiler von Stefan Lindner
oder dem Hänisch-Modula-2-Entwicklungssystem. Intern arbeitet
Clix mit (!EM)LF(!em) als Zeilenende. Daher wird ein Text, den Sie mit (!EM)CR+LF(!em)
und ohne Tabulatorenkomprimierung abspeichern, auf Diskette immer etwas mehr
Platz einnehmen, als im Informations-Dialog angezeigt wird. Andererseits
nimmt der Text beim Abspeichern durch Tabulatorenkomprimierung an Länge ab.

(!EM)Automatisches Einrücken(!em)
!index Einrücken !! automatisches
!index Automatisches Einrücken
!label AutoIndent
führt dazu, da₧ beim Einfügen einer neuen Zeile
der Cursor unter das erste Zeichen der vorhergehenden Zeile gestellt wird.
Ist es nicht aktiviert, wird der Cursor in diesem Fall immer auf den linken
Rand gesetzt.

(!EM)Linker Rand(!em) setzt für die Funktionen Zeile einfügen und Zeile teilen den
linken Rand, auf den der Cursor wenigstens gesetzt werden soll.
Selbstverständlich kann der Cursor anschlie₧end links davon positioniert
werden.

(!EM)Nicht editierbar(!em) verhindert sämtliche inhaltliche Änderungen an dem
entsprechenden Dokument.

(!EM)An Zeilenenden Leerzeichen entfernen(!em) ist im Normalfall aktiv. Dadurch
werden eventuell am Zeilenende vorhandene Leerzeichen entfernt. Bei der
Bearbeitung bestimmer Dateien (z.B. DESKTOP.INF) mu₧ die Option jedoch
abgeschaltet werden. Im Wortumbruch-Modus ist diese Option nicht
aktivierbar.

(!EM)Faltung von Blöcken übernehmen(!em) entscheidet darüber, ob beim Laden und
Speichern die Blockfaltung erhalten bleiben soll.

(!EM)Wortumbruch ab Spalte(!em) aktiviert den automatischen Zeilenumbruch. Wird
bei der Eingabe der angegebene rechte Rand erreicht, so wird das letzte Wort
der Zeile umbrochen. Ein linker Rand (Einrückungen) bleibt dabei bei
aktivierter Option (!EM)Automatisches Einrücken(!em) erhalten.

(!EM)Einrückungen...(!em) zeigt die in der Datei (!REF)CLIX.IND(!ref) definierten
Einrückungen an.

!subnode Textinformationen

!begin_center
(!IMAGE [Images/clixtinf])
!end_center

(!KEY)Control I(!key) bzw. der Menüpunkt (!EM)Optionen/Information...(!em) öffnet
eine Dialogbox, die Informationen über den gerade im Vordergrund befindlichen
Text enthält. Dies ist der Zugriffspfad mit dem Dateinamen, die Anzahl der
Zeichen und die Anzahl der Zeilen im Text. Wurde für den Text eine
Fehlerdatei geladen, so so wird dies angezeigt. Au₧erdem wird die Grö₧e eines
markieren Blocks ausgegeben.

!subnode Schriftart

!index Schriftart
Clix ist in der Lage, die einzelnen Texte in unterschiedlichen Schriftgrö₧en
und verschiedenen Schriftarten darzustellen. Wurde GDOS installiert, so
werden alle verfügbaren GEM-Zeichensätze geladen, falls die Option (!EM)GDOS
Zeichensätze laden(!em) aktiv ist. Zur Darstellung können jedoch keine
Proportional-Fonts verwendet werden.

(!KEY)Control Z(!key) oder der Menüpunkt (!EM)Optionen/Schriftart...(!em)
aktiviert folgenden Dialog:

!begin_center
(!IMAGE [Images/clixfont])
!end_center

Hier kann man über einen Popup-Selektor die Grö₧e des Zeichensatzes für das
gerade aktive Fenster verändern. Ist kein Text geöffnet, so bezieht sich die
Zeichensatzeinstellung auf alle folgenden Texte. Die Pfeilbox
(!EM)Zeilenzwischenraum(!em) vergrö₧ert den Zeilenabstand. Dies führt vor allem
bei kleinen Zeichensätzen zu einer besseren Lesbarkeit. Über eine weiteren
Selektor lä₧t sich der gewünschte GEM-Zeichensatz auswählen. Der Button
(!EM)Setzen(!em) setzt die gerade gewählte Schriftgrö₧e und den Zeichensatz als
Standardeinstellung für alle folgenden Fenster. (!EM)Holen(!em) setzt den
Zeichensatz und dessen Grö₧e auf die Standardeinstellung zurück.

Zwei Pfeilboxen erlauben die getrennte Einstellung einer Vorder- und
Hintergrundfarbe für jeden Text.


#}}}


#*****************************************************************
!newpage
!node Die Hilfefunktion
#{{{

Clix unterstützt ST-Guide als Hilfesystem sowie andere,
aufrufkompatible Hilfesysteme.

Die Nachricht zur Darstellung wird an 'ST-GUIDE' verschickt. Wenn Sie
ein anderes Hilfesystem verwenden oder ST-GUIDE unter anderem Namen
verwenden, sollten Sie eine Environmentvariable 'HELP' setzen, in der
der Name des Hilfesystems angegeben ist (z.B. unter Gemini: (!T) export
HELP=STGUIDE(!t).

Wenn Sie F1 drücken, wird der Hilfetext zu Clix von ST-Guide
angezeigt.

Wenn Sie HELP drücken, wird das unter dem Textcursor stehende Wort
selektiert und als Parameter an ST-GUIDE übergeben.

Für Anwender von Hänisch Modula-2 gibt es eine erweiterte Hilfe-Technik:

Handelt es sich um einen bekannten Bezeichner eines Modules (Modulname,
qualifizierter Typ eines anderen Moduls oder ein in einer IMPORT-Liste
aufgeführtes Wort), so wird das zugehörige DEFINITION-Module geladen.
#}}}

#*****************************************************************
!newpage
!node Zubehör
#{{{
Zu Clix gehören einige kleine Programme als Zubehör.

!begin_description
  !item [SE_Call.APP] Mit diesem Programm können sie bei einer SE-Shell
    Handlungen auslösen. Clix besitzt zwar das SE-Protokoll, aber manchmal
    ist es angenehmer, ein externes Programm zu verwenden. Zum einen kann man
    damit auch von anderen Programmen aus SE-Befehle absetzen, zum anderen
    kann man die zu übergebenden Parameter frei bestimmen.

    Ein Beispiel dazu ist das Auslösen eines Linking, während man ein
    beliebiges Modul editiert.

    Parameter für SE_Call:

    !begin_itemize
      !item -c <filename>  compile filename
      !item -m <filename>  Make filename
      !item -l <filename>  Link filename
      !item -x <filename>  execute filename
    !end_itemize

  !item [uff.ttp] uff steht für unfold/fold. Ein Clix-Text wird entfaltet,
  mit einem anderen Programm bearbeitet, und wieder gefaltet. Dies ist dann
  sinnvoll, wenn andere Programme durch die Faltung gestört werden, der auch
  die Faltung einfach nur zerstören (zB awk, sed). Als Parameter werden die
  Namen der Dateien übergeben und ab einem '-' das zu verwendende Kommando
  mit Parametern. Die Liste der Dateinamen kann dabei aus Wildcards
  expandiert werden.

!end_description
#}}}


#*****************************************************************

!newpage
!node Tastenübersicht
#{{{
Die Tastenkombinationen wurden, soweit möglich, nach vorhandenen Richtlinien
sowie logischen Gesichtspunkten festgelegt. So bedeutet z.B. die Shift-Taste
zumeist eine Richtungsumkehr, Control-Kombinationen sind in erster Linie für
Block- und Zeilenoperationen sowie zum Markieren zuständig, und
Alternate-Kombinationen sind für Dateioperationen, Programmstarts und zum
Anspringen von Marken vorgesehen.

!subnode Sondertasten

(!TASTE [Links/Rechts] [bewegt den Cursor in der Zeile])
(!TASTE [Shift Links/Rechts] [bewegt den Cursor zum Zeilenanfang/-ende])
(!TASTE [Ctrl Links/Rechts] [bewegt den Cursor wortweise links/rechts])
(!TASTE [Shift Ctrl Links] [bewegt den Cursor zum logischen Zeilenanfang])

(!TASTE [Auf/Ab] [bewegt den Cursor eine Zeile vor/zurück])
(!TASTE [Shift Auf/Ab] [bewegt den Cursor eine Seite vor/zurück])
(!TASTE [Ctrl Auf/Ab] [bewegt den Cursor zum Seitenanfang/-ende])
(!TASTE [Shift Ctrl Auf/Ab] [bewegt den Textausschnitt eine Zeile vor/zurück])

(!TASTE [Home/Shift Home] [bewegt den Cursor zum Textanfang/-ende])
(!TASTE [Ctrl Home] [kompletter Bildschirm-Redraw])

(!TASTE [Help] [sucht im Manual nach dem Wort unter dem Cursor])
(!TASTE [Shift Help] [sucht im Manual nach einer Anleitung zu Clix])

(!TASTE [Undo] [macht Änderungen in der letzten editierten Zeile rückgängig])
(!TASTE [Alt Undo] [oberstes Fenster schlie₧en])

(!TASTE [Insert] [fügt an der Cursorposition eine neue Zeile ein])
(!TASTE [Ctrl Insert] [verdoppelt die aktuelle Zeile])

(!TASTE [Return/Enter] [fügt unter der aktuellen Zeile eine neue Zeile ein abhängig von der Option 'RETURN trennt Zeile'])
(!TASTE [Alt Return/Enter] [trennt die Zeile ab Cursor einschlie₧lich abhängig von der Option 'RETURN trennt Zeile'])

(!TASTE [Backspace] [löscht das Zeichen links des Cursors])
(!TASTE [Alt Backspace] [vereinigt die aktuelle Zeile mit der darüber])
(!TASTE [Shift Backspace] [führt Backspace aus, bis der Cursor auf der vorigen Tabulatorposition steht (am Zeilenanfang werden Zeilen vereinigt!)])
(!TASTE [Control Backspace] [setzt den Cursor auf die nächste, linke Tabulatorposition])
(!TASTE [Delete] [löscht das Zeichen unter dem Cursor])
(!TASTE [Alt Delete] [vereinigt die aktuelle Zeile mit der darunter])

(!TASTE [Tab] [fügt Leerzeichen ein, bis der Cursor auf der nächsten Tabulatorposition steht])
(!TASTE [Shift Tab] [führt Backspace aus, bis der Cursor auf der vorigen Tabulatorposition steht (maximal bis zum Zeilenanfang!)])
(!TASTE [Alt Tab] [ruft Dialog auf, um die Textoptionen zu setzen])
(!TASTE [Control Tab] [setzt den Cursor auf die nächste, rechte Tabulatorposition])
(!TASTE [Shift Control Tab] [setzt den Cursor auf die nächste, linke Tabulatorposition])

(!TASTE [Esc] [ruft mit weiterer Taste Makro auf])
(!TASTE [Shift Esc] [nächste Taste nicht als Tastaturmakro ausführen])
(!TASTE [Ctrl Esc] [Tastaturmakro programmieren])
(!TASTE [Alt Esc] [Tastaturmakro aufrufen])

!subnode Funktionstasten

(!TASTE [F2/F3] [Wort links/rechts löschen])
(!TASTE [Shift F2/F3] [löschen bis Zeilenanfang/-ende])
(!TASTE [Ctrl F2/F3] [Fensterausschnitt halbe Seite links/rechts])
(!TASTE [F4] [Einfüge Modus an-/ausschalten])
(!TASTE [Shift F4] [Allgemeine Optionen])
(!TASTE [Control F4] [Spaltenblock an/aus])
(!TASTE [F5] [Textmakro löschen oder definieren, falls Block markiert])
(!TASTE [Shift F5] [Tastaturmakro zuweisen oder löschen])
(!TASTE [Alt F5] [Makrodatei lesen oder schreiben])
(!TASTE [F6] [RTD mit Testprogramm in der Kommandozeile starten])
(!TASTE [Shift F7] [Post Mortem Debugger PMD starten])
(!TASTE [Shift F6] [Runtime Debugger RTD starten])
(!TASTE [F7] [unter TEST angemeldetes Programm starten])
(!TASTE [F8] [öffnet das HMplus-Accessory])
(!TASTE [Shift F8] [öffnet den Optionendialog des HMplus-Accessories])
(!TASTE [Ctrl F8] [meldet die aktuelle Datei im Make an])
(!TASTE [F9] [falls nötig, compilieren, und dann Programm linken])
(!TASTE [Shift F9] [Make --- compilieren, bis Modulhierarchie konsistent ist])
(!TASTE [Alt F9] [Linken und Starten des Testprogramms])
(!TASTE [Shift Alt F9] [Linken und Starten des Testprogramms über RTD])
(!TASTE [F10] [im Vordergrund befindliche Datei compilieren])
(!TASTE [Shift F10] [Präprozessor Assembler ONYX starten])
(!TASTE [Ctrl F10] [Im Vordergrund befindliche Datei compilieren und bei Erfolg aktuelles Hauptmodul linken])
(!TASTE [Ctrl Alt F10] [Compilieren, Linken und Starten des Testprogramms])
(!TASTE [Shift Ctrl Alt F10] [Compilieren, Linken und Starten des Testprogramms über RTD])
(!TASTE [Shift F10] [Absatz formatieren])
(!TASTE [Ctrl F10] [Zeile formatieren, auch wenn sie Absatzende ist])
(!TASTE [Shift Ctrl F10] [bis zur nächsten Leerzeile als Absatz formatieren])


!subnode Control-Kombinationen

(!TASTE [Ctrl 1..0] [(Hauptblock!) Marke 1..10 setzen])
(!TASTE [Ctrl A] [gesamten Text als Block markieren])
(!TASTE [Ctrl B] [Blockanfang setzen])
(!TASTE [Ctrl C] [Block merken (in Puffer kopieren!)])
(!TASTE [Shift Ctrl C] [Block an Puffer anhängen])
(!TASTE [Ctrl D] [Zeichen aus darüberliegender Zeile an Cursorposition kopieren])
(!TASTE [Shift Ctrl D] [Wort aus darüberliegender Zeile an Cursorposition kopieren])
(!TASTE [Ctrl E] [Zeilenpuffer einfügen])
(!TASTE [Ctrl F] [Begriff suchen])
(!TASTE [Shift Ctrl F] [Begriff rückwärts suchen])
(!TASTE [Ctrl G] [Globale Suche])
(!TASTE [Shift Ctrl G] [Umschaltung zwischen Blockpuffer und GEM-Klemmbrett])
(!TASTE [Ctrl H] [Blockmarkierung aufheben/wiederherstellen])
(!TASTE [Shift Ctrl H] [Blockmarkierung zwingend aufheben])
(!TASTE [Ctrl I] [Informationen über Text anzeigen])
(!TASTE [Ctrl J] [markierten Block ein- bzw. ausfalten])
(!TASTE [Shift Ctrl J] [alle Faltungen aufheben])
(!TASTE [Control Alt J] [Sprung zu erstem Fehler])
(!TASTE [Shift Control Alt J] [Sprung zu letztem Fehler])
(!TASTE [Ctrl K] [Blockende setzen])
(!TASTE [Ctrl L] [beliebiges ASCII-Zeichen aus Tabelle einfügen])
(!TASTE [Shift Ctrl L] [Dateinamen einfügen])
(!TASTE [Ctrl M] [Klammerung/Wort unter Cursor markieren])
(!TASTE [Ctrl N] [neue Zeile an Cursorposition einfügen])
(!TASTE [Ctrl O] [inkrementelle Suche vorwärts])
(!TASTE [Shift Ctrl O] [inkrementelle Suche rückwärts])
(!TASTE [Ctrl Alt O] [Text aus letztem Pfad öffnen])
(!TASTE [Ctrl P] [Block drucken])
(!TASTE [Ctrl Alt P] [Block über externen Druckertreiber drucken])
(!TASTE [Ctrl Q] [Clix verlassen])
(!TASTE [Shift Ctrl Q] [Clix verlassen, ohne CLIX.PAR zu sichern])
(!TASTE [Ctrl R] [Begriff suchen und Ersetzen])
(!TASTE [Shift Ctrl R] [Begriff rückwärts suchen und Ersetzen])
(!TASTE [Ctrl S] [Text speichern])
(!TASTE [Ctrl T] [Wort rechts löschen])
(!TASTE [Shift Ctrl T] [Wort links löschen])
(!TASTE [Ctrl U] [oberstes Fenster schlie₧en])
(!TASTE [Ctrl V] [Block aus Puffer einfügen])
(!TASTE [Ctrl W] [das nächste Fenster nach vorne bringen])
(!TASTE [Ctrl X] [Block in Puffer ausschneiden])
(!TASTE [Ctrl Alt X] [Block löschen])
(!TASTE [Ctrl Y] [Zeile löschen])
(!TASTE [Ctrl Z] [Schriftart einstellen])
(!TASTE [Ctrl~,] [Fenster überlappend anordnen])
(!TASTE [Ctrl~.] [Fenster nebeneinander anordnen])
(!TASTE [Ctrl --] [Fenster untereinander anordnen])
(!TASTE [Shift Ctrl --] [Fenster zweispaltig untereinander anordnen])
(!TASTE [Ctrl ' '] [Leerzeichen einfügen, ohne Cursorposition zu ändern])

Auf dem Ziffernblock:

(!TASTE [Ctrl (, !), /, *] [Fenster 0--3 öffnen; mit Shift Fenster 4--7])
(!TASTE [Ctrl 0..9] [Tool 0..19 starten])
(!TASTE [Ctrl Shift Ctrl 0..9] [Tool 10..19 starten])

!subnode Alternate-Kombinationen

(!TASTE [Alt 1..0] [(Hauptblock!) Marke 1..10 anspringen])
(!TASTE [Alt A] [Text aufgeben])
(!TASTE [Shift Alt A] [geladene Fehlerdatei aus dem Speicher entfernen])
(!TASTE [Alt B] [zum Blockanfang springen])
(!TASTE [Alt C] [Block kopieren])
(!TASTE [Shift Alt C] [Block in eine Datei schreiben])
(!TASTE [Alt E] [*.PRG, *.TOS, *.TTP ausführen])
(!TASTE [Alt F] [Suche fortsetzen])
(!TASTE [Shift Alt F] [Begriff rückwärts suchen])
(!TASTE [Ctrl Alt F] [Suche ab Textanfang fortsetzen])
(!TASTE [Shift Ctrl Alt F] [Suche rückwärts ab Textende fortsetzen])
(!TASTE [Alt G] [zur letzten Position springen])
(!TASTE [Alt H] [Zeile auskommentieren bzw. Auskommentierung aufheben])
(!TASTE [Ctrl Alt H] [Block auskommentieren])
(!TASTE [Alt I] [Klammern und Umlaute definieren])
(!TASTE [Alt J] [Sprung zu nächstem Fehler])
(!TASTE [Shift Alt J] [Sprung zu vorherigem Fehler])
(!TASTE [Alt K] [zum Blockende springen])
(!TASTE [Alt L] [Text durch Version in der Datei ersetzen (überladen!)])
(!TASTE [Alt M] [markierten Block als Suchbegriff übernehmen])
(!TASTE [Shift Alt M] [markierten Block als Ersetzungsbegriff übernehmen])
(!TASTE [Alt N] [Text neu anlegen])
(!TASTE [Alt O] [Text aus erstem Pfad öffnen])
(!TASTE [Shift Alt O] [Fehlerdatei zuladen])
(!TASTE [Alt P] [Pfadedialog öffnen])
(!TASTE [Alt Q] [neuen Text aus den letzten 10 Texten auswählen, die Extensions verändern oder Text von anderen Pfaden laden])
(!TASTE [Alt R] [Suchen und Ersetzen mit Nachfrage fortsetzen])
(!TASTE [Shift Alt R] [Suchen und Ersetzen rückwärts fortsetzen])
(!TASTE [Ctrl Alt R] [Suchen und Ersetzen ab Textanfang fortsetzen])
(!TASTE [Shift Ctrl Alt R] [Suchen und Ersetzen rückwärts ab Textende fortsetzen])
(!TASTE [Alt S] [Zeile merken (in Zeilenpuffer kopieren!)])
(!TASTE [Alt T] [Tabulatoren komprimieren/expandieren])
(!TASTE [Alt U] [Text unter anderem Namen abspeichern])
(!TASTE [Shift Alt U] [wie Alt U, Dateidatum bleibt unverändert])
(!TASTE [Alt V] [Block verschieben])
(!TASTE [Shift Alt V] [Block von Datei an Cursorposition einfügen])
(!TASTE [Ctrl Alt W] [Absatz formatieren])
(!TASTE [Shift Alt W] [Absatz formatieren])
(!TASTE [Ctrl Alt W] [Zeile formatieren, auch wenn sie Absatzende ist])
(!TASTE [Shift Ctrl Alt W] [bis zur nächsten Leerzeile als Absatz formatieren])
(!TASTE [Alt X] [Leerzeichen entfernen (Redundanz!)])
(!TASTE [Alt Y] [Block in Puffer ausschneiden])
(!TASTE [Alt Z] [zu Zeile/Spalte springen])
(!TASTE [Alt~,] [Fenster auf Maximalgrö₧e bringen])
(!TASTE [Shift Alt~,] [alle Fenster auf Maximalgrö₧e bringen])
(!TASTE [Alt~.] [Fenster auf Maximalhöhe bringen])
(!TASTE [Alt -] [Fenster auf Maximalbreite bringen])
(!TASTE [Alt !~] [Zeile mit darunterliegender vertauschen])
(!TASTE [Shift Alt !~] [Zeile mit darüberliegender vertauschen])
(!TASTE [Alt <] [Block bzw. Zeile um Tabulatorweite nach links schieben])
(!TASTE [Shift Alt <] [Block bzw. Zeile um Tabulatorweite nach rechts schieben])

Auf dem Ziffernblock:

(!TASTE [Alt (, !), /, *] [Fenster 0--3 schlie₧en; mit Shift Fenster 4--7])
(!TASTE [Alt~--] [Zeichen in Kleinschrift umwandeln und Cursor nach rechts])
(!TASTE [Ctrl Alt~--] [Block in Kleinschrift umwandeln])
(!TASTE [Alt~+] [Zeichen in Gro₧schrift umwandeln und Cursor nach rechts])
(!TASTE [Ctrl Alt~+] [Block in Gro₧schrift umwandeln])
(!TASTE [Alt~.] [die beiden Zeichen links vom Cursor vertauschen])
#}}}


!node History
#{{{
!begin_description
  !item [Clix 3.50]
      Erstes Release als Shareware

  !item [Clix 3.60]
      !begin_itemize
        !item Probleme mit 68040 beseitigt
        !item IO-Redirection für externe Tools
        !item SE-Protokoll eingebaut
        !item Hervorhebungen aus 256 Farben, statt wie bisher aus den 16
        AES-Farben
        !item Parameterdateien werden in der Reihenfolge
          !begin_enumerate
            !item aktueller Pfad
            !item Environment-Variable HOME
            !item Environment-Variable CLIXPAR
            !item Environment-Variable CLIX
          !end_enumerate
          gesucht.
        !item Optimierungen beim Scrolling, insbesondere bei sehr gro₧en
        Texten merkbar.
        !item Annahme von APTERM
        !item Keine Icons mehr im Desktop-Fenster, stattdessen Liste der
        Texte
        !item mit der Environment-Variable SCREENBORDER=x0,y0,x1,y1 kann der
        verfügbare Bildschirmbereich für das Anordnen von Fenstern
        eingeschränkt werden.
        !item Projektdateien: eine Datei mit Dateinamen kann als Projektdatei
        verwendet werden. Dateien, die ständig benötigt werden, können aus
        einem Popup ausgewählt werden. Das Popup wird mit SHIFT-ALT-Q
        aufgerufen. Die Projektdatei enthält eine Datei pro Zeile, Kommentare
        können mit '!#' eingeleitet werden.
        !item Blockcursor für die die es unbedingt haben wollten...

        !item diverse kleine Bugs beseitigt
      !end_itemize

  !item [Clix 3.70]
    !begin_itemize
      !item Diverse Sachen, von denen ich kaum mehr wei₧, was es alles war
      !item Support für OLGA
      !item Spezialrelease für Whiteline Kappa
    !end_itemize

  !item [Clix 3.71]
    !begin_itemize
      !item Die Schlüsselregistrierte Version hatte leider wie die
      Kappa-Version keinen Button zum Erreichen des Registrierdialoges.
    !end_itemize

  !item [Clix 3.72]
    !begin_itemize
      !item Bugfix: proportionale Fonts machten wieder Ärger, Clix blieb beim
      Start in einer Endlosschleife hängen. Eine Korrektur war bereits vor
      langer Zeit erfolgt, eine weitere mu₧te noch durchgeführt werden.

      Es gibt leider noch weitere Probleme mit proportionalen Zeichensätzen
      in der GEMPLUS-Library, wie zB eine fehlerhafte Positionierung von
      Tastaturkürzelmarkeren oder in Listboxen (Pick-Dialog). Es tut mir
      leid, aber eine Korrektur wäre sehr aufwendig. Ich bitte daher um
      Verständnis für die Darstellungsfehler.
      !item Die Trennlinien im Hauptmenu werden nicht mehr selbst gezeichnet.
      Damit sind '3D-Menüs' möglich.
      Das scrollende Toolsmenü hat leider nach wie vor Zeichnungsfehler. Dies
      würde einen erheblichen Eingriff in die GEMPLUS-Library erfordern. Ich
      bitte um Nachsicht bei dieser Unschönheit.
    !end_itemize




!end_description

#}}}