Und genau hier sehe ich das Problem. Nehmen wir mal an, ich verliere mein Handy und jemand findet es. Ohne Eingabe eines PINs kann er sich in ein Wlan einlinken und so meine Emails und meinen Kalender zugreifen.
Ich könnte zwar einstellen, dass beim Ausschalten der Tastensperre eine Code-Abfrage kommt, aber ich will nicht jedes mal einen Code eingeben.
Allerdings bin ich der Meinung, dass das Handy nicht benutztbar (außer für Notrufe) sein sollte, solange ich keinen PIN oder entsprechendes eingegeben habe.

Ich denke, hier muss Palm nacharbeiten! Wie seht ihr das?

Die alte Schreibweise

Die Schreibweise unter C#3.0 mit Überladung wäre also in etwa so:

    public class Program
    {
        static void Main(string[] args)
        {

            AddValues("Ich bin ein", "String");
            Console.WriteLine(_value);

            AddValues("Ich bin ein", "String", true);

            Console.ReadLine();
        }

        public static string _value;

        public static void AddValues(string value1, string value2)
        {
            AddValues(value1, value2, false);
        }
        public static void AddValues(string value1, string value2, bool output)
        {
            _value = string.Format("{0} {1}", value1, value2);
            if(output)
            {
                Console.WriteLine(_value);
            }
        }
    }

Wenn wir nun das Projekt ausführen erhalten wir folgende Ausgabe.

Ich bin ein String
Ich bin ein String

Die erste Ausgabe erfolgt manuell, die zweite direkt in der Methode, wie gewünscht.

C#4.0 mit Default Values

Unter C#4.0 mit Default Values kann man die ganze Sache nun vereinfachen:

public static void AddValues(string value1, string value2, bool output = false)
{
    _value = string.Format("{0} {1}", value1, value2);
    if(output)
    {
        Console.WriteLine(_value);
    }
}

Die Ausgabe ist identisch. Die erste Zeile wird manuell ausgegeben, die zweite über den Methodenaufruf. Das macht die Sache einfach, spart Code, macht ihn leserlicher. Man findet sicherlich noch weitere Vorteile.

Das Problem erkennen

Kommen wir nun zu den Problemen. Bevor ich die erläutern kann, muss man wissen, wie C# die Default Values behandelt. Wenn man sich die Anwendung per Reflector ansieht, sieht man folgenden Code (in der C#-Ansicht):

private static void AddValues(string value1, string value2, [Optional, DefaultParameterValue(false)] bool output);

Die Zeile spricht für sich. Der Standardwert lautet “false”. Nun erstellen wir ein neues Projekt (“TestApp”) und referenzieren auf unsere Methode mit dem Default Value:

namespace TestApp
{
    class Program
    {
        static void Main(string[] args)
        {
            DefaultValues.Program.AddValues("Ich bin ein", "String");
            Console.WriteLine(DefaultValues.Program._value);

            Console.ReadLine();
        }
    }
}

Ausgegben wird eine Zeile, wie erwartet, durch die manuelle Ausgabe. Nun sehen wir uns die zweite Exe-Datei mal im Reflector an:

Program.AddValues("Ich bin ein", "String", false);

Auf einmal sind drei Parameter vorhanden, obwohl wir nur zwei im Sourcecode angegeben haben. Der Compiler setzt automatisch den dritten Parameter mit dem Standardwert, in dem Fall false.
Nun ändern wir die AddValues()-Methode, die Ausgabe soll standardmäßig sofort in der Methode erfolgen, zudem ändern wir den String etwas:

public static void AddValues(string value1, string value2, bool output = true)
{
    _value = string.Format("Zusammengesetzt: {0} {1}", value1, value2);
    if (output)
    {
        Console.WriteLine(_value);
    }
}

Nun kompilier ich nur das Projekt “DefaultValues” und kopiere die DefaultValues.exe in das Bin-Verzeichnis der TestApp. Wenn ich nun die TestApp.exe starte erhalte ich folgende Ausgabe:

Zusammengesetzt: Ich bin ein String

Allerdings haben wir den Standardwert für die Ausgabe auf true gesetzt, daher müsste die Ausgabe doppelt erscheinen, einmal direkt über den Methodenaufruf und einmal durch die manuelle Ausgabe.

Problem beheben

Dieses Problem resultiert daher, dass der Standardwert nicht “on-the-fly” aus der DefaultValue.exe geholt wird, sondern vom Compiler in der TestApp.exe gesetzt wurde.
Die Methode aus der DefaultValues.exe wird also immer noch mit “AddValues(“Ich bin ein”, “String”, false);” aufgerufen. Und so lange wir das TestApp-Projekt nicht neu kompilieren, wird sich an der Ausgabe nichts ändern.

Fazit

Default Values sind eine nette Sache, um sich Überladungen zu sparen, den Code leserlicher zu machen und dem Programmierer das Leben leichter. Aber eigentlich gibt es keine Default Value, der Compiler setzt einfach nur die Werte, die man vorher manuell gesetzt hat. Wenn man diesen Aspekt nicht vergisst, können DefaultValues eine schöne Sache sein, ansonsten sucht man sich wahrscheinlich dumm und dämlich, bis man den Fehler gefunden hat.

Vielen Dank hier noch mal an Oliver Sturm, welcher die Problematik auf der Basta kurz aber verständlich erklärt hat.

Beispielsolution: DefaultValues.zip

void Foobar(string valueWithoutDefaultValue, string valueWithDefaultValue = "Ich bin ein Default Value") {
   // ..
}

Ich kann den 2. Parameter nun mit geben oder es eben sein lassen. Mehr dazu findet ihr hier. Nun wollte ich dies bei einem Delegaten ausnutzen. Der Delegate feuert nur mit einem Parameter, die Methode hat aber zwei Parameter, wobei der zweite einen Defaultwert hat.

public delegate void DelegateFoobar(string text);
public event DelegateFoobar foobarEvent;

Dies funktioniert nicht, der Compiler spuckt folgende Fehlermeldung:

No overload for 'Foobar' matches delegate 'TestApp.Classes.Test.foobarEvent'

Schade eigentlich, denn meiner Interpretation nach sollte es funktionieren. Gelöst habe ich es mit eine Lambda Expression:

testclass.foobarEvent += str => this.Foobar(str);

Funktioniert ohne Probleme.

(Wenn Interesse besteht, lade ich mal eine Beispielsolution hoch).

Dort steht nun in der Datei:

function syndication_permalink ($permalink = '') {
	global $feedwordpress_the_original_permalink;

	// Save the local permalink in case we need to retrieve it later.
	$feedwordpress_the_original_permalink = $permalink;

	// Map this permalink to a post ID so we can get the correct permalink
	// even outside of the Post Loop. Props Björn.
	$id = url_to_postid($permalink);

Ja Leute, nun werde ich berühmt

Die GUI ist nicht mehr ganz so aktuell. Aktuell bin ich mir noch nicht so sicher, wie ich die Daten speicher, momentan tendiere ich dazu, die Daten als XML-Datei auf der Platte zu speichern.

Update: Eben kam eine SMS, dass meine Übernahme zum 10.04.2010 00:00:00 Uhr geschaltet wird. Ick freu mir!

Das Plugin sorgt dafür, dass der RSS Feed anderer Blogs ausgelesen werden und hier als eigene Einträge erscheinen. Damit der Fehler reproduzierbar ist, müssen folgende Voraussetzungen erfüllt sein:
- Bei FeedWordpress muss unter Einstellungen -> “Posts & Links” -> Permalink auf “point to the copy on the original website” stehen
- der letzte Eintrag der Seite muss ein per Feed importierter Eintrag sein
- Das Widget “Recent_Comments” oder jede andere Funktion, dass einen Permalink per “get_permalink()” zu holen versucht, muss “nach” diesem bestimmten Beitrag ausgeführt werden

Um den Fehler zu verstehen, schauen wir kurz in die “feedwordpress.php” im Pluginverzeichnis.
Dort steht folgendes:

function syndication_permalink ($permalink = '') {
	if (get_option('feedwordpress_munge_permalink') != 'no'):
		$uri = get_syndication_permalink();
		return ((strlen($uri) > 0) ? $uri : $permalink);
	else:
		return $permalink;
	endif;
} // function syndication_permalink ()

In unserem Fall ruft er also die Funktion “get_syndication_permalink()” ohne Parameter auf:

function get_syndication_permalink ($id = NULL) {
	list($u) = get_post_custom_values('syndication_permalink', $id); return $u;
}

Als Defaultwert ist NULL angegeben. Ein Blick in den Wordpress-Codex verrät, dass er das Benutzerdefinierte Feld des aktuellen Eintrags laden versucht. Das ist logischerweise noch der aus dem Feed importierte Eintrag und daher lädt er eine falsche URL.

Um das Problem zu beheben, einfach den Code oben durch folgenden ersetzen:

function syndication_permalink ($permalink = '') {
	$id = url_to_postid($permalink);
	if (get_option('feedwordpress_munge_permalink') != 'no'):
		$uri = get_syndication_permalink($id);
		return ((strlen($uri) > 0) ? $uri : $permalink);
	else:
		return $permalink;
	endif;
} // function syndication_permalink ()

Die “url_to_postid()” ist eine Wordpress-eigene Funktion. Nun funktioniert es wieder. Darauf muss man erstmal kommen!

PrintDialog pd = new PrintDialog();
if (pd.ShowDialog() == DialogResult.OK)
{
    // do nothing

}

Nichts großes, sollte einfach nur so ein Druckerfenster öffnen, wo der Drucker ausgewählt wird etc. Leider öffnete sich der erhoffte Dialog nicht. Der Debugger läuft dahin, aber er führt den ShowDialog() einfach nicht aus.

Wenn ich die Eigenschaft “UseEXDialog” auf “true” setze, funktioniert es.
Jedoch wollte ich nicht den XP-Dialog, sondern den anderen. Auch im Netz fand ich keine wirkliche Lösung.
Da diese Codezeilen aus einem bestehenden Projekt stammen, habe ich kurzerhand neue Projekte in den Frameworks 2.0, 3.5 und 4.0 angelegt. Jeweils mit dem Codeschnippsel oben. Und siehe da, es funktioniert problemlos, in jeder Frameworkversion. Nun die Unterschiede gesucht.

Fündig wurde ich den Projekteigenschaften unter “Build” bzw. “Erstellen”.
Ich muss dazu sagen, dass die Applikation vorher auf einem anderen Rechner mit einem 32-bit Windows entwickelt wurde. So stand hier unter dem Punkt “Platform target:” (auf Deutsch vermutlich Zielplattform) “Any CPU”.
Stellt die Anwendung hier auf 32-bit (x86) und der PrintDialog() wird hervorragend funktionieren. x64 oder Any CPU funktioniert nicht.
Auf so etwas muss man erstmal kommen, warum das so ist, keine Ahnung.

So habe ich noch mal in der MSDN nachgeschlagen:

This class may not work on AMD64 microprocessors unless you set the UseEXDialog property to true.

Ich bin zwar nun nicht der technisch versierte Mensch, aber für mich hört sich das nach einem Problem mit einem AMD Prozessor an, ich habe jedoch einen Intel (ich lasse es mir aber dennoch gerne erklären).

29.05.2006 – Vertrag bei T-Mobile, 24 Monate Laufzeit
10.04.2008 – Vertragsverlängerung um 24 Monate

So, was meint ihr, wann der Vertrag ausläuft? Also meiner Rechnung nach am 28.05. 2010. Bei T-Mobile am 09.04.2010. Daher ist meine Kündigung laut deren Meinung auch zu spät rausgegangen, so das sie meinen Vertrag erst zum 09.04.2011 kündigen wollen. Nun hab ich gestern da angerufen und wollte wissen, wie die darauf kommen. Nach langem hin und her konnte mir der Supporter auch nicht sagen, warum das alles so ist. Nun wird mein Anliegen an die Reklamationsabteilung weitergeleitet, die wollen sich Montag melden.
Ich bin gespannt.

Leider gab es auch eine Session, wo ich mir doch mehr versprochen habe. Sie hatte den schönen Namen “Nein! – Meinen Code und meine Daten bekommst du nicht”. Es ging darum, wie man den Code (und die Daten) seiner .NET-Anwendung so “verschlüsseln” kann, dass niemand ran kommt (Stichwort Reflection). Es wurden dabei einige Beispiele und Möglichkeiten mit ihren Vor- und Nachteilen genannt. Die wohl am besten zu nutzende ist eine, bei der der Code der Methoden verschlüsselt wird und zur Laufzeit wieder entschlüsselt wird. Hört sich für mich etwa nach eval() in PHP an. Egal, ein Beispiel wurde leider nicht gezeigt, denn als man ja die beste Möglichkeit präsentiert hatte, wurde gleich das Hauseigene Produkt vorgestellt, dass natürlich genau diese und noch einige andere Features bietet. Schade eigentlich. Ich hätte jetzt keine genaue funktionsweise ihrer kostenpflichtigen Anwendung erwartet, aber so beispielhafte Applikationen wären schon wünschenswert. Ich bin halt naiv.

Morgen geht es weiter. Ich werde morgen mit dem Tipps und Tricks rund um die VS IDE anfangen. Interessant wird auch parallele Entwicklung in .NET 4 und LINQ nach PLINQ. Am Nachmittag werde ich mich über Freeware Security Tools informieren. Und abends gehts dann in die Piano Bar, Casino

Und heute solls noch Freibier geben, ich muss es nur noch finden :p

Joa und nächste Woche geht es zur “Basta Spring 2010” nach Darmstadt. Dies ist meine erste Veranstaltung dieser Art und von daher kann ich noch gar nicht genau sagen, was mich erwartet. Vermutlich komme ich mir wie ein Möchtegernschauspieler bei der Oscar-Verleihung vor. An mir laufen die “Stars” der Szene vorbei und ich komme mir so minderwertig vor. Mal sehen, ich denke mal ich twitter vor Ort.

Wir berichten weiter, wenn es was zu berichten gibt. Falls euch langweilig wird, schaut doch mal bei Leoni und Mirko und ihrem Traumhaus vorbei.

Webdesign mit Zeta CMS im Landkreis Göppingen

Ich denke, dass ist ein guter Deal für ein Film Ich nehme auch gern mehr Filme

Ach die Wohnungsbesichtigung hat auch was ergeben: das junge Pärchen nimmt eine der anderen Wohnungen. Aber nicht, weil ihnen unsere nicht gefällt. Sie wollen/können erst im Juli umziehen, bis dahin sind aber bereits andere Wohnungen renoviert und können mit unserer mithalten. Ich erwähnte schon mal, dass wir die beste Wohnung haben. Sie haben sich trotzdem unsere Wohnung angeschaut, die Farben gefielen ihnen sogar richtig gut. Da ich gut eingeheizt hatte, konnten sie auch gleich sehen, wie gut die Dinger heizen. Auf die Macken bin ich nicht weiter eingegangen, sie konnten sich schließlich ein Bild davon machen (was wir damals nicht machen konnten). Unser Hausmeister vermutet, dass er die Wohnung schon vorher ohne größere Probleme an den Mann bringen kann. Falls wer interessiert ist, meine Emailadresse steht im Impressum

Dazu brauchen wir erstmal das Palm Pre SDK. Dabei wird gleich eine virtuelle Maschine per Java Virtual Box mit einem WebOS installiert. Ansonsten wird alles installiert, was ihr braucht, um eine WebOS App zu erstellen. Wenn ihr wollt könnt ihr nun mit jedem beliebigen Texteditor loslegen.
Ich habe mich für Eclipse mit der webOS-Erweiterung entschieden. Du kannst die App von hier aus direkt in der VM starten, was einfacher ist, als die Apps jedes mal per Command-Tool in entsprechende Formate zu konvertieren und in die VM zu portieren.
Wie ihr das ganze installiert, könnt ihr hier nachlesen.

Nun will ich euch zeigen, wir ihr eine App für das Palm Pre erstellt. Als Beispiel entwickeln wir ein simples TicTacToe für zwei Spieler. Inspiriert wurde ich durch eine OpenSource Variante von TicTacToe namens Tics’n'Tacs, welche aber für Anfänger doch recht oversized wirkt (enthält eine KI etc.)

Da webOS mit dem Javascript Framework “Prototype” arbeitet, welches man natürlich auch lokal nutzen kann, habe ich beschlossen, die Spiellogik erstmal für den Browser zu erstellen, und diese dann fürs Palm zu portieren und zu erweitern.

Als erstes erstellen wir eine Klasse in Javascript (kann man da von Klasse sprechen?):

function Game() {
}

/*
 * Setzt das Spielfeld zurück *
*/
Game.prototype.reset = function() {
	this.gameRunning = true;
	this.grid = [[ 0, 0, 0], [0, 0, 0], [0,0,0]];
	this.fieldsLeft = 9;
}

/*
 * Click abfangen und entsprechend reagieren
 */
Game.prototype.handleFieldClick = function(event, x, y) {
    // Spiel läuft nicht mehr oder Feld bereits von jemanden belegt!
	if(!this.gameRunning || this.grid[x][y] != 0) {
		return;
	}

	// Feld für den aktuellen Spieler reservieren
	this.grid[x][y] = this.currentPlayer;
	var id = "field" + x + y;
	$(id).addClassName("p" + this.currentPlayer);

	// Züge reduzieren
	this.fieldsLeft--;

	// Prüfen, ob er gewonnen hat oder alle Felder belegt!
	if(this.checkForWin()) {
		// Hat gewonnen, callback funktion aufrufen!
		this.endGameCallback(this.winner);
		return;
	}
	// Aktuellen Spieler ändern
	this.currentPlayer = (this.currentPlayer == 1) ? 2 : 1;		

}

/*
 * Dient als Zeiger für die Callback Funktion, wird aufgerufen, sobald das Spiel vorbei ist.
 */
Game.prototype.endGameCallback = null;

/*
 * Startet das Spiel und setzt die Eventhandler auf die Felder.
 */
Game.prototype.start = function() {
	var id;
	this.reset();
	for(var i = 0; i < 3; i++) {
		for(var j = 0; j < 3; j++) {
			id = "field" + i + j;
			Event.observe($(id), "click", this.handleFieldClick.bindAsEventListener(this, i, j));
		}
	}

}	

/*
 * Gibt die Debugmeldung für das Spielfeld aus
 */
Game.prototype.debug = function() {
	alert(this.grid[0][0] + " " + this.grid[0][1] + " " + this.grid[0][2] + "\n" +this.grid[1][0] + " " + this.grid[1][1] + " " + this.grid[1][2] + "\n" +this.grid[2][0] + " " + this.grid[2][1] + " " + this.grid[2][2] + "\n");
}

/*
 * gibt true zurück, wenn ein Spieler gewonnen hat oder Spiel zuende ist
 */
Game.prototype.checkForWin = function() {
	if(this.checkWinDiagonal() || this.checkWinCol() || this.checkWinRow()) {
		this.gameRunning = false;
		return true;
	}

	if(this.fieldsLeft == 0) {
		this.winner = 3;
		return true;
	}
}

/* Prüft, ob Spieler diagonal eine Reihe hat */
Game.prototype.checkWinDiagonal = function() {
	if(	(
			(this.grid[0][0] == this.grid[1][1] &&
			this.grid[1][1] == this.grid[2][2]) ||
			(this.grid[2][0] == this.grid[1][1] &&
			 this.grid[1][1] == this.grid[0][2]))
		&& this.grid[1][1] != 0) {
			this.winner = this.grid[1][1];
			return true;
		}
	return false;
}

/* prüft ob Spieler eine Spalte voll hat */
Game.prototype.checkWinCol = function() {
	for(var i = 0; i < 3; i++) {
		if(	this.grid[0][i] == this.grid[1][i] &&
			this.grid[1][i] == this.grid[2][i] &&
			this.grid[0][i] != 0) {
				this.winner = this.grid[0][i];
				return true;
			}
	}

	return false;
}

/* prüft ob Spieler eine Reihe voll hat */
Game.prototype.checkWinRow = function() {
	for(var i = 0; i < 3; i++) {
		if(	this.grid[i][0] == this.grid[i][1] &&
			this.grid[i][1] == this.grid[i][2] &&
			this.grid[i][0] != 0) {
				this.winner = this.grid[i][0];
				return true;
			}
	}

	return false;
}

// 0: game running, 1: player 1, 2:player 2, 3: draw
Game.prototype.winner = 0;
Game.prototype.fieldsLeft = 9;
Game.prototype.gameRunning = false;
Game.prototype.currentPlayer = 1;
Game.prototype.grid = null;

Das Spielfeld:

<html>
<head><title>Tic Tac Toe</title>
<script type="text/javascript" src="prototype.js" />
<script type="text/javascript" src="game.js" />
  <link href="style.css" rel="stylesheet" type="text/css"/>
</head>
<script type="text/javascript">

var game = null;
function startgame() {
	game = new Game();
	game.start();
	game.endGameCallback = spielEnde;
}

function spielEnde(winner) {
	if(winner == 1 || winner == 2) {
		alert("Gewonnen hat Spieler " + winner);
	}
	else {
		alert("Keiner hat gewonnen!");
	}

	//game.debug();
}

</script>
<body>

<div id="spielfeld">
	<div class="row row1">
		<div id="field00" class="cell col1">1</div>
		<div id="field01" class="cell col2">2</div>
		<div id="field02" class="cell col3">3</div>
	</div>
	<div class="row row2">
		<div id="field10" class="cell col1">4</div>
		<div id="field11" class="cell col2">5</div>
		<div id="field12" class="cell col3">6</div>
	</div>
	<div class="row row3">
		<div id="field20" class="cell col1">7</div>
		<div id="field21" class="cell col2">8</div>
		<div id="field22" class="cell col3">9</div>
	</div>
</div>
<div style="clear:both;"></div>

<input type="button" onclick="startgame();" value="start game"/>

</body>
</html>

Per div-Container und CSS wird ein Spielfeld geformt. Nach einem Klick auf “start game” wird die Klasse initialisiert und die Variabeln gesetzt (game.start()). Dort werden “OnClick”-Events auf die einzelnen Spielfelder gesetzt. Klickt nun ein Spieler auf ein Feld, wird geprüft, ob es noch frei ist und für den Spieler reserviert und durch hinzufügen der entsprechenden CSS-Klasse auch mit einer entsprechenden Grafik visuell markiert. Danach wird geprüft, ob das Spiel vorrüber ist (weil einer gewonnen hat oder kein Zug mehr möglich ist) und bei Bedarf die Funktion “endGameCallback()” aufgerufen. Wenn ihr noch eine Runde spielen wollt, müsst ihr die Seite neuladen.

Damit ihr das nun nicht alles per Copy&Paste selbst machen müsst, habe ich euch alles in einer ZIP-Datei zusammen gepackt: tictactoe.zip

Nun erstellen wir daraus eine webOS Applikation. Dazu legen wir in Eclipse eine neue Mojo App an:

Nun legen wir eine neue Mojo-Scene an und nennen sie “game”:

Wir legen (der Übersicht halber) unter dem Ordner “app” einen Ordner “model” an und kopieren die game.js von oben dortrein.

Damit die “game.js” später in der App bekannt ist, muss sie in der Datei “sources.json” eingetragen werden. Erweitert sie in etwa so:

[
    {"source": "app/assistants/stage-assistant.js"},
    {
        "scenes": "game",
        "source": "app/assistants/game-assistant.js"
    },
    {
    	"source": "app/model/game.js"
    }
]

In der Datei “/app/views/game/game-scene.html” füge ich nun das Spielfeld hinzu. Wichtig ist, dass ich hier keinen Header einbaue.

<div class="palm-page-header">
  <div class="palm-page-header-wrapper">
    <div class="icon app"></div>
    <div class="title">Tic Tac Toe</div>
  </div>
</div>
<div id="spielfeld">
	<div class="row row1">
		<div id="field00" class="cell col1">1</div>
		<div id="field01" class="cell col2">2</div>
		<div id="field02" class="cell col3">3</div>
	</div>
	<div class="row row2">
		<div id="field10" class="cell col1">4</div>
		<div id="field11" class="cell col2">5</div>
		<div id="field12" class="cell col3">6</div>
	</div>
	<div class="row row3">
		<div id="field20" class="cell col1">7</div>
		<div id="field21" class="cell col2">8</div>
		<div id="field22" class="cell col3">9</div>
	</div>
</div>

Die beiden Bilder 1.png und 2.png kopiere ich in den Ordner “/images”. Den Inhalt der style.css kopiere ich in die Datei “/resources/tictactoe.css” und passe die Pfade für die beiden Bilder an.

Nun müssen wir die Spiellogik der game.js in die App einbauen. Das ist ähnlich, wie in der HTML-Datei am Anfang des Beitrags. Dazu bearbeite ich die “/app/assistants/game-assistant.js” und erweitern die vorhandenen Funktionen wie hier (bzw. fügen sie hinzu):

var game = null;
GameAssistant.prototype.setup = function() {
	this.game = new Game();
	this.game.start();
	this.game.callback = this.spielEnde;
}

GameAssistant.prototype.spielEnde = function(winner) {

	var endText;
	if(winner == 3) {
		endText = "Das Spiel endete unentschieden.";
	} else {
		endText = "Gewonnen hat Spieler " + winner;
	}
	Mojo.Controller.errorDialog(endText);
}

Unterschiedlich ist hier nur die Callback-Funktion. Sie ruft die Funktion “errorDialog()” auf. Dies ist ein webOS Dialog. Es gibt noch andere Dialoge, aber halten wir es mal einfach. Das Ergebnis seht ihr später.

Nun müssen wir der App auch sagen, dass es die Szene “game” starten soll, dies geschieht in der “stage-assistant.js”:

StageAssistant.prototype.setup = function() {

this.controller.pushScene("game");
}

Nun starten wir die App (Emulator muss schon laufen), in dem wir aufs Projekt rechtsklicken und “Run” -> “Mojo Application” auswählen. Nach einem kurzen Moment startet die App im Emulator. Das Ergebnis:

Und zu guter letzt noch das ganze Eclipseprojekt als Download: tictactoe-eclipse.zip