/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ // UI handler functions (global scope mandatory if set inline html tags) /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ // accuracy of float format output in parse log (1 for integer, 0.1 for one digit after point, and so on... 0 for max/full accuracy) // (not used for gauges parsing, wich require only integer for degrees and minutes, and an accuracy step of 3 for seconds) var accuracy = 0.00001; // regular expression required for update and parse dms angle format (copy in ''pattern' html attribute for css validation imported at start of 'parse' and 'update' functions: could be commented/deleted if not removed from html) /* var ag_dms_re = /(?:^\s*(\d+(?:[.]\d+)?)\s*°?\s*$)|(?:^\s*(?:(\d+)\s*°)?\s*(?:(?:([0-5]?\d(?:[.]\d+)?)\s*'?)$))|(?:^\s*(?:(\d+)\s*°)?\s*(?:([0-5]?\d)\s*')?\s*(?:([0-5]?\d(?:[.]\d+)?)\s*(?:"|'')?)?\s*$)/; */ // log function (required only for 'parse' function, if log calls not commented) /* REMOVED AS NOT USEFULL FEATURE function log(a) { if (!document.getElementById('auto-log').checked) return; var e = document.getElementById('angle-out'); if (!e) { e = document.createElement('table'); e.innerHTML = 'degrees' +'minutes' +'seconds'; // change log target (same container than new alternate output) console.log(document.querySelector('body>*:last-child')+''); document.querySelector('body>*:last-child').append(e); e = e.lastChild; } var n = document.createElement('tr'); n.innerHTML = ''+(a.d||'-')+''+(a.m||'-')+''+(a.s||'-')+''; e.insertBefore(n,e.firstChild); // or for a top-bottom add of row, instead of bottom-top: //e.appendChild(n); } */ // required by parse() function: // used for both interface (directly and through update() function) and main gauges order computation function convert(d) { // convert from decimal to deg-min-sec var n = parseFloat(d); d = Math.floor(n); n = 60*(n-d); var m = Math.floor(n); var s = 60*(n-m); if (accuracy) { var ac = accuracy.toString().length-2; s = accuracy*Math.round(s/accuracy); if (ac<0) ac = 0; s = s.toFixed(ac); s = s.replace(/(0+$)|(\.0+$)/,''); if (s=='60') { if (++m==60) { d++; m = 0; } s = 0; } } return { d: d, m: m, s: s }; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ // event handlers /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ function parse(self) { var v = self.value; ag_dms_re = new RegExp(document.querySelector('input').getAttribute('pattern')); var r = ag_dms_re.exec(v); var f = false; var i = (r) ? r.length : 1; while (--i) { f = f || r[i]; if (f) break; } if (!f) return; else self.className = 'valid'; var a = {d:r[1]||r[2]||r[4]||'0',m:r[3]||r[5]||'0',s:r[6]||'0'}; /* // log parsed angle log(a); */ // convert from decimal to deg-min-sec if needed if (a.d.indexOf('.')!=-1) { a = convert(a.d); /* // log converted angle log(a); */ } else { a.d = parseInt(a.d); // convert decimal minutes to min-sec if needed if (a.m.indexOf('.')!=-1) { a.m = parseFloat(a.m); a.s = a.m-Math.floor(a.m)*60; if (accuracy) { var ac = accuracy.toString().length-2; s = accuracy*Math.round(s/accuracy); if (ac<0) ac = 0; s = s.toFixed(ac); s = s.replace(/(0+$)|(\.0+$)/,''); if (s=='60') { if (++m==60) { d++; m = 0; } s = 0; } } // log(a); } else a.m = parseInt(a.m); } a.s = parseFloat(a.s); return a; } function update(self,force) { ag_dms_re = new RegExp(document.querySelector('input').getAttribute('pattern')); var r = ag_dms_re.exec(self.value); var f = false; var i = (r) ? r.length : 0; if (r) while (--i) { f = f || r[i]; if (f) break; } self.className = (f) ? 'valid' : ''; if (f&&(force||document.getElementById('auto-update').checked)) ag.parse(self); } function check(self) { var id = self.id.split('-').pop(); /* // (log button removed) if (id=='log') { if (document.getElementById('btn-update').disabled) document.getElementById('btn-log').disabled = self.checked; else document.getElementById('btn-log').disabled = false; } else { */ document.getElementById('btn-update').disabled = self.checked; /* document.getElementById('auto-log').disabled = !self.checked; if (self.checked) { document.getElementById('btn-log').disabled = document.getElementById('auto-log').checked; update(document.getElementById('inp')); } } */ } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ // main handler: angle gauges standalone object slightly adapted for ui /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ var ag = { d: [1,3,9,27,41], m: [1,3,9,27], s: [3,9,18,30], max: { d:81, m:40, s:60 }, acc: 3, pre: { // ugly fix for algorithm failing case '15':[27,-9,-3], '16':[27,-9,-3,+1], '17':[27,-9,-1], '56':[41,27,-9,-3], '57':[41,27,-9,-3,+1], '58':[41,27,-9,-1] }, Obj: (function() { var AngleGauges = function() {}; AngleGauges.prototype = { // overwriting toString() method allow easy logging // (ie: console.log(''+angle_gauges_obj) or alert(...) // will output result of our function instead of anonymous // default '[object Object]'... toString: function() { return 'd: '+this.d.reduce(ag.f.reduce_str,'')+ ', m: '+this.m.reduce(ag.f.reduce_str,'')+ ', s: '+this.s.reduce(ag.f.reduce_str,''); }, /* no more used, could be deleted get html() { // reset to default: // (prevent new result output alternative mixing missuse) ag.f.separator_reduce_str = null; ag.f.unit_reduce_str = null; ag.f.nosign_reduce_str = false; // sign 'plus' in front of positive values return '

Gauges:: degrees: '+ this.d.reduce(ag.f.reduce_str,'')+ '; minutes: '+ this.m.reduce(ag.f.reduce_str,'')+ '; secondes: '+ this.s.reduce(ag.f.reduce_str,'')+'

'; }, */ // adding methods/accessors for building result figure res_reduce_opt: function(u) { ag.f.nosign_reduce_str = true; // no sign ag.f.separator_reduce_str = ','; ag.f.unit_reduce_str = u; }, res_list_get: function(a,u) { this.res_reduce_opt(u); a = a.map(Math.abs); // comment to get sign in output (and change parameter in res_reduce_opt()) return a.reduce(ag.f.reduce_str.bind(ag.f),''); }, res_body_get: function(a,u) { var r = ''; r += a.reduce(ag.f.reduce_sum,0); r += u+' => '; r += a.reduce(this.res_reduce_cell.bind({u:u,s:0}),''); return r; }, res_reduce_cell: function(r,v) { var f = (this.s) ? true : false; this.s += v; r += (f&&v>0) ? '+ '+v : ((v<0) ? '- '+Math.abs(v) : v); r += this.u; if (f) { r += '

'+this.s+this.u; } return r+'
'; }, get res_foot() { var r = []; if (this.d.length) r.push(this.res_list_get(this.d,'°')); if (this.m.length) r.push(this.res_list_get(this.m,'\'')); if (this.s.length) r.push(this.res_list_get(this.s,'"')); return 'We will use a ['+r.join(',')+']'; }, get res_body() { var d, m, s, r = ''; d = (this.d.length) ? this.res_body_get(this.d,'°') : ''; m = (this.m.length) ? this.res_body_get(this.m,'\'') : ''; s = (this.s.length) ? this.res_body_get(this.s,'"') : ''; r += d+''+m+''+s+''; if (this.d.length) r += '[ '+this.res_list_get(this.d,'°')+' ]'; r += ''; if (this.m.length) r += '[ '+this.res_list_get(this.m,'\'')+' ]'; r += ''; if (this.s.length) r += '[ '+this.res_list_get(this.s,'"')+' ]'; return r+''; } }; return new AngleGauges(); })(), sub_parse: function(n,ag_) { // ugly fix for algorithm failing case (use of preset) if (ag_[0]==1 && ag.pre.hasOwnProperty(n)) return ag.pre[n]; // var r, s = n, g_ = []; var dbg = 10; while (n) { ag.f.reset(Math.abs(n),g_); r = ag_.reduce(ag.f.reduce_nearest.bind(ag.f),null); r *= (g_.reduce(ag.f.reduce_sum,0)<=s) ? 1 : -1; g_.push(r); n -= r; if (!dbg--) break; // safety base case for avoiding infinite loop } // ('dbg' lines could be removed as normally bug free now) if (dbg==-1) console.log('ERROR: Debug loop limit overflow!'); return g_; }, // main function handler (called by 'oninput' event of host ) parse: function(self) { // get user value as dms format var a = parse(self); // (argument: {d:[Num],m:[Num],s:[Num]}) // parse: function(a) { var g = ag.Obj; // handle gauges accuracy var n = Math.round(a.s); var n3 = n%ag.acc; if (n3) n -= (n3ag.max.s) n -= 60, a.d++; g.s = ag.sub_parse(n,ag.s); // handle minutes n = a.m; if (n>ag.max.m) n -= 60, a.d++; g.m = ag.sub_parse(n,ag.m); // handle degrees n = a.d; // if (n>ag.max.d) n = 0, g = 'Angle out of range!'; if (n>ag.max.d) n = 0, g = '

Angle out of range!

'; g.d = ag.sub_parse(n,ag.d); // return result (standalone version) // return g; // output (modified for new alternate output) if (typeof g != 'string') { document.querySelector('#result tbody').innerHTML = g.res_body; document.querySelector('#result tfoot th').innerHTML = g.res_foot; document.getElementById('result').style = ''; } else { document.getElementById('result').style = 'display:none;'; } // old modified output handler n = (n3 && typeof g!='string') ? ' (rounded to)' : ''; n = 'Given angle'+n+': '+a.d+'°'+a.m+'\''+s+'"'; // g = (typeof g=='string') ? n+g : n; if (typeof g=='string') { n += g; document.getElementById('inp').className = ''; } document.querySelector('output *:first-child').innerHTML = n; }, // object for hosting callback filters and 'private' variables options // (not used for reduce_sum() callback method: could be 'standalone' -- ie: not embed into the object) f: (function() { function AgFilter(v) { this.reset(v); } AgFilter.prototype.reset = function(v,g) { this.v = v; this.g = g || []; this.s = 0; // adding parameters for 'reduce_str' filter this.separator_reduce_str = null; this.unit_reduce_str = null; this.nosign_reduce_str = false; // long names to avoid conflict with global scope when testing if exist before use (in case of previous way of use, without binding: for use parameter it's required to bind 'ag.f' object, as done for 'nearest' filter) ^^ }; AgFilter.prototype.reduce_nearest = function(r,v) { if (this.g.indexOf(v)==-1 && this.g.indexOf(-v)==-1) if (r===null || Math.abs(this.v-v)<=Math.abs(this.v-r) || (v!=41 && r!=this.v && this.s+1==this.v)) r = v; this.s += v; return r; }; AgFilter.prototype.reduce_sum = function(r,v) { return r+v; }; AgFilter.prototype.reduce_str = function(r,v) { // modified for adding parameters var s = (r) ? this.separator_reduce_str || '' : ''; var u = this.unit_reduce_str || ''; var p = (this.nosign_reduce_str) ? '' : '+'; return r+( (r&&v>0) ? s+p+v+u : s+v+u ); // return r+( (r&&v>0) ? '+'+v : v ); }; return new AgFilter(); })() };

Angle gauges [coded for @Lalit Patil] v.1.6