Start of examples refactor

This is the general reorg of the examples directory structure, plus additional
guidelines.

calculator, animations and accessibility have been updated to the new standards
and tested, as an example.

Task-number: QTBUG-24133
Change-Id: I76c3b86751d3195ba2a5474ff23afb875765e9a4
Reviewed-by: Alan Alpert <alan.alpert@nokia.com>

1 files changed, 316 insertions, 0 deletions

diff --git a/examples/demos/snake/content/snake.js b/examples/demos/snake/content/snake.js
new file mode 100644
index 0000000000..107c9f4591
--- /dev/null
+++ b/examples/demos/snake/content/snake.js
@@ -0,0 +1,316 @@
+
+var snake = new Array;
+var board = new Array;
+var links = new Array;
+var scheduledDirections = new Array;
+var numRows = 1;
+var numColumns = 1;
+var linkComponent = Qt.createComponent("Link.qml");
+var cookieComponent = Qt.createComponent("Cookie.qml");
+var cookie;
+var linksToGrow = 0;
+var linksToDie = 0;
+var waitForCookie = 0;
+var growType = 0;
+var skullMovementsBeforeDirectionChange = 0;
+
+
+function rand(n)
+{
+  return (Math.floor(Math.random() * n));
+}
+
+function scheduleDirection(dir)
+{
+    if (state == "starting") {
+        direction = dir;
+        headDirection = direction;
+        head.rotation = headDirection;
+    } else if (state == "running"){
+        direction = dir;
+        if(scheduledDirections[scheduledDirections.length-1]!=direction)
+            scheduledDirections.push(direction);
+    }
+}
+
+function startNewGame()
+{
+    if (state == "starting") {
+        return;
+    }
+
+    if (activeGame) {
+        endGame();
+        startNewGameTimer.running = true;
+        return;
+    }
+
+    state = "starting";
+
+    numRows = numRowsAvailable;
+    numColumns = numColumnsAvailable;
+    board = new Array(numRows * numColumns);
+    snake = new Array;
+    scheduledDirections = new Array;
+    growType = 0;
+
+    skull.z = numRows * numColumns + 1;
+
+    for (var i = 0; i < numRows * numColumns; ++i) {
+        if (i < links.length) {
+            var link = links[i];
+            link.spawned = false;
+            link.dying = false;
+        } else {
+            if(linkComponent.status != Component.Ready) {
+                if(linkComponent.status == Component.Error) 
+                    console.log(linkComponent.errorString());
+                else
+                    console.log("Still loading linkComponent");
+                continue;//TODO: Better error handling?
+            }
+            var link = linkComponent.createObject(playfield);
+            link.z = numRows * numColumns + 1 - i;
+            link.type = i == 0 ? 2 : 0;
+            link.spawned = false;
+            link.dying = false;
+            links.push(link);
+        }
+    }
+
+    head = links[0];
+    snake.push(head);
+    head.row = numRows/2 -1;
+    head.column = numColumns/2 -1;
+    head.spawned = true;
+
+    linksToGrow = 5;
+    linksToDie = 0;
+    waitForCookie = 5;
+    score = 0;
+    startHeartbeatTimer.running = true;
+}
+
+function endGame()
+{
+    activeGame = false;
+    for(var i in snake)
+        snake[i].dying = true;
+    if (cookie) {
+        cookie.dying = true;
+        cookie = 0;
+    }
+    lastScore = score;
+    highScores.saveScore(lastScore);
+    state = "";
+}
+
+function move() {
+
+    if (!head)
+        return;
+
+    var dir = direction;
+
+    if (scheduledDirections.length) {
+        dir = scheduledDirections.shift();
+    }
+
+    if (state == "starting") {
+        var turn = (dir - headDirection);
+        head.rotation += turn == -3 ? 1 : (turn == 3 ? -1 : turn );
+        headDirection = dir;
+        return;
+    }
+
+    var row = head.row;
+    var column = head.column;
+
+    if (dir == 0) {
+        row = row - 1;
+    } else if (dir == 1) {
+        column = column + 1
+    } else if (dir == 2) {
+        row = row + 1;
+    } else if (dir == 3) {
+        column = column - 1;
+    }
+
+    //validate the new position
+    if (row < 0 || row >= numRows
+        || column < 0 || column >= numColumns
+        || (row == skull.row && column == skull.column)
+        || !isFree(row, column)) {
+        var turn = (dir - headDirection);
+        head.rotation += turn == -3 ? 1 : (turn == 3 ? -1 : turn );
+        headDirection = dir;
+        endGame();
+        return;
+    }
+
+    var newLink;
+    if (linksToGrow > 0) {
+        --linksToGrow;
+        newLink = links[snake.length];
+        newLink.spawned = false;
+        newLink.rotation = snake[snake.length-1].rotation;
+        newLink.type = growType;
+        newLink.dying = false;
+        snake.push(newLink);
+    } else {
+        var lastLink = snake[snake.length-1];
+        board[lastLink.row * numColumns + lastLink.column] = undefined;
+    }
+
+    if (waitForCookie > 0) {
+        if (--waitForCookie == 0)
+            createCookie(cookie? (cookie.value+1) : 1);
+    }
+
+    for (var i = snake.length-1; i > 0; --i) {
+        snake[i].row = snake[i-1].row;
+        snake[i].column = snake[i-1].column;
+        snake[i].rotation = snake[i-1].rotation;
+    }
+
+    if (newLink) {
+        newLink.spawned = true;
+    }
+
+    // move the head
+    head.row = row;
+    head.column = column;
+    board[row * numColumns + column] = head;
+
+    var turn = (dir - headDirection);
+    head.rotation += turn == -3 ? 1 : (turn == 3 ? -1 : turn );
+    headDirection = dir;
+
+    var value = testCookie(row, column);
+    if (value > 0) {
+        linksToGrow += value;
+        score += value;
+    }
+}
+
+function isFree(row, column)
+{
+    return board[row * numColumns + column] == undefined;
+}
+
+function isHead(row, column)
+{
+    return head.column == column && head.row == row;
+}
+
+function testCookie(row, column)
+{
+    if (cookie && !cookie.dying && cookie.row == row && cookie.column == column) {
+        var value = cookie.value;
+        waitForCookie = value;
+        growType = snake[snake.length-1].type == 1 ? 0 : 1;
+        cookie.dying = true;
+        cookie.z = numRows * numColumns + 2;
+        return value;
+    }
+    return 0;
+}
+
+function moveSkull()
+{
+
+    if (linksToDie > 0) {
+        --linksToDie;
+        var link = snake.pop();
+        link.dying = true;
+        board[link.row * numColumns + link.column] = undefined;
+        if (score > 0)
+            --score;
+        if (snake.length == 0) {
+            endGame();
+            return;
+        }
+    }
+
+    var row = skull.row;
+    var column = skull.column;
+    if (isHead(row, column)) {
+        endGame();
+        return;
+    }
+    row +=  skull.verticalMovement;
+    column += skull.horizontalMovement;
+
+    var attempts = 4;
+
+    while (skullMovementsBeforeDirectionChange == 0 || row < 0 || row >= numRows
+        || column < 0 || column >= numColumns
+        || (!isFree(row, column) && !isHead(row, column))) {
+        var d = rand(8);
+        skull.verticalMovement = 0;
+        skull.horizontalMovement = 0;
+        skullMovementsBeforeDirectionChange = rand(20)+1;
+        if (d == 0) {
+            skull.verticalMovement = -1
+        } else if (d == 1) {
+            skull.horizontalMovement = -1;
+        } else if (d == 2) {
+            skull.verticalMovement = 1
+        } else if (d == 3){
+            skull.horizontalMovement = 1;
+        } else if (cookie) {
+            var rd = cookie.row - skull.row;
+            var rc = cookie.column - skull.column;
+            if (Math.abs(rd) > Math.abs(rc)) {
+                skull.verticalMovement = rd > 0 ? 1 : -1;
+                skullMovementsBeforeDirectionChange = Math.abs(rd);
+            } else {
+                skull.horizontalMovement= rc > 0 ? 1 : -1;
+                skullMovementsBeforeDirectionChange = Math.abs(rc);
+            }
+        }
+        row = skull.row + skull.verticalMovement;
+        column = skull.column + skull.horizontalMovement;
+        if (--attempts == 0)
+            return;
+    }
+
+    skull.row = row;
+    skull.column = column;
+    --skullMovementsBeforeDirectionChange;
+    var value = testCookie(row, column);
+    if (value > 0)
+        linksToDie += value/2;
+
+    if (isHead(row, column))
+        endGame();
+}
+
+function createCookie(value) {
+    if (numRows * numColumns - snake.length < 10)
+        return;
+
+    var column = rand(numColumns);
+    var row = rand(numRows);
+    while (!isFree(row, column)) {
+        column++;
+        if (column == numColumns) {
+            column = 0;
+            row++;
+            if (row == numRows)
+                row = 0;
+        }
+    }
+
+    if(cookieComponent.status != Component.Ready) {
+        if(cookieComponent.status == Component.Error)
+            console.log(cookieComponent.errorString());
+        else
+            console.log("Still loading cookieComponent");
+        return;//TODO: Better error handling?
+    }
+    cookie = cookieComponent.createObject(head.parent);
+    cookie.value = value;
+    cookie.row = row;
+    cookie.column = column;
+}