// Help file syntax MODIF 2
// This is the help file for C.a.R., used inside the program
// for context sensitive help, and also to extract HTML
// pages using the Translator program contained in C.a.R.
// Refer to the Wiki for more information.


//************************************
.index
.related start online license gui
CaRMetal


CaRMetal est développé depuis février 2006 par Eric Hakenholz à partir du moteur mathématique du logiciel C.a.R. de René Grothmann. A côté des fonctionnalités de ce logiciel d'origine, on en trouve beaucoup de nouvelles (voir <a href="http://db-maths.nuxit.net/CaRMetal/versions.html">la page d'évolution de CaRMetal</a>), et du point de vue de l'interface graphique, ce logiciel propose une approche différente très axée sur la notion de <a href="http://revue.sesamath.net/spip.php?article39">manipulation directe</a>. Il ne s'agit donc pas d'un simple réhabillage cosmétique de l'application C.a.R. - ce qui en soi n'aurait que peu d'interêt - mais d'un changement important dans la manière d'accéder aux fonctionnalités.

Je vous souhaite de bonnes constructions avec CaRMetal !
 L'auteur :
 Eric Hakenholz

//************************************
.start
.related index online license gui tips localize language
Aide contextuelle

Ce système d'aide fournit des informations sur l'outil courant (clic sur une
icône de la palette), sur la dernière action, ou sur toute requête formulée par l'intermédiaire du
cadre de recherche : 

<img src="images/context/001.gif" border="1">

L'entrée de tout mot ou début de mot dans ce cadre provoquera, à chaque lettre tapée, une recherche "plein texte" dans la totalité de l'aide afin d'y trouver des occurrences
de la requête.
Lorsque plusieurs rubriques d'aide correspondent à un sujet donné,
un menu de navigation est disponible (icône "loupe" ou flèche bas du clavier). Les sujets connexes à une aide donnée sont aussi affichés sous forme de liens
hypertextes en bas de page.

Le texte de certaines rubriques contiennent aussi des liens qui pointent
soit vers une autre rubrique, soit vers un site Internet. Dans ce
dernier cas, le navigateur s'ouvrira automatiquement à l'adresse
ciblée par le lien.

Bonnes constructions avec CaRMetal !
 Cordialement,
 <u><i>Eric Hakenholz</i></u>




//************************************
.online
.related start tips license
Aide sur Internet

Vous pouvez trouver sur <a href="http://db-maths.nuxit.net/CaRMetal/">le site de CaRMetal</a> des tutoriels sous forme d'animations flash qui permettront au débutant de se familiariser rapidement avec certaines fonctionnalités du logiciel. Certains tutoriels sont aussi destinés aux utilisateurs avertis : ils sont de toutes façons classés par ordre de difficulté croissante, de une à quatre étoiles.

Pour avoir quelques exemples supplémentaires de ce qui peut se faire avec CaRMetal, nous vous proposons la lecture des différents articles du <a href="http://db-maths.nuxit.net/CARzine/">webzine CARzine</a>.

.license
.related online start
Licence de CaRMetal

CaRMetal est un logiciel gratuit sous licence GNU-GPL, ce qui signifie que vous
pouvez le redistribuer et/ou le modifier selon les termes de la <a href="http://www.gnu.org/licences/gpl.txt">licence publiée par la "Free Software Foundation"</a>.

//************************************
.nom_points
.related zone_aspect point gui iconbar macrobar mouse zoom online keyboard
Menu de choix<br >des noms de points

Ce menu permet d'activer l'attribution automatique des noms de points dans l'ordre alphabétique à partir d'une lettre donnée.

<img src="images/palettes/palettecars.gif" border="1">

Les 4 premières lettres de la colonne bleue de ce menu permettent de choisir 4 types de jeux de caractères : majuscules (D), minuscules (d), majuscules grecques (∆) et minuscules grecques (∂). Dans l'exemple, le jeu "majuscules" est sélectionné : si on clique sur E', tous les points créés dans la figures apparaîtront avec les noms E', F', G', H', etc...

Cliquer sur P1 désactive le nommage automatique : de manière interne les points seront nommés de manière générique P1, P2, etc... et leurs noms n'apparaîtront pas avec la création des points.

//************************************
.zone_aspect
.related nom_points gui iconbar macrobar mouse zoom online keyboard
Zone de palette<br >"Aspect et couleur"

Cette zone se charge de définir l'aspect des objets à créer, c'est à dire ceux qui ne sont pas encore dans la construction. Si, par exemple, l'outil droite est sélectionné, la partie
inférieure de cette zone affiche les propriétés d'aspect des droites :

<img src="images/palettes/aspectobj.gif" border="1">

Cliquer sur d'autres icônes (couleur, épaisseur, ...) modifie l'aspect par défaut des droites à venir. Notons qu'ici certaines icônes sont grisées, donc inaccessibles,
parce que certaines propriétés ne peuvent s'appliquer aux droites.

Il serait fastidieux d'avoir à cliquer sur l'outil point à chaque fois qu'on veut changer l'apparence des points à venir, d'autant plus qu'ils peuvent être créés "à la volée" pendant une phase de construction avec d'autres outils (droite, cercle, etc...). La partie supérieure de cette zone permet de changer la forme et le nom des points même lorsqu'un autre outil est sélectionné :

<img src="images/palettes/formepts.gif" border="1">

En cliquant sur la dernière icône (indiquant P4 ci-dessus) un menu fait apparaître <a href="#nom_points">une palette dédiée au choix du nom des points à venir</a>.

 
//************************************
.gui
.related zone_aspect iconbar macrobar mouse zoom online keyboard
Interface utilisateur


La fenêtre principale de CaRMetal, située juste à droite de ce panneau d'aide,
affiche la construction géométrique. La vue de la figure peut être modifié soit par
un déplacement (clic-droit glissé dans une zone vide), soit par un zoom (molette de la souris). Un <a href="#zoom">outil zoom</a>, disponible dans le menu Edition, peut aussi être utilisé pour ces deux actions.

A droite de cette construction se trouve la palette d'outils classés par thèmes dans différentes zones. Cliquer sur ces outils fera apparaître l'aide expliquant ce à quoi ils servent et comment s'en servir.

Après un clic-droit sur un objet, ou après avoir demandé "Inspecteur d'objets" dans le menu "Affichage" une barre horizontale de propriétés des objets apparaît au dessus ou en dessous de la fenêtre principale. Attention à la différence de status entre cette barre et la zone de palette "Aspect & couleur" : cette dernière se charge de l'apparence des objets à venir, tandis que la barre de propriété prend le relai pour les objets déjà créés.

//************************************
.iconbar
.related restricted gui settings
La palette principale

Il y a dans la palette principale de CaRMetal (à droite de la fenêtre de construction), des icônes-outils de nature différentes :

- Les icônes qui attendent que l'utilisateur clique dans la fenêtre de construction. C'est le cas de tous les outils de la zone "Construction".

- Les icônes qui servent à modifier les paramètres par défaut des objets. C'est le cas de tous les icônes de <a href="#zone_aspect">la palette "Aspect & couleur"</a>.

- Des icônes-bascule comme l'icône d'affichage du repère <img src="#palette/grid.png" border="1" align="middle"> ou encore celle qui permet d'afficher les objets cachés <img src="#palette/hidden.png" border="1" align="middle">.

//************************************
.restricted beginner
.related iconbar
Palette restreinte

-- A FAIRE --



//************************************
.mouse
.related gui settings hide point circle move keyboard edit
La souris

Lorsqu'un outil de construction est sélectionné, le bouton gauche de la
souris permet de créer un nouvel objet dans la figure.

De nombreux objets attendent que l'utilisateur choisissent plus d'un seul objet.
Dans ce cas, les objets apparaissent en rouge au fur et à mesure qu'ils sont
sélectionnés.

S'il peut avoir un rôle dans une phase de création, un objet "flashe" en jaune
fluo au passage du curseur, pour que l'utilisateur sache exactement ce qu'il est
en train de faire. 

<img src="images/flash.gif" border="0">

Ci-dessus, le logiciel prévient qu'on s'apprête à créer un point
sur une droite, ou sur un cercle, ou à l'intersection des deux. Ces réponses vidéos sont
systématiques dans le logiciel.

Si la touche <i>shift</i> est pressée pendant la création d'un point, d'un cercle, d'un segment
ou d'un angle, CaRMetal comprendra qu'il faut qu'il crée un objet fixe dans la figure, invitant
par l'intermédiaire de <a href="#properties">la barre de propriétés</a> l'utilisateur à déterminer
numériquement les coordonnées du point, le rayon du cercle, la longueur du segment ou l'angle.

Le clic-droit est comme une seconde nature dans le logiciel :
 - Sur un objet, il charge ses paramètres dans la barre de propriétés pour que vous puissiez les
modifier aisément.
 - Si la touche <i>ctrl</i> est enfoncée pendant le clic-droit sur un objet, les propriétés
conditionnelles de l'objet apparaissent dans la barre.
 - Si la touche <i>ctrl</i> ET la touche <i>shift</i> sont enfoncées
pendant le clic-droit sur un cercle ou une droite définie par deux points l'objet devient "incomplet" puis, si on clique encore, invisible.
 - Si la touche <i>ctrl</i> ET la touche <i>shift</i> sont enfoncées
pendant le clic-droit sur un autre type d'objet, cet objet devient caché.
 - le clic-droit glisser permet de déplacer un objet même quand l'outil <a href="#move">"déplacer"</a> n'est pas sélectionné.
 - le clic-droit glisser permet aussi de déplacer les noms des objets (les étiquettes) lorsqu'ils sont visibles dans la fenêtre. Si la  touche <i>shift</i> est enfoncée pendant cette opération, le nom peut être déplacer à n'importe quel endroit de la fenêtre. Sinon, l'étiquette du nom restera près de l'objet.


//************************************
.background
.related gui move htmlexport
Image de fond de fenêtre

CaRMetal peut afficher une image derrière la construction courante. La figure doit être enregistrée et l'image (gif ou png) doit se trouver dans le même répertoire que la figure. Cliquer sur l'outil <img src="#palette/background.png" border="1" align="middle" width="28" height="28"> de la zone de palette "Fond : couleur & image" permet de sélectionner le fichier image. Cette icône est une bascule : recliquer dessus lorsqu'elle est sélectionnée aura pour effet d'enlever l'image de fond.

La façon dont l'image apparaît en fond de figure est géré par les trois icônes situés dans le coin inférieur droit de cette zone de palette :

<table width="100%" class="tab" cellspacing="2">
<tr><td width="40"><img src="#palette/imstretch.png"></td><td class="comment">Permet d'étirer l'image pour qu'elle occupe tout le fond de la fenêtre</td></tr>
<tr><td width="40"><img src="#palette/imcenter.png"></td><td class="comment">Permet de centrer l'image de fond</td></tr>
<tr><td width="40"><img src="#palette/imtile.png"></td><td class="comment">Permet de répéter l'image de fond sous forme de mosaique</td></tr>
</table>

//************************************
.prop_name
.related properties
Nom d'un objet<p class="comment">Barre de propriétés</p>

Les noms d'objets peuvent contenir presque tous les caractères et doivent tous être unique. S'ils contiennent le caractère "~" l'affichage du nom se limitera à ce qui est avant. Cela peut permettre de visualiser un même nom pour deux objets différents, mais on peut pour cela utiliser aussi (plus simplement !) <a href="#prop_alias">l'alias des objets</a>.

Si un nom d'objet se termine par un nombre, ce nombre est automatiquement placé en indice à l'affichage. Par exemple, si on entre "A1" pour le nom, ce qui sera affiché est A<sub>1</sub>. Il se peut que dans de rares cas ce ne soit pas ce que vous vouliez voir : il faudra alors simplement utiliser l'alias : entrer "A1" dans cette autre rubrique ne provoque pas la mise en indice automatique.

Si on demande, par l'intermédiaire de <a href="#prop_showline">deux icônes dédiés</a>, l'affichage du nom ou de <a href="#prop_alias">l'alias</a> et de la valeur d'un objet, l'affichage est du type "s=2", où s est le nom ou l'alias de l'objet. Si on termine le nom ou l'alias d'un objet par le caractère de soulignement "_", le signe "=" n'est pas affiché. Par exemple si le nom d'un point est P_ et qu'on demande l'affichage de sa "valeur" (les coordonnées) l'affichage est du type P(2,1;5,2) et non pas P=(2,1;5,2).

//************************************
.prop_alias
.related properties
Alias d'un objet<p class="comment">Barre de propriétés</p>

Les objets peuvent utiliser d'autres noms (un "alias") pour l'affichage que leurs noms propres. Comme les textes que l'ont peut inclure dans une figure,
les alias peuvent aussi être utilisés pour insérer du <a href="#latex">code LaTeX</a> entre $...$ qui permettent un affichage sophistiqué des noms d'objets. Un alias peut aussi contenir des expressions entre %...% qui
sont évaluées en permanence.

Si par exemple, pour un point A de l'axe des abscisses, on crée l'alias $x_A=%x(A)%$ , on obtiendra ceci :

<img src="images/tex.gif" border="1">

Une chaine de caractère de la forme %=s% renvoie le nom courant de l'objet s : si on change son nom l'expression est automatiquement actualisée pour refléter
ce changement.

Une chaine de caractère de la forme %~s% retournera l'équation de l'objet s.

//************************************
.prop_unit
.related properties
Unité des mesures affichées<p class="comment">Barre de propriétés,<br >onglet Aspect</p>

Certains objets peuvent afficher des mesures et des unités. L'unité peut être n'importe quel texte : celui-ci sera automatiquement
placé juste après la longueur. L'unité peut donc être interprétée comme étant
juste un suffixe de la mesure.

Si on demande par exemple les propriétés d'un segment et qu'on demande " km"
comme unité, l'affichage donnera :

<img src="images/unit.gif" border="1">

//************************************
.prop_zindex
.related properties
Niveaux de calques<p class="comment">Barre de propriétés,<br >onglet Aspect</p>

Vous pouvez attribuer un niveau de calque à n'importe quel objet géométrique. De deux objets, celui qui a le plus petit niveau de calque est affiché devant l'autre dans la fenêtre.

<table width="100%">
<tr><td><img src="images/zindex02.gif" border="1"></td><td width="10">&nbsp;</td><td><img src="images/zindex01.gif" border="1"></td></tr>
<tr><td class="comment">Le calque du triangle vaut 1 et celui du segment vaut 2</td><td width="10">&nbsp;</td><td class="comment">Le calque du triangle vaut 2 et celui du segment vaut 1</td></tr>
</table>
 Un niveau de calque n'est pas forcément un entier, et n'est pas non plus nécessairement un positif. Dans tous les cas, la règle du "inférieur->devant" est appliquée.

Un niveau de calque peut aussi être autre chose qu'un simple nombre : on peut entrer une expression, ce qui permet d'obtenir à l'affichage un ordre de superposition des objets qui dépend de la configuration géométrique.

//************************************
.prop_coordinates
.related properties
Coordonnées<p class="comment">Barre de propriétés,<br >onglet Numérique</p>

Les cadres "X" et "Y" permettent d'imposer des coordonnées cartésiennes à un point. Si le chaînage des coordonnées est activé par l'icône <img src="#palette/chaine.png" border="1" align="middle">, la frappe clavier dans le cadre X entraîne un remplissage automatique du cadre Y, avec remplacement de toutes les fonctions abscisses "x()" par des fonctions ordonnées "y()".

Avec chaînage actif, il suffit par exemple de taper "2*x(B)-x(A)" comme abscisse d'un point M pour que l'expression "2*y(B)-y(A)" soit affichée automatiquement dans le cadre Y, et le point M devient donc le symétrique de A par rapport à B.

Pour activer ou désactiver le chaînage, il suffit de cliquer sur l'icône de la chaîne.

//************************************
.prop_grid
.related properties
Incrément de la grille<p class="comment">Barre de propriétés,<br >onglet Numérique</p>

Un point libre par définition peut être déplacé n'importe où dans la fenêtre. Mais si on lui impose un incrément autre que 0, ce point va suivre un déplacement discret. Si, par exemple, un point a 0,5 comme incrément, il ne se déplacera que de demi-unité en demi-unité, en suivant les noeuds d'une grille virtuelle 0,5x0,5 centrée sur l'origine du repère interne. On peut aussi définir un incrément pour des points sur objet.

Le grand intérêt de ce système par rapport à une grille magnétique est qu'on peut attribuer un incrément différent à plusieurs points... sans avoir à créer plusieurs grilles.

//************************************
.prop_length
.related properties
Longueur d'un segment<br >Rayon d'un cercle<p class="comment">Barre de propriétés,<br >onglet Numérique</p>

Lorsqu'on demande les propriétés d'un cercle (rep. d'un segment), on peut dans l'onglet "Numérique" fixer son rayon (resp. sa longueur) par l'intermédiaire du cadre rayon (resp. longueur).

En phase de création, on peut utiliser les outils <img src="#palette/fixedcircle.png" border="1" align="middle"> et <img src="#palette/fixedsegment.png" border="1" align="middle"> pour imposer un rayon ou une longueur : la barre de propriété s'ouvre alors automatiquement et il n'y a qu'à taper au clavier.

On peut entrer indifféremment un nombre ou une expression dans ce cadre.


//************************************
.prop_angle
.related properties
Mesure d'un angle<p class="comment">Barre de propriétés,<br >onglet Numérique</p>

Lorsqu'on demande les propriétés d'un angle, on peut dans l'onglet "Numérique" fixer sa mesure en degrés par l'intermédiaire du cadre Angle.

En phase de création, on peut utiliser l'outil <img src="#palette/fixedangle.png" border="1" align="middle"> pour imposer une mesure d'angle : la barre de propriété s'ouvre alors automatiquement et il n'y a qu'à taper au clavier.

On peut entrer indifféremment un nombre ou une expression dans ce cadre.

//************************************
.prop_conditionals
.related properties
Propriétés conditionnelles des objets<p class="comment">Barre de propriétés,<br >onglet Conditionnel</p>

On peut attribuer des propriétés conditionnelles à tout objet géométrique. Cela se fait par l'intermédiaire des cadres de l'onglet "Conditionnel" de la barre de propriétés.

Prenons un exemple : on se donne un point A et un segment s. Dans les propriétés conditionnelles de s (clic droit sur l'objet) on entre dans le cadre intitulé <i>Rouge</i> l'expression "x(A)&lt;0" et dans celui intitulé <i>Épais</i> la même expression. Dans le cadre <i>Vert</i> nous entrons "x(A)&gt;0" et dans le cadre <i>Pointillés</i> la même expression. Le résultat est que le segment s est affiché rouge et épais si A est d'abscisse négative et vert pointillé sinon.

//************************************
.prop_thickness
.related properties
Epaisseur des traits<p class="comment">Barre de propriétés, onglet Aspect</p>

Trois modes d'affichage des lignes sont disponibles : normal, épais et pointillé.
Pour les polygones et les cercles remplis, ces trois modes donneront l'apparence suivante :

<table width="100%"><tr><td><img src="images/thickness/normal.gif" border="1"></td><td><img src="images/thickness/thick.gif" border="1"></td><td><img src="images/thickness/dotted.gif" border="1"></td><td></td></tr><tr><td class="comment">Normal: fond léger, contour foncé</td><td class="comment">Épais: fond et coutour foncés</td><td class="comment">Pointillés: fond léger et aucun contour</td></tr></table>

//************************************
.prop_color
.related properties
Couleur<p class="comment">Barre de propriétés, onglet Aspect</p>

Six couleurs standard (noir, bleu, cyan, vert, marron, rouge) sont à votre disposition. Vous pouvez cliquer sur une de ces icônes pour changer la couleur de l'objet, mais vous pouvez aussi utiliser le <a href="#prop_scolor">menu des couleurs personnalisées</a>.

//************************************
.prop_scolor
.related properties
Couleurs personnalisées

<table width="100%" cellspacing="4" cellpadding="2">
<tr><td class="tds" width="40"><img src="images/scolors/icone.png" border="0"></td><td class="comment2">
A côté des <a href="#prop_color">six couleurs standard</a> figure dans la palette et la barre de propriétés un menu vous permettant de choisir une couleur quelconque.
</td></tr>
</table>
- Lorsqu'on clique-gauche sur l'icône de ce sélecteur de couleurs (en maintenant le bouton enfoncé) une palette de couleurs saturées vous permet par simple glisser de sélectionner une couleur :

<img src="images/scolors/saturated.jpg" border="1">

- Si maintenant (bouton gauche toujours enfoncé) vous appuyez sur la touche Majuscule, c'est une palette de couleur désaturées qui prend le relais :

<img src="images/scolors/desaturated.jpg" border="1">

- Si vous appuyez sur la touche Alt, c'est une palette de couleurs web qui arrive :

<img src="images/scolors/swatches.jpg" border="1">

- Si vous cliquez cette fois-ci avec le bouton droit de la souris sur ce menu, la palette qui arrive vous donne la liste de toutes les couleurs qui ont été utilisées dans la construction. En bas de cette palette figure en commentaire le nom du premier objet de la construction contenant la couleur survolée :

<img src="images/scolors/construction.gif" border="1">

- Si vous préférez maintenant obtenir une boîte à dialogue système pour obtenir de la couleur, il vous suffit d'enfoncer la touche espace pendant qu'une palette est affichée.

//************************************
.prop_type
.related properties
Forme des points<p class="comment">Barre de propriétés, onglet Aspect</p>

En demandant les propriétés d'un point, dans l'onglet <i>Aspect</i>, on peut modifier la façon dont cet objet sera affiché. Vous pouvez aussi modifier la taille des points, mais d'une manière globale, en agissant sur l'un des curseurs de la zone de palette : "Tailles".

//************************************
.prop_circleline
.related properties
Apparence des cercles<p class="comment">Barre de propriétés, onglet Aspect</p>

L'apparence des cercles est définie par <a href="#prop_thickness">l'épaisseur des traits</a>, par la
<a href="#prop_color">couleur</a>, les <a href="#prop_showline">bascules montrer/cacher</a> et par les quatre icônes ci-dessous :


<table width="100%" cellspacing="4" cellpadding="2">
<tr><td class="tds" width="40"><img src="#palette/partial.png" border="0"></td><td class="comment2">
Lorsque des points sont sur le cercle,
sélectionner ce paramètre entraînera un dessin incomplet
du cercle, qui ressemble à des "traits" de construction faits au compas et passant par les points.</td></tr>
<tr><td class="tds" width="40"><img src="#palette/filled.png" border="0"></td><td class="comment2">
Le cercle est rempli lorsque cette icône est sélectionnée.
</td></tr>
<tr><td class="tds" width="40"><img src="#palette/obtuse.png" border="0"></td><td class="comment2">
Lorsque le cercle est représenté sous forme d'arc AB (bouton arc de l'onglet "Numérique"),
sélectionner cette icône dessinera l'arc orienté AB, quel que soit la mesure de son angle.
Sinon, le petit arc sera affiché.
</td></tr>
<tr><td class="tds" width="40"><img src="#palette/solid.png" border="0"></td><td class="comment2">
Lorsque le cercle est rempli, on peut le rendre opaque en sélectionnant cette icône : il sera alors
susceptible de masquer tous les objets qui ont été créés avant lui. Notons qu'on peut aussi combiner
l'utilisation de ce paramètre "opaque" avec la notion de <a href="#prop_zindex">niveau de calque</a>.</td></tr>
</table>

//************************************
.prop_polyline
.related properties
Apparence des polygones<p class="comment">Barre de propriétés, onglet Aspect</p>

L'apparence des polygones est définie par <a href="#prop_thickness">l'épaisseur des traits</a>, par la
<a href="#prop_color">couleur</a>, les <a href="#prop_showline">bascules montrer/cacher</a> et par les deux icônes ci-dessous :

<table width="100%" cellspacing="4" cellpadding="2">
<tr><td class="tds" width="40"><img src="#palette/filled.png" border="0"></td><td class="comment2">
Le polygone est rempli lorsque cette icône est sélectionnée.
</td></tr>
<tr><td class="tds" width="40"><img src="#palette/solid.png" border="0"></td><td class="comment2">
Lorsque le polygone est rempli, on peut le rendre opaque en sélectionnant cette icône : il sera alors
susceptible de masquer tous les objets qui ont été créés avant lui. Notons qu'on peut aussi combiner
l'utilisation de ce paramètre "opaque" avec la notion de <a href="#prop_zindex">niveau de calque</a>.</td></tr>
</table>

//************************************
.prop_showline
.related properties
Bascules montrer/cacher<p class="comment">Barre de propriétés, onglet Aspect</p>

Ces icônes-bascule permettent d'afficher ou de masquer l'objet, sa valeur ou son nom :

<table width="100%" cellspacing="4" cellpadding="2">
<tr><td class="tds" width="40"><img src="#palette/hide.png" border="0"></td><td class="comment2">
Cette icône est commune à tous les objets : elle permet de montrer ou cacher l'objet dans la construction.
</td></tr>
<tr><td class="tds" width="40"><img src="#palette/showvalue.png" border="0"></td><td class="comment2">
Certains objets peuvent afficher des valeurs. Cette icône, lorsqu'elle est présente, permet d'afficher par exemple la longueur d'un segment, le rayon d'un cercle, la valeur d'une expression, etc... Si <a href="#prop_unit">une unité</a> a été définie, celle-ci accompagnera toujours la valeur.
</td></tr>
<tr><td class="tds" width="40"><img src="#palette/showname.png" border="0"></td><td class="comment2">
La plupart des objets permettent, par l'intermédiaire de cette icône, que l'on affiche <a href="#prop_name">leurs noms</a> ou <a href="#prop_alias">leurs alias</a> dans la construction.
</td></tr>
</table>

//************************************
.prop_boldline
.related properties
Grosseur des caractères<p class="comment">Barre de propriétés, onglet Aspect</p>

Ces icônes ne servent à quelque chose que si le nom, l'alias ou la valeur de l'objet est affiché :
<table width="100%" cellspacing="4" cellpadding="2">
<tr><td class="tds" width="40"><img src="#palette/bold.png" border="0"></td><td class="comment2">
Le nom, l'alias ou la valeur apparaîtra en caractères gras</td></tr>
<tr><td class="tds" width="40"><img src="#palette/large.png" border="0"></td><td class="comment2">
Le nom, l'alias ou la valeur apparaîtra en police plus grande.
</td></tr>
</table>

//************************************
.prop_magnetic
.related properties
Magnétisation des objets

Un point mobile P peut-être attiré par n'importe quel objet de la construction.

Lorsqu'on clique sur l'icône représentant un aimant, ou dans la boîte de texte "Objets magnétiques" de l'onglet "Numérique" (propriétés du point P), le mode d'aimantation est activé : on peut alors sélectionner à la souris les objets de la construction qui vont attirer le point P. On peut aussi taper au clavier, dans cette boîte de texte, le nom des objets séparés par des virgules.

La boîte de texte "Attraction" représente le rayon d'action, en pixels, du champs magnétique qui s'exerce autour de chaque objet dont le nom figure dans la liste "Objets magnétiques". On peut aussi définir des exceptions : si, par exemple, le champs "Objets magnétiques" contient la liste "A,E,c1:20,l1" et que le champs "Attraction" contient 50, les objets A,E et l1 auront un rayon d'attraction de 50 pixels, alors que l'objet c1 attirera P dans un rayon de 20 pixels.

//************************************
.properties
.related prop_name prop_alias prop_unit prop_zindex prop_coordinates prop_grid prop_length prop_angle prop_conditionals prop_thickness prop_color prop_type prop_circleline prop_showline prop_boldline edit conditions colors hide mouse transparent point fixedangle replay animatebreak expressionsyntax latex
Barre de propriétés


Vous pouvez ouvrir cette barre horizontale en effectuant un clic-droit sur
un objet, en utilisant <a href="#edit">l'outil d'édition</a> ou en demandant "Inspecteur d'objets" dans le menu "Affichage". Les propriétés de l'objet sur lequel on effectue un clic-droit sont chargées dans cette barre et organisés suivant trois rubriques : "Aspect", "Numérique" et "Conditionnel".

Beaucoup de paramètres sont communs à tous les objets, certains sont spécifiques : dans tous les cas, vous pourrez obtenir une aide contextuelle ciblée en cliquant dans un cadre texte, une icône ou n'importe quel item de cette barre de propriétés.

//************************************
.latex
.related properties text
LaTeX Code

CaRMetal utilise HotEqn pour afficher des formules LaTeX. Dans des textes, il faut entourer tout code LaTeX par le caractère $.

<table width="100%" cellspacing="4" cellpadding="2">
<tr><td class="tds" width="40"><img src="#bar/carbtn.png" border="0"></td><td class="comment2">Dans la barre de propriétés, lorsqu'on tape du texte dans certains cadres, on peut utiliser l'icône <i>Insérer</i> ci-contre pour obtenir un menu intitulé "Commandes LaTeX". Les articles de ce menu créeront pour vous automatiquement des formules LaTeX usuelles.</td></tr>
</table>

HotEqn peut afficher beaucoup de formule LaTeX. Les lettres grecques sont supportées (\alpha,\beta, ...), comme beaucoup de symboles LaTeX (\nabla). Bien sûr la notation indice (x_n) ou exposant (x^2) est possible, comme les fractions (\frac{1}{x} ou \dfrac). Les grands opérateurs, comme l'intégrale ou la somme peuvent aussi être affichées, tout comme les limites (\lim_{x \to \infty}).

Les grands crochets ou parenthèses sont très utiles, par exemple pour afficher une matrice : 

$\left(\begin{array}{cc}2&3 \\3&4\end{array}\right)$

Pour de plus amples informations sur les possibilités de HotEqn, vous pouvez vous rendre <a href="http://mathsrv.ku-eichstaett.de/MGF/homes/grothmann/java/zirkel/doc_en/Documentation/HotEqn.html">sur cette page web (en anglais)</a>.

//************************************
.transparent
.related colors reorder properties
Transparence


Les objets remplis tels que les polygones ou les cercles peuvent apparaître opaques ou transparents :

<table width="100%" cellspacing="4" cellpadding="2">
<tr><td class="tds" width="40"><img src="#palette/solid.png" border="0"></td><td class="comment2">
Lorsque l'objet est rempli, on peut le rendre opaque en sélectionnant cette icône dans la barre de propriétés (ongle <i>Aspect</i>): il sera alors susceptible de masquer tous les objets qui ont été créés avant lui dans la construction. Notons qu'on peut aussi combiner l'utilisation de ce paramètre "opaque" avec la notion de <a href="#prop_zindex">niveau de calque</a>.</td></tr>
</table>

Le choix opaque ou transparent peut aussi être fait avant de créer l'objet, dans la zone de palette "Aspect et couleur".

//************************************
.point
.related nom_points boundedpoint intersection settings mouse properties selfreference
Points

Un point peut être généré par différents outils et de multiples
façons. L'outil point peut créer un point libre, un <a href="#boundedpoint">point sur un objet</a> ou un point
à une <a href="#intersection">intersection d'objets</a>. Les objets approchés par le curseur, lorsque cet
outil est sélectionné, flashent de manière à indiquer clairement ce
que vous vous apprêtez à faire :

<img src="images/point/001.gif" border="2">

Si la touche "shift" est enfoncée pendant la création, le point sera
de coordonnées fixe. 

<u>Exemple d'utilisation :</u> faire un "shift-clic" sur un point déjà existant
effectue une sorte de clonage du point ciblé. Ceci est particulièrement
utile lorsqu'on souhaite avoir un bon aperçu des positions clé d'un point
dans une figure. Dans certaines circonstances (démarche d'investigation par exemple), cela peut être mieux que l'utilisation d'un lieu ou d'une trace de point... Vous pouvez <a href=http://db-maths.nuxit.net/CaRMetal/tutoriels/lieux_pt_par_pt/lieux_pt_par_pt.htm">visualiser un tutoriel internet</a> à ce sujet.

//************************************
.boundedpoint
.related point line mouse properties
Points sur objets

Ce sont des points contrains à rester sur une droite, un cercle, une courbe etc... Ils se déplacent de façon continue. Un point peut être attaché ou détaché à tout moment en prenant ses propriétés (clic-droit sur le point) : dans l'onglet Numérique figure un bouton "Attacher" ou "Détacher".

Si l'objet sur lequel on place un point est un polygone ou un cercle, il est possible de demander à ce qu'il soit à l'intérieur de l'objet (enfermé par son périmètre). Cela se fait dans la barre de propriétés, en cochant la case "Dans l'objet" de l'onglet "Numérique".

//************************************
.line ray
.related point parallel properties segment
Droites et demi-droites

Les droites peuvent être des parallèles, des perpendiculaires ou des droites définies par deux points. Une demi-droite peut être définie par deux points, ou être issue d'une utilisation de l'outil <a href="#fixedangle">angle fixe</a>.

//************************************
.segment fixedsegment
.related expressionsyntax point parallel properties line
Segments et segments de longueur fixe

<table width="100%" cellspacing="4" cellpadding="2">
<tr><td class="tds" width="40"><img src="#palette/segment.png" border="0"></td><td class="comment2">Pour créer un segment il suffit de désigner deux points, ou de les créer "à la volée". On peut aussi créer un segment de longueur fixe en maintenant enfoncée la touche Maj tout en cliquant sur le second point. En demandant les propriétés d'un segment déjà créé, il est aussi possible de fixer sa longueur en demandant ses propriétés (clic-droit sur le segment).</td></tr>
<tr><td class="tds" width="40"><img src="#palette/fixedsegment.png" border="0"></td><td class="comment2">Lorsqu'on utilise cet outil "segment de longueur fixe", la barre de propriété apparaît automatiquement et vous permet d'entrer un nombre pour fixer sa longueur.</td></tr>
</table>

//************************************
.circle circle3
.related properties point transparent fixedcircle
Cercles

Il existe dans CaRMetal 5 types d'objets circulaires :

<table width="100%" cellspacing="4" cellpadding="2">
<tr><td class="tds" width="40"><img src="#palette/circle.png" border="0"></td><td class="comment2">Les cercles définis par centre et point.</td></tr>
<tr><td class="tds" width="40"><img src="#palette/circle3.png" border="0"></td><td class="comment2">On désigne un point M</td></tr>
</table>


//image- images/circle.png
There are three types of circles. Circles around a point M and through
a point A, circles around a point M with radius AB, and fixed circles.
Each type has an own tool. The first kind expects two points, the
second three, and the last only one.

Drawing a circle can be restricted between two defining points,
yielding circular arcs. In this case, it is possible to keep the arc
less than 180 degrees (i.e., always the shorter arc will be drawn
connecting the ends of the arc). You select the end points using a
button in the property dialogs of the circle.

Circles can be filled. Arcs can be filled in two ways, either as a
chord section of a circle, or as a pie.

Circles can be restricted to their necessary parts. These partial
circles are only drawn in little arcs through all points related to
them.

-> See: Fixed Circles

.fixedcircle
.related circle reorder expressionsyntax properties point transparent
Fixed Circles

//image- images/fixedcircle.png
Fixed circles have no radius point. To generate such a circle, hold
the shift key when defining the radius point, or use the special tool
for this. This will open the settings dialog, where you can enter any
expression for the radius. If the circle is dragged immediately after
the generation, the settings dialog will not open, but the current
size will be used.

Fixed circles can be sized to the distance of two points using any
expression. Instead of writing the expression in the
__properties__dialog, the value can be taken from the construction.
Either use another expression, or two points, or another circle. for
this, use the button "Set size ..." in the settings dialog.

//image images/CircleDialog.jpg

The size of fixed circles can be dragged with the mouse, if the fixed
state is released in the __properties__ dialog. If the fixed state is
set and the center of the circle is free, the center will be dragged
instead.

.intersection
.related point properties segment selectintersection
Intersections

//image- images/intersection.png
__Intersections__ can either be created by the point tool, clicking on
an intersection point, or with a special intersection tool. The
intersection tool is hidden by default, since the point tool can be
used instead in most cases.

The program can compute intersections between lines, circles, function
graphs, parametric curves and automatic tracks. In paper constructions,
intersections might not be thought of as an extra step to do. But the
computer won't compute all possible intersections. Also it makes the
necessary steps much clearer, if the user has to construct
intersections explicitly. 

It is possible to create intersection between __conicßsections__,
__tracks__, and __functions__ too. Note, that these intersections may
need some time to compute. Creating very many intersections of the
complicated kind will slow down your construction. Moreover, only one
of the intersection points is computed and updated in a continuous
way. The user can drag the intersection to other intersection points.

-> See: Selecting Intersections

.selectintersection
.related intersection point
Selecting Intersections

Circles intersect in two points. The program creates both
__intersections__ at once, if the two circles are selected as
parameters of the intersection tool. If you need only one, hide the
other. For automatically created intersections, the other intersection
will not be generated.

//image images/Intersections.jpg

There is a subtle problem with the way the program selects the two
intersections of circles (or a circle and a line). In contrast to
other programs, this is done in a predictable way. For circles, the
order will change, if the circles are switched. The intersections
between a line and a circle depend on the direction of the line (i.e.
the order of its creating points). Try moving the line so that it does
no longer intersect the circle, then move it back. The 
intersection will be the same.

Sometimes the intersection must be specified. This can be done by
telling one of the intersection points to be __differentßfrom__ a
certain other point. The intersections will then be selected such that
the chosen intersection is furthest away from the other point. The
dialog for intersections contains a special field to specify the other
point, or a button to select the point interactively. 

Note that this type is intersection is created automatically, if the
other intersection point is a point on the perimeter of both circles,
and if this point is visible. 

You an also specify that the intersection should be the one that is
__closeßto__ a given point.

Selections with circles can be set to switch automatically whenever
they become invalid. As with automatic tracks, the construction
will then run through all states.

.parallel plumb midpoint
.related line point properties
Parallel and Perpendicular Lines, Midpoints

//image- images/parallel.png
These are simply shortcuts for classical constructions. The first
two tools create lines. The midpoint is a point, of course. These
tools could be replaced by standard circle and ruler constructions, or
by macros.

Perpendicular lines to segments become invalid, if the intersection
is not within the segment. You can switch that off in the properties
dialog.

.move
.related circle angle background mouse
Move Objects

//image- images/move.png
This tool moves points (an alternative to the right mouse button). It
can also drag the size fixed circles and angles, unless these objects
are fixed for dragging. To unfix those objects, hold down the
__Ctrl-key__ while moving.

If lines, circles, polygons, or conic sections are generated by free
points only, they can be dragged too.

When the move tool is selected or when it is reset with the Esc
key, all moveable objects blink in red. This helps to identify the
__freeßpoints__. Moreover, free objects are also marked in the
__objectßlist__ by ">".

It is possible to move several points at once. To do this, hold down
the __Shift-key__ while selecting the points, and release it for the
last point.

When the shift key is hold during the movement, the movement will be
restricted, to the point where an intersection becomes invalid. For
applets, this behaviour can be made the default by the
"restrictedmove" applet parameter.

If the __ctrlßkey__ is hold while moveing, the old construction will
be visible in the background during the movement.

.tracker
.related point animate background mouse objecttracker
Manual Point and Line Tracking

//image- images/tracker.png
This tool draws ___tracks__ of moving points or lines. For a point its
position is tracked, and for a line, a curve is generated with the
tracked lines as tangent lines (a __polarßset__).

//image images/Track.jpg

First one or more point or line to be tracked have to be selected. To
select more than one object to be tracked, hold down the __Shift-key__
when selecting objects. Then some point, slider or other moveable
object can be dragged with the left mouse button. This moves the
selected object and creates the track. 

The color of the track is the same as of the tracked objects, and
the track will remain visible until another construction tool is
selected, or the track tool is reset with the __Escßkey__.

Point and line tracks can be mixed. Line tracks can be produced
from lines, rays or segments.

To turn a track into a permanent construction object, you have to use
the automatic tracking tool.

-> See: Automatic Point and Line Tracking  

.objecttracker
.related tracker point animate
Automatic Point and Line Tracking

//image- images/objecttracker.png
This tool draws point and line __tracks__ (as the manual tracking
tool) by animating the movement of a single point along a line or
circle. First select one or more points or lines to be tracked. Hold
down the __Shift-key__, if more than one object should to be tracked.
Then select a point on a line or on a circle, a slider or an
expression, or a line or circe. In the latter case, you need to select
the point to move on this line or circle too. The point will be
moved, or the slider or expression be changed, creating the tracks of
the selected objects.

Should the first tracked object become invalid due to an invalid
intersection, the movement is automatically reversed. In case the
first track point becomes invalid because two circles no longer
intersect, the other intersection point will be chosen when the moving
point reverses its movement. Thus the construction runs through all
possible __states__.

The __animationßspeed__ can be reduced or increased with the shift key
and the left or right __arrowßkeys__. Repeated left mouse button
clicks cycle the animation through 3 modes: animation and track,
animation and hidden track, track with no animation. In the last mode
the moving point can be dragged with the left mouse button. Other
points can be dragged with the right mouse button at any time, but
while this is done, the track will be hidden and any animation
paused.

If a construction file is saved with this tool as active tool, it will
become active when the file is loaded.   

To stop the animation and clear the tracks, select any tool., or press
Esc.

__PermanentßTracks__

To make the first track a permanent construction object, press shift
and enter, or select the automatic track tool with the control key. A
new object will be created using the currently selected color and
weight properties. The track can be edited in the same way as any
other object. It is possible to create __intersections__ between the
track and other objects, and to put points on the track.

Tracks saved this way are calculated at every change in the figure,
which may slow down the program on older computers. It is therefore
wise to limit the number of tracks, and to restrict their lengths to
reduce the calculation load. Moreover, it is possible to turn the
calculation of a track off or on by using the fixed checkbox in
its __properties__ dialogue.  

-> See Manual Point and Line Tracking

.animate
.related circle line
Animation

//image- images/animate.png
This will animate a single point, moving along one or several
segments or circles. To start the animation, select a point, then a
sequence of segments or circles. Finish by selecting the last point
with a double click.

To stop the __animation__, click on the construction. To reverse the
animation shift click. shift and right or left __arrowßkeys__ changes
the speed of the animation.

Animations are saved to the construction file. In applets, the
animation will prevent user interaction completely.

To go back and forth on line segments or on arcs, __shiftßclick__ into
the construction. This will also reverse the direction in circles.

.angle
.related circle properties fixedangle
Angles

//image- images/angle.png
Normal Angles are decoration and cannot be used to construct anything.
The exception is that it is possible to __bind__ points into the angle
area. The order of input for such angles is A, B, C, where B is the
corner point.

Angles can be displayed in three different sizes. The largest size
will display a circular arc, which starts in A.

Angles can have Greek letters in their name. To achieve an alpha,
enter \a, \A etc. You can use all Unicode letters with \0XXXX, where
XXXX is any hexadecimal digit. Angles, which are 90∞ or have a name
starting with "." will be labeled with a dot, if the size display is
switched on. Angles may be filled. It is probably better to use an
__alias__ for angles to achieve this.

By default, angles are never larger than __180ßdegrees__. The order of
A and C does not matter. However, this can be switched off in the
properties dialog of the angle.

As with other objects, the invisible thickness shows the label, but
not the angle.

-> See: Fixed Angles

.fixedangle
.related circle reorder expressionsyntax properties angle
Fixed angles

//image- images/fixedangle.png
Fixed angles have no third point, but a fixed size. This type of angle
behaves more like a ray than like an angle. It is possible to
intersect with the ray or place points on it.

__Fixedßangles__ are generated by holding down the __Shift-key__,
while clicking for the third point, or with the special tool for fixed
angles. This will open the settings dialog, where the user can enter
any expression for the size of the angle. If the angle is dragged
immediately, the settings dialog will not open.

Fixed angles can be sized using three given points, or any other
expression or angle. To do this select the button "set size ..." in
the settings dialog. Then e.g., select three points A, B, C, where B
is the corner point. The angle will be the same size as the angle ABC.
You can also use any other expression or angle to size the angle.

Fixed angles can be __inverted__. Thus one does not have to use
positive orientation. Furthermore, if a fixed angle is restricted to
180∞ (which is the default), and if such an angle is constructed in a
mathematical negative way, it will be inverted. There is an icon in
the settings dialog, which controls the inversion.

-> See: Angles

.area
.related point properties background
Filled Polygons

//image- images/area.png
This tool generates filled __polygons__ with given corners. Select
the corners of the area, and __doubleßclick__ the last point. The
sides are hidden, when the polygon has thin thickness in the
properties dialog.

The value of the filled polygon is its area. The sign of the value
depends on the orientation of the corners.


//************************************
.expression
.related angle circle properties reorder expressionsyntax
Expressions

Cet outil permet de placer une expression dans la fenêtre de travail. Lorsqu'on clique dans la construction, la barre de propriété est prête à recevoir une expression.

<img src="images/expression01.gif" border="1">
 Dans l'image ci-dessus, on affiche la longueur AB par l'intermédiaire d'une expression. Dans cet exemple taper d(A;B) dans le cadre "Exp" affiche la longueur AB seule, et entrer le commentaire "AB" fait apparaître le texte "AB=" devant celle-ci. Tout ce qui est entré dans le cadre texte définissant l'expression, pour que celle-ci soit valide, doit obéir à <a href="#expressionsyntax">certaines règles syntaxiques</a>. Le cadre "Commentaire" quant à lui peut recevoir n'importe quel texte, y compris <a href="#latex">du code LaTeX</a>.

Les expressions sont très utiles (cachées ou non) pour calculer des valeurs, afin de les
réutiliser plus tard dans la construction.

La valeur d'une expression peut aussi être fixée par un curseur. Pour cela, cocher la case "Curseur" de la barre de propriété et modifier éventuellement ses valeurs min et max (cadres de valeurs initiales -5 et 5).


.expressionsyntax
.related fixedangle fixedcircle point properties reorder function
Syntax for Expressions

Name 
 Example 
 DEscription 
 
+, -, *, /,^ or ** 
 3.5*3+3/(4-5^2) 
 Elementary math. 
 
Name of object 
 AB/CD 
 The name of a segment, circle, angle and other expression. The object
must not depend on the current object. To refer to objects
by name there is the syntax @name or @"name". This will not work in
macros, however. If the object is not found, an error will occur.
 
Function
 sin(a) 
 The functions abs, sign, sin, cos, tan, arcsin, arccos, arctan, sqrt,
exp, log, round, ceil, floor, deg, rad, sinhyp, coshyp, angle180 and angle360. Note
that the trigonometric functions work with degrees. To convert, use
deg(x), or the functions rsin, rcos, rtan, rarcsin, rarccos, rarctan.
 
User __Functions__
 f(a)
 Evaluation of a user defined function object at a. 

__Pi __
 pi 
 The constant Pi. 
 
__x__,__y__,__z__ 
 x(P), y(P) , z(P)
 x- and y-coordinates of a point, or the z-value of the point.
 
__d__
 d(P,Q) 
 Distance of two points. 
 
__d__ 
 d(x) 
 Computes changes of the expression x. If x is a point, it computes
movements.
 
__sum__
 sum(x,f)
 Sums up x. If f is negative or invalid, the sum is reset to 0.
 
__a__
 a(P,Q,Z) 
 Size of angle PQZ. 

__scale__
 scale(x,a,b) 
 The relative position of x in [a,b), if x is in that interval. Else
the expression becomes invalid. 

__if __
 if(e,e1,e2)
 Returns e1, if e is valid, else e2. 

__invalid__
 invalid Returns an invalid expression. 

&&,||,! ! 
 (x<4 && y<4) 
 Logical expressions. 1 is true, 0 is false. 

<, >, <=, >=, ==, ~= 
 x<y 
 Comparing numbers. ~= means "circa equal". 

__integrate__
 integrate(f,a,b)
 integrate(f)
 Integrates the function f from a to b using the Romberg method. f
must be a function object (probably hidden). The y-part of f is
used. If f shows points only, the Riemann sum is computed. If f
is parametric, the area inside the curve is approximated or
its length, if it is not filled.

__zero__
 zero(f,a,b)
 Find a zero of the function f in the interval a,b. The sign of f
in a and b must be different. The procedure uses the secant method
or interval bisection.

__diff__
 diff(f,a)
 Numerically differentiate f at a. This is the usual approximation
(f(h)-f(-h))/(2h)

__min__,__max__
 min(f,a,b)
 Computes the point of the minimum (maximum) of f between a and b.
min(a,b) and max(a,b) compute the minimum or maximum of a and b.

__this__
 x(this)
 Refers to the object containing the expression.
 
__windoww__,__windowh__,__windowcx__,__windowcy__
 Returns the dimensions and center coordinates of the current screen.
 
__pixel__
 Returns the pixel per coordinate unit. Not to be used in print.
 
__simulate__
 simulate(e,x,f)
 Sets the expression e to to the value x, recomputes the construction with
this new value and returns the value of f. Only one simulation can be
computed at any time, so simulations can not be nested. An expression,
a fixed angle or a fixed circle can be used for e.

__inside__
 inside(P,A)
 Tests, if the point P is inside the object A. Returns 1/2, if it is
on the boundary if A. A can be a polygon, a circle or an angle.

.text
.related replay comment properties latex
Text

//image- images/text.png
This displays a multiline __text__ in the construction. The text can
be changed using an internal editor. This editor contains a button to
reach the normal dialog for object __properties__. 

To create a __bold__ or __large__ line, or both, precede the line with
*, **, or ***. To use __LaTeX__ commands, enclose the line or parts of
it in $...$ signs. Moreover, expressions can be used enclosed in %..%.
These expressions will be evaluated, and the text will display the
result. Strings of the form %=s% will return the current name of
object "s", and strings of the form %~s% will return the equation of
s.

__Hiddenßtexts__ appear in replay mode. This allows to show local
comments of constructions steps that disappear later.

.quadric
.related properties point transparent
Conic sections

//image- images/quadric.png
__Conicßsections__ are sets of solutions of equations formed by linear
combinations of x^2, y^2, x, y, xy and 1 (quadratic functions in two
variables). It is well know, that conics are determined by 5 points.
Simply select the 5 points to create a conic section.

To edit the __properties__ of the curve, click on it and use the
normal properties dialog. Conics will display the defining formula as
their value.

It is possible to __bind__ points on conic sections, and to create
__intersections__ of conic sections with other objects.

.hide
.related construction properties mouse
Hiding Objects

//image- images/hide.png
This will __hide__ objects, or make hidden objects __visible__. To
make a hidden object visible, you will of course need to enable the
icon to show all hidden objects. Hiding objects can also be achieved
by holding the __Ctrl-key__ and clicking on the object with the right
mouse button. In this case, circles and lines go to the partial state
first, and hide at the second click.

If the __Shift-key__ is held, when an object is selected for hiding,
the object will be completely hidden. In this case, one can make the
object visible again only by using the __objectßlist__.

With a special menu item it is possible to hide all
__duplicate&objects__. Only the most recent objects will be visible.
Altgernatively, press the __Ctrl-key__ while selecting the hide tool.

.rename
.related properties
Rename alphabetically

//image- images/rename.png
This tool __rename__s lines to a,b,c, points to A,B,C and angles to
\a,\b,\c with mouse clicks using this tool. The first unused letter
will be used.

Force A, B, C by pressing the shift key when you click on a point.
Letters will then be switched, if they were already in the
construction. To start over, press Escape.

By the way, if you need the letter "a" for two different objects, use
"a~1" and "a~2". Names show only up to "~". Alternatively, use an
__alias__.

.delete undo back
.related construction
Deleting Objects

//image- images/back.png
This tool deletes the most recently constructed object, and all hidden
objects before it. Alternatively, use the __backspaceßkey__.

//image- images/delete.png
There is another tool that deletes any object and all objects depending
on it. Of course, doing so may have unwanted side effects, especially,
if objects use complicated dependencies.

//image- images/undo.png
Undo restores all recently deleted objects.

.function
.related expressionsyntax properties
Functions and Curves

//image- images/function.png
The program can display __functions__ and parametric __curves__ in
the construction, or use __user&defined&functions__ of one or more
parameters in other expressions. 

First, we describe the type of functions for display in the
construction window. In the dialog, enter the start and stop
value of the parameter variable and the step size. If you wish, you
can use any string not containing blanks as a parameter name. The
default is "x".

//image images/Function.jpg

For a function, leave the X-value empty or set it to "x", and enter
an expression dependong on "x" for the Y-value. For a parametric
curve, one needs two expressions, one for the X-value and one for the
Y-value.

The program will increment the parameter variable from start to end
using the given step size. If the function is valid between two
parameter steps, a line segment is drawn in the construction
using the construction coordinates.

This type of functions can be used in other functions. The Y-value
will be evaluated then.

Functions and curves can be filled. For a parametric curve, the center is
0, but can be changed. To do that use the __properties__ dialog and
press the "Select Center" button. Functions can be reduced to a
sequence of points. If a function is filled additionally, a Riemann
step function will be drawn.

Display functions or curves can intersect with other objects, and
points can be fixed on the function graph. Geometrically these
functions behave like a curve.

User defined functions of several variables cannot be plotted. Their
purpose is to be used in other expressions. Consequently, there is a
much simpler dialog for these functions, which can be called by
holding the __ctrl-key__ while pressing the function icon. One has to
declare all variables, separated by blanks, in this dialog. The
variables may then be used in the expression. There is only one
expression, of course. The function will display its definition,
unless it is hidden, of course. The display can be moved as usual.

.defaults
.related line angle colors
Default settings

You can set the __defaults__ for color and appearance and some other
properties of new objects.

 - color of objects
 - thickness of objects
 - style of points
 - partial circles
 - partial lines
 - segments as arrows
 - show name
 - show value
 - use long names
 - large and bold font
 - angles larger than 180 degrees
 - non-transparent objects

These default settings are available in the menu and as tool bar
icons.

.edit
.related mouse properties conditions
Edit Objects

//image- images/edit.png
This tool edits the properties of one or more objects. To select
several objects, hold the __Shift-key___. The edit dialog for more
than one objects has fields in an invalid state. Only the changed
fields will be used to update the objects.

If the __Ctrl-key__ is pressed when the tool is selected, the last
object will be edited.

-> See: Conditional formatting

.conditions
.related edit properties
Conditional Formatting

If the __Ctrl-key__ is pressed, when an object is selected with the
right mouse button, an editor for the __conditionalßformating__ of
objects opens. The dialog is also accessible from the normal
__properties__ dialog by holding the __Ctrl-key__ for OK, or with a
separate button, if this option is enabled in the
__specialßsettings__.

//image images/Conditions.jpg

For colors, thickness and other properties, it is possible to define
conditions to activate these properties. This is useful for special
effects. Each property can have a condition and it will be enabled
when this condition evaluates to true, which is any value other then
0.

A special condition is the z-buffer value. It determines the order
of painting. The objects with the largest z-buffer are painted first.
All objects that have a z-buffer value are painted after the background
objects, but before any other objects.

One can set the properties of several objects at once. The current
object can be referred to by the name "this".

.show
.related hide
Hide by Color

//image- images/showcolor.png
Show or hide objects with specific colors. This is used to make the
construction clearer.

.grid
.related zoom move mouse
Grid

//image- images/grid.png
This tool toggles the display of the coordinate system, the coordinate
system with axes, and no coordinate system. There is a dialog to set
the __color__ and __thickness__ of the coordinate system, and the
__font__ of the labels.

If the grid is on, new points and points moved by the right mouse
button __snap__ to grid points. However, it is possible to snap with
the move tool and the __leftßmouseßbutton__ instead, changing an
__specialßsetting__. This may be useful for constructions on Web pages
with grids.

If the grid is on while the construction is saved, it will be switched
on, when the construction is loaded. The grid settings are also saved
in the construction file.

.replay
.related htmlexport text animatebreak
Walk through constructions

//image- images/replay.png
This tool opens a small dialog with navigation buttons containing
buttons for forward, back, fast forward, fast rewind etc. Additionally,
__breakpoints__ can be set with this tool. There is a button to jump
to the next breakpoint. Moreover, breakpoints are important for HTML
export in replay style.

//image images/Replay.jpg

To set a __hidingßbreakpoint__ hold the shift key while setting the
breakpoint. Hiding breakpoints hide all previous objects up to the
next previous breakpoint. The construction will be split into several
parts.

Breakpoints and hiding breakpoints can also be set in the properties
dialog.

During the replay, hidden texts will be visible.

.animatebreak
.related replay
Animate breakpoints

This tool automatically goes from breakpoint to breakpoint. To increase
or decrease the speed, press __Shift-key__ plus the right or left
__arrow&keys__.

.draw
.related mouse
Paint with the Mouse

//image- images/draw.png
This tool paints sketches above the current construction with the
mouse in the current __color__. To erase the sketch, press __Escßkey__
or use the menu entry. The sketch will be saved with the
construction.

.zoom
.related mouse grid
Zoom with the mouse

//image- images/zoom.png
With this tool it is poosible to zoom in and out by dragging in the
outer region of the construction, and to move the construction by
dragging the inner region of the construction.

Note that it is possible to zoom the construction at any time with a
__mouseßwheel__, and to move the construction with the
__rightßmouseßbutton__, dragging some empty spot.

One can also zoom with the __+/-ßkeys__, and move with the
__arrowßkeys__.

The current viewing window is saved in the construction file, and the
same view will be used when the construction is loaded.

.parameter
.related runmacro parametertypes target macro
Macro Parameters

//image- images/macro.png
__Macros__ are an important tool for more complicated constructions.
Without macros, only more or less simple constructions can be done.
Macros collect many constructions steps into one construction step.
They behave like subroutines in a programming language. Macros are
like new, user defined tools.

A macro needs parameter objects and target objects, just like the
segment tool takes two points as __parameters__ and has a segment as
its __target__.

Macros in Z.u.L. are easily defined. Show the macro, which part of
your construction it should learn. This part is called the "pattern
construction". To create the pattern, construct some targets starting
with some given parameter objects. E.g., you could construct the
middle perpendicular line of a segment between two points, starting
with the two points.

//image- images/macro1.png
In the first step of macro creation, the macro needs to learn your
starting points. In the next step, you press the macro tool once more
and define the targets. In the final step, the macro dialog appears
and the macro definition is finished.

Continue with: Targets

.target
.related parameter runmacro parametertypes macro
Targets

//image- images/macro2.png
After the macro parameters have been selected, another click on the
macro tool starts the selection of the __targets__. Here, only those
objects are __visible__ that are constructible from the parameters.
E.g., the middle perpendicular of two points is visible, if the two
points have been selected as parameters. All intermediate construction
steps are visible too unless they are hidden.

Select the targets now. In the example mentÌoned above, select the
middle perpendicular line.

At least one target object should always be defined. Otherwise, all
visible objects will be constructed by the macro. Moreover, targets
will get the default __color__ and styles when the macro is used. All
other objects get the style in the definition pattern, with the
exception that black objects get the default color. Especially, all
__hidden__ objects will be constructed in the hidden state. However,
there is an option to hide all objects that are no targets
automatically, even if they were visible in the construction.
Moreover, if the macro is used in the descriptive mode, the user can
assign names only to target objects.

Another click on the macro tool finished the definition of the macro
using a dialog. 

Continue with: Macro Definition

.macro
.related runmacro parametertypes parameter target expression fixedcircle fixedangle hintparameters selfreference defaultmacros macroerror
Macro Definition

//image images/DefineMacro.jpg

After all __parameters__ and __targets__ have been selected, another
click on the macro tool defines the macro using a dialog. 

Here, the name of the macro and a __comment__ can be set. It is
possible to definie the user __prompts__ for each parameter. Comments
and user prompts are important, since the user might not know, what
the macro does and what it needs. The prompts are displayed in the
status line, while the macro waits for parameters.

It is possible to __fixßaßparameter__ to an object A by using "=A" for
the parameter prompt. The parameter will not be prompted, but instead
an object "A" will be used, if there is one, and if it has the correct
type.

Be default, macros hide all objects that are __duplicates__ from
existing objects. This behaviour can be changed here.

Moreover, it is possible to ask the user for a value for either a
fixed circle, a fixed angle or an expression while the macro is
running (__valueßprompt__). To do this, enter the name of the circle,
the angle or the expression into the box in the last line. The user
will be prompted with a dialog and can enter any arithmetic
expression. Several comma separated objects can be prompted from the
user.

-> See also: Hint Parameters, Self reference

.macrobar
.related macro
The Macro Bar

On request, a line for macro icons can be used. In the program, select
this line with a menu option. Also select, if you want to see the
default icons in that line. In applets, include the parameter
"macrobar" into the "options" parameter.

Macros are only displayed, if the macro name ends with a text in
brackets. The program and the applet will try to load an icon with
that name from a subdirectory named "icons". If no icon is found, the
text will displayed. Icons should be 32x32 in PNG with transparent
background, and the aliasing should be optimized for light gray.

The program archive contains the following useful icons.

//image- icons/1.png
1 - Middle Perpendicular

//image- icons/2.png
2 - Orthogonal Projection

//image- icons/3.png
3 - Inscribed Circle

//image- icons/4.png
4 - Circumcircle

//image- icons/5.png
5 - Reflection at a Line

//image- icons/6.png
6 - Reflection at a Circle

//image- icons/7.png
7 - Reflection at a Point

//image- icons/8.png
8 - Angle Bisector

//image- icons/9.png
9 - Angle Bisector as Ray

//image- icons/10.png
10 - Rotation, given 5 points

//image- icons/11.png
11 - Rotation, given an angle and 2 points

//image- icons/12.png
12 - Translation

//image- icons/13.png
13 - Point

//image- icons/14.png
14 - Angle

//image- icons/15.png
15 - Polygon

//image- icons/16.png
16 - Vector

//image- icons/17.png
17 - Point on a Line

//image- icons/18.png
18 - Arc

//image- icons/19.png
19 - Circle

//image- icons/20.png
20 - Circle, given three points

//image- icons/21.png
21 - Fixed Angle

//image- icons/22.png
22 - Fixed Circle

//image- icons/23.png
23 - Fixed Segment

//image- icons/24.png
24 - Function

//image- icons/25.png
25 - Axes

//image- icons/26.png
26 - Intersection

//image- icons/27.png
27 - Line

//image- icons/28.png
28 - Midpoint, given 2 points

//image- icons/29.png
29 - Parallel

//image- icons/30.png
30 - Conic Section

//image- icons/31.png
31 - Ray

//image- icons/32.png
32 - Line Segment

//image- icons/33.png
33 - Perpendicular

.hintparameters
.related macro
Hint Parameters

A special feature __hide__s parameters. If a hidden point is chosen as
a macro parameter during the generation of the macro, and if that
point is associated to a point generated during the parameter
selection when the macro is used, this new point will be hidden after
the macro has been run. 

This feature makes it possible to use points as __hintßparameters__.
An example would be a macro, which generates an equilateral triangle
on a segment. The hint would be a third click indicating either side
of the segment. In this case, an expression must be used for one of
the 60 degree angles involving the third point, something like
"60*sign(180-a(P,A,B))".

.selectmacro
.related runmacro macro
The Macro Selection Dialog

//image images/MacroSelection.jpg

The macro selection dialog contains a list of all __macros__. Macros
may be organized in __macroßfolders__. To switch to a folder, double
click on it. To revert to the parent directory, double click on "..".
To put the macro into a subfolder, rename it like
"subdir/macroname". __Defaultßmacros__ are displayed in red.

If the dialog allows multiple selections, subdirectories can be selected.
In this case, all macros in all subdirectories of this subdirectory will
be selected at once.

.runmacro
.related parameter parametertypes mouse expressionsyntax fixparameters selectmacro
Running a Macro

//image- images/runmacro.png
If the __Shift-key__ is pressed when the macro run tool is selected,
the previously used macro will be selected automatically. If not,
and there is more than one macro, the macro selection dialog will
open. After the user has chosen a macro, the program will __prompt__
for each parameter, and the expected object type and the prompt will
be displayed in the __statusßline__.

Macros can also be selected with the __rightßmouseßbutton__. Choose
the macro from the list in the popup menu.

If "Space selects ..." appears in the status line, this parameter
object can be selected by pressing the __spaceßkey__. This feature is
useful, if the macro is used several times.

At the end, the macro will be executed. If the macro needs a value for
a fixed circle or angle (__valueßprompt__), it will prompt for this
value with a dialog box. The user can enter any arithmetic expression
here.

If the full __preview__ is turned on, the result of the macro
operation can be seen before the last parameter point is selected.

-> See: Macro Selection Dialog, Macro Definition

.defaultmacros
.related runmacro save
Default Macros

When starting, C.a.R. looks for a file named ".default.mcr" in the
current directory. If there is such a file, the macros contained in
this file are loaded as __defaultßmacros__. Note, that there is a a
default macro file in the program archive, which is used, if the
program does not find another file.

The default macros are protected. They are not deleted when a new
file is loaded and they are not saved with constructions. To delete
protected macros, use the menu entry in the macro menu, and select all
macros. 

You can create default macros yourself. Simply save a file
".default.mcr" into the current directory. If you need a special
language version, save the file as ".la_default.mcr", where "la"
is your language shortcut, of simply overwrite ".default.mcr". the
language shortcut can be found in the "about" dialog (__languages__).

.macroerror
.related macro
Warning: "Object is used, but not in Macro"

This warning occurs if an object in the macro refers to an object not
contained in the macro. Usually, the reason is a __@...__ reference in
an expression, maybe in the conditional formatting of objects. Those
references do not make objects depend on the referred object, and thus
the objects are still constructable. However, they might not work as
expected, or might even refer to wrong objects when used.

Another type of references are the bounds of __arcs__. Since those
bounds depend on the circle most of the time, the circle arc cannot
depend on the bounds to avoid circular dependencies. If you ignore the
warning, the arc will be determined by objects with the same name.

A third reason may be the __intersections__ with circles. To choose the
intersection, the intersection may be kept __awayßfrom__ a given
point. This might happen automatically, if the other intersection
already exists. If you ignore the warning, this intersection will be
kept away from a point with the same name, or will become an
unrestricted intersection.

To avoid the warning, add the missing object to the parameters, so that
it is included in the macro.

.localize
.related defaultmacros
Localized Help

C.a.R. already runs in many __languages__. However, if you want to
provide your own version, you should translate

 - ZirkelProperties.properties
 - info.txt

The __properties__ file needs to be translated into an internal
Unicode representation by a tool named "native2ascii". It is wise to
let me do that for you. Simply send me the file. I will also include
your translation into the current distribution.

The help file should be in your local __encoding__. But is is possible
to specify any encoding in the properties file.

.fixparameters
.related runmacro parameter
Fixed Parameters

You can also fix the selection of macro __parameters__ by pressing the
__Shift-key__ during the selection. This will create a copy of the
macro, which is fixed in these parameters. You cannot fix all
parameters of course.

A parameter can be fixed, while the macro is defined. To do that,
"=A" is used as the prompt of the parameter. The parameter
will then be fixed to the object with name "A".

.parametertypes
.related parameter
Types of Parameters

Macro should use __points__ as __parameters__. This makes dependencies
easier to understand and avoids many problems. But other types of
parameters are possible too.

Lines, rays, segments, and circles generate __secondaryßparameters__,
namely the two end points, or the center respectively. This simplifies
macro usage. However, the user must take care to use these parameters
in the same configuration. Two concentric circles must be concentric.
If the segments AB and BC are macro parameters, then the user must
choose segments EF and FG. In these cases, it might be better to use
points as parameters.

Lines and rays are of two types: with two defining points, and with
one defining point (e.g., parallel lines). In the macro, lines, rays,
and segments are stored as pointless lines, if their defining points
are not used in the target construction, or if they have only one
defining point. The user can then choose any line as a parameter. If
one of the two defining points is used, the user will have to choose a
line, ray or segment of the same type. Again, this is complicated, and
it may be best to use points.

.htmlexport
.related runningdemo save comment exportdialog jobexport
HTML Export

C.a.R. can generate __HTML__ pages for your constructions. These HTML
pages contain an __applet__ that displays the construction. In the
dialog for HTML export the appearance of the page and the applet can
be set.

To set up a HTML page, a construction file has to be created, and,
for assignments with solution pages, another one for the solution.
One needs to publish

 - the HTML page just generated, 
 - a solution page, if present,
 - style sheets, if present, 
 - the applet archive zirkel.jar,
 - the construction file. 

Note that __tracks__ and __animations__ are saved with the
construction. They will automatically reload in constructions, which
are displayed in applets. In this case, there is no user interaction.
So you should use the plain or border style for these applets.

It is best to have only one applet on each HTML page.

-> See also: HTML Export dialg.

.htmlexporttemplate
.related htmlexport save comment settings
HTML Export with Templates

__Templates__ are a comfortable way to export your construction to
__HTML__. The program loads a template for the HTML page, and fills in
the necessary information replacing all placeholders on the template
page. The dialog is much shorter, since most information is
continained in the template file, including __applet__ size, applet
and page colors, style sheets and archive position.

The __documentation__ of C.a.R. contains some templates to start with.
Template files use the extension "*.template". You can edit these
template files with any file or HTML editor. Foreign language users
should disable __UTF-8__ in the settings dialog, or they must use an
editor, capable of handling UTF properly (e.g my text editor JE, the
HTML editors of Mozilla, or Frontpage by MS, and many others). You can
base your template on the template files that come with the
documentation.

The following placeholders are recognized in template files.

#title
  Replaced by the construction title as shown in the export dialog.

#comment1,#comment2,...
  This will be replaced by the section of the construction comment
with the corresponding number. Comment sections are separated by lines
consisting of "~". Each paragraph of the comment section will be
bracketed by <p>...</p>.

#comment
  Works like text, but does not look for comment sections.

#text1,#text2,...
  Works like #comment1,... but does not generate paragraphs
<p>...</p>. The user can provide any HTML-tags he likes.

#text
  Works like #text1,... but does not look for comment sections.

#parameter
  Inserts the applet parameters: file or job, style, tools and options.

#color
  Inserts the applet parameters for colors.

#font
  Inserts the applet parameter for fonts and digits.

#codebase
  The codebase from the export dialog.

Here is a very simple template file.

  <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
  <HTML>
  <HEAD>
  <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8">
  <TITLE>
  #title
  </TITLE>
  </HEAD>
  <BODY BGCOLOR=#F0F0F0>
  <H1>
  #title
  </H1>
  <CENTER>
  <P>
  <APPLET CODE="rene.zirkel.ZirkelApplet.class" #codebase WIDTH="400" 
  HEIGHT="400" ALIGN="CENTER">
  <PARAM NAME="color" VALUE="240,240,240">
  #parameter
  </APPLET>
  </P>
  </CENTER>
  #comment
  </BODY>
  </HTML>

-> See also: Export Dialog

.exportdialog
.related htmlexport jobexport
Export Dialog

//image images/Export.jpg

Applets can have several styles.

- Plain: The __applet__ has no border. The user can only display
hidden elements and move points. One should use the same color for the
page and the applet in this case. 

- Border: The applet gets a border. 

- Border and Icons: The applet gets a border and icons. The user can
construct things. 

- Border, Icons and Status: The applet gets a status line. The status
text is displayed in the browser status line too. 

- Border, Icons and Input Line: The construction must be done in
descriptive (non-visual) mode. 

- Replay with Breakpoints: Three buttons are displayed to enable
navigation from breakpoint to breakpoint. To set the breakpoints, use
the replay tool. 

Title of Page: This is the title of your page in <H1> style.

CSS Style-Files: Cascading Style Sheets are useful to give several
pages a common appearance. If you do not use them, leave the input
empty. Use a path relative to the program archive.

Width, Height: The dimensions of the applet display.

Construction File: The name of the file containing the construction,
usually in the same directory as the HTML file. However, the file
names must be relative to the program archive. Absolute URLs and paths
are not allowed here.

Jar File: This is the program archive. The path must be relative to
the HTML page.

Colors: You can choose a color for the page background and for the
applet background. The color can be chosen with the button below.

Moreover, there are switches to save the defined colors for the
construction elements and for the construction background. The
background of the construction can be different from the background of
the applet and the background of the page.

Save Digits: Will save the settings for the number of digits. Should
be enabled.

Show Comment: This will put the __comment__ below the applet. All
browsers should be able to handle the default __UTF-8__ encoding. If
not switch to the Windows encoding in the special settings.

Tools: These two icon bars let you choose the __tools__, which should
be displayed to the user. In any case, one should provide the undo
tool. With the special icon for two lines the user gets two lines of
tools.

The user can only define macros, if you give him the macro tool. And
he can run only macros only, if this tool is available.

The icons with the question mark are switches for the object selection
dialog, the question for points on objects and for intersections.
By default, all these dialogs and questions are turned off in applets.

In the non-__visualßmode__, the icons help the user to find the
syntax. In this mode, all construction tools work.

.jobexport
.related htmlexport exportdialog
Export Assignments

The export dialog has some additional features for __assignments__.

Display as Assignment: Needs to be checked to save the
construction as an assignment.

Solution File - Jump - Save - Link: These settings allow the automatic
generation of a solution page, which is a separate page to display the
solution. After the user finishes the assignment, the browser can jump
directly to the solution page. One can also set a link to this page
below the construction.

Comment: Exports the assignment comment, of course. The construction
comment is only shown on the solution page.

.runningdemo
.related htmlexport online
Creating a running demo

It is possible to create an __applet__ to load a series of
constructions and display them to the user at a given rate
(__demoßshow__). The applet syntax is quite different and there is no
automatic export.

An example of the applet code looks like this.

 <APPLET ARCHIVE="zirkel.jar" CODE="rene.zirkel.ZirkelApplet.class" 
       WIDTH="500" HEIGHT="565" ALIGN="center">
 <PARAM NAME="demo" VALUE="demo.xml">
 <PARAM NAME="color" VALUE="244,244,242">
 </APPLET>

The file "demo.xml" contains the file list. It is an XML file with a
straightforward syntax. Here is a sample.

 <?xml version="1.0" encoding="utf-8"?>
 <Demo delay="30">
 <File name="Uhr.zir" delay="20">Clockwork</File>
 <File name="Cindarella-Maschine.zir">Cindarella machine</File>
   ...
 </Demo>

The delay parameters are in seconds.

.visual
.related expressionsyntax runmacro
Descriptive Constructions

In this non-__visualßmode__, there is an input line below the
construction. The following differences apply.

 - Choosing a tool will only display an input pattern. 
 - The necessary construction parameters must be supplied by name. 
 - The name of the constructed object may be given left of an equality sign =.
 - The construction is carried out be pressing Return. 

There is a fixed __syntax__ for the input.

 name=function(parameter,...)
 name1,name2=function(parameter,...)

The second line applies to intersection and macros with several
targets.

If the name is missing, the new object will get the default name. 

Here is a short Description of the syntax. Note, that __expressions__
may be used in all places, where a value is expected. Empty brackets
can be omitted.

Syntax 
 Long 
 DEscription 
 
A=P() 
 point 
 Generates a point at random position. 
 
A=P(0,1) 
  A fixed point. 
 
a=s(B,C) 
 segment 
 A segment from B to C. 
 
a=s(B,2) 
  A segment of fixed length. 
 
a=g(B,C) 
 line 
 A line through B and C. 
 
a=r(B,C) 
 ray 
 A ray from B to C. 
 
k=k(A,B) 
 circle 
 A circle around A trough B. 
 
k=k(A,2) 
  A circle with fixed radius. 
 
k=k(A,B,C) 
  A circle around A with radius BC. 
 
A=S(g,g) 
 intersection 
 An intersection between two lines. 
 
A,B=S(k,k) 
 Both intersections between circles, or circles and lines. 
 
away(A,P) 
 away 
 Keeps the intersection A away from the point P. 
 
M=M(A,B) 
 middle 
 The midpoint of AB. 
 
g=pl(g,A) 
 parallel 
 The parallel through A to g. 
 
g=p(g,A) 
 plumb 
 The perpendicular through A to g. 
 
a=w(A,B,C) 
 angle 
 The angle A,B,C 
 
a=w(A,B,90) 
  An angle of fixed size. 
 
A=area(P1,P2,P3) 
 area 
 Creates an area with these corners. 

Q=quadric(P1,P2,P3,P4,P5)
 Creates a conic section through these points.

F=function(a,b,d,t,xt,yt)
 Creates a function on [a,b] with step size d, plotting xt,yt,
 which are expressions depending on the variable t.

value(P,0,1) 
 value 
 Fixes the coordinates of the point 
 
value(s,2) 
  Fixes the length of the segment. 
 
value(k,2) 
  Fixes the radius of a circle. 
 
value(w,90) 
  Fixes the size of an angle. 
 
value(true,o) 
  Sets the display of the value for o. 
 
value(o) 
  Sets the display of the value for o to on. 
 
value(true) 
  Sets the default display of values. 
 
name(o,p) 
 name 
 Sets the name of o to p. 
 
name(true,o) 
  Sets the display of the name for o. 
 
name(o) 
  Sets the display of the name for o to on. 
 
name(true) 
  Sets the default display of names. 
 
hide(true,o) 
 hide 
 Hides or un-hides o. 
 
hide(o) 
  Hides o. 
 
hide(true) 
  Sets the default hidden state for objects. 
 
col(green,o) 
 color 
 Sets the color of o to red, green, blue or brown. 
 
col(green) 
  Sets the default color. 
 
th(thick,o) 
 thickness 
 Sets the thickness of o to thick, normal or thin. 
 
th(thick) 
  Sets the default thickness 
 
type(square,P) 
 type 
 Sets the point type to square, circle, diamond or point. 
 
type(square) 
  Sets the default point type. 
 
part(k) 
part(true,k) 
 partial 
 Sets the object k to partial display or full display. 
 
part(true) 
  Sets the default partial state. 
 
fill(o) 
fill(true,o) 
 fill 
 Sets the object o to filled state or outline state. 
 
back(o) 
back(true,o) 
 background 
 Sets the object o to the background or not. 
 
window(0,0,5) 
 window 
 Sets the view window to width 2*5 and center (0,0). 

valid(o)
valid(true,o)
 Treat segments and rays as lines in intersections and in
 perpendicular lines. o is the intersection or the perpendicular.

obtuse(a)
obtuse(true,a)
 Set angles so that they can become greater then 180 degrees.

solid(a)
solid(true,a)
 Set the object to the nontransparent state.

restrict(c,A,B)
 Restrict a circle to become an arc from A to B.

valid(o)
valid(true,o)
 Remove the restrictions from perpendicular lines and intersection.
 These objects will be valid, even if the intersection is outside a
 segment or an arc.

rename(A,B)
 Rename the object A to B.
 
__Macros__ can be used too. Names left of = will be assigned to
targets. If there are several targets, the names must be separated by
commas. One additional parameter may be used to assign a value for an
object, which would be prompted in interactive mode.

.descritivefiles run
.related visual save
Descriptive constructions in files

__Descriptiveßconstructions__ can be loaded from a file. Alternatively
edit the description and then load the construction. 

The syntax is line oriented and uses the commands described above.
Line comments //... may be used. The files may contain __macros__ in
the following format.

 macro U 
 // Constructs a circle through three points
    parameter A=point // Select first point
    parameter B=point // Select second Point
    parameter C=point // Select third point
    g1=MS(A,B)
    g2=MS(A,C)
    U=intersection(g1,g2)
    target k=circle(U,A)
 end

The indents are optional. __Comments__ in the parameter lines are used
as prompts, if the macro is used interactively. This macro calls the
macro MS with two parameters.

 macro MS
  param A=point
  param B=point
  partial(true)
  k1=circle(A,B)
  k2=circle(B,A)
  partial(false)
  P1,P2=intersection(k1,k2)
  target g=line(P1,P2)
 end

If the command constructing the target constructs two objects, the
target can be defined separately.

 A,B=intersection(g,k)
 target B

If a macro has more than one target, all targets must be assigned.

 A,B=test(...)

Prompts are defined by the keyword prompt in front of an object name.

 k=circle(A,5)
 prompt k

Here is an example of a macro using a segment as a parameter.

 macro MS
 // Mittelsenkrechte
  A=point
  B=point
    parameter s=segment(A,B)
    ...
 end

If circles are used as a parameter, there is the special syntax

 M=point
 parameter circle(M)

This kind of circle can only be used in parameters.

The special command "showall" shows all intermediate objects.
Otherwise, only targets will be visible. The command "invisible"
superhides all objects that are no targets.

.assignments
.related save restricted colors comment
Assignments

Assignments (or jobs) are incompletely displayed constructions, which
the user is supposed to finish. The computer will only check for the
constructed target object, and the solution itself might be different
than the give one. The user will receive a message, as soon as he has
completed the construction. The target objects will be displayed in a
light color, unless they are hidden before the construction is saved.

Assignments are generated by choosing the last object to be displayed
to the user. Furthermore, there must be target objects. Targets are
not checked for the solution, if they are generated pressing the shift
key.

To test the assignment, click on the menu entry for this. In contrast
to the user, you will have the complete set of tools available,
however. You can use the restricted icon bar to save the assignment.

Area objects as targets should be defined by the least set of corner
points. If the solving user creates additional points on the sides of
the polygons those points will be skipped.

.browser
.related online
Starting the help browser

To start the __HTML__ help in the __browser__, you need to configure
it. Enter the command line to the browser in the dialog. If the path
contains blanks, include the browser in double quotes.

Moreover, add the path to the help index.html file. This should be
preconfigured already. If no help is found, the configuration dialog
will use the web page.

The default browser is the Explorer on Windows systems, and Netscape
elsewhere.

.comment
.related assignments parameter htmlexport
Comments

//image- images/comment.png
Every construction can have a comment. __Comments__ will be displayed
when the user loads the construction. Moreover, comments can be
exported to __HTML__.

Assignments may have a special comment, displayed to the user, when
the assignment is presented. This comment should explain what to do in
the assignment.

__Macros__ should have a comment too, explaining their usage
and purpose. The macro comment is displayed in the macro selection
dialog.

.fonts
.related zoom save sizes
Fonts

__Fonts__ can either be set globally or for each object. Global
settings take precedence. Fonts are scaled with the screen height.
However, there is a minimum for this scaling.

C.a.R. uses fonts in two sizes and strokes. Fonts and points are
scaled with the construction, however. For small windows or applets,
this would lead to very small fonts and points. Thus there is a
minimal point size. Bold fonts are recommended for small screen sizes
and high resolutions.

Note, that fonts for the __graphicsßexport__ can be scaled to an exact
size. The screen preview for the graphics export scales the fonts to
get the same visual appearance of the construction. This overrides the
global setting for the font size and the minimal font size.

.sizes
.related fonts
Sizes

In this dialog, one can set the minimal line, point and font sizes.
To keep the same look on all screen sizes, these items are
scaled with the screen height. But one can set __minimalßsizes__ here.

Moreover, one can set the arrow size, and the selection size for
cursor selection of objects.

Note that for graphics exports, one may set the these values exactly,
independent of the size of the output. This overrides any other
settings.

The minimal sizes can be exported to __applets__.

.save
.related assignments parameter visual print defaultmacros filedialog
Saving and loading files

Constructions are saved in __XML__-format to computer files. This
format is human readable. Normal constructions have the extension
".zir", and assignments have the extension ".job". Macros use ".mcr".

Constructions may contain __macros__. There is a switch, if the
currently defined macros (besides the __defaultßmacros__) should be
saved along with the constructions or not. To avoid accumulating
macros from several constructions, it might be a good idea to delete
all macros before a new construction is loaded. There is a switch to
do this by default.

Files can be __compressed__ by adding "z" to their extension. There is
no need to do this, unless you want to minimize download time, when
the file comes from a server.

There are special menu items to load __assignments__, to load
__macros__, and to load __descriptiveßconstructions__ in files.

-> See: File Dialog

.filedialog
.related save settings
The File Dialog

C.a.R. implements an own __fileßdialog__, since the file dialogs of
Windows and Linux have some defects when used from Java. If you want
to use the normal system file dialog, however, you can switch to it in
the __specialßsettings__.

//image images/FileDialog.jpg

The file dialog of C.a.R. uses a __history__ for files, directories
and filters. The directory and file history has a special drop down
choice menu, and the history of the file and pattern fields show when
the cursor up or down __arrowßkeys__ are pressed in these fields.

Navigate in the directories with a __doubleßclick__ on the directory
name in the left panel. The "Back" button opens previous directories.
To choose a file, you can double click on its name in the right panel,
or select it and use the action button.

It is possible to enter several __fileßpatterns__ separated by spaces.
File patterns can contain one or more place holders, "?" for single
letters and "*" for strings.

A new directory can be created. Enter the name of the directory into
the directory field, then press the button. Files or directories
cannot be deleted in this dialog.

The home button brings you to the __homeßdirectory__ of C.a.R., if
installed in the home directory of the user. The English name is "CaR
Files". If there is no such directory, the button brings you to the
user home directory. In Windows, the English name is "My Documents".
In __Linux__, the home button brings you into your home directory. It
is possible to change the home directory by pressing the home button
with the __shift-Ctrl-key__. The current directory will become the new
home directory for C.a.R. Another click with these keys restores the
old settings.

.print
.related exportsettings print
Print and Export Constructions

There are several ways to __exportßconstructions__ to other
programs or view them externally. 

First of all, you can __print__ your constructions. There is an option
to print in __exactßscaling__, so that units of 1 are 1 cm exactly.
Make sure, the construction window fits on the paper for this option.

Moreover, you can export in various graphics and vector formats
(__graphicsßexport__). For word processors, I recommend using __PNG__,
properly scaled for the exact output width. There is not much sense in
using PDF or PS for print, since the line widths, the fonts and the
point sizes have to be scaled for the exact output size.

For PNG output, a dialog will open, where the output size is set.
Alternatively, use a factor relative to the screen size. It is also
possible to determine the size using the graphics width and height in
cm and the resolution in __dpi__. There is a drop down selection box
for various formats. If "1:1 scaled" is used, a scaled version (1 unit
= 1 cm) with a 300 dpi resolution is used. Make sure, the output fits
on your paper.

Since lines, fonts and points may become too small in small pictures,
it is possible to __scale__ these sizes in cm. Use the __preview__ to
see the effect on the screen.

For use with the typesetting program __LaTeX__, C.a.R. can generate
two accompanying files, the bounding box file, and a file to draw the
image. The latter has the same name as the PNG file, but an extension
"ztx" (zirkel tex). It is possible to let LaTeX do the drawing of the
strings and equations in the construction. In the dialog, select the
type of strings that should be done by LaTeX. The graphics export will
generate the necessary LaTeX commands. This type of LaTeX export will
work with pdflatex and latex. In the LaTeX source, it is necessary to
import the "__graphicx__" package, and to load the image file with an
input command, like in

 \begin{figure}
 \centering
 \input{image.ztx}
 \end{figure}

C.a.R. can also copy graphics to the __clipboard__. The same scaling
will apply as in the PNG output. If a screen dump of the construction
is needed, use "screen size" in the scaling dialog.

For __PDF__ output, only set the picture sizes in cm. PDF can also
scale lines, fonts and points. Of course, you will then have to set
the intended print width of the PDF output.

.construction
.related hide reorder
List of objects

//image images/Gui.jpg

C.a.R can display an __objectßlist__ of your construction with the
corresponding menu entry. By default, the list is turned on. This list
can be used to edit invisible objects. In fact, it is the only way to
access completely hidden construction steps. The lines in the list
have the same colors as the objects. Completely hidden objects are in
brackets.

Press the question mark or the right mouse button to access the popup
menu with more options.

To select objects click on them. To select or deselect more objects
click with the __Ctrl-key__. To select a range of objects use the
__Shift-key__.

It is possible to restrict the display to certain types of objects
with the drop down menu in the line above the object list. 

The view is either sorted in the order the objects were constructed,
or in the order the objects are stored. Note that the program may
change the order of the objects to make sure no object refers to
another object, which is defined later.

Objects can display the description, the value or the formula besides
the name of the object. Moreover, there are special display styles for
hidden objects, completely hidden objects, invalid objects and basic
(__moveable__) objects.

The object list can be copied to the __clipboard__.

.colors
.related htmlexport
Set colors

Set the various colors of C.a.R. to your liking. Colors will not be
saved with your construction, but are exported to HTML.

Colors are composed in the red, green and blue color model. Switch
back to default colors for best compatibility.

.settings
.related restricted iconbar tips beginner
Special Settings

This dialog contains some __specialßsettings__ for advanced users.
Some of these settings are affected by the beginner mode, however.

First of all, there is a switch for the display of object labels while
the object is moved. This option may be disturbing, but it is quite
useful in some cases. C.a.R. can restrict that to fixed objects only.

Then, there are switchs for some questions the program asks before
critical actions.

If the dialog to choose objects is disabled, the program will always
select the first object, even if the selection cannot be determined
uniquely from the mouse position.

It is also possible to turn off the construction preview, or restrict
it to points. By default, most tools show a preview of the result
before the last parameter point is selected. In the beginner mode, only
points are shown in preview, since other objects tend to mislead the
users.

The icon bar can be placed to the lower edge of the window, and
tooltips can be disabled.

Some users want to use the system __fileßdialog__. I prefer mine, and
it does indeed have some advantages. However, it cannot delete or
rename files. It can create directories, however.

One should use __UTF-8__ encoding all the time, but C.a.R can also
choose to use the local encoding for construction files. This affects
comments and descriptions in the files. Use the local setting only, if
you want to edit the construction yourself, and if you do not have a
UTF-8 editor.

In the __smartboard__ mode, dragging will behave differently. A
smartboard cannot report mouse movements, so they are replaced by
drags. You have to click once more to complete the construction. This
is only important for the preview of construction steps.

By default, the program writes __backups__ of the files before
overwriting. If you find you do not need these, disable the backup
feature.

The user can choose to call the macro popup dialog with a single
or a __doubleßclick__ of the right mouse button.

On a slow system, one may want to disable the smooth graphics with
__anti-aliasing__.

.exportsettings
.related settings print
Settings for Graphics Export

Normally, points and fonts are scaled. But the minimal sizes are 
respected, if this is enabled, since fonts would become to small
otherwise. To get large fonts in small prints, use the scaling feature
in the __graphicsßexport__.

Bitmaps are normally generated on a white __background__. You can tell
the program to use your background color.

.reorder
.related circle angle expressionsyntax
Reorder points

It is possible to change the __order__ of the construction manually.
There is a special tool for this, and if you select an object with
this tool, the program will try to move this object as far to the
start of the construction as possible. This may be useful to control
the sequence the objects are drawn.

However, reordering is obsolete now. C.a.R. reorders the cosntruction
chain itself, if objects refer to later objects. Moreover, it is
possible to control the sequence of drawing using
__conditionalßformatting__.

.tips
.related online browser start move intersection expression reorder
Tips

In this help section, we give some tips to solve common problems.

Invalid Constructions. To test a construction, move one of the basic
points. If the construction does not remain valid, the most common
reason is that you did not choose an intersection properly. Instead,
you may have defined a line that goes through the intersection point
only by chance.

Wrong Intersection. If a construction becomes invalid, whenever the
order of the basic points is changed or if one point is flipped to
another side, you are facing the problem to choose the right
intersection point. So, if you want your construction to be valid for
all situations, make sure, you choose all intersections properly. If
the automatic selection of C.a.R. fails, you can select the
intersection by hand. Open its properties and press "Close to" or
"Away from". Then choose a point that should be nearer to or further
away from the intersection point. You can also set intersection close
to itself. In this case, the intersection will behave continously.

.keyboard
.related gui delete zoom mouse iconbar
Using the Keyboard

Most commands in C.a.R. have __keyboardßshortcuts__. Have a look into
the menu to find the shortcut for each command. Shortcuts depend on
the language.

Note, that you need to give your construction the keyboard focus if
it looses the focus. Click on an empty spot with the right mouse
button.

Useful shortcuts are the __backspaceßkey__ to delete the last action,
the __+/-__ key to zoom in and out, and the arrow keys to move the
construction. Moreover, __F1__ will open the context sensitive help.

The important __Escßkey__ resets the current tool.

Note that the __Ctrl-key__  and the __Shift-key__ change the behavior
of some tools.

The __Spaceßkey__ is used by Java and Windows versions to press
buttons. Some systems use the __Returnßkey__ instead.

.image
.related background
Images

__Images__ can be added to the construction as objects. Images use
either two __anchorßpoint__s or three. In the first case, the image is
rotated and scaled, in the second case, an affine transformation is
used. If you want only two points, double click the second point.

These images must be in the same directory as the construction.

-> See also: Background Images

.language
Set Language

By default, C.a.R. starts with the language of the system it is running
on. It can be commanded to start in any other of the implemented
__languages__. Use the following shortcuts for the current languages:

 English - en
 German - de
 French - fr
 Netherlands - nl
 Italian - it
 Spanish - es
 Portuguese - pt
 Brazilian - br
 Slovenian - sl
 Danish - da
 Norway - no
 Poland - pl
 Russian - ru
 Korean - co

Either use the menu item to set the language or set the command line parameter
like "-l de" for the German language.

.selfreference
.related macro point
Self Reference

A point may contain references to itself to fix its coordinates, or to
set the appearance in the __conditionalßformatting__. If a point
refers to itself only (__@-references__ do not count), it is called a
__selfßreferring__ object. It will then be moveable by the user.
First, the rest of construction will be updated, then the point.

This feature allows to give the point to a special behavior, when it
is moved. E.g., one could restrict the movements of the point this
way. Note, that this is only necessary in very special situations,
since points can __bind__ to the inside of angles, polygons and
circles, and of course to the boundary of many other objects.
Moreover, there is a __grid__ setting for points, which keeps it on an
integer grid. All these points are moveable, but fixed points.

Such moveable fixed points can also be created by __macros__. The
point must be a macro parameter, and this parameter must be selected
with the shift key, when the macro is created. When the macro runs,
the points chosen for the parameter gets the coordinate fixes.
