ubuntuusers.de

Anjuta

Archivierte Anleitung

Dieser Artikel wurde archiviert. Das bedeutet, dass er nicht mehr auf Richtigkeit überprüft oder anderweitig gepflegt wird. Der Inhalt wurde für keine aktuell unterstützte Ubuntu-Version getestet. Wenn du Gründe für eine Wiederherstellung siehst, melde dich bitte in der Diskussion zum Artikel. Bis dahin bleibt die Seite für weitere Änderungen gesperrt.

./anjuta_logo.png Anjuta 🇬🇧 ist eine vollständige Entwicklungsumgebung (IDE) für den GNOME-Desktop, die mit vielen Programmiersprachen (C, C++, Python, Java ...) zurecht kommt. Sie kann durch Plugins beliebig erweitert werden, allerdings wird aufgrund der Fülle an Plugins nur auf eine Auswahl eingegangen.

Diese Seite soll helfen, mit dieser IDE vollständige Programme zu erstellen. Dabei wird erklärt, wie Bibliotheken zu einem Projekt richtig hinzugefügt werden, eine grafische Oberfläche für GTK+ mit dem Glade-Plugin erstellt und aus diesem Programm ein Paket gemacht wird. Des Weiteren wird sich das Beispielprogramm bei der Installation automatisch ins GNOME-Menü integrieren.

Dieser Artikel bezieht sich auf die Programiersprache C, allerdings lässt sich die Arbeitsweise auf die meisten anderen Programmiersprachen fast eins zu eins übertragen.

Voraussetzung

Hier eine Auswahl der wichtigsten Pakete, die generell zur Software-Entwicklung in der Sprache C benötigt werden:

  • build-essential

  • autogen

  • automake

  • libtool

  • libglade2-dev

  • libgtk2.0-dev

  • libgnome2-dev

  • libgtk2.0-doc

  • libgnome2-doc

  • intltool

Paketliste zum Kopieren:

sudo apt-get install build-essential autogen automake libtool libglade2-dev libgtk2.0-dev libgnome2-dev libgtk2.0-doc libgnome2-doc intltool 

Oder mit apturl installieren, Link: apt://build-essential,autogen,automake,libtool,libglade2-dev,libgtk2.0-dev,libgnome2-dev,libgtk2.0-doc,libgnome2-doc,intltool

Diese Liste kann je nach Bedarf ggf. noch erweitert werden.

Installation der Entwicklungsumgebung

Installation aus den Ubuntu-Quellen

Es wird einfach das nachfolgend genannte Paket installiert [1]:

  • anjuta (universe [2])

Paketliste zum Kopieren:

sudo apt-get install anjuta 

Oder mit apturl installieren, Link: apt://anjuta

Wer dazu eine umfangreiche Hilfe möchte, installiert ebenfalls

  • devhelp

Paketliste zum Kopieren:

sudo apt-get install devhelp 

Oder mit apturl installieren, Link: apt://devhelp

Für grafische Oberflächen eignet sich

  • glade (universe)

Die Anwendungen können anschließend über das GNOME-Startmenü aufgerufen werden.

Lässt sich Anjuta nicht erfolgreich starten, hilft es unter Umständen, wenn im persönlichen Ordner das versteckte Verzeichnis .anjuta gelöscht wird, sofern dieses noch aus einer früheren Installation stammt.

Installation aus dem Quellcode

Für die Kompilierung der Programme werden folgende Pakete benötigt:

  • libbonoboui2-dev

  • libgnomeui-dev

  • libwnck-dev

  • firefox-dev

  • libgnomeprint2.2-dev

  • libgnomeprintui2.2-dev

  • libvte-dev

  • libxslt1-dev

  • libpcre3-dev

  • binutils-dev

Paketliste zum Kopieren:

sudo apt-get install libbonoboui2-dev libgnomeui-dev libwnck-dev firefox-dev libgnomeprint2.2-dev libgnomeprintui2.2-dev libvte-dev libxslt1-dev libpcre3-dev binutils-dev 

Oder mit apturl installieren, Link: apt://libbonoboui2-dev,libgnomeui-dev,libwnck-dev,firefox-dev,libgnomeprint2.2-dev,libgnomeprintui2.2-dev,libvte-dev,libxslt1-dev,libpcre3-dev,binutils-dev

Für die Installation wird der aktuelle Quellcode von der Projektseite 🇬🇧 herunterladen.

Folgende zusätzliche Pakete müssen ebenfalls auf der Anjuta-Seite als Quelltext heruntergeladen 🇬🇧 dann entpackt [4] und kompiliert [6] werden, falls die Pakete in den Quellen zu alt sind.

  • gdl

  • gnome-build

  • glade3

  • devhelp

Erst danach kann man das eigentliche Anjuta-Paket kompilieren [6] und installieren. Wenn alles geklappt hat, erscheint jetzt im GNOME-Menü unter "Programmierung" der Eintrag "Anjuta - IDE".

Ein neues Projekt erstellen

Der Umgang mit der Anjuta-Oberfläche soll an einer Hello-World-Anwendung gezeigt, welche immer mehr ausgebaut wird.

"Datei → Neu → Projekt" öffnet den Druiden, der hilft, das neue Projekt einzurichten. Dieser wird kurz darauf geöffnet und enthält auch eine Beschreibung über den Zweck des Programms. Als nächstes wird der Typ ausgewählt. In diesem Fall erstellt "Generic" eine Vorlage mit grundlegenden Dateien zur Dokumentation, Kompilierung und einer Quelltextdatei mit einer Minimalroutine.

Im nächsten Dialog werden Daten hinzugefügt, welche das Projekt näher beschreiben.

  • Der Name des Projekts sollte in diesem Falle tutor heißen.

  • Unter "Destination" wird das Verzeichnis eingetragen, in welchem das Projekt gespeichert werden soll.

  • Falls schon vorher bekannt ist, welche Bibliotheken verwendet werden sollen, kann man "Configure external package" auf "Ja" stellen.

Im letzten Schritt beim Konfigurieren der externen Pakete steht u.a. für den Eintrag gtk+-2.0 >= 2.10.6. Daher wird der ./configure - Aufruf dem Benutzer später eine Fehlermeldung geben, falls die installierte Version kleiner als 2.10.6 ist. Dazu später mehr im Abschnitt Bibliotheken hinzufügen.

Folgende Bildserie veranschaulicht den Vorgang:

druide_2.png
Projekttyp

druide_3.png
Basisinformationen

druide_4.png
Projektoptionen

druide_5.png
externe Pakete konfigurieren

Programm erstellen, kompilieren und ausführen

Jetzt wird erst einmal automatisch ./autogen.sh beziehungsweise ./configure ausgeführt und es erscheinen mehrere Meldungen im unteren Bereich von Anjuta. Falls dies nicht der Fall sein sollte, kann man auch auf "Generieren → Run Autogenerate" klicken. Wenn man etwas an den Compiler oder Linkereinstellungen verändert (z.B. Bibliotheken einfügen), sollte man diesen Befehl erneut aufrufen. Denn das autogen-Skript erzeugt die Dateien für den Befehl ./configure welcher wiederum die Dateien für make bereitstellt.

Links im Bild sieht man den Projektbaum (im Projekt-Tabulator). Ein Doppelklick auf main.c unter dem Ast "tutor" präsentiert die Anwendung. In dem Quelltext steht bislang nur der Befehl zur Textausgabe:

1
2
3
4
5
6
#include <stdio.h>
int main()
{
        printf("Hello world\n");
        return (0);
}

Um die Anwendung zu kompilieren kann man auf "Erstellen → Compile" klicken oder F9 drücken. Der Compiler meldet im Ausgabefenster "succesfull!" Der Befehl zum Kompilieren [6] nennt sich make und kann natürlich auch wie gewohnt manuell im Terminal aufgerufen werden.

Gestartet wird das Programm mit "Ausführen → Ausführen" oder F3 . Zum Starten im Terminal würde man ohne grafische Oberfläche einfach ./tutor verwenden. Nach Start des Programms öffnet sich ein Terminalfenster mit folgender Ausgabe:

Hello world 

Bibliotheken hinzufügen

Um unter Anjuta eine Bibliothek hinzuzufügen, gibt es mehrere Möglichkeiten auf die im Folgenden kurz eingegangen wird.

pkg-config

anjuta_project_properties.png
Projekt-Eigenschaften

Wenn die gewünschte Bibliothek von pkg-config unterstützt wird, hat man in der Regel leichtes Spiel. Dann überprüft ein Makro welche Version vorhanden ist und gibt einem die entsprechenden Pfade für die Konfiguration zurück. Möchte man eine Liste der unterstützten Pakete haben und dann anschließend erfahren, welche Version dieses Pakets auf dem System installiert ist, so kann man das im Terminal durch folgende Befehle erreichen:

pkg-config --list-all
pkg-config gtk+-2.0 --modversion 

Unter Anjuta klickt man dazu auf "Project → Properties" und dann auf den Reiter "Packages". Um nun eine neue Bibliothek einzufügen, klickt man als erstes auf "Add module" mit dem Namen TUTOR. Der Name ist eine Art Variable, die die Information über die Bibliotheken enthalten soll. Mit "Add Package" kann man dann die Bibliothek zur Liste hinzufügen. Falls eine Versionsüberprüfung erwünscht ist, trägt man noch in der rechten Spalte >= Versionnummer ein. Wobei statt dem Wort Versionsnummer die entsprechende Zahl eingegeben werden muss.

Durch diesen Schritt wird veranlasst, dass die zwei Variablen $(TUTOR_CFLAGS) und $(TUTOR_LIBS) erzeugt werden und diese entsprechenden Optionen für den Compiler und den Linker enthalten.

anjuta_flags_dialog.png
Gruppen-Eigenschaften

Um dem Compiler dies mitzuteilen klickt man mit linke Maustaste auf "src → Properties" im Projekt - Fenster. Dort ergänze man zu den vorhanden Einträgen $(TUTOR_CFLAGS). Diese Variable enthält die Pfade, die man auch mit dem Befehl pkg-config gtk+-2.0 --cflags erhalten würde.

anjuta_libs_dialog.png
Ziel-Eigenschaften

Für den Linker ist die Prozedur sehr ähnlich. Allerdings klickt man hier stattdessen auf den Programmnamen, in diesem Fall "tutor → Properties" im Projekt - Fenster. Dort ergänzt man den Eintrag $(TUTOR_LIBS) unter "Libraries". Die Variable enthält die Pfade, die man auch mit dem Befehl pkg-config gtk+-2.0 --libs erhalten würde.

An der Stelle wird noch kurz erklärt, was Anjuta intern in den Dateien verändert hat. Die wichtigste Dateien, von Automake / Autoconf sind configure.ac und Makefile.am. Man kann diese Dateien ohne Probleme in Anjuta öffnen und editieren. Die IDE erkennt selbständig Änderungen und bessert automatisch die Menüeinstellungen aus. Zunächst einmal wurde in die configure.ac folgendes Makro eingefügt:

1
2
3
PKG_CHECK_MODULES(TUTOR, gtk+-2.0 >= 2.10.6 libglade-2.0 >= 2.6.0) 
AC_SUBST(TUTOR_CFLAGS)
AC_SUBST(TUTOR_LIBS)

Das bedeutet salopp ausgedrückt: Überprüfe ob gtk+-2.0 und libglade-2.0 in den richtigen Versionen vorliegen und fülle die Variablen $(TUTOR_CFLAGS) und $(TUTOR_LIBS) mit den entsprechenden Werten.

In der Datei src/Makefile.am findet man die Ausdrücke TUTOR_CFLAGS- und TUTOR_LIBS-Variable wieder, die dem Compiler und dem Linker die Pfade und Bibliotheken mitteilen:

1
2
3
4
5
6
7
INCLUDES = \ 
        -DPACKAGE_LOCALE_DIR=\""$(prefix)/$(DATADIRNAME)/locale"\" \
        -DPACKAGE_SRC_DIR=\""$(srcdir)"\" \
        -DPACKAGE_DATA_DIR=\""$(datadir)"\" \
        $(TUTOR_CFLAGS)
tutor_LDADD = \
        $(TUTOR_LIBS)

Jetzt muss nur noch autogen.sh ausgeführt werden. Das erreicht man durch "Generieren → Run autogenerate". Damit sind die die Bibliotheken richtig zum Projekt hinzugefügt und man kann sich ganz dem Programmieren widmen.

m4-Skript

Diese Art eine Bibliothek hinzuzufügen ist nicht viel komplizierter. Man sollte sich dennoch damit beschäftigen, da es relativ viele Bibliotheken gibt, die pkg-config nicht beherrschen (z.B. wxWidget, SDL, ... ). Die meisten Bibliotheken installieren eine Makrodatei mit der Endung .m4 ins Verzeichnis /usr/share/aclocal Öffnet man die entsprechende Datei, so wird meist am Anfang erklärt, wie dieses Makro mit automake zu benutzen ist. Zum Beispiel trägt man, wenn man die SDL-Bibliothek benutzen will, folgendes Makro in die Datei configure.ac des Projektes ein:

1
2
3
4
5
6
7
dnl Checks for libraries. 
dnl Check for SDL
SDL_VERSION=1.2.0
AM_PATH_SDL($SDL_VERSION,
            :,
            AC_MSG_ERROR([*** SDL version $SDL_VERSION not found!])
)

Dieses Makro überprüft die Version und legt die Variablen $(SDL_CFLAGS) und $(SDL_LIBS) an. Diese müssen wie bei der pkg-Methode dem Compiler und dem Linker mitgeteilt werden. Dies funktioniert analog zur oben beschriebenen Methode.

Danach sollte wieder autogen.sh ausführt oder auf "Generieren → Run Autogenerate" geklickt werden.

Experten-Info:

Es gibt verschiedene Möglichkeiten, die das Einfügen solcher Bibliotheken erleichtern:

  • Einen Assistenten schreiben, der das Konfigurieren übernimmt und die entsprechenden Zeilen automatisch in die Dateien einfügt, wenn man den Anwendungsdruiden ausführt. Hier könnte man sich als Beispiel den wxWidgets Wizard genauer ansehen.

  • Das Macro Plugin aktivieren ("Einstellungen → Plugins") und für Bibliotheken entsprechende Makros erstellen.

  • Selbst ein Plugin für Anjuta entwickeln. Informationen dazu gibt es in der Anjuta Entwicklerdokumentation 🇬🇧

Direkte Pfadangabe

Achtung!

Diese Methode scheint am einfachsten, ist jedoch problembehaftet, eher unsauber und daher wenn möglich zu vermeiden.

Man kann natürlich die Bibliotheken auch einfach hinzufügen, indem man auf "src → Properties" klickt und sdl-config --cflags oder die direkten Pfade -I/usr/include/SDL -D_GNU_SOURCE=1 -D_REENTRANT einfügt. Dasselbe gilt für die Linkereinstellungen, in diesem Fall sdl-config --libs oder -L/usr/lib -lSDL -lpthread unter "tutor → Properties"

Diese Methode funktioniert zwar auch, führt aber keine Versionsüberprüfung durch. Außerdem werden die Pfade nicht automatisch eingestellt. Es wird dann beim configure-Prozess kein Hinweis ausgegeben, dass die Bibliothek fehlt oder der Pfad nicht gefunden wurde. Beim Kompilieren werden dann teilweise kryptische Fehlermeldungen ausgegeben, die schwer zu interpretieren sind.

Grafische Oberfläche erstellen

gtk_linker.png
Ziel-Eigenschaften

Mit Anjuta kann man zusammen mit dem Glade-Plugin auch komplette graphische Oberflächen auf eine sehr kompfortable Art und Weise erstellen.

Vorbereitungen

Damit Autoconnect Signale automatisch mit ihrer entsprechenden Callback-Funktion verbunden werden, muss die Linkereinstellungen noch um die Option -export-dynamic erweitert werden.

Glade Datei erstellen

Das Glade-Interface-Designer-Widget findet man unter "Datei → Neu → Glade File". Es gibt hier vier wichtige Bereiche:

Glade-Interface-Designer
Fenstername Erklärung
Palette Dieser Bereich enthält alle Steuerelemente (Buttons, Textwidget,...)
Designer Eine Art graphischer Editor, in den die Steuerelemente gezogen werden können.
Widgets Alle Elemente (Buttons, Window, Container, ...) heißen Widgets. Die Elemente, die im Designer sichtbar sind, sind hier in einer Baumstruktur angeordnet und können ausgewählt werden um ihre Eigenschaften zu verändern
Properties Im Eigenschaftsfenster kann man jedem Widget z.B.. Signale (linke Maustaste auf Button), Größe usw. zuordnen

Für unser Beispiel bauen wir nun folgende Oberfläche:

glade_interface_designer.png
Glade-Interface-Designer
  • "Toplevels → Neues Fenster" ./neues_fenster.png

  • "Containers → Vertical Box" ./vertical_box.png (Anzahl der Elemente: 2)

    • Oberer Teil des Containers:

      • "Control and Display → Label" ./label.png (unter "Properties: General → Beschriftung": Dies ist ein Text)

    • Unterer Teil des Containers:

      • "Containers → Horizontal Button Box" ./horizont_button_box.png (Anzahl der Element 2, unter "Properties: Anordnungsstil → Spread")

        • Linke Seite und rechte Seite jeweils eine Schaltfläche ./button.png einfügen

Jetzt noch ein paar Signale zuordnen, die beim linke Maustaste auf die Schaltflächen ausgelöst werden sollen:

Signal Handler
"window1: Properties → Signals → Gtk-Widget → delete-event" gtk_main_quit
"button1: Properties → Signals → GtkButton → clicked" on_button1_clicked
"button2: Properties → Signals → GtkButton → clicked" on_button2_clicked

Wenn alles so aussieht wie auf dem Bild rechts, muss das Glade Projekt nur noch gespeichert mittels "Glade → Save as" gespeichert werden. Als Dateinamen tutor.glade wählen und sie im /src - Verzeichnis speichern. Dannach wird das Glade-Plugin über "Glade → Close" beendet.

Dateien zum Projekt hinzufügen

Die erzeugte Glade Datei muss jetzt noch zu diesem Projekt hinzufügt werden, schließlich will man ja, dass die Datei beim Installieren des Programms auch mit installiert wird. Wenn man eine neue Datei zu einem Projekt hinzufügen möchte (dies gilt auch für andere Dateien, wie z.B. Icons), geht man folgendermaßen vor:

add_target.png
Add Target

new_target.png
Target Glade erzeugen

add_source_file.png
Add Source File

add_source.png
tutor.glade hinzu fügen

Im Projekt Fenster auf "src" klicken und dann auf "Add Target". Dieses Zielen wird nun Glade genant. Der "Target Type" ist: Miscellaneous Data. Danach wird die Glade-Datei tutor.glade zum Ziel Glade mittels "Glade → Add Source File" hinzu gefügt.

group_prop.png
Gruppen-Eigenschaften

Jetzt muss nur noch der Installationspfad für dieses Ziel angegeben werden: Dazu geht man auf "src → properties". Hier werden die "Group properties" angezeigt. Unter Glade trägt man dann $(datadir)/tutor/glade ein.

Der Quelltext zu diesem Beispiel

Diesen Quelltext kann man in die main.c kopieren. Danach musst nur noch auf "Generieren → Generieren" klicken und das Programm ausführen. Dabei wird ein Fenster mit zwei Buttons geöffnet. Wenn man auf einen der Button klickt erscheint im Terminal button1 oder button2. Das Programm sollte selbsterklärend sein. Wenn man genauere Informationen über die Befehle erfahren möchte, schaut man die GTK - Referenz an.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <stdio.h>
#include <config.h>
#include <gtk/gtk.h>
#include <glade/glade.h>
void on_button1_clicked(GtkButton*button,gpointer user_data) // Callback Funktion
{
     g_print("button1\n");
}
void on_button2_clicked(GtkButton*button,gpointer user_data) // Callback Funktion
{
     g_print("button2\n");
}
//Wenn das Programm installiert wird, sollte man die folgende
//Zeile auskommentieren
//#define GLADE_FILE PACKAGE_DATA_DIR"/tutor/glade/tutor.glade"
#define GLADE_FILE "tutor.glade"
GtkWidget* create_window (void)
{
     GtkWidget *window;
     GladeXML *gxml;
     gxml = glade_xml_new (GLADE_FILE, NULL, NULL); // Glade Datei laden
     glade_xml_signal_autoconnect (gxml); // Signale mit Callback- Funktionen verbinden z.B. on_button1_clicked
     window = glade_xml_get_widget (gxml, "window1"); // Nach Widget window1 suchen und dem Pointer window zusweisen
     return window;
}
int main (int argc, char *argv[])
{
     GtkWidget *window;
     gtk_init (&argc, &argv); // Gtk Initialisieren
     window = create_window (); // Window erstellen mit der Glade Datei
     gtk_widget_show (window);  // Window anzeigen
     gtk_main (); // Repeat schleifen - Wartet auf Signale z.B. Button klicken ...
     return 0;
}

GNOME Menüeintrag erstellen

Nett wäre es jetzt noch, wenn sich unser Programm beim Installieren direkt ins GNOME-Menü integrieren würde. Mit Anjuta ist das auch gar nicht schwer und es lässt sich auch mit dem bisher Gelernten erreichen:

Zuerst erstellt man ein weiteres Target mit dem Namen "Desktop_Menu" (Typ: Miscellaneous Data) und fügt eine neue Datei zum Projekt hinzu der man den Namen tutor.desktop gibt. Das alles geht analog zur obigen Anleitung: Dateien zum Projekt hinzufügen.

Da Menüeinträge im Normalfall durch ein spezifisches Icon gekennzeichnet werden, ist es sinnvoll, dass man seinem Programm ebenfalls eines spendiert. Wer möchte kann zu Testzwecken dieses ./tutor.png verwenden. Das Icon kopiert man nach src/tutor.png und fügt die Datei zum Target "Desktop_Icon" hinzu, nachdem man es erzeugt hat.

Die Installationspfade unter Group Properties:

Installationspfade
Name Pfad
Desktop_menu $(datadir)/applications
Glade $(datadir)/tutor/glade
Desktop_Icon $(datadir)/pixmaps

Die Datei tutor.desktop könnte z.B. folgendermaßen aussehen:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
[Desktop Entry] 
Version=0.1
Name=Tutor Version 0.1
Comment=Testanwendung
Exec=tutor
Icon=tutor
Terminal=true
Type=Application
Categories=GNOME;GTK;Application;AudioVideo;
StartupNotify=true

Wenn man das Programm jetzt mit make install oder über "Generieren → Install Projekt" installiert, wird ein neuer Menüeintrag mit dem Namen "Tutor" und dem gewählten Icon unter "Anwendungen → Unterhaltungsmedien" erscheinen.

Source Paket und Ubuntu Paket erstellen

Quellcode weitergeben

Programme unter Linux werden oft als gepackter Quellcode mit der Dateibezeichnung "Name-Version.tar.gz" weitergeben. Dies hat den Vorteil, dass das Programm auf anderen Computern weiterbearbeitet werden kann. Darüber hinaus ist es so auch dadurch möglich Programme auf Nicht-Debian-Systemen zu installieren.

Um die Datei tutor-0.1.tar.gz zu erzeugen, gibt man im Terminal [3] den Befehl

make dist 

ein. Unter Anjuta erreicht man dies durch "Generieren → Build Tarball". Hierbei werden werden nur die Dateien gepackt, die notwendig für die Ausführung des Programms sind. Unwichtiges, wie Objektleichen oder Notizdateien werden weg gelassen. Damit das Make-System die hinzugefügten Dateien als notwendig erkennt, wird in der Datei src/Makefile.am folgendes ergänzt:

1
2
3
4
EXTRA_DIST = \ 
$(Desktop_Menu_DATA) \
$(Glade_DATA) \
$(Desktop_Icon_DATA)

und in der Datei Makefile.am:

1
2
3
EXTRA_DIST = \ 
$(tutordoc_DATA) \
tutor.anjuta

Das Beispielprogramm kann jetzt z.B. hier heruntergeladen werden: http://media.ubuntuusers.de/wiki/attachments/13/28/tutor-0.1.tar.gz

Hinweis:

Bevor das Programm mit make install installiert wird, sollte die Zeile 15 in der main.c auskommentiert und die Zeile 16 gelöscht werden, da sonst die Glade-Datei nicht im richtigen Verzeichnis gesucht wird.

Debian Paket erstellen

Debian Pakete haben gewöhnlich die Dateiendung .deb und sollen jedem die einfache Installation deines Programms ermöglichen. Da Ubuntu ein Derivat von Debian ist, finden sie auch hier Verwendung. An dieser Stelle wird auf den Artikel Ubuntu-Pakete erstellen im Wiki verwiesen, in dem dieses Thema sehr ausführlich besprochen wird.

Fehler

Obwohl Anjuta 2.1 schon sehr stabil läuft, enthält es trotzdem noch einige Fehler und stürzt hin und wieder ab. Es kommt hin und wieder vor, dass Anjuta beim Eintragen des Installationspfades in die Datei Makefile.am am Ende des Pfades ein Leerzeichen zuviel einträgt. Das führt dazu, dass z.B. die .desktop-Datei nicht ins richtige Verzeichnis installiert wird.

Entwicklungsumgebungen

Toolkits

Autoconf und Automake

Tutorials zu dem Thema:

Literatur

Diese Revision wurde am 26. Juli 2018 23:19 von Beforge erstellt.
Die folgenden Schlagworte wurden dem Artikel zugewiesen: Programmierung, GNOME