+ //gDebug = true;
+ if (gDebug) {
+ gGeolocation = geofake;
+ var hiddenList = document.getElementsByClassName("debugHide");
+ // last to first - list of elements with that class is changing!
+ for (var i = hiddenList.length - 1; i >= 0; i--) {
+ hiddenList[i].classList.remove("debugHide");
+ }
+ }
+
+ gAction.addEventListener("prefload-done", initGL, false);
+
+ console.log("map vars set, loading prefs...");
+ loadPrefs();
+}
+
+function loadPrefs(aEvent) {
+ if (aEvent && aEvent.type == "prefs-step") {
+ console.log("wait: " + gWaitCounter);
+ if (gWaitCounter == 0) {
+ gAction.removeEventListener(aEvent.type, loadPrefs, false);
+ gMapPrefsLoaded = true;
+ console.log("prefs loaded.");
+
+ gTrackCanvas.addEventListener("mouseup", mapEvHandler, false);
+ gTrackCanvas.addEventListener("mousemove", mapEvHandler, false);
+ gTrackCanvas.addEventListener("mousedown", mapEvHandler, false);
+ gTrackCanvas.addEventListener("mouseout", mapEvHandler, false);
+
+ gTrackCanvas.addEventListener("touchstart", mapEvHandler, false);
+ gTrackCanvas.addEventListener("touchmove", mapEvHandler, false);
+ gTrackCanvas.addEventListener("touchend", mapEvHandler, false);
+ gTrackCanvas.addEventListener("touchcancel", mapEvHandler, false);
+ gTrackCanvas.addEventListener("touchleave", mapEvHandler, false);
+
+ gTrackCanvas.addEventListener("wheel", mapEvHandler, false);
+
+ document.getElementById("body").addEventListener("keydown", mapEvHandler, false);
+
+ document.getElementById("copyright").innerHTML =
+ gMapStyles[gActiveMap].copyright;
+
+ gLoadingTile = new Image();
+ gLoadingTile.src = "style/loading.png";
+ gLoadingTile.onload = function() {
+ var throwEv = new CustomEvent("prefload-done");
+ gAction.dispatchEvent(throwEv);
+ };
+ }
+ }
+ else {
+ if (aEvent)
+ gAction.removeEventListener(aEvent.type, loadPrefs, false);
+ gAction.addEventListener("prefs-step", loadPrefs, false);
+ gWaitCounter++;
+ gPrefs.get("position", function(aValue) {
+ if (aValue) {
+ gPos = aValue;
+ }
+ gWaitCounter--;
+ var throwEv = new CustomEvent("prefs-step");
+ gAction.dispatchEvent(throwEv);
+ });
+ gWaitCounter++;
+ gPrefs.get("center_map", function(aValue) {
+ if (aValue === undefined)
+ document.getElementById("centerCheckbox").checked = true;
+ else
+ document.getElementById("centerCheckbox").checked = aValue;
+ setCentering(document.getElementById("centerCheckbox"));
+ gWaitCounter--;
+ var throwEv = new CustomEvent("prefs-step");
+ gAction.dispatchEvent(throwEv);
+ });
+ gWaitCounter++;
+ gPrefs.get("tracking_enabled", function(aValue) {
+ if (aValue === undefined)
+ document.getElementById("trackCheckbox").checked = true;
+ else
+ document.getElementById("trackCheckbox").checked = aValue;
+ gWaitCounter--;
+ var throwEv = new CustomEvent("prefs-step");
+ gAction.dispatchEvent(throwEv);
+ });
+ gWaitCounter++;
+ var trackLoadStarted = false;
+ var redrawBase = 100;
+ gTrackStore.getListStepped(function(aTPoint) {
+ if (aTPoint) {
+ // Add in front and return new length.
+ var tracklen = gTrack.unshift(aTPoint);
+ // Redraw track periodically, larger distance the longer it gets.
+ // Initial paint will do initial track drawing.
+ if (tracklen % redrawBase == 0) {
+ drawTrack();
+ redrawBase = tracklen;
+ }
+ }
+ else {
+ // Last point received.
+ drawTrack();
+ }
+ if (!trackLoadStarted) {
+ // We have the most recent point, if present, rest will load async.
+ trackLoadStarted = true;
+ gWaitCounter--;
+ var throwEv = new CustomEvent("prefs-step");
+ gAction.dispatchEvent(throwEv);
+ }
+ });
+ }
+}
+
+function initGL() {
+ if (gMapGL) {
+ gMapGL.clearColor(0.0, 0.0, 0.0, 0.5); // Set clear color to black, fully opaque.
+ gMapGL.clear(gMapGL.COLOR_BUFFER_BIT|gMapGL.DEPTH_BUFFER_BIT); // Clear the color.
+
+ // Create and initialize the shaders.
+ var vertShader = gMapGL.createShader(gMapGL.VERTEX_SHADER);
+ var vertShaderSource =
+ 'attribute vec2 aVertexPosition;\n' +
+ 'attribute vec2 aTextureCoord;\n\n' +
+ 'uniform vec2 uResolution;\n\n' +
+ 'varying highp vec2 vTextureCoord;\n\n' +
+ 'void main(void) {\n' +
+ // convert the rectangle from pixels to -1.0 to +1.0 (clipspace) 0.0 to 1.0
+ ' vec2 clipSpace = aVertexPosition * 2.0 / uResolution - 1.0;\n' +
+ ' gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);\n' +
+ ' vTextureCoord = aTextureCoord;\n' +
+ '}';
+ var fragShader = gMapGL.createShader(gMapGL.FRAGMENT_SHADER);
+ var fragShaderSource =
+ 'varying highp vec2 vTextureCoord;\n\n' +
+ 'uniform sampler2D uImage;\n\n' +
+ 'void main(void) {\n' +
+ ' gl_FragColor = texture2D(uImage, vTextureCoord);\n' +
+ '}';
+
+ gMapGL.shaderSource(vertShader, vertShaderSource);
+ // Compile the shader program.
+ gMapGL.compileShader(vertShader);
+ // See if it compiled successfully.
+ if (!gMapGL.getShaderParameter(vertShader, gMapGL.COMPILE_STATUS)) {
+ console.log("An error occurred compiling the vertix shader: " + gMapGL.getShaderInfoLog(vertShader));
+ return null;
+ }
+ gMapGL.shaderSource(fragShader, fragShaderSource);
+ // Compile the shader program.
+ gMapGL.compileShader(fragShader);
+ // See if it compiled successfully.
+ if (!gMapGL.getShaderParameter(fragShader, gMapGL.COMPILE_STATUS)) {
+ console.log("An error occurred compiling the fragment shader: " + gMapGL.getShaderInfoLog(fragShader));
+ return null;
+ }
+
+ var shaderProgram = gMapGL.createProgram();
+ gMapGL.attachShader(shaderProgram, vertShader);
+ gMapGL.attachShader(shaderProgram, fragShader);
+ gMapGL.linkProgram(shaderProgram);
+ // If creating the shader program failed, alert
+ if (!gMapGL.getProgramParameter(shaderProgram, gMapGL.LINK_STATUS)) {
+ alert("Unable to initialize the shader program.");
+ }
+ gMapGL.useProgram(shaderProgram);
+ var vertexPositionAttribute = gMapGL.getAttribLocation(shaderProgram, "aVertexPosition");
+ var textureCoordAttribute = gMapGL.getAttribLocation(shaderProgram, "aTextureCoord");
+ var resolutionAttribute = gMapGL.getUniformLocation(shaderProgram, "uResolution");