Konstantin Lübeck

Ich möchte in dieser Anleitung erklären, wie man unter Mac OS X mit Eclipse C++ Programme mit GTK erstellen kann.
Um überhaupt ein C/C++ Programm auf dem Mac kompilieren zu können braucht man die Compiler GCC und G++. Diese lassen sich leider nur über Umwege durch XCode installieren. Wenn man Apples eigene Entwicklungsumgebung noch nicht installiert hat, kann man dies über den Mac App Store nachholen (einfach nach Xcode suchen).

Nachdem Xcode erfolgreich installiert wurde kann man es einfach aus dem Programme-Verzeichnis starten (und anschließend eventuelle Begrüßungsmeldungen wegdrücken). Nun kann GCC und G++ installiert werden, dazu begibt man sich im Xcode-Menü zu Xcode -> Preferences, anschließend wählt man in diesem Fenster den Reiter Downloads und wählt in der Liste Command Line Tools zu Installation aus mit install.

Nachdem die Installation der Command Line Tools abgeschlossen wurde, sollte man im Terminal prüfen ob die Installation erfolgreich war. Ein Terminal kann man öffnen, indem man im Programme-Verzeichnis das Verzeichnis Dienstprogramme öffnet und dort das Programm Terminal startet. Anschließend gibt man nacheinander folgendes ein:

g++
gcc

Die Ausgabe sollte so aussehen:

Da Mountain Lion kein xquartz mehr mit an Bord hat muss man es händisch nachinstallieren (xquartz wird benötigt damit die grafische Oberfläche GTK unter Mac OS X gestartet werden kann). xquartz kann man unter der folgenden Adresse herunterladen: http://xquartz.macosforge.org/landing/
Um xquartz zu installieren muss man einfach das *.dmg öffnen und mit ein paar Klicks das Paket installieren. Nach der Installation von xquartz sollte man den Computer neustarten.

Nun kommt der schwierigste und längste Teil der Einrichtung, den es muss das Programm fink installiert werden. Hierzu läd man sich zuerst den Quellcode von fink runter, unter: http://sourceforge.net/projects/fink/ (hier nimmt man die derzeit aktuellste Version fink-0.34.7.tar.gz).
Das tar.gz-Archiv lässt sich anschließend mit einem Doppelklick im Download-Verzeichnis entpacken. Nachdem man das Archiv entpackt hat, muss man sich wieder in ein Terminal begeben und mit dem folgenden Befehl in das soeben entpackte fink-Verzeichnis wechseln.

cd ~/Downloads/fink-0.34.7

Wenn man sich im Verzeichnis befindet kann man fink über das Terminal installieren mit:

sudo ./bootstrap

Am Anfang fragt das Kommando sudo das Benutzerpasswort ab, dies sollte man eingeben ansonsten kann die Installation nicht ausgeführt werden. Danach werden dem Benutzer einige Fragen gestellt, diese sollte man sich durchlesen, aber meistens reicht ein einfaches ENTER-drücken für die Bestätigung der default-Werte.
Wenn die fink Installation abgeschlossen ist muss man noch die Pfade für fink im System setzen mit (Ich gehe hier davon aus, dass man sich während der Installation für das default-Verzeichnis /sw entschieden hat):

sudo /sw/bin/pathsetup.sh

Danach muss man noch eine Konfigurationsdatei ändern mit:

sudo nano ~/.bash_profile

Hier wird der Editor nano geöffnet. Mit den Pfeiltasten begibt man sich nun zum Ende der Datei und ergänzt die folgende Zeile:

source /sw/bin/init.sh

Mit drücken von [ctrl]+[o] wird die Datei gespeichert. Anschließend kann man nano wieder über drücken von [ctrl]+[x] verlassen. Damit die Änderungen an der Konfigurationsdatei wirksam werden muss man das Terminal schließen mit [cmd]+[q].

Nun kann ein neues Terminal geöffnet werden in welchem man fink verwenden kann. Als erstes sollte man ein Update der fink-Datenbank durchführen mit:

sudo fink selfupdate

(Das kann je nach Verbindungsgeschwindigkeit eine Weile dauern).
Wenn das Update erfolgreich beendet wurde, kann nun das Paket gtkmm2.4-gtk-dev installiert werden mit:

sudo fink install gtkmm2.4-gtk-dev

Nun werden alle benötigten Pakete für gtkmm heruntergeladen und kompiliert, das kann schonmal 1-2 Stunden dauern.

Nachdem die Installation von gtkmm abgeschlossen wurde, muss man noch einen Link im Dateisystem setzen damit später das Programm pkg-config aufgerufen werden kann. Dies macht man mit dem folgenden Befehl:

sudo ln -s /sw/bin/pkg-config /usr/bin

Nun kann das Terminal geschlossen werden.

Als nächstes fährt man mit der Installation von Eclipse fort. Eclipse kann man unter der folgenden Adresse herunterladen: http://www.eclipse.org/downloads/
Hier wählt man am besten Eclipse IDE for Java EE Developers (Juno 64Bit). Anschließend entpackt man das tar.gz-Archiv und zieht man das entpackte Verzeichnis eclipse in das Programme-Verzeichnis. Eclipse lässt sich starten über Eclipse (violette Kugel im Verzeichnis eclipse). Beim ersten Start wird man nach dem workspace gefragt, hier gibt man einfach ein Verzeichnis in welches Eclipse alle Daten ablegen soll (zB Dokumente/workspace). Anschließend sieht man eine Willkommensnachricht, diese kann man einfach ignorieren und schließen.
Nun muss das CDT-Plugin installiert werden, mit welchem Eclipse einem eine Umgebung für C/C++ Programme zur Verfügung stellt. Um dieses Pulgin zu installieren begibt man sich innerhalb von Eclipse zu: Help -> Install New Software...

Anschließend muss man im erscheinenden Dialog auf den Button Add... drücken und eine neue Downloadseite hinzufügen.
Name: CDT
Location: http://download.eclipse.org/tools/cdt/releases/juno

Mit drücken von OK wird die neue Downloadseite in die Datenbank eingetragen. Danach sucht wählt man CDT bei Work with aus, und setzt einen Haken bei CDT Main Features. Und drück auf Next.

Im Anschluss muss man nochmals auf Next drücken und zum Schluss müssen die Lizenzvereibarungen akzeptiert werden. Mit Finish wird das CDT-Plugin installiert.

Wenn die Installation erfolgreich war muss man Eclipse neustarten damit die Änderungen wirksam werden.

Nachdem Neustart kann die C/C++ Oberfläche aktiviert werden, dazu begibt man sich im Eclipse-Menü zu: Window -> Open Perspective -> Other....

Im folgenden Dialog wählt man C/C++ aus und beendet die Abfrage mit OK.

Nun kann man ein neues C++ Projekt anlegen mit: File -> New -> C++ Project.

Im folgenden Dialog muss man dem Projekt einen Namen geben (hier GtkTest) und unter Project Type: Makefile project -> Empty Project auswählen. Unter Toolchains wählt man MacOSX GCC aus. Die Erstellung des Projekts schließt man mit Finish ab.

Nun erscheint links im Project Explorer eine neues Projekt mit dem Namen GtkTest. Bevor man etwas programmieren kann muss noch der Pfad zu gtkmm-2.4 zum Projekt hinzugefügt werden, dazu begibt man sich im Eclipse-Menü zu: Project -> Properties.

Im Properties-Dialog navigiert man auf der linken Seite zu: C/C++ General -> Paths and Symbols. Anschließend wählt man im Reiter Includes unter Languages den Punkt GNU C++ aus.

Hier kann nun der Pfad zu gtkmm-2.4 über drücken von Add... hinzugefügt werden. Bei Directory gibt man folgendes ein: /sw/include/gtkmm-2.4/

Mit drücken von OK wird der Pfad dem Projekt hinzugefügt. Anschließen kann man den Properties-Dialog schließen mit OK. Der Hinweis kann mit drücken von Yes geschlossen werden.

Nachdem alle Einstellungen für das Projekt vorgenommen wurden, kann das Source File erstellt werden. Mit einem Rechtsklick auf den Projektname im Project Explorer wählt man New -> Source File.

Im folgenden Dialog gibt man der Datei den Namen main.cpp und schließt die Erstellung mit drücken von Finish ab.

Die Datei erhält den folgenden Inhalt:

#include <gtkmm.h>
 
int main(int argc, char *argv[]) {
	Gtk::Main kit(argc, argv);
	Gtk::Window window;
	Gtk::Main::run(window);
}

(Eclipse wird alles rot unterstreichen, aber das verschwindet nach ein paar Sekunden wenn GTK gefunden wurde.)

Zuletzt braucht man noch ein Makefile. Dieses erstellt man mit einem Rechtsklick auf den Projektnamen und anschließend wählt man: New -> File.

Im folgenden Dialog gibt man der Datei den Namen Makefile und schließt die Erstellung der Datei mit Finish ab.

Das Makefile bekommt im Anschluss folgenden Inhalt:

all: main.cpp
	g++ -v `pkg-config gtkmm-2.4 --cflags` -O0 -g3 -Wall -c -o main.o main.cpp
	g++ -v -o main.exe main.o `pkg-config gtkmm-2.4 --libs`
clean:
	rm -f main.exe main.o

(Es werden keine Hochkommata verwendet sondern Backticks: `).

Nun sind alle Dateien angelegt und das Programm kann kompiliert werden mit drücken des kleinen Hammers im Eclipse-Menü.
Anschließend kann man das Programm starten mit drücken des Run-Buttons:

Nun sollte im Dock ein X erscheinen und kurz darauf das Fenster des soeben erstellen Programms.

Diese Anleitung wurde mit Tims Unterstützung erstellt (http://podcastination.de/).

Dieses Werk bzw. Inhalt steht unter einer Creative Commons Namensnennung-Nicht-kommerziell 3.0 Unported Lizenz.

Möchte man in seiner awstats Auswertung Eine Tabelle anzeigen lassen die alle Zugriffe nach second level domain und top level domain (zB Host: http://subdomain.exmaple.de -> example.de) aufschlüsselt muss die folgendee Zeilen ans Ende seiner awstats.SERVERNAME.conf hinzufügen.

ExtraSectionName1="Provider"
ExtraSectionCodeFilter1="200 304"
ExtraSectionCondition1=""
ExtraSectionFirstColumnTitle1="Provider"
ExtraSectionFirstColumnValues1="HOST,(([\-a-z]+)\.([a-z]+))$"
ExtraSectionFirstColumnFormat1="%s"
ExtraSectionStatTypes1=PHB
MaxNbOfExtra1=50
MinHitExtra1=1

Anschließend wird am Ende der Auswertung eine weitere Tabelle angezeigt.

awstats: filter top level domain (tld) and second level domain

If you want to filter all accesses by top level (tld) and second level domain (e.g. http://subdomain.exmaple.de -> example.de), you have to put the following lines to the end of your awstats.SERVERNAME.conf file.

ExtraSectionName1="Provider"
ExtraSectionCodeFilter1="200 304"
ExtraSectionCondition1=""
ExtraSectionFirstColumnTitle1="Provider"
ExtraSectionFirstColumnValues1="HOST,(([\-a-z]+)\.([a-z]+))$"
ExtraSectionFirstColumnFormat1="%s"
ExtraSectionStatTypes1=PHB
MaxNbOfExtra1=50
MinHitExtra1=1

Then you can see a new table at the end of your analysis.

Dieses Werk bzw. Inhalt steht unter einer Creative Commons Namensnennung-Nicht-kommerziell 3.0 Unported Lizenz.

Wenn man ein git repository auf einem entfernten Server hat kann es ganz nützlich sein, dass bei jedem push die Versions- bzw. Build-Nummer um eins erhöht wird. Dies lässt sich leicht mit einem hook realisieren. Wenn man sein git repository auf dem Server mit dem folgenden Befehl angelegt hat:

git init --bare REPO_NAME

Dann findet man im Verzeichnis REPO_NAME.git diese Struktur:

REPO_NAME.git/
├── branches
├── config
├── description
├── HEAD
├── hooks
├── info
├── objects
└── refs

Für das Hochzählen der Versions/Build-Nummer ist das Verzeichnis hooks interessant. Im Verzeichnis hooks legt man eine Datei mit dem Namen post-receive an, und gibt dieser Datei noch Ausführrechte:

touch post-receive
chmod a+x post-receive

Das Script post-receive wird nun jedesmal ausgeführt wenn ein git push erfolgt.

Nun muss man noch ein kleines bash Script erstellen (außerhalb des repositorys) mit dem Namen increase_version.sh und dem folgenden Inhalt:

#!/bin/bash
 
# get current version
VERSION=$( cat $1 )
 
# increase version number
VERSION=$(( ${VERSION} + 1 ))
 
# write new version to file
echo ${VERSION} > $1

In der Variable $1 ist der Dateiname enthalten welcher beim Aufruf als Kommandozeilen-Parameter übergeben wird gespeichert. Anschließend wird der Inhalt der Datei in der Variable VERSION gespeichert. Im nächsten Schritt wird VERSION um eins erhöht. Zum Schluss wird der Inhalt der Datei überschrieben mit der neuen Versionsnummer. Da man das Script auch ausführen möchte braucht es natürlich auch Ausführrechte:

chmod a+x increase_version.sh

Jetzt muss noch eine Datei erstellt werden in welcher die Versions/Build-Nummer gespeichert wird. Es bietet sich an das diese Datei mit dem innerhalb von REPO_NAME.git erstellt wird. In die Datei sollte nun noch die aktuelle Version eingetragen werden:

touch version.txt
echo 1 > version.txt

Zum Schluss muss man den Aufruf von increase_version.sh noch in post-receive eingetragen werden, dazu erhält post-receive den folgenden Inhalt:

#!/bin/bash
 
/path/to/increase_version.sh /path/to/REPO_NAME.git/version.txt

Hier wird der dem Script increase_version.sh als Parameter der Pfad zu version.txt übergeben.

Dieses Werk bzw. Inhalt steht unter einer Creative Commons Namensnennung-Nicht-kommerziell 3.0 Unported Lizenz.

Wenn man mit Java arbeitet benötigt man meistens die unterschiedlichsten JAR Dateien um dem Programm gewisse Funktionalitäten zur Verfügung zu stellen.
Zuerst erstellt man ein Java Projekt in Eclipse. Anschließend begibt man sich in sein Workspace-Verzeichnis in das Verzeichnis welches genauso heißt wie das soeben erstellte Java Projekt.

cd ~/home/workspace/PROJEKTNAME

Innerhalb des Projektverzeichnisses erstellt man ein neues Verzeichnis namens lib

mkdir lib

In das Verzeichnis lib werden nun alle benötigten JARs abgelegt. Anschließend begibt man sich wieder in Eclipse und aktualisiert das Projekt mit Rechtsklick -> Refresh

Nun sieht man das Verzeichnis lib innerhalb seines Projekts.

Danach öffnet man die Projekteinstellungen mit Rechtsklick -> Properties:

Innerhalb des Einstellungsdialog begibt man sich zu Java Build Path und dort zu Libraries

Nun wählt man Add JARs... und öffnet den Projektordner und innerhalb von diesem das Verzeichnis lib. Nun kann man die zuvor hinzugefügt JARs auswählen und bestätigen mit OK. Danach kann man den Einstellungsdialog wieder schließen und die JARs sind dem Classpath hinzugefügt.

Dieses Werk bzw. Inhalt steht unter einer Creative Commons Namensnennung-Nicht-kommerziell 3.0 Unported Lizenz.

Wenn man häufig LaTeX Dokumente erstellt, wird es irgendwann lästig immer wieder alle \usepackage{} Anweisungen zu kopieren. Hierfür bietet es sich an eine eigene LaTeX-Klasse zu erstellen.
Zu erst muss man eine neue Datei mit dem LaTeX-Editor seiner wahl erstellen. Diese neuerstellte Datei erhält aber nicht wie üblich die Endung *.tex sondern die Endung *.cls für class. In die ersten Zeilen der Klassendatei schreibt man folgendes:

1
2
3
4

\LoadClass[12pt,oneside,a4paper]{article}
 
\NeedsTeXFormat{LaTeX2e}
\ProvidesClass{my_own_class}

Hierbei ist darauf zu achten, dass man in der Zeile 1 die Elternklasse (article) läd sowie die Parameter (12pt,oneside,a4paper) an die Elternklasse übergibt.
In der Zeile 3 wird eingetragen welche LaTeX-Version für diese Klasse benötigt wird.
In der Zeile 4 wird noch der Name der Klasse angeben, dabei ist darauf zu achten dass der Name der Klasse sowie der Dateiname gleich sind, also my_own_class.cls als Dateiname und \ProvidesClass{my_own_class} in der Klassendatei.
Unterhalb von \ProvidesClass{my_own_class} können nun die \usepackage{} Anweisungen eingetragen werden, sowie die Definition weiterer Befehle mit \newcommand{} und alles andere was sich normalerweise über der \begin{document} Anweisung innerhalb der *.tex befindet.

5
6
7
8
9
10

\usepackage[left=2.5cm,right=2.5cm,top=1.5cm,bottom=2cm,includeheadfoot]{geometry}
 
\usepackage[ngerman]{babel}
\usepackage[utf8]{inputenc}
 
\newcommand{\aufgabe}{\refstepcounter{aufgabe}{\noindent\large \bfseries Aufgabe~\arabic{aufgabe}}}

Die Klasse kann nun im Kopf der *.tex Datei oberhalb von \begin{document} aufgerufen werden über:

\documentclass{my_own_class}

In der Anweisung \documentclass{PATH} wird der absolute oder relative Pfad zur Klassendatei angegeben. Hierbei ist darauf zu achten dass man beim Name der Klasse am Ende das *.cls weglässt. Im obigen Beispiel befindet sich die Klassendatei my_own_class.cls selben Verzeichnis wie die *.tex Datei.

Wenn man nicht immer den Pfad zur Klassendatei angeben möchte kann man diese auch in das “Klassenverzeichnis” von LaTeX verschieben. Unter Linux lässt sich das Klassenverzeichnis leicht über den Befehl locate herausfinden, zuvor muss aber ein Suchdatenbank Update durchgeführt werden mit updatedb.

sudo updatedb
locate article.cls

In der obenstehenden Befehlsanweisung wird nach der Datei article.cls gesucht, diese Befindet sich im Klassenverzeichnis von LaTeX. Wenn man das Verzeichnis gefunden hat kann man seine eigenen Klassendateien in dieses Verzeichnis verschieben. Nachdem man die seine eigene Klasse in das Klassenverzeichnis verschoben hat, muss man noch das Programm texhash ausführen damit die Klasse beim kompilieren gefunden werden kann.

sudo texhash

Nun kann man die Klasse im *.tex Dokument nur mit dem Namen und ohne Pfadangabe über \documentclass{} aufrufen.

Dieses Werk bzw. Inhalt steht unter einer Creative Commons Namensnennung-Nicht-kommerziell 3.0 Unported Lizenz.