├── .env.example
├── .gitignore
├── LICENSE
├── README.md
├── index.js
├── package.json
├── scripts
    ├── startgps.py
    └── stopgps.py
├── signal-logr-rtl-sdr.png
├── signal-logr.png
└── www
    ├── dashboard.html
    ├── dashboard.js
    ├── gmap.html
    ├── img
        ├── focus.png
        ├── gpio.png
        ├── gps.png
        ├── restart.png
        ├── rtlsdr.jpeg
        └── wifi.png
    └── jquery-ui-timepicker-addon.js


/.env.example:
--------------------------------------------------------------------------------
1 | apiKey=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Logs
 2 | logs
 3 | *.log
 4 | npm-debug.log*
 5 | 
 6 | # Runtime data
 7 | pids
 8 | *.pid
 9 | *.seed
10 | 
11 | # Directory for instrumented libs generated by jscoverage/JSCover
12 | lib-cov
13 | 
14 | # Coverage directory used by tools like istanbul
15 | coverage
16 | 
17 | # nyc test coverage
18 | .nyc_output
19 | 
20 | # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
21 | .grunt
22 | 
23 | # node-waf configuration
24 | .lock-wscript
25 | 
26 | # Compiled binary addons (http://nodejs.org/api/addons.html)
27 | build/Release
28 | 
29 | # Dependency directories
30 | node_modules
31 | jspm_packages
32 | 
33 | # Optional npm cache directory
34 | .npm
35 | 
36 | # Optional REPL history
37 | .node_repl_history
38 | 
39 | #Project data files
40 | data/wifi/*.json
41 | data/gps/*.json
42 | www/dump1090/*.json
43 | .env
44 | # fuck you npm
45 | package-lock.json
46 | 
47 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2016 tobozo
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | **Air logger for Raspberry Pi**
  2 | ===========
  3 | 
  4 | This is an attempt to build a GPS + Wifi logger for war walking, with the addition of ADSB tracking.
  5 | This build requires at least a Pi2 + Serial GPS + Wifi USB Dongle + RTL-SDR Dongle.
  6 | The collected data can be rendered later or observed in realtime through the HTML5 GUI.
  7 | 
  8 | <p align="center">
  9 | <img src="https://raw.githubusercontent.com/tobozo/signal-logr/master/signal-logr.png" />
 10 | </p>
 11 | <p align="center">
 12 | <img src="https://raw.githubusercontent.com/tobozo/signal-logr/master/signal-logr-rtl-sdr.png" />
 13 | </p>
 14 | 
 15 | **OS/System Requirements:**
 16 | ----
 17 | 
 18 | - Raspbian Stretch (works with Jessie too)
 19 | - NodeJS
 20 | - ForeverJS (https://github.com/foreverjs/forever)
 21 | - gpsd (http://catb.org/gpsd/)
 22 | - A GPS device connected to the Pi
 23 | - A Wifi device connected to the Pi
 24 | - A valid Google Maps Api key (https://developers.google.com/maps/documentation/javascript/get-api-key)
 25 | - A GSM/GPRS device (such as [this one](https://www.waveshare.com/wiki/GSM/GPRS/GNSS_HAT))
 26 | - A RTL-SDR dongle (see [this page](https://www.rtl-sdr.com/buy-rtl-sdr-dvb-t-dongles/))
 27 | 
 28 | **Installation:**
 29 | ----
 30 | 
 31 | **Prerequisites** GPS / Wifi / RTL-SDR devices are plugged in
 32 | 
 33 | Choose your veersion and [install NodeJS](https://github.com/nodesource/distributions#debinstall)
 34 | 
 35 | Install RTL-SDR software 
 36 | 
 37 |     cd ~
 38 |     git clone https://github.com/MalcolmRobb/dump1090
 39 |     cd dump1090
 40 |     make
 41 | 
 42 | If using GSM/GPRS/GNSS hat instead of external GPS module, start by [installing GSM/GPRS/GNSS software from WaveShare](https://www.waveshare.com/wiki/GSM/GPRS/GNSS_HAT) first.
 43 | Any other GPS will do as long as it is supported by gpsd and detected by the Pi.
 44 | 
 45 | Install gpsd
 46 | 
 47 |     sudo apt-get install gpsd
 48 | 
 49 | Edit your `/etc/defaults/gpsd`
 50 | 
 51 |     sudo nano /etc/defaults/gpsd
 52 | 
 53 | Verify the tty of your GPS device, change if necessary
 54 | 
 55 |     DEVICES="/dev/ttyUSB0"
 56 | 
 57 | Other values to check
 58 | 
 59 |     START_DAEMON="true"
 60 |     USBAUTO="false"
 61 | 
 62 | Then restart gpsd
 63 | 
 64 |     sudo service gpsd restart
 65 | 
 66 | You need *forever.js* installed globally to run this project headless
 67 | 
 68 |     sudo npm install forever -g
 69 | 
 70 | Clone the repository and install
 71 | 
 72 |     cd ~
 73 |     git clone https://github.com/tobozo/signal-logr.git
 74 |     cd signal-logr
 75 |     npm install
 76 | 
 77 | Put your Google Maps Api key in the `.env` file
 78 | 
 79 |     cp .env.example .env
 80 |     nano .env
 81 | 
 82 | Test the app
 83 | 
 84 |     node index.js
 85 | 
 86 | You can add to `/etc/rc.local` and reboot
 87 | 
 88 |     cd /home/pi/signal-logr/ && /opt/nodejs/bin/forever start index.js
 89 | 
 90 | 
 91 | ****
 92 | **Useful links**
 93 | ----
 94 |   * http://www.catb.org/gpsd/troubleshooting.html
 95 |   * http://www.xarg.org/2016/06/neo6mv2-gps-module-with-raspberry-pi/
 96 |   * https://bigdanzblog.wordpress.com/2015/01/18/connecting-u-blox-neo-6m-gps-to-raspberry-pi/
 97 |   * http://www.bashpi.org/?page_id=459
 98 | 
 99 | ****
100 | **Roadmap**
101 | ----
102 | * Enable GSM/GPRS data collection using sim900 / sim800
103 | * Enable rogue mode + sms/ppp notifications
104 | * Compliance with more advanced wifi tools and platforms (e.g. Kali)
105 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
  1 | /*
  2 | 
  3 |   RPi-GPS-Wifi logger
  4 |   (c+) tobozo 2016-11-13
  5 | 
  6 |  */
  7 | 
  8 | require('dotenv').config();
  9 | 
 10 | // load app stack
 11 | 
 12 | const express = require('express')
 13 |   , app = express()
 14 |   , http = require('http').Server(app)
 15 |   , request = require('request')
 16 |   , io = require('socket.io')(http)
 17 |   , gpsd = require("node-gpsd")
 18 |   , GPS = require('gps')
 19 |   , exec = require('child_process').exec
 20 |   , spawn = require('child_process').spawn
 21 |   , execSync = require("child_process").execSync
 22 |   , jsonfile = require('jsonfile')
 23 |   , fs = require('fs')
 24 |   , Wireless = require('wireless')
 25 |   , os = require('os')
 26 |   , path = require('path')
 27 | ;
 28 | 
 29 | // throw some vars
 30 | let connected = false
 31 |   , killing_app = false
 32 |   , oldalias = 0
 33 |   , secondsSinceLastPoll = 0
 34 |   , fixPoll = []
 35 |   , lastFix
 36 |   , currentFix
 37 |   , secondsSinceLastFix = 0
 38 |   , dataDir = __dirname + '/data'
 39 |   , geoDataDir = dataDir + '/gps/'
 40 |   , wifiDataDir = dataDir + '/wifi/'
 41 |   , htmlDir =  __dirname + '/www'
 42 |   , rtlsdrDataDir = htmlDir + '/dump1090'
 43 |   , dump1090Dir = '/home/pi/dump1090/'
 44 |   , dump1090HTMLDir = dump1090Dir + 'public_html/'
 45 |   , dump1090ConfigFile = dump1090HTMLDir + 'config.js'
 46 |   , dump1090timer
 47 |   , pollFiles = []
 48 |   , wifiFiles = []
 49 |   , wifiMaxHistoryItems = 100
 50 |   , googleMapsApiKey = process.env.apiKey
 51 |   , wifiCache = { }
 52 |   , gpstime = new Date()
 53 |   , gpsdaemonisrunning = true
 54 |   , gpshatisrunning = false
 55 |   , wirelessisrunning = false
 56 |   , rtlsdrisrunning = false
 57 | ;
 58 | 
 59 | 
 60 | if(googleMapsApiKey===undefined) console.log("[WARN] Missing apiKey in .env file, GUI may suffer");
 61 | 
 62 | const wireless = new Wireless({
 63 |     iface: 'wlan0',
 64 |     updateFrequency: 30, // Optional, seconds to scan for networks
 65 |     connectionSpyFrequency: 2, // Optional, seconds to scan if connected
 66 |     vanishThreshold: 5 // Optional, how many scans before network considered gone
 67 | });
 68 | 
 69 | 
 70 | const gpsWarn = function(msg) {
 71 |   console.log('[WARN] GPSD - ', msg);
 72 | }
 73 | const gpsErr = function(msg) {
 74 |   console.log('[ERROR] GPSD - ', msg);
 75 |   gpsdaemonisrunning = false;
 76 | }
 77 | 
 78 | 
 79 | const gps = new GPS;
 80 | 
 81 | 
 82 | const listener = new gpsd.Listener({
 83 |     port: 2947,
 84 |     hostname: 'localhost',
 85 |     emitraw: true,
 86 |     parsejson: false,
 87 |     logger:  {
 88 |         info:  function() {},
 89 |         warn:  gpsWarn,
 90 |         error: gpsErr
 91 |     },
 92 |     parse: false
 93 | });
 94 | 
 95 | 
 96 | const mkdirSync = function (path) {
 97 |   try {
 98 |     fs.mkdirSync(path);
 99 |   } catch(e) {
100 |     if ( e.code != 'EEXIST' ) throw e;
101 |   }
102 | }
103 | 
104 | 
105 | const checkInterfaces = function() {
106 |   if(wirelessisrunning===false) return;
107 |   const ifaces = os.networkInterfaces();
108 |   let alias = 0;
109 |   Object.keys(ifaces).forEach(function (ifname) {
110 |     alias = 0;
111 | 
112 |     ifaces[ifname].forEach(function (iface) {
113 | 
114 |       if ('IPv4' !== iface.family || iface.internal !== false) {
115 |         // skip over internal (i.e. 127.0.0.1) and non-ipv4 addresses
116 |         return;
117 |       }
118 | 
119 |       if (alias >= 1) {
120 |         // this single interface has multiple ipv4 addresses
121 |         //console.log(ifname + ':' + alias, iface.address);
122 |       } else {
123 |         // this interface has only one ipv4 adress
124 |         //console.log(ifname, iface.address);
125 |       }
126 |       ++alias;
127 |     });
128 |   });
129 | 
130 |   if(alias==0) {
131 |     console.log('no eth0: headless mode');
132 |   } else {
133 |     if(oldalias!==0 && oldalias!==alias) {
134 |       console.log('network changed, restarting nodejs app');
135 |       process.exit(0);
136 |     }
137 |   }
138 |   oldalias = alias;
139 | };
140 | 
141 | 
142 | const setPoll = function() {
143 |   secondsSinceLastFix++;
144 |   secondsSinceLastPoll++;
145 |   if(fixPoll.length === 0) {
146 |     return;
147 |   }
148 |   if(fixPoll.length>=100 || secondsSinceLastPoll>=60) {
149 |     savePoll();
150 |     secondsSinceLastPoll = 0;
151 |   }
152 | };
153 | 
154 | 
155 | const setFix = function() {
156 |   if(gpsdaemonisrunning===false) return;
157 |   if(lastFix===undefined) {
158 |     // not started yet
159 |     return;
160 |   }
161 |   if(currentFix===undefined) {
162 |     // setting initial currentFix
163 |     currentFix = lastFix;
164 |     fixPoll.push(lastFix);
165 |     return;
166 |   }
167 |   if(currentFix.time === lastFix.time) return; // don't create duplicates
168 |   fixPoll.push(lastFix);
169 |   currentFix = lastFix;
170 | }
171 | 
172 | 
173 | const savePoll = function() {
174 |   if(fixPoll.length===0) {
175 |     // can't save empty poll!
176 |     return;
177 |   }
178 | 
179 |   const fileName = geoDataDir + fixPoll[0].time.replace(/[^a-z0-9-]+/gi, '_') + '.json';
180 |   let wifilist = {};
181 |   try {
182 |     wifilist = wireless.list();
183 |   } catch(e) {
184 |     console.log('cannot save wifilist', e);
185 |   }
186 | 
187 |   jsonfile.writeFile(fileName, fixPoll, {spaces: 2}, function(err) {
188 |     if(err) console.error(err);
189 |     resetPoll();
190 |     refreshPollInventory();
191 |   });
192 | 
193 | }
194 | 
195 | 
196 | const resetPoll = function() {
197 |   fixPoll = [];
198 | }
199 | 
200 | 
201 | const refreshPollInventory = function() {
202 |   fs.readdir(geoDataDir, function(err, files) {
203 |     if(err) {
204 |       console.log('failed to get dir', geoDataDir, err);
205 |       return;
206 |     }
207 |     if(files.length===0) {
208 |       // geodatadir is empty!
209 |       return;
210 |     }
211 |     pollFiles = JSON.parse(JSON.stringify(files));
212 |     io.emit('pollsize', pollFiles.length);
213 |   });
214 | }
215 | 
216 | 
217 | const sendPollInventory = function() {
218 |   fs.readdir(geoDataDir, function(err, files) {
219 |     if(err) {
220 |       console.log('failed to get dir', geoDataDir, err);
221 |       return;
222 |     }
223 |     if(files.length===0) {
224 |       // geodatadir is empty!
225 |       return;
226 |     }
227 |     pollFiles = JSON.parse(JSON.stringify(files));
228 |     io.emit('pollfiles', files);
229 |   });
230 | }
231 | 
232 | const sendPollContent = function(fileName) {
233 |   let pollName = false;
234 |   // console.log('got poll content request', fileName);
235 |   pollFiles.forEach(function(tmpFileName) {
236 |     if(fileName === tmpFileName) {
237 |       pollName = fileName;
238 |     }
239 |   });
240 |   if(pollName===false) return;
241 |   jsonfile.readFile(geoDataDir + pollName, function(err, obj) {
242 |     if(err) {
243 |       console.log(err);
244 |       io.emit('pollfile', {filename:pollName, error: JSON.stringify(err)});
245 |       return;
246 |     }
247 |     io.emit('pollfile', {filename:pollName, content: obj});
248 |   });
249 | }
250 | 
251 | 
252 | const sendWifiCache = function() {
253 |   io.emit('wificache', wifiCache);
254 | }
255 | 
256 | const setWifiCache = function() {
257 |   if(wirelessisrunning===false) return;
258 |   if(Object.keys(wifiCache).length ===0) return;
259 |   sendWifiCache();
260 | }
261 | 
262 | 
263 | const saveWifi = function(wifi, event) {
264 |   const fileName = wifiDataDir + wifi.address.replace(/[^a-z0-9-]+/gi, '_') + '.json';
265 | 
266 |   jsonfile.readFile(fileName, function(err, obj) {
267 | 
268 |     if(obj===undefined || (err!==null && err.code==="ENOENT")) {
269 |       // console.log('new wifi device');
270 |       obj = {};
271 |       obj.iface = wifi;
272 |       obj.events = [];
273 |     }
274 | 
275 |     // prevent database explosion
276 |     if(obj.events.length > wifiMaxHistoryItems) {
277 |       while(obj.events.length > wifiMaxHistoryItems) {
278 |         obj.events.pop();
279 |       }
280 |     }
281 | 
282 |     obj.events.unshift([gpstime, event, wifi.channel, wifi.quality, wifi.strength]);
283 | 
284 |     jsonfile.writeFile(fileName, obj, {spaces:0}, function(err, obj) {
285 |       if(err) console.error(err);
286 |     });
287 | 
288 |   });
289 | }
290 | 
291 | 
292 | 
293 | const sendWifiInventory = function() {
294 |   fs.readdir(wifiDataDir, function(err, files) {
295 |     if(err) {
296 |       console.log('failed to get dir', geoDataDir, err);
297 |       return;
298 |     }
299 |     if(files.length===0) {
300 |       // wifidatadir is empty!
301 |       return;
302 |     }
303 |     wifiFiles = JSON.parse(JSON.stringify(files));
304 |     io.emit('wififiles', files);
305 |   });
306 | }
307 | 
308 | 
309 | const sendWifiContent = function(fileName) {
310 |   let wifiName = false;
311 |   // console.log('got wifi content request', fileName);
312 |   wifiFiles.forEach(function(tmpFileName) {
313 |     if(fileName === tmpFileName) {
314 |       wifiName = fileName;
315 |     }
316 |   });
317 |   if(wifiName===false) return;
318 |   jsonfile.readFile(wifiDataDir + wifiName, function(err, obj) {
319 |     if(err) {
320 |       console.log(err);
321 |       io.emit('wififile', {filename:wifiName, error: JSON.stringify(err)});
322 |       return;
323 |     }
324 |     io.emit('wififile', {filename:wifiName, content: obj});
325 |   });
326 | }
327 | 
328 | 
329 | const wirelessStart = function() {
330 |   if(wirelessisrunning===true) {
331 |     console.log("[INFO] Wireless already started");
332 |     return;
333 |   }
334 |   wireless.enable(function(err) {
335 |     if (err) {
336 |         console.log("[FAILURE] Unable to enable wireless card. Quitting...");
337 |         return;
338 |     }
339 |     console.log("[INFO] Wireless card enabled.");
340 |     console.log("[INFO] Starting wireless scan...");
341 |     wireless.start();
342 |     wirelessisrunning = true;
343 |   });
344 | }
345 | 
346 | 
347 | const wirelessStop = function() {
348 |   if(wirelessisrunning===false) {
349 |     console.log("[INFO] Wireless already stopped");
350 |     return;
351 |   }
352 |   wireless.disable(function() {
353 |       console.log("[INFO] Stopping Wifi");
354 |       wireless.stop();
355 |       wirelessisrunning = false;
356 |   });
357 | }
358 | 
359 | 
360 | 
361 | const onChildStdOut = function(data) {
362 |   console.log('[STDOUT]', data.toString());
363 | }
364 | const onChildStdErr = function(data) {
365 |   console.log('[STDOUT]', data.toString());
366 | }
367 | const onChildClose = function(code) {
368 |   console.log("[EOL] Finished with code " + code);
369 | }
370 | 
371 | const spawnChild = function(cmd, args, opts, onstdout, onstderr, onclose) {
372 |   let child = spawn(cmd, args, opts);
373 |   child.stdout.on('data', onstdout);
374 |   child.stderr.on('data', onstderr);
375 |   child.on('close', onclose);
376 | }
377 | 
378 | const dump1090JSON = function() {
379 |   // get http://localhost:8080/dump1090/data.json 
380 |   // write locally
381 |   //request('http://localhost:8080/dump1090/data.json').pipe(fs.createWriteStream(htmlDir + '/dump1090/data.json'))
382 |   request('http://localhost:8080/dump1090/data.json', function (error, response, body) {
383 |     if(response && response.statusCode && response.statusCode==200) {
384 |       io.emit('rtlsdr', body);
385 |     }
386 |   });//.pipe(io.emit('rtlsdr'))
387 | }
388 | 
389 | 
390 | const startDump1090 = function() {
391 |   //execSync(dump1090Dir + 'dump1090 --net --net-http-port 8080 --quiet &');
392 |   stopDump1090();
393 |   spawnChild(dump1090Dir + 'dump1090', ['--net', '--net-http-port', '8080', '--quiet'], {cwd:dump1090Dir}, onChildStdOut, onChildStdErr, function() {
394 |     console.log('[INFO] dump1090 exited Successfully!');
395 |     rtlsdrisrunning = false;
396 |   });
397 |   
398 |   rtlsdrisrunning = true;
399 |   clearInterval( dump1090timer );
400 |   dump1090timer = setInterval( dump1090JSON, 5000);
401 |   
402 |   console.log('[INFO] RTLSDR Device Started Successfully!');
403 | }
404 | const stopDump1090 = function() {
405 |   try {
406 |     execSync('sudo killall dump1090');
407 |   } catch(e) { ; }
408 |   rtlsdrisrunning = false;
409 |   clearInterval( dump1090timer );
410 |   console.log('[INFO] RTLSDR Device Killed Successfully!');
411 | }
412 | 
413 | 
414 | const startGPSDaemon = function() {
415 |   execSync('sudo service gpsd restart');
416 |   console.log('[INFO] GPS Daemon Started Successfully, will restart server');
417 |   gpsdaemonisrunning = true;
418 |   process.exit(0);
419 | }
420 | const stopGPSDaemon = function() {
421 |   execSync('sudo service gpsd stop');
422 |   console.log('[INFO] GPS Daemon Stopped Successfully');
423 |   gpsdaemonisrunning = false;
424 |   //process.exit(0);
425 | }
426 | 
427 | const startGPSDevice = function() {
428 |   spawnChild('python', ['scripts/startgps.py'], {}, onChildStdOut, onChildStdErr, function() {
429 |     gpsdaemonisrunning = true;
430 |     console.log('[INFO] GPS Device Started Successfully!');
431 |     startGPSDaemon();
432 |   });
433 | }
434 | const stopGPSDevice = function() {
435 |   spawnChild('python', ['scripts/stopgps.py'], {}, onChildStdOut, onChildStdErr, function() {
436 |     gpsdaemonisrunning = true;
437 |     console.log('[INFO] GPS Device Stopped Successfully!');
438 |     stopGPSDaemon();
439 |   });
440 | }
441 | 
442 | const sendDeviceStatus = function() {
443 |   io.emit('device-status', {
444 |      wirelessisrunning:wirelessisrunning,
445 |     gpsdaemonisrunning:gpsdaemonisrunning,
446 |        gpshatisrunning:gpshatisrunning,
447 |        rtlsdrisrunning:rtlsdrisrunning
448 |   });
449 | }
450 | 
451 | 
452 | mkdirSync( dataDir );
453 | mkdirSync( geoDataDir );
454 | mkdirSync( wifiDataDir);
455 | mkdirSync( rtlsdrDataDir );
456 | 
457 | setInterval(checkInterfaces, 20000); // check for network change every 20 sec
458 | setInterval(setPoll, 1000);
459 | setInterval(setFix, 1000);
460 | setInterval(setWifiCache, 61000); // force wifi cache reload every minute
461 | setInterval(sendDeviceStatus, 1000); // send device status every second
462 | 
463 | 
464 | listener.connect(function() {
465 |   console.log('[INFO] Connected and Listening to GPSD');
466 |   gpsdaemonisrunning = true;
467 | });
468 | 
469 | 
470 | listener.watch({class: 'WATCH', nmea: true});
471 | 
472 | // tell express to use ejs for rendering HTML files:
473 | app.set('views', htmlDir);
474 | //app.set('views', htmlDir+'/dump1090');
475 | app.engine('html', require('ejs').renderFile);
476 | 
477 | // feed the dashboard with the apiKey
478 | app.get('/', function(req, res) {
479 |   res.render('dashboard.html', {
480 |     apiKey: googleMapsApiKey
481 |   });
482 | });
483 | 
484 | app.get('/jquery-ui-timepicker-addon.js', function(req, res) {
485 |   res.sendFile(htmlDir + '/jquery-ui-timepicker-addon.js');
486 | });
487 | app.get('/gmap.html', function(req, res) {
488 |   res.render('gmap.html', {
489 |     host: req.headers.host.replace('3000', '8080'),
490 |     lat: lastFix.lat,
491 |     lon: lastFix.lon
492 |   });
493 |   //res.sendFile(htmlDir + '/gmap.html');
494 | });
495 | 
496 | 
497 | app.get('/dump1090/data.json', function(req, res) {
498 |   res.sendFile(htmlDir + '/dump1090/data.json');
499 | });
500 | 
501 | app.get('/dashboard.js', function(req, res) {
502 |   res.sendFile(htmlDir + '/dashboard.js');
503 | });
504 | app.use(express.static(path.join(__dirname, 'www/img')));
505 | 
506 | http.listen(3000, function() {
507 |   console.log('[INFO] Web Server GUI listening on *:3000');
508 | 
509 |   gps.on('data', function() {
510 |     io.emit('state', gps.state);
511 |     //console.log('[state]', gps.state);
512 |     if(gps.state.fix && gps.state.fix==='3D') {
513 |       if(gps.state.lat===0 || gps.state.lat===null) return;
514 |       if(gps.state.lon===0 || gps.state.lon===null) return;
515 |       lastFix = JSON.parse(JSON.stringify(gps.state));
516 |       secondsSinceLastFix = 0;
517 |     }
518 |     if(gps.time) {
519 |       gpstime = new Date(gps.time);
520 |     }
521 |   });
522 | 
523 | 
524 |   listener.on('raw', function(data) {
525 |     gpshatisrunning = true;
526 |     try {
527 |       gps.update(data);
528 |       //console.log('[RAW]', data);
529 |     } catch(e) {
530 |       console.log('invalid data');
531 |       console.log(data)
532 |       console.dir(e);
533 |     }
534 |   });
535 | 
536 | 
537 |   io.sockets.on('connection', function (socket) {
538 | 
539 |     socket.on('gpsenable', function(data) {
540 |       console.log('[INFO] Will enable GPS');
541 |       startGPSDevice();
542 |     });
543 |     socket.on('gpsdisable', function(data) {
544 |       console.log('[INFO] Will disable GPS');
545 |       stopGPSDevice();
546 |     });
547 |     socket.on('gpsdaemonstart', function(data) {
548 |       startGPSDaemon();
549 |     });
550 |     socket.on('gpsdaemonstop', function(data) {
551 |       stopGPSDaemon();
552 |     });
553 |     socket.on('rtlsdrenable', function(data) {
554 |       wirelessStop();
555 |       startDump1090();
556 |       rtlsdrisrunning = true;
557 |     });
558 |     socket.on('rtlsdrdisable', function(data) {
559 |       stopDump1090();
560 |     });
561 |     socket.on('wifienable', function(data) {
562 |       stopDump1090();
563 |       wirelessStart();
564 |       rtlsdrisrunning = false;
565 |     });
566 |     socket.on('wifidisable', function(data) {
567 |       wirelessStop();
568 |     });
569 |     
570 |     
571 |     //socket.on('sms', function(data) {
572 |     //  console.log('received event sms', data);
573 |     //  var gammu = "/usr/bin/sudo";
574 |     //  var destination = "0606060606";
575 |     //  var cmdargs = '';
576 |     //  cmdargs = ' /usr/bin/gammu-smsd-inject TEXT ' + destination + ' -text "'+data.msg+'"';
577 |     //  console.log(gammu+cmdargs);
578 |     //  execSync([gammu+cmdargs]);
579 |     //});
580 | 
581 |     socket.on('reload', function(data) {
582 |       // foreferjs
583 |       process.exit(0);
584 |     });
585 | 
586 |     socket.on('poll-files', sendPollInventory);
587 |     socket.on('poll-content', sendPollContent);
588 |     socket.on('wifi-cache', sendWifiCache);
589 |     socket.on('device-status', sendDeviceStatus);
590 | 
591 |   });
592 | 
593 |   setTimeout(function() {
594 |     console.log('will reload web UI');
595 |     io.emit('reload', {go:true});
596 |   }, 2000);
597 | 
598 | 
599 |   wirelessStart();
600 | 
601 | });
602 | 
603 | 
604 | // Found a new network
605 | wireless.on('appear', function(network) {
606 |     const quality = Math.floor(network.quality / 70 * 100);
607 | 
608 |     network.ssid = network.ssid || '[HIDDEN]';
609 | 
610 |     network.encryption_type = 'NONE';
611 |     if (network.encryption_wep) {
612 |         network.encryption_type = 'WEP';
613 |     } else if (network.encryption_wpa && network.encryption_wpa2) {
614 |         network.encryption_type = 'WPA-WPA2';
615 |     } else if (network.encryption_wpa) {
616 |         network.encryption_type = 'WPA';
617 |     } else if (network.encryption_wpa2) {
618 |         network.encryption_type = 'WPA2';
619 |     }
620 |     io.emit('wifi', {appear:network});
621 |     wifiCache[network.address] = network;
622 |     //console.log("[  APPEAR] " + network.ssid + " [" + network.address + "] " + quality + "% " + network.strength + "dBm " + network.encryption_type);
623 |     saveWifi(network, 'appear');
624 | });
625 | 
626 | wireless.on('change', function(network) {
627 |     const quality = Math.floor(network.quality / 70 * 100);
628 | 
629 |     network.ssid = network.ssid || '[HIDDEN]';
630 | 
631 |     network.encryption_type = 'NONE';
632 |     if (network.encryption_wep) {
633 |         network.encryption_type = 'WEP';
634 |     } else if (network.encryption_wpa && network.encryption_wpa2) {
635 |         network.encryption_type = 'WPA-WPA2';
636 |     } else if (network.encryption_wpa) {
637 |         network.encryption_type = 'WPA';
638 |     } else if (network.encryption_wpa2) {
639 |         network.encryption_type = 'WPA2';
640 |     }
641 |     io.emit('wifi', {appear:network});
642 |     wifiCache[network.address] = network;
643 |     //console.log("[  APPEAR] " + network.ssid + " [" + network.address + "] " + quality + "% " + network.strength + "dBm " + network.encryption_type);
644 |     saveWifi(network, 'change');
645 | });
646 | 
647 | 
648 | // A network disappeared (after the specified threshold)
649 | wireless.on('vanish', function(network) {
650 |     io.emit('wifi', {vanish:network});
651 |     if(wifiCache[network.address]!==undefined) {
652 |       delete(wifiCache[network.address]);
653 |     }
654 |     //console.log("[  VANISH] " + network.ssid + " [" + network.address + "] ");
655 |     saveWifi(network, 'vanish');
656 | });
657 | 
658 | wireless.on('error', function(message) {
659 |     // io.emit('wifi', {error:network});
660 |     console.log("[ERROR] Wifi / " + message);
661 |     wirelessStop();
662 |     /*
663 |     wireless.disable(function() {
664 |         console.log("[INFO] Stopping Wifi");
665 |         wireless.stop();
666 |     });
667 |     */
668 | });
669 | 
670 | 
671 | // User hit Ctrl + C
672 | process.on('SIGINT', function() {
673 |     console.log("\n");
674 | 
675 |     if (killing_app) {
676 |         console.log("[INFO] Double SIGINT, Killing without cleanup!");
677 |         process.exit();
678 |     }
679 | 
680 |     killing_app = true;
681 |     console.log("[INFO] Gracefully shutting down from SIGINT (Ctrl+C)");
682 |     console.log("[INFO] Disabling RTL-SDR Dongle");
683 |     stopDump1090();
684 |     console.log("[INFO] Disabling Wifi Adapter...");
685 |     wireless.disable(function() {
686 |         console.log("[INFO] Stopping Wifi and Exiting...");
687 |         wireless.stop();
688 |     });
689 | 
690 | });
691 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "signal-logr",
 3 |   "version": "1.0.0",
 4 |   "description": "GPS & Wifi Signal Logger + GUI for Raspberry Pi",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "test": "echo \"Error: no test specified\" && exit 1"
 8 |   },
 9 |   "author": "tobozo",
10 |   "license": "MIT",
11 |   "dependencies": {
12 |     "dotenv": "^2.0.0",
13 |     "ejs": "^2.5.2",
14 |     "express": "^4.14.0",
15 |     "gps": "^0.2.0",
16 |     "jsonfile": "^2.4.0",
17 |     "node-gpsd": "^0.2.6",
18 |     "request": "^2.83.0",
19 |     "socket.io": "^1.5.1",
20 |     "wireless": "^0.3.2"
21 |   }
22 | }
23 | 


--------------------------------------------------------------------------------
/scripts/startgps.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | #
 3 | # gps.py
 4 | # Script to start GPS on the WaveShare GSM/GPRS/GNSS hat https://www.waveshare.com/wiki/GSM/GPRS/GNSS_HAT
 5 | #
 6 | import wiringpi
 7 | import serial
 8 | import time, sys
 9 | import datetime
10 | import os, signal
11 | import argparse
12 | 
13 | ##############Begin process command line ###########
14 | parser = argparse.ArgumentParser(description='Enable GPS and display output')
15 | 
16 | parser.add_argument('--port', '-p',
17 |                     help='Serial port',
18 |                     type=str,
19 |                     default='/dev/ttyAMA0')
20 | 
21 | args = parser.parse_args()
22 | serial_port = args.port
23 | ##############End process command line ###########
24 | 
25 | # Wait for the nadhat answer
26 | def wait_Answer(code):
27 |     time.sleep(0.3)
28 |     rep = ser.read(ser.inWaiting()) # Check if the board answers
29 |     if rep != "":
30 |         if code in rep:
31 |             print "Answers : "+code
32 |         else :
33 |             print code+" not received : No communication with the board"
34 |             sys.exit(0)
35 |     else :
36 |         print "No response from the board"
37 |         sys.exit(1)
38 | 
39 | # Serial port init
40 | ser = serial.Serial(
41 |     port = serial_port,
42 |     baudrate = 115200,
43 |     parity = serial.PARITY_NONE,
44 |     stopbits = serial.STOPBITS_ONE,
45 |     bytesize = serial.EIGHTBITS
46 | )
47 | 
48 | # Check the communication with the nadhat board
49 | ser.write("AT\r") # Send AT command
50 | print "AT\r"
51 | wait_Answer("OK")
52 | 
53 | print "AT+CGNSTST=0\r" # turn off data sending (otherwise wait_Answer might raise false positives)
54 | 
55 | print "AT+CGNSPWR=1\r" # Turn on the power of GPS
56 | ser.write("AT+CGNSPWR=1\r")
57 | wait_Answer("OK")
58 | 
59 | #print "AT+CGNSSEQ=\"RMC\"\r" # RMC mode, Recommended Minimum Specific GNSS Data
60 | #ser.write("AT+CGNSSEQ=\"RMC\"\r")
61 | #wait_Answer("OK")
62 | 
63 | #print "AT+CGNSINF" # GNSS  navigation information parsed from NMEA sentences.
64 | #ser.write("AT+CGNSINF\r")
65 | #wait_Answer("OK")
66 | 
67 | #print "AT+CGNSURC=2" # set URC reporting every 2 seconds
68 | #ser.write("AT+CGNSURC=2\r")
69 | ser.write("AT+CGNSURC=0\r")
70 | #wait_Answer("OK")
71 | 
72 | print "AT+CGNSTST=1\r" # Send data received to UART
73 | ser.write("AT+CGNSTST=1\r")
74 | 
75 | print "END"
76 | 
77 | 


--------------------------------------------------------------------------------
/scripts/stopgps.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | #
 3 | # stopgps.py
 4 | # Script to stop GPS from spamming the serial
 5 | #
 6 | import wiringpi
 7 | import serial
 8 | import time, sys
 9 | import datetime
10 | import os, signal
11 | import argparse
12 | 
13 | ##############Begin process command line ###########
14 | parser = argparse.ArgumentParser(description='Enable GPS and display output')
15 | 
16 | parser.add_argument('--port', '-p',
17 |                     help='Serial port',
18 |                     type=str,
19 |                     default='/dev/ttyAMA0')
20 | 
21 | args = parser.parse_args()
22 | serial_port = args.port
23 | ##############End process command line ###########
24 | 
25 | # Wait for the nadhat answer
26 | def wait_Answer(code):
27 |     time.sleep(0.3)
28 |     rep = ser.read(ser.inWaiting()) # Check if the board answers
29 |     if rep != "":
30 |         if code in rep:
31 |             print "Answers : "+code
32 |         else :
33 |             print code+" not received : No communication with the board"
34 |             sys.exit(0)
35 |     else :
36 |         print "No response from the board"
37 |         sys.exit(1)
38 | 
39 | # Serial port init
40 | ser = serial.Serial(
41 |     port = serial_port,
42 |     baudrate = 115200,
43 |     parity = serial.PARITY_NONE,
44 |     stopbits = serial.STOPBITS_ONE,
45 |     bytesize = serial.EIGHTBITS
46 | )
47 | 
48 | # Check the communication with the nadhat board
49 | ser.write("AT\r") # Send AT command
50 | print "AT\r"
51 | wait_Answer("OK")
52 | 
53 | print "AT+CGNSTST=0\r" # turn off data sending (otherwise wait_Answer might raise false positives)
54 | 
55 | print "END"
56 | 
57 | 
58 | 
59 | 
60 | 
61 | 
62 | 
63 | 


--------------------------------------------------------------------------------
/signal-logr-rtl-sdr.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tobozo/signal-logr/5228b0f6c50e7d698a4ed0bef006ea793c1e5ce0/signal-logr-rtl-sdr.png


--------------------------------------------------------------------------------
/signal-logr.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tobozo/signal-logr/5228b0f6c50e7d698a4ed0bef006ea793c1e5ce0/signal-logr.png


--------------------------------------------------------------------------------
/www/dashboard.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | <head>
  4 | <title>GPS/Wifi Dashboard</title>
  5 | <meta name="viewport" content="initial-scale=1.0">
  6 | <meta charset="utf-8">
  7 | <style>
  8 | 
  9 | body {
 10 |   font-family: arial;
 11 | }
 12 | 
 13 | th{
 14 |   text-align:right
 15 | }
 16 | td {
 17 |   text-align: left;
 18 | }
 19 | .map-holder {
 20 |   width:100%;
 21 |   height:500px;
 22 |   display: flex;
 23 | }
 24 | #mapid {
 25 |   height: 100%;
 26 |   width:100%;
 27 | }
 28 | #pollsize {
 29 |   position: relative;
 30 | }
 31 | #pollsize:before {
 32 |   content: attr(data-label) " (" attr(data-pollsize) ")";
 33 | }
 34 | .dataviz {
 35 |   transform: scale(.5);
 36 |   transform-origin: top left;
 37 |   position:absolute;
 38 | }
 39 | svg {
 40 |   display: block;
 41 | }
 42 | header {
 43 |   /*min-height: 12rem;*/
 44 | }
 45 | /* css for timepicker */
 46 | .ui-timepicker-div dl{ text-align: left; }
 47 | .ui-timepicker-div dl dt{ height: 25px; }
 48 | .ui-timepicker-div dl dd{ margin: -25px 0 10px 65px; }
 49 | .hasDatepicker { width: 5rem; }
 50 | 
 51 | .panel, .panel button, .panel input {
 52 |   font-size: calc(100vw / 75);
 53 | }
 54 | 
 55 | .gps-info {
 56 |   float:right;
 57 |   margin: 0 1rem 1rem 0;
 58 |   width:370px;
 59 | }
 60 | 
 61 | .wifi-wrapper {
 62 |   width: auto; 
 63 |   height: 8rem; 
 64 |   position: relative; 
 65 |   margin-left: 290px;
 66 |   margin-bottom: 1rem;
 67 |   width:270px;
 68 | }
 69 | 
 70 | .wifi-wrapper .title,
 71 | .dataviz .title,
 72 | .gps-info .title {
 73 |   font-weight: bold;
 74 |   padding-bottom: .5em;
 75 |   text-align: center;
 76 | }
 77 | .dataviz .title {
 78 |   font-size: 2em;
 79 |   padding-bottom:0;
 80 | }
 81 | 
 82 | .title select {
 83 |   font-size:75%;
 84 |   border:0;
 85 | }
 86 | 
 87 | .wifi-list {
 88 |     height: 100%;
 89 |     overflow-x: hidden;
 90 |     overflow-y: visible;
 91 |     width: 100%;
 92 | }
 93 | 
 94 | .wifi-list::before {
 95 |     content: attr(data-iface-size);
 96 |     position: absolute;
 97 |     left: -1.5em;
 98 |     top: 2em;
 99 | }
100 | 
101 | .wifi-list > div {
102 |     font-size: 0.83rem;
103 |     padding: 0.2rem 0.3rem;
104 |     box-sizing: border-box;
105 |     box-shadow: -13px 2px 8px black;
106 |     position:relative;
107 | }
108 | 
109 | .wifi-bar::before {
110 |     content: "";
111 |     display: block;
112 |     font-weight: bold;
113 |     height: .18rem;
114 |     padding:0;
115 |     margin:0;
116 |     text-align: center;
117 |     width:.75rem;
118 |     background-color: currentColor;
119 | }
120 | .wifi-bar {
121 |     width: 0;
122 |     padding:0;
123 |     color: green;
124 | }
125 | .wifi-bar.off {
126 |     color: orange;
127 | }
128 | .signal-box {
129 |     display: block;
130 |     width: .75rem;
131 |     position: relative;
132 |     margin-right:0.3rem;
133 |     padding:0;
134 |     float: left;
135 |     vertical-align: middle;
136 |     box-shadow: 0 0 1px red;
137 | }
138 | .iface-box {
139 |     vertical-align: middle;
140 | }
141 | .iface-name {
142 |     display: block;
143 |     position: relative;
144 |     text-shadow: 0 0 1px white, 1px 1px 2px black;
145 |     color: black;
146 |     font-weight: bold;
147 |     font-family: arial
148 |     float: left;
149 |     line-height: 1.2rem;
150 |     white-space: nowrap;
151 |     text-overflow: ellipsis;
152 |     overflow: hidden;
153 | }
154 | 
155 | [data-encryption-type]::before {
156 |     float: left;
157 |     content: " "; /*attr(data-encryption-type);*/
158 |     font-size: .5rem;
159 |     margin: 0;
160 |     font-family: arial;
161 |     font-weight: normal;
162 |     margin-right: .2rem;
163 |     width: 1em;
164 |     height: 1em;
165 |     border: 1px solid;
166 |     background: blue;
167 | }
168 | [data-encryption-type="wpa-wpa2"]::before {
169 |     background: yellow;
170 | }
171 | [data-encryption-type="wpa2"]::before {
172 |     background: lightgreen;
173 | }
174 | [data-encryption-type="wpa"]::before {
175 |     background: green;
176 | }
177 | [data-encryption-type="wep"]::before {
178 |     background: orange;
179 | }
180 | [data-encryption-type="none"]::before {
181 |     background: red;
182 | }
183 | 
184 | .legend [data-encryption-type] {
185 |     display: inline-block;
186 |     font-size: 0.75rem;
187 | }
188 | 
189 | 
190 | .device-status {
191 |   position: fixed;
192 |   bottom: 1em;
193 |   right: 1em;
194 | }
195 | .device-status > div {
196 |   width:2em;
197 |   height:2em;
198 |   display: inline-block;
199 |   background-repeat:no-repeat;
200 |   background-position: center center;
201 |   background-size: cover;
202 | }
203 | 
204 | .device-status > div.disabled {
205 |   /*opacity: 0.5;*/
206 |   filter:grayscale(100%) brightness(40%) sepia(100%) hue-rotate(-50deg) saturate(600%) contrast(0.8);
207 | }
208 | 
209 | .device-wifi { background-image:url('/wifi.png'); }
210 | .device-gpsdaemon { background-image:url('/gps.png'); }
211 | .device-gpshat { background-image:url('/gpio.png'); }
212 | .device-rtlsdr { background-image:url('/rtlsdr.jpeg'); }
213 | #focus-lastfix { background-image:url('/focus.png'); }
214 | #reload-ws { background-image:url('/restart.png'); }
215 | 
216 | 
217 | .rtlsdr-wrapper {
218 |   font-size: 10px;
219 |   width: 300px;
220 | }
221 | 
222 | fieldset { border:0; }
223 | .gps-heatmap-options { display: none; }
224 | legend.active + .gps-heatmap-options { display: block; }
225 | legend::after {
226 |   content:"[+]";
227 | }
228 | legend.active::after {
229 |   content:"[-]";
230 | }
231 | 
232 | /*
233 | .map-holder.rtlsdr {
234 |   width: auto;
235 |   flex: 1;
236 | }
237 | .map-holder.rtlsdr .rtlsdr-wrapper {
238 |   display: block;
239 |   flex: 1;
240 | }*/
241 | 
242 | </style>
243 | <link rel="stylesheet" href="http://code.jquery.com/ui/1.12.1/themes/base/jquery-ui.css" />
244 | </head>
245 | <body>
246 | <script src="/socket.io/socket.io.js"></script>
247 | <script src="https://cdnjs.cloudflare.com/ajax/libs/d3/3.5.14/d3.js"></script>
248 | <script src="https://code.jquery.com/jquery-2.2.0.min.js"></script>
249 | <script src="http://code.jquery.com/ui/1.12.1/jquery-ui.min.js"></script>
250 | <script src="/jquery-ui-timepicker-addon.js"></script>
251 | <script src="//maps.googleapis.com/maps/api/js?key=<%= apiKey %>&libraries=visualization,geometry"></script>
252 | <header>
253 |   <div class="dataviz" style="float:left">
254 |     <div class="title">GPS Satellites</div>
255 |     <div class="satellites"></div>
256 |     <div class="title wifi-item">Wifi Devices</div>
257 |     <div class="wifi  wifi-item"></div>
258 |   </div>
259 | 
260 |   <div class="gps-info">
261 |     <div class="title">GPS Info</div>
262 |     <table style="font-size:70%">
263 |       <tr>
264 |         <th>DOP</th>
265 |         <td>
266 |             P:<span id="pdop"></span> -
267 |             V:<span id="vdop"></span> -
268 |             H:<span id="hdop"></span>
269 |         </td>
270 |         <th>Date</th>
271 |         <td><span id="date"></span></td>
272 |       </tr>
273 |       <tr>
274 |         <th><span class="focus-latlng">Lat</span></th>
275 |         <td><span id="lat"></span></td>
276 |         <th><span class="focus-latlng">Lng</span></th>
277 |         <td><span id="lon"></span></td>
278 |       </tr>
279 |       <tr>
280 |         <th>Alt.</th>
281 |         <td><span id="alt"></span></td>
282 |         <th>Speed</th>
283 |         <td><span id="speed"></span></td>
284 |       </tr>
285 |       <tr>
286 |         <th>FIX</th>
287 |         <td><span id="status"></span> total (<span id="totalFixes">0</span>)</td>
288 |         <th>Sats in Use</th>
289 |         <td><span id="active"></span> / <span id="view"></span></td>
290 |       </tr>
291 |       <tr>
292 |         <td colspan="4" style="text-align:center">
293 |             <meter id="fix-progress" min="0" max="60" value="60"></meter>
294 |             <span id="secondsSinceLastFix">0</span> since last fix
295 |         </td>
296 |       </tr>
297 |     </table>
298 |   </div>
299 | 
300 |   <div class="device-status">
301 |     <div id="reload-ws" title="Restart Server"></div>
302 |     <div id="focus-lastfix" title="Focus Last Fix"></div>
303 |   
304 |     <div class="device-wifi" title="WiFi (will DISABLE RTL-SDR)"></div>
305 |     <div class="device-gpsdaemon" title="GPS Daemon"></div>
306 |     <div class="device-gpshat" title="GPIO Hat"></div>
307 |     <div class="device-rtlsdr" title="RTL-SRD Dongle (will DISABLE WiFi)"></div>
308 |   </div>
309 | 
310 |   
311 |   <div class="wifi-wrapper wifi-item">
312 |     <div class="title">
313 |       Wifi 
314 |       <select id="wifi-named-by" onchange="setWifiName()">
315 |         <option selected value="ssid">ssid</option>
316 |         <option value="address">address</option>
317 |       </select>
318 |       sorted by
319 |       <select id="wifi-sort-by" onchange="setWifiSort()">
320 |         <option selected value="quality">quality</option>
321 |         <option value="strength">strength</option>
322 |       </select>
323 |     </div>
324 |     <div class="wifi-list">Loading...</div>
325 |     <div class="legend">
326 |       <div data-encryption-type="wpa-wpa2">wpa+wpa2</div>
327 |       <div data-encryption-type="wpa2">wpa2</div>
328 |       <div data-encryption-type="wpa">wpa</div>
329 |       <div data-encryption-type="wep">wep</div>
330 |       <div data-encryption-type="none">none</div>
331 |     </div>
332 |   </div>
333 |   <div style="clear:both"></div>
334 | </header>
335 | <div style="clear:both"></div>
336 | <fieldset class="panel">
337 |   <legend onclick="this.classList.toggle('active')" align="right">GPS Heat Map Options</legend>
338 |   <div class="gps-heatmap-options">
339 |     Min Radius: <input type="number" id="radius" value="15" min="10" max="1500" style="width:3rem" />
340 |     After: <input type="datetime" id="date-filter-after" value="" placeholder="yyyy-mm-ddThh:mm:ss">
341 |     Before <input type="datetime" id="date-filter-before" value="" placeholder="yyyy-mm-ddThh:mm:ss">
342 |       <button id="pollsize" onclick="togglePollFiles()" data-pollsize="0" data-label="Start Retrieving data"></button>
343 |     <button style="display:none" id="initheatmap-button" class="button-control-heatmap" disabled onclick="initHeatmap()">Init heatmap</button>
344 |     <button onclick="location.reload()">Reset</button>
345 |     <br>
346 |     Layers: <button class="button-control-heatmap" disabled onclick="toggleHeatmap()">Toggle Heatmap</button>
347 |     <button class="button-control-heatmap" disabled onclick="changeGradient()">Change gradient</button>
348 |     <button class="button-control-heatmap" disabled onclick="changeRadius()">Change radius</button>
349 |     <button class="button-control-heatmap" disabled onclick="changeHeatmapOpacity()">Change Heatmap Opacity</button>
350 |     <button class="button-control-circle" onclick="changecircleOpacity()">Toggle Circle</button>
351 |   </div>
352 | </fieldset>
353 | 
354 | <div class="map-holder">
355 |   <div id="mapid"></div>
356 |   <div class="rtlsdr-wrapper">
357 |     <div class="rtlsdr-container">
358 |         <div id="plane_detail"></div>
359 |         <div id="options"></div>
360 |         <div id="planes_table"></div>
361 |         <div id="plane_extension"></div>
362 |     </div>
363 |   </div>
364 | </div>
365 | 
366 | 
367 | <script src="/dashboard.js"></script>
368 | </body>
369 | </html>
370 | 


--------------------------------------------------------------------------------
/www/dashboard.js:
--------------------------------------------------------------------------------
   1 | var mapElement,
   2 |     parent,
   3 |     mapOptions,
   4 |     map,
   5 |     marker,
   6 |     circle,
   7 |     bounds,
   8 |     latLng,
   9 |     openMarker,
  10 |     lastFix,
  11 |     lastState,
  12 |     nmeaInfo,
  13 |     rawData,
  14 |     secondsSinceLastFix = 0,
  15 |     totalFixes = 0,
  16 |     updateFreq = 1000,
  17 |     updateTimer = false,
  18 |     timeSinceLastPoll = 0,
  19 |     fixPoll = [],
  20 |     heatmap,
  21 |     heatmapData = [],
  22 |     heatmapFiles = {},
  23 |     heatmapCount = 0,
  24 |     pollReceiving = false,
  25 |     lastPoint = false,
  26 |     radius = 15,
  27 |     filterBefore,
  28 |     filterAfter,
  29 |     wifiCache = {},
  30 |     wifiTimeline = [],
  31 |     wifiSort = 'quality',
  32 |     wifiName = 'ssid',
  33 |     $wifilist = $('.wifi-list'),
  34 |     deviceStatus = {
  35 |       wifi:null,
  36 |       rtlsdr:null,
  37 |       gpshat:null,
  38 |       gpsdaemon:null
  39 |     },
  40 |     listKMLType = ['Approch', 'Departure', 'Transit', 'Custom1', 'Custom2'],
  41 |     listKMLs = localStorage['listKMLs'] || [],
  42 |     Planes        = {},
  43 |     PlanesOnMap   = 0,
  44 |     PlanesOnTable = 0,
  45 |     PlanesToReap  = 0,
  46 |     SelectedPlane = null,
  47 |     SpecialSquawk = false,
  48 |     iSortCol=-1,
  49 |     bSortASC=true,
  50 |     bDefaultSortASC=true,
  51 |     iDefaultSortCol=3,
  52 |     Metric = false,
  53 |     MarkerColor	  = "rgb(127, 127, 127)",
  54 |     SelectedColor = "rgb(225, 225, 225)",
  55 |     StaleColor = "rgb(190, 190, 190)",
  56 |     SiteShow    = false,
  57 |     SiteCircles = true, // true or false (Only shown if SiteShow is true)
  58 |     // In nautical miles or km (depending settings value 'Metric')
  59 |     SiteCirclesDistances = new Array(100,150,200)
  60 | ;
  61 | 
  62 | 
  63 | var socket = io();
  64 | 
  65 | var rad = function(x) {
  66 |     return x * Math.PI / 180;
  67 | };
  68 | 
  69 | var getDistance = function(p1, p2) {
  70 |     var R = 6378137; // Earth ^ ^ s mean radius in meter
  71 |     var dLat = rad(p2.lat() - p1.lat());
  72 |     var dLong = rad(p2.lng() - p1.lng());
  73 |     var a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
  74 |     Math.cos(rad(p1.lat())) * Math.cos(rad(p2.lat())) *
  75 |     Math.sin(dLong / 2) * Math.sin(dLong / 2);
  76 |     var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
  77 |     var d = R * c;
  78 |     return d; // returns the distance in meter
  79 | };
  80 | 
  81 | 
  82 | String.prototype.toHHMMSS = function () {
  83 |     var sec_num = parseInt(this, 10); // don't forget the second param
  84 |     var hours   = Math.floor(sec_num / 3600);
  85 |     var minutes = Math.floor((sec_num - (hours * 3600)) / 60);
  86 |     var seconds = sec_num - (hours * 3600) - (minutes * 60);
  87 | 
  88 |     if (10 > hours) {hours   = "0"+hours;}
  89 |     if (10 > minutes) {minutes = "0"+minutes;}
  90 |     if (10 > seconds) {seconds = "0"+seconds;}
  91 |     return hours+':'+minutes+':'+seconds;
  92 | }
  93 | 
  94 | String.prototype.replaceAll = function(search, replacement) {
  95 |     var target = this;
  96 |     return target.replace(new RegExp(search, 'g'), replacement);
  97 | };
  98 | 
  99 | 
 100 | google.maps.event.addDomListener(window, 'load', initializeMap);
 101 | 
 102 | var renderIface = function(iface) {
 103 |     var wifibar = '<div class="wifi-bar"></div>';
 104 |     var $ifacename = $('<div class="iface-name">'+iface[wifiName]+'</div>');
 105 |     var $ifacebox = $('<div class="iface-box"></div>')
 106 |     var $signalbox = $('<div class="signal-box"></div>');
 107 |     var clearfix = '<div style="clear:both"></div>';
 108 |     var signalstrength = Math.floor( iface.quality / 20 );
 109 |     var encryption_type = 'none';
 110 | 
 111 |     $ifacename.appendTo($ifacebox);
 112 | 
 113 |     for(var i=5;i>0;i--) {
 114 |         if(signalstrength>=i) {
 115 |             $(wifibar).appendTo($signalbox);
 116 |         } else {
 117 |             $(wifibar).addClass('off').appendTo($signalbox);
 118 |         }
 119 |     }
 120 | 
 121 |     $signalbox.prependTo($ifacebox);
 122 | 
 123 |     $ifacebox.css({
 124 |         "background-image": "linear-gradient(to right, lightgreen, rgba(125,0,0,0.5) "+ ( iface.quality - 1) + "%, transparent " + iface.quality + "%)"
 125 |     });
 126 | 
 127 |     if (iface.encryption_wep) {
 128 |         encryption_type = 'wep';
 129 |     } else if (iface.encryption_wpa && iface.encryption_wpa2) {
 130 |         encryption_type = 'wpa-wpa2';
 131 |     } else if (iface.encryption_wpa) {
 132 |         encryption_type = 'wpa';
 133 |     } else if (iface.encryption_wpa2) {
 134 |         encryption_type = 'wpa2';
 135 |     }
 136 | 
 137 |     $ifacename.attr('data-encryption-type', encryption_type);
 138 |     $ifacebox.attr('data-iface-addr', iface.address);
 139 |     $ifacebox.appendTo($wifilist);
 140 |     $(clearfix).appendTo($ifacebox);
 141 | }
 142 | 
 143 | 
 144 | var renderWifiCache = function(data) {
 145 |     var ifaceList = Object.keys(data).sort(function(a,b){return data[b][wifiSort]-data[a][wifiSort]});
 146 |     wifiCache = data;
 147 |     $wifilist.empty();
 148 |     // console.log(ifaceList);
 149 |     ifaceList.forEach(function(iface) {
 150 |       renderIface(wifiCache[iface]);
 151 |     });
 152 |     $wifilist.attr('data-iface-size', ifaceList.length);
 153 |     updateWifi(wifiCache);
 154 | }
 155 | 
 156 | 
 157 | socket.on('rtlsdr', function(data) {
 158 |   data = JSON.parse(data);
 159 |   console.log(data);
 160 |   PlanesOnMap = 0
 161 |   SpecialSquawk = false;
 162 |   
 163 |   // Loop through all the planes in the data packet
 164 |   for (var j=0; j < data.length; j++) {
 165 |       // Do we already have this plane object in Planes?
 166 |       // If not make it.
 167 |       if (Planes[data[j].hex]) {
 168 |           var plane = Planes[data[j].hex];
 169 |       } else {
 170 |           var plane = jQuery.extend(true, {}, planeObject);
 171 |       }
 172 |       
 173 |       /* For special squawk tests
 174 |       if (data[j].hex == '48413x') {
 175 |           data[j].squawk = '7700';
 176 |       } //*/
 177 |       
 178 |       // Set SpecialSquawk-value
 179 |       if (data[j].squawk == '7500' || data[j].squawk == '7600' || data[j].squawk == '7700') {
 180 |           SpecialSquawk = true;
 181 |       }
 182 | 
 183 |       // Call the function update
 184 |       plane.funcUpdateData(data[j]);
 185 |       
 186 |       // Copy the plane into Planes
 187 |       Planes[plane.icao] = plane;
 188 |   }
 189 | 
 190 |   PlanesOnTable = data.length;
 191 |   
 192 |   refreshTableInfo();
 193 |   refreshSelected();
 194 |   reaper();
 195 |   
 196 | });
 197 | 
 198 | 
 199 | socket.on('reload', function() { location.reload(); });
 200 | 
 201 | 
 202 | socket.on('device-status', function(data) {
 203 |   
 204 |   if(data.wirelessisrunning != deviceStatus.wifi) {
 205 |     deviceStatus.wifi = data.wirelessisrunning;
 206 |     if(deviceStatus.wifi) {
 207 |       $('.device-wifi').removeClass('disabled')
 208 |       $('.wifi-item').show();
 209 |       $('.rtlsdr-wrapper').hide();
 210 |       marker.setVisible(true);
 211 |     } else {
 212 |       $('.device-wifi').addClass('disabled');
 213 |       $('.wifi-item').hide();
 214 |     }
 215 |   }
 216 |   if(data.gpsdaemonisrunning != deviceStatus.gpsdaemon) {
 217 |     deviceStatus.gpsdaemon = data.gpsdaemonisrunning;
 218 |     if(deviceStatus.gpsdaemon)
 219 |       $('.device-gpsdaemon').removeClass('disabled');
 220 |     else
 221 |       $('.device-gpsdaemon').addClass('disabled');
 222 |   }
 223 |   if(data.rtlsdrisrunning != deviceStatus.rtlsdr) {
 224 |     deviceStatus.rtlsdr = data.rtlsdrisrunning;
 225 |     if(deviceStatus.rtlsdr) {
 226 |       $('.device-rtlsdr').removeClass('disabled')
 227 |       $('.wifi-item').hide();
 228 |       $('.rtlsdr-wrapper').show();
 229 |       marker.setVisible(false);
 230 |     } else {
 231 |       $('.device-rtlsdr').addClass('disabled');
 232 |       $('.wifi-item').show();
 233 |       $('.rtlsdr-wrapper').hide();
 234 |       marker.setVisible(true);
 235 |     }
 236 |   }
 237 |   if(data.gpshatisrunning != deviceStatus.gpshat) {
 238 |     deviceStatus.gpshat = data.gpshatisrunning;
 239 |     if(deviceStatus.gpshat)
 240 |       $('.device-gpshat').removeClass('disabled')
 241 |     else
 242 |       $('.device-gpshat').addClass('disabled');
 243 |   }
 244 | 
 245 | });
 246 | 
 247 | socket.on('wificache', renderWifiCache);
 248 | 
 249 | socket.on('wifi', function(data) {
 250 |     var event = Object.keys(data)[0];
 251 |     var wifi = data[event];
 252 |     switch(event) {
 253 |       case 'vanish':
 254 |         if(wifiCache[wifi.address]!==undefined) {
 255 |           delete(wifiCache[wifi.address]);
 256 |         }
 257 |       break;
 258 |       case 'appear':
 259 |       case 'change':
 260 |         wifiCache[wifi.address] = wifi;
 261 |       break;
 262 |     }
 263 |     renderWifiCache(wifiCache);
 264 |     //console.log('wifi', event, wifi.ssid, wifi.address, Object.keys(wifiCache).length);
 265 | });
 266 | 
 267 | 
 268 | socket.on('state', function(state) {
 269 |     //console.log('state', state);
 270 |     updateSatellite(state);
 271 |     updateTable(state);
 272 |     updateMap(state);
 273 | });
 274 | 
 275 | 
 276 | socket.on('pollsize', function(data) {
 277 |     $('#pollsize').attr("data-poll-currentsize", data);
 278 | });
 279 | 
 280 | 
 281 | socket.on('pollfiles', function(data) {
 282 |     data.forEach(function(file) {
 283 |         if(heatmapFiles[file]!==undefined) return;
 284 | 
 285 |         stringDate = file.replaceAll("_", ":").replace(":000Z.json", ".000Z");
 286 |         propDate = new Date( stringDate ).getTime();
 287 |         if(!isNaN(filterBefore) && propDate > filterBefore ) return;
 288 |         if(!isNaN(filterAfter)  && filterAfter > propDate ) return;
 289 | 
 290 |         heatmapFiles[file] = [];
 291 |     });
 292 |     setOnePoll();
 293 | });
 294 | 
 295 | 
 296 | socket.on('pollfile', function(data) {
 297 |     var progress = 0;
 298 | 
 299 |     if(heatmapFiles[data.filename]!==undefined && heatmapFiles[data.filename].length>0) return;
 300 | 
 301 |     if(data.content===undefined) {
 302 |         data.content = [];
 303 |     }
 304 | 
 305 |     data.content.forEach(function(obj, index) {
 306 |         if(obj.wifilist!==undefined) {
 307 |           //console.log(obj.wifilist);
 308 |           //throw('bah');
 309 |           return; // skip wifilist
 310 |         }
 311 |         if(obj.lat===null || obj.lon===null) return; // exclude null coords
 312 |         if(0- -(obj.lat).toFixed(4)===0 || 0- -(obj.lon).toFixed(4)===0) return; // exclude zero coords
 313 |         var thisPoint = new google.maps.LatLng(obj.lat, obj.lon);
 314 |         var distance = 0;
 315 |         var objTime = new Date(obj.time).getTime();
 316 |         if(lastPoint!==false) {
 317 |             lastObject = obj;
 318 |             distance = google.maps.geometry.spherical.computeDistanceBetween( thisPoint, lastPoint );
 319 |             if( radius > distance ) {
 320 |             return;
 321 |             }
 322 |             if(!isNaN(filterBefore) && objTime > filterBefore ) return;
 323 |             if(!isNaN(filterAfter)  && filterAfter > objTime ) return;
 324 |         }
 325 |         lastPoint = thisPoint;
 326 |         heatmapData.push(new google.maps.LatLng(obj.lat, obj.lon));
 327 |         bounds.extend(thisPoint);
 328 |     });
 329 | 
 330 |     heatmapFiles[data.filename] = data.content;
 331 |     heatmapCount++;
 332 | 
 333 |     if(data.error) {
 334 |         console.log('ignoring invalid data for', data.filename);
 335 |         delete(heatmapFiles[data.filename]);
 336 |     }
 337 | 
 338 |     progress = Math.floor( (heatmapCount / Object.keys(heatmapFiles).length) * 100 );
 339 | 
 340 |     $('#pollsize').css('background-image', 'linear-gradient(to right, lightgray, rgba(0,0,0,0.5) '+(progress-1)+'%, transparent '+progress+'%)')
 341 |                 .attr('data-pollsize', heatmapData.length);
 342 | 
 343 |     if(progress===100) {
 344 |         if(heatmapData.length>0) {
 345 |             $('.button-control-heatmap').prop("disabled", false);
 346 |             $('#pollsize').prop('disabled', true).css('background-image', '');
 347 |             map.fitBounds(bounds);
 348 |             initHeatmap();
 349 |         }
 350 |     } else {
 351 |         setOnePoll();
 352 |     }
 353 | });
 354 | 
 355 | //Width and height
 356 | var width = 500;
 357 | var barHeight = 100;
 358 | var padding = 1;
 359 | var paddingGPS = 4;
 360 | 
 361 | var dataset = [];
 362 | 
 363 | //Create SVG element for satellites
 364 | var svgSatellite = d3.select(".dataviz .satellites")
 365 |         .append("svg")
 366 |         .attr("width", width)
 367 |         .attr("height", barHeight + 50)
 368 |         .append("g");
 369 | 
 370 | 
 371 | var svgWifi = d3.select(".dataviz .wifi")
 372 |         .append("svg")
 373 |         .attr("width", width)
 374 |         .attr("height", barHeight)
 375 |         .append("g");
 376 | 
 377 | function updateWifi(obj) {
 378 |     var data = [];
 379 |     var keys = Object.keys(obj);
 380 |     var rect;
 381 | 
 382 |     // turn incoming object into an array
 383 |     keys.forEach(function(iface){ data.push(obj[iface]); });
 384 | 
 385 |     rect = svgWifi.selectAll("rect").data(data);
 386 | 
 387 |     rect.enter().append("rect");
 388 |     rect.attr("x", function(d, i) {
 389 |       return i * (width / data.length);
 390 |     }).attr("y", function(d) {
 391 |       var v = d.quality || 10;
 392 |       return barHeight - (v * 1);
 393 |     }).attr("width", width / data.length - padding).attr("height", function(d) {
 394 |       var v = d.quality || 10;
 395 |       return v * 4;
 396 |     }).attr("fill", function(d) {
 397 |       var v = 255 + d.strength*2 || 0;
 398 |       if (d.strength<-67) {
 399 |         return "rgb(0, 0, " + (v * 1 | 0) + ")";
 400 |       }
 401 |       return "rgb(" + (v * 1 | 0) + ", 0, 0)";
 402 |     });
 403 |     rect.exit().remove();
 404 | }
 405 | 
 406 | function updateSatellite(data) {
 407 | 
 408 |     var rect = svgSatellite.selectAll("rect").data(data.satsVisible);
 409 |     var text = svgSatellite.selectAll("text").data(data.satsVisible);
 410 |     rect.enter().append("rect");
 411 |     rect.enter().append("text");
 412 |     rect.attr("x", function(d, i) {
 413 |       return i * (width / data.satsVisible.length);
 414 |     }).attr("y", function(d) {
 415 |       var v = d.snr || 10;
 416 |       return barHeight - (v * 2);
 417 |     }).attr("width", width / data.satsVisible.length - paddingGPS).attr("height", function(d) {
 418 |       var v = d.snr || 10;
 419 |       return v * 2;
 420 |     }).attr("fill", function(d) {
 421 |       var v = d.snr || 10;
 422 |       if (-1 !== data.satsActive.indexOf(d.prn)) {
 423 |         return "rgb(0, 0, " + (v * 10 | 0) + ")";
 424 |       }
 425 |       return "rgb(" + (v * 10 | 0) + ", 0, 0)";
 426 |     });
 427 |     text.attr("x", function(d, i) {
 428 |       return 15 + i * (width / data.satsVisible.length);
 429 |     }).attr("y", barHeight + 20).text(function(d) {
 430 |       return d.prn;
 431 |     }).attr("fill", "black");
 432 |     rect.exit().remove();
 433 |     text.exit().remove();
 434 | }
 435 | 
 436 | 
 437 | function updateTable(state) {
 438 |     lastState = state;
 439 |     $("#date").text(state.time);
 440 |     $("#lat").text(state.lat);
 441 |     $("#lon").text(state.lon);
 442 |     $("#alt").text(state.alt);
 443 |     $("#speed").text(state.speed);
 444 |     $("#status").text(state.fix);
 445 |     $("#pdop").text(state.pdop);
 446 |     $("#vdop").text(state.vdop);
 447 |     $("#hdop").text(state.hdop);
 448 |     $("#active").text(state.satsActive.length);
 449 |     $("#view").text(state.satsVisible.length);
 450 | }
 451 | 
 452 | 
 453 | function updateMap(state) {
 454 |     if(state.lat===undefined ||  state.lon===undefined) return;
 455 |     if(state.lat===null ||  state.lon===null) return;
 456 |     if(google===undefined) return;
 457 |     if(google.maps===undefined) return;
 458 |     if(map==undefined) return;
 459 |     if(state.fix=='2D' || state.fix=='3D') {
 460 |         // do not overload UI + localStorage
 461 |         if(updateTimer) return;
 462 |         updateTimer = setTimeout(function() {
 463 |             updateTimer = false;
 464 |         }, updateFreq);
 465 | 
 466 |         if(state.hdop!== undefined && state.pdop!==undefined) {
 467 |             if(state.hdop>50 || state.pdop>50) return;
 468 |             if(2>state.hdop || 2>state.pdop) return;
 469 |             circle.setRadius( Math.sqrt(state.hdop*state.pdop) *10 );
 470 |         }
 471 | 
 472 |         localStorage.setItem('lastFix', JSON.stringify(state));
 473 | 
 474 |         setPoll(lastFix);
 475 | 
 476 |         lastFix = state;
 477 |         totalFixes++;
 478 | 
 479 |         $('#fix-progress').trigger('reset');
 480 | 
 481 |         latLng = new google.maps.LatLng(state.lat, state.lon);
 482 |         
 483 |         localStorage['CenterLat'] = state.lat;
 484 |         localStorage['CenterLon'] = state.lon;
 485 | 
 486 |         marker.setPosition(latLng);
 487 |         circle.setCenter(latLng);
 488 |         map.setCenter(latLng);
 489 |     }
 490 | }
 491 | 
 492 | 
 493 | function initializeMap() {
 494 | 
 495 |     $fixProgress = $('#fix-progress');
 496 |     $secondsSinceLastFix = $('#secondsSinceLastFix');
 497 |     $totalFixes = $('#totalFixes');
 498 |     $pollisze = $('#pollsize');
 499 | 
 500 |     lastFix = JSON.parse(localStorage.getItem('lastFix'));
 501 | 
 502 |     if(lastFix===null) {
 503 |         latLng = new google.maps.LatLng(48.8, 2.3);
 504 |     } else {
 505 |         latLng = new google.maps.LatLng(lastFix.lat, lastFix.lon);
 506 |     }
 507 | 
 508 |     mapElement = document.getElementById('mapid');
 509 | 
 510 |     /*
 511 |     mapOptions = {
 512 |         center: latLng,
 513 |         zoom: 14,
 514 |         mapTypeId: google.maps.MapTypeId.ROADMAP
 515 |     };
 516 |     */
 517 |     
 518 |     
 519 |     // Get current map settings
 520 |     //CenterLat = Number(localStorage['CenterLat']) || latL;
 521 |     //CenterLon = Number(localStorage['CenterLon']) || CONST_CENTERLON;
 522 |     ZoomLvl   = Number(localStorage['ZoomLvl']) || 5;
 523 | 	// Make a list of all the available map IDs
 524 | 	var mapTypeIds = [];
 525 | 	for(var type in google.maps.MapTypeId) {
 526 | 		mapTypeIds.push(google.maps.MapTypeId[type]);
 527 | 	}
 528 | 	// Push OSM on to the end
 529 | 	mapTypeIds.push("OSM");
 530 | 	mapTypeIds.push("dark_map");
 531 | 
 532 | 	// Styled Map to outline airports and highways
 533 | 	var styles = [
 534 | 		{
 535 | 			"featureType": "administrative",
 536 | 			"stylers": [
 537 | 				{ "visibility": "off" }
 538 | 			]
 539 | 		},{
 540 | 			"featureType": "landscape",
 541 | 			"stylers": [
 542 | 				{ "visibility": "off" }
 543 | 			]
 544 | 		},{
 545 | 			"featureType": "poi",
 546 | 			"stylers": [
 547 | 				{ "visibility": "off" }
 548 | 			]
 549 | 		},{
 550 | 			"featureType": "road",
 551 | 			"stylers": [
 552 | 				{ "visibility": "off" }
 553 | 			]
 554 | 		},{
 555 | 			"featureType": "transit",
 556 | 			"stylers": [
 557 | 				{ "visibility": "off" }
 558 | 			]
 559 | 		},{
 560 | 			"featureType": "landscape",
 561 | 			"stylers": [
 562 | 				{ "visibility": "on" },
 563 | 				{ "weight": 8 },
 564 | 				{ "color": "#000000" }
 565 | 			]
 566 | 		},{
 567 | 			"featureType": "water",
 568 | 			"stylers": [
 569 | 			{ "lightness": -74 }
 570 | 			]
 571 | 		},{
 572 | 			"featureType": "transit.station.airport",
 573 | 			"stylers": [
 574 | 				{ "visibility": "on" },
 575 | 				{ "weight": 8 },
 576 | 				{ "invert_lightness": true },
 577 | 				{ "lightness": 27 }
 578 | 			]
 579 | 		},{
 580 | 			"featureType": "road.highway",
 581 | 			"stylers": [
 582 | 				{ "visibility": "simplified" },
 583 | 				{ "invert_lightness": true },
 584 | 				{ "gamma": 0.3 }
 585 | 			]
 586 | 		},{
 587 | 			"featureType": "road",
 588 | 			"elementType": "labels",
 589 | 			"stylers": [
 590 | 				{ "visibility": "off" }
 591 | 			]
 592 | 		}
 593 | 	]
 594 | 
 595 | 	// Add our styled map
 596 | 	var styledMap = new google.maps.StyledMapType(styles, {name: "Dark Map"});
 597 | 
 598 | 	// Define the Google Map
 599 | 	var mapOptions = {
 600 | 		center: latLng, // new google.maps.LatLng(CenterLat, CenterLon),
 601 | 		zoom: ZoomLvl,
 602 | 		mapTypeId: google.maps.MapTypeId.ROADMAP,
 603 | 		mapTypeControl: true,
 604 | 		streetViewControl: false,
 605 | 		mapTypeControlOptions: {
 606 | 			mapTypeIds: mapTypeIds,
 607 | 			position: google.maps.ControlPosition.TOP_LEFT,
 608 | 			style: google.maps.MapTypeControlStyle.DROPDOWN_MENU
 609 | 		}
 610 | 	};
 611 |     
 612 |     
 613 |     
 614 |     
 615 |     map = new google.maps.Map(mapElement, mapOptions)
 616 |     bounds = new google.maps.LatLngBounds();
 617 |     marker = new google.maps.Marker({position: latLng, map: map});
 618 |     circle = new google.maps.Circle({
 619 |         strokeColor: '#FF0000',
 620 |         strokeOpacity: 0.8,
 621 |         strokeWeight: 2,
 622 |         fillColor: '#FF0000',
 623 |         fillOpacity: 0.35,
 624 |         map: map,
 625 |         center: latLng,
 626 |         radius: 100
 627 |     });
 628 | 
 629 |     
 630 | 	//Define OSM map type pointing at the OpenStreetMap tile server
 631 | 	map.mapTypes.set("OSM", new google.maps.ImageMapType({
 632 | 		getTileUrl: function(coord, zoom) {
 633 | 			return "http://tile.openstreetmap.org/" + zoom + "/" + coord.x + "/" + coord.y + ".png";
 634 | 		},
 635 | 		tileSize: new google.maps.Size(256, 256),
 636 | 		name: "OpenStreetMap",
 637 | 		maxZoom: 18
 638 | 	}));
 639 | 
 640 | 	map.mapTypes.set("dark_map", styledMap);
 641 |     
 642 | 	// Listeners for newly created Map
 643 |     google.maps.event.addListener(map, 'center_changed', function() {
 644 |         localStorage['CenterLat'] = map.getCenter().lat();
 645 |         localStorage['CenterLon'] = map.getCenter().lng();
 646 |     });
 647 |     
 648 |     google.maps.event.addListener(map, 'zoom_changed', function() {
 649 |         localStorage['ZoomLvl']  = map.getZoom();
 650 |     }); 
 651 |     
 652 |     
 653 |     $('#focus-lastfix').on('click', function() {
 654 |         latLng = new google.maps.LatLng( document.getElementById('lat').innerHTML, document.getElementById('lon').innerHTML );
 655 |         map.setCenter(latLng);
 656 |         marker.setPosition(latLng);
 657 |         circle.setCenter(latLng);
 658 |     });
 659 | 
 660 |     $('#reload-ws').on('click', function() {
 661 |         $(this).attr('disabled', true);
 662 |         socket.emit('reload', "blah");
 663 |         setTimeout(function() {
 664 |             top.location = top.location
 665 |         }, 10000);
 666 |     });
 667 |     
 668 |     $('.device-gpsdaemon').on('click', function() {
 669 |       if(deviceStatus.gpsdaemon===true) {
 670 |         socket.emit('gpsdaemonstop');
 671 |       } else {
 672 |         socket.emit('gpsdaemonstart');
 673 |       }
 674 |     });
 675 |     $('.device-gpshat').on('click', function() {
 676 |       if(deviceStatus.gpshat===true) {
 677 |         socket.emit('gpsdisable');
 678 |       } else {
 679 |         socket.emit('gpsenable');
 680 |       }
 681 |     });
 682 |     $('.device-rtlsdr').on('click', function() {
 683 |       if(deviceStatus.rtlsdr===true) {
 684 |         socket.emit('rtlsdrdisable');
 685 |       } else {
 686 |         socket.emit('rtlsdrenable');
 687 |       }
 688 |     });
 689 |     $('.device-wifi').on('click', function() {
 690 |       if(deviceStatus.wifi===true) {
 691 |         socket.emit('wifidisable');
 692 |       } else {
 693 |         socket.emit('wifienable');
 694 |       }
 695 |     });    
 696 | 
 697 |     $fixProgress.on('reset', function() {
 698 |         $fixProgress.val(60);
 699 |         $totalFixes.text(totalFixes);
 700 |         secondsSinceLastFix = 0;
 701 |         $secondsSinceLastFix.text('00:00:01');
 702 |     });
 703 | 
 704 |     setInterval(function() {
 705 |       var fixVal = 0- -$fixProgress.val();
 706 |       secondsSinceLastFix++;
 707 |       timeSinceLastPoll++;
 708 |       $secondsSinceLastFix.text( (""+secondsSinceLastFix).toHHMMSS() );
 709 |       if(fixVal==0) return;
 710 |       $fixProgress.val(fixVal-1);
 711 |     }, 1000);
 712 | 
 713 |     setWifiSort();
 714 | }
 715 | 
 716 | 
 717 | function setPoll() {
 718 |     fixPoll.push(lastFix);
 719 |     // save every minute or every 100 records
 720 |     if(fixPoll.length>100 || timeSinceLastPoll > 60) {
 721 |         // save
 722 |         socket.emit('setpoll', fixPoll);
 723 |         // purge
 724 |         fixPoll = [];
 725 |         timeSinceLastPoll = 0;
 726 |         return;
 727 |     }
 728 | }
 729 | 
 730 | 
 731 | function togglePollFiles() {
 732 |     if(pollReceiving===true) {
 733 |         stopPollFiles();
 734 |     } else {
 735 |         getPollFiles();
 736 |     }
 737 | }
 738 | 
 739 | 
 740 | function getPollFiles() {
 741 |     pollReceiving = true;
 742 |     $('#pollsize').attr('data-label', 'Stop retrieving files');
 743 |     radius = 0- -$('#radius').val();
 744 |     filterBeforeString = $('#date-filter-before').val().replace(" ", "") + ".000Z";
 745 |     filterAfterString  = $('#date-filter-after').val().replace(" ", "") + ".000Z";
 746 | 
 747 |     filterBefore = new Date( filterBeforeString ).getTime();
 748 |     filterAfter  = new Date(  filterAfterString ).getTime();
 749 |     $('.button-control-heatmap').prop("disabled", true);
 750 |     socket.emit('poll-files', {blah:true});
 751 | }
 752 | 
 753 | 
 754 | function stopPollFiles() {
 755 |     pollReceiving = false;
 756 |     $('.button-control-heatmap').prop("disabled", false);
 757 |     $('#pollsize').attr('data-label', 'Start retrieving files');
 758 |     if(heatmapData.length>0) {
 759 |         $('#initheatmap-button').css('display', 'inline-block');
 760 |     } else {
 761 |         $('#initheatmap-button').css('display', 'none');
 762 |     }
 763 | }
 764 | 
 765 | 
 766 | function setOnePoll() {
 767 |     //var propDate;
 768 |     //var stringDate;
 769 |     if(pollReceiving!==true) return;
 770 |     for(prop in heatmapFiles) {
 771 |         if(!prop.match(/^[0-9]{4}-[0-9]{2}-[0-9]{2}/)) continue;
 772 |         if(heatmapFiles[prop].length===0) {
 773 |             socket.emit('poll-content', prop);
 774 |             return;
 775 |         }
 776 |     }
 777 | }
 778 | 
 779 | function toggleHeatmap() {
 780 |     heatmap.setMap(heatmap.getMap() ? null : map);
 781 | }
 782 | 
 783 | function changeGradient() {
 784 |     var gradient = [
 785 |         'rgba(0, 255, 255, 0)',
 786 |         'rgba(0, 255, 255, 1)',
 787 |         'rgba(0, 191, 255, 1)',
 788 |         'rgba(0, 127, 255, 1)',
 789 |         'rgba(0, 63, 255, 1)',
 790 |         'rgba(0, 0, 255, 1)',
 791 |         'rgba(0, 0, 223, 1)',
 792 |         'rgba(0, 0, 191, 1)',
 793 |         'rgba(0, 0, 159, 1)',
 794 |         'rgba(0, 0, 127, 1)',
 795 |         'rgba(63, 0, 91, 1)',
 796 |         'rgba(127, 0, 63, 1)',
 797 |         'rgba(191, 0, 31, 1)',
 798 |         'rgba(255, 0, 0, 1)'
 799 |     ];
 800 |     heatmap.set('gradient', heatmap.get('gradient') ? null : gradient);
 801 | }
 802 | 
 803 | 
 804 | function changeRadius() {
 805 |     heatmap.set('radius', heatmap.get('radius') ? null : 20);
 806 | }
 807 | 
 808 | 
 809 | function changeHeatmapOpacity() {
 810 |     heatmap.set('opacity', heatmap.get('opacity') ? null : 0.2);
 811 | }
 812 | 
 813 | 
 814 | function changecircleOpacity() {
 815 |     circle.setVisible(!circle.getVisible());
 816 | }
 817 | 
 818 | 
 819 | function getPoints() {
 820 |     return heatmapData;
 821 | }
 822 | 
 823 | function setWifiSort() {
 824 |     wifiSort = $('#wifi-sort-by').val();
 825 |     socket.emit('wifi-cache', "blah");
 826 | }
 827 | 
 828 | function setWifiName() {
 829 |     wifiName = $('#wifi-named-by').val();
 830 |     socket.emit('wifi-cache', 'blah');
 831 | }
 832 | 
 833 | function initHeatmap() {
 834 |     heatmap = new google.maps.visualization.HeatmapLayer({
 835 |         data: getPoints(),
 836 |         map: map
 837 |     });
 838 |     $('#initheatmap-button').prop('disabled', true);
 839 |     circle.setVisible(false);
 840 | }
 841 | 
 842 | $(function() {
 843 |     $( 'input[type="datetime"]').datetimepicker({dateFormat:"yy-mm-ddT", timeFormat:"HH:mm:ss"}); 
 844 | });
 845 | 
 846 | 
 847 | 
 848 | // This looks for planes to reap out of the master Planes variable
 849 | function reaper() {
 850 | 	PlanesToReap = 0;
 851 | 	// When did the reaper start?
 852 | 	reaptime = new Date().getTime();
 853 | 	// Loop the planes
 854 | 	for (var reap in Planes) {
 855 | 		// Is this plane possibly reapable?
 856 | 		if (Planes[reap].reapable == true) {
 857 | 			// Has it not been seen for 5 minutes?
 858 | 			// This way we still have it if it returns before then
 859 | 			// Due to loss of signal or other reasons
 860 | 			if ((reaptime - Planes[reap].updated) > 300000) {
 861 | 				// Reap it.
 862 | 				delete Planes[reap];
 863 | 			}
 864 | 			PlanesToReap++;
 865 | 		}
 866 | 	};
 867 | } 
 868 | 
 869 | // Refresh the detail window about the plane
 870 | function refreshSelected() {
 871 |     var selected = false;
 872 | 	if (typeof SelectedPlane !== 'undefined' && SelectedPlane != "ICAO" && SelectedPlane != null) {
 873 |     	selected = Planes[SelectedPlane];
 874 |     }
 875 | 	
 876 | 	var columns = 2;
 877 | 	var html = '';
 878 | 	
 879 | 	if (selected) {
 880 |     	html += '<table id="selectedinfo" width="100%">';
 881 |     } else {
 882 |         html += '<table id="selectedinfo" class="dim" width="100%">';
 883 |     }
 884 | 	
 885 | 	// Flight header line including squawk if needed
 886 | 	if (selected && selected.flight == "") {
 887 | 	    html += '<tr><td colspan="' + columns + '" id="selectedinfotitle"><b>N/A (' +
 888 | 	        selected.icao + ')</b>';
 889 | 	} else if (selected && selected.flight != "") {
 890 | 	    html += '<tr><td colspan="' + columns + '" id="selectedinfotitle"><b>' +
 891 | 	        selected.flight + '</b>';
 892 | 	} else {
 893 | 	    html += '<tr><td colspan="' + columns + '" id="selectedinfotitle"><b>DUMP1090</b>';
 894 | 	}
 895 | 	
 896 | 	if (selected && selected.squawk == 7500) { // Lets hope we never see this... Aircraft Hijacking
 897 | 		html += '&nbsp;<span class="squawk7500">&nbsp;Squawking: Aircraft Hijacking&nbsp;</span>';
 898 | 	} else if (selected && selected.squawk == 7600) { // Radio Failure
 899 | 		html += '&nbsp;<span class="squawk7600">&nbsp;Squawking: Radio Failure&nbsp;</span>';
 900 | 	} else if (selected && selected.squawk == 7700) { // General Emergency
 901 | 		html += '&nbsp;<span class="squawk7700">&nbsp;Squawking: General Emergency&nbsp;</span>';
 902 | 	} else if (selected && selected.flight != '') {
 903 | 		html += '&nbsp;<a href="http://fr24.com/'+selected.flight+'" target="_blank">[FR24]</a>';
 904 | 	    html += '&nbsp;<a href="http://www.flightstats.com/go/FlightStatus/flightStatusByFlight.do?';
 905 |         html += 'flightNumber='+selected.flight+'" target="_blank">[FlightStats]</a>';
 906 | 	    html += '&nbsp;<a href="http://flightaware.com/live/flight/'+selected.flight+'" target="_blank">[FlightAware]</a>';
 907 | 	}
 908 | 	html += '<td></tr>';
 909 | 	
 910 | 	if (selected) {
 911 | 	    if (Metric) {
 912 |         	html += '<tr><td>Altitude: ' + Math.round(selected.altitude / 3.2828) + ' m</td>';
 913 |         } else {
 914 |             html += '<tr><td>Altitude: ' + selected.altitude + ' ft</td>';
 915 |         }
 916 |     } else {
 917 |         html += '<tr><td>Altitude: n/a</td>';
 918 |     }
 919 | 		
 920 | 	if (selected && selected.squawk != '0000') {
 921 | 		html += '<td>Squawk: ' + selected.squawk + '</td></tr>';
 922 | 	} else {
 923 | 	    html += '<td>Squawk: n/a</td></tr>';
 924 | 	}
 925 | 	
 926 | 	html += '<tr><td>Speed: ' 
 927 | 	if (selected) {
 928 | 	    if (Metric) {
 929 | 	        html += Math.round(selected.speed * 1.852) + ' km/h';
 930 | 	    } else {
 931 | 	        html += selected.speed + ' kt';
 932 | 	    }
 933 | 	} else {
 934 | 	    html += 'n/a';
 935 | 	}
 936 | 	html += '</td>';
 937 | 	
 938 | 	if (selected) {
 939 |         html += '<td>ICAO (hex): ' + selected.icao + '</td></tr>';
 940 |     } else {
 941 |         html += '<td>ICAO (hex): n/a</td></tr>'; // Something is wrong if we are here
 942 |     }
 943 |     
 944 |     html += '<tr><td>Track: ' 
 945 | 	if (selected && selected.vTrack) {
 946 | 	    html += selected.track + '&deg;' + ' (' + normalizeTrack(selected.track, selected.vTrack)[1] +')';
 947 | 	} else {
 948 | 	    html += 'n/a';
 949 | 	}
 950 | 	html += '</td><td>&nbsp;</td></tr>';
 951 | 
 952 | 	html += '<tr><td colspan="' + columns + '" align="center">Lat/Long: ';
 953 | 	if (selected && selected.vPosition) {
 954 | 	    html += selected.latitude + ', ' + selected.longitude + '</td></tr>';
 955 | 	    
 956 | 	    // Let's show some extra data if we have site coordinates
 957 | 	    if (SiteShow) {
 958 |             //var siteLatLon  = new google.maps.LatLng(SiteLat, SiteLon);
 959 |             var planeLatLon = new google.maps.LatLng(selected.latitude, selected.longitude);
 960 |             var dist = google.maps.geometry.spherical.computeDistanceBetween (latLng, planeLatLon);
 961 |             
 962 |             if (Metric) {
 963 |                 dist /= 1000;
 964 |             } else {
 965 |                 dist /= 1852;
 966 |             }
 967 |             dist = (Math.round((dist)*10)/10).toFixed(1);
 968 |             html += '<tr><td colspan="' + columns + '" align="center">Distance from Site: ' + dist +
 969 |                 (Metric ? ' km' : ' NM') + '</td></tr>';
 970 |         } // End of SiteShow
 971 | 	} else {
 972 | 	    if (SiteShow) {
 973 | 	        html += '<tr><td colspan="' + columns + '" align="center">Distance from Site: n/a ' + 
 974 | 	            (Metric ? ' km' : ' NM') + '</td></tr>';
 975 | 	    } else {
 976 |     	    html += 'n/a</td></tr>';
 977 |     	}
 978 | 	}
 979 | 
 980 | 	html += '</table>';
 981 | 	
 982 | 	document.getElementById('plane_detail').innerHTML = html;
 983 | }
 984 | 
 985 | // Right now we have no means to validate the speed is good
 986 | // Want to return (n/a) when we dont have it
 987 | // TODO: Edit C code to add a valid speed flag
 988 | // TODO: Edit js code to use said flag
 989 | function normalizeSpeed(speed, valid) {
 990 | 	return speed	
 991 | }
 992 | 
 993 | // Returns back a long string, short string, and the track if we have a vaild track path
 994 | function normalizeTrack(track, valid){
 995 | 	x = []
 996 | 	if ((track > -1) && (track < 22.5)) {
 997 | 		x = ["North", "N", track]
 998 | 	}
 999 | 	if ((track > 22.5) && (track < 67.5)) {
1000 | 		x = ["North East", "NE", track]
1001 | 	}
1002 | 	if ((track > 67.5) && (track < 112.5)) {
1003 | 		x = ["East", "E", track]
1004 | 	}
1005 | 	if ((track > 112.5) && (track < 157.5)) {
1006 | 		x = ["South East", "SE", track]
1007 | 	}
1008 | 	if ((track > 157.5) && (track < 202.5)) {
1009 | 		x = ["South", "S", track]
1010 | 	}
1011 | 	if ((track > 202.5) && (track < 247.5)) {
1012 | 		x = ["South West", "SW", track]
1013 | 	}
1014 | 	if ((track > 247.5) && (track < 292.5)) {
1015 | 		x = ["West", "W", track]
1016 | 	}
1017 | 	if ((track > 292.5) && (track < 337.5)) {
1018 | 		x = ["North West", "NW", track]
1019 | 	}
1020 | 	if ((track > 337.5) && (track < 361)) {
1021 | 		x = ["North", "N", track]
1022 | 	}
1023 | 	if (!valid) {
1024 | 		x = [" ", "n/a", ""]
1025 | 	}
1026 | 	return x
1027 | }
1028 | 
1029 | // Refeshes the larger table of all the planes
1030 | function refreshTableInfo() {
1031 | 	var html = '<table id="tableinfo" width="100%">';
1032 | 	html += '<thead style="background-color: #BBBBBB; cursor: pointer;">';
1033 | 	html += '<td onclick="setASC_DESC(\'0\');sortTable(\'tableinfo\',\'0\');">ICAO</td>';
1034 | 	html += '<td onclick="setASC_DESC(\'1\');sortTable(\'tableinfo\',\'1\');">Flight</td>';
1035 | 	html += '<td onclick="setASC_DESC(\'2\');sortTable(\'tableinfo\',\'2\');" ' +
1036 | 	    'align="right">Squawk</td>';
1037 | 	html += '<td onclick="setASC_DESC(\'3\');sortTable(\'tableinfo\',\'3\');" ' +
1038 | 	    'align="right">Altitude</td>';
1039 | 	html += '<td onclick="setASC_DESC(\'4\');sortTable(\'tableinfo\',\'4\');" ' +
1040 | 	    'align="right">Speed</td>';
1041 |         // Add distance column header to table if site coordinates are provided
1042 |         if (SiteShow && (typeof SiteLat !==  'undefined' || typeof SiteLon !==  'undefined')) {
1043 |             html += '<td onclick="setASC_DESC(\'5\');sortTable(\'tableinfo\',\'5\');" ' +
1044 |                 'align="right">Distance</td>';
1045 |         }
1046 | 	html += '<td onclick="setASC_DESC(\'5\');sortTable(\'tableinfo\',\'6\');" ' +
1047 | 	    'align="right">Track</td>';
1048 | 	html += '<td onclick="setASC_DESC(\'6\');sortTable(\'tableinfo\',\'7\');" ' +
1049 | 	    'align="right">Msgs</td>';
1050 | 	html += '<td onclick="setASC_DESC(\'7\');sortTable(\'tableinfo\',\'8\');" ' +
1051 | 	    'align="right">Seen</td></thead><tbody>';
1052 | 	for (var tablep in Planes) {
1053 | 		var tableplane = Planes[tablep]
1054 | 		if (!tableplane.reapable) {
1055 | 			var specialStyle = "";
1056 | 			// Is this the plane we selected?
1057 | 			if (tableplane.icao == SelectedPlane) {
1058 | 				specialStyle += " selected";
1059 | 			}
1060 | 			// Lets hope we never see this... Aircraft Hijacking
1061 | 			if (tableplane.squawk == 7500) {
1062 | 				specialStyle += " squawk7500";
1063 | 			}
1064 | 			// Radio Failure
1065 | 			if (tableplane.squawk == 7600) {
1066 | 				specialStyle += " squawk7600";
1067 | 			}
1068 | 			// Emergancy
1069 | 			if (tableplane.squawk == 7700) {
1070 | 				specialStyle += " squawk7700";
1071 | 			}
1072 | 			
1073 | 			if (tableplane.vPosition == true) {
1074 | 				html += '<tr class="plane_table_row vPosition' + specialStyle + '">';
1075 | 			} else {
1076 | 				html += '<tr class="plane_table_row ' + specialStyle + '">';
1077 | 		    }
1078 | 		    
1079 | 			html += '<td>' + tableplane.icao + '</td>';
1080 | 			html += '<td>' + tableplane.flight + '</td>';
1081 | 			if (tableplane.squawk != '0000' ) {
1082 |     			html += '<td align="right">' + tableplane.squawk + '</td>';
1083 |     	    } else {
1084 |     	        html += '<td align="right">&nbsp;</td>';
1085 |     	    }
1086 |     	    
1087 |     	    if (Metric) {
1088 |     			html += '<td align="right">' + Math.round(tableplane.altitude / 3.2828) + '</td>';
1089 |     			html += '<td align="right">' + Math.round(tableplane.speed * 1.852) + '</td>';
1090 |     	    } else {
1091 |     	        html += '<td align="right">' + tableplane.altitude + '</td>';
1092 |     	        html += '<td align="right">' + tableplane.speed + '</td>';
1093 |     	    }
1094 |                         // Add distance column to table if site coordinates are provided
1095 |                         if (SiteShow && (typeof SiteLat !==  'undefined' || typeof SiteLon !==  'undefined')) {
1096 |                         html += '<td align="right">';
1097 |                             if (tableplane.vPosition) {
1098 |                                 //var siteLatLon  = new google.maps.LatLng(SiteLat, SiteLon);
1099 |                                 var planeLatLon = new google.maps.LatLng(tableplane.latitude, tableplane.longitude);
1100 |                                 var dist = google.maps.geometry.spherical.computeDistanceBetween (latLng, planeLatLon);
1101 |                                     if (Metric) {
1102 |                                         dist /= 1000;
1103 |                                     } else {
1104 |                                         dist /= 1852;
1105 |                                     }
1106 |                                 dist = (Math.round((dist)*10)/10).toFixed(1);
1107 |                                 html += dist;
1108 |                             } else {
1109 |                             html += '0';
1110 |                             }
1111 |                             html += '</td>';
1112 |                         }
1113 | 			
1114 | 			html += '<td align="right">';
1115 | 			if (tableplane.vTrack) {
1116 |     			 html += normalizeTrack(tableplane.track, tableplane.vTrack)[2];
1117 |     			 // html += ' (' + normalizeTrack(tableplane.track, tableplane.vTrack)[1] + ')';
1118 |     	    } else {
1119 |     	        html += '&nbsp;';
1120 |     	    }
1121 |     	    html += '</td>';
1122 | 			html += '<td align="right">' + tableplane.messages + '</td>';
1123 | 			html += '<td align="right">' + tableplane.seen + '</td>';
1124 | 			html += '</tr>';
1125 | 		}
1126 | 	}
1127 | 	html += '</tbody></table>';
1128 | 
1129 | 	document.getElementById('planes_table').innerHTML = html;
1130 | 
1131 | 	if (SpecialSquawk) {
1132 |     	$('#SpecialSquawkWarning').css('display', 'inline');
1133 |     } else {
1134 |         $('#SpecialSquawkWarning').css('display', 'none');
1135 |     }
1136 | 
1137 | 	// Click event for table
1138 | 	$('#planes_table').find('tr').click( function(){
1139 | 		var hex = $(this).find('td:first').text();
1140 | 		if (hex != "ICAO") {
1141 | 			selectPlaneByHex(hex);
1142 | 			refreshTableInfo();
1143 | 			refreshSelected();
1144 | 		}
1145 | 	});
1146 | 
1147 | 	sortTable("tableinfo");
1148 | }
1149 | 
1150 | // Credit goes to a co-worker that needed a similar functions for something else
1151 | // we get a copy of it free ;)
1152 | function setASC_DESC(iCol) {
1153 | 	if(iSortCol==iCol) {
1154 | 		bSortASC=!bSortASC;
1155 | 	} else {
1156 | 		bSortASC=bDefaultSortASC;
1157 | 	}
1158 | }
1159 | 
1160 | function sortTable(szTableID,iCol) { 
1161 | 	//if iCol was not provided, and iSortCol is not set, assign default value
1162 | 	if (typeof iCol==='undefined'){
1163 | 		if(iSortCol!=-1){
1164 | 			var iCol=iSortCol;
1165 |                 } else if (SiteShow && (typeof SiteLat !==  'undefined' || typeof SiteLon !==  'undefined')) {
1166 |                         var iCol=5;
1167 | 		} else {
1168 | 			var iCol=iDefaultSortCol;
1169 | 		}
1170 | 	}
1171 | 
1172 | 	//retrieve passed table element
1173 | 	var oTbl=document.getElementById(szTableID).tBodies[0];
1174 | 	var aStore=[];
1175 | 
1176 | 	//If supplied col # is greater than the actual number of cols, set sel col = to last col
1177 | 	if (typeof oTbl.rows[0] !== 'undefined' && oTbl.rows[0].cells.length <= iCol) {
1178 | 		iCol=(oTbl.rows[0].cells.length-1);
1179 |     }
1180 | 
1181 | 	//store the col #
1182 | 	iSortCol=iCol;
1183 | 
1184 | 	//determine if we are delaing with numerical, or alphanumeric content
1185 | 	var bNumeric = false;
1186 | 	if ((typeof oTbl.rows[0] !== 'undefined') &&
1187 | 	    (!isNaN(parseFloat(oTbl.rows[0].cells[iSortCol].textContent ||
1188 | 	    oTbl.rows[0].cells[iSortCol].innerText)))) {
1189 | 	    bNumeric = true;
1190 | 	}
1191 | 
1192 | 	//loop through the rows, storing each one inro aStore
1193 | 	for (var i=0,iLen=oTbl.rows.length;i<iLen;i++){
1194 | 		var oRow=oTbl.rows[i];
1195 | 		vColData=bNumeric?parseFloat(oRow.cells[iSortCol].textContent||oRow.cells[iSortCol].innerText):String(oRow.cells[iSortCol].textContent||oRow.cells[iSortCol].innerText);
1196 | 		aStore.push([vColData,oRow]);
1197 | 	}
1198 | 
1199 | 	//sort aStore ASC/DESC based on value of bSortASC
1200 | 	if (bNumeric) { //numerical sort
1201 | 		aStore.sort(function(x,y){return bSortASC?x[0]-y[0]:y[0]-x[0];});
1202 | 	} else { //alpha sort
1203 | 		aStore.sort();
1204 | 		if(!bSortASC) {
1205 | 			aStore.reverse();
1206 | 	    }
1207 | 	}
1208 | 
1209 | 	//rewrite the table rows to the passed table element
1210 | 	for(var i=0,iLen=aStore.length;i<iLen;i++){
1211 | 		oTbl.appendChild(aStore[i][1]);
1212 | 	}
1213 | 	aStore=null;
1214 | }
1215 | 
1216 | function selectPlaneByHex(hex) {
1217 | 	// If SelectedPlane has something in it, clear out the selected
1218 | 	if (SelectedPlane != null) {
1219 | 		Planes[SelectedPlane].is_selected = false;
1220 | 		Planes[SelectedPlane].funcClearLine();
1221 | 		Planes[SelectedPlane].markerColor = MarkerColor;
1222 | 		// If the selected has a marker, make it not stand out
1223 | 		if (Planes[SelectedPlane].marker) {
1224 | 			Planes[SelectedPlane].marker.setIcon(Planes[SelectedPlane].funcGetIcon());
1225 | 		}
1226 | 	}
1227 | 
1228 | 	// If we are clicking the same plane, we are deselected it.
1229 | 	if (String(SelectedPlane) != String(hex)) {
1230 | 		// Assign the new selected
1231 | 		SelectedPlane = hex;
1232 | 		Planes[SelectedPlane].is_selected = true;
1233 | 		// If the selected has a marker, make it stand out
1234 | 		if (Planes[SelectedPlane].marker) {
1235 | 			Planes[SelectedPlane].funcUpdateLines();
1236 | 			Planes[SelectedPlane].marker.setIcon(Planes[SelectedPlane].funcGetIcon());
1237 | 		}
1238 | 	} else { 
1239 | 		SelectedPlane = null;
1240 | 	}
1241 |     refreshSelected();
1242 |     refreshTableInfo();
1243 | }
1244 | 
1245 | 
1246 | var planeObject = {
1247 | 	oldlat		: null,
1248 | 	oldlon		: null,
1249 | 	oldalt		: null,
1250 | 
1251 | 	// Basic location information
1252 | 	altitude	: null,
1253 | 	speed		: null,
1254 | 	track		: null,
1255 | 	latitude	: null,
1256 | 	longitude	: null,
1257 | 	
1258 | 	// Info about the plane
1259 | 	flight		: null,
1260 | 	squawk		: null,
1261 | 	icao		: null,
1262 | 	is_selected	: false,	
1263 | 
1264 | 	// Data packet numbers
1265 | 	messages	: null,
1266 | 	seen		: null,
1267 | 
1268 | 	// Vaild...
1269 | 	vPosition	: false,
1270 | 	vTrack		: false,
1271 | 
1272 | 	// GMap Details
1273 | 	marker		: null,
1274 | 	markerColor	: MarkerColor,
1275 | 	lines		: [],
1276 | 	trackdata	: new Array(),
1277 | 	trackline	: new Array(),
1278 | 
1279 | 	// When was this last updated?
1280 | 	updated		: null,
1281 | 	reapable	: false,
1282 | 
1283 | 	// Appends data to the running track so we can get a visual tail on the plane
1284 | 	// Only useful for a long running browser session.
1285 | 	funcAddToTrack	: function(){
1286 | 			// TODO: Write this function out
1287 | 			this.trackdata.push([this.latitude, this.longitude, this.altitude, this.track, this.speed]);
1288 | 			this.trackline.push(new google.maps.LatLng(this.latitude, this.longitude));
1289 | 		},
1290 | 
1291 | 	// This is to remove the line from the screen if we deselect the plane
1292 | 	funcClearLine	: function() {
1293 | 			if (this.line) {
1294 | 				this.line.setMap(null);
1295 | 				this.line = null;
1296 | 			}
1297 | 		},
1298 | 
1299 | 	// Should create an icon for us to use on the map...
1300 | 	funcGetIcon	: function() {
1301 | 			this.markerColor = MarkerColor;
1302 | 			// If this marker is selected we should make it lighter than the rest.
1303 | 			if (this.is_selected == true) {
1304 | 				this.markerColor = SelectedColor;
1305 | 			}
1306 | 
1307 | 			// If we have not seen a recent update, change color
1308 | 			if (this.seen > 15) {
1309 | 				this.markerColor = StaleColor;
1310 | 			}
1311 | 			
1312 | 			// Plane marker
1313 |             var baseSvg = {
1314 |                 planeData : "M 1.9565564,41.694305 C 1.7174505,40.497708 1.6419973,38.448747 " +
1315 |                     "1.8096508,37.70494 1.8936398,37.332056 2.0796653,36.88191 2.222907,36.70461 " +
1316 |                     "2.4497603,36.423844 4.087816,35.47248 14.917931,29.331528 l 12.434577," +
1317 |                     "-7.050718 -0.04295,-7.613412 c -0.03657,-6.4844888 -0.01164,-7.7625804 " +
1318 |                     "0.168134,-8.6194061 0.276129,-1.3160905 0.762276,-2.5869575 1.347875," +
1319 |                     "-3.5235502 l 0.472298,-0.7553719 1.083746,-0.6085497 c 1.194146,-0.67053522 " +
1320 |                     "1.399524,-0.71738842 2.146113,-0.48960552 1.077005,0.3285939 2.06344," +
1321 |                     "1.41299352 2.797602,3.07543322 0.462378,1.0469993 0.978731,2.7738408 " +
1322 |                     "1.047635,3.5036272 0.02421,0.2570284 0.06357,3.78334 0.08732,7.836246 0.02375," +
1323 |                     "4.052905 0.0658,7.409251 0.09345,7.458546 0.02764,0.04929 5.600384,3.561772 " +
1324 |                     "12.38386,7.805502 l 12.333598,7.715871 0.537584,0.959688 c 0.626485,1.118378 " +
1325 |                     "0.651686,1.311286 0.459287,3.516442 -0.175469,2.011604 -0.608966,2.863924 " +
1326 |                     "-1.590344,3.127136 -0.748529,0.200763 -1.293144,0.03637 -10.184829,-3.07436 " +
1327 |                     "C 48.007733,41.72562 44.793806,40.60197 43.35084,40.098045 l -2.623567," +
1328 |                     "-0.916227 -1.981212,-0.06614 c -1.089663,-0.03638 -1.985079,-0.05089 -1.989804," +
1329 |                     "-0.03225 -0.0052,0.01863 -0.02396,2.421278 -0.04267,5.339183 -0.0395,6.147742 " +
1330 |                     "-0.143635,7.215456 -0.862956,8.845475 l -0.300457,0.680872 2.91906,1.361455 " +
1331 |                     "c 2.929379,1.366269 3.714195,1.835385 4.04589,2.41841 0.368292,0.647353 " +
1332 |                     "0.594634,2.901439 0.395779,3.941627 -0.0705,0.368571 -0.106308,0.404853 " +
1333 |                     "-0.765159,0.773916 L 41.4545,62.83158 39.259237,62.80426 c -6.030106,-0.07507 " +
1334 |                     "-16.19508,-0.495041 -16.870991,-0.697033 -0.359409,-0.107405 -0.523792," +
1335 |                     "-0.227482 -0.741884,-0.541926 -0.250591,-0.361297 -0.28386,-0.522402 -0.315075," +
1336 |                     "-1.52589 -0.06327,-2.03378 0.23288,-3.033615 1.077963,-3.639283 0.307525," +
1337 |                     "-0.2204 4.818478,-2.133627 6.017853,-2.552345 0.247872,-0.08654 0.247455," +
1338 |                     "-0.102501 -0.01855,-0.711959 -0.330395,-0.756986 -0.708622,-2.221756 -0.832676," +
1339 |                     "-3.224748 -0.05031,-0.406952 -0.133825,-3.078805 -0.185533,-5.937448 -0.0517," +
1340 |                     "-2.858644 -0.145909,-5.208974 -0.209316,-5.222958 -0.06341,-0.01399 -0.974464," +
1341 |                     "-0.0493 -2.024551,-0.07845 L 23.247235,38.61921 18.831373,39.8906 C 4.9432155," +
1342 |                     "43.88916 4.2929558,44.057819 3.4954426,43.86823 2.7487826,43.690732 2.2007966," +
1343 |                     "42.916622 1.9565564,41.694305 z"
1344 |             };
1345 | 
1346 | 			// If the squawk code is one of the international emergency codes,
1347 | 			// match the info window alert color.
1348 | 			if (this.squawk == 7500) {
1349 | 				this.markerColor = "rgb(255, 85, 85)";
1350 | 			}
1351 | 			if (this.squawk == 7600) {
1352 | 				this.markerColor = "rgb(0, 255, 255)";
1353 | 			}
1354 | 			if (this.squawk == 7700) {
1355 | 				this.markerColor = "rgb(255, 255, 0)";
1356 | 			}
1357 | 
1358 | 			// If we have not overwritten color by now, an extension still could but
1359 | 			// just keep on trucking.  :)
1360 | 
1361 | 			return {
1362 |                 strokeWeight: (this.is_selected ? 2 : 1),
1363 |                 path:  "M 0,0 "+ baseSvg["planeData"],
1364 |                 scale: 0.4,
1365 |                 fillColor: this.markerColor,
1366 |                 fillOpacity: 0.9,
1367 |                 anchor: new google.maps.Point(32, 32), // Set anchor to middle of plane.
1368 |                 rotation: this.track
1369 |             };
1370 | 		},
1371 | 
1372 | 	// TODO: Trigger actions of a selecting a plane
1373 | 	funcSelectPlane	: function(selectedPlane){
1374 | 			selectPlaneByHex(this.icao);
1375 | 		},
1376 | 
1377 | 	// Update our data
1378 | 	funcUpdateData	: function(data){
1379 | 			// So we can find out if we moved
1380 | 			var oldlat 	= this.latitude;
1381 | 			var oldlon	= this.longitude;
1382 | 			var oldalt	= this.altitude;
1383 | 
1384 | 			// Update all of our data
1385 | 			this.updated	= new Date().getTime();
1386 | 			this.altitude	= data.altitude;
1387 | 			this.speed	= data.speed;
1388 | 			this.track	= data.track;
1389 | 			this.latitude	= data.lat;
1390 | 			this.longitude	= data.lon;
1391 | 			this.flight	= data.flight;
1392 | 			this.squawk	= data.squawk;
1393 | 			this.icao	= data.hex;
1394 | 			this.messages	= data.messages;
1395 | 			this.seen	= data.seen;
1396 | 
1397 | 			// If no packet in over 58 seconds, consider the plane reapable
1398 | 			// This way we can hold it, but not show it just in case the plane comes back
1399 | 			if (this.seen > 58) {
1400 | 				this.reapable = true;
1401 | 				if (this.marker) {
1402 | 					this.marker.setMap(null);
1403 | 					this.marker = null;
1404 | 				}
1405 | 				if (this.line) {
1406 | 					this.line.setMap(null);
1407 | 					this.line = null;
1408 | 				}
1409 | 				if (SelectedPlane == this.icao) {
1410 | 					if (this.is_selected) {
1411 | 						this.is_selected = false;
1412 | 					}
1413 | 					SelectedPlane = null;
1414 | 				}
1415 | 			} else {
1416 | 				if (this.reapable == true) {
1417 | 				}
1418 | 				this.reapable = false;
1419 | 			}
1420 | 
1421 | 			// Is the position valid?
1422 | 			if ((data.validposition == 1) && (this.reapable == false)) {
1423 | 				this.vPosition = true;
1424 | 
1425 | 				// Detech if the plane has moved
1426 | 				changeLat = false;
1427 | 				changeLon = false;
1428 | 				changeAlt = false;
1429 | 				if (oldlat != this.latitude) {
1430 | 					changeLat = true;
1431 | 				}
1432 | 				if (oldlon != this.longitude) {
1433 | 					changeLon = true;
1434 | 				}
1435 | 				if (oldalt != this.altitude) {
1436 | 					changeAlt = true;
1437 | 				}
1438 | 				// Right now we only care about lat/long, if alt is updated only, oh well
1439 | 				if ((changeLat == true) || (changeLon == true)) {
1440 | 					this.funcAddToTrack();
1441 | 					if (this.is_selected) {
1442 | 						this.line = this.funcUpdateLines();
1443 | 					}
1444 | 				}
1445 | 				this.marker = this.funcUpdateMarker();
1446 | 				PlanesOnMap++;
1447 | 			} else {
1448 | 				this.vPosition = false;
1449 | 			}
1450 | 
1451 | 			// Do we have a valid track for the plane?
1452 | 			if (data.validtrack == 1)
1453 | 				this.vTrack = true;
1454 | 			else
1455 | 				this.vTrack = false;
1456 | 		},
1457 | 
1458 | 	// Update our marker on the map
1459 | 	funcUpdateMarker: function() {
1460 | 			if (this.marker) {
1461 | 				this.marker.setPosition(new google.maps.LatLng(this.latitude, this.longitude));
1462 | 				this.marker.setIcon(this.funcGetIcon());
1463 | 			} else {
1464 | 				this.marker = new google.maps.Marker({
1465 | 					position: new google.maps.LatLng(this.latitude, this.longitude),
1466 | 					map: map,
1467 | 					icon: this.funcGetIcon(),
1468 | 					visable: true
1469 | 				});
1470 | 
1471 | 				// This is so we can match icao address
1472 | 				this.marker.icao = this.icao;
1473 | 
1474 | 				// Trap clicks for this marker.
1475 | 				google.maps.event.addListener(this.marker, 'click', this.funcSelectPlane);
1476 | 			}
1477 | 
1478 | 			// Setting the marker title
1479 | 			if (this.flight.length == 0) {
1480 | 				this.marker.setTitle(this.hex);
1481 | 			} else {
1482 | 				this.marker.setTitle(this.flight+' ('+this.icao+')');
1483 | 			}
1484 | 			return this.marker;
1485 | 		},
1486 | 
1487 | 	// Update our planes tail line,
1488 | 	// TODO: Make this multi colored based on options
1489 | 	//		altitude (default) or speed
1490 | 	funcUpdateLines: function() {
1491 | 			if (this.line) {
1492 | 				var path = this.line.getPath();
1493 | 				path.push(new google.maps.LatLng(this.latitude, this.longitude));
1494 | 			} else {
1495 | 				this.line = new google.maps.Polyline({
1496 | 					strokeColor: '#000000',
1497 | 					strokeOpacity: 1.0,
1498 | 					strokeWeight: 3,
1499 | 					map: map,
1500 | 					path: this.trackline
1501 | 				});
1502 | 			}
1503 | 			return this.line;
1504 | 		}
1505 | };
1506 | 


--------------------------------------------------------------------------------
/www/gmap.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 	<head>
 3 | 		<meta charset="utf-8"/>
 4 | 		<link rel="stylesheet" type="text/css" href="http://<%= host %>/style.css" />
 5 | 		<link rel="stylesheet" href="http://code.jquery.com/ui/1.10.3/themes/smoothness/jquery-ui.css" />
 6 | 		<script>
 7 | 		localStorage['CenterLat'] = <%= lat %>;
 8 | 		localStorage['CenterLon'] = <%= lon %>;
 9 | 		</script>
10 | 		<script src="//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
11 | 		<script src="//ajax.googleapis.com/ajax/libs/jqueryui/1.10.3/jquery-ui.min.js"></script>
12 | 		<script type="text/javascript" src="https://maps.googleapis.com/maps/api/js?sensor=false&amp;libraries=geometry"></script>
13 | 		<script type="text/javascript" src="http://<%= host %>/config.js"></script>
14 | 		<script type="text/javascript" src="http://<%= host %>/planeObject.js"></script>
15 | 		<script type="text/javascript" src="http://<%= host %>/options.js"></script>
16 | 		<script type="text/javascript" src="http://<%= host %>/extension.js"></script>
17 | 		<script type="text/javascript" src="http://<%= host %>/script.js"></script>
18 | 		<script type="text/javascript" src="http://<%= host %>/coolclock/excanvas.js"></script>
19 | 		<script type="text/javascript" src="http://<%= host %>/coolclock/coolclock.js"></script>
20 | 		<script type="text/javascript" src="http://<%= host %>/coolclock/moreskins.js"></script>
21 |         <title>DUMP1090</title>
22 | 	</head>
23 | 	<body onload="initialize()">
24 | 		<div id="dialog-modal" title="Basic modal dialog" style="display:none;">
25 | 			<p>The settings feature is coming soon. Keep checking GitHub.</p>
26 | 		</div>
27 | 		<div id="map_container">
28 | 			<div id="map_canvas"></div>
29 | 		</div>
30 | 		<div id="sidebar_container">
31 | 			<div id="sidebar_canvas">
32 | 				<div id="timestamps" style="align: center">
33 | 					<table width="100%"><tr>
34 | 						<td>Local Time</td>
35 | 						<td>
36 | 							<canvas id="localclock" class="CoolClock:classic:40"></canvas>
37 | 						</td>
38 | 						<td>UTC Time</td>
39 | 						<td>
40 | 							<canvas id="gmtclock" class="CoolClock:classic:40::0"></canvas>
41 | 						</td>
42 | 					</tr></table>
43 | 				</div>
44 | 				<div id="sudo_buttons">
45 | 					<table width="100%"><tr>
46 | 						<td width="150" style="text-align: center;" class="pointer">
47 | 						    [ <span onclick="resetMap();">Reset Map</span> ]
48 | 						</td>
49 | 						<td>&nbsp;</td>
50 | 						<td width="150" style="text-align: center;" id="setings_button" class="pointer">
51 | 						    [ <span onclick="optionsModal();">Settings</span> ]
52 | 						</td>
53 | 					</tr></table>
54 | 				</div>
55 | 
56 | 				<div id="plane_detail"></div>
57 | 				<div id="options"></div>
58 | 				<div id="planes_table"></div>
59 | 				<div id="plane_extension"></div>
60 | 			</div>
61 | 		</div>
62 | 		<div id="SpecialSquawkWarning">
63 | 		    <b>Squak 7x00 is reported and shown.</b><br>
64 |             This is most likely an error in reciving or decoding.<br>
65 |             Please do not call the local authorities, they already know about it if it is valid squak.
66 | 		</div>
67 | 		<div id="container_splitter"></div>
68 | 	</body>
69 | </html>
70 | 


--------------------------------------------------------------------------------
/www/img/focus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tobozo/signal-logr/5228b0f6c50e7d698a4ed0bef006ea793c1e5ce0/www/img/focus.png


--------------------------------------------------------------------------------
/www/img/gpio.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tobozo/signal-logr/5228b0f6c50e7d698a4ed0bef006ea793c1e5ce0/www/img/gpio.png


--------------------------------------------------------------------------------
/www/img/gps.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tobozo/signal-logr/5228b0f6c50e7d698a4ed0bef006ea793c1e5ce0/www/img/gps.png


--------------------------------------------------------------------------------
/www/img/restart.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tobozo/signal-logr/5228b0f6c50e7d698a4ed0bef006ea793c1e5ce0/www/img/restart.png


--------------------------------------------------------------------------------
/www/img/rtlsdr.jpeg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tobozo/signal-logr/5228b0f6c50e7d698a4ed0bef006ea793c1e5ce0/www/img/rtlsdr.jpeg


--------------------------------------------------------------------------------
/www/img/wifi.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tobozo/signal-logr/5228b0f6c50e7d698a4ed0bef006ea793c1e5ce0/www/img/wifi.png


--------------------------------------------------------------------------------
/www/jquery-ui-timepicker-addon.js:
--------------------------------------------------------------------------------
   1 | /*! jQuery Timepicker Addon - v1.6.3 - 2016-04-20
   2 | * http://trentrichardson.com/examples/timepicker
   3 | * Copyright (c) 2016 Trent Richardson; Licensed MIT */
   4 | (function (factory) {
   5 | 	if (typeof define === 'function' && define.amd) {
   6 | 		define(['jquery', 'jquery-ui'], factory);
   7 | 	} else {
   8 | 		factory(jQuery);
   9 | 	}
  10 | }(function ($) {
  11 | 
  12 | 	/*
  13 | 	* Lets not redefine timepicker, Prevent "Uncaught RangeError: Maximum call stack size exceeded"
  14 | 	*/
  15 | 	$.ui.timepicker = $.ui.timepicker || {};
  16 | 	if ($.ui.timepicker.version) {
  17 | 		return;
  18 | 	}
  19 | 
  20 | 	/*
  21 | 	* Extend jQueryUI, get it started with our version number
  22 | 	*/
  23 | 	$.extend($.ui, {
  24 | 		timepicker: {
  25 | 			version: "1.6.3"
  26 | 		}
  27 | 	});
  28 | 
  29 | 	/*
  30 | 	* Timepicker manager.
  31 | 	* Use the singleton instance of this class, $.timepicker, to interact with the time picker.
  32 | 	* Settings for (groups of) time pickers are maintained in an instance object,
  33 | 	* allowing multiple different settings on the same page.
  34 | 	*/
  35 | 	var Timepicker = function () {
  36 | 		this.regional = []; // Available regional settings, indexed by language code
  37 | 		this.regional[''] = { // Default regional settings
  38 | 			currentText: 'Now',
  39 | 			closeText: 'Done',
  40 | 			amNames: ['AM', 'A'],
  41 | 			pmNames: ['PM', 'P'],
  42 | 			timeFormat: 'HH:mm',
  43 | 			timeSuffix: '',
  44 | 			timeOnlyTitle: 'Choose Time',
  45 | 			timeText: 'Time',
  46 | 			hourText: 'Hour',
  47 | 			minuteText: 'Minute',
  48 | 			secondText: 'Second',
  49 | 			millisecText: 'Millisecond',
  50 | 			microsecText: 'Microsecond',
  51 | 			timezoneText: 'Time Zone',
  52 | 			isRTL: false
  53 | 		};
  54 | 		this._defaults = { // Global defaults for all the datetime picker instances
  55 | 			showButtonPanel: true,
  56 | 			timeOnly: false,
  57 | 			timeOnlyShowDate: false,
  58 | 			showHour: null,
  59 | 			showMinute: null,
  60 | 			showSecond: null,
  61 | 			showMillisec: null,
  62 | 			showMicrosec: null,
  63 | 			showTimezone: null,
  64 | 			showTime: true,
  65 | 			stepHour: 1,
  66 | 			stepMinute: 1,
  67 | 			stepSecond: 1,
  68 | 			stepMillisec: 1,
  69 | 			stepMicrosec: 1,
  70 | 			hour: 0,
  71 | 			minute: 0,
  72 | 			second: 0,
  73 | 			millisec: 0,
  74 | 			microsec: 0,
  75 | 			timezone: null,
  76 | 			hourMin: 0,
  77 | 			minuteMin: 0,
  78 | 			secondMin: 0,
  79 | 			millisecMin: 0,
  80 | 			microsecMin: 0,
  81 | 			hourMax: 23,
  82 | 			minuteMax: 59,
  83 | 			secondMax: 59,
  84 | 			millisecMax: 999,
  85 | 			microsecMax: 999,
  86 | 			minDateTime: null,
  87 | 			maxDateTime: null,
  88 | 			maxTime: null,
  89 | 			minTime: null,
  90 | 			onSelect: null,
  91 | 			hourGrid: 0,
  92 | 			minuteGrid: 0,
  93 | 			secondGrid: 0,
  94 | 			millisecGrid: 0,
  95 | 			microsecGrid: 0,
  96 | 			alwaysSetTime: true,
  97 | 			separator: ' ',
  98 | 			altFieldTimeOnly: true,
  99 | 			altTimeFormat: null,
 100 | 			altSeparator: null,
 101 | 			altTimeSuffix: null,
 102 | 			altRedirectFocus: true,
 103 | 			pickerTimeFormat: null,
 104 | 			pickerTimeSuffix: null,
 105 | 			showTimepicker: true,
 106 | 			timezoneList: null,
 107 | 			addSliderAccess: false,
 108 | 			sliderAccessArgs: null,
 109 | 			controlType: 'slider',
 110 | 			oneLine: false,
 111 | 			defaultValue: null,
 112 | 			parse: 'strict',
 113 | 			afterInject: null
 114 | 		};
 115 | 		$.extend(this._defaults, this.regional['']);
 116 | 	};
 117 | 
 118 | 	$.extend(Timepicker.prototype, {
 119 | 		$input: null,
 120 | 		$altInput: null,
 121 | 		$timeObj: null,
 122 | 		inst: null,
 123 | 		hour_slider: null,
 124 | 		minute_slider: null,
 125 | 		second_slider: null,
 126 | 		millisec_slider: null,
 127 | 		microsec_slider: null,
 128 | 		timezone_select: null,
 129 | 		maxTime: null,
 130 | 		minTime: null,
 131 | 		hour: 0,
 132 | 		minute: 0,
 133 | 		second: 0,
 134 | 		millisec: 0,
 135 | 		microsec: 0,
 136 | 		timezone: null,
 137 | 		hourMinOriginal: null,
 138 | 		minuteMinOriginal: null,
 139 | 		secondMinOriginal: null,
 140 | 		millisecMinOriginal: null,
 141 | 		microsecMinOriginal: null,
 142 | 		hourMaxOriginal: null,
 143 | 		minuteMaxOriginal: null,
 144 | 		secondMaxOriginal: null,
 145 | 		millisecMaxOriginal: null,
 146 | 		microsecMaxOriginal: null,
 147 | 		ampm: '',
 148 | 		formattedDate: '',
 149 | 		formattedTime: '',
 150 | 		formattedDateTime: '',
 151 | 		timezoneList: null,
 152 | 		units: ['hour', 'minute', 'second', 'millisec', 'microsec'],
 153 | 		support: {},
 154 | 		control: null,
 155 | 
 156 | 		/*
 157 | 		* Override the default settings for all instances of the time picker.
 158 | 		* @param  {Object} settings  object - the new settings to use as defaults (anonymous object)
 159 | 		* @return {Object} the manager object
 160 | 		*/
 161 | 		setDefaults: function (settings) {
 162 | 			extendRemove(this._defaults, settings || {});
 163 | 			return this;
 164 | 		},
 165 | 
 166 | 		/*
 167 | 		* Create a new Timepicker instance
 168 | 		*/
 169 | 		_newInst: function ($input, opts) {
 170 | 			var tp_inst = new Timepicker(),
 171 | 				inlineSettings = {},
 172 | 				fns = {},
 173 | 				overrides, i;
 174 | 
 175 | 			for (var attrName in this._defaults) {
 176 | 				if (this._defaults.hasOwnProperty(attrName)) {
 177 | 					var attrValue = $input.attr('time:' + attrName);
 178 | 					if (attrValue) {
 179 | 						try {
 180 | 							inlineSettings[attrName] = eval(attrValue);
 181 | 						} catch (err) {
 182 | 							inlineSettings[attrName] = attrValue;
 183 | 						}
 184 | 					}
 185 | 				}
 186 | 			}
 187 | 
 188 | 			overrides = {
 189 | 				beforeShow: function (input, dp_inst) {
 190 | 					if ($.isFunction(tp_inst._defaults.evnts.beforeShow)) {
 191 | 						return tp_inst._defaults.evnts.beforeShow.call($input[0], input, dp_inst, tp_inst);
 192 | 					}
 193 | 				},
 194 | 				onChangeMonthYear: function (year, month, dp_inst) {
 195 | 					// Update the time as well : this prevents the time from disappearing from the $input field.
 196 | 					// tp_inst._updateDateTime(dp_inst);
 197 | 					if ($.isFunction(tp_inst._defaults.evnts.onChangeMonthYear)) {
 198 | 						tp_inst._defaults.evnts.onChangeMonthYear.call($input[0], year, month, dp_inst, tp_inst);
 199 | 					}
 200 | 				},
 201 | 				onClose: function (dateText, dp_inst) {
 202 | 					if (tp_inst.timeDefined === true && $input.val() !== '') {
 203 | 						tp_inst._updateDateTime(dp_inst);
 204 | 					}
 205 | 					if ($.isFunction(tp_inst._defaults.evnts.onClose)) {
 206 | 						tp_inst._defaults.evnts.onClose.call($input[0], dateText, dp_inst, tp_inst);
 207 | 					}
 208 | 				}
 209 | 			};
 210 | 			for (i in overrides) {
 211 | 				if (overrides.hasOwnProperty(i)) {
 212 | 					fns[i] = opts[i] || this._defaults[i] || null;
 213 | 				}
 214 | 			}
 215 | 
 216 | 			tp_inst._defaults = $.extend({}, this._defaults, inlineSettings, opts, overrides, {
 217 | 				evnts: fns,
 218 | 				timepicker: tp_inst // add timepicker as a property of datepicker: $.datepicker._get(dp_inst, 'timepicker');
 219 | 			});
 220 | 			tp_inst.amNames = $.map(tp_inst._defaults.amNames, function (val) {
 221 | 				return val.toUpperCase();
 222 | 			});
 223 | 			tp_inst.pmNames = $.map(tp_inst._defaults.pmNames, function (val) {
 224 | 				return val.toUpperCase();
 225 | 			});
 226 | 
 227 | 			// detect which units are supported
 228 | 			tp_inst.support = detectSupport(
 229 | 					tp_inst._defaults.timeFormat +
 230 | 					(tp_inst._defaults.pickerTimeFormat ? tp_inst._defaults.pickerTimeFormat : '') +
 231 | 					(tp_inst._defaults.altTimeFormat ? tp_inst._defaults.altTimeFormat : ''));
 232 | 
 233 | 			// controlType is string - key to our this._controls
 234 | 			if (typeof(tp_inst._defaults.controlType) === 'string') {
 235 | 				if (tp_inst._defaults.controlType === 'slider' && typeof($.ui.slider) === 'undefined') {
 236 | 					tp_inst._defaults.controlType = 'select';
 237 | 				}
 238 | 				tp_inst.control = tp_inst._controls[tp_inst._defaults.controlType];
 239 | 			}
 240 | 			// controlType is an object and must implement create, options, value methods
 241 | 			else {
 242 | 				tp_inst.control = tp_inst._defaults.controlType;
 243 | 			}
 244 | 
 245 | 			// prep the timezone options
 246 | 			var timezoneList = [-720, -660, -600, -570, -540, -480, -420, -360, -300, -270, -240, -210, -180, -120, -60,
 247 | 					0, 60, 120, 180, 210, 240, 270, 300, 330, 345, 360, 390, 420, 480, 525, 540, 570, 600, 630, 660, 690, 720, 765, 780, 840];
 248 | 			if (tp_inst._defaults.timezoneList !== null) {
 249 | 				timezoneList = tp_inst._defaults.timezoneList;
 250 | 			}
 251 | 			var tzl = timezoneList.length, tzi = 0, tzv = null;
 252 | 			if (tzl > 0 && typeof timezoneList[0] !== 'object') {
 253 | 				for (; tzi < tzl; tzi++) {
 254 | 					tzv = timezoneList[tzi];
 255 | 					timezoneList[tzi] = { value: tzv, label: $.timepicker.timezoneOffsetString(tzv, tp_inst.support.iso8601) };
 256 | 				}
 257 | 			}
 258 | 			tp_inst._defaults.timezoneList = timezoneList;
 259 | 
 260 | 			// set the default units
 261 | 			tp_inst.timezone = tp_inst._defaults.timezone !== null ? $.timepicker.timezoneOffsetNumber(tp_inst._defaults.timezone) :
 262 | 							((new Date()).getTimezoneOffset() * -1);
 263 | 			tp_inst.hour = tp_inst._defaults.hour < tp_inst._defaults.hourMin ? tp_inst._defaults.hourMin :
 264 | 							tp_inst._defaults.hour > tp_inst._defaults.hourMax ? tp_inst._defaults.hourMax : tp_inst._defaults.hour;
 265 | 			tp_inst.minute = tp_inst._defaults.minute < tp_inst._defaults.minuteMin ? tp_inst._defaults.minuteMin :
 266 | 							tp_inst._defaults.minute > tp_inst._defaults.minuteMax ? tp_inst._defaults.minuteMax : tp_inst._defaults.minute;
 267 | 			tp_inst.second = tp_inst._defaults.second < tp_inst._defaults.secondMin ? tp_inst._defaults.secondMin :
 268 | 							tp_inst._defaults.second > tp_inst._defaults.secondMax ? tp_inst._defaults.secondMax : tp_inst._defaults.second;
 269 | 			tp_inst.millisec = tp_inst._defaults.millisec < tp_inst._defaults.millisecMin ? tp_inst._defaults.millisecMin :
 270 | 							tp_inst._defaults.millisec > tp_inst._defaults.millisecMax ? tp_inst._defaults.millisecMax : tp_inst._defaults.millisec;
 271 | 			tp_inst.microsec = tp_inst._defaults.microsec < tp_inst._defaults.microsecMin ? tp_inst._defaults.microsecMin :
 272 | 							tp_inst._defaults.microsec > tp_inst._defaults.microsecMax ? tp_inst._defaults.microsecMax : tp_inst._defaults.microsec;
 273 | 			tp_inst.ampm = '';
 274 | 			tp_inst.$input = $input;
 275 | 
 276 | 			if (tp_inst._defaults.altField) {
 277 | 				tp_inst.$altInput = $(tp_inst._defaults.altField);
 278 | 				if (tp_inst._defaults.altRedirectFocus === true) {
 279 | 					tp_inst.$altInput.css({
 280 | 						cursor: 'pointer'
 281 | 					}).focus(function () {
 282 | 						$input.trigger("focus");
 283 | 					});
 284 | 				}
 285 | 			}
 286 | 
 287 | 			if (tp_inst._defaults.minDate === 0 || tp_inst._defaults.minDateTime === 0) {
 288 | 				tp_inst._defaults.minDate = new Date();
 289 | 			}
 290 | 			if (tp_inst._defaults.maxDate === 0 || tp_inst._defaults.maxDateTime === 0) {
 291 | 				tp_inst._defaults.maxDate = new Date();
 292 | 			}
 293 | 
 294 | 			// datepicker needs minDate/maxDate, timepicker needs minDateTime/maxDateTime..
 295 | 			if (tp_inst._defaults.minDate !== undefined && tp_inst._defaults.minDate instanceof Date) {
 296 | 				tp_inst._defaults.minDateTime = new Date(tp_inst._defaults.minDate.getTime());
 297 | 			}
 298 | 			if (tp_inst._defaults.minDateTime !== undefined && tp_inst._defaults.minDateTime instanceof Date) {
 299 | 				tp_inst._defaults.minDate = new Date(tp_inst._defaults.minDateTime.getTime());
 300 | 			}
 301 | 			if (tp_inst._defaults.maxDate !== undefined && tp_inst._defaults.maxDate instanceof Date) {
 302 | 				tp_inst._defaults.maxDateTime = new Date(tp_inst._defaults.maxDate.getTime());
 303 | 			}
 304 | 			if (tp_inst._defaults.maxDateTime !== undefined && tp_inst._defaults.maxDateTime instanceof Date) {
 305 | 				tp_inst._defaults.maxDate = new Date(tp_inst._defaults.maxDateTime.getTime());
 306 | 			}
 307 | 			tp_inst.$input.bind('focus', function () {
 308 | 				tp_inst._onFocus();
 309 | 			});
 310 | 
 311 | 			return tp_inst;
 312 | 		},
 313 | 
 314 | 		/*
 315 | 		* add our sliders to the calendar
 316 | 		*/
 317 | 		_addTimePicker: function (dp_inst) {
 318 | 			var currDT = $.trim((this.$altInput && this._defaults.altFieldTimeOnly) ? this.$input.val() + ' ' + this.$altInput.val() : this.$input.val());
 319 | 
 320 | 			this.timeDefined = this._parseTime(currDT);
 321 | 			this._limitMinMaxDateTime(dp_inst, false);
 322 | 			this._injectTimePicker();
 323 | 			this._afterInject();
 324 | 		},
 325 | 
 326 | 		/*
 327 | 		* parse the time string from input value or _setTime
 328 | 		*/
 329 | 		_parseTime: function (timeString, withDate) {
 330 | 			if (!this.inst) {
 331 | 				this.inst = $.datepicker._getInst(this.$input[0]);
 332 | 			}
 333 | 
 334 | 			if (withDate || !this._defaults.timeOnly) {
 335 | 				var dp_dateFormat = $.datepicker._get(this.inst, 'dateFormat');
 336 | 				try {
 337 | 					var parseRes = parseDateTimeInternal(dp_dateFormat, this._defaults.timeFormat, timeString, $.datepicker._getFormatConfig(this.inst), this._defaults);
 338 | 					if (!parseRes.timeObj) {
 339 | 						return false;
 340 | 					}
 341 | 					$.extend(this, parseRes.timeObj);
 342 | 				} catch (err) {
 343 | 					$.timepicker.log("Error parsing the date/time string: " + err +
 344 | 									"\ndate/time string = " + timeString +
 345 | 									"\ntimeFormat = " + this._defaults.timeFormat +
 346 | 									"\ndateFormat = " + dp_dateFormat);
 347 | 					return false;
 348 | 				}
 349 | 				return true;
 350 | 			} else {
 351 | 				var timeObj = $.datepicker.parseTime(this._defaults.timeFormat, timeString, this._defaults);
 352 | 				if (!timeObj) {
 353 | 					return false;
 354 | 				}
 355 | 				$.extend(this, timeObj);
 356 | 				return true;
 357 | 			}
 358 | 		},
 359 | 
 360 | 		/*
 361 | 		* Handle callback option after injecting timepicker
 362 | 		*/
 363 | 		_afterInject: function() {
 364 | 			var o = this.inst.settings;
 365 | 			if ($.isFunction(o.afterInject)) {
 366 | 				o.afterInject.call(this);
 367 | 			}
 368 | 		},
 369 | 
 370 | 		/*
 371 | 		* generate and inject html for timepicker into ui datepicker
 372 | 		*/
 373 | 		_injectTimePicker: function () {
 374 | 			var $dp = this.inst.dpDiv,
 375 | 				o = this.inst.settings,
 376 | 				tp_inst = this,
 377 | 				litem = '',
 378 | 				uitem = '',
 379 | 				show = null,
 380 | 				max = {},
 381 | 				gridSize = {},
 382 | 				size = null,
 383 | 				i = 0,
 384 | 				l = 0;
 385 | 
 386 | 			// Prevent displaying twice
 387 | 			if ($dp.find("div.ui-timepicker-div").length === 0 && o.showTimepicker) {
 388 | 				var noDisplay = ' ui_tpicker_unit_hide',
 389 | 					html = '<div class="ui-timepicker-div' + (o.isRTL ? ' ui-timepicker-rtl' : '') + (o.oneLine && o.controlType === 'select' ? ' ui-timepicker-oneLine' : '') + '"><dl>' + '<dt class="ui_tpicker_time_label' + ((o.showTime) ? '' : noDisplay) + '">' + o.timeText + '</dt>' +
 390 | 								'<dd class="ui_tpicker_time '+ ((o.showTime) ? '' : noDisplay) + '"><input class="ui_tpicker_time_input" ' + (o.timeInput ? '' : 'disabled') + '/></dd>';
 391 | 
 392 | 				// Create the markup
 393 | 				for (i = 0, l = this.units.length; i < l; i++) {
 394 | 					litem = this.units[i];
 395 | 					uitem = litem.substr(0, 1).toUpperCase() + litem.substr(1);
 396 | 					show = o['show' + uitem] !== null ? o['show' + uitem] : this.support[litem];
 397 | 
 398 | 					// Added by Peter Medeiros:
 399 | 					// - Figure out what the hour/minute/second max should be based on the step values.
 400 | 					// - Example: if stepMinute is 15, then minMax is 45.
 401 | 					max[litem] = parseInt((o[litem + 'Max'] - ((o[litem + 'Max'] - o[litem + 'Min']) % o['step' + uitem])), 10);
 402 | 					gridSize[litem] = 0;
 403 | 
 404 | 					html += '<dt class="ui_tpicker_' + litem + '_label' + (show ? '' : noDisplay) + '">' + o[litem + 'Text'] + '</dt>' +
 405 | 								'<dd class="ui_tpicker_' + litem + (show ? '' : noDisplay) + '"><div class="ui_tpicker_' + litem + '_slider' + (show ? '' : noDisplay) + '"></div>';
 406 | 
 407 | 					if (show && o[litem + 'Grid'] > 0) {
 408 | 						html += '<div style="padding-left: 1px"><table class="ui-tpicker-grid-label"><tr>';
 409 | 
 410 | 						if (litem === 'hour') {
 411 | 							for (var h = o[litem + 'Min']; h <= max[litem]; h += parseInt(o[litem + 'Grid'], 10)) {
 412 | 								gridSize[litem]++;
 413 | 								var tmph = $.datepicker.formatTime(this.support.ampm ? 'hht' : 'HH', {hour: h}, o);
 414 | 								html += '<td data-for="' + litem + '">' + tmph + '</td>';
 415 | 							}
 416 | 						}
 417 | 						else {
 418 | 							for (var m = o[litem + 'Min']; m <= max[litem]; m += parseInt(o[litem + 'Grid'], 10)) {
 419 | 								gridSize[litem]++;
 420 | 								html += '<td data-for="' + litem + '">' + ((m < 10) ? '0' : '') + m + '</td>';
 421 | 							}
 422 | 						}
 423 | 
 424 | 						html += '</tr></table></div>';
 425 | 					}
 426 | 					html += '</dd>';
 427 | 				}
 428 | 
 429 | 				// Timezone
 430 | 				var showTz = o.showTimezone !== null ? o.showTimezone : this.support.timezone;
 431 | 				html += '<dt class="ui_tpicker_timezone_label' + (showTz ? '' : noDisplay) + '">' + o.timezoneText + '</dt>';
 432 | 				html += '<dd class="ui_tpicker_timezone' + (showTz ? '' : noDisplay) + '"></dd>';
 433 | 
 434 | 				// Create the elements from string
 435 | 				html += '</dl></div>';
 436 | 				var $tp = $(html);
 437 | 
 438 | 				// if we only want time picker...
 439 | 				if (o.timeOnly === true) {
 440 | 					$tp.prepend('<div class="ui-widget-header ui-helper-clearfix ui-corner-all">' + '<div class="ui-datepicker-title">' + o.timeOnlyTitle + '</div>' + '</div>');
 441 | 					$dp.find('.ui-datepicker-header, .ui-datepicker-calendar').hide();
 442 | 				}
 443 | 
 444 | 				// add sliders, adjust grids, add events
 445 | 				for (i = 0, l = tp_inst.units.length; i < l; i++) {
 446 | 					litem = tp_inst.units[i];
 447 | 					uitem = litem.substr(0, 1).toUpperCase() + litem.substr(1);
 448 | 					show = o['show' + uitem] !== null ? o['show' + uitem] : this.support[litem];
 449 | 
 450 | 					// add the slider
 451 | 					tp_inst[litem + '_slider'] = tp_inst.control.create(tp_inst, $tp.find('.ui_tpicker_' + litem + '_slider'), litem, tp_inst[litem], o[litem + 'Min'], max[litem], o['step' + uitem]);
 452 | 
 453 | 					// adjust the grid and add click event
 454 | 					if (show && o[litem + 'Grid'] > 0) {
 455 | 						size = 100 * gridSize[litem] * o[litem + 'Grid'] / (max[litem] - o[litem + 'Min']);
 456 | 						$tp.find('.ui_tpicker_' + litem + ' table').css({
 457 | 							width: size + "%",
 458 | 							marginLeft: o.isRTL ? '0' : ((size / (-2 * gridSize[litem])) + "%"),
 459 | 							marginRight: o.isRTL ? ((size / (-2 * gridSize[litem])) + "%") : '0',
 460 | 							borderCollapse: 'collapse'
 461 | 						}).find("td").click(function (e) {
 462 | 								var $t = $(this),
 463 | 									h = $t.html(),
 464 | 									n = parseInt(h.replace(/[^0-9]/g), 10),
 465 | 									ap = h.replace(/[^apm]/ig),
 466 | 									f = $t.data('for'); // loses scope, so we use data-for
 467 | 
 468 | 								if (f === 'hour') {
 469 | 									if (ap.indexOf('p') !== -1 && n < 12) {
 470 | 										n += 12;
 471 | 									}
 472 | 									else {
 473 | 										if (ap.indexOf('a') !== -1 && n === 12) {
 474 | 											n = 0;
 475 | 										}
 476 | 									}
 477 | 								}
 478 | 
 479 | 								tp_inst.control.value(tp_inst, tp_inst[f + '_slider'], litem, n);
 480 | 
 481 | 								tp_inst._onTimeChange();
 482 | 								tp_inst._onSelectHandler();
 483 | 							}).css({
 484 | 								cursor: 'pointer',
 485 | 								width: (100 / gridSize[litem]) + '%',
 486 | 								textAlign: 'center',
 487 | 								overflow: 'hidden'
 488 | 							});
 489 | 					} // end if grid > 0
 490 | 				} // end for loop
 491 | 
 492 | 				// Add timezone options
 493 | 				this.timezone_select = $tp.find('.ui_tpicker_timezone').append('<select></select>').find("select");
 494 | 				$.fn.append.apply(this.timezone_select,
 495 | 				$.map(o.timezoneList, function (val, idx) {
 496 | 					return $("<option />").val(typeof val === "object" ? val.value : val).text(typeof val === "object" ? val.label : val);
 497 | 				}));
 498 | 				if (typeof(this.timezone) !== "undefined" && this.timezone !== null && this.timezone !== "") {
 499 | 					var local_timezone = (new Date(this.inst.selectedYear, this.inst.selectedMonth, this.inst.selectedDay, 12)).getTimezoneOffset() * -1;
 500 | 					if (local_timezone === this.timezone) {
 501 | 						selectLocalTimezone(tp_inst);
 502 | 					} else {
 503 | 						this.timezone_select.val(this.timezone);
 504 | 					}
 505 | 				} else {
 506 | 					if (typeof(this.hour) !== "undefined" && this.hour !== null && this.hour !== "") {
 507 | 						this.timezone_select.val(o.timezone);
 508 | 					} else {
 509 | 						selectLocalTimezone(tp_inst);
 510 | 					}
 511 | 				}
 512 | 				this.timezone_select.change(function () {
 513 | 					tp_inst._onTimeChange();
 514 | 					tp_inst._onSelectHandler();
 515 | 					tp_inst._afterInject();
 516 | 				});
 517 | 				// End timezone options
 518 | 
 519 | 				// inject timepicker into datepicker
 520 | 				var $buttonPanel = $dp.find('.ui-datepicker-buttonpane');
 521 | 				if ($buttonPanel.length) {
 522 | 					$buttonPanel.before($tp);
 523 | 				} else {
 524 | 					$dp.append($tp);
 525 | 				}
 526 | 
 527 | 				this.$timeObj = $tp.find('.ui_tpicker_time_input');
 528 | 				this.$timeObj.change(function () {
 529 | 					var timeFormat = tp_inst.inst.settings.timeFormat;
 530 | 					var parsedTime = $.datepicker.parseTime(timeFormat, this.value);
 531 | 					var update = new Date();
 532 | 					if (parsedTime) {
 533 | 						update.setHours(parsedTime.hour);
 534 | 						update.setMinutes(parsedTime.minute);
 535 | 						update.setSeconds(parsedTime.second);
 536 | 						$.datepicker._setTime(tp_inst.inst, update);
 537 | 					} else {
 538 | 						this.value = tp_inst.formattedTime;
 539 | 						this.blur();
 540 | 					}
 541 | 				});
 542 | 
 543 | 				if (this.inst !== null) {
 544 | 					var timeDefined = this.timeDefined;
 545 | 					this._onTimeChange();
 546 | 					this.timeDefined = timeDefined;
 547 | 				}
 548 | 
 549 | 				// slideAccess integration: http://trentrichardson.com/2011/11/11/jquery-ui-sliders-and-touch-accessibility/
 550 | 				if (this._defaults.addSliderAccess) {
 551 | 					var sliderAccessArgs = this._defaults.sliderAccessArgs,
 552 | 						rtl = this._defaults.isRTL;
 553 | 					sliderAccessArgs.isRTL = rtl;
 554 | 
 555 | 					setTimeout(function () { // fix for inline mode
 556 | 						if ($tp.find('.ui-slider-access').length === 0) {
 557 | 							$tp.find('.ui-slider:visible').sliderAccess(sliderAccessArgs);
 558 | 
 559 | 							// fix any grids since sliders are shorter
 560 | 							var sliderAccessWidth = $tp.find('.ui-slider-access:eq(0)').outerWidth(true);
 561 | 							if (sliderAccessWidth) {
 562 | 								$tp.find('table:visible').each(function () {
 563 | 									var $g = $(this),
 564 | 										oldWidth = $g.outerWidth(),
 565 | 										oldMarginLeft = $g.css(rtl ? 'marginRight' : 'marginLeft').toString().replace('%', ''),
 566 | 										newWidth = oldWidth - sliderAccessWidth,
 567 | 										newMarginLeft = ((oldMarginLeft * newWidth) / oldWidth) + '%',
 568 | 										css = { width: newWidth, marginRight: 0, marginLeft: 0 };
 569 | 									css[rtl ? 'marginRight' : 'marginLeft'] = newMarginLeft;
 570 | 									$g.css(css);
 571 | 								});
 572 | 							}
 573 | 						}
 574 | 					}, 10);
 575 | 				}
 576 | 				// end slideAccess integration
 577 | 
 578 | 				tp_inst._limitMinMaxDateTime(this.inst, true);
 579 | 			}
 580 | 		},
 581 | 
 582 | 		/*
 583 | 		* This function tries to limit the ability to go outside the
 584 | 		* min/max date range
 585 | 		*/
 586 | 		_limitMinMaxDateTime: function (dp_inst, adjustSliders) {
 587 | 			var o = this._defaults,
 588 | 				dp_date = new Date(dp_inst.selectedYear, dp_inst.selectedMonth, dp_inst.selectedDay);
 589 | 
 590 | 			if (!this._defaults.showTimepicker) {
 591 | 				return;
 592 | 			} // No time so nothing to check here
 593 | 
 594 | 			if ($.datepicker._get(dp_inst, 'minDateTime') !== null && $.datepicker._get(dp_inst, 'minDateTime') !== undefined && dp_date) {
 595 | 				var minDateTime = $.datepicker._get(dp_inst, 'minDateTime'),
 596 | 					minDateTimeDate = new Date(minDateTime.getFullYear(), minDateTime.getMonth(), minDateTime.getDate(), 0, 0, 0, 0);
 597 | 
 598 | 				if (this.hourMinOriginal === null || this.minuteMinOriginal === null || this.secondMinOriginal === null || this.millisecMinOriginal === null || this.microsecMinOriginal === null) {
 599 | 					this.hourMinOriginal = o.hourMin;
 600 | 					this.minuteMinOriginal = o.minuteMin;
 601 | 					this.secondMinOriginal = o.secondMin;
 602 | 					this.millisecMinOriginal = o.millisecMin;
 603 | 					this.microsecMinOriginal = o.microsecMin;
 604 | 				}
 605 | 
 606 | 				if (dp_inst.settings.timeOnly || minDateTimeDate.getTime() === dp_date.getTime()) {
 607 | 					this._defaults.hourMin = minDateTime.getHours();
 608 | 					if (this.hour <= this._defaults.hourMin) {
 609 | 						this.hour = this._defaults.hourMin;
 610 | 						this._defaults.minuteMin = minDateTime.getMinutes();
 611 | 						if (this.minute <= this._defaults.minuteMin) {
 612 | 							this.minute = this._defaults.minuteMin;
 613 | 							this._defaults.secondMin = minDateTime.getSeconds();
 614 | 							if (this.second <= this._defaults.secondMin) {
 615 | 								this.second = this._defaults.secondMin;
 616 | 								this._defaults.millisecMin = minDateTime.getMilliseconds();
 617 | 								if (this.millisec <= this._defaults.millisecMin) {
 618 | 									this.millisec = this._defaults.millisecMin;
 619 | 									this._defaults.microsecMin = minDateTime.getMicroseconds();
 620 | 								} else {
 621 | 									if (this.microsec < this._defaults.microsecMin) {
 622 | 										this.microsec = this._defaults.microsecMin;
 623 | 									}
 624 | 									this._defaults.microsecMin = this.microsecMinOriginal;
 625 | 								}
 626 | 							} else {
 627 | 								this._defaults.millisecMin = this.millisecMinOriginal;
 628 | 								this._defaults.microsecMin = this.microsecMinOriginal;
 629 | 							}
 630 | 						} else {
 631 | 							this._defaults.secondMin = this.secondMinOriginal;
 632 | 							this._defaults.millisecMin = this.millisecMinOriginal;
 633 | 							this._defaults.microsecMin = this.microsecMinOriginal;
 634 | 						}
 635 | 					} else {
 636 | 						this._defaults.minuteMin = this.minuteMinOriginal;
 637 | 						this._defaults.secondMin = this.secondMinOriginal;
 638 | 						this._defaults.millisecMin = this.millisecMinOriginal;
 639 | 						this._defaults.microsecMin = this.microsecMinOriginal;
 640 | 					}
 641 | 				} else {
 642 | 					this._defaults.hourMin = this.hourMinOriginal;
 643 | 					this._defaults.minuteMin = this.minuteMinOriginal;
 644 | 					this._defaults.secondMin = this.secondMinOriginal;
 645 | 					this._defaults.millisecMin = this.millisecMinOriginal;
 646 | 					this._defaults.microsecMin = this.microsecMinOriginal;
 647 | 				}
 648 | 			}
 649 | 
 650 | 			if ($.datepicker._get(dp_inst, 'maxDateTime') !== null && $.datepicker._get(dp_inst, 'maxDateTime') !== undefined && dp_date) {
 651 | 				var maxDateTime = $.datepicker._get(dp_inst, 'maxDateTime'),
 652 | 					maxDateTimeDate = new Date(maxDateTime.getFullYear(), maxDateTime.getMonth(), maxDateTime.getDate(), 0, 0, 0, 0);
 653 | 
 654 | 				if (this.hourMaxOriginal === null || this.minuteMaxOriginal === null || this.secondMaxOriginal === null || this.millisecMaxOriginal === null) {
 655 | 					this.hourMaxOriginal = o.hourMax;
 656 | 					this.minuteMaxOriginal = o.minuteMax;
 657 | 					this.secondMaxOriginal = o.secondMax;
 658 | 					this.millisecMaxOriginal = o.millisecMax;
 659 | 					this.microsecMaxOriginal = o.microsecMax;
 660 | 				}
 661 | 
 662 | 				if (dp_inst.settings.timeOnly || maxDateTimeDate.getTime() === dp_date.getTime()) {
 663 | 					this._defaults.hourMax = maxDateTime.getHours();
 664 | 					if (this.hour >= this._defaults.hourMax) {
 665 | 						this.hour = this._defaults.hourMax;
 666 | 						this._defaults.minuteMax = maxDateTime.getMinutes();
 667 | 						if (this.minute >= this._defaults.minuteMax) {
 668 | 							this.minute = this._defaults.minuteMax;
 669 | 							this._defaults.secondMax = maxDateTime.getSeconds();
 670 | 							if (this.second >= this._defaults.secondMax) {
 671 | 								this.second = this._defaults.secondMax;
 672 | 								this._defaults.millisecMax = maxDateTime.getMilliseconds();
 673 | 								if (this.millisec >= this._defaults.millisecMax) {
 674 | 									this.millisec = this._defaults.millisecMax;
 675 | 									this._defaults.microsecMax = maxDateTime.getMicroseconds();
 676 | 								} else {
 677 | 									if (this.microsec > this._defaults.microsecMax) {
 678 | 										this.microsec = this._defaults.microsecMax;
 679 | 									}
 680 | 									this._defaults.microsecMax = this.microsecMaxOriginal;
 681 | 								}
 682 | 							} else {
 683 | 								this._defaults.millisecMax = this.millisecMaxOriginal;
 684 | 								this._defaults.microsecMax = this.microsecMaxOriginal;
 685 | 							}
 686 | 						} else {
 687 | 							this._defaults.secondMax = this.secondMaxOriginal;
 688 | 							this._defaults.millisecMax = this.millisecMaxOriginal;
 689 | 							this._defaults.microsecMax = this.microsecMaxOriginal;
 690 | 						}
 691 | 					} else {
 692 | 						this._defaults.minuteMax = this.minuteMaxOriginal;
 693 | 						this._defaults.secondMax = this.secondMaxOriginal;
 694 | 						this._defaults.millisecMax = this.millisecMaxOriginal;
 695 | 						this._defaults.microsecMax = this.microsecMaxOriginal;
 696 | 					}
 697 | 				} else {
 698 | 					this._defaults.hourMax = this.hourMaxOriginal;
 699 | 					this._defaults.minuteMax = this.minuteMaxOriginal;
 700 | 					this._defaults.secondMax = this.secondMaxOriginal;
 701 | 					this._defaults.millisecMax = this.millisecMaxOriginal;
 702 | 					this._defaults.microsecMax = this.microsecMaxOriginal;
 703 | 				}
 704 | 			}
 705 | 
 706 | 			if (dp_inst.settings.minTime!==null) {
 707 | 				var tempMinTime=new Date("01/01/1970 " + dp_inst.settings.minTime);
 708 | 				if (this.hour<tempMinTime.getHours()) {
 709 | 					this.hour=this._defaults.hourMin=tempMinTime.getHours();
 710 | 					this.minute=this._defaults.minuteMin=tempMinTime.getMinutes();
 711 | 				} else if (this.hour===tempMinTime.getHours() && this.minute<tempMinTime.getMinutes()) {
 712 | 					this.minute=this._defaults.minuteMin=tempMinTime.getMinutes();
 713 | 				} else {
 714 | 					if (this._defaults.hourMin<tempMinTime.getHours()) {
 715 | 						this._defaults.hourMin=tempMinTime.getHours();
 716 | 						this._defaults.minuteMin=tempMinTime.getMinutes();
 717 | 					} else if (this._defaults.hourMin===tempMinTime.getHours()===this.hour && this._defaults.minuteMin<tempMinTime.getMinutes()) {
 718 | 						this._defaults.minuteMin=tempMinTime.getMinutes();
 719 | 					} else {
 720 | 						this._defaults.minuteMin=0;
 721 | 					}
 722 | 				}
 723 | 			}
 724 | 
 725 | 			if (dp_inst.settings.maxTime!==null) {
 726 | 				var tempMaxTime=new Date("01/01/1970 " + dp_inst.settings.maxTime);
 727 | 				if (this.hour>tempMaxTime.getHours()) {
 728 | 					this.hour=this._defaults.hourMax=tempMaxTime.getHours();
 729 | 					this.minute=this._defaults.minuteMax=tempMaxTime.getMinutes();
 730 | 				} else if (this.hour===tempMaxTime.getHours() && this.minute>tempMaxTime.getMinutes()) {
 731 | 					this.minute=this._defaults.minuteMax=tempMaxTime.getMinutes();
 732 | 				} else {
 733 | 					if (this._defaults.hourMax>tempMaxTime.getHours()) {
 734 | 						this._defaults.hourMax=tempMaxTime.getHours();
 735 | 						this._defaults.minuteMax=tempMaxTime.getMinutes();
 736 | 					} else if (this._defaults.hourMax===tempMaxTime.getHours()===this.hour && this._defaults.minuteMax>tempMaxTime.getMinutes()) {
 737 | 						this._defaults.minuteMax=tempMaxTime.getMinutes();
 738 | 					} else {
 739 | 						this._defaults.minuteMax=59;
 740 | 					}
 741 | 				}
 742 | 			}
 743 | 
 744 | 			if (adjustSliders !== undefined && adjustSliders === true) {
 745 | 				var hourMax = parseInt((this._defaults.hourMax - ((this._defaults.hourMax - this._defaults.hourMin) % this._defaults.stepHour)), 10),
 746 | 					minMax = parseInt((this._defaults.minuteMax - ((this._defaults.minuteMax - this._defaults.minuteMin) % this._defaults.stepMinute)), 10),
 747 | 					secMax = parseInt((this._defaults.secondMax - ((this._defaults.secondMax - this._defaults.secondMin) % this._defaults.stepSecond)), 10),
 748 | 					millisecMax = parseInt((this._defaults.millisecMax - ((this._defaults.millisecMax - this._defaults.millisecMin) % this._defaults.stepMillisec)), 10),
 749 | 					microsecMax = parseInt((this._defaults.microsecMax - ((this._defaults.microsecMax - this._defaults.microsecMin) % this._defaults.stepMicrosec)), 10);
 750 | 
 751 | 				if (this.hour_slider) {
 752 | 					this.control.options(this, this.hour_slider, 'hour', { min: this._defaults.hourMin, max: hourMax, step: this._defaults.stepHour });
 753 | 					this.control.value(this, this.hour_slider, 'hour', this.hour - (this.hour % this._defaults.stepHour));
 754 | 				}
 755 | 				if (this.minute_slider) {
 756 | 					this.control.options(this, this.minute_slider, 'minute', { min: this._defaults.minuteMin, max: minMax, step: this._defaults.stepMinute });
 757 | 					this.control.value(this, this.minute_slider, 'minute', this.minute - (this.minute % this._defaults.stepMinute));
 758 | 				}
 759 | 				if (this.second_slider) {
 760 | 					this.control.options(this, this.second_slider, 'second', { min: this._defaults.secondMin, max: secMax, step: this._defaults.stepSecond });
 761 | 					this.control.value(this, this.second_slider, 'second', this.second - (this.second % this._defaults.stepSecond));
 762 | 				}
 763 | 				if (this.millisec_slider) {
 764 | 					this.control.options(this, this.millisec_slider, 'millisec', { min: this._defaults.millisecMin, max: millisecMax, step: this._defaults.stepMillisec });
 765 | 					this.control.value(this, this.millisec_slider, 'millisec', this.millisec - (this.millisec % this._defaults.stepMillisec));
 766 | 				}
 767 | 				if (this.microsec_slider) {
 768 | 					this.control.options(this, this.microsec_slider, 'microsec', { min: this._defaults.microsecMin, max: microsecMax, step: this._defaults.stepMicrosec });
 769 | 					this.control.value(this, this.microsec_slider, 'microsec', this.microsec - (this.microsec % this._defaults.stepMicrosec));
 770 | 				}
 771 | 			}
 772 | 
 773 | 		},
 774 | 
 775 | 		/*
 776 | 		* when a slider moves, set the internal time...
 777 | 		* on time change is also called when the time is updated in the text field
 778 | 		*/
 779 | 		_onTimeChange: function () {
 780 | 			if (!this._defaults.showTimepicker) {
 781 |                                 return;
 782 | 			}
 783 | 			var hour = (this.hour_slider) ? this.control.value(this, this.hour_slider, 'hour') : false,
 784 | 				minute = (this.minute_slider) ? this.control.value(this, this.minute_slider, 'minute') : false,
 785 | 				second = (this.second_slider) ? this.control.value(this, this.second_slider, 'second') : false,
 786 | 				millisec = (this.millisec_slider) ? this.control.value(this, this.millisec_slider, 'millisec') : false,
 787 | 				microsec = (this.microsec_slider) ? this.control.value(this, this.microsec_slider, 'microsec') : false,
 788 | 				timezone = (this.timezone_select) ? this.timezone_select.val() : false,
 789 | 				o = this._defaults,
 790 | 				pickerTimeFormat = o.pickerTimeFormat || o.timeFormat,
 791 | 				pickerTimeSuffix = o.pickerTimeSuffix || o.timeSuffix;
 792 | 
 793 | 			if (typeof(hour) === 'object') {
 794 | 				hour = false;
 795 | 			}
 796 | 			if (typeof(minute) === 'object') {
 797 | 				minute = false;
 798 | 			}
 799 | 			if (typeof(second) === 'object') {
 800 | 				second = false;
 801 | 			}
 802 | 			if (typeof(millisec) === 'object') {
 803 | 				millisec = false;
 804 | 			}
 805 | 			if (typeof(microsec) === 'object') {
 806 | 				microsec = false;
 807 | 			}
 808 | 			if (typeof(timezone) === 'object') {
 809 | 				timezone = false;
 810 | 			}
 811 | 
 812 | 			if (hour !== false) {
 813 | 				hour = parseInt(hour, 10);
 814 | 			}
 815 | 			if (minute !== false) {
 816 | 				minute = parseInt(minute, 10);
 817 | 			}
 818 | 			if (second !== false) {
 819 | 				second = parseInt(second, 10);
 820 | 			}
 821 | 			if (millisec !== false) {
 822 | 				millisec = parseInt(millisec, 10);
 823 | 			}
 824 | 			if (microsec !== false) {
 825 | 				microsec = parseInt(microsec, 10);
 826 | 			}
 827 | 			if (timezone !== false) {
 828 | 				timezone = timezone.toString();
 829 | 			}
 830 | 
 831 | 			var ampm = o[hour < 12 ? 'amNames' : 'pmNames'][0];
 832 | 
 833 | 			// If the update was done in the input field, the input field should not be updated.
 834 | 			// If the update was done using the sliders, update the input field.
 835 | 			var hasChanged = (
 836 | 						hour !== parseInt(this.hour,10) || // sliders should all be numeric
 837 | 						minute !== parseInt(this.minute,10) ||
 838 | 						second !== parseInt(this.second,10) ||
 839 | 						millisec !== parseInt(this.millisec,10) ||
 840 | 						microsec !== parseInt(this.microsec,10) ||
 841 | 						(this.ampm.length > 0 && (hour < 12) !== ($.inArray(this.ampm.toUpperCase(), this.amNames) !== -1)) ||
 842 | 						(this.timezone !== null && timezone !== this.timezone.toString()) // could be numeric or "EST" format, so use toString()
 843 | 					);
 844 | 
 845 | 			if (hasChanged) {
 846 | 
 847 | 				if (hour !== false) {
 848 | 					this.hour = hour;
 849 | 				}
 850 | 				if (minute !== false) {
 851 | 					this.minute = minute;
 852 | 				}
 853 | 				if (second !== false) {
 854 | 					this.second = second;
 855 | 				}
 856 | 				if (millisec !== false) {
 857 | 					this.millisec = millisec;
 858 | 				}
 859 | 				if (microsec !== false) {
 860 | 					this.microsec = microsec;
 861 | 				}
 862 | 				if (timezone !== false) {
 863 | 					this.timezone = timezone;
 864 | 				}
 865 | 
 866 | 				if (!this.inst) {
 867 | 					this.inst = $.datepicker._getInst(this.$input[0]);
 868 | 				}
 869 | 
 870 | 				this._limitMinMaxDateTime(this.inst, true);
 871 | 			}
 872 | 			if (this.support.ampm) {
 873 | 				this.ampm = ampm;
 874 | 			}
 875 | 
 876 | 			// Updates the time within the timepicker
 877 | 			this.formattedTime = $.datepicker.formatTime(o.timeFormat, this, o);
 878 | 			if (this.$timeObj) {
 879 | 				if (pickerTimeFormat === o.timeFormat) {
 880 | 					this.$timeObj.val(this.formattedTime + pickerTimeSuffix);
 881 | 				}
 882 | 				else {
 883 | 					this.$timeObj.val($.datepicker.formatTime(pickerTimeFormat, this, o) + pickerTimeSuffix);
 884 | 				}
 885 | 				if (this.$timeObj[0].setSelectionRange) {
 886 | 					var sPos = this.$timeObj[0].selectionStart;
 887 | 					var ePos = this.$timeObj[0].selectionEnd;
 888 | 					this.$timeObj[0].setSelectionRange(sPos, ePos);
 889 | 				}
 890 | 			}
 891 | 
 892 | 			this.timeDefined = true;
 893 | 			if (hasChanged) {
 894 | 				this._updateDateTime();
 895 | 				//this.$input.focus(); // may automatically open the picker on setDate
 896 | 			}
 897 | 		},
 898 | 
 899 | 		/*
 900 | 		* call custom onSelect.
 901 | 		* bind to sliders slidestop, and grid click.
 902 | 		*/
 903 | 		_onSelectHandler: function () {
 904 | 			var onSelect = this._defaults.onSelect || this.inst.settings.onSelect;
 905 | 			var inputEl = this.$input ? this.$input[0] : null;
 906 | 			if (onSelect && inputEl) {
 907 | 				onSelect.apply(inputEl, [this.formattedDateTime, this]);
 908 | 			}
 909 | 		},
 910 | 
 911 | 		/*
 912 | 		* update our input with the new date time..
 913 | 		*/
 914 | 		_updateDateTime: function (dp_inst) {
 915 | 			dp_inst = this.inst || dp_inst;
 916 | 			var dtTmp = (dp_inst.currentYear > 0?
 917 | 							new Date(dp_inst.currentYear, dp_inst.currentMonth, dp_inst.currentDay) :
 918 | 							new Date(dp_inst.selectedYear, dp_inst.selectedMonth, dp_inst.selectedDay)),
 919 | 				dt = $.datepicker._daylightSavingAdjust(dtTmp),
 920 | 				//dt = $.datepicker._daylightSavingAdjust(new Date(dp_inst.selectedYear, dp_inst.selectedMonth, dp_inst.selectedDay)),
 921 | 				//dt = $.datepicker._daylightSavingAdjust(new Date(dp_inst.currentYear, dp_inst.currentMonth, dp_inst.currentDay)),
 922 | 				dateFmt = $.datepicker._get(dp_inst, 'dateFormat'),
 923 | 				formatCfg = $.datepicker._getFormatConfig(dp_inst),
 924 | 				timeAvailable = dt !== null && this.timeDefined;
 925 | 			this.formattedDate = $.datepicker.formatDate(dateFmt, (dt === null ? new Date() : dt), formatCfg);
 926 | 			var formattedDateTime = this.formattedDate;
 927 | 
 928 | 			// if a slider was changed but datepicker doesn't have a value yet, set it
 929 | 			if (dp_inst.lastVal === "") {
 930 |                 dp_inst.currentYear = dp_inst.selectedYear;
 931 |                 dp_inst.currentMonth = dp_inst.selectedMonth;
 932 |                 dp_inst.currentDay = dp_inst.selectedDay;
 933 |             }
 934 | 
 935 | 			/*
 936 | 			* remove following lines to force every changes in date picker to change the input value
 937 | 			* Bug descriptions: when an input field has a default value, and click on the field to pop up the date picker.
 938 | 			* If the user manually empty the value in the input field, the date picker will never change selected value.
 939 | 			*/
 940 | 			//if (dp_inst.lastVal !== undefined && (dp_inst.lastVal.length > 0 && this.$input.val().length === 0)) {
 941 | 			//	return;
 942 | 			//}
 943 | 
 944 | 			if (this._defaults.timeOnly === true && this._defaults.timeOnlyShowDate === false) {
 945 | 				formattedDateTime = this.formattedTime;
 946 | 			} else if ((this._defaults.timeOnly !== true && (this._defaults.alwaysSetTime || timeAvailable)) || (this._defaults.timeOnly === true && this._defaults.timeOnlyShowDate === true)) {
 947 | 				formattedDateTime += this._defaults.separator + this.formattedTime + this._defaults.timeSuffix;
 948 | 			}
 949 | 
 950 | 			this.formattedDateTime = formattedDateTime;
 951 | 
 952 | 			if (!this._defaults.showTimepicker) {
 953 | 				this.$input.val(this.formattedDate);
 954 | 			} else if (this.$altInput && this._defaults.timeOnly === false && this._defaults.altFieldTimeOnly === true) {
 955 | 				this.$altInput.val(this.formattedTime);
 956 | 				this.$input.val(this.formattedDate);
 957 | 			} else if (this.$altInput) {
 958 | 				this.$input.val(formattedDateTime);
 959 | 				var altFormattedDateTime = '',
 960 | 					altSeparator = this._defaults.altSeparator !== null ? this._defaults.altSeparator : this._defaults.separator,
 961 | 					altTimeSuffix = this._defaults.altTimeSuffix !== null ? this._defaults.altTimeSuffix : this._defaults.timeSuffix;
 962 | 
 963 | 				if (!this._defaults.timeOnly) {
 964 | 					if (this._defaults.altFormat) {
 965 | 						altFormattedDateTime = $.datepicker.formatDate(this._defaults.altFormat, (dt === null ? new Date() : dt), formatCfg);
 966 | 					}
 967 | 					else {
 968 | 						altFormattedDateTime = this.formattedDate;
 969 | 					}
 970 | 
 971 | 					if (altFormattedDateTime) {
 972 | 						altFormattedDateTime += altSeparator;
 973 | 					}
 974 | 				}
 975 | 
 976 | 				if (this._defaults.altTimeFormat !== null) {
 977 | 					altFormattedDateTime += $.datepicker.formatTime(this._defaults.altTimeFormat, this, this._defaults) + altTimeSuffix;
 978 | 				}
 979 | 				else {
 980 | 					altFormattedDateTime += this.formattedTime + altTimeSuffix;
 981 | 				}
 982 | 				this.$altInput.val(altFormattedDateTime);
 983 | 			} else {
 984 | 				this.$input.val(formattedDateTime);
 985 | 			}
 986 | 
 987 | 			this.$input.trigger("change");
 988 | 		},
 989 | 
 990 | 		_onFocus: function () {
 991 | 			if (!this.$input.val() && this._defaults.defaultValue) {
 992 | 				this.$input.val(this._defaults.defaultValue);
 993 | 				var inst = $.datepicker._getInst(this.$input.get(0)),
 994 | 					tp_inst = $.datepicker._get(inst, 'timepicker');
 995 | 				if (tp_inst) {
 996 | 					if (tp_inst._defaults.timeOnly && (inst.input.val() !== inst.lastVal)) {
 997 | 						try {
 998 | 							$.datepicker._updateDatepicker(inst);
 999 | 						} catch (err) {
1000 | 							$.timepicker.log(err);
1001 | 						}
1002 | 					}
1003 | 				}
1004 | 			}
1005 | 		},
1006 | 
1007 | 		/*
1008 | 		* Small abstraction to control types
1009 | 		* We can add more, just be sure to follow the pattern: create, options, value
1010 | 		*/
1011 | 		_controls: {
1012 | 			// slider methods
1013 | 			slider: {
1014 | 				create: function (tp_inst, obj, unit, val, min, max, step) {
1015 | 					var rtl = tp_inst._defaults.isRTL; // if rtl go -60->0 instead of 0->60
1016 | 					return obj.prop('slide', null).slider({
1017 | 						orientation: "horizontal",
1018 | 						value: rtl ? val * -1 : val,
1019 | 						min: rtl ? max * -1 : min,
1020 | 						max: rtl ? min * -1 : max,
1021 | 						step: step,
1022 | 						slide: function (event, ui) {
1023 | 							tp_inst.control.value(tp_inst, $(this), unit, rtl ? ui.value * -1 : ui.value);
1024 | 							tp_inst._onTimeChange();
1025 | 						},
1026 | 						stop: function (event, ui) {
1027 | 							tp_inst._onSelectHandler();
1028 | 						}
1029 | 					});
1030 | 				},
1031 | 				options: function (tp_inst, obj, unit, opts, val) {
1032 | 					if (tp_inst._defaults.isRTL) {
1033 | 						if (typeof(opts) === 'string') {
1034 | 							if (opts === 'min' || opts === 'max') {
1035 | 								if (val !== undefined) {
1036 | 									return obj.slider(opts, val * -1);
1037 | 								}
1038 | 								return Math.abs(obj.slider(opts));
1039 | 							}
1040 | 							return obj.slider(opts);
1041 | 						}
1042 | 						var min = opts.min,
1043 | 							max = opts.max;
1044 | 						opts.min = opts.max = null;
1045 | 						if (min !== undefined) {
1046 | 							opts.max = min * -1;
1047 | 						}
1048 | 						if (max !== undefined) {
1049 | 							opts.min = max * -1;
1050 | 						}
1051 | 						return obj.slider(opts);
1052 | 					}
1053 | 					if (typeof(opts) === 'string' && val !== undefined) {
1054 | 						return obj.slider(opts, val);
1055 | 					}
1056 | 					return obj.slider(opts);
1057 | 				},
1058 | 				value: function (tp_inst, obj, unit, val) {
1059 | 					if (tp_inst._defaults.isRTL) {
1060 | 						if (val !== undefined) {
1061 | 							return obj.slider('value', val * -1);
1062 | 						}
1063 | 						return Math.abs(obj.slider('value'));
1064 | 					}
1065 | 					if (val !== undefined) {
1066 | 						return obj.slider('value', val);
1067 | 					}
1068 | 					return obj.slider('value');
1069 | 				}
1070 | 			},
1071 | 			// select methods
1072 | 			select: {
1073 | 				create: function (tp_inst, obj, unit, val, min, max, step) {
1074 | 					var sel = '<select class="ui-timepicker-select ui-state-default ui-corner-all" data-unit="' + unit + '" data-min="' + min + '" data-max="' + max + '" data-step="' + step + '">',
1075 | 						format = tp_inst._defaults.pickerTimeFormat || tp_inst._defaults.timeFormat;
1076 | 
1077 | 					for (var i = min; i <= max; i += step) {
1078 | 						sel += '<option value="' + i + '"' + (i === val ? ' selected' : '') + '>';
1079 | 						if (unit === 'hour') {
1080 | 							sel += $.datepicker.formatTime($.trim(format.replace(/[^ht ]/ig, '')), {hour: i}, tp_inst._defaults);
1081 | 						}
1082 | 						else if (unit === 'millisec' || unit === 'microsec' || i >= 10) { sel += i; }
1083 | 						else {sel += '0' + i.toString(); }
1084 | 						sel += '</option>';
1085 | 					}
1086 | 					sel += '</select>';
1087 | 
1088 | 					obj.children('select').remove();
1089 | 
1090 | 					$(sel).appendTo(obj).change(function (e) {
1091 | 						tp_inst._onTimeChange();
1092 | 						tp_inst._onSelectHandler();
1093 | 						tp_inst._afterInject();
1094 | 					});
1095 | 
1096 | 					return obj;
1097 | 				},
1098 | 				options: function (tp_inst, obj, unit, opts, val) {
1099 | 					var o = {},
1100 | 						$t = obj.children('select');
1101 | 					if (typeof(opts) === 'string') {
1102 | 						if (val === undefined) {
1103 | 							return $t.data(opts);
1104 | 						}
1105 | 						o[opts] = val;
1106 | 					}
1107 | 					else { o = opts; }
1108 | 					return tp_inst.control.create(tp_inst, obj, $t.data('unit'), $t.val(), o.min>=0 ? o.min : $t.data('min'), o.max || $t.data('max'), o.step || $t.data('step'));
1109 | 				},
1110 | 				value: function (tp_inst, obj, unit, val) {
1111 | 					var $t = obj.children('select');
1112 | 					if (val !== undefined) {
1113 | 						return $t.val(val);
1114 | 					}
1115 | 					return $t.val();
1116 | 				}
1117 | 			}
1118 | 		} // end _controls
1119 | 
1120 | 	});
1121 | 
1122 | 	$.fn.extend({
1123 | 		/*
1124 | 		* shorthand just to use timepicker.
1125 | 		*/
1126 | 		timepicker: function (o) {
1127 | 			o = o || {};
1128 | 			var tmp_args = Array.prototype.slice.call(arguments);
1129 | 
1130 | 			if (typeof o === 'object') {
1131 | 				tmp_args[0] = $.extend(o, {
1132 | 					timeOnly: true
1133 | 				});
1134 | 			}
1135 | 
1136 | 			return $(this).each(function () {
1137 | 				$.fn.datetimepicker.apply($(this), tmp_args);
1138 | 			});
1139 | 		},
1140 | 
1141 | 		/*
1142 | 		* extend timepicker to datepicker
1143 | 		*/
1144 | 		datetimepicker: function (o) {
1145 | 			o = o || {};
1146 | 			var tmp_args = arguments;
1147 | 
1148 | 			if (typeof(o) === 'string') {
1149 | 				if (o === 'getDate'  || (o === 'option' && tmp_args.length === 2 && typeof (tmp_args[1]) === 'string')) {
1150 | 					return $.fn.datepicker.apply($(this[0]), tmp_args);
1151 | 				} else {
1152 | 					return this.each(function () {
1153 | 						var $t = $(this);
1154 | 						$t.datepicker.apply($t, tmp_args);
1155 | 					});
1156 | 				}
1157 | 			} else {
1158 | 				return this.each(function () {
1159 | 					var $t = $(this);
1160 | 					$t.datepicker($.timepicker._newInst($t, o)._defaults);
1161 | 				});
1162 | 			}
1163 | 		}
1164 | 	});
1165 | 
1166 | 	/*
1167 | 	* Public Utility to parse date and time
1168 | 	*/
1169 | 	$.datepicker.parseDateTime = function (dateFormat, timeFormat, dateTimeString, dateSettings, timeSettings) {
1170 | 		var parseRes = parseDateTimeInternal(dateFormat, timeFormat, dateTimeString, dateSettings, timeSettings);
1171 | 		if (parseRes.timeObj) {
1172 | 			var t = parseRes.timeObj;
1173 | 			parseRes.date.setHours(t.hour, t.minute, t.second, t.millisec);
1174 | 			parseRes.date.setMicroseconds(t.microsec);
1175 | 		}
1176 | 
1177 | 		return parseRes.date;
1178 | 	};
1179 | 
1180 | 	/*
1181 | 	* Public utility to parse time
1182 | 	*/
1183 | 	$.datepicker.parseTime = function (timeFormat, timeString, options) {
1184 | 		var o = extendRemove(extendRemove({}, $.timepicker._defaults), options || {}),
1185 | 			iso8601 = (timeFormat.replace(/\'.*?\'/g, '').indexOf('Z') !== -1);
1186 | 
1187 | 		// Strict parse requires the timeString to match the timeFormat exactly
1188 | 		var strictParse = function (f, s, o) {
1189 | 
1190 | 			// pattern for standard and localized AM/PM markers
1191 | 			var getPatternAmpm = function (amNames, pmNames) {
1192 | 				var markers = [];
1193 | 				if (amNames) {
1194 | 					$.merge(markers, amNames);
1195 | 				}
1196 | 				if (pmNames) {
1197 | 					$.merge(markers, pmNames);
1198 | 				}
1199 | 				markers = $.map(markers, function (val) {
1200 | 					return val.replace(/[.*+?|()\[\]{}\\]/g, '\\$&');
1201 | 				});
1202 | 				return '(' + markers.join('|') + ')?';
1203 | 			};
1204 | 
1205 | 			// figure out position of time elements.. cause js cant do named captures
1206 | 			var getFormatPositions = function (timeFormat) {
1207 | 				var finds = timeFormat.toLowerCase().match(/(h{1,2}|m{1,2}|s{1,2}|l{1}|c{1}|t{1,2}|z|'.*?')/g),
1208 | 					orders = {
1209 | 						h: -1,
1210 | 						m: -1,
1211 | 						s: -1,
1212 | 						l: -1,
1213 | 						c: -1,
1214 | 						t: -1,
1215 | 						z: -1
1216 | 					};
1217 | 
1218 | 				if (finds) {
1219 | 					for (var i = 0; i < finds.length; i++) {
1220 | 						if (orders[finds[i].toString().charAt(0)] === -1) {
1221 | 							orders[finds[i].toString().charAt(0)] = i + 1;
1222 | 						}
1223 | 					}
1224 | 				}
1225 | 				return orders;
1226 | 			};
1227 | 
1228 | 			var regstr = '^' + f.toString()
1229 | 					.replace(/([hH]{1,2}|mm?|ss?|[tT]{1,2}|[zZ]|[lc]|'.*?')/g, function (match) {
1230 | 							var ml = match.length;
1231 | 							switch (match.charAt(0).toLowerCase()) {
1232 | 							case 'h':
1233 | 								return ml === 1 ? '(\\d?\\d)' : '(\\d{' + ml + '})';
1234 | 							case 'm':
1235 | 								return ml === 1 ? '(\\d?\\d)' : '(\\d{' + ml + '})';
1236 | 							case 's':
1237 | 								return ml === 1 ? '(\\d?\\d)' : '(\\d{' + ml + '})';
1238 | 							case 'l':
1239 | 								return '(\\d?\\d?\\d)';
1240 | 							case 'c':
1241 | 								return '(\\d?\\d?\\d)';
1242 | 							case 'z':
1243 | 								return '(z|[-+]\\d\\d:?\\d\\d|\\S+)?';
1244 | 							case 't':
1245 | 								return getPatternAmpm(o.amNames, o.pmNames);
1246 | 							default:    // literal escaped in quotes
1247 | 								return '(' + match.replace(/\'/g, "").replace(/(\.|\$|\^|\\|\/|\(|\)|\[|\]|\?|\+|\*)/g, function (m) { return "\\" + m; }) + ')?';
1248 | 							}
1249 | 						})
1250 | 					.replace(/\s/g, '\\s?') +
1251 | 					o.timeSuffix + '$',
1252 | 				order = getFormatPositions(f),
1253 | 				ampm = '',
1254 | 				treg;
1255 | 
1256 | 			treg = s.match(new RegExp(regstr, 'i'));
1257 | 
1258 | 			var resTime = {
1259 | 				hour: 0,
1260 | 				minute: 0,
1261 | 				second: 0,
1262 | 				millisec: 0,
1263 | 				microsec: 0
1264 | 			};
1265 | 
1266 | 			if (treg) {
1267 | 				if (order.t !== -1) {
1268 | 					if (treg[order.t] === undefined || treg[order.t].length === 0) {
1269 | 						ampm = '';
1270 | 						resTime.ampm = '';
1271 | 					} else {
1272 | 						ampm = $.inArray(treg[order.t].toUpperCase(), $.map(o.amNames, function (x,i) { return x.toUpperCase(); })) !== -1 ? 'AM' : 'PM';
1273 | 						resTime.ampm = o[ampm === 'AM' ? 'amNames' : 'pmNames'][0];
1274 | 					}
1275 | 				}
1276 | 
1277 | 				if (order.h !== -1) {
1278 | 					if (ampm === 'AM' && treg[order.h] === '12') {
1279 | 						resTime.hour = 0; // 12am = 0 hour
1280 | 					} else {
1281 | 						if (ampm === 'PM' && treg[order.h] !== '12') {
1282 | 							resTime.hour = parseInt(treg[order.h], 10) + 12; // 12pm = 12 hour, any other pm = hour + 12
1283 | 						} else {
1284 | 							resTime.hour = Number(treg[order.h]);
1285 | 						}
1286 | 					}
1287 | 				}
1288 | 
1289 | 				if (order.m !== -1) {
1290 | 					resTime.minute = Number(treg[order.m]);
1291 | 				}
1292 | 				if (order.s !== -1) {
1293 | 					resTime.second = Number(treg[order.s]);
1294 | 				}
1295 | 				if (order.l !== -1) {
1296 | 					resTime.millisec = Number(treg[order.l]);
1297 | 				}
1298 | 				if (order.c !== -1) {
1299 | 					resTime.microsec = Number(treg[order.c]);
1300 | 				}
1301 | 				if (order.z !== -1 && treg[order.z] !== undefined) {
1302 | 					resTime.timezone = $.timepicker.timezoneOffsetNumber(treg[order.z]);
1303 | 				}
1304 | 
1305 | 
1306 | 				return resTime;
1307 | 			}
1308 | 			return false;
1309 | 		};// end strictParse
1310 | 
1311 | 		// First try JS Date, if that fails, use strictParse
1312 | 		var looseParse = function (f, s, o) {
1313 | 			try {
1314 | 				var d = new Date('2012-01-01 ' + s);
1315 | 				if (isNaN(d.getTime())) {
1316 | 					d = new Date('2012-01-01T' + s);
1317 | 					if (isNaN(d.getTime())) {
1318 | 						d = new Date('01/01/2012 ' + s);
1319 | 						if (isNaN(d.getTime())) {
1320 | 							throw "Unable to parse time with native Date: " + s;
1321 | 						}
1322 | 					}
1323 | 				}
1324 | 
1325 | 				return {
1326 | 					hour: d.getHours(),
1327 | 					minute: d.getMinutes(),
1328 | 					second: d.getSeconds(),
1329 | 					millisec: d.getMilliseconds(),
1330 | 					microsec: d.getMicroseconds(),
1331 | 					timezone: d.getTimezoneOffset() * -1
1332 | 				};
1333 | 			}
1334 | 			catch (err) {
1335 | 				try {
1336 | 					return strictParse(f, s, o);
1337 | 				}
1338 | 				catch (err2) {
1339 | 					$.timepicker.log("Unable to parse \ntimeString: " + s + "\ntimeFormat: " + f);
1340 | 				}
1341 | 			}
1342 | 			return false;
1343 | 		}; // end looseParse
1344 | 
1345 | 		if (typeof o.parse === "function") {
1346 | 			return o.parse(timeFormat, timeString, o);
1347 | 		}
1348 | 		if (o.parse === 'loose') {
1349 | 			return looseParse(timeFormat, timeString, o);
1350 | 		}
1351 | 		return strictParse(timeFormat, timeString, o);
1352 | 	};
1353 | 
1354 | 	/**
1355 | 	 * Public utility to format the time
1356 | 	 * @param {string} format format of the time
1357 | 	 * @param {Object} time Object not a Date for timezones
1358 | 	 * @param {Object} [options] essentially the regional[].. amNames, pmNames, ampm
1359 | 	 * @returns {string} the formatted time
1360 | 	 */
1361 | 	$.datepicker.formatTime = function (format, time, options) {
1362 | 		options = options || {};
1363 | 		options = $.extend({}, $.timepicker._defaults, options);
1364 | 		time = $.extend({
1365 | 			hour: 0,
1366 | 			minute: 0,
1367 | 			second: 0,
1368 | 			millisec: 0,
1369 | 			microsec: 0,
1370 | 			timezone: null
1371 | 		}, time);
1372 | 
1373 | 		var tmptime = format,
1374 | 			ampmName = options.amNames[0],
1375 | 			hour = parseInt(time.hour, 10);
1376 | 
1377 | 		if (hour > 11) {
1378 | 			ampmName = options.pmNames[0];
1379 | 		}
1380 | 
1381 | 		tmptime = tmptime.replace(/(?:HH?|hh?|mm?|ss?|[tT]{1,2}|[zZ]|[lc]|'.*?')/g, function (match) {
1382 | 			switch (match) {
1383 | 			case 'HH':
1384 | 				return ('0' + hour).slice(-2);
1385 | 			case 'H':
1386 | 				return hour;
1387 | 			case 'hh':
1388 | 				return ('0' + convert24to12(hour)).slice(-2);
1389 | 			case 'h':
1390 | 				return convert24to12(hour);
1391 | 			case 'mm':
1392 | 				return ('0' + time.minute).slice(-2);
1393 | 			case 'm':
1394 | 				return time.minute;
1395 | 			case 'ss':
1396 | 				return ('0' + time.second).slice(-2);
1397 | 			case 's':
1398 | 				return time.second;
1399 | 			case 'l':
1400 | 				return ('00' + time.millisec).slice(-3);
1401 | 			case 'c':
1402 | 				return ('00' + time.microsec).slice(-3);
1403 | 			case 'z':
1404 | 				return $.timepicker.timezoneOffsetString(time.timezone === null ? options.timezone : time.timezone, false);
1405 | 			case 'Z':
1406 | 				return $.timepicker.timezoneOffsetString(time.timezone === null ? options.timezone : time.timezone, true);
1407 | 			case 'T':
1408 | 				return ampmName.charAt(0).toUpperCase();
1409 | 			case 'TT':
1410 | 				return ampmName.toUpperCase();
1411 | 			case 't':
1412 | 				return ampmName.charAt(0).toLowerCase();
1413 | 			case 'tt':
1414 | 				return ampmName.toLowerCase();
1415 | 			default:
1416 | 				return match.replace(/'/g, "");
1417 | 			}
1418 | 		});
1419 | 
1420 | 		return tmptime;
1421 | 	};
1422 | 
1423 | 	/*
1424 | 	* the bad hack :/ override datepicker so it doesn't close on select
1425 | 	// inspired: http://stackoverflow.com/questions/1252512/jquery-datepicker-prevent-closing-picker-when-clicking-a-date/1762378#1762378
1426 | 	*/
1427 | 	$.datepicker._base_selectDate = $.datepicker._selectDate;
1428 | 	$.datepicker._selectDate = function (id, dateStr) {
1429 | 		var inst = this._getInst($(id)[0]),
1430 | 			tp_inst = this._get(inst, 'timepicker'),
1431 | 			was_inline;
1432 | 
1433 | 		if (tp_inst && inst.settings.showTimepicker) {
1434 | 			tp_inst._limitMinMaxDateTime(inst, true);
1435 | 			was_inline = inst.inline;
1436 | 			inst.inline = inst.stay_open = true;
1437 | 			//This way the onSelect handler called from calendarpicker get the full dateTime
1438 | 			this._base_selectDate(id, dateStr);
1439 | 			inst.inline = was_inline;
1440 | 			inst.stay_open = false;
1441 | 			this._notifyChange(inst);
1442 | 			this._updateDatepicker(inst);
1443 | 		} else {
1444 | 			this._base_selectDate(id, dateStr);
1445 | 		}
1446 | 	};
1447 | 
1448 | 	/*
1449 | 	* second bad hack :/ override datepicker so it triggers an event when changing the input field
1450 | 	* and does not redraw the datepicker on every selectDate event
1451 | 	*/
1452 | 	$.datepicker._base_updateDatepicker = $.datepicker._updateDatepicker;
1453 | 	$.datepicker._updateDatepicker = function (inst) {
1454 | 
1455 | 		// don't popup the datepicker if there is another instance already opened
1456 | 		var input = inst.input[0];
1457 | 		if ($.datepicker._curInst && $.datepicker._curInst !== inst && $.datepicker._datepickerShowing && $.datepicker._lastInput !== input) {
1458 | 			return;
1459 | 		}
1460 | 
1461 | 		if (typeof(inst.stay_open) !== 'boolean' || inst.stay_open === false) {
1462 | 
1463 | 			this._base_updateDatepicker(inst);
1464 | 
1465 | 			// Reload the time control when changing something in the input text field.
1466 | 			var tp_inst = this._get(inst, 'timepicker');
1467 | 			if (tp_inst) {
1468 | 				tp_inst._addTimePicker(inst);
1469 | 			}
1470 | 		}
1471 | 	};
1472 | 
1473 | 	/*
1474 | 	* third bad hack :/ override datepicker so it allows spaces and colon in the input field
1475 | 	*/
1476 | 	$.datepicker._base_doKeyPress = $.datepicker._doKeyPress;
1477 | 	$.datepicker._doKeyPress = function (event) {
1478 | 		var inst = $.datepicker._getInst(event.target),
1479 | 			tp_inst = $.datepicker._get(inst, 'timepicker');
1480 | 
1481 | 		if (tp_inst) {
1482 | 			if ($.datepicker._get(inst, 'constrainInput')) {
1483 | 				var ampm = tp_inst.support.ampm,
1484 | 					tz = tp_inst._defaults.showTimezone !== null ? tp_inst._defaults.showTimezone : tp_inst.support.timezone,
1485 | 					dateChars = $.datepicker._possibleChars($.datepicker._get(inst, 'dateFormat')),
1486 | 					datetimeChars = tp_inst._defaults.timeFormat.toString()
1487 | 											.replace(/[hms]/g, '')
1488 | 											.replace(/TT/g, ampm ? 'APM' : '')
1489 | 											.replace(/Tt/g, ampm ? 'AaPpMm' : '')
1490 | 											.replace(/tT/g, ampm ? 'AaPpMm' : '')
1491 | 											.replace(/T/g, ampm ? 'AP' : '')
1492 | 											.replace(/tt/g, ampm ? 'apm' : '')
1493 | 											.replace(/t/g, ampm ? 'ap' : '') +
1494 | 											" " + tp_inst._defaults.separator +
1495 | 											tp_inst._defaults.timeSuffix +
1496 | 											(tz ? tp_inst._defaults.timezoneList.join('') : '') +
1497 | 											(tp_inst._defaults.amNames.join('')) + (tp_inst._defaults.pmNames.join('')) +
1498 | 											dateChars,
1499 | 					chr = String.fromCharCode(event.charCode === undefined ? event.keyCode : event.charCode);
1500 | 				return event.ctrlKey || (chr < ' ' || !dateChars || datetimeChars.indexOf(chr) > -1);
1501 | 			}
1502 | 		}
1503 | 
1504 | 		return $.datepicker._base_doKeyPress(event);
1505 | 	};
1506 | 
1507 | 	/*
1508 | 	* Fourth bad hack :/ override _updateAlternate function used in inline mode to init altField
1509 | 	* Update any alternate field to synchronise with the main field.
1510 | 	*/
1511 | 	$.datepicker._base_updateAlternate = $.datepicker._updateAlternate;
1512 | 	$.datepicker._updateAlternate = function (inst) {
1513 | 		var tp_inst = this._get(inst, 'timepicker');
1514 | 		if (tp_inst) {
1515 | 			var altField = tp_inst._defaults.altField;
1516 | 			if (altField) { // update alternate field too
1517 | 				var altFormat = tp_inst._defaults.altFormat || tp_inst._defaults.dateFormat,
1518 | 					date = this._getDate(inst),
1519 | 					formatCfg = $.datepicker._getFormatConfig(inst),
1520 | 					altFormattedDateTime = '',
1521 | 					altSeparator = tp_inst._defaults.altSeparator ? tp_inst._defaults.altSeparator : tp_inst._defaults.separator,
1522 | 					altTimeSuffix = tp_inst._defaults.altTimeSuffix ? tp_inst._defaults.altTimeSuffix : tp_inst._defaults.timeSuffix,
1523 | 					altTimeFormat = tp_inst._defaults.altTimeFormat !== null ? tp_inst._defaults.altTimeFormat : tp_inst._defaults.timeFormat;
1524 | 
1525 | 				altFormattedDateTime += $.datepicker.formatTime(altTimeFormat, tp_inst, tp_inst._defaults) + altTimeSuffix;
1526 | 				if (!tp_inst._defaults.timeOnly && !tp_inst._defaults.altFieldTimeOnly && date !== null) {
1527 | 					if (tp_inst._defaults.altFormat) {
1528 | 						altFormattedDateTime = $.datepicker.formatDate(tp_inst._defaults.altFormat, date, formatCfg) + altSeparator + altFormattedDateTime;
1529 | 					}
1530 | 					else {
1531 | 						altFormattedDateTime = tp_inst.formattedDate + altSeparator + altFormattedDateTime;
1532 | 					}
1533 | 				}
1534 | 				$(altField).val( inst.input.val() ? altFormattedDateTime : "");
1535 | 			}
1536 | 		}
1537 | 		else {
1538 | 			$.datepicker._base_updateAlternate(inst);
1539 | 		}
1540 | 	};
1541 | 
1542 | 	/*
1543 | 	* Override key up event to sync manual input changes.
1544 | 	*/
1545 | 	$.datepicker._base_doKeyUp = $.datepicker._doKeyUp;
1546 | 	$.datepicker._doKeyUp = function (event) {
1547 | 		var inst = $.datepicker._getInst(event.target),
1548 | 			tp_inst = $.datepicker._get(inst, 'timepicker');
1549 | 
1550 | 		if (tp_inst) {
1551 | 			if (tp_inst._defaults.timeOnly && (inst.input.val() !== inst.lastVal)) {
1552 | 				try {
1553 | 					$.datepicker._updateDatepicker(inst);
1554 | 				} catch (err) {
1555 | 					$.timepicker.log(err);
1556 | 				}
1557 | 			}
1558 | 		}
1559 | 
1560 | 		return $.datepicker._base_doKeyUp(event);
1561 | 	};
1562 | 
1563 | 	/*
1564 | 	* override "Today" button to also grab the time and set it to input field.
1565 | 	*/
1566 | 	$.datepicker._base_gotoToday = $.datepicker._gotoToday;
1567 | 	$.datepicker._gotoToday = function (id) {
1568 | 		var inst = this._getInst($(id)[0]);
1569 | 		this._base_gotoToday(id);
1570 | 		var tp_inst = this._get(inst, 'timepicker');
1571 | 		if (!tp_inst) {
1572 | 		  return;
1573 | 		}
1574 | 
1575 | 		var tzoffset = $.timepicker.timezoneOffsetNumber(tp_inst.timezone);
1576 | 		var now = new Date();
1577 | 		now.setMinutes(now.getMinutes() + now.getTimezoneOffset() + parseInt(tzoffset, 10));
1578 | 		this._setTime(inst, now);
1579 | 		this._setDate(inst, now);
1580 | 		tp_inst._onSelectHandler();
1581 | 	};
1582 | 
1583 | 	/*
1584 | 	* Disable & enable the Time in the datetimepicker
1585 | 	*/
1586 | 	$.datepicker._disableTimepickerDatepicker = function (target) {
1587 | 		var inst = this._getInst(target);
1588 | 		if (!inst) {
1589 | 			return;
1590 | 		}
1591 | 
1592 | 		var tp_inst = this._get(inst, 'timepicker');
1593 | 		$(target).datepicker('getDate'); // Init selected[Year|Month|Day]
1594 | 		if (tp_inst) {
1595 | 			inst.settings.showTimepicker = false;
1596 | 			tp_inst._defaults.showTimepicker = false;
1597 | 			tp_inst._updateDateTime(inst);
1598 | 		}
1599 | 	};
1600 | 
1601 | 	$.datepicker._enableTimepickerDatepicker = function (target) {
1602 | 		var inst = this._getInst(target);
1603 | 		if (!inst) {
1604 | 			return;
1605 | 		}
1606 | 
1607 | 		var tp_inst = this._get(inst, 'timepicker');
1608 | 		$(target).datepicker('getDate'); // Init selected[Year|Month|Day]
1609 | 		if (tp_inst) {
1610 | 			inst.settings.showTimepicker = true;
1611 | 			tp_inst._defaults.showTimepicker = true;
1612 | 			tp_inst._addTimePicker(inst); // Could be disabled on page load
1613 | 			tp_inst._updateDateTime(inst);
1614 | 		}
1615 | 	};
1616 | 
1617 | 	/*
1618 | 	* Create our own set time function
1619 | 	*/
1620 | 	$.datepicker._setTime = function (inst, date) {
1621 | 		var tp_inst = this._get(inst, 'timepicker');
1622 | 		if (tp_inst) {
1623 | 			var defaults = tp_inst._defaults;
1624 | 
1625 | 			// calling _setTime with no date sets time to defaults
1626 | 			tp_inst.hour = date ? date.getHours() : defaults.hour;
1627 | 			tp_inst.minute = date ? date.getMinutes() : defaults.minute;
1628 | 			tp_inst.second = date ? date.getSeconds() : defaults.second;
1629 | 			tp_inst.millisec = date ? date.getMilliseconds() : defaults.millisec;
1630 | 			tp_inst.microsec = date ? date.getMicroseconds() : defaults.microsec;
1631 | 
1632 | 			//check if within min/max times..
1633 | 			tp_inst._limitMinMaxDateTime(inst, true);
1634 | 
1635 | 			tp_inst._onTimeChange();
1636 | 			tp_inst._updateDateTime(inst);
1637 | 		}
1638 | 	};
1639 | 
1640 | 	/*
1641 | 	* Create new public method to set only time, callable as $().datepicker('setTime', date)
1642 | 	*/
1643 | 	$.datepicker._setTimeDatepicker = function (target, date, withDate) {
1644 | 		var inst = this._getInst(target);
1645 | 		if (!inst) {
1646 | 			return;
1647 | 		}
1648 | 
1649 | 		var tp_inst = this._get(inst, 'timepicker');
1650 | 
1651 | 		if (tp_inst) {
1652 | 			this._setDateFromField(inst);
1653 | 			var tp_date;
1654 | 			if (date) {
1655 | 				if (typeof date === "string") {
1656 | 					tp_inst._parseTime(date, withDate);
1657 | 					tp_date = new Date();
1658 | 					tp_date.setHours(tp_inst.hour, tp_inst.minute, tp_inst.second, tp_inst.millisec);
1659 | 					tp_date.setMicroseconds(tp_inst.microsec);
1660 | 				} else {
1661 | 					tp_date = new Date(date.getTime());
1662 | 					tp_date.setMicroseconds(date.getMicroseconds());
1663 | 				}
1664 | 				if (tp_date.toString() === 'Invalid Date') {
1665 | 					tp_date = undefined;
1666 | 				}
1667 | 				this._setTime(inst, tp_date);
1668 | 			}
1669 | 		}
1670 | 
1671 | 	};
1672 | 
1673 | 	/*
1674 | 	* override setDate() to allow setting time too within Date object
1675 | 	*/
1676 | 	$.datepicker._base_setDateDatepicker = $.datepicker._setDateDatepicker;
1677 | 	$.datepicker._setDateDatepicker = function (target, _date) {
1678 | 		var inst = this._getInst(target);
1679 | 		var date = _date;
1680 | 		if (!inst) {
1681 | 			return;
1682 | 		}
1683 | 
1684 | 		if (typeof(_date) === 'string') {
1685 | 			date = new Date(_date);
1686 | 			if (!date.getTime()) {
1687 | 				this._base_setDateDatepicker.apply(this, arguments);
1688 | 				date = $(target).datepicker('getDate');
1689 | 			}
1690 | 		}
1691 | 
1692 | 		var tp_inst = this._get(inst, 'timepicker');
1693 | 		var tp_date;
1694 | 		if (date instanceof Date) {
1695 | 			tp_date = new Date(date.getTime());
1696 | 			tp_date.setMicroseconds(date.getMicroseconds());
1697 | 		} else {
1698 | 			tp_date = date;
1699 | 		}
1700 | 
1701 | 		// This is important if you are using the timezone option, javascript's Date
1702 | 		// object will only return the timezone offset for the current locale, so we
1703 | 		// adjust it accordingly.  If not using timezone option this won't matter..
1704 | 		// If a timezone is different in tp, keep the timezone as is
1705 | 		if (tp_inst && tp_date) {
1706 | 			// look out for DST if tz wasn't specified
1707 | 			if (!tp_inst.support.timezone && tp_inst._defaults.timezone === null) {
1708 | 				tp_inst.timezone = tp_date.getTimezoneOffset() * -1;
1709 | 			}
1710 | 			date = $.timepicker.timezoneAdjust(date, $.timepicker.timezoneOffsetString(-date.getTimezoneOffset()), tp_inst.timezone);
1711 | 			tp_date = $.timepicker.timezoneAdjust(tp_date, $.timepicker.timezoneOffsetString(-tp_date.getTimezoneOffset()), tp_inst.timezone);
1712 | 		}
1713 | 
1714 | 		this._updateDatepicker(inst);
1715 | 		this._base_setDateDatepicker.apply(this, arguments);
1716 | 		this._setTimeDatepicker(target, tp_date, true);
1717 | 	};
1718 | 
1719 | 	/*
1720 | 	* override getDate() to allow getting time too within Date object
1721 | 	*/
1722 | 	$.datepicker._base_getDateDatepicker = $.datepicker._getDateDatepicker;
1723 | 	$.datepicker._getDateDatepicker = function (target, noDefault) {
1724 | 		var inst = this._getInst(target);
1725 | 		if (!inst) {
1726 | 			return;
1727 | 		}
1728 | 
1729 | 		var tp_inst = this._get(inst, 'timepicker');
1730 | 
1731 | 		if (tp_inst) {
1732 | 			// if it hasn't yet been defined, grab from field
1733 | 			if (inst.lastVal === undefined) {
1734 | 				this._setDateFromField(inst, noDefault);
1735 | 			}
1736 | 
1737 | 			var date = this._getDate(inst);
1738 | 
1739 | 			var currDT = null;
1740 | 
1741 | 			if (tp_inst.$altInput && tp_inst._defaults.altFieldTimeOnly) {
1742 | 				currDT = tp_inst.$input.val() + ' ' + tp_inst.$altInput.val();
1743 | 			}
1744 | 			else if (tp_inst.$input.get(0).tagName !== 'INPUT' && tp_inst.$altInput) {
1745 | 				/**
1746 | 				 * in case the datetimepicker has been applied to a non-input tag for inline UI,
1747 | 				 * and the user has not configured the plugin to display only time in altInput,
1748 | 				 * pick current date time from the altInput (and hope for the best, for now, until "ER1" is applied)
1749 | 				 *
1750 | 				 * @todo ER1. Since altInput can have a totally difference format, convert it to standard format by reading input format from "altFormat" and "altTimeFormat" option values
1751 | 				 */
1752 | 				currDT = tp_inst.$altInput.val();
1753 | 			}
1754 | 			else {
1755 | 				currDT = tp_inst.$input.val();
1756 | 			}
1757 | 
1758 | 			if (date && tp_inst._parseTime(currDT, !inst.settings.timeOnly)) {
1759 | 				date.setHours(tp_inst.hour, tp_inst.minute, tp_inst.second, tp_inst.millisec);
1760 | 				date.setMicroseconds(tp_inst.microsec);
1761 | 
1762 | 				// This is important if you are using the timezone option, javascript's Date
1763 | 				// object will only return the timezone offset for the current locale, so we
1764 | 				// adjust it accordingly.  If not using timezone option this won't matter..
1765 | 				if (tp_inst.timezone != null) {
1766 | 					// look out for DST if tz wasn't specified
1767 | 					if (!tp_inst.support.timezone && tp_inst._defaults.timezone === null) {
1768 | 						tp_inst.timezone = date.getTimezoneOffset() * -1;
1769 | 					}
1770 | 					date = $.timepicker.timezoneAdjust(date, tp_inst.timezone, $.timepicker.timezoneOffsetString(-date.getTimezoneOffset()));
1771 | 				}
1772 | 			}
1773 | 			return date;
1774 | 		}
1775 | 		return this._base_getDateDatepicker(target, noDefault);
1776 | 	};
1777 | 
1778 | 	/*
1779 | 	* override parseDate() because UI 1.8.14 throws an error about "Extra characters"
1780 | 	* An option in datapicker to ignore extra format characters would be nicer.
1781 | 	*/
1782 | 	$.datepicker._base_parseDate = $.datepicker.parseDate;
1783 | 	$.datepicker.parseDate = function (format, value, settings) {
1784 | 		var date;
1785 | 		try {
1786 | 			date = this._base_parseDate(format, value, settings);
1787 | 		} catch (err) {
1788 | 			// Hack!  The error message ends with a colon, a space, and
1789 | 			// the "extra" characters.  We rely on that instead of
1790 | 			// attempting to perfectly reproduce the parsing algorithm.
1791 | 			if (err.indexOf(":") >= 0) {
1792 | 				date = this._base_parseDate(format, value.substring(0, value.length - (err.length - err.indexOf(':') - 2)), settings);
1793 | 				$.timepicker.log("Error parsing the date string: " + err + "\ndate string = " + value + "\ndate format = " + format);
1794 | 			} else {
1795 | 				throw err;
1796 | 			}
1797 | 		}
1798 | 		return date;
1799 | 	};
1800 | 
1801 | 	/*
1802 | 	* override formatDate to set date with time to the input
1803 | 	*/
1804 | 	$.datepicker._base_formatDate = $.datepicker._formatDate;
1805 | 	$.datepicker._formatDate = function (inst, day, month, year) {
1806 | 		var tp_inst = this._get(inst, 'timepicker');
1807 | 		if (tp_inst) {
1808 | 			tp_inst._updateDateTime(inst);
1809 | 			return tp_inst.$input.val();
1810 | 		}
1811 | 		return this._base_formatDate(inst);
1812 | 	};
1813 | 
1814 | 	/*
1815 | 	* override options setter to add time to maxDate(Time) and minDate(Time). MaxDate
1816 | 	*/
1817 | 	$.datepicker._base_optionDatepicker = $.datepicker._optionDatepicker;
1818 | 	$.datepicker._optionDatepicker = function (target, name, value) {
1819 | 		var inst = this._getInst(target),
1820 | 			name_clone;
1821 | 		if (!inst) {
1822 | 			return null;
1823 | 		}
1824 | 
1825 | 		var tp_inst = this._get(inst, 'timepicker');
1826 | 		if (tp_inst) {
1827 | 			var min = null,
1828 | 				max = null,
1829 | 				onselect = null,
1830 | 				overrides = tp_inst._defaults.evnts,
1831 | 				fns = {},
1832 | 				prop,
1833 | 				ret,
1834 | 				oldVal,
1835 | 				$target;
1836 | 			if (typeof name === 'string') { // if min/max was set with the string
1837 | 				if (name === 'minDate' || name === 'minDateTime') {
1838 | 					min = value;
1839 | 				} else if (name === 'maxDate' || name === 'maxDateTime') {
1840 | 					max = value;
1841 | 				} else if (name === 'onSelect') {
1842 | 					onselect = value;
1843 | 				} else if (overrides.hasOwnProperty(name)) {
1844 | 					if (typeof (value) === 'undefined') {
1845 | 						return overrides[name];
1846 | 					}
1847 | 					fns[name] = value;
1848 | 					name_clone = {}; //empty results in exiting function after overrides updated
1849 | 				}
1850 | 			} else if (typeof name === 'object') { //if min/max was set with the JSON
1851 | 				if (name.minDate) {
1852 | 					min = name.minDate;
1853 | 				} else if (name.minDateTime) {
1854 | 					min = name.minDateTime;
1855 | 				} else if (name.maxDate) {
1856 | 					max = name.maxDate;
1857 | 				} else if (name.maxDateTime) {
1858 | 					max = name.maxDateTime;
1859 | 				}
1860 | 				for (prop in overrides) {
1861 | 					if (overrides.hasOwnProperty(prop) && name[prop]) {
1862 | 						fns[prop] = name[prop];
1863 | 					}
1864 | 				}
1865 | 			}
1866 | 			for (prop in fns) {
1867 | 				if (fns.hasOwnProperty(prop)) {
1868 | 					overrides[prop] = fns[prop];
1869 | 					if (!name_clone) { name_clone = $.extend({}, name); }
1870 | 					delete name_clone[prop];
1871 | 				}
1872 | 			}
1873 | 			if (name_clone && isEmptyObject(name_clone)) { return; }
1874 | 			if (min) { //if min was set
1875 | 				if (min === 0) {
1876 | 					min = new Date();
1877 | 				} else {
1878 | 					min = new Date(min);
1879 | 				}
1880 | 				tp_inst._defaults.minDate = min;
1881 | 				tp_inst._defaults.minDateTime = min;
1882 | 			} else if (max) { //if max was set
1883 | 				if (max === 0) {
1884 | 					max = new Date();
1885 | 				} else {
1886 | 					max = new Date(max);
1887 | 				}
1888 | 				tp_inst._defaults.maxDate = max;
1889 | 				tp_inst._defaults.maxDateTime = max;
1890 | 			} else if (onselect) {
1891 | 				tp_inst._defaults.onSelect = onselect;
1892 | 			}
1893 | 
1894 | 			// Datepicker will override our date when we call _base_optionDatepicker when
1895 | 			// calling minDate/maxDate, so we will first grab the value, call
1896 | 			// _base_optionDatepicker, then set our value back.
1897 | 			if(min || max){
1898 | 				$target = $(target);
1899 | 				oldVal = $target.datetimepicker('getDate');
1900 | 				ret = this._base_optionDatepicker.call($.datepicker, target, name_clone || name, value);
1901 | 				$target.datetimepicker('setDate', oldVal);
1902 | 				return ret;
1903 | 			}
1904 | 		}
1905 | 		if (value === undefined) {
1906 | 			return this._base_optionDatepicker.call($.datepicker, target, name);
1907 | 		}
1908 | 		return this._base_optionDatepicker.call($.datepicker, target, name_clone || name, value);
1909 | 	};
1910 | 
1911 | 	/*
1912 | 	* jQuery isEmptyObject does not check hasOwnProperty - if someone has added to the object prototype,
1913 | 	* it will return false for all objects
1914 | 	*/
1915 | 	var isEmptyObject = function (obj) {
1916 | 		var prop;
1917 | 		for (prop in obj) {
1918 | 			if (obj.hasOwnProperty(prop)) {
1919 | 				return false;
1920 | 			}
1921 | 		}
1922 | 		return true;
1923 | 	};
1924 | 
1925 | 	/*
1926 | 	* jQuery extend now ignores nulls!
1927 | 	*/
1928 | 	var extendRemove = function (target, props) {
1929 | 		$.extend(target, props);
1930 | 		for (var name in props) {
1931 | 			if (props[name] === null || props[name] === undefined) {
1932 | 				target[name] = props[name];
1933 | 			}
1934 | 		}
1935 | 		return target;
1936 | 	};
1937 | 
1938 | 	/*
1939 | 	* Determine by the time format which units are supported
1940 | 	* Returns an object of booleans for each unit
1941 | 	*/
1942 | 	var detectSupport = function (timeFormat) {
1943 | 		var tf = timeFormat.replace(/'.*?'/g, '').toLowerCase(), // removes literals
1944 | 			isIn = function (f, t) { // does the format contain the token?
1945 | 					return f.indexOf(t) !== -1 ? true : false;
1946 | 				};
1947 | 		return {
1948 | 				hour: isIn(tf, 'h'),
1949 | 				minute: isIn(tf, 'm'),
1950 | 				second: isIn(tf, 's'),
1951 | 				millisec: isIn(tf, 'l'),
1952 | 				microsec: isIn(tf, 'c'),
1953 | 				timezone: isIn(tf, 'z'),
1954 | 				ampm: isIn(tf, 't') && isIn(timeFormat, 'h'),
1955 | 				iso8601: isIn(timeFormat, 'Z')
1956 | 			};
1957 | 	};
1958 | 
1959 | 	/*
1960 | 	* Converts 24 hour format into 12 hour
1961 | 	* Returns 12 hour without leading 0
1962 | 	*/
1963 | 	var convert24to12 = function (hour) {
1964 | 		hour %= 12;
1965 | 
1966 | 		if (hour === 0) {
1967 | 			hour = 12;
1968 | 		}
1969 | 
1970 | 		return String(hour);
1971 | 	};
1972 | 
1973 | 	var computeEffectiveSetting = function (settings, property) {
1974 | 		return settings && settings[property] ? settings[property] : $.timepicker._defaults[property];
1975 | 	};
1976 | 
1977 | 	/*
1978 | 	* Splits datetime string into date and time substrings.
1979 | 	* Throws exception when date can't be parsed
1980 | 	* Returns {dateString: dateString, timeString: timeString}
1981 | 	*/
1982 | 	var splitDateTime = function (dateTimeString, timeSettings) {
1983 | 		// The idea is to get the number separator occurrences in datetime and the time format requested (since time has
1984 | 		// fewer unknowns, mostly numbers and am/pm). We will use the time pattern to split.
1985 | 		var separator = computeEffectiveSetting(timeSettings, 'separator'),
1986 | 			format = computeEffectiveSetting(timeSettings, 'timeFormat'),
1987 | 			timeParts = format.split(separator), // how many occurrences of separator may be in our format?
1988 | 			timePartsLen = timeParts.length,
1989 | 			allParts = dateTimeString.split(separator),
1990 | 			allPartsLen = allParts.length;
1991 | 
1992 | 		if (allPartsLen > 1) {
1993 | 			return {
1994 | 				dateString: allParts.splice(0, allPartsLen - timePartsLen).join(separator),
1995 | 				timeString: allParts.splice(0, timePartsLen).join(separator)
1996 | 			};
1997 | 		}
1998 | 
1999 | 		return {
2000 | 			dateString: dateTimeString,
2001 | 			timeString: ''
2002 | 		};
2003 | 	};
2004 | 
2005 | 	/*
2006 | 	* Internal function to parse datetime interval
2007 | 	* Returns: {date: Date, timeObj: Object}, where
2008 | 	*   date - parsed date without time (type Date)
2009 | 	*   timeObj = {hour: , minute: , second: , millisec: , microsec: } - parsed time. Optional
2010 | 	*/
2011 | 	var parseDateTimeInternal = function (dateFormat, timeFormat, dateTimeString, dateSettings, timeSettings) {
2012 | 		var date,
2013 | 			parts,
2014 | 			parsedTime;
2015 | 
2016 | 		parts = splitDateTime(dateTimeString, timeSettings);
2017 | 		date = $.datepicker._base_parseDate(dateFormat, parts.dateString, dateSettings);
2018 | 
2019 | 		if (parts.timeString === '') {
2020 | 			return {
2021 | 				date: date
2022 | 			};
2023 | 		}
2024 | 
2025 | 		parsedTime = $.datepicker.parseTime(timeFormat, parts.timeString, timeSettings);
2026 | 
2027 | 		if (!parsedTime) {
2028 | 			throw 'Wrong time format';
2029 | 		}
2030 | 
2031 | 		return {
2032 | 			date: date,
2033 | 			timeObj: parsedTime
2034 | 		};
2035 | 	};
2036 | 
2037 | 	/*
2038 | 	* Internal function to set timezone_select to the local timezone
2039 | 	*/
2040 | 	var selectLocalTimezone = function (tp_inst, date) {
2041 | 		if (tp_inst && tp_inst.timezone_select) {
2042 | 			var now = date || new Date();
2043 | 			tp_inst.timezone_select.val(-now.getTimezoneOffset());
2044 | 		}
2045 | 	};
2046 | 
2047 | 	/*
2048 | 	* Create a Singleton Instance
2049 | 	*/
2050 | 	$.timepicker = new Timepicker();
2051 | 
2052 | 	/**
2053 | 	 * Get the timezone offset as string from a date object (eg '+0530' for UTC+5.5)
2054 | 	 * @param {number} tzMinutes if not a number, less than -720 (-1200), or greater than 840 (+1400) this value is returned
2055 | 	 * @param {boolean} iso8601 if true formats in accordance to iso8601 "+12:45"
2056 | 	 * @return {string}
2057 | 	 */
2058 | 	$.timepicker.timezoneOffsetString = function (tzMinutes, iso8601) {
2059 | 		if (isNaN(tzMinutes) || tzMinutes > 840 || tzMinutes < -720) {
2060 | 			return tzMinutes;
2061 | 		}
2062 | 
2063 | 		var off = tzMinutes,
2064 | 			minutes = off % 60,
2065 | 			hours = (off - minutes) / 60,
2066 | 			iso = iso8601 ? ':' : '',
2067 | 			tz = (off >= 0 ? '+' : '-') + ('0' + Math.abs(hours)).slice(-2) + iso + ('0' + Math.abs(minutes)).slice(-2);
2068 | 
2069 | 		if (tz === '+00:00') {
2070 | 			return 'Z';
2071 | 		}
2072 | 		return tz;
2073 | 	};
2074 | 
2075 | 	/**
2076 | 	 * Get the number in minutes that represents a timezone string
2077 | 	 * @param  {string} tzString formatted like "+0500", "-1245", "Z"
2078 | 	 * @return {number} the offset minutes or the original string if it doesn't match expectations
2079 | 	 */
2080 | 	$.timepicker.timezoneOffsetNumber = function (tzString) {
2081 | 		var normalized = tzString.toString().replace(':', ''); // excuse any iso8601, end up with "+1245"
2082 | 
2083 | 		if (normalized.toUpperCase() === 'Z') { // if iso8601 with Z, its 0 minute offset
2084 | 			return 0;
2085 | 		}
2086 | 
2087 | 		if (!/^(\-|\+)\d{4}$/.test(normalized)) { // possibly a user defined tz, so just give it back
2088 | 			return parseInt(tzString, 10);
2089 | 		}
2090 | 
2091 | 		return ((normalized.substr(0, 1) === '-' ? -1 : 1) * // plus or minus
2092 | 					((parseInt(normalized.substr(1, 2), 10) * 60) + // hours (converted to minutes)
2093 | 					parseInt(normalized.substr(3, 2), 10))); // minutes
2094 | 	};
2095 | 
2096 | 	/**
2097 | 	 * No way to set timezone in js Date, so we must adjust the minutes to compensate. (think setDate, getDate)
2098 | 	 * @param  {Date} date
2099 | 	 * @param  {string} fromTimezone formatted like "+0500", "-1245"
2100 | 	 * @param  {string} toTimezone formatted like "+0500", "-1245"
2101 | 	 * @return {Date}
2102 | 	 */
2103 | 	$.timepicker.timezoneAdjust = function (date, fromTimezone, toTimezone) {
2104 | 		var fromTz = $.timepicker.timezoneOffsetNumber(fromTimezone);
2105 | 		var toTz = $.timepicker.timezoneOffsetNumber(toTimezone);
2106 | 		if (!isNaN(toTz)) {
2107 | 			date.setMinutes(date.getMinutes() + (-fromTz) - (-toTz));
2108 | 		}
2109 | 		return date;
2110 | 	};
2111 | 
2112 | 	/**
2113 | 	 * Calls `timepicker()` on the `startTime` and `endTime` elements, and configures them to
2114 | 	 * enforce date range limits.
2115 | 	 * n.b. The input value must be correctly formatted (reformatting is not supported)
2116 | 	 * @param  {Element} startTime
2117 | 	 * @param  {Element} endTime
2118 | 	 * @param  {Object} options Options for the timepicker() call
2119 | 	 * @return {jQuery}
2120 | 	 */
2121 | 	$.timepicker.timeRange = function (startTime, endTime, options) {
2122 | 		return $.timepicker.handleRange('timepicker', startTime, endTime, options);
2123 | 	};
2124 | 
2125 | 	/**
2126 | 	 * Calls `datetimepicker` on the `startTime` and `endTime` elements, and configures them to
2127 | 	 * enforce date range limits.
2128 | 	 * @param  {Element} startTime
2129 | 	 * @param  {Element} endTime
2130 | 	 * @param  {Object} options Options for the `timepicker()` call. Also supports `reformat`,
2131 | 	 *   a boolean value that can be used to reformat the input values to the `dateFormat`.
2132 | 	 * @param  {string} method Can be used to specify the type of picker to be added
2133 | 	 * @return {jQuery}
2134 | 	 */
2135 | 	$.timepicker.datetimeRange = function (startTime, endTime, options) {
2136 | 		$.timepicker.handleRange('datetimepicker', startTime, endTime, options);
2137 | 	};
2138 | 
2139 | 	/**
2140 | 	 * Calls `datepicker` on the `startTime` and `endTime` elements, and configures them to
2141 | 	 * enforce date range limits.
2142 | 	 * @param  {Element} startTime
2143 | 	 * @param  {Element} endTime
2144 | 	 * @param  {Object} options Options for the `timepicker()` call. Also supports `reformat`,
2145 | 	 *   a boolean value that can be used to reformat the input values to the `dateFormat`.
2146 | 	 * @return {jQuery}
2147 | 	 */
2148 | 	$.timepicker.dateRange = function (startTime, endTime, options) {
2149 | 		$.timepicker.handleRange('datepicker', startTime, endTime, options);
2150 | 	};
2151 | 
2152 | 	/**
2153 | 	 * Calls `method` on the `startTime` and `endTime` elements, and configures them to
2154 | 	 * enforce date range limits.
2155 | 	 * @param  {string} method Can be used to specify the type of picker to be added
2156 | 	 * @param  {Element} startTime
2157 | 	 * @param  {Element} endTime
2158 | 	 * @param  {Object} options Options for the `timepicker()` call. Also supports `reformat`,
2159 | 	 *   a boolean value that can be used to reformat the input values to the `dateFormat`.
2160 | 	 * @return {jQuery}
2161 | 	 */
2162 | 	$.timepicker.handleRange = function (method, startTime, endTime, options) {
2163 | 		options = $.extend({}, {
2164 | 			minInterval: 0, // min allowed interval in milliseconds
2165 | 			maxInterval: 0, // max allowed interval in milliseconds
2166 | 			start: {},      // options for start picker
2167 | 			end: {}         // options for end picker
2168 | 		}, options);
2169 | 
2170 | 		// for the mean time this fixes an issue with calling getDate with timepicker()
2171 | 		var timeOnly = false;
2172 | 		if(method === 'timepicker'){
2173 | 			timeOnly = true;
2174 | 			method = 'datetimepicker';
2175 | 		}
2176 | 
2177 | 		function checkDates(changed, other) {
2178 | 			var startdt = startTime[method]('getDate'),
2179 | 				enddt = endTime[method]('getDate'),
2180 | 				changeddt = changed[method]('getDate');
2181 | 
2182 | 			if (startdt !== null) {
2183 | 				var minDate = new Date(startdt.getTime()),
2184 | 					maxDate = new Date(startdt.getTime());
2185 | 
2186 | 				minDate.setMilliseconds(minDate.getMilliseconds() + options.minInterval);
2187 | 				maxDate.setMilliseconds(maxDate.getMilliseconds() + options.maxInterval);
2188 | 
2189 | 				if (options.minInterval > 0 && minDate > enddt) { // minInterval check
2190 | 					endTime[method]('setDate', minDate);
2191 | 				}
2192 | 				else if (options.maxInterval > 0 && maxDate < enddt) { // max interval check
2193 | 					endTime[method]('setDate', maxDate);
2194 | 				}
2195 | 				else if (startdt > enddt) {
2196 | 					other[method]('setDate', changeddt);
2197 | 				}
2198 | 			}
2199 | 		}
2200 | 
2201 | 		function selected(changed, other, option) {
2202 | 			if (!changed.val()) {
2203 | 				return;
2204 | 			}
2205 | 			var date = changed[method].call(changed, 'getDate');
2206 | 			if (date !== null && options.minInterval > 0) {
2207 | 				if (option === 'minDate') {
2208 | 					date.setMilliseconds(date.getMilliseconds() + options.minInterval);
2209 | 				}
2210 | 				if (option === 'maxDate') {
2211 | 					date.setMilliseconds(date.getMilliseconds() - options.minInterval);
2212 | 				}
2213 | 			}
2214 | 
2215 | 			if (date.getTime) {
2216 | 				other[method].call(other, 'option', option, date);
2217 | 			}
2218 | 		}
2219 | 
2220 | 		$.fn[method].call(startTime, $.extend({
2221 | 			timeOnly: timeOnly,
2222 | 			onClose: function (dateText, inst) {
2223 | 				checkDates($(this), endTime);
2224 | 			},
2225 | 			onSelect: function (selectedDateTime) {
2226 | 				selected($(this), endTime, 'minDate');
2227 | 			}
2228 | 		}, options, options.start));
2229 | 		$.fn[method].call(endTime, $.extend({
2230 | 			timeOnly: timeOnly,
2231 | 			onClose: function (dateText, inst) {
2232 | 				checkDates($(this), startTime);
2233 | 			},
2234 | 			onSelect: function (selectedDateTime) {
2235 | 				selected($(this), startTime, 'maxDate');
2236 | 			}
2237 | 		}, options, options.end));
2238 | 
2239 | 		checkDates(startTime, endTime);
2240 | 
2241 | 		selected(startTime, endTime, 'minDate');
2242 | 		selected(endTime, startTime, 'maxDate');
2243 | 
2244 | 		return $([startTime.get(0), endTime.get(0)]);
2245 | 	};
2246 | 
2247 | 	/**
2248 | 	 * Log error or data to the console during error or debugging
2249 | 	 * @param  {Object} err pass any type object to log to the console during error or debugging
2250 | 	 * @return {void}
2251 | 	 */
2252 | 	$.timepicker.log = function () {
2253 | 		// Older IE (9, maybe 10) throw error on accessing `window.console.log.apply`, so check first.
2254 | 		if (window.console && window.console.log && window.console.log.apply) {
2255 | 			window.console.log.apply(window.console, Array.prototype.slice.call(arguments));
2256 | 		}
2257 | 	};
2258 | 
2259 | 	/*
2260 | 	 * Add util object to allow access to private methods for testability.
2261 | 	 */
2262 | 	$.timepicker._util = {
2263 | 		_extendRemove: extendRemove,
2264 | 		_isEmptyObject: isEmptyObject,
2265 | 		_convert24to12: convert24to12,
2266 | 		_detectSupport: detectSupport,
2267 | 		_selectLocalTimezone: selectLocalTimezone,
2268 | 		_computeEffectiveSetting: computeEffectiveSetting,
2269 | 		_splitDateTime: splitDateTime,
2270 | 		_parseDateTimeInternal: parseDateTimeInternal
2271 | 	};
2272 | 
2273 | 	/*
2274 | 	* Microsecond support
2275 | 	*/
2276 | 	if (!Date.prototype.getMicroseconds) {
2277 | 		Date.prototype.microseconds = 0;
2278 | 		Date.prototype.getMicroseconds = function () { return this.microseconds; };
2279 | 		Date.prototype.setMicroseconds = function (m) {
2280 | 			this.setMilliseconds(this.getMilliseconds() + Math.floor(m / 1000));
2281 | 			this.microseconds = m % 1000;
2282 | 			return this;
2283 | 		};
2284 | 	}
2285 | 
2286 | 	/*
2287 | 	* Keep up with the version
2288 | 	*/
2289 | 	$.timepicker.version = "1.6.3";
2290 | 
2291 | }));
2292 | 


--------------------------------------------------------------------------------