QGIS User Guide 1.7 - en to de translation catalogue (66 entries)

en: Using SEXTANTE from the console
de: SEXTANTE mit der Konsole nutzen

en: Introduction
de: Einführung

en: The console allows advanced users to increase their productivity and perform complex operations that cannot be performed using any of the other elements of the SEXTANTE GUI. Models involving several algorithms can be defined using the command-line interface, and additional operations such as loops and conditional sentences can be added to create more flexible and powerful workflows.
de: Die Konsole ermöglicht fortgeschrittenen Anwendern, die Produktivität zu steigern und komplexe Operationen auszuführen, die mit keinem der anderen Elemente der SEXTANTE Toolbox ausgeführt werden können. Modelle mit mehreren Algorithmen können mit der Kommandozeilen-Schnittstelle erstellt und zusätzliche Operationen wie Schleifen und Bedingungen hinzugefügt werden, um flexible und leistungsfähige Workflows zu erstellen.

en: There is not a SEXTANTE console in QGIS, but all SEXTANTE commands are available instead from QGIS built-in Python console. That means that you can incorporate those command to your console work and connect SEXTANTE algorithms to all the other features (including methods from the QGIS API) available from there.
de: Es gibt keine SEXTANTE Konsole in QGIS, aber alle SEXTANTE Befehle stehen in der QGIS Python-Konsole zur Verfügung. Das bedeutet, dass Sie diese Befehle in Ihre Arbeit mit der Konsole einfließen lassen und mit SEXTANTE Algorithmen verbinden können, um somit alle Funktionen (einschließlich der Methoden aus der QGIS API) zur Verfügung zu haben.

en: The code that you can execute from the Python console, even if it does call any SEXTANTE method, can be converted into a new SEXTANTE algorithm that you can later call from the toolbox, the graphical modeler or any other SEXTANTE component, just like you do with any other SEXTANTE algorithm. In fact, some algorithms that you can find in the toolbox, like all the ones in the :guilabel:`mmqgis` group, are simple scripts.
de: Der Code, den Sie mit der Python-Konsole ausführen, auch wenn es keine SEXTANTE Methode enthält, können Sie in einen neuen SEXTANTE Algorithmus umwandeln, den Sie später aus der Toolbox, den grafischen Modeller oder jede andere SEXTANTE Komponente starten können. genauso wie jeder andere SEXTANTE Algorithmus. Tatsächlich sind einige Algorithmen, die Sie in der Toolbox finden, z.B. aus der :guilabel:`mmqgis` Gruppe einfache Skripte.

en: In this chapter we will see how to use SEXTANTE from the QGIS Python console, and also how to write your own algorithms using Python.
de: In diesem Kapitel werden Sie sehen, wie Sie die SEXTANTE QGIS Python-Konsole verwenden, und auch, wie Sie Ihre eigenen Algorithmen mit Python schreiben können.

en: Calling SEXTANTE from the Python console
de: SEXTANTE aus der Python Konsole aufrufen

en: The first thing you have to do is to import the SEXTANTE functions with the following line:
de: Als erstes müssen Sie die SEXTANTE Funktionen mit folgender Zeile importieren:

en: Now, there is basically just one (interesting) thing you can do with SEXTANTE from the console: to execute an algorithm. That is done using the ``runalg()`` method, which takes the name of the algorithm to execute as its first parameter, and then a variable number of additional parameter depending on the requirements of the algorithm. So the first thing you need to know is the name of the algorithm to execute. That is not the name you see in the toolbox, but rather a unique command–line name. To find the right name for your algorithm, you can use the ``algslist()`` method. Type the following line in you console:
de: Im Grunde gibt es nur eine (interessante) Sache, die Sie mit SEXTANTE von der Konsole aus tun können: einen Algorithmus ausführen. Dieses geschieht mit dem ``runalg()`` Verfahren, die den Namen des Algorithmus nimmt und  als ersten Parameter ausführt und danach eine variable Anzahl von zusätzlichen Parametern in Abhängigkeit von den Anforderungen des Algorithmus. Die erste Sache, die Sie wissen müssen, ist also der Name des Algorithmus. Das ist nicht der Name, den Sie in der Toolbox sehen, sondern ein Kommandozeilen-Name. Um den richtigen Namen für Ihren Algorithmus zu finden, können Sie die ``algslist()``-Methode nutzen. Geben Sie folgende Zeile in die Konsole ein:

en: You will see something like this.
de: Sie werden etwas wie dieses sehen.

en: That's a list of all the available algorithms, alphabetically ordered, along with their corresponding command-line names.
de: Das ist eine Liste aller verfügbaren Algorithmen, alphabetisch geordnet, zusammen mit ihren entsprechenden Kommandozeilen-Namen.

en: You can use a string as a parameter for this method. Instead of returning the full list of algorithm, it will only display those that include that string. If, for instance, you are looking for an algorithm to calculate slope from a DEM, type ``alglist("slope")`` to get the following result:
de: Sie können einen String als Parameter für diese Methode verwenden. Statt die vollständige Liste der Algorithmen zurückzugeben, werden nur diejenigen angezeigt, die diese Zeichenfolge enthalten. Wenn Sie auf der Suche nach einem Algorithmus sind, um aus einem DGM die Hangneigung zu berechnen, tippen Sie ``alglist("slope")``, um das folgende Ergebnis zu bekommen:

en: This result might change depending on the algorithms you have available.
de: Dieses Ergebnis könnte sich ändern, je nach den Algorithmen, die Sie zur Verfügung haben.

en: It is easier now to find the algorithm you are looking for and its command-line name, in this case ``saga:slopeaspectcurvature``.
de: Es ist jetzt einfacher, den Algorithmus, die Sie suchen und den Kommandozeilen-Namen zu finden, in diesem Fall ``saga:slopeaspectcurvature``.

en: Once you know the command-line name of the algorithm, the next thing to do is to know the right syntax to execute it. That means knowing which parameters are needed and the order in which they have to be passed when calling the ``runalg()`` method. SEXTANTE has a method to describe an algorithm in detail, which can be used to get a list of the parameters that an algorithms require and the outputs that it will generate. To do it, you can use the ``alghelp(name_of_the_algorithm)`` method. Use the command-line name of the algorithm, not the full descriptive name.
de: Sobald Sie den Kommandozeilen-Namen des Algorithmus wissen, ist das nächste, was zu tun ist, die richtige Syntax zu kennen, um sie auszuführen. Das bedeutet, Sie müssen wissen, welche Parameter erforderlich sind und in welcher Reihenfolge sie beim Aufruf des ``runalg()`` Verfahrens  zu übergeben sind. SEXTANTE bietet ein Verfahren, um einen Algorithmus im Detail zu beschreiben mit einer Liste der Parameter, die der Algorithmus fordert und die Ausgaben, die erzeugt werden können. Um dies zu erreichen, können Sie die ``alghelp(name_of_the_algorithm)``-Methode nutzen. Verwenden Sie den Kommandozeilen-Name des Algorithmus, nicht den beschreibenden Namen.

en: Calling the method with ``saga:slopeaspectcurvature`` as parameter, you get the following description.
de: Aufrufen der Methode mit ``saga:slopeaspectcurvature`` als Parameter, wird folgende Beschreibung ausgegeben.

en: Now you have everything you need to run any algorithm. As we have already mentioned, there is only one single command to execute algorithms: ``runalg()``. Its syntax is as follows:
de: Jetzt haben Sie alles, was Sie brauchen, um jeden Algorithmus laufen zu lassen. Wie wir bereits erwähnt haben, gibt es nur einen einzigen Befehl, Algorithmen auszuführen: ``runalg()``. Die Syntax ist wie folgt:

en: The list of parameters and outputs to add depends on the algorithm you want to run, and is exactly the list that the ``alghelp()`` method gives you, in the same order as shown.
de: Die Liste der Parameter und Ausgaben, die hinzugefügt werden müssen, hängt vom Algorithmus ab, den Sie ausführen möchten, und ist genau die Liste, die die ``alghelp()``-Methode anzeigt, und zwar in derselben Reihenfolge wie gezeigt.

en: Depending on the type of parameter, values are introduced differently. The next one is a quick review of how to introduce values for each type of input parameter
de: Je nach Art der Parameter, werden Werte unterschiedlich integriert. Der nächste Abschnitt gibt einen kurzen Überblick, wie man Werte für jede Art von Eingabeparameter einführt

en: Raster Layer, Vector Layer or Table. Simply use a string with the name that identifies the data object to use (the name it has in the QGIS Table of Contents) or a filename (if the corresponding layer is not opened, it will be opened, but not added to the map canvas). If you have an instance of a QGIS object representing the layer, you can also pass it as parameter. If the input is optional and you do not want to use any data object, use ``None``.
de: Rasterlayer, Vektorlayer oder Tabelle. Verwenden Sie einfach einen String mit dem Namen, der das Datenobjekt identifiziert (der Name der in der QGIS Legende auftaucht) oder ein Dateiname (wenn der entsprechende Layer nicht geöffnet ist, wird es geöffnet, aber nicht in das Kartenfenster hinzugefügt). Wenn Sie eine Instanz eines QGIS Objekts eines Layers haben, können Sie diese auch als Parameter übergeben. Wenn die Eingabe optional ist und Sie kein Datenobjekt angeben wollen, verwenden Sie ``None``.

en: Selection. If an algorithm has a selection parameter, the value of that parameter should be entered using an integer value. To know the available options, you can use the ``algoptions`` command, as shown in the following example:
de: Auswahl. Wenn ein Algorithmus einen Auswahl-Parameter hat, sollte der Wert dieses Parameters als Integer-Wert eingegeben werden. Um die verfügbaren Optionen zu kennen, können Sie den Befehl ``algoptions`` nutzen, wie im folgenden Beispiel gezeigt:

en: In this case, the algorithm has one of such such parameters, with 7 options. Notice that ordering is zero-based.
de: In diesem Fall weist der Algorithmus einen Parameter mit 7 Optionen auf. Beachten Sie, dass Ordnung auf Null-basiert ist.

en: Multiple input. The value is a string with input descriptors separated by semicolons. As in the case of single layers or tables, each input descriptor can be the data object name, or its filepath.
de: Multiple Input. Der Wert ist ein String mit Eingabebeschreibung durch Semikolon getrennt. Wie in dem Fall der einzelnen Layer oder Tabellen kann jede Eingabebeschreibung der Datenobjektname oder der Dateipfad sein.

en: Table Field from XXX. Use a string with the name of the field to use. This parameter is case-sensitive.
de: Tabellenspalte von XXX. Verwenden Sie eine Zeichenfolge mit dem Namen des Feldes. Dieser Parameter reagiert auf Groß-und Kleinschreibung.

en: Fixed Table. Type the list of all table values separated by commas and enclosed between quotes. Values start on the upper row and go from left to right. You can also use a 2D array of value representing the table.
de: Feste Tabelle. Geben Sie die Liste aller Tabellenwerte durch Kommata getrennt und eingeschlossen zwischen Anführungszeichen an. Werte beginnen in der oberen Zeile und gehen von links nach rechts. Sie können auch ein 2D-Array der Wert verwenden, um die Tabelle abzubilden.

en: CRS. Enter the EPSG code number of the desired CRS.
de: KBS. Geben Sie den EPSG Code des gewünschten KBS an.

en: Extent. You must use a string with ``xmin``, ``xmax``, ``ymin`` and ``ymax`` values separated by commas.
de: Extent. Sie müssen einen Text mit ``xmin``, ``xmax``, ``ymin`` und ``ymax`` Werten, durch Kommata getrennt angeben.

en: Boolean, file, string and numerical parameters do not need any additional explanations.
de: Boolean, Datei, Text-und numerische Parameter benötigen keine zusätzlichen Erklärungen.

en: Input parameters such as strings booleans or numerical values have default values. To use them, use ``None`` in the corresponding parameter entry.
de: Input-Parameter wie Text booleans oder Zahlenwerte haben Standardwerte. Um sie zu verwenden, verwenden Sie ``None`` für der entsprechenden Parameter-Eintrag.

en: For output data objects, type the filepath to be used to save it, just as it is done from the toolbox. If you want to save the result to a temporary file, use ``None``. The extension of the file determines the file format. If you enter a file extension not included in the ones supported by the algorithm, the default file format for that output type will be used, and its corresponding extension appended to the given filepath.
de: Für die Ausgabe-Datenobjekte geben Sie den Dateipfad an, der verwendet werden soll, um sie zu speichern, so wie es auch aus der Toolbox getan wird. Wenn Sie das Ergebnis in einer temporären Datei speichern möchten, verwenden  Sie ``None``. Die Erweiterung der Datei bestimmt das Dateiformat. Wenn Sie eine Datei-Erweiterung verwenden, die nicht von QGIS unterstützt wird, wird das Standard-Dateiformat für diesen Ausgang Typ verwendet werden, und die entsprechende Erweiterung an den angegebenen Dateipfad angehängt.

en: Unlike when an algorithm is executed from the toolbox, outputs are not added to the map canvas if you execute that same algorithm from the Python console. If you want to add an output to it, you have to do it yourself after running the algorithm. To do so, you can use QGIS API commands, or, even easier, use one of the handy methods provided by SEXTANTE for such task.
de: Anders als ein Algorithmus aus der Toolbox ausgeführt wird, werden die Ausgaben nicht ins Kartenfenster hinzugefügt, wenn Sie denselben Algorithmus in der Python-Konsole ausführen. Wenn Sie eine Ausgabe hinzufügen möchten, müssen Sie es selbst tun nachdem der Algorithmus abgeschlossen ist. Um dies zu tun, können Sie QGIS API-Befehle nutzen, oder, noch einfacher, verwenden Sie eine der Methoden, die SEXTANTE für solche Aufgaben zur Verfügung gestellt.

en: The ``runalg()`` method returns a dictionary with the output names (the ones shown in the algorithm description) as keys and the filepaths of those outputs as values. To add all the outputs generated by an algorithm, pass that dictionary to the ``loadFromAlg()`` method. You can also load an individual layer passing its filepath to the ``load()`` method.
de: Die ``runalg()``-Methode gibt ein Wörterbuch mit den Ausgabe-Namen (die in der Algorithmusbeschreibung dargestellt sind) als Schlüssel und die Dateipfade der Ausgaben als Werte. Um alle Ausgaben, die durch einen Algorithmus generiert wurden, hinzuzufügen, überführen Sie den Dictionary in die ``loadFromAlg()``-Methode. Sie können auch einen einzelnen Layer laden, indem Sie den Dateipfad an die``load()``-Methode übergeben.

en: Creating scripts and running them from the toolbox
de: Erstellen von Skripten und diese aus der Toolbox starten

en: You can create your own algorithms by writing the corresponding Python code and adding a few extra lines to supply additional information needed by SEXTANTE. You can find a :guilabel:`Create new script` under the tools group in the script algorithms block of the toolbox. Double click on it to open the script edition dialog. That's where you should type your code. Saving the script from there in the :file:`scripts` folder (the default one when you open the save file dialog), with :file:`.py` extension, will automatically create the corresponding algorithm.
de: Sie können Ihre eigenen Algorithmen mit Python schreiben, indem ein paar zusätzliche Zeilen ergänzen, um zusätzliche Informationen für SEXTANTE bereitzustellen. Dafür finden Sie einen : guilabel:`Neues Skript erstellen` Knopf unter der Gruppe Tools im Bereich Algorithmen der Toolbox. Doppelklicken Sie darauf, um die Skriptausgabe zu öffnen. Das ist der Ort, an dem Sie Ihren Code eingeben können. Speichern Sie das Skript von dort aus in den :file:`Skriptordner` (Standard ist der Ordner, wenn Sie den 'Datei speichern' Dialog öffnen), mit :file:` py`-Erweiterung, wird automatisch ein entsprechender Algorithmus erstellt.

en: The name of the algorithm (the one you will see in the toolbox) is created from the filename, removing its extension and replacing low hyphens with blank spaces.
de: Der Name des Algorithmus (den Sie in der Toolbox sehen) wird aus dem Dateinamen erstellt, wobei die Erweiterung entfernt wird und Leerzeichen durch Unterstriche ersetzt werden.

en: Let's have the following code, which calculates the Topographic Wetness Index (TWI) directly from a DEM
de: Schauen wir uns den folgenden Code an, der den Topographischen Feuchte-Index (TWI) direkt aus einem DEM berechnet

en: As you can see, it involves 3 algorithms, all of them coming from SAGA. The last one of them calculates de TWI, but it needs a slope layer and a flow accumulation layer. We do not have these ones, but since we have the DEM, we can calculate them calling the corresponding SAGA algorithms.
de: Wie Sie sehen können, geht es um 3 Algorithmen, die alle von SAGA kommen. Der letzte von ihnen berechnet den TWI, aber es wird ein Hangneigungslayer und ein Abflussakkumulationslayer benötigt, die zwar noch nicht vorhanden sind, aber auf Basis des DEM mit SAGA Algorithmen berechnet werden können.

en: The part of the code where this processing takes place is not difficult to understand if you have read the previous sections in this chapter. The first lines, however, need some additional explanation. They provide SEXTANTE the information it needs to turn your code into an algorithm that can be run from any of its components, like the toolbox or the graphical modeler.
de: Der Teil des Codes, in dem diese Verarbeitung stattfindet, ist nicht schwer zu verstehen, wenn Sie die vorherigen Abschnitte in diesem Kapitel gelesen haben. Die ersten Zeilen brauchen jedoch einige zusätzliche Erklärungen. Sie bieten SEXTANTE Informationen, die notwendig sind, um Ihren Code in einen Algorithmus zu überführen, der mit einer seiner Komponenten ausgeführt werden kann, wie z.B. die Toolbox oder der grafische Modeller.

en: These lines start with a double Python comment symbol and have the following structure:
de: Diese Zeilen beginnen mit einem Doppel-Python Kommentar Symbol und haben die folgende Struktur:

en: Here is a list of all the parameter types that SEXTANTE supports in its scripts, their syntax and some examples.
de: Hier ist eine Liste aller Parameter-Typen, die SEXTANTE unterstützt in seinen Skripten, ihre Syntax und einige Beispiele.

en: ``raster``. A raster layer
de: ``raster``. Ein Rasterlayer

en: ``vector``. A vector layer
de: ``vector``. Ein Vektorlayer

en: ``table``. A table
de: ``table``. Eine Tabelle

en: ``number``. A numerical value. A default value must be provided. For instance, ``depth=number 2.4``
de: ``number``. Ein numerischer Wert. Ein Standardwert muss festgelegt werden. Z.B.: ``depth=number 2.4``

en: ``string``. A text string. As in the case of numerical values, a default value must be added. For instance, ``name=string Victor``
de: ``String``. Eine Textzeichenfolge. Wie im Fall von numerischen Werten, muss ein Standardwert hinzugefügt werden.  Z.B.: ``name=string Victor``

en: ``boolean``. A boolean value. Add ``True`` or ``False`` after it to set the default value. For example, ``verbose=boolean True``
de: ``boolean``. Ein boolescher Wert. Füge danach ``Add`` oder ``False`` hinzu, um den Standardwert zu setzen. Z.B.: ``verbose=boolean True``

en: ``multiple raster``. A set of input raster layers.
de: ``multiple raster``. Ein Satz von Eingabe-Rasterlayern.

en: ``multiple vector``. A set of input vector layers.
de: ``multiple vector``. Ein Satz von Eingabe-Vektorlayern.

en: ``field``. A field in the attributes table of a vector layer. The name of the layer has to be added after the ``field`` tag. For instance, if you have declared a vector input with ``mylayer=vector``, you could use ``myfield=field mylayer`` to add a field from that layer as parameter.
de: ``Spalte``. Eine Spalte in der Attributtabelle eines Vektorlayers. Der Name des Layers muss nach dem ``Spalte`` tag hinzugefügt werden. Z.B.:, wenn Sie eine Vektoreingabe mit ``mylayer=Vektor`` definiert haben, können Sie ``myfield=spalte mylayer`` verwenden, um eine Spalte aus diesem Layer als Parameter hinzuzufügen.

en: ``folder``. A folder
de: ``folder``. Ein Ordner

en: ``file``. A filename
de: ``file``. Ein Dateiname

en: The parameter name is the name that will be shown to the user when executing the algorithm, and also the variable name to use in the script code. The value entered by the user for that parameter will be assigned to a variable with that name.
de: Der Parameter Name ist der Name, der dem Benutzer angezeigt wird, wenn der Algorithmus ausgeführt wird und auch der Variablenname der im Skript-verwendet wird. Der Wert, der durch den Benutzer für diesen Parameter eingegeben wird der Variablen mit diesem Namen zugeordnet.

en: When showing the name of the parameter to the user, SEXTANTE will edit it to improve its appearance, replacing low hyphens with blankspaces. So, for instance, if you want the user to see a parameter named ``A numerical value``, you can use the variable name ``A_numerical_value``.
de: Beim Zeigen des Namens des Parameters bearbeitet SEXTANTE es, um das Erscheinungsbild zu verbessern. Dabei werden niedrige Bindestriche mit Leerzeichen ersetzt. So, zum Beispiel, wenn Sie wollen, dass der Benutzer einen Parameter ``Ein numerischer Wert`` sieht, können Sie für den Namen der Variablen ``A_numerical_value`` verwenden.

en: Layers and tables values are strings containing the filepath of the corresponding object. To turn them into a QGIS object, you can use the ``sextante.getObjectFromUri()`` function. Multiple inputs also have a string value, which contains the filepaths to all selected object, separated by semicolons.
de: Layer und Tabellen Werte sind Strings, die den Dateipfad des entsprechenden Objekts enthalten. Um sie zu einem QGIS Objekt zu machen, können Sie die ``sextante.getObjectFromUri()``-Funktion nutzen. Mehrere Eingaben haben auch einen String-Wert, der die Dateipfade enthält mit allen ausgewählten Objekten, durch Semikolon getrennt.

en: Outputs are defined in a similar manner, using the following tags:
de: Die Ausgaben sind in ähnlicher Weise definiert, mit den folgenden Tags:

en: The value assigned to the output variables is always a string with a filepath. It will correspond to a temporary filepath in case the use has not entered any output filename.
de: Der zugewiesene Wert der Ausgabevariablen ist immer eine Zeichenfolge mit einem Dateipfad. Es entspricht einem vorübergehenden Dateipfad für den Fall, dass der Benutzer keine Ausgabedatei festgelegt hat.

en: When you declare an output, SEXTANTE will try to add it to QGIS once the algorithm is finished. That is the reason why, although the ``runalg()`` method does not load the layers it produces, the final TWI layer will be loaded, since it is saved to the file entered by the user, which is the value of the corresponding output.
de: Wenn Sie eine Ausgabe festlegen, wird SEXTANTE versuchen, es in QGIS hinzuzufügen, sobald der Algorithmus beendet ist. Das ist der Grund, warum, obwohl die ``runalg()`` Methode die produzierten Layer nicht lädt, der endgültige TWI Layer geladen wird, da es als Datei gespeichert wird, die vom Benutzer angegeben wurde.

en: Do not use the ``load()`` method in your script algorithms, but just when working with the console line. If a layer is created as output of an algorithm, it should be declared as such. Otherwise, you will not be able to properly use the algorithm in the modeler, since its syntax (as defined by the tags explained above) will not match what the algorithm really creates.
de: Verwenden Sie nicht die ``load()``-Methode in Ihren Skripten, sondern nur, wenn Sie mit der Konsole arbeiten. Wenn ein Layer als Ausgabe eines Algorithmus erstellt wird, sollte er als solches deklariert werden. Andernfalls werden Sie nicht in der Lage sein, den Algorithmus im Modeller richtig zu verwenden, da die Syntax (wie durch die Tags definiert und weiter oben erläutert) nicht übereinstimmen mit dem, was der Algorithmus wirklich erstellt.

en: Hidden outputs (numbers and strings) do not have a value. Instead, it is you who has to assign a value to them. To do so, just set the value of a variable with the name you used to declare that output. For instance, if you have used this declaration,
de: Versteckte Ausgaben (Zahlen und Strings) haben keinen Wert. Stattdessen müssen Sie Ihnen einen Wert zuweisen. Um dies zu tun, setzen Sie nur den Wert einer Variablen mit dem Namen, den Sie verwendet haben, um diese Ausgabe anzuzeigen. Zum Beispiel, wenn Sie diese Anzeige verwendet haben,

en: the following line will set the value of the output to 5:
de: die folgende Zeile wird den Wert der Ausgabe auf 5 setzen:

en: In addition to the tags for parameters and outputs, you can also define the group under which the algorithm will be shown, using the ``group`` tag.
de: Zusätzlich zu den Tags für die Parameter-und Ausgänge können Sie auch die Gruppe definieren, unter denen der Algorithmus angezeigt werden soll, indem Sie die ``tag`` Gruppe nutzen.

en: If you algorithm takes a long time to process, it is a good idea to inform the user. You have a global named ``progress`` available, with two available methods: ``setText(text)`` and ``setPercentage(percent)`` to modify the progress text and the progress bar.
de: Wenn Ihr Algorithmus eine lange Zeit braucht, um die Daten zu verarbeiten, ist es eine gute Idee, den Benutzer zu informieren. Sie haben dafür einen globalen Namen ``Fortschritt`` zur Verfügung, mit zwei verfügbaren Methoden: ``setText(text)`` und ``setPercentage(Prozent)``, um den Fortschritt Text und die Fortschrittsanzeige zu ändern.

en: Several examples are provided with SEXTANTE. Please, check them to see real examples of how to create algorithms using this feature of SEXTANTE. You can right-click on any script algorithm and select :guilabel:`Edit script` to edit its code or just to see it.
de: Einige Beispiele sind bereits in SEXTANTE vorhanden. Bitte, schauen Sie sich diese Beispiele an, wie man Algorithmen  mit SEXTANTE erstellen kann. Sie können auf jeden Skript-Algorithmus mit der rechten Maustaste klicken und dann 
    :guilabel:`Skript bearbeiten` auswählen, um den Code zu bearbeiten oder einfach nur zu sehen.

en: Documenting your scripts
de: Eigene Skripte dokumentieren

en: As in the case of models, you can create additional documentation for your script, to explain what they do and how to use them. In the script editing dialog you will find a **[Edit script help]** button. Click on it and it will take you to the help editing dialog. Check the chapter about the graphical modeler to know more about this dialog and how to use it.
de: Wie im Fall von Modellen, können Sie zusätzliche Dokumentation zu Ihrem Skript erstellen, um zu erklären, was sie tun und wie man das Skript benutzt. In dem :guilabel:`Skript-Bearbeitung` Dialog finden Sie ein **[Bearbeite Skript Hilfe]** Knopf. Klicken Sie darauf, um einen Editierdialog zu starten. Lesen Sie das Kapitel über den grafischen Modeller, um mehr über diesen Dialog und wie er benutzt wird zu erfahren.

en: Help files are saved in the same folder as the script itself, adding the :file:`.help` extension to the filename. Notice that you can edit your script's help before saving it for the first time. If you later close the script editing dialog without saving the script (i.e. you discard it), the help content you wrote will be lost. If your script was already saved and is associated to a filename, saving is done automatically.
de: Hilfe-Dateien werden im selben Ordner wie das Skript selbst gespeichert, indem sie die :file:`.help` Erweiterung zum Dateinamen hinzufügen. Beachten Sie, dass Sie Ihre Skripthilfe vor dem Speichern zum ersten Mal bearbeiten. Wenn Sie später den Dialog schliessen, ohne das Skript zu speichern, ist der Inhalt der Hilfe verloren. Wenn Ihr Skript bereits gespeichert wurde, und einem Dateinamen zugeordnet ist, findet die Speicherung automatisch statt.
