Programmieren in C++ – Teil 2

- zu Programmieren in C++ – Teil 1 ->

Deklaration

Bei einer Deklaration wird eine Variable festgelegt, dabei ist entscheidend welchen Datentyp sie hat und optional kann man einen Startwert angeben.

int meineZahl = 5

<Datentyp> <Variablenname> = <Startwert>

Bedingungen:

Die bekannteste Bedingung, auch Verzweigung genannt, ist die IF-Abfrage:

if ( password == "Hallo" )
{
    //wenn der Fall zutrifft
}else{
   //wenn der Fall NICHT zutrifft
}

Die Switch’n’Case Mehrfachverzeigung

Die Variable „wert“ darf nur int, long, short oder char sein.

swich(wert)
{
    case 1:  // Anweisungen für 1
                break;
    case 2:  //Anweisungen für 2
                break;
    case 3:  //Anweisungen für 3
                break;
    default:  //Anweisung für andern Wert
                break;
}

Schleifen:

Schleifen werden verwendet um oft verwendete Anweisungen bzw. Befehle einfach zu wiederholen, ohne es im Quellcode mehrfach kopieren zu müssen.

Man unterteilt die Schleifen in 3 Arten:

Kopfgesteuerte Schleife:

while( BEDIGNUNG )
{
     //Aktionen
}

Fußgesteuerte Schleife:

do{
    //Aktionen
}while( BEDINGUNG )

Zählschleife:

for ( int i = 0; i < 70; i++)
{
    //Ausführung die 70 Mal erfolgt
}

Compiler

Das wichtigste Element, bei dem erstellen von Programmen. Denn der Compiler wandelt unseren Quellcode um, in einen Maschinencode. Dieser Maschinencode ist dann auf den jeweiligen Prozessor abgestimmt und kann nur auf der ausgewählten Architektur laufen. Eine Architekturist somit von dem verwendete µControler abhängig.

Der Compiler weist auch auf Fehler im Quelltext hin, die nach verschiedenen Kriterien sortiert werden:

Lexikalische Analyse: Überprüft ob Sonderzeichen im Quellcode verwendet werden, die nicht zugelassen sind, wie z. B. „ä“ , „ö“ , „ü“ und „ß“.

Syntaktische Analyse: Untersucht ob alle Syntaxrichtlinien eingehalten worden sind. Darunter fällt z. B., dass jede geöffnete Klammer „{“ eine geschlossene Klammer „}“ hat.

Semantische Analyse: Vergleicht ob die Inhalte der Bibliotheken, Module und Datentypen richtig verwendet wurden.

Benjamin Salchow

MySQL – Dort wo es verwendet wird!

Nun hatten wir schon einen kleinen Einblick, was MySQL ist und wie die Befehle in der Datenbank verarbeitet werden. Eine Menge Theorie, aber wofür brauchen wir das Ganze?

MySQL begegnen wir öfters als wir denken

Sei es auf E-Bay oder auf Google.de, überall stecken Datenbanken im Hintergrund, die unsere gewünschten Informationen anzeigen.

Bei E-Bay z. B. werden Datenbanken verwendet, um die alle möglichen Auktionen zu speichern und nur gewählte auf Wunsch anzeigen zu können.

Das Old-School Webseiten entwickeln ist ausgestorben. Statische Seiten gehören mehr oder weniger der Vergangenheit an, selbst diese Seite, auf der Du dich gerade befindest, funktioniert mittels einer MySQL 5.2 Datenbank. Die Datenbank beinhaltet von jedem Artikel den Inhalt mit allen Einstellungen. Im HTML-Bereich wird NUR das grundlegende Design bereitgestellt. Alles andere wird mittels PHP eingefügt aus den Informationen der Datenbank.

Der Vorteil

Mittels einer Änderung in der Datenbank, gilt dies für meine gesamte Webseite.

Durch das Dynamische erzeugen, kann ich somit mit wenigen Schritten, neue Unterseiten bzw. Artikel erstellen, ohne eine neue HTML-Datei anlegen zu müssen.

Anwendungsbereich neben Webseiten

Nicht nur Webseiten nutzen und schätzen die MySQL Datenbank, auch viele Programme verwenden diese.

Normalerweise werden in Programmen Dateien gespeichert, die Deine Informationen beinhaltet, aber oft kann es ja sein, dass diese Datei nicht nur du bearbeiten möchtest.

Wenn also mehrere Benutzer eine Datei bearbeiten wollen, dann gibt es einen Fehler. Durch eine Datenbank können mehrere Benutzer zur gleichen Zeit die Datenbank bearbeiten, solange sie nicht den gleichen Eintrag (ZELLE) bearbeiten.

Wie gehts weiter mit dem Tutorial?

Wir werden uns in den kommenden Tutorials anschauen, wie ein SQL-Befehl aufgebaut ist und wie Du damit dein Abfrageziel erreichen kannst.

MySQL – der einfache Einstieg

Datenbanken werden immer notwendiger, sei es für eine dynamische Webseite mit PHP oder in Anwendungen, die mit einer Datenbank zusammenarbeiten.

Eine etablierte Datenbankarchitektur ist SQL, genaugenommen ist SQL aber eher eine “Programmiersprache” mit der man Informationen aus der Datenbank filtern, bearbeiten, löschen und erstellen kann.

Von Sun gibt es MySQL, aber auch Microsoft hat eine SQL Datenbankserveranwendung namens MS SQL auf dem Markt gestellt.

Der grundlegende Aufbau einer MySQL Datenbank

Mittels eines Querys (SQL) wird eine Anfrage zur Datenbankengine gestellt und diese Verarbeitet die Information und gibt diese wieder zurück.

SQL-Befehlsschema

Hier ist ein Schema des vollen SQL-Befehls, jeder Schritt brauch Zeit, wobei nur 1. from und 5. select unbedingt benötigt werden. 2. where ist meistens auch verwendet, da man mit where filtert.

Eine schlanke Abfrage sorgt für schnelle Verarbeitung und sollte bevorzugt werden, des weiteren sollte man bei der From-Klausel sparsam mit Tabellen umgehen, da automatisch mit jeder Tabelle ein Kreuzprodukt erzeugt wird, was man nur mittels JOIN umgehen kann.

Kommendes Tutorial

Im kommenden Teil werden wir einfache SQL-Befehle entwickeln und erklären und dabei auf Fremdschlüssel und Primarykeys wertlegen.

Ein Java 2D Spiel entwickeln mit der GTGE

Um ein 2D-Spiel in Java entwickeln zu können, benötigen wir die gesamten GTGE libarys. Diese können wir sogar in Eclipse mittels SVN (Subclipse Plug-In) einfach einrichten.

In einem neuen VHPD Videotutorial erklären wir Schritt für Schritt, wie man Eclipse so konfiguriert, damit man die GTGE herunterladen kann.

Verwendete Links

SVN -- Subclipse: http://subclipse.tigris.org/update_1.6.x

GTGE Source -- SVN: http://gtge.googlecode.com/svn/trunk

GTGE

Der Sourcecode von der GTGE ist unter der GPL-Lizens veröffentlicht und kann auch über der GTGE direkt heruntergeladen werden.

Zu der GTGE-Homepage ->

Der Standard aller Dateien – XML

Immer mehr verschiedene Datentypen gibt es, immer mehr Programme zum verwenden von Dateien werden benötigt. Seit 2002 gibt es jedoch eine Einigung, dass XML-Format als Grundlage zu verwenden ist.

Durch das einsetzen einer klaren Struktur in Dateien, sodass man sie auch problemlos mit anderen Programmen bearbeitet werden können, ist XML der erste Grundstein.

Beispiel einer XML-Datei:

1
2
3
4
5
6
7
8
9

<?xml version="1.0" encoding="UTF-8"?>
<NAMEROOT>
  <kontakt nr="0">
             <test>das war der Test 1</test>
   </kontakt>
   <kontakt nr="1">
 	    <test>das war der Test 2</test>
   </kontakt>
</NAMEROOT>

Informationen werden wie in HTML gewohnt als TAG gespeichert und können verschiedene Attribute haben. HTML ist der Vorgänger von XML und jeder der sich mit HTML auskennt wird XML sofort verstehen.

Selbst Microsoft hat mit Office sich zum ersten Mal, an einem Dateistandard gehalten, denn mit *.docx, *.xlsx und *.pptx wird auch der XML-Aufbau verwendet. Aber natürlich mit einen MS Algorithmus gepackt, sodass der “Plaintext” auch nicht richtig lesbar ist.

Die Verwendung von XML kann jeder sich aneignen, vor allem auch Plattformunabhängig können XML-Dateien verwendet werden. Der ITs-real Blog hat ein gelungenes Tutorial veröffentlicht, um mit Java und JDom eine XML-Datei zu erstellen.

- Zu dem XML Tutorial ->

Mit Java in Eclipse ein Adressbuch programmieren

Vorwort

In diesem Tutorial werden wir ein Adressbuch programmieren, dass mit Hilfe eines Arrays von einem benutzerdefinierten Datentyp, die Kontakte Speichert. Daraus sollte man die Verwendung des 3. Schichten Modells besser verstehen können.

Profil

Um dieses Tutorial mitmachen zu können, sollte man die Grundkenntnisse von Java beherrschen und wissen, wie man mit Arrays umgeht. Dazu wird als Formgestalltungsprogramm Jigloo verwendet. Jigloo ist für nicht-kommerzielle Software kostenlos.

Einführung in das 3 Schichten Modell

Das ist die Grundlage des Tutorials, das 3 Schichten Modell. Wie man gut Heraushören kann, war es mal wieder ein langer Tag und dazu noch leicht erkältet .

Struktogramme und UML

Alle Struktogramme wurden von der Gewerblichen Schule Göppingen im Unterricht bereitgestellt und das UML stellen wir nun bereit.

[Zeigen als Slideshow]

[Mit PicLens anzeigen]

Der Start

Erstellen eines neuen Javaprojektes mit dem Titel “P_AdressBuch”. Danach legen wir unsere StartKlasse mit static void main() an.

Erstellen des EingabeForms

Nun kommen wir schon zur GUI, die GUI sollte uns die Möglichkeit geben, alle Inhalte anzeigen und bearbeiten zu lassen. Wir müssen daher zwingend Textfields nehmen. Bitte beachtet die Einstellung: Set Layout > AbsoluteLayout und optional Set look and feel > System. Die Oberfläche sollte danach so aussehen:

Fehlende Klassen erstellen

Danach sollte man die fehlenden Klassen erstellen, die Steuerungsklasse und Datensatz. Mithilfe der gegebenen Stuktogramme und UML sollte jeder problemlos wissen, was er nun zu machen hat. Noch eine Kurze Erklärung wie: Zuerst UML anschauen, danach feststellen welche Methoden, die als Struktogramme gegeben wurden, in welche Klasse gehören.

Die Klasse Datensatz.java sollte nun erstellt werden mit folgendem Inhalt:

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

public class Datensatz {
 
	//Globale Attribute der Klasse
	public String vorname, nachname, adresse, plz, email, ort, telnr;
 
	//Konstruktor - 2 Versionen für vorhandene Daten und ohne
 
	//Konstruktor mit Daten füllen
	public Datensatz(String p_vorname, String p_nachname, 
			String p_adresse, String p_plz, String p_email, 
			String p_ort, String p_telnr){
		vorname = p_vorname;
		nachname = p_nachname;
		adresse = p_adresse;
		plz = p_plz;
		ort = p_ort;
		email = p_email;
		telnr = p_telnr;
	}
 
	//Konstruktor ohne Daten
	public Datensatz(){
		vorname = null;
		nachname = null;
		adresse = null;
		plz = null;
		ort = null;
		email = null;
		telnr = null;
	}
}

Hier kann man gut erkennen, wie man 2 Konstruktoren für verschiedene Fälle anwendet. Einfach einen weiteren Konstruktor anlegen mit anderen Parametern und schon entscheidet Java, welcher Konstruktor verwendet wird.
Durch das null Setzen der Attribute, kann es nicht zu einem Fehler führen, wenn man auf ein Attribut zugreift

Nun kommt der Inhalt der Steuerungsklasse.java:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

public class Steuerungsklasse {
 
	//Atribute
	private int feldGröße = 100;
	public int derZeiger = 0;
	private EingabeFrame fenster = null;
	private Datensatz[] dieDaten = new Datensatz[feldGröße+1];
 
	//Konstruktor
	public Steuerungsklasse(EingabeFrame p_fenster){
		fenster = p_fenster;
	}
 
	//Funktionen von Struktogramm siehe UML
 
	public Datensatz erstesElement(){
		derZeiger = 0;
		if (dieDaten[derZeiger]== null){
			return new Datensatz();
		} else {
			return dieDaten[derZeiger];
		}
	}
 
	public Datensatz letztesElement(){
		if (dieDaten[derZeiger]==null){
			return new Datensatz();
		} else {
			while (dieDaten[derZeiger +1]!=null){
				derZeiger++;
			}
			return dieDaten[derZeiger];
		}
	}
 
	public Datensatz links(){
		if (derZeiger > 0){
			derZeiger--;
		}
		if (dieDaten[derZeiger]==null){
			return new Datensatz();
		} else {
			return dieDaten[derZeiger];
		}
	}
 
	public Datensatz rechts(){
		if (dieDaten[derZeiger]== null){
			return new Datensatz();
		} else {
			if (dieDaten[derZeiger +1]!= null){
				derZeiger++;
			}
			return dieDaten[derZeiger];
		}
	}
 
	public Datensatz refresh(){
		if (dieDaten[derZeiger] == null){
			return new Datensatz();
		} else {
			return dieDaten[derZeiger];
		}
	}
 
	public boolean insert(Datensatz d){
		if (dieDaten[derZeiger]== null){
			dieDaten[derZeiger] = new Datensatz();
			dieDaten[derZeiger] = d;
			return true;
		} else {
			if (dieDaten [feldGröße - 1] == null){
				int derZeiger2 = feldGröße -1;
				while (derZeiger2 > derZeiger){
					dieDaten[derZeiger2] = dieDaten[derZeiger2-1];
					derZeiger2--;
				}
				dieDaten[derZeiger] = d;
				return true;
			} else return false;
		}
	}
 
	public boolean delete(){
		int derZeiger2 = derZeiger;
		while(dieDaten[derZeiger2]!= null){
			dieDaten[derZeiger2] = dieDaten[derZeiger2+1];
			derZeiger2++;
		}
		return true;
	}
 
	public boolean modify(Datensatz d){
		if (dieDaten[derZeiger] != null){
			dieDaten[derZeiger] = d;
			return true;
		} else {
			return false;
		}
	}
 
}

Die erstellten Methoden wurden aufgrund der Struktogramme der Gewerblichen Schule angefertigt, jedoch sollte man dazu sagen, dass Variablennamen sich unterscheiden. z. B. bei dem VHPD Adressbuch dieDaten und im Struktogramm dasDatenfeld.
Profis werden die Assoziation fenster nicht verstehen, natürlich ich diese in diesem Fall mehr als unnütz, jedoch hier sollte es die gegenseitige Verbindung wie im UML darstellen. In der fenster-Variable wird nur die Adresse zu dem echten Fenster gespeichert.

Nun kommen wir zu dem schweren Teil, das erweitern von dem EingabeFrame. Als Erstes sollte man alle Buttons, außer New, auf disabled stellen. Danach erstellen wir eine weitere Methode in der EingabeFrame Klasse.

1
2
3
4
5
6
7
8
9

	private void clearAll(){
		tfVorname.setText("");
		tfNachname.setText("");
		tfAdresse.setText("");
		tfPLZ.setText("");
		tfOrt.setText("");
		tfTelNr.setText("");
		tfEMail.setText("");
	}

Diese Erweiterung erspart uns viel Tipparbeit. Sollte sich jetzt jemand Fragen, wie man eine Methode einfügt in eine Klasse, dann sollte dieser Hinweis reichen: Zwischen zwei bereits vorhandenen Methoden aber nicht nach der Abschließenden Klassenklammer }.
Danach erstellt man die Buttons nach der Reihe, davor sollte man aber wissen, wie das Programm jetzt eigentlich genau funktioniert:

Wenn man auf Neu klickt, dann werden die Buttons Neu, Ändern, Löschen deaktiviert und im Gegenzug Sichern und Abbrechen aktiviert. Nach dem Umstellen der Schalter wird ein Leerer Datensatz eingefügt. Als Letztes verwenden wir unsere clearAll() Methode, um die Textfelder zu leeren. Dass sieht im Java Code so aus:

1
2
3
4
5
6
7

	private void bNeuActionPerformed(ActionEvent evt) {
		bAbbrechen.setEnabled(true);
		bSichern.setEnabled(true);
		bNeu.setEnabled(false);
		clearAll();
		dieSteuerung.insert(new Datensatz());		
	}

Nun schauen wir uns Sichern an, wenn wir auf Sichern klicken, dann wird ein Datensatz mit dem Formularinhalt erstellt und dann wird mit Hilfe von modify der Steuerungsklasse, der vorher neu erstellte Eintrag geändert, mit dem Inhalt des Formulars. Im Java Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

	private void bSichernActionPerformed(ActionEvent evt) {
		Datensatz d = new Datensatz(tfVorname.getText(),
				tfNachname.getText(), tfAdresse.getText(),
				tfPLZ.getText(), tfEMail.getText(),
				tfOrt.getText(), tfTelNr.getText());
 
		if (dieSteuerung.modify(d)!= true){
			System.out.println("Kontne nicht Gesichert werden");
		}
		bNeu.setEnabled(true);
		bLöschen.setEnabled(true);
		bÄndern.setEnabled(true);
		bAbbrechen.setEnabled(false);
		bSichern.setEnabled(false);
	}

Mit einem Klick auf Löschen erstellen wir einen leeren Datensatz, um die Daten des nachfolgenden Elementes anzeigen zu können. Damit keine Lücken im Array der Datensätze entstehen, müssen wir alle Einträge dann immer aufschieben. Danach benutzen wir die void Methode delete() von derSteuerung und zum Schluss laden wir in unseren leeren Datensatz d, die Informationen vom Aufgerutschten Element. Die Inhalte von d werden dann mit der setText() Methode der Textfelder angezeigt. Das sieht in Java so aus:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

	private void bLöschenActionPerformed(ActionEvent evt) {
		Datensatz d = new Datensatz();
 
		dieSteuerung.delete();
 
		d = dieSteuerung.refresh();
		tfVorname.setText(d.vorname);
		tfNachname.setText(d.nachname);
		tfAdresse.setText(d.adresse);
		tfPLZ.setText(d.plz);
		tfOrt.setText(d.ort);
		tfTelNr.setText(d.telnr);
		tfEMail.setText(d.email);
	}

Nun gibt es noch Ändern, wenn man darauf klickt, wird ein Datensatz mit den Inhalten des Fensters erstellt und mit der Methode modify von derSteuerung übertragen an dieDaten. Im Java Code:

1
2
3
4
5
6
7
8
9

	private void bÄndernActionPerformed(ActionEvent evt) {
		Datensatz d = new Datensatz(tfVorname.getText(),
				tfNachname.getText(), tfAdresse.getText(),
				tfPLZ.getText(), tfEMail.getText(),
				tfOrt.getText(), tfTelNr.getText());
		if (dieSteuerung.modify(d) != true){
			System.out.println("Konnte nicht Geändert werden");
		}
	}

Nun gibt es noch Abbrechen, wenn man darauf klickt, wird Neu, Ändern, Löschen aktiviert und Abbrechen und Sichern deaktiviert. Danach werden die Textfelder mit clearAll() geleert und wir benutzen die refresh() Methode der Steuerungsklasse, um die Orginaldaten wiederherzustellen. Natürlich müssen wir wie davor, einen leeren Datensatz d erstellen, den wir mit refresh() füllen und dann auslesen um die Textfelder mit dem richtigen Inhalt voll stopfen zu können. In Java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

	private void bAbbrechenActionPerformed(ActionEvent evt) {
		clearAll();
		bAbbrechen.setEnabled(false);
		bSichern.setEnabled(false);
		bNeu.setEnabled(true);
		bLöschen.setEnabled(true);
		bÄndern.setEnabled(true);
 
		Datensatz d = new Datensatz();
		d = dieSteuerung.refresh();
		tfVorname.setText(d.vorname);
		tfNachname.setText(d.nachname);
		tfAdresse.setText(d.adresse);
		tfPLZ.setText(d.plz);
		tfOrt.setText(d.ort);
		tfTelNr.setText(d.telnr);
		tfEMail.setText(d.email);
	}

Nun muss man noch Blättern können, mit einem klick auf das erste Element wird, wie bereits schon 4 mal geschrieben, ein leerer Datensatz d erstellt, der mit den Inhalt von dem ersten Element in der Steuerungsklasse, gefüllt wird. Danach wird der Inhalt wieder im Fenster angezeigt. Java:

1
2
3
4
5
6
7
8
9
10
11
12
13

	private void bErstesElementActionPerformed(ActionEvent evt) {
		Datensatz d = new Datensatz();
 
		d = dieSteuerung.erstesElement();
 
		tfVorname.setText(d.vorname);
		tfNachname.setText(d.nachname);
		tfAdresse.setText(d.adresse);
		tfPLZ.setText(d.plz);
		tfOrt.setText(d.ort);
		tfTelNr.setText(d.telnr);
		tfEMail.setText(d.email);
	}

Um jetzt nach links, rechts oder zum letzten Element zu kommen, muss man nur die 4. Zeile anpassen und anstelle von erstesElement, die gewünschte Methode aufrufen.

Nun ist das Grundgerüst einwandfrei fertig und alles läuft so, wie es sollte. Um die Anzeige noch besser machen zu können, kann man den Zeiger anzeigen lassen. Dazu sollte man auf dem Form ein Label mit dem Namen lZeiger erstellen und den folgenden Baustein zu jeder Button-Methode einfügen:

1

lZeiger.setText(Integer.toString(dieSteuerung.derZeiger));

Wenn alles Geklappt hat, sollte das Fertige Programm so aussehen:

Hier noch die Source zum Download, jedoch wurde der EingabeFrame entfernt, denn sollte man mindestens noch selber hinbekommen . Download Source.

Lazarus einrichten, um Windows CE Programme zu schreiben

Jeder dem Free Pascal was sagt, wird sofort es mit Lazarus in Verbindung setzen. Lazarus ist eine kostenlose IDE für Free Pascal, mit der man für viele Plattformen, sein Programm komplimieren kann.

Windows CE wird seit kurzem auch unterstützt, jedoch muss man zuvor einige Einstellungen treffen. Mit diesem Tutorial wird Schritt für Schritt alles erklärt, um Lazarus für Windows CE vorzubereiten.

1. Daten aus dem Internet organisieren

Bevor es losgeht, muss man zuerst die Lazarus Installationspakete herunterladen und in der gleichen Version auch den cross-compiler, mit dem es möglich ist, ein Windows CE Programm zu komplimieren.

• Auf SourceForge.net die aktuellste Windows Lazarus 32 Bit Version herunterladen: 0.9.26.2
  http://sourceforge.net/project/downloading.php?group_id=89339&filename=lazarus-0.9.26.2-fpc-2.2.2-win32.exe&a=68051971
• Das herunter geladene Installationspaket Installieren
• Auf SourceForge.net die passende Windows Lazarus cross-arm-wince Compiler Version downloaden: 0.9.26.2
  http://sourceforge.net/project/downloading.php?group_id=89339&filename=lazarus-0.9.26.2-fpc-2.2.2-cross-arm-wince-win32.exe&a=37187510
• Den Cross-Compiler installieren.

2. Notwendige Datei verschieben

Die Datei “wincemenures.or” muss von “lazarus/lcl/interfaces/wince” nach “lazarus/lcl/units/arm-wince” kopiert werden.

3. Einstellungen in Lazarus treffen

In der Lazarus IDE Einstellungen -> Options… -> Environment -> Compilerdateiname muss auf die ppcrpssarm.exe zeigen.

Jedes Projekt muss nun aber dann zusätzlich eingestellt werden:

Wie man auf den Bildern erkennt müssen nun bei den Compilereinstellungen noch die grundlegenden Einstellungen getroffen werden. Es empfiehlt sich die Einstellung zu testen und dazu sollte man sich diese vorgenommenen Projekteinstellungen Speichern, damit man bei weiteren Projekten einfach das erstellte Schema verwenden kann.

Wichtige Infos

Der Debugmodus ist nur mit Hilfe eines Plug-Ins und dem Windows Mobile Emulator möglich, deshalb empfiehlt es sich dringend den Emulator herunterzuladen, von der Microsoft Homepage. Dazu kann man daher NUR durch Projekt->Erstellen die WinCE EXE erstellen. Um diese zu testen, muss man die WinCE EXE auf ein WinCE Emulator/Gerät kopieren und dort ausführen. Windows CE Anwendungen laufen nicht unter Windows 32 Bit.

Nützliche Links (englisch)

Wer immer noch nicht genug hat, kann auf den folgenden Seiten noch weitere Tipps zur CE Programmierung mit Hilfe von Lazarus erhalten.

http://wiki.lazarus.freepascal.org/Windows_CE_Development_Notes

http://wiki.lazarus.freepascal.org/WinCE_Programming_Tips

Erstellen einer Pivot Tabelle

So einfach kann man Pivot Tabellen erstellen:

Einfacher Start mit dem Tracking, für Open Street Maps und Google Maps

Benötigt werden:

Handy, das Java (J2ME) unterstützt,

Eine Bluetooth GPS-Maus

und gute Laune

Erste schritte:

Herunterladen des Handyprogramms “Mobile Trail Explorer” auf der Entwicklerseite, oder direkt als .JAR oder .JAD downloaden. Das Hadyprogramm ist unter der GPL (General Public Licence) veröffentlicht und ist somit kostenlos.

Ich benutze dieses Programm, da es nach meiner Meinung das stabilste und einfachste war, auf meinem Nokia 5300 Xpress Music.

Die heruntergeladene Java-Datei auf das Handy kopieren.

Erste Einstellungen:

Sollte die neuere mobile Javaumgebung installiert sein, muss man die Sicherheitseinstellungen verändert, dass das Programm die Trackings auch auf der Speicherkarte speichern kann.

Das geht in den man die Javadatei “TrailExplorer” markiert und dann auf Optionen->Programmzugriff->Datenzugriff-> Dat. hinzufüg./bearb. es erlaubt, bzw. auf “jedes Mal fragen” stellt.

Erster Programmstart:

Wenn man den roten Punkt in der mite seiht, drückt man auf die mittlere Taste und kommt somit in das Menü. Danach geht man auf Settings->GPS  und das Handy verlangt nun, das Bluetooth zu aktivieren und möchte damit eine Verbindung aufbauen. Dann einfach seine Bluetooth GPS-Maus auswählen.

Leichter geht es, wenn man die Bluetooth GPS-Maus schon vorab mit dem Handy im Bluetooth Menü gekoppelt hat. Der Sicherheitscode ist bei den meisten Bluetooth GPS-Mäusen “0000″.

Sollte das Handy die Bluetooth GPS-Maus nicht finden, liegt es daran, dass die Java-Sicherheitseinstellungen dies verwehren, somit muss man wie mit dem Datenzugriff auch den Verbingunszugriff bestätigen.

Weiterlesen »