<?xml version="1.0" ?>
<!DOCTYPE book PUBLIC "-//KDE//DTD DocBook XML V4.5-Based Variant V1.1//EN" "dtd/kdedbx45.dtd" [
<!ENTITY kseg "<application>KSeg</application>">
<!ENTITY cabri "<application>Cabri</application>">
<!ENTITY drgeo "<application>Dr.Geo</application>">
<!ENTITY % addindex "IGNORE">
<!ENTITY % English "INCLUDE">
<!-- change language only here -->
]
>

<book id="kig" lang="&language;">

<bookinfo>
<title>The &kig; Handbook</title>

<authorgroup>
<author>
<firstname>Dominique</firstname> <surname>Devriese</surname>
<affiliation>
<address><email>devriese@kde.org</email></address>
</affiliation>
</author>
<!-- TRANS:ROLES_OF_TRANSLATORS -->
</authorgroup>


<copyright>
<year>2002</year><year>2003</year><year>2004</year> <holder>Dominique
Devriese</holder>
</copyright>

<legalnotice>&FDLNotice;</legalnotice>

<date>2020-12-23</date>
<releaseinfo>Applications 20.12</releaseinfo>

<abstract>
<para>
&kig; is an application for Interactive Geometry by &kde;.
</para>
</abstract>

<keywordset>
<keyword>KDE</keyword>
<keyword>KDE-Edu</keyword>
<keyword>Kig</keyword>
<keyword>Interactive Geometry</keyword>
<keyword>KGeo</keyword>
<keyword>Cabri</keyword>
<keyword>Dr.Geo</keyword>
<keyword>KSeg</keyword>
</keywordset>
</bookinfo>


<chapter id="introduction">
<title>Introduction</title>

<para>
&kig; is an application for Interactive Geometry. It's intended
to serve two purposes:
</para>

<itemizedlist>
<listitem><para> Allow students to interactively explore
mathematical figures and concepts using the computer.
</para></listitem>

<listitem><para> Serve as a <acronym>WYSIWYG</acronym> tool for
drawing mathematical figures and including them in other
documents.</para></listitem>
</itemizedlist>

<para>
You can report problems in &kig; using the internal bug
reporting tool
(<menuchoice><guimenu>Help</guimenu><guimenuitem>Report
Bug...</guimenuitem></menuchoice>).
</para>

<para>
Since &kig; supports macros and the construction of loci, it allows for
some
rather advanced macros to be defined. If you have created an
interesting macro, which you think might be useful for other
people, please open a review request for the change, so that
it can be evaluated for the inclusion in the distribution
(if you do this, it will be licensed under the
terms of &kig;'s license, the <ulink
url="https://www.gnu.org/licenses/licenses.html#GPL">GPL</ulink>,
so that other people can freely use and adapt it).
</para>
</chapter>


<chapter id="using-kig-basic">
<title>Basic usage</title>
<sect1 id="constructing-objects">
<title>Constructing Objects</title>
<sect2 id="constructing-points">
<title>Constructing points</title>
<para>
You can construct points in several ways:</para>
<itemizedlist>
<listitem>
<para>
Select <menuchoice><guimenu>Objects</guimenu>
<guisubmenu>Points</guisubmenu>
<guimenuitem>Point</guimenuitem></menuchoice> from the
menubar or
press the appropriate button in the toolbar. You can
then construct a point by clicking at the desired
position in the window.</para>

<note><para>Press the &Shift; key to activate a snap raster mode
which allows you to set any point in a construction exactly to points
of the grid.</para></note>
<note><para>Actually, this
works the same way for constructing other objects as
well: click on the desired menubar entry or toolbar
button and select the necessary items to construct
the object.</para></note>
</listitem>

<listitem>
<para>
Since you often need to construct points, simply
clicking somewhere in the screen with the &MMB; will
construct a point for you, without going to a menu or
button.
</para>
</listitem>
<listitem>
<para>
You can construct points while you are building other
objects in the background, optionally selecting them
for the object you are building. For more on this,
see <xref linkend="constructing-other-objects" />.
</para>
</listitem>
</itemizedlist>

<screenshot>
<screeninfo>A point has been constructed</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="constructed_a_point.png"
format="PNG"/>
</imageobject>
<textobject>
<phrase>A point has been constructed</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect2>

<sect2 id="constructing-other-objects">
<title>Constructing Other Objects</title>
<para>
Constructing objects other than points is usually done by
selecting the appropriate entry in the
<guimenu>Objects</guimenu> menu, or by clicking on one of
the toolbar buttons.
</para>
<screenshot>
<screeninfo>Constructing a circle</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="constructing_a_circle.png"
format="PNG"/>
</imageobject>
<textobject>
<phrase>Constructing a circle</phrase>
</textobject>
</mediaobject>
</screenshot>
<para>
This will start the construction of the chosen object type.
All of these types require arguments. For example, if you
selected to construct a circle by center and point, you will need to
give two points: one for the center, and one for the point on
the circle.
</para>
<para>
These arguments are objects too, which can also be selected, simply by
clicking on them. When you move the cursor over an argument you want to use to
construct an object, a preliminary image will be shown of the object, so you will
know what it will look like. For objects that require points as arguments, you
can place a new point at the
current cursor position and select it by clicking the &LMB;.
</para>
<para>
You can always cancel the construction of the new object by
pressing the &Esc; button or by clicking on the &nbsp;<inlinemediaobject>
<imageobject> <imagedata fileref="process-stop.png" format="PNG"/> </imageobject>
</inlinemediaobject> <guibutton>Cancel Construction</guibutton> button on the toolbar.
</para>
<screenshot>
<screeninfo>Constructing a circle.</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="constructing_a_circle_2.png"
format="PNG"/>
</imageobject>
<textobject>
<phrase>Constructing a circle</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect2>
</sect1>

<sect1 id="selecting-objects">
<title>Selecting Objects</title>
<para>
Selecting objects can be done in two ways:
</para>
<itemizedlist>
<listitem>
<para>
Simply clicking on an object causes that object to be selected, clearing the
current selection. If you
want to select multiple objects simultaneously, hold down the &Ctrl; key while
clicking on an object.
</para>
</listitem>
<listitem>
<para>
By clicking and dragging on an empty spot on the screen,
you can select all objects within the rectangle that is
created. This action will clear the current selection. As
in the previous case, holding down the &Ctrl; key allows you
to keep the current selection.
</para>
</listitem>
</itemizedlist>
<para>
When you have more than one object under the mouse (indicated by <guilabel>Which object?</guilabel>
in the statusbar and at the mouse cursor), you can easily
choose which object select or add to the current selection. Click
with the &LMB;, while holding the &Shift; key or click the &RMB;, to have a popup with
all the objects under the mouse. Then, you can select the object
you need. As said before, the behaviour of the &Ctrl; key will
affect the selection.
</para>
<screenshot>
<screeninfo>Selecting objects</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="selecting_objects.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>Selecting objects</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect1>

<sect1 id="moving-objects">
<title>Moving Objects</title>
<para>
To move objects, you must first <link
linkend="selecting-objects">select</link> them.
</para>
<para>
When the objects you want to move are selected, you can start
moving them by &LMB; clicking and dragging any one of them. When you are done,
simply release the &LMB;.
</para>
<note><para>For some types of objects (especially when defined by
complicated loci), moving them can be slow on old hardware. This
is unfortunate, but inevitable, given the calculations involved.
</para></note> <note><para>If you &RMB; click one of the selected objects, and
choose
<guimenuitem>Move</guimenuitem>, moving the mouse will move the object. When the
object is moved to the desired position, another &LMB; click will stop the
moving of the object.</para></note>
</sect1>
<sect1 id="deleting-objects">
<title>Deleting objects</title>
<para>
Deleting objects is done by first <link
linkend="selecting-objects">selecting</link> them, and next doing either of
these:
<itemizedlist>
<listitem>
<para>
Press the &Del; key.
</para>
</listitem>
<listitem>
<para>
Press the &nbsp;<inlinemediaobject> <imageobject> <imagedata fileref="edit-delete.png" format="PNG"/>
</imageobject> </inlinemediaobject> <guibutton>Delete Objects</guibutton> button on the toolbar.
</para>
</listitem>
<listitem>
<para>
<mousebutton>Right</mousebutton>-click on one of the
objects, and select
<guimenuitem>Delete</guimenuitem>
in the <link linkend="objects-context-menus">context
menu</link> that appears.
</para>
</listitem>
</itemizedlist>
</para>
</sect1>

<sect1 id="showing-hiding-objects">
<title>Showing and hiding objects</title>
<para>
In &kig;, objects can be hidden. This is done by selecting
the objects, &RMB; clicking one of
them, and selecting
<guimenuitem>Hide</guimenuitem> in
the <link linkend="objects-context-menus">context menu</link>
that appears.
</para>
<para>
To unhide the objects, use the
<menuchoice><guimenu>Edit</guimenu><guimenuitem>Unhide
All</guimenuitem></menuchoice>. This will unhide all
currently hidden objects.
</para>

<sect2 id="night-vision">
<title>Night Vision</title>
<para>
Night Vision is a particular way of working with hidden
objects. When you have to move or change something in one or
more object but without unhiding all the hidden objects you
have, then the night vision mode will be of benefit to you.
</para>
<para>
Basically, it allows you to see the hidden objects as if they
were visible, so that you can manipulate them as you would normally.
In Night Vision mode, the hidden objects will be visible with
a grey colour.
</para>
<para>
To toggle the night vision mode, use
<menuchoice><guimenu>Settings</guimenu><guimenuitem>Wear
Infrared Glasses</guimenuitem></menuchoice>.
</para>
</sect2>
</sect1>

<sect1 id="undo-redo">
<title>Undo/Redo</title>
<para>
In &kig;, you can undo almost any change you make in the
document. Just use the
<guiicon>Undo</guiicon>/<guiicon>Redo</guiicon> buttons on the
toolbar, the <guimenu>Edit</guimenu> menu or the appropriate keyboard shortcuts.
</para>
</sect1>

<sect1 id="full-screen-mode">
<title>Full Screen Mode</title>
<para>
&kig; also has a Full Screen mode. To use it, click the
appropriate button on the toolbar, or select
<menuchoice><guimenu>Settings</guimenu><guimenuitem>Full
Screen Mode</guimenuitem></menuchoice>.
</para>
<para>
To leave Full Screen mode,
&RMB; click the screen at a place
where there is no object present, and select
<guimenuitem>Exit Full Screen Mode</guimenuitem>, or press the shortcut
<keycombo action="simul">&Ctrl;&Shift;<keycap>F</keycap></keycombo>.
</para>
</sect1>
</chapter>


<chapter id="kig-object-types">
<title>&kig; Object Types</title>
<para>
&kig; supports a rather large number of object types. Please
note that not all of the available object types are shown in the
toolbars: there are some objects that you can only
construct via the <guimenu>Objects</guimenu> menu in the menu
bar. Of course, as with all &kde; applications, the contents of the toolbars are
configurable. Try out the
<menuchoice><guimenu>Settings</guimenu><guimenuitem>Configure
Toolbars...</guimenuitem></menuchoice> option if you want to do this.
</para>
</chapter>


<chapter id="using-advanced">
<title>Advanced Usage</title>
<sect1 id="objects-context-menus">
<title>Context Menus</title>
<para>
&kig; has context menus for its objects. Try
&RMB; clicking on an object in order to see
a context menu appear. There are many options: for
constructing other objects, setting colours, pen width, style, and even hiding,
moving or deleting objects. Some objects have options of
their own (&eg; you can redefine certain points to be
constrained to a line if they previously weren't, &etc;).
These options should be very straightforward to understand.
</para>

<para>Some of the actions in the context menu of an object need another 
defined object as reference, for example:</para>

<variablelist>
<varlistentry>
<term>Rotate a shape a specific number of degrees around a point</term>
<listitem>
<orderedlist>
<listitem><para>Click on <menuchoice><guimenu>Objects</guimenu>
<guisubmenu>Angles</guisubmenu><guimenuitem>Angle by Three Points</guimenuitem> 
</menuchoice> and make your desired angle of rotation somewhere in the &kig; window, generally in 
an unobtrusive place. If desired, right click on the angle and click on 
<menuchoice><guisubmenu>Add Text Label</guisubmenu><guimenuitem>Angle in Degrees</guimenuitem></menuchoice>.</para></listitem>
<listitem><para>Click with the &RMB; on the angle and select <guimenuitem>Set 
Size</guimenuitem> and insert the new size for this angle in the dialog.
</para></listitem>
<listitem><para>Click on <guimenu>Objects</guimenu> menu and construct your desired object.
</para></listitem>
<listitem><para>Right click on your shape, and select on <menuchoice><guisubmenu>Transform</guisubmenu>
<guimenuitem>Rotate</guimenuitem></menuchoice>.</para></listitem>
<listitem><para>Set your desired point of rotation.</para></listitem>
<listitem><para>Click on your angle.</para></listitem>
<listitem><para>Your shape is rotated!</para></listitem>
</orderedlist>
<!--this does not work in 4.3/4.4/4.5 and trunk, so comment out for now
<note>
<para>Constructing your angle with an opening to the right allows for clockwise
shape rotation. Constructing your angle with an opening to the left <emphasis>and</emphasis>
adding the text label will allow both clockwise and counter-clockwise
rotations.</para></note>
<para>
Clicking on the arrow created by the angle makes a counter-clockwise
rotation. Clicking on the text label of the angle makes a clockwise
rotation.</para>
-->
</listitem>
</varlistentry>

<varlistentry>
<term>Translate an object</term>
<listitem>
<orderedlist>
<listitem><para>Click on <menuchoice><guimenu>Objects</guimenu>
<guisubmenu>Vectors &amp; Segments</guisubmenu><guimenuitem>Vector</guimenuitem> 
</menuchoice> and construct the object by selecting the start and end point somewhere
in the &kig; window.</para></listitem>
<listitem><para>To adjust length and direction of the vector you have to edit its start
and end point. Select them and choose <guimenuitem>Set Coordinate...</guimenuitem> in the context menu.
</para></listitem>
<listitem><para>Click on <guimenu>Objects</guimenu> and construct your desired object.
</para></listitem>
<listitem><para>Right click on your object, and select on <menuchoice><guisubmenu>Transform</guisubmenu>
<guimenuitem>Translate</guimenuitem></menuchoice>.</para></listitem>
<listitem><para>Select the vector to translate by.</para></listitem>
</orderedlist>
</listitem>
</varlistentry>
</variablelist>
</sect1>

<sect1 id="document-context-menus">
<title>Document context menus</title>
<para>
<mousebutton>Right</mousebutton>-clicking on the document (&ie; not on an
object) will
present a popup that you can use to start constructing a new object, change the
coordinate system used, show hidden
objects, zoom in and zoom out of the document and switch to the full screen mode.
</para>
</sect1>

<sect1 id="defining-macros">
<title>Defining Macros</title>
<para>
One of the more advanced features in &kig; is its support for
macros. This allows you to define new types of objects from
other ones which are defined already.
</para>
<para>
For example: Suppose you want to make a macro for constructing
a circle from three points on it. You would input three points,
then construct some perpendiculars and midpoints
until you find the center. Now you can use the existing
<guimenuitem>Circle by Center &amp; Point</guimenuitem> command
(using one of the three points as the point for this command). The
following image should make this a bit more clear:
</para>
<screenshot>
<screeninfo>Test running macros</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="test_run_macro.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>Test running macros</phrase>
</textobject>
</mediaobject>
</screenshot>

<para>
Next comes defining the macro. Select the <menuchoice><guimenu>Types</guimenu>
<guimenuitem>New Macro...</guimenuitem></menuchoice> menu item, or
click on the &nbsp;<inlinemediaobject> <imageobject> <imagedata fileref="system-run.png"
format="PNG"/></imageobject> </inlinemediaobject> <guibutton>New Macro...</guibutton>
button on the toolbar. A wizard will appear and ask you to select the given objects.
In our example, these are the three points. Select the three points (click on
them to select, click again to unselect) and click the
<guibutton>Next</guibutton> button to continue. Finally,
select the last objects (only the circle in our example).
</para>

<screenshot>
<screeninfo>The macro wizard</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="macro_wizard.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>The macro wizard</phrase>
</textobject>
</mediaobject>
</screenshot>

<para> After the previous steps are completed, click the
<guibutton>Next</guibutton> button to continue. Enter a name
and optionally a description for your new type, and click the
<guibutton>Finish</guibutton> button. Your macro type is now
finished.
</para>

<para>
To use the new macro type, click its button on the toolbar or
use the <guimenu>Objects</guimenu> menu. Constructing a macro
object is just like constructing any other object.
</para>
<screenshot>
<screeninfo>Using your new type</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="macros_at_work.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>Using your new type</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect1>

<sect1 id="working-with-types">
<title>Working with types</title>
<para>
As you saw in the previous chapter, &kig; allows you to create
your own objects. &kig; also makes sure that once you have
created an object, it is saved on exit and loaded on startup.
You do not have to manually save or load macro definitions.
However, &kig; does allow you to do more with the macros. If
you select <menuchoice><guimenu>Types</guimenu><guimenuitem>Manage
Types...</guimenuitem></menuchoice> from the menu, you will see
a dialog where you can edit your types. It allows you to modify
the existent types, delete types that are no longer used, export
them to a file, or even load them from another file.
</para>
<screenshot>
<screeninfo>Edit Types Dialog</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="edit_types_dialog.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>The Edit Types Dialog</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect1>

<sect1 id="text-labels">
<title>Text labels</title>
<para>
&kig; allows you to add text labels to a construction. This
is very useful for adding names, explanations or other text
to constructions. &kig; can also display variable information
about objects (also known as <quote>properties</quote>).
</para>
<para>
To start constructing a text label, simply press the
&nbsp;<inlinemediaobject> <imageobject> <imagedata fileref="kig_text.png" format="PNG"/>
</imageobject> </inlinemediaobject> <guibutton>Text Label</guibutton>
button in the &kig; toolbar or select the <menuchoice><guimenu>Objects</guimenu>
<guisubmenu>Other</guisubmenu><guimenuitem>Text Label</guimenuitem>
</menuchoice> menu item.
</para>
<para>
Next, you have to choose a location for the text label. You
can either just select a random location on the screen, or
choose to <quote>attach</quote> the label to an object.
</para>
<screenshot>
<screeninfo>Attaching a label to a circle...</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="text_label_attaching.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>Attaching a label to a circle...</phrase>
</textobject>
</mediaobject>
</screenshot>
<para>
After you have selected where to put the label, the text label dialog appears. 
Here, you can type in
the text that you want in the new label, and click
<guibutton>Finish</guibutton>. You should now see the label in your document.
</para>
<screenshot>
<screeninfo>The Text Label Dialog</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="text_label_wizard.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>The Text Label Dialog</phrase>
</textobject>
</mediaobject>
</screenshot>
<para>
The previous example was a simple one, and limited to just
text. However, there is also support for showing variable
information about objects in a label (&eg; you can construct a
label with the text <quote>This segment is %1 units
long.</quote> where <token>%1</token> would be dynamically
replaced with the length of a specific segment).
</para>
<para>
To do this, enter a text with a number of placeholders (
<token>%1</token>, <token>%2</token> &etc;) in it.
Then, press the <guibutton>Next</guibutton> button to
continue. If you want to change the text or variables later,
you can go back using the <guibutton>Back</guibutton> button.
</para>
<para>
The wizard now shows the text you entered with all
placeholders replaced by something like <guilabel>argument
1</guilabel>. Selecting the property connected to a certain argument is
done by first clicking on the argument in question. Then click
on the object that you need and that has this property, and
then select the property itself in the popup
menu that appears. For instance, in the example above, you
would click <guilabel>argument 1</guilabel>, click on the
correct segment in the main &kig; window, and select the
property <guilabel>Length</guilabel>. Afterwards, you can
fill in the rest of the variable parts, or select another
property for one of the variable parts if you wish to change
it. When you are ready, click the
<guibutton>Finish</guibutton> button to complete the
construction of the text label.
</para>
<screenshot>
<screeninfo>Selecting a property for a variable
part</screeninfo>
<mediaobject>
<imageobject>
<imagedata
fileref="text_label_wizard__select_property.png"
format="PNG"/>
</imageobject>
<textobject>
<phrase>Selecting a property for a variable part</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect1>

<sect1 id="loci">
<title>Loci</title>
<para>
&kig; supports the use of loci. A locus is mathematically defined as
the set of all points or lines that satisfy or are determined by specific
conditions; as in <quote>the locus of points
equidistant from a given point is a circle</quote>.
Let's look at an example of how to use loci in &kig;:
</para>
<para>
Consider the following geometrical construction: We draw a
circle, and a point that can move only along its circumference
(construct this point by positioning the cursor on a circle, and clicking
the &MMB;. If you then try to move the resulting point,
you'll see that you cannot move it off the circle). Then, we
draw a segment from that point to the center of the circle,
and the midpoint of that segment.
</para>
<screenshot>
<screeninfo>A simple construction using a locus</screeninfo>
<mediaobject>
<imageobject>
<imagedata
fileref="simple_locus_construction.png"
format="PNG"/>
</imageobject>
<textobject>
<phrase>A simple construction using a locus</phrase>
</textobject>
</mediaobject>
</screenshot>
<para>
Now if you move the point that is constrained to the circle,
you'll see that the second point moves along with it. If you
were to hold a pen at the second point, and move the
first point around the entire circle, a new circle, half the
size of the other would be drawn. The path that the second point
travels while the first one moves around the circle is its locus.
</para>
<para>
Actually constructing the locus of a point is very easy. Click
the &nbsp;<inlinemediaobject><imageobject> <imagedata fileref="locus.png"
format="PNG"/> </imageobject></inlinemediaobject> <guibutton>Locus</guibutton>
button in the toolbar, or select the <menuchoice><guimenu>Objects</guimenu>
<guisubmenu>Other</guisubmenu><guimenuitem>Locus</guimenuitem></menuchoice>
menu item. Then select the constrained point as the
moving point (the text <guilabel>Moving Point</guilabel> will
appear as you move the mouse over it), and the other as the
<guilabel>Dependent point</guilabel>. The locus of the dependent
point will then be drawn.
</para>
</sect1>
</chapter>

<chapter id="scripting">
<title>Scripting</title>
<para>
&kig; allows you to create custom types in the Python
scripting language. This is a very advanced feature, and I know
of only one other Interactive Geometry program that has a similar
functionality (the <acronym>GNOME</acronym> program &drgeo;). 
</para>
<para>
Python Scripting in &kig; basically allows you to create your
own objects from certain parent objects. For example, if you are a math
teacher, and you have some fancy way
of calculating an interesting point on a conic, then instead of
messing with complex constructions and macros, you could just
write down in Python code how the point is to be calculated and
then &kig; will show it for you.
</para>
<para>
Suppose you were not aware of the &kig; built-in type <quote>Mid Point</quote>,
and you wanted to show the midpoint of two given points. You
would then click on the &nbsp;<inlinemediaobject> <imageobject> <imagedata
fileref="text-x-python3.png" format="PNG"/></imageobject> </inlinemediaobject>
<guibutton>Python Script</guibutton> button in the toolbar, or select
<menuchoice><guimenu>Objects</guimenu><guisubmenu>Other</guisubmenu>
<guimenuitem>Python Script</guimenuitem></menuchoice> from the
menubar. You are then presented with a wizard that allows you
to proceed.
</para>
<screenshot>
<screeninfo>The Script Object Wizard</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="script_wizard.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>The Script Object Wizard</phrase>
</textobject>
</mediaobject>
</screenshot>
<para>
The first thing you have to do is select the arguments for the
script object. In our example, this means the two points of
which we want to show the midpoint. Select them in the &kig;
main window, and click <guibutton>Next</guibutton> to proceed.
</para>
<para>
Now you are presented with a text edit box where you can enter
the code for you script object. Template code and some comments
are already in place. It is important to make sure that your
code is valid Python code. People familiar with Python will
notice that we are actually defining a Python function called
<function>calc</function>. It is therefore necessary to adhere
to the Python rules for defining functions. For example, every
line of the function should start with a tab. The first line not
starting with a tab ends the definition of the function.
</para>
<para>
The Python function that we want to define is called
<function>calc</function>, and in our case it accepts two arguments.
These are the objects you have selected as arguments in the
previous screen. You need as many arguments as you have
selected there. They are called <parameter>arg1</parameter> and
<parameter>arg2</parameter>, but you can change their names to
something more meaningful if you want.
</para>
<para>
In the function, you can do all sorts of calculations that you
deem necessary, using the two arguments if needed. You should
return the object you want to define. In our case, this is a
<classname>Point</classname> object. The two arguments are also
<classname>Point</classname> objects, and we
can use the <function>Point.coordinate()</function> function to
define the coordinates of the two given points.
</para>
<para>
The calculation necessary in our example is very simple, we
simply add the two sets of coordinates, and divide the new set
by two. We then construct a new point using the result.
The Python code needed is:</para>

<programlisting>
def calc( a, b ):
    m = ( a.coordinate() + b.coordinate() ) / 2;
    return Point( m )
</programlisting>

<screenshot>
<screeninfo>Entering the code</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="script_wizard_entering_code.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>Entering the code for the midpoint in the Script Object
wizard.</phrase>
</textobject>
</mediaobject>
</screenshot>
<para>
If you now click the <guibutton>Finish</guibutton> button,
the new object will appear in the &kig; document. If you move
one of the points, the newly created point will move along
with it. Much more powerful objects can be built in this way:
you are encouraged to try it out.
</para>
<screenshot>
<screeninfo>Constructed a Script Object</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="constructed_script_object.png" format="PNG" />
</imageobject>
<textobject>
<phrase>
The newly constructed Script Object.
</phrase>
</textobject>
</mediaobject>
</screenshot>
<para>
All objects in &kig; can be used in the Python code. As we have
seen above, points are of the <classname>Point</classname> class, and you
can use &eg; the <function>Point.coordinate()</function> method. You can
also return all kinds of objects, not just a <classname>Point</classname>.
Many more classes and methods are available in the &kig; Python code,
and a more complete reference is provided <ulink
url="https://edu.kde.org/kig/manual/scripting-api/index.html">on
the &kig; website</ulink>.
</para>
</chapter>

<chapter id="kig-features">
<title>&kig; Features</title>

<itemizedlist>
<listitem>
<para>
&kig; is an open source application. This means that you
are free to use and modify it any way you like it.
Distributing &kig; is subject to some restrictions,
basically that everyone should have the same rights to use
&kig;, including your modifications, as you and me.
</para>
<para>
Free software programs are developed in a very open
spirit, and its developers are usually very responsive to
user feedback. Therefore, if you have any questions,
complaints, or whatever about &kig;, please contact the
kde-edu mailing list at <email>kde-edu@kde.org</email>.
</para>
</listitem>
<listitem>
<para>
&kig; is a KPart application, which means that you can
embed it into other &kde; software. If you open a <literal
role="extension">.kig</literal> file in &konqueror;, it
can be opened directly in the &konqueror; screen without
the need to start an external application.
</para>
</listitem>
<listitem>
<para>
Working with &kig; should be very straightforward.
Constructing objects is easy and interactive, with
preliminary results being shown, &etc; Moving, selecting
and building all work as one would expect them to. Undo
support should also be very intuitive.
</para>
</listitem>
<listitem>
<para>
&kig; supports macros to be defined in a straightforward
manner. These objects are presented to the user like
normal objects. They are saved on exit and loaded on
startup, so that they aren't lost on exit. You can
manage these objects in the <guilabel>Manage Types</guilabel>
dialog (see <xref linkend="working-with-types" />). You can export
them
to files, import them from files, edit and delete them.
</para>
</listitem>
<listitem>
<para>
&kig; saves its data in a clear &XML; format.
</para>
</listitem>
<listitem>
<para>
&kig; supports the construction of loci.
</para>
</listitem>
<listitem>
<para>
&kig; allows you to export a &kig; file to some interesting
formats, like images, <application>XFig</application> and
<application>LaTeX</application> files, and &SVG;
vectorial images. This is rather useful, because not all programs
support the &kig; file format yet.
</para>
</listitem>
<listitem>
<para>
&kig; has a very flexible transformation system.
</para>
</listitem>
<listitem>
<para>
&kig; aims to be compatible with its competitors. This is
why it supports the &kgeo; file format, the &kseg; file
format and partially the &drgeo; and &cabri; formats; moreover,
support for other formats is planned.
</para>
</listitem>
</itemizedlist>
</chapter>


<chapter id="credits">
<title>Credits and License</title>

<para>
Main authors:
</para>
<para>
&kig; copyright 2011-2015 David E. Narvaez
<email>david.narvaez@computer.org</email>
</para>
<para>
&kig; copyright 2002-2013 Maurizio Paolini
<email>paolini@dmf.unicatt.it</email>
</para>
<para>
&kig; copyright 2004-2010 Pino Toscano
<email>pino@kde.org</email>
</para>
<para>
&kig; copyright 2002-2005 Dominique Devriese
<email>devriese@kde.org</email>
</para>

<para>
Documentation copyright 2002-2004 Dominique
Devriese <email>devriese@kde.org</email>.
</para>

<para>
Documentation copyright 2004-2005 Pino Toscano
<email>toscano.pino@tiscali.it</email>.
</para>

<para>
Reviewed by &Philip.Rodrigues; &Philip.Rodrigues.mail;.
</para>
<!-- TRANS:CREDIT_FOR_TRANSLATORS -->
&underFDL; &underGPL;
</chapter>

<appendix id="contributing">
<title>Contribute</title>
<sect1 id="kig-is-free">
<title>Free Software</title>
<para>
&kig; is <ulink
url="https://www.gnu.org/philosophy/philosophy.html#AboutFreeSoftware">
Free Software</ulink>. This means that its source code is
freely available on the Internet, and everyone can use it,
read it, modify it, and distribute it.
</para>
</sect1>

<sect1 id="contribute-to-kig">
<title>Contribute</title>
<para>
In this chapter I want to point out to you (the user) the
rights that &kig;'s license gives you. As with all free
software, you are allowed (and encouraged) to fix problems
you encounter while using it, to add features you miss, to
distribute your modified program, and to send these
modifications back for inclusion through the review tools
available for the &kde; community.
</para>
<para>
If you are uncertain of your rights to use this software, or
other people's right to use any modifications you make to this
program &etc;, please read the license. You can find it in the
<filename>COPYING</filename> file in the &kig; source tree or
the license link in the <guilabel>About
&kig;</guilabel> dialog.
</para>
</sect1>

<sect1 id="howto-contribute">
<title>How to contribute ?</title>
<para>
Any contributions are welcome. If you don't like the icons,
or think that the manual needs updating, or if you have this really
cool macro that you want to share with the world, do not
hesitate to send it to me. Please note that your
contributions will be distributed under the terms of the &GNU;
<acronym>GPL</acronym>; you can find the terms of this license in the
<filename>COPYING</filename> file in the &kig; source tree,
and in the <link linkend="credits">Credits and
License</link> chapter in this manual.
</para>
</sect1>
</appendix>

&documentation.index;
</book>
<!--
Local Variables:
mode: xml
End:
-->
