# Der Anfang mit Anjuta

2002, 2003
Ishan Chattopadhyaya und Ulrich Gehring

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. You may obtain a copy of the GNU Free Documentation License from the Free Software Foundation by visiting their Web site or by writing to: Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Many of the names used by companies to distinguish their products and services are claimed as trademarks. Where those names appear in any GNOME documentation, and those trademarks are made aware to the members of the GNOME Documentation Project, the names have been printed in caps or initial caps.

This is version 1.1 of 'Starting Off in Anjuta'.

## Einführung

Früher war unter Linux das Entwickeln von grafischen Bedieneroberflächen problematisch. Durch die Entwicklung des GIMP Toolkits (GTK, oder kurz Gimp) wurde dies entscheidend einfacher. Noch einfacher wurde die Entwicklung von GUI-Programmen (Graphical User Interface / Bedienoberfläche) durch Glade. Es ist ein Programm mit dem leicht das GUI für GTK-Programme erstellt werden kann. Es wurde von Damon Chaplin entwickelt. Aber Glade ist keine IDE (Integrated Development Environment) wie z.B. Visual Basic (u.a.). Dadurch kann der Programmierer den von Glade erzeugten Code nicht direkt editieren. Hier setzt Anjuta an!

Anjuta nutzt die Fähigkeiten von Glade (leichte Erstellung von GUIs) und kombiniert dies mit den Fähigkeiten eines guten Editors. Das Ergebnis ist eine leistungsfähige Entwicklungsumgebung für eine zügige Softwareentwicklung. Anjuta RAD (rapid application development), denn The best is in you.... Früher nutzte man Glade fuer das Erstellen des GUIs, einen Editor um den Programmcode zu editieren und verschiedene Terminals zum Kompilieren des Projektscodes. Das alles ist nun dank Anjuta in einer intuitiv zu bebienenden Oberfläche vereint. Das ist alles was ein gutes Softwaretool können muß.

Also verschwenden Sie nicht mehr Zeit und starten in die Welt von Anjuta. Erstellen Sie ein einfaches Hello World-Programm.

Es sei angemerkt, dass diese Einführung stärker auf das Erstellen der Anwendung und weniger auf die GTK-Programmierung eingeht. Für mehr Details über GTK besuchen Sie die GTK-Seite.

## Ein neues Projekt erstellen

Beachte: Diese Einführung wurde erstellt mit Anjuta 1.1.97 unter Slackware 9.0 mit Gnome2.2 und DropLinie Gnome. Bei anderen Versionen dieser Programme sollten keine wesentlichen Unterschiede bestehen.

Unser Ziel ist das Erstellen eines kleinen Programms, dass uns nach Eingabe unseres Namens freundlich begrüßt.

### Unsere Anwendung

Die laufende Anwendung

Zunächst starten wir mal Anjuta. Es öffnet sich der Startdialog:

### Anjuta - Startdialog

startdialog Da wir ein neues Projekt erstellen wollen, wählen wir den Anwendungsdruiden aus.

### Anwendungsdruide - 1. Schritt

anwendungsdruide, start Es ist allgemein üblich das geschriebene nicht zu lesen und so drücken wir einfach auf ([Vor]). Jedoch sollten wir im Folgenden nicht unüberlegt handeln. Der zweite Schritt ist entscheidend. Hier können wir den Typ der Anwendung wählen. Für unseren Zweck wühlen wir "GNOME 2.0 Projekt"...

### Anwendungsdruide - 2. Schritt

anwendungsdruide 2 ...und bestätigen mit der Taste ([Vor]).

Im dritten Schritt geben wir einige Informationen zu unserem Programm ein...

- Projektname: hallo

- Version des Projekts: 0.1

- Author des Projekts: Ihr Name

- Ziel des Projekts: hallo

- Programmiersprache: C

### Anwendungsdruide - 3. Schritt

anwendungsdruide 3

...und drücken die Taste ([Vor]).

Im nächsten Schritt, hier Schritt 4, geben wir eine Beschreibung unseres Projektes ein. Also z.B. "Ein kleines Hallo Welt Programm". Und weiter geht's mit der Taste ([Vor]).

Im fünften Schritt schalten wir "Unterstuetzung für Gettext" aus. Gettext-Unterstützung (Internationalisierung) ist hier nicht nötig...

### Anwendungsdruide - 5. Schritt

anwendungsdruide 5

...und drücken die Taste ([Vor]).

Nun wird eine kurze Zusammenfassung unserer Angaben angezeigt. Sind wir mit allem zufrieden, so drücken wir zum Abschluß die Taste ([Anwenden]) und Anjuta erstellt die Projektdateien. Sind alle Projektdateien erstellt, dies kann etwas dauern, erscheint im Message-Fenster die Meldung:

Auto generation completed...............Successful, Now Build the Project to have a LOOK at it

### Projektdateien erstellt

projektdateien fertig erstellt

## Entwurf der Bedienoberfläche

Anjuta braucht einige Zeit um die Verzeichnisstruktur des Projekts anzulegen, die Konfigurationsscripte ablaufen zu lassen und zum Erzeugen der Projektdateien. Im Messagefenster kann der Erstellungsprozess verfolgt werden. Nachdem der Erstellungsprozess abgelaufen ist sind im Projektfenster (Menü: Ansicht Projektfenster ) die Quellcode-Dateien, Dokumentationsdateien und Pixmap-Dateien aufgelistet.

Von besonderem Interesse ist die Datei: interface.c. In dieser Datei befinden sich die Deklarationen der GUI-Elemente unserer Anwendung. Diese Datei (u.a.) wird dann später von Glade verändert.

Jetzt starten wir aber erst mal Glade und entwerfen die Anwendung (GUI). Menü: Projekt GUI der Anwendung editieren bzw. [Alt]+[G]. Nachdem Glade gestartet ist sind idealerweise drei Fenster zu sehen:

1) das Hauptfenster von Glade

### Glade Hauptfenster

glade hauptfenster 2) die Palette mit den Werkzeugen (Widgets, Tools)

### Glade Widgets

glade widgets 3) das Eigenschaften-Fenster

### Glade Eigenschaften-Fenster

glade eigenschaften

Im Glade Hauptfenster klicken wir auf "window1" doppelt, so dass sich ein neues Fenster, das Hauptfenster unserer (noch leeren) Anwendung, öffnet. Im Eigenschaftsfenster tragen wir dann ein für die Überschrift: Hallo Linux Welt. Beachte: Der Eintrag "window1" unter "Name:" darf nicht geändert werden.

### GUI - Eigenschaften

gui eigenschaften

Um bei einer Veränderung der Fenstergröße unserer Anwendung die enthaltenen Elemente (z.B. Knöpfe, Listen, usw.) automatisch anzupassen, werden alle Elemente in sgn. "Container" eingelagert. Zunächst wählen wir also einen solchen. Hier ein "vertikales Feld" (Vertical Box Container) von der Werkzeugleiste durch anklicken und klicken dann auf unser Hauptfenster. Die Zeilenanzahl stellen wir auf 2 ein.

### Zeilenzahl

zeilenzahl

Dies teilt unser Anwendungsfenster in zwei Häften. In gleicher Weise wählen wir für die so entstandene obere und untere Hälfte je ein "horizontales Feld" mit zwei Spalten. Nun sollte unsere Anwendung folgendes Aussehen haben:

### Unsere Anwendung (Zwischenschritt)

gui2

Zum Bedienen unserer Anwendung benötigen wir zwei Knöpfe. Den ersten wollen wir im Feld unten links, den zweiten im Feld unten rechts plazieren. Dazu OK_Knopf in der Werkzeigleiste anklicken und danach auf das gewünschte Feld in unserer Anwendung klicken. Ändere die Eigenschaften der Knöpfe wie folgt:

    		Linker Knopf:
    		 	Name: key_OK
    		 	Randbreite: 7
    		 	Repertoire-Knopf: An_wenden
    		 	Beschriftung: OK
    		Rechter Knopf:
    		 	Name: key_Ende
    		 	Randbreite: 7
    		 	Repertoire-Knopf: _Beenden
    			Beschriftung: Ende

### Eigenschaften key_OK

gui3

In gleicher Weise fügen wir im oberen linken Feld unserer Anwendung ein Beschriftungsfeld ein. Im oberen rechten Feld ein Texteingabefeld . Ändere die Eigenschaften wie folgt:

    		Beschriftungsfeld:
    		 	Name: beliebig
    			Beschriftung: Dein Name:
    			Polsterung: 7
    		Eingabefeld:
    		 	Name: eingabe
    		 	Beschriftung: keine
    			Polsterung: 7

Nun stellen wir noch für alle Elemente (Knöpfe, Eingabefeld und Beschriftungsfeld) im Register Packen die Eigenschaft "Ausdehnend" und "Füllend" auf "Ja".

Signale der Objekte

Jetzt verbinden wir die Signale der Objekte "key_Ende" und "key_OK" mit zweckmäßigen Callback-Funktionen:

Dazu "key_Ende" anklicken. Dann im Eigenschaften-Fenster den Reiter Signale ([Signale]) wählen und unter dem Parameter Signal den Knopf ([...]) betätigen. Signal "clicked" mit Doppelklick auswählen. Der von Glade gewählte "Handler" "on_key_Ende_clicked" übernehmer wir unverändert. Dann mit ([Hinzufügen]) die beiden Parameter übernehmen.

### Signal von key_Ende

signal von key_ende

Mit dem Knopf "key_OK" verfahren wir in gleicher Weise.

Sollte Ihnen das Design unserer Anwendung noch nicht zusagen, so können Sie mit den verschiedenen Eigenschaften das Design verändern. Dazu sind unter der Registrierkarte ([Packen]) die Eigenschaften "Ausdehnend" und "Füllend" sowie "Randbreite" und "Polsterung" sehr nützlich. Soll beispielsweise unser Programmfenster in seiner Größe nicht veränderbar sein, so setzen Sie die Eigenschaft "Größe änderbar" des Widgets "window1" (Registrierkarte Widget) auf "Nein". Eine ebenfalls nützliche Hilfe ist die Darstellung der Widgets im Widgetbaum. Sie erhalten diese Ansicht durch das Menü: Ansicht Widgetbaum im Glade-Hauptfenster.

Nachdem alle Einstellungen gemacht sind, sollte unsere Programmoberfläche ungefähr wie hier gezeigt aussehen:

### Widgetbaum und fertige Programmoberfläche

Fertige Programmoberflaeche

Wenn Sie mit allem zufrieden sind schalten Sie auf das Glade-Hauptfenster und stellen sicher, dass die Option C-Code erzeugen aktiviert ist - das ist i.d.R. die Standard-Einstellung - (Glade-Hauptfenster: Menü: Datei Projekt Optionen... ), dann drücken Sie den Knopf ([Erstellen]) wodurch die GUI-Dateien erstellt werden und dann ([Speichern]) um diese dann auf die Festplatte zu schreiben. Dadurch werden einige Dateien im Quellcodeverzeichnis (src) unserer (Anjuta-)Anwendung verändert.

Wir beenden Glade und kehren zu Anjuta zurück um unser Programm "mit Leben zu füllen".

## Eingabe des Programmcodes

Nun, da wir zur Anjuta Entwicklungsumgebung zurückgekehrt sind, wollen wir unser Programm mal in Aktion betrachten. Dazu wählen wir im Menü: Generieren Generieren ) ([F11]) und dann Menü: Generieren Ausführen ) ([F3]).

### Unsere Anwendung beschäftigungslos

Fertige Programmoberflaeche Funktionalität hat unsere Anwendung freilich noch nicht; das kommt jetzt...

Im Projekt-Fenster sind auf der Registrierkarte Projekt alle wichtigen Quellcode-Dateien aufgelistet. Durch Doppelklick auf die gewünschte Datei (hier: callbacks.c) öffnet sich diese.

- Es ist einfacher und motivierender, wenn Dinge farbig sind. Darum ist in Anjuta "SyntaxHighlighting" und viele andere nützliche Dinge integriert. Nehmen Sie sich etwas Zeit und schauen Sie sich die vielfältigen Einstellungsmöglichkeiten an.

Im Quellcode von "callbacks.c" sind zwei callback-Funktionen: "on_key_OK_clicked()" und "on_key_Ende_clicked()". In der zweiten fügen wir den Funktionsaufruf "gtk_main_quit()" hinzu:

    	void
    	on_key_Ende_clicked (GtkButton *button, gpointer user_data)
    	{
    		gtk_main_quit();
    	}

Dadurch wird beim Klicken auf den Knopf [Beenden] unser Programm beendet.

Nur zu - versuchen Sie es: -> [Stgr] + [S], ->[F11], -> [F3]

In gleicher Weise fügen wir folgenden Code zur Funktion "on_key_OK_clicked()" hinzu:

    	void
    	on_key_OK_clicked (GtkButton *button, gpointer user_data)
    	{
    		/* Konstruktor Eingabefeld */
    		GtkWidget *eingabe = lookup_widget (GTK_WIDGET(button), "eingabe");

    		/* Name auslesen */
    		const char *text2 = gtk_entry_get_text (GTK_ENTRY(eingabe));
    		/* Anmerkung: An Stelle von char kann auch gchar benutzt werden */

    		/* Konstruktor MessageBox */
    		GtkWidget *msgbox = gnome_app_new("","");

    		/* String zusammenbasteln */
    		char text[88];
    		strcpy(text,"Hallo ");
    		strcat(text,text2);
    		strcat(text," :-)");

    		/* MessageBox anzeigen */
    		gnome_app_message (GNOME_APP(msgbox),text);
    	}

Nun können wir unser Werk speichern und zum spannensten Punkt schreiten...

-> [Stgr] + [S], ->[F11], -> [F3]

### Unsere Anwendung in voller Aktion

Laufendes Programm

:-)

## Erzeugen und ausführen des Programmcodes, Distribution erstellen

Den erfreulichsten Moment beim Entwickeln unseres Programms haben wir schon im letzten Kapitel genossen. Nun erstellen wir alle zu einer Distribution gehörenden Dateien: Menü: Generieren Alles generieren . Dies erzeugt die ausführbare Datei im src-Verzeichnis und die Dateien: viz., main.c, interface.c, support.c and callbacks.c. Üblicherweise wird dazu der gcc-Kompiler benutzt. Wenn alles ohne Fehlermeldungen abgeschlossen wird und das Austesten (Menü: Generieren Ausführen ) unseres Programms ebenfalls glücklich verläuft, dann freuen Sie sich darüber! Ihre Arbeit hat sich gelohnt!

Nun können Sie Ihr Programm in Ihr System installieren: Menü: Generieren Installieren . Dazu brauchen Sie aber i.d.R. auf verschiedene Verzeichnisse root-Rechte.

Bevor Sie Ihr Programm veröffentlichen, vergessen Sie nicht die Dateien TODO, ChangeLog, INSTALL und README auszufüllen. Um eine Distribution zu erstellen gehen Sie folgendermaßen vor: Menü: Generieren Distribution generieren . Es wird etwas dauern bis die Datei "hallo-0.1.tar.gz" im Verzeichnis "/home/(username)/Projects/hallo/" erzeugt ist. Wenn Sie diese Datei dann an einen guten Bekannten weitergeben, wird es sich zeigen ob sich die Mühe gelohnt hat ;-)

## Hinweise

Nun, dies ist nur eine einfache Einführung wie Anjuta zu benutzen ist. Aber wir hoffen, dass sie Anfängern auf dem Weg in die Programmierung hilfreich ist. Wir werden weiterführende Dokumentationen entwikeln und veröffentlichen. Der Originaltext wurde von einem 16-jährigen High School Studenten in Allahabad, Indien verfaßt. Er schreibt dazu: You may contact me with your suggestions at: ichattopadhyaya@hclinfinet.com. Mich können Sie freilich auch kontaktieren ufg@hosengummi.de - obwohl ich schon eher zu den EDV-"Fossilien" gehöre. Alle anderen Fragen welche nötig sind können an die Anjuta Mailing-Liste gestellt werden. Sie können sich auf der Anjuta-Webseite anjuta.sourceforge.net registrieren.

Good luck and enjoy Anjuta!