diff options
| author | Richard Wall <richard@largo> | 2011-08-12 22:04:39 +0100 |
|---|---|---|
| committer | Richard Wall <richard@largo> | 2011-08-12 22:04:39 +0100 |
| commit | 824cbd8bb2aa30a1c6771d7709e4081cb0aa4b0c (patch) | |
| tree | aef2693ad32483b429ea69b4769deefc58c23517 | |
| parent | b404903c1d43af270a0349890f439b4e0637831e (diff) | |
import jsrrdgraph.js
| -rw-r--r-- | docs/examples/assets/js/jsrrdgraph.js | 4875 |
1 files changed, 4875 insertions, 0 deletions
diff --git a/docs/examples/assets/js/jsrrdgraph.js b/docs/examples/assets/js/jsrrdgraph.js new file mode 100644 index 0000000..f9851eb --- /dev/null +++ b/docs/examples/assets/js/jsrrdgraph.js @@ -0,0 +1,4875 @@ +/** + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + + * RRDtool 1.4.5 Copyright by Tobi Oetiker, 1997-2010 + * + * Convert to javascript: Manuel Sanmartin <manuel.luis at gmail.com> + **/ + +"use strict"; + +var RRDTime = function() { + this.parser.apply(this, arguments); +}; + +RRDTime.EOF = -1; +RRDTime.MIDNIGHT = 0; +RRDTime.NOON = 1; +RRDTime.TEATIME = 2; +RRDTime.PM = 3; +RRDTime.AM = 4; +RRDTime.YESTERDAY = 5; +RRDTime.TODAY = 6; +RRDTime.TOMORROW = 7; +RRDTime.NOW = 8; +RRDTime.START = 9; +RRDTime.END = 10; +RRDTime.EPOCH = 11; +RRDTime.SECONDS = 12; +RRDTime.MINUTES = 13; +RRDTime.HOURS = 14; +RRDTime.DAYS = 15; +RRDTime.WEEKS = 16; +RRDTime.MONTHS = 17; +RRDTime.YEARS = 18; +RRDTime.MONTHS_MINUTES = 19; +RRDTime.NUMBER = 20; +RRDTime.PLUS = 21; +RRDTime.MINUS = 22; +RRDTime.DOT = 23; +RRDTime.COLON = 24; +RRDTime.SLASH = 25; +RRDTime.ID = 26; +RRDTime.JUNK = 27; +RRDTime.JAN = 28; +RRDTime.FEB = 29; +RRDTime.MAR = 30; +RRDTime.APR = 31; +RRDTime.MAY = 32; +RRDTime.JUN = 33; +RRDTime.JUL = 34; +RRDTime.AUG = 35; +RRDTime.SEP = 36; +RRDTime.OCT = 37; +RRDTime.NOV = 38; +RRDTime.DEC = 39; +RRDTime.SUN = 40; +RRDTime.MON = 41; +RRDTime.TUE = 42; +RRDTime.WED = 43; +RRDTime.THU = 44; +RRDTime.FRI = 45; +RRDTime.SAT = 46; + +RRDTime.variousWords = [ + {name: "midnight", value: RRDTime.MIDNIGHT}, /* 00:00:00 of today or tomorrow */ + {name: "noon", value: RRDTime.NOON}, /* 12:00:00 of today or tomorrow */ + {name: "teatime", value: RRDTime.TEATIME}, /* 16:00:00 of today or tomorrow */ + {name: "am", value: RRDTime.AM}, /* morning times for 0-12 clock */ + {name: "pm", value: RRDTime.PM}, /* evening times for 0-12 clock */ + {name: "tomorrow", value: RRDTime.TOMORROW}, + {name: "yesterday", value: RRDTime.YESTERDAY}, + {name: "today", value: RRDTime.TODAY}, + {name: "now", value: RRDTime.NOW}, + {name: "n", value: RRDTime.NOW}, + {name: "start", value: RRDTime.START}, + {name: "s", value: RRDTime.START}, + {name: "end", value: RRDTime.END}, + {name: "e", value: RRDTime.END}, + {name: "epoch", value: RRDTime.EPOCH}, + {name: "jan", value: RRDTime.JAN}, + {name: "feb", value: RRDTime.FEB}, + {name: "mar", value: RRDTime.MAR}, + {name: "apr", value: RRDTime.APR}, + {name: "may", value: RRDTime.MAY}, + {name: "jun", value: RRDTime.JUN}, + {name: "jul", value: RRDTime.JUL}, + {name: "aug", value: RRDTime.AUG}, + {name: "sep", value: RRDTime.SEP}, + {name: "oct", value: RRDTime.OCT}, + {name: "nov", value: RRDTime.NOV}, + {name: "dec", value: RRDTime.DEC}, + {name: "january", value: RRDTime.JAN}, + {name: "february", value: RRDTime.FEB}, + {name: "march", value: RRDTime.MAR}, + {name: "april", value: RRDTime.APR}, + {name: "may", value: RRDTime.MAY}, + {name: "june", value: RRDTime.JUN}, + {name: "july", value: RRDTime.JUL}, + {name: "august", value: RRDTime.AUG}, + {name: "september", value: RRDTime.SEP}, + {name: "october", value: RRDTime.OCT}, + {name: "november", value: RRDTime.NOV}, + {name: "december", value: RRDTime.DEC}, + {name: "sunday", value: RRDTime.SUN}, + {name: "sun", value: RRDTime.SUN}, + {name: "monday", value: RRDTime.MON}, + {name: "mon", value: RRDTime.MON}, + {name: "tuesday", value: RRDTime.TUE}, + {name: "tue", value: RRDTime.TUE}, + {name: "wednesday", value: RRDTime.WED}, + {name: "wed", value: RRDTime.WED}, + {name: "thursday", value: RRDTime.THU}, + {name: "thu", value: RRDTime.THU}, + {name: "friday", value: RRDTime.FRI}, + {name: "fri", value: RRDTime.FRI}, + {name: "saturday", value: RRDTime.SAT}, + {name: "sat", value: RRDTime.SAT} +]; + +RRDTime.timeMultipliers = [ + {name: "second", value: RRDTime.SECONDS}, /* seconds multiplier */ + {name: "seconds", value: RRDTime.SECONDS}, /* (pluralized) */ + {name: "sec", value: RRDTime.SECONDS}, /* (generic) */ + {name: "s", value: RRDTime.SECONDS}, /* (short generic) */ + {name: "minute", value: RRDTime.MINUTES}, /* minutes multiplier */ + {name: "minutes", value: RRDTime.MINUTES}, /* (pluralized) */ + {name: "min", value: RRDTime.MINUTES}, /* (generic) */ + {name: "m", value: RRDTime.MONTHS_MINUTES}, /* (short generic) */ + {name: "hour", value: RRDTime.HOURS}, /* hours ... */ + {name: "hours", value: RRDTime.HOURS}, /* (pluralized) */ + {name: "hr", value: RRDTime.HOURS}, /* (generic) */ + {name: "h", value: RRDTime.HOURS}, /* (short generic) */ + {name: "day", value: RRDTime.DAYS}, /* days ... */ + {name: "days", value: RRDTime.DAYS}, /* (pluralized) */ + {name: "d", value: RRDTime.DAYS}, /* (short generic) */ + {name: "week", value: RRDTime.WEEKS}, /* week ... */ + {name: "weeks", value: RRDTime.WEEKS}, /* (pluralized) */ + {name: "wk", value: RRDTime.WEEKS}, /* (generic) */ + {name: "w", value: RRDTime.WEEKS}, /* (short generic) */ + {name: "month", value: RRDTime.MONTHS}, /* week ... */ + {name: "months", value: RRDTime.MONTHS}, /* (pluralized) */ + {name: "mon", value: RRDTime.MONTHS}, /* (generic) */ + {name: "year", value: RRDTime.YEARS}, /* year ... */ + {name: "years", value: RRDTime.YEARS}, /* (pluralized) */ + {name: "yr", value: RRDTime.YEARS}, /* (generic) */ + {name: "y", value: RRDTime.YEARS} /* (short generic) */ +]; + +RRDTime.ABSOLUTE_TIME = 0; +RRDTime.RELATIVE_TO_START_TIME = 1; +RRDTime.RELATIVE_TO_END_TIME = 2; +RRDTime.RELATIVE_TO_EPOCH = 3; + +RRDTime.prototype = { + tokens: null, + toklen: 0, + tokidx: 0, + + token: null, + tokid: 0, + + type: 0, + offset: 0, + tm_sec: 0, + tm_min: 0, + tm_hour: 0, + tm_mday: 0, + tm_mon: 0, + tm_year: 0, + tm_wday: 0, + + specials: null, + + gettok: function () + { + if (this.tokidx >= this.toklen) { + this.tokid = RRDTime.EOF; + } else { + this.token = this.tokens[this.tokidx]; + this.tokidx++; + if (!isNaN(this.token)) { + this.tokid = RRDTime.NUMBER; + this.token = parseInt(this.token); + } else if (this.token === ':') { + this.tokid = RRDTime.COLON; + } else if (this.token === '.') { + this.tokid = RRDTime.DOT; + } else if (this.token === '+') { + this.tokid = RRDTime.PLUS; + } else if (this.token === '/') { + this.tokid = RRDTime.SLASH; + } else if (this.token === '-') { + this.tokid = RRDTime.MINUS; + } else { + this.tokid = RRDTime.ID; + for (var i = 0, len = this.specials.length; i < len; i++) { + if (this.specials[i].name === this.token) { + this.tokid = this.specials[i].value; + break; + } + } + } + } + return this.tokid; + }, + plus_minus: function (doop) + { + var op = RRDTime.PLUS; + var prev_multiplier = -1; + var delta; + + if (doop >= 0) { + op = doop; + if (this.gettok() != RRDTime.NUMBER) + throw "There should be number after '"+(op == RRDTime.PLUS ? '+' : '-')+"'"; + prev_multiplier = -1; /* reset months-minutes guessing mechanics */ + } + /* if doop is < 0 then we repeat the previous op with the prefetched number */ + delta = this.token; + if (this.gettok() == RRDTime.MONTHS_MINUTES) { + /* hard job to guess what does that -5m means: -5mon or -5min? */ + switch (prev_multiplier) { + case RRDTime.DAYS: + case RRDTime.WEEKS: + case RRDTime.MONTHS: + case RRDTime.YEARS: + this.tokid = RRDTime.MONTHS; + break; + case RRDTime.SECONDS: + case RRDTime.MINUTES: + case RRDTime.HOURS: + this.tokid = RRDTime.MINUTES; + break; + default: + if (delta < 6) /* it may be some other value but in the context of RRD who needs less than 6 min deltas? */ + this.tokid = RRDTime.MONTHS; + else + this.tokid = RRDTime.MINUTES; + } + } + prev_multiplier = this.tokid; + switch (this.tokid) { + case RRDTime.YEARS: + this.tm_year += ( op == RRDTime.PLUS) ? delta : -delta; + return; + case RRDTime.MONTHS: + this.tm_mon += ( op == RRDTime.PLUS) ? delta : -delta; + return; + case RRDTime.WEEKS: + delta *= 7; + case RRDTime.DAYS: + this.tm_mday += ( op == RRDTime.PLUS) ? delta : -delta; + return; + case RRDTime.HOURS: + this.offset += (op == RRDTime.PLUS) ? delta * 60 * 60 : -delta * 60 * 60; + return; + case RRDTime.MINUTES: + this.offset += (op == RRDTime.PLUS) ? delta * 60 : -delta * 60; + return; + case RRDTime.SECONDS: + this.offset += (op == RRDTime.PLUS) ? delta : -delta; + return; + default: /*default unit is seconds */ + this.offset += (op == RRDTime.PLUS) ? delta : -delta; + return; + } + throw "well-known time unit expected after "+delta; + }, + tod: function() /* tod() computes the time of day (TIME-OF-DAY-SPEC) */ + { + var hour, minute = 0; + var tlen; + /* save token status in case we must abort */ + var tokid_sv = this.tokid; + + tlen = (this.token+"").length; + /* first pick out the time of day - we assume a HH (COLON|DOT) MM time */ + if (tlen > 2) + return; + hour = this.token; + this.gettok(); + if (this.tokid == RRDTime.SLASH || this.tokid == RRDTime.DOT) { + /* guess we are looking at a date */ + this.tokid = tokid_sv; + this.token = hour; + return; + } + if (this.tokid == RRDTime.COLON) { + if (this.gettok() != RRDTime.NUMBER) + throw "Parsing HH:MM syntax, expecting MM as number, got none"; + minute = this.token; + if (minute > 59) + throw "parsing HH:MM syntax, got MM = "+minute+" (>59!)"; + this.gettok(); + } + /* check if an AM or PM specifier was given */ + if (this.tokid == RRDTime.AM || this.tokid == RRDTime.PM) { + if (hour > 12) { + throw "there cannot be more than 12 AM or PM hours"; + } + if (this.tokid == RRDTime.PM) { + if (hour != 12) /* 12:xx PM is 12:xx, not 24:xx */ + hour += 12; + } else { + if (hour == 12) /* 12:xx AM is 00:xx, not 12:xx */ + hour = 0; + } + this.gettok(); + } else if (hour > 23) { + /* guess it was not a time then ... */ + this.tokid = tokid_sv; + this.token = hour; + return; + } + this.tm_hour = hour; + this.tm_min = minute; + this.tm_sec = 0; + if (this.tm_hour == 24) { + this.tm_hour = 0; + this.tm_mday++; + } + }, + assign_date: function(mday, mon, year) + { + if (year > 138) { + if (year > 1970) { + year -= 1900; + } else { + throw "invalid year "+year+" (should be either 00-99 or >1900)"; + } + } else if (year >= 0 && year < 38) { + year += 100; /* Allow year 2000-2037 to be specified as */ + } + /* 00-37 until the problem of 2038 year will */ + /* arise for unices with 32-bit time_t :) */ + if (year < 70) + throw "won't handle dates before epoch (01/01/1970), sorry"; + + this.tm_mday = mday; + this.tm_mon = mon; + this.tm_year = year; + }, + day: function () + { + var mday = 0, wday, mon, year = this.tm_year; + var tlen; + + switch (this.tokid) { + case RRDTime.YESTERDAY: + this.tm_mday--; + case RRDTime.TODAY: + this.gettok(); + break; + case RRDTime.TOMORROW: + this.tm_mday++; + this.gettok(); + break; + case RRDTime.JAN: + case RRDTime.FEB: + case RRDTime.MAR: + case RRDTime.APR: + case RRDTime.MAY: + case RRDTime.JUN: + case RRDTime.JUL: + case RRDTime.AUG: + case RRDTime.SEP: + case RRDTime.OCT: + case RRDTime.NOV: + case RRDTime.DEC: + mon = (this.tokid - RRDTime.JAN); + if (this.gettok() != RRDTime.NUMBER) + throw "the day of the month should follow month name"; + mday = this.token; + if (this.gettok() == RRDTime.NUMBER) { + year = this.token; + this.gettok(); + } else { + year = this.tm_year; + } + this.assign_date(mday, mon, year); + break; + case RRDTime.SUN: + case RRDTime.MON: + case RRDTime.TUE: + case RRDTime.WED: + case RRDTime.THU: + case RRDTime.FRI: + case RRDTime.SAT: + wday = (this.tokid - RRDTime.SUN); + this.tm_mday += (wday - this.tm_wday); + this.gettok(); + break; + case RRDTime.NUMBER: + mon = this.token; + if (mon > 10 * 365 * 24 * 60 * 60) { + this.localtime(mon); + this.gettok(); + break; + } + if (mon > 19700101 && mon < 24000101) { /*works between 1900 and 2400 */ + var str = this.token + ''; + year = parseInt(str.substr(0,4)); + mon = parseInt(str.substr(4,2)); + mday = parseInt(str.substr(6,2)); + this.gettok(); + } else { + this.gettok(); + if (mon <= 31 && (this.tokid == RRDTime.SLASH || this.tokid == RRDTime.DOT)) { + var sep = this.tokid; + if (this.gettok() != RRDTime.NUMBER) + throw "there should be "+(RRDTime.DOT ? "month" : "day")+" number after '"+(RRDTime.DOT ? '.' : '/')+"'"; + mday = this.token; + if (this.gettok() == sep) { + if (this.gettok() != RRDTime.NUMBER) + throw "there should be year number after '"+(sep == RRDTime.DOT ? '.' : '/')+"'"; + year = this.token; + this.gettok(); + } + if (sep == RRDTime.DOT) { + var x = mday; + mday = mon; + mon = x; + } + } + } + mon--; + if (mon < 0 || mon > 11) + throw "did you really mean month "+(mon+1)+"?"; + if (mday < 1 || mday > 31) + throw "I'm afraid that "+mday+" is not a valid day of the month", + this.assign_date(mday, mon, year); + break; + } + }, + parser: function(tspec) + { + var date = new Date(); + var hr = 0; + + this.specials = RRDTime.variousWords; + this.tokens = (tspec+'').match(/[0-9]+|[A-Za-z]+|[:.+-\/]/g); + this.toklen = this.tokens.length; + + /* establish the default time reference */ + this.type = RRDTime.ABSOLUTE_TIME; + this.offset = 0; + this.tm_sec = date.getSeconds(); + this.tm_min = date.getMinutes(); + this.tm_hour = date.getHours(); + this.tm_mday = date.getDate(); + this.tm_mon = date.getMonth(); + this.tm_year = date.getFullYear()-1900; + this.tm_wday = date.getDay(); + //thisptv->tm = *localtime(&now); + + this.gettok(); + switch (this.tokid) { + case RRDTime.PLUS: + case RRDTime.MINUS: + break; /* jump to OFFSET-SPEC part */ + case RRDTime.EPOCH: + this.type = RRDTime.RELATIVE_TO_EPOCH; + case RRDTime.START: + case RRDTime.END: + if (this.tokid === RRDTime.EPOCH) + this.type = RRDTime.RELATIVE_TO_START_TIME; + else + this.type = RRDTime.RELATIVE_TO_END_TIME; + this.tm_sec = 0; + this.tm_min = 0; + this.tm_hour = 0; + this.tm_mday = 0; + this.tm_mon = 0; + this.tm_year = 0; + case RRDTime.NOW: + var time_reference = this.tokid; + this.gettok(); + if (this.tokid == RRDTime.PLUS || this.tokid == RRDTime.MINUS) + break; + if (time_reference != RRDTime.NOW) { + throw "'start' or 'end' MUST be followed by +|- offset"; + } else if (this.tokid != RRDTime.EOF) { + throw "if 'now' is followed by a token it must be +|- offset"; + } + break; + case RRDTime.NUMBER: /* Only absolute time specifications below */ + var hour_sv = this.tm_hour; + var year_sv = this.tm_year; + this.tm_hour = 30; + this.tm_year = 30000; + this.tod(); + this.day(); + if (this.tm_hour == 30 && this.tm_year != 30000) + this.tod(); + if (this.tm_hour == 30) + this.tm_hour = hour_sv; + if (this.tm_year == 30000) + this.tm_year = year_sv; + break; + case RRDTime.JAN: + case RRDTime.FEB: + case RRDTime.MAR: + case RRDTime.APR: + case RRDTime.MAY: + case RRDTime.JUN: + case RRDTime.JUL: + case RRDTime.AUG: + case RRDTime.SEP: + case RRDTime.OCT: + case RRDTime.NOV: + case RRDTime.DEC: + this.day(); + if (this.tokid != RRDTime.NUMBER) + break; + this.tod(); + break; + case RRDTime.TEATIME: + hr += 4; + case RRDTime.NOON: + hr += 12; + case RRDTime.MIDNIGHT: + this.tm_hour = hr; + this.tm_min = 0; + this.tm_sec = 0; + this.gettok(); + this.day(); + break; + default: + throw "unparsable time: "+this.token+" "+this.sct; + break; + } /* ugly case statement */ + + /* + * the OFFSET-SPEC part + * + * (NOTE, the sc_tokid was prefetched for us by the previous code) + */ + if (this.tokid == RRDTime.PLUS || this.tokid == RRDTime.MINUS) { + this.specials = RRDTime.timeMultipliers; /* switch special words context */ + while (this.tokid == RRDTime.PLUS || this.tokid == RRDTime.MINUS || this.tokid == RRDTime.NUMBER) { + if (this.tokid == RRDTime.NUMBER) { + this.plus_minus(-1); + } else { + this.plus_minus(this.tokid); + } + this.gettok(); /* We will get EOF eventually but that's OK, since token() will return us as many EOFs as needed */ + } + } + + /* now we should be at EOF */ + if (this.tokid != RRDTime.EOF) + throw "unparsable trailing text: '..."+this.token+"'"; +// if (this.type == RRDTime.ABSOLUTE_TIME) +// if (mktime(&ptv->tm) == -1) // FIXME ?? +// panic(e("the specified time is incorrect (out of range?)")); + }, + localtime: function (tm) + { + var date = new Date(tm*1000); + this.tm_sec = date.getSeconds(); + this.tm_min = date.getMinutes(); + this.tm_hour = date.getHours(); + this.tm_mday = date.getDate(); + this.tm_mon = date.getMonth(); + this.tm_year = date.getFullYear()-1900; + this.tm_wday = date.getDay(); + }, + mktime: function() + { + var date = new Date(this.tm_year+1900, this.tm_mon, this.tm_mday, this.tm_hour, this.tm_min, this.tm_sec); + return Math.round(date.getTime()/1000.0); + } +} + +RRDTime.proc_start_end = function(start_t, end_t) { + var start, end; + + if (start_t.type == RRDTime.RELATIVE_TO_END_TIME && end_t.type == RRDTime.RELATIVE_TO_START_TIME) + throw "the start and end times cannot be specified relative to each other"; + if (start_t.type == RRDTime.RELATIVE_TO_START_TIME) + throw "the start time cannot be specified relative to itself"; + if (end_t.type == RRDTime.RELATIVE_TO_END_TIME) + throw "the end time cannot be specified relative to itself"; + + if (start_t.type == RRDTime.RELATIVE_TO_END_TIME) { + end = end_t.mktime() + end_t.offset; + var tmtmp = new Date(end*1000); + tmtmp.setDate(tmtmp.getDate()+start_t.tm_mday); + tmtmp.setMonth(tmtmp.getMonth()+start_t.tm_mon); + tmtmp.setFullYear(tmtmp.getFullYear()+start_t.tm_year); + start = Math.round(tmtmp.getTime()/1000.0) + start_t.offset; + } else { + start = start_t.mktime() + start_t.offset; + } + if (end_t.type == RRDTime.RELATIVE_TO_START_TIME) { + start = start_t.mktime() + start_t.offset; + var tmtmp = new Date(start*1000); + tmtmp.setDate(tmtmp.getDate()+end_t.tm_mday); + tmtmp.setMonth(tmtmp.getMonth()+end_t.tm_mon); + tmtmp.setFullYear(tmtmp.getFullYear()+end_t.tm_year); + end = Math.round(tmtmp.getTime()/1000.0) + end_t.offset; + } else { + end = end_t.mktime() + end_t.offset; + } + return [start, end]; +} + +var RRDRpn = function() { + this.parser.apply(this, arguments); +}; + +RRDRpn.OP = { NUMBER: 0, VARIABLE: 1, INF: 2, PREV: 3, NEGINF: 4, + UNKN: 5, NOW: 6, TIME: 7, ADD: 8, MOD: 9, SUB: 10, MUL: 11, + DIV: 12, SIN: 13, DUP: 14, EXC: 15, POP: 16, + COS: 17, LOG: 18, EXP: 19, LT: 20, LE: 21, GT: 22, GE: 23, EQ: 24, IF: 25, + MIN: 26, MAX: 27, LIMIT: 28, FLOOR: 29, CEIL: 30, + UN: 31, END: 32, LTIME: 33, NE: 34, ISINF: 35, PREV_OTHER: 36, COUNT: 37, + ATAN: 38, SQRT: 39, SORT: 40, REV: 41, TREND: 42, TREDNAN: 43, + ATAN2: 44, RAD2DEG: 45, DEG2RAD: 46, + PREDICT: 47, PREDICTSIGMA: 48, AVG: 49, ABS: 50, ADDNAN: 51 }; + +RRDRpn.STACK_UNDERFLOW = 'RPN stack underflow'; + +RRDRpn.prototype = { + + rpnstack: null, + rpnp: null, + + find_var: function(gdes, key) + { + for (var ii = 0, gdes_c = gdes.length; ii < gdes_c; ii++) { + if ((gdes[ii].gf == RRDGraphDesc.GF.DEF || + gdes[ii].gf == RRDGraphDesc.GF.VDEF || + gdes[ii].gf == RRDGraphDesc.GF.CDEF) + && gdes[ii].vname == key) { + return ii; + } + } + return -1; + }, + parser: function (str_expr, gdes) + { + var steps = -1; + var expr; + var exprs = str_expr.split(','); + + this.rpnp = []; + + for(var i=0, len=exprs.length; i < len; i++) { + expr=exprs[i].toUpperCase(); + + steps++; + this.rpnp[steps] = {}; + + if (!isNaN(expr)) { + this.rpnp[steps].op = RRDRpn.OP.NUMBER; + this.rpnp[steps].val = parseFloat(expr); + } + else if (expr === '+') this.rpnp[steps].op = RRDRpn.OP.ADD; + else if (expr === '-') this.rpnp[steps].op = RRDRpn.OP.SUB; + else if (expr === '*') this.rpnp[steps].op = RRDRpn.OP.MUL; + else if (expr === '/') this.rpnp[steps].op = RRDRpn.OP.DIV; + else if (expr === '%') this.rpnp[steps].op = RRDRpn.OP.MOD; + else if (expr === 'SIN') this.rpnp[steps].op = RRDRpn.OP.SIN; + else if (expr === 'COS') this.rpnp[steps].op = RRDRpn.OP.COS; + else if (expr === 'LOG') this.rpnp[steps].op = RRDRpn.OP.LOG; + else if (expr === 'FLOOR') this.rpnp[steps].op = RRDRpn.OP.FLOOR; + else if (expr === 'CEIL') this.rpnp[steps].op = RRDRpn.OP.CEIL; + else if (expr === 'EXP') this.rpnp[steps].op = RRDRpn.OP.EXP; + else if (expr === 'DUP') this.rpnp[steps].op = RRDRpn.OP.DUP; + else if (expr === 'EXC') this.rpnp[steps].op = RRDRpn.OP.EXC; + else if (expr === 'POP') this.rpnp[steps].op = RRDRpn.OP.POP; + else if (expr === 'LTIME') this.rpnp[steps].op = RRDRpn.OP.LTIME; + else if (expr === 'LT') this.rpnp[steps].op = RRDRpn.OP.LT; + else if (expr === 'LE') this.rpnp[steps].op = RRDRpn.OP.LE; + else if (expr === 'GT') this.rpnp[steps].op = RRDRpn.OP.GT; + else if (expr === 'GE') this.rpnp[steps].op = RRDRpn.OP.GE; + else if (expr === 'EQ') this.rpnp[steps].op = RRDRpn.OP.EQ; + else if (expr === 'IF') this.rpnp[steps].op = RRDRpn.OP.IF; + else if (expr === 'MIN') this.rpnp[steps].op = RRDRpn.OP.MIN; + else if (expr === 'MAX') this.rpnp[steps].op = RRDRpn.OP.MAX; + else if (expr === 'LIMIT') this.rpnp[steps].op = RRDRpn.OP.LIMIT; + else if (expr === 'UNKN') this.rpnp[steps].op = RRDRpn.OP.UNKN; + else if (expr === 'UN') this.rpnp[steps].op = RRDRpn.OP.UN; + else if (expr === 'NEGINF') this.rpnp[steps].op = RRDRpn.OP.NEGINF; + else if (expr === 'NE') this.rpnp[steps].op = RRDRpn.OP.NE; + else if (expr === 'COUNT') this.rpnp[steps].op = RRDRpn.OP.COUNT; + else if (/PREV\([-_A-Za-z0-9]+\)/.test(expr)) { + var match = exprs[i].match(/PREV\(([-_A-Za-z0-9]+)\)/i); + if (match.length == 2) { + this.rpnp[steps].op = RRDRpn.OP.PREV_OTHER; + this.rpnp[steps].ptr = this.find_var(gdes, match[1]); // FIXME if -1 + } + } + else if (expr === 'PREV') this.rpnp[steps].op = RRDRpn.OP.PREV; + else if (expr === 'INF') this.rpnp[steps].op = RRDRpn.OP.INF; + else if (expr === 'ISINF') this.rpnp[steps].op = RRDRpn.OP.ISINF; + else if (expr === 'NOW') this.rpnp[steps].op = RRDRpn.OP.NOW; + else if (expr === 'TIME') this.rpnp[steps].op = RRDRpn.OP.TIME; + else if (expr === 'ATAN2') this.rpnp[steps].op = RRDRpn.OP.ATAN2; + else if (expr === 'ATAN') this.rpnp[steps].op = RRDRpn.OP.ATAN; + else if (expr === 'SQRT') this.rpnp[steps].op = RRDRpn.OP.SQRT; + else if (expr === 'SORT') this.rpnp[steps].op = RRDRpn.OP.SORT; + else if (expr === 'REV') this.rpnp[steps].op = RRDRpn.OP.REV; + else if (expr === 'TREND') this.rpnp[steps].op = RRDRpn.OP.TREND; + else if (expr === 'TRENDNAN') this.rpnp[steps].op = RRDRpn.OP.TRENDNAN; + else if (expr === 'PREDICT') this.rpnp[steps].op = RRDRpn.OP.PREDICT; + else if (expr === 'PREDICTSIGMA') this.rpnp[steps].op = RRDRpn.OP.PREDICTSIGMA; + else if (expr === 'RAD2DEG') this.rpnp[steps].op = RRDRpn.OP.RAD2DEG; + else if (expr === 'DEG2RAD') this.rpnp[steps].op = RRDRpn.OP.DEG2RAD; + else if (expr === 'AVG') this.rpnp[steps].op = RRDRpn.OP.AVG; + else if (expr === 'ABS') this.rpnp[steps].op = RRDRpn.OP.ABS; + else if (expr === 'ADDNAN') this.rpnp[steps].op = RRDRpn.OP.ADDNAN; + else if (/[-_A-Za-z0-9]+/.test(expr)) { + this.rpnp[steps].ptr = this.find_var(gdes, exprs[i]); + this.rpnp[steps].op = RRDRpn.OP.VARIABLE; + } else { + return; + } + } + this.rpnp[steps + 1] = {}; + this.rpnp[steps + 1].op = RRDRpn.OP.END; + + }, + compare_double: function(x, y) + { + var diff = x - y; + return (diff < 0) ? -1 : (diff > 0) ? 1 : 0; + }, + fmod: function (x, y) { + var tmp, tmp2, p = 0, + pY = 0, + l = 0.0, + l2 = 0.0; + + tmp = x.toExponential().match(/^.\.?(.*)e(.+)$/); + p = parseInt(tmp[2], 10) - (tmp[1] + '').length; + tmp = y.toExponential().match(/^.\.?(.*)e(.+)$/); + pY = parseInt(tmp[2], 10) - (tmp[1] + '').length; + + if (pY > p) p = pY; + + tmp2 = (x % y); + + if (p < -100 || p > 20) { + l = Math.round(Math.log(tmp2) / Math.log(10)); + l2 = Math.pow(10, l); + return (tmp2 / l2).toFixed(l - p) * l2; + } else { + return parseFloat(tmp2.toFixed(-p)); + } + }, + calc: function (data_idx, output, output_idx) + { + var stptr = -1; + + this.rpnstack = []; + + for (var rpi = 0; this.rpnp[rpi].op != RRDRpn.OP.END; rpi++) { + switch (this.rpnp[rpi].op) { + case RRDRpn.OP.NUMBER: + this.rpnstack[++stptr] = this.rpnp[rpi].val; + break; + case RRDRpn.OP.VARIABLE: + case RRDRpn.OP.PREV_OTHER: + if (this.rpnp[rpi].ds_cnt == 0) { + throw "VDEF made it into rpn_calc... aborting"; + } else { + if (this.rpnp[rpi].op == RRDRpn.OP.VARIABLE) { + this.rpnstack[++stptr] = this.rpnp[rpi].data[this.rpnp[rpi].pdata]; + } else { + if ((output_idx) <= 0) this.rpnstack[++stptr] = Number.NaN; + else this.rpnstack[++stptr] = this.rpnp[rpi].data[this.rpnp[rpi].pdata - this.rpnp[rpi].ds_cnt]; + } + if (data_idx % this.rpnp[rpi].step == 0) { + this.rpnp[rpi].pdata += this.rpnp[rpi].ds_cnt; + } + } + break; + case RRDRpn.OP.COUNT: + this.rpnstack[++stptr] = (output_idx + 1); /* Note: Counter starts at 1 */ + break; + case RRDRpn.OP.PREV: + if ((output_idx) <= 0) this.rpnstack[++stptr] = Number.NaN; + else this.rpnstack[++stptr] = output[output_idx - 1]; + break; + case RRDRpn.OP.UNKN: + this.rpnstack[++stptr] = Number.NaN; + break; + case RRDRpn.OP.INF: + this.rpnstack[++stptr] = Infinity; + break; + case RRDRpn.OP.NEGINF: + this.rpnstack[++stptr] = -Infinity; + break; + case RRDRpn.OP.NOW: + this.rpnstack[++stptr] = Math.round((new Date()).getTime() / 1000); + break; + case RRDRpn.OP.TIME: + this.rpnstack[++stptr] = data_idx; + break; + case RRDRpn.OP.LTIME: + var date = new Date(data_idx*1000); // FIXME XXX + this.rpnstack[++stptr] = date.getTimezoneOffset() * 60 + data_idx; + break; + case RRDRpn.OP.ADD: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr - 1] = this.rpnstack[stptr - 1] + this.rpnstack[stptr]; + stptr--; + break; + case RRDRpn.OP.ADDNAN: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + if (isNaN(this.rpnstack[stptr - 1])) { + this.rpnstack[stptr - 1] = this.rpnstack[stptr]; + } else if (isNaN(this.rpnstack[stptr])) { + /* NOOP */ + /* this.rpnstack[stptr - 1] = this.rpnstack[stptr - 1]; */ + } else { + this.rpnstack[stptr - 1] = this.rpnstack[stptr - 1] + this.rpnstack[stptr]; + } + stptr--; + break; + case RRDRpn.OP.SUB: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr - 1] = this.rpnstack[stptr - 1] - this.rpnstack[stptr]; + stptr--; + break; + case RRDRpn.OP.MUL: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr - 1] = (this.rpnstack[stptr - 1]) * (this.rpnstack[stptr]); + stptr--; + break; + case RRDRpn.OP.DIV: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr - 1] = this.rpnstack[stptr - 1] / this.rpnstack[stptr]; + stptr--; + break; + case RRDRpn.OP.MOD: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr - 1] = this.fmod(this.rpnstack[stptr - 1] , this.rpnstack[stptr]); + stptr--; + break; + case RRDRpn.OP.SIN: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr] = Math.sin(this.rpnstack[stptr]); + break; + case RRDRpn.OP.ATAN: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr] = Math.atan(this.rpnstack[stptr]); + break; + case RRDRpn.OP.RAD2DEG: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr] = 57.29577951 * this.rpnstack[stptr]; + break; + case RRDRpn.OP.DEG2RAD: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr] = 0.0174532952 * this.rpnstack[stptr]; + break; + case RRDRpn.OP.ATAN2: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr - 1] = Math.atan2(this.rpnstack[stptr - 1], this.rpnstack[stptr]); + stptr--; + break; + case RRDRpn.OP.COS: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr] = Math.cos(this.rpnstack[stptr]); + break; + case RRDRpn.OP.CEIL: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr] = Math.ceil(this.rpnstack[stptr]); + break; + case RRDRpn.OP.FLOOR: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr] = Math.floor(this.rpnstack[stptr]); + break; + case RRDRpn.OP.LOG: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr] = Math.log(this.rpnstack[stptr]); + break; + case RRDRpn.OP.DUP: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr + 1] = this.rpnstack[stptr]; + stptr++; + break; + case RRDRpn.OP.POP: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + stptr--; + break; + case RRDRpn.OP.EXC: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; { + var dummy = this.rpnstack[stptr]; + this.rpnstack[stptr] = this.rpnstack[stptr - 1]; + this.rpnstack[stptr - 1] = dummy; + } + break; + case RRDRpn.OP.EXP: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr] = Math.exp(this.rpnstack[stptr]); + break; + case RRDRpn.OP.LT: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + if (isNaN(this.rpnstack[stptr - 1])); + else if (isNaN(this.rpnstack[stptr])) + this.rpnstack[stptr - 1] = this.rpnstack[stptr]; + else + this.rpnstack[stptr - 1] = this.rpnstack[stptr - 1] < this.rpnstack[stptr] ? 1.0 : 0.0; + stptr--; + break; + case RRDRpn.OP.LE: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + if (isNaN(this.rpnstack[stptr - 1])); + else if (isNaN(this.rpnstack[stptr])) + this.rpnstack[stptr - 1] = this.rpnstack[stptr]; + else + this.rpnstack[stptr - 1] = this.rpnstack[stptr - 1] <= this.rpnstack[stptr] ? 1.0 : 0.0; + stptr--; + break; + case RRDRpn.OP.GT: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + if (isNaN(this.rpnstack[stptr - 1])); + else if (isNaN(this.rpnstack[stptr])) + this.rpnstack[stptr - 1] = this.rpnstack[stptr]; + else + this.rpnstack[stptr - 1] = this.rpnstack[stptr - 1] > this.rpnstack[stptr] ? 1.0 : 0.0; + stptr--; + break; + case RRDRpn.OP.GE: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + if (isNaN(this.rpnstack[stptr - 1])); + else if (isNaN(this.rpnstack[stptr])) + this.rpnstack[stptr - 1] = this.rpnstack[stptr]; + else + this.rpnstack[stptr - 1] = this.rpnstack[stptr - 1] >= this.rpnstack[stptr] ? 1.0 : 0.0; + stptr--; + break; + case RRDRpn.OP.NE: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + if (isNaN(this.rpnstack[stptr - 1])); + else if (isNaN(this.rpnstack[stptr])) + this.rpnstack[stptr - 1] = this.rpnstack[stptr]; + else + this.rpnstack[stptr - 1] = this.rpnstack[stptr - 1] == this.rpnstack[stptr] ? 0.0 : 1.0; + stptr--; + break; + case RRDRpn.OP.EQ: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + if (isNaN(this.rpnstack[stptr - 1])); + else if (isNaN(this.rpnstack[stptr])) + this.rpnstack[stptr - 1] = this.rpnstack[stptr]; + else + this.rpnstack[stptr - 1] = this.rpnstack[stptr - 1] == this.rpnstack[stptr] ? 1.0 : 0.0; + stptr--; + break; + case RRDRpn.OP.IF: + if(stptr < 2) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr - 2] = (isNaN(this.rpnstack[stptr - 2]) || this.rpnstack[stptr - 2] == 0.0) ? this.rpnstack[stptr] : this.rpnstack[stptr - 1]; + stptr--; + stptr--; + break; + case RRDRpn.OP.MIN: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + if (isNaN(this.rpnstack[stptr - 1])); + else if (isNaN(this.rpnstack[stptr])) + this.rpnstack[stptr - 1] = this.rpnstack[stptr]; + else if (this.rpnstack[stptr - 1] > this.rpnstack[stptr]) + this.rpnstack[stptr - 1] = this.rpnstack[stptr]; + stptr--; + break; + case RRDRpn.OP.MAX: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + if (isNaN(this.rpnstack[stptr - 1])); + else if (isNaN(this.rpnstack[stptr])) + this.rpnstack[stptr - 1] = this.rpnstack[stptr]; + else if (this.rpnstack[stptr - 1] < this.rpnstack[stptr]) + this.rpnstack[stptr - 1] = this.rpnstack[stptr]; + stptr--; + break; + case RRDRpn.OP.LIMIT: + if(stptr < 2) throw RRDRpn.STACK_UNDERFLOW; + if (isNaN(this.rpnstack[stptr - 2])); + else if (isNaN(this.rpnstack[stptr - 1])) + this.rpnstack[stptr - 2] = this.rpnstack[stptr - 1]; + else if (isNaN(this.rpnstack[stptr])) + this.rpnstack[stptr - 2] = this.rpnstack[stptr]; + else if (this.rpnstack[stptr - 2] < this.rpnstack[stptr - 1]) + this.rpnstack[stptr - 2] = Number.NaN; + else if (this.rpnstack[stptr - 2] > this.rpnstack[stptr]) + this.rpnstack[stptr - 2] = Number.NaN; + stptr -= 2; + break; + case RRDRpn.OP.UN: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr] = isNaN(this.rpnstack[stptr]) ? 1.0 : 0.0; + break; + case RRDRpn.OP.ISINF: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr] = isInfinite(this.rpnstack[stptr]) ? 1.0 : 0.0; + break; + case RRDRpn.OP.SQRT: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr] = Math.sqrt(this.rpnstack[stptr]); + break; + case RRDRpn.OP.SORT: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + var spn = this.rpnstack[stptr--]; + if(stptr < spn - 1) throw RRDRpn.STACK_UNDERFLOW; + var array = this.rpnstack (stptr - spn + 1, stptr +1); + array.sort(this.rpn_compare_double); + for (var i=stptr - spn + 1, ii=0; i < (stptr +1) ; i++, ii++) + this.rpnstack[i] = array[ii]; + // qsort(this.rpnstack + stptr - spn + 1, spn, sizeof(double), rpn_compare_double); + break; + case RRDRpn.OP.REV: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + var spn = this.rpnstack[stptr--]; + if(stptr < spn - 1) throw RRDRpn.STACK_UNDERFLOW; + var array = this.rpnstack (stptr - spn + 1, stptr +1); + array.reverse(); + for (var i=stptr - spn + 1, ii=0; i < (stptr +1) ; i++, ii++) + this.rpnstack[i] = array[ii]; +// var p, q; +// p = this.rpnstack + stptr - spn + 1; +// q = this.rpnstack + stptr; +// while (p < q) { +// var x = q; +// q-- = p; +// p++ = x; +// } + break; + case RRDRpn.OP.PREDICT: + case RRDRpn.OP.PREDICTSIGMA: + if(stptr < 2) throw RRDRpn.STACK_UNDERFLOW; + var locstepsize = this.rpnstack[--stptr]; + var shifts = this.rpnstack[--stptr]; + if(stptr < shifts) throw RRDRpn.STACK_UNDERFLOW; + if (shifts<0) stptr--; + else stptr-=shifts; + var val=Number.NaN; + var dsstep = this.rpnp[rpi - 1].step; + var dscount = this.rpnp[rpi - 1].ds_cnt; + var locstep = Math.ceil(locstepsize/dsstep); + var sum = 0; + var sum2 = 0; + var count = 0; + /* now loop for each position */ + var doshifts=shifts; + if (shifts<0) doshifts=-shifts; + for(var loop=0;loop<doshifts;loop++) { + var shiftstep=1; + if (shifts<0) shiftstep = loop*this.rpnstack[stptr]; + else shiftstep = this.rpnstack[stptr+loop]; + if(shiftstep <0) { + throw "negative shift step not allowed: "+shiftstep; + } + shiftstep=Math.ceil(shiftstep/dsstep); + for(var i=0;i<=locstep;i++) { + var offset=shiftstep+i; + if ((offset>=0)&&(offset<output_idx)) { + val =this.rpnp[rpi - 1].data[-dscount * offset]; + if (! isNaN(val)) { + sum+=val; + sum2+=val*val; + count++; + } + } + } + } + val=Number.NaN; + if (this.rpnp[rpi].op == RRDRpn.OP.PREDICT) { + if (count>0) val = sum/count; + } else { + if (count>1) { + val=count*sum2-sum*sum; + if (val<0) { + val=Number.NaN; + } else { + val=Math.sqrt(val/(count*(count-1.0))); + } + } + } + this.rpnstack[stptr] = val; + break; + case RRDRpn.OP.TREND: + case RRDRpn.OP.TRENDNAN: + if(stptr < 1) throw RRDRpn.STACK_UNDERFLOW; + if ((rpi < 2) || (this.rpnp[rpi - 2].op != RRDRpn.OP.VARIABLE)) { + throw "malformed trend arguments"; + } else { + var dur = this.rpnstack[stptr]; + var step = this.rpnp[rpi - 2].step; + + if (output_idx > Math.ceil(dur / step)) { + var ignorenan = (this.rpnp[rpi].op == RRDRpn.OP.TREND); + var accum = 0.0; + var i = 0; + var count = 0; + + do { + var val = this.rpnp[rpi - 2].data[this.rpnp[rpi - 2].ds_cnt * i--]; + if (ignorenan || !isNaN(val)) { + accum += val; + ++count; + } + dur -= step; + } while (dur > 0); + + this.rpnstack[--stptr] = (count == 0) ? Number.NaN : (accum / count); + } else this.rpnstack[--stptr] = Number.NaN; + } + break; + case RRDRpn.OP.AVG: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + var i = this.rpnstack[stptr--]; + var sum = 0; + var count = 0; + + if(stptr < i - 1) throw RRDRpn.STACK_UNDERFLOW; + while (i > 0) { + var val = this.rpnstack[stptr--]; + i--; + if (isNaN(val)) continue; + count++; + sum += val; + } + if (count > 0) this.rpnstack[++stptr] = sum / count; + else this.rpnstack[++stptr] = Number.NaN; + break; + case RRDRpn.OP.ABS: + if(stptr < 0) throw RRDRpn.STACK_UNDERFLOW; + this.rpnstack[stptr] = fabs(this.rpnstack[stptr]); + break; + case RRDRpn.OP.END: + break; + } + } + if (stptr != 0) throw "RPN final stack size != 1"; + output[output_idx] = this.rpnstack[0]; + return 0; + } +} + +var RRDGraphDesc = function() { + this.init.apply(this, arguments); +}; + +RRDGraphDesc.GF = {PRINT: 0, GPRINT: 1, COMMENT: 2, HRULE: 3, VRULE: 4, LINE: 5, AREA:6, STACK:7, TICK:8, TEXTALIGN:9, DEF:10, CDEF:11, VDEF:12, SHIFT: 13, XPORT: 14 }; + +RRDGraphDesc.VDEF = {MAXIMUM: 0, MINIMUM: 1, AVERAGE: 2, STDEV: 3, PERCENT: 4, TOTAL: 5, FIRST: 6, LAST: 7, LSLSLOPE: 8, LSLINT: 9, LSLCORREL: 10, PERCENTNAN: 11 }; + +RRDGraphDesc.CF = {AVERAGE: 0, MINIMUM: 1, MAXIMUM: 2, LAST: 3, HWPREDICT: 4, SEASONAL: 5, DEVPREDICT: 6, DEVSEASONAL: 7, FAILURES: 8, MHWPREDICT:9 }; +RRDGraphDesc.TXA = {LEFT: 0, RIGHT: 1, CENTER: 2, JUSTIFIED: 3}; + +RRDGraphDesc.prototype = { + + gf: null, /* graphing function */ + stack: false, /* boolean */ + debug: false, /* boolean */ + vname: null, /* name of the variable */ + vidx: Number.NaN, /* gdes reference */ + rrd: null, /* name of the rrd_file containing data */ + ds_nam: null, /* data source name */ + ds: -1, /* data source number */ + cf: null, /* consolidation function */ + cf_reduce: null, /* consolidation function for reduce_data() */ + col: null, /* graph color */ + format: null, /* format for PRINT AND GPRINT */ + legend: null, /* legend */ + strftm: false, /* should the VDEF legend be formated with strftime */ + leg_x: 0, /* location of legend */ + leg_y: 0, + yrule: Number.NaN, /* value for y rule line and for VDEF */ + xrule: 0, /* time for x rule line and for VDEF */ + vf: null, /* instruction for VDEF function */ + rpnp: null, /* instructions for CDEF function */ + + /* SHIFT implementation */ + shidx: 0, /* gdes reference for offset (-1 --> constant) */ + shval: 0, /* offset if shidx is -1 */ + shift: 0, /* current shift applied */ + + /* description of data fetched for the graph element */ + start: 0, /* timestaps for first and last data element */ + end: 0, + start_orig: 0, /* timestaps for first and last data element */ + end_orig: 0, + step: 0, /* time between samples */ + step_orig: 0, /* time between samples */ + ds_cnt: 0, /* how many data sources are there in the fetch */ + data_first: 0, /* first pointer to this data */ + ds_namv: null, /* name of datasources in the fetch. */ + data: null, /* the raw data drawn from the rrd */ + p_data: null, /* processed data, xsize elments */ + linewidth: 0, /* linewideth */ + + /* dashed line stuff */ + dash: false, /* boolean, draw dashed line? */ + p_dashes: null, /* pointer do dash array which keeps the lengths of dashes */ + ndash: false, /* number of dash segments */ + offset: 0, /* dash offset along the line */ + + txtalign: 0, /* change default alignment strategy for text */ + + init: function (graph) + { + this.step = graph.step; + this.step_orig = graph.step; + this.start = graph.start; + this.start_orig = graph.start; + this.end = graph.end; + this.end_orig = graph.end; + this.cf = RRDGraphDesc.CF.AVERAGE; + this.cf_reduce = RRDGraphDesc.CF.AVERAGE; + this.data = []; + this.pdata = []; + this.ds_namv = []; + } +} + +Date.prototype.getWeek = function() { + var onejan = new Date(this.getFullYear(),0,1); + return Math.ceil((((this - onejan) / 86400000) + onejan.getDay()+1)/7); +} + + +var RRDGraph = function() { + this.init.apply(this, arguments); +}; + +RRDGraph.pad2 = function(number) { return (number < 10 ? '0' : '') + number }; +RRDGraph.pad3 = function(number) { return (number < 10 ? '00' : number < 100 ? '0' : '') + number }; +RRDGraph.lpad = function(str, padString, length) { while (str.length < length) str = padString + str; return str; }; +RRDGraph.days = [ 'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat' ]; +RRDGraph.fdays = [ 'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']; +RRDGraph.months = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]; +RRDGraph.fmonths = [ 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']; +RRDGraph.TMT = { SECOND: 0, MINUTE: 1, HOUR: 2, DAY: 3, WEEK: 4, MONTH: 5 , YEAR: 6 }; + +RRDGraph.prototype = { + + xlab: [ {minsec: 0, length: 0, gridtm: RRDGraph.TMT.SECOND, gridst: 30, mgridtm: RRDGraph.TMT.MINUTE, mgridst: 5, labtm: RRDGraph.TMT.MINUTE, labst: 5, precis: 0, stst: function (date) { return RRDGraph.pad2(date.getHours())+':'+RRDGraph.pad2(date.getMinutes()); }} , + {minsec: 2, length: 0, gridtm: RRDGraph.TMT.MINUTE, gridst: 1, mgridtm: RRDGraph.TMT.MINUTE, mgridst: 5, labtm: RRDGraph.TMT.MINUTE, labst: 5, precis: 0, stst: function (date) { return RRDGraph.pad2(date.getHours())+':'+RRDGraph.pad2(date.getMinutes()); }} , + {minsec: 5, length: 0, gridtm: RRDGraph.TMT.MINUTE, gridst: 2, mgridtm: RRDGraph.TMT.MINUTE, mgridst: 10, labtm: RRDGraph.TMT.MINUTE, labst: 10, precis: 0, stst: function (date) { return RRDGraph.pad2(date.getHours())+':'+RRDGraph.pad2(date.getMinutes()); }} , + {minsec: 10, length: 0, gridtm: RRDGraph.TMT.MINUTE, gridst: 5,mgridtm: RRDGraph.TMT.MINUTE, mgridst: 20, labtm: RRDGraph.TMT.MINUTE, labst: 20, precis: 0, stst: function (date) { return RRDGraph.pad2(date.getHours())+':'+RRDGraph.pad2(date.getMinutes()); }} , + {minsec: 30, length: 0, gridtm: RRDGraph.TMT.MINUTE, gridst: 10, mgridtm: RRDGraph.TMT.HOUR, mgridst: 1, labtm: RRDGraph.TMT.HOUR, labst: 1, precis: 0, stst: function (date) { return RRDGraph.pad2(date.getHours())+':'+RRDGraph.pad2(date.getMinutes()); }} , + {minsec: 60, length: 0, gridtm: RRDGraph.TMT.MINUTE, gridst: 30, mgridtm: RRDGraph.TMT.HOUR, mgridst: 2, labtm: RRDGraph.TMT.HOUR, labst: 2, precis: 0, stst: function (date) { return RRDGraph.pad2(date.getHours())+':'+RRDGraph.pad2(date.getMinutes()); }} , + {minsec: 60, length: 24 * 3600, gridtm: RRDGraph.TMT.MINUTE, gridst: 30, mgridtm: RRDGraph.TMT.HOUR, mgridst: 2, labtm: RRDGraph.TMT.HOUR, labst: 6, precis: 0, stst: function (date) { return RRDGraph.days[date.getDay()]+' '+RRDGraph.pad2(date.getHours())+':'+RRDGraph.pad2(date.getMinutes()); }}, + {minsec: 180, length: 0, gridtm: RRDGraph.TMT.HOUR, gridst: 1, mgridtm: RRDGraph.TMT.HOUR, mgridst: 6, labtm: RRDGraph.TMT.HOUR, labst: 6, precis: 0, stst: function (date) { return RRDGraph.pad2(date.getHours())+':'+RRDGraph.pad2(date.getMinutes());}} , + {minsec: 180, length: 24 * 3600, gridtm: RRDGraph.TMT.HOUR, gridst: 1, mgridtm: RRDGraph.TMT.HOUR, mgridst: 6, labtm: RRDGraph.TMT.HOUR, labst: 12, precis: 0, stst: function (date) { return RRDGraph.days[date.getDay()]+' '+RRDGraph.pad2(date.getHours())+':'+RRDGraph.pad2(date.getMinutes());}} , + {minsec: 600, length: 0, gridtm: RRDGraph.TMT.HOUR, gridst: 6, mgridtm: RRDGraph.TMT.DAY, mgridst: 1, labtm: RRDGraph.TMT.DAY, labst: 1, precis: 24 * 3600, stst: function (date) { return RRDGraph.days[date.getDay()];}}, + {minsec: 1200, length: 0, gridtm: RRDGraph.TMT.HOUR, gridst: 6, mgridtm: RRDGraph.TMT.DAY, mgridst: 1, labtm: RRDGraph.TMT.DAY, labst: 1, precis: 24 * 3600, stst: function (date) { return RRDGraph.pad2(date.getDate());}}, + {minsec: 1800, length: 0, gridtm: RRDGraph.TMT.HOUR, gridst: 12, mgridtm: RRDGraph.TMT.DAY, mgridst: 1, labtm: RRDGraph.TMT.DAY, labst: 2, precis: 24 * 3600, stst: function (date) { return RRDGraph.days[date.getDay()]+' '+RRDGraph.pad2(date.getDate());}} , + {minsec: 2400, length: 0, gridtm: RRDGraph.TMT.HOUR, gridst: 12, mgridtm: RRDGraph.TMT.DAY, mgridst: 1, labtm: RRDGraph.TMT.DAY, labst: 2, precis: 24 * 3600,stst: function (date) { return RRDGraph.days[date.getDay()];}} , + {minsec: 3600, length: 0, gridtm: RRDGraph.TMT.DAY, gridst: 1, mgridtm: RRDGraph.TMT.WEEK, mgridst: 1, labtm: RRDGraph.TMT.WEEK, labst: 1, precis: 7 * 24 * 3600, stst: function (date) { return 'Week '+RRDGraph.pad2(date.getWeek());}} , + {minsec: 3 * 3600, length: 0, gridtm: RRDGraph.TMT.WEEK, gridst: 1, mgridtm: RRDGraph.TMT.MONTH, mgridst: 1, labtm: RRDGraph.TMT.WEEK, labst: 2, precis: 7 * 24 * 3600, stst: function (date) { return 'Week '+RRDGraph.pad2(date.getWeek());}} , + {minsec: 6 * 3600, length: 0, gridtm: RRDGraph.TMT.MONTH, gridst: 1, mgridtm: RRDGraph.TMT.MONTH, mgridst: 1, labtm: RRDGraph.TMT.MONTH, labst: 1, precis: 30 * 24 * 3600, stst: function (date) { return RRDGraph.months[date.getMonth()];}} , + {minsec: 48 * 3600,length: 0, gridtm: RRDGraph.TMT.MONTH, gridst: 1, mgridtm: RRDGraph.TMT.MONTH, mgridst: 3, labtm: RRDGraph.TMT.MONTH, labst: 3, precis: 30 * 24 * 3600, stst: function (date) { return RRDGraph.months[date.getMonth()];}} , + {minsec: 315360, length: 0, gridtm: RRDGraph.TMT.MONTH, gridst: 3, mgridtm: RRDGraph.TMT.YEAR, mgridst: 1, labtm: RRDGraph.TMT.YEAR, labst: 1, precis: 365 * 24 * 3600, stst: function (date) { return ''+date.getFullYear();}} , + {minsec: 10 * 24 * 3600 , length: 0, gridtm: RRDGraph.TMT.YEAR, gridst: 1, mgridtm: RRDGraph.TMT.YEAR, mgridst: 1, labtm: RRDGraph.TMT.YEAR, labst: 1, precis: 365 * 24 * 3600, stst: function (date) { return ('' + date.getFullYear()).substr(2, 4);}} , + {minsec: -1, length: 0, gridtm: RRDGraph.TMT.MONTH, gridst: 0, mgridtm: RRDGraph.TMT.MONTH, mgridst: 0, labtm: RRDGraph.TMT.MONTH, labst: 0, precis: 0, stst: null } + ], + + ylab: [ {grid: 0.1, lfac: [1, 2, 5, 10] } , + {grid: 0.2, lfac: [1, 5, 10, 20] } , + {grid: 0.5, lfac: [1, 2, 4, 10] } , + {grid: 1.0, lfac: [1, 2, 5, 10] } , + {grid: 2.0, lfac: [1, 5, 10, 20] } , + {grid: 5.0, lfac: [1, 2, 4, 10] } , + {grid: 10.0, lfac: [1, 2, 5, 10] } , + {grid: 20.0, lfac: [1, 5, 10, 20] } , + {grid: 50.0, lfac: [1, 2, 4, 10] } , + {grid: 100.0, lfac: [1, 2, 5, 10] } , + {grid: 200.0, lfac: [1, 5, 10, 20] } , + {grid: 500.0, lfac: [1, 2, 4, 10] }, + {grid: 0.0, lfac: [0, 0, 0, 0] } + ], + si_symbol: [ + 'a', /* 10e-18 Atto */ + 'f', /* 10e-15 Femto */ + 'p', /* 10e-12 Pico */ + 'n', /* 10e-9 Nano */ + 'u', /* 10e-6 Micro */ + 'm', /* 10e-3 Milli */ + ' ', /* Base */ + 'k', /* 10e3 Kilo */ + 'M', /* 10e6 Mega */ + 'G', /* 10e9 Giga */ + 'T', /* 10e12 Tera */ + 'P', /* 10e15 Peta */ + 'E' /* 10e18 Exa */ + ], + si_symbcenter: 6, + + GRC: null, + + GFX_H: { LEFT: 1, RIGHT: 2, CENTER: 3 }, + GFX_V: { TOP: 1, BOTTOM: 2, CENTER: 3 }, + + DEFAULT_FONT: 'DejaVu Sans Mono', //DejaVu Sans Mono ,Bitstream Vera Sans Mono,monospace,Courier', +// DEFAULT_FONT: 'DejaVuSansMono', //DejaVu Sans Mono ,Bitstream Vera Sans Mono,monospace,Courier', +// pt -> pt=px*72/96 + TEXT: null, + MGRIDWIDTH: 0.6, + GRIDWIDTH: 0.4, + + YLEGEND_ANGLE: 90.0, + + LEGEND_POS: { NORTH: 0, WEST: 1, SOUTH: 2, EAST: 3 }, + LEGEND_DIR: { TOP_DOWN: 0, BOTTOM_UP: 1 }, + + canvas: null, + ctx: null, + xsize: 400, /* graph area size in pixels */ + ysize: 100, + ylegend: null, /* legend along the yaxis */ + title: '', /* title for graph */ + watermark: null, /* watermark for graph */ + draw_x_grid: true, /* no x-grid at all */ + draw_y_grid: true, /* no y-grid at all */ + draw_3d_border: 2, /* size of border in pixels, 0 for off */ + dynamic_labels: false,/* pick the label shape according to the line drawn */ + grid_dash_on: 1, + grid_dash_off: 1, + xlab_form: null, /* format for the label on the xaxis */ + second_axis_scale: 0, /* relative to the first axis (0 to disable) */ + second_axis_shift: 0, /* how much is it shifted vs the first axis */ + second_axis_legend: null, /* label to put on the seond axis */ + second_axis_format: null, /* format for the numbers on the scond axis */ + ygridstep: Number.NaN, /* user defined step for y grid */ + ylabfact: 0, /* every how many y grid shall a label be written ? */ + tabwidth: 40, /* tabwdith */ + start: 0, /* what time does the graph cover */ + start_t: null, + end: 0, + end_t: null, + step: 0, /* any preference for the default step ? */ + setminval: Number.NaN, /* extreme values in the data */ + setmaxval: Number.NaN, + minval: Number.NaN, /* extreme values in the data */ + maxval: Number.NaN, + rigid: false, /* do not expand range even with values outside */ + gridfit: true, /* adjust y-axis range etc so all grindlines falls in integer pixel values */ + lazy: 0, /* only update the image if there is reasonable probablility that the existing one is out of date */ + slopemode: false, /* connect the dots of the curve directly, not using a stair */ + legendposition: 0, /* the position of the legend: north, west, south or east */ + legenddirection: 0, /* The direction of the legend topdown or bottomup */ + logarithmic: false, /* scale the yaxis logarithmic */ + force_scale_min: 0, /* Force a scale--min */ + force_scale_max: 0, /* Force a scale--max */ + /* status information */ + //with_markup: 0, + xorigin: 0, /* where is (0,0) of the graph */ + yorigin: 0, + xOriginTitle: 0, /* where is the origin of the title */ + yOriginTitle: 0, + xOriginLegendY: 0, /* where is the origin of the y legend */ + yOriginLegendY: 0, + xOriginLegendY2: 0, /* where is the origin of the second y legend */ + yOriginLegendY2: 0, + xOriginLegend: 0, /* where is the origin of the legend */ + yOriginLegend: 0, + ximg: 0, /* total size of the image */ + yimg: 0, + legendwidth: 0, /* the calculated height and width of the legend */ + legendheight: 0, + zoom: 1, + magfact: 0, /* numerical magnitude */ + base: 1000, /* 1000 or 1024 depending on what we graph */ + symbol: null, /* magnitude symbol for y-axis */ + viewfactor: 1.0, /* how should the numbers on the y-axis be scaled for viewing ? */ + unitsexponent: 9999, /* 10*exponent for units on y-asis */ + unitslength: 6, /* width of the yaxis labels */ + forceleftspace: false, /* do not kill the space to the left of the y-axis if there is no grid */ + + alt_ygrid: false, /* use alternative y grid algorithm */ + alt_autoscale: false, /* use alternative algorithm to find lower and upper bounds */ + alt_autoscale_min: false, /* use alternative algorithm to find lower bounds */ + alt_autoscale_max: false, /* use alternative algorithm to find upper bounds */ + no_legend: false, /* use no legend */ + no_minor: false, /* Turn off minor gridlines */ + only_graph: false, /* use only graph */ + force_rules_legend: false, /* force printing of HRULE and VRULE legend */ + force_units: false, /* mask for all FORCE_UNITS_* flags */ + force_unit_si: false, /* force use of SI units in Y axis (no effect in linear graph, SI instead of E in log graph) */ + full_size_mode: false, /* -width and -height indicate the total size of the image */ + no_rrdtool_tag: false, /* disable the rrdtool tag */ + + xlab_user: null, + ygrid_scale: null, + + gdes: null, + + ytr_pixie: 0, + xtr_pixie: 0, + + rrdfiles: null, + + init: function (canvasId) + { + this.canvas = document.getElementById(canvasId); + this.ctx = this.canvas.getContext('2d'); + + this.AlmostEqualBuffer = new ArrayBuffer(Float32Array.BYTES_PER_ELEMENT*2); + this.AlmostEqualInt = new Int32Array(this.AlmostEqualBuffer); + this.AlmostEqualFloat = new Float32Array(this.AlmostEqualBuffer); + + this.legenddirection = this.LEGEND_DIR.TOP_DOWN; + this.legendposition = this.LEGEND_POS.SOUTH; + this.gdes = []; + this.rrdfiles = {}; + this.TEXT = { DEFAULT: { size: 11, font: this.DEFAULT_FONT }, + TITLE: { size: 12, font: this.DEFAULT_FONT }, + AXIS: { size: 10, font: this.DEFAULT_FONT }, + UNIT: { size: 11, font: this.DEFAULT_FONT }, + LEGEND: { size: 11, font: this.DEFAULT_FONT }, + WATERMARK: { size: 8, font: this.DEFAULT_FONT } }; + this.GRC = { CANVAS: 'rgba(255, 255, 255, 1.0)', + BACK: 'rgba(242,242, 242, 1.0)', + SHADEA: 'rgba(207, 207, 207, 1.0)', + SHADEB: 'rgba(158, 158, 158, 1.0)', + GRID: 'rgba(143, 143, 143, 0.75)', + MGRID: 'rgba(222, 79, 79, 0.60)', + FONT: 'rgba(0, 0, 0, 1.0)', + ARROW: 'rgba(127, 31, 31, 1.0)', + AXIS: 'rgba(31, 31, 31, 1.0)', + FRAME: 'rgba(0, 0, 0, 1.0)' }; + + + this.start_t = new RRDTime("end-24h"); + this.end_t = new RRDTime("now"); + }, + set_default_font: function (name) + { + for (var font in this.TEXT) + this.TEXT[font].font = name; + }, + set_option: function(option, value) + { + switch(option) { + case 'alt-autoscale': + case 'A': + this.alt_autoscale = true; + break; + case 'base': + case 'b': + this.base = parseInt(value); + if (this.base !== 1000 && this.base !== 1024) + throw 'the only sensible value for base apart from 1000 is 1024'; + break; + case 'color': + case 'c': + var index = value.indexOf('#'); + if (index === -1) + throw "invalid color def format"; + var name = value.substr(0,index); + if (!this.GRC[name]) + throw "invalid color name '"+name+"'" + this.GRC[name] = value.substr(index); // FIXME check color + break; + case 'full-size-mode': + case 'D': + this.full_size_mode = true; + break; + case 'slope-mode': + case 'E': + this.slopemode = true; + break; + case 'end': + case 'e': + this.end_t = new RRDTime(value); +// this.end = parseInt(value); + break; + case 'force-rules-legend': + case 'F': + this.force_rules_legend = true; + break; + case 'imginfo': + case 'f': + // im->imginfo = optarg; + break; + case 'graph-render-mode': + case 'G': + // im->graph_antialias + break; + case 'no-legend': + case 'g': + this.no_legend = true; + break; + case 'height': + case 'h': + this.ysize = parseInt(value); + break; + case 'no-minor': + case 'I': + this.no_minor = false; + break; + case 'interlaced': + case 'i': + break; + case 'alt-autoscale-min': + case 'J': + this.alt_autoscale_min = true; + break; + case 'only-graph': + case 'j': + this.only_graph = true; + break; + case 'units-length': + case 'L': + this.unitslength = parseInt(value); + this.forceleftspace = true; + break; + case 'lower-limit': + case 'l': + this.setminval = parseFloat(value) + break; + case 'alt-autoscale-max': + case 'M': + this.alt_autoscale_max = true; + break; + case 'zoom': + case 'm': + this.zoom = parseFloat(value); + if (this.zoom <= 0.0) + throw "zoom factor must be > 0"; + break; + case 'no-gridfit': + case 'N': + this.gridfit = true; + break; + case 'font': + case 'n': + var args = value.split(':'); + if (args.length !== 3) + throw "invalid text property format"; + if (!this.TEXT[args[0]]) + throw "invalid fonttag '"+args[0]+"'" + if (args[1] > 0) + this.TEXT[args[0]].size = args[1]; + if (args[2]) + this.TEXT[args[0]].font = args[2]; + break; + case 'logarithmic': + case 'o': + this.logarithmic = true; + break; + case 'pango-markup': + case 'P': + // im->with_markup = 1; + break; + case 'font-render-mode': + case 'R': + // im->font_options: normal light mono + break; + case 'rigid': + case 'r': + this.rigid = true; + break; + case 'step': + this.step = parseInt(value); + break; + case 'start': + case 's': + this.start_t = new RRDTime(value); + //this.start = parseInt(value); + break; + case 'tabwidth': + case 'T': + this.tabwidth = parseFloat(value); + break; + case 'title': + case 't': + this.title = value; + break; + case 'upper-limit': + case 'u': + this.setmaxval = parseFloat(value); + break; + case 'vertical-label': + case 'v': + this.ylegend = value; + break; + case 'watermark': + case 'W': + this.watermark = value; + break; + case 'width': + case 'w': + this.xsize = parseInt(value); + if (this.xsize < 10) + throw "width below 10 pixels"; + break; + case 'units-exponent': + case 'X': + this.unitsexponent = parseInt(value); + break; + case 'x-grid': + case 'x': + if (value === 'none') { + this.draw_x_grid = false; + } else { + var args = value.split(':'); + if (args.length !== 8) + throw "invalid x-grid format"; + this.xlab_user.gridtm = this.tmt_conv(args[0]); + if (this.xlab_user.gridtm < 0) + throw "unknown keyword "+args[0]; + this.xlab_user.gridst = parseInt(args[1]); + this.xlab_user.mgridtm = this.tmt_conv(args[2]); + if (this.xlab_user.mgridtm < 2) + throw "unknown keyword "+args[2]; + this.xlab_user.mgridst = parseInt(args[3]); + this.xlab_user.labtm = this.tmt_conv(args[4]); + if (this.xlab_user.labtm < 0) + throw "unknown keyword "+args[4]; + this.xlab_user.labst = parseInt(args[5]); + this.xlab_user.precis = parseInt(args[6]); + this.xlab_user.minsec = 1; + this.xlab_form = args[7]; // FIXME : ? join(:) + this.xlab_user.stst = this.xlab_form; + } + break; + case 'alt-y-grid': + case 'Y': + this.alt_y_grid = true; + break; + case 'y-grid': + case 'y': + if (value === 'none') { + this.draw_y_grid = false; + } else { + var index = value.indexOf(':'); + if (index === -1) + throw "invalid y-grid format"; + this.ygridstep = parseFloat(value.substr(0,index)); + if (this.ygridstep <= 0) + throw "grid step must be > 0"; + this.ylabfact = parseInt(value.substr(index+1)); + if (this.ylabfact < 1) + throw "label factor must be > 0"; + } + break; + case 'lazy': + case 'z': + this.lazy = 1; + break; + case 'units': + if (this.force_units) + throw "--units can only be used once!"; + if (value === 'si') + this.force_units_si = true; + else + throw "invalid argument for --units: "+value; + break; + case 'alt-y-mrtg': + break; + case 'disable-rrdtool-tag': + this.no_rrdtool_tag = true; + break; + case 'right-axis': + var index = value.indexOf(':'); + if (index === -1) + throw "invalid right-axis format expected scale:shift"; + this.second_axis_scale = parseFloat(value.substr(0,index)); + if(this.second_axis_scale === 0) + throw "the second_axis_scale must not be 0"; + this.second_axis_shift = parseFloat(value.substr(index+1)); + break; + case 'right-axis-label': + this.second_axis_legend = value; + break; + case 'right-axis-format': + this.second_axis_format = value; + break; + case 'legend-position': + if (value === "north") { + this.legendposition = this.LEGEND_POS.NORTH; + } else if (value === "west") { + this.legendposition = this.LEGEND_POS.WEST; + } else if (value === "south") { + this.legendposition = this.LEGEND_POS.SOUTH; + } else if (value === "east") { + this.legendposition = this.LEGEND_POS.EAST; + } else { + throw "unknown legend-position '"+value+"'"; + } + break; + case 'legend-direction': + if (value === "topdown") { + this.legenddirection = this.LEGEND_DIR.TOP_DOWN; + } else if (value === "bottomup") { + this.legenddirection = this.LEGEND_DIR.BOTTOM_UP; + } else { + throw "unknown legend-position '"+value+"'"; + } + break; + case 'border': + this.draw_3d_border = parseInt(value); + break; + case 'grid-dash': + var index = value.indexOf(':'); + if (index === -1) + throw "expected grid-dash format float:float"; + this.grid_dash_on = parseFloat(value.substr(0,index)); + this.grid_dash_off = parseFloat(value.substr(index+1)); + break; + case 'dynamic-labels': + this.dynamic_labels = true; + break; + default: + throw 'Unknow option "'+option+'"'; + } + + }, + parse_color: function(str) + { + var bits; + if ((bits = /^#?([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])$/.exec(str))) { + return [parseInt(bits[1]+bits[1], 16), parseInt(bits[2]+bits[2], 16), parseInt(bits[3]+bits[3], 16), 1.0]; + } else if ((bits = /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/.exec(str))) { + return [parseInt(bits[1], 16), parseInt(bits[2], 16), parseInt(bits[3], 16), 1.0]; + } else if ((bits = /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/.exec(str))) { + return [parseInt(bits[1], 16), parseInt(bits[2], 16), parseInt(bits[3], 16), parseInt(bits[4], 16)/255]; + } else if ((bits = /^rgb\((\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\)$/.exec(str))) { + return [parseInt(bits[1]), parseInt(bits[2]), parseInt(bits[3]), 1.0]; + } else if ((bits = /^rgba\((\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*([0-9.]+)\)$/.exec(str))) { + return [parseInt(bits[1]), parseInt(bits[2]), parseInt(bits[3]), parseFloat(bits[4])]; + } else { + throw "Unknow color format '"+str+"'"; + } + }, + color2rgba: function (color) + { + return 'rgba('+color[0]+','+color[1]+','+color[2]+','+color[3]+')'; + }, + cmdline: function(line) // FIXME + { + var i = 0; + line = line.replace(/\n/g," "); + var lines = line.match(/[^" ]+|"[^"]+"/g); + var len = lines.length; + + while (i < len) { + var arg = lines[i]; + if (arg.charAt(0) === '"' && arg.charAt(arg.length-1) === '"') + arg = arg.substr(1,arg.length-2); + if (/^LINE[0-9.]+:/.test(arg)) { + this.parse_line(arg); + } else if (/^AREA:/.test(arg)) { + this.parse_area(arg); + } else if (/^DEF:/.test(arg)) { + this.parse_def(arg); + } else if (/^CDEF:/.test(arg)) { + this.parse_cdef(arg); + } else if (/^VDEF:/.test(arg)) { + this.parse_vdef(arg); + } else if (/^GPRINT:/.test(arg)) { + this.parse_gprint(arg); + } else if (/^COMMENT:/.test(arg)) { + this.parse_comment(arg); + } else if (/^VRULE:/.test(arg)) { + this.parse_vrule(arg); + } else if (/^HRULE:/.test(arg)) { + this.parse_hrule(arg); + } else if (/^TICK:/.test(arg)) { + this.parse_tick(arg); + } else if (/^TEXTALIGN:/.test(arg)) { + this.parse_textaling(arg); + } else if (/^SHIFT:/.test(arg)) { + this.parse_shift(arg); + } else if (arg.charAt(0) === '-') { + var strip = 1; + if (arg.length > 1 && arg.charAt(1) === '-') { + strip = 2; + } + var option = arg.substr(strip); + var value = undefined; + + if (option.indexOf('=') !== -1) { + var index = option.indexOf('='); + value = option.substr(index+1); + option = option.substr(0,index); + } else if (i+1 < len) { + if (lines[i+1].charAt(0) !== '-' && + !/^"?LINE[0-9.]+:/.test(lines[i+1]) && + !/^"?AREA:/.test(lines[i+1]) && + !/^"?DEF:/.test(lines[i+1]) && + !/^"?CDEF:/.test(lines[i+1]) && + !/^"?VDEF:/.test(lines[i+1]) && + !/^"?GPRINT:/.test(lines[i+1]) && + !/^"?COMMENT:/.test(lines[i+1]) && + !/^"?HRULE:/.test(lines[i+1]) && + !/^"?VRULE:/.test(lines[i+1]) && + !/^"?TICK:/.test(lines[i+1]) && + !/^"?TEXTALING:/.test(lines[i+1]) && + !/^"?SHIFT:/.test(lines[i+1]) + ) { + i++; + if (lines[i].charAt(0) === '"' && lines[i].charAt(lines[i].length-1) === '"') + value = lines[i].substr(1,lines[i].length-2); + else + value = lines[i]; + } + } + this.set_option(option, value); + } else { + throw "Unknow argument: "+arg; + } + i++; + } + var start_end = RRDTime.proc_start_end(this.start_t, this.end_t); // FIXME here? + this.start = start_end[0]; + this.end = start_end[1]; + }, + sprintf: function() + { + var argc = 0; + var args = arguments; + var fmt = args[argc++]; + + function format (match, width, dot, precision, length, conversion) + { + if (match === '%%') return '%'; + + var value = args[argc++]; + var prefix; + + if (width === undefined) + width = 0; + else + width = +width; + + if (precision === undefined) + precision = conversion == 'd' ? 0 : 6; + else + precision = +precision; + + switch (conversion) { + case 's': + case 'c': + return value; + break; + case 'd': + return parseInt(value, 10); + break; + case 'e': + prefix = value < 0 ? '-' : ''; + return RRDGraph.lpad(prefix+Math.abs(value).toExponential(precision),' ',width); + break; + case 'f': + prefix = value < 0 ? '-' : ''; + return RRDGraph.lpad(prefix+Math.abs(value).toFixed(precision),' ',width); + break; + case 'g': + prefix = value < 0 ? '-' : ''; + return RRDGraph.lpad(prefix+Math.abs(value).toPrecision(precision),' ',width); + break; + default: + return match; + } + + }; + return fmt.replace(/%(\d+)?(\.(\d+))?(l?)([%scdfeg])/g,format); + }, + strftime: function (ftm, time) + { + var d = new Date(time*1000); + + function format(match, opt) + { + if (match === '%%') return '%'; + + switch (opt) { + case 'a': + return RRDGraph.days[d.getDay()]; + break; + case 'A': + return RRDGraph.fdays[d.getDay()]; + break; + case 'b': + return RRDGraph.months[d.getMonth()]; + break; + case 'B': + return RRDGraph.fmonths[d.getMonth()]; + break; + case 'c': + return d.toLocaleString(); + break; + case 'd': + return RRDGraph.pad2(d.getDate()); + break; + case 'H': + return RRDGraph.pad2(d.getHours()); + break; + case 'I': + var hours = d.getHours()%12; + return RRDGraph.pad2(hours === 0 ? 12 : hours); + break; + case 'j': + var d01 = new Date (date.getFullYear(), 0, 1); + return RRDGraph.pad3(Math.ceil((d01.getTime()-d.getTime())/86400000)); + break; + case 'm': + return RRDGraph.pad2(d.getMonth()); + break; + case 'M': + return RRDGraph.pad2(d.getMinutes()); + break; + case 'p': + return d.getHours() >= 12 ? 'PM' : 'AM'; + break; + case 's': + return RRDGraph.pad2(d.getSeconds()); + break; + case 'S': + return d.getTime()/1000; + break; +//%U The week number of the current year as a decimal number, range 00 to 53, starting with the first Sunday as the first day of week 01. See also %V and %W. + case 'U': + var d01 = new Date(this.getFullYear(),0,1); + return RRDGraph.pad2(Math.ceil((((d.getTime() - d01.getTime()) / 86400000) + d01.getDay()+1)/7)); // FIXME weeks + break; +//%V The ISO 8601:1988 week number of the current year as a decimal number, range 01 to 53, where week 1 is the first week that has at least 4 days in the current year, and with Monday as the first day of the week. See also %U and %W. + case 'V': + var d01 = new Date(this.getFullYear(),0,1); // FIXME weeks + break; +//%W The week number of the current year as a decimal number, range 00 to 53, starting with the first Monday as the first day of week 01. + case 'w': + return d.getDay(); + break; + case 'W': // FIXME weeks + break; + case 'x': + return RRDGraph.pad2(d.getDate())+'/'+RRDGraph.pad2(d.getMonth())+'/'+d.getFullYear() + break; + case 'X': + return RRDGraph.pad2(d.getHours())+':'+RRDGraph.pad2(d.getMinutes())+':'+RRDGraph.pad2(d.getSeconds()); + break; + case 'y': + return RRDGraph.pad2(d.getFullYear()%100); + break; + case 'Y': + return d.getFullYear(); + break; + case 'Z': + return d.toString().replace(/^.*\(([^)]+)\)$/, '$1'); + break; + default: + return match; + } + }; + return fmt.replace(/%([aAbBcdHIjmMpsSUVwWxXyYZ%])/g, format); + }, + gfx_line: function (X0, Y0, X1, Y1, width, color) + { + X0 = Math.round(X0); + Y0 = Math.round(Y0); + X1 = Math.round(X1); + Y1 = Math.round(Y1); + + if (Y0 === Y1) { + Y0 += 0.5; + Y1 += 0.5; + } else if (X0 === X1) { + X0 += 0.5; + X1 += 0.5; + } + + this.ctx.save(); + this.ctx.lineWidth = width; + this.ctx.strokeStyle = color + this.ctx.beginPath(); + this.ctx.moveTo(X0, Y0); + this.ctx.lineTo(X1, Y1); + this.ctx.stroke(); + this.ctx.restore(); + }, + gfx_dashed_line: function (X0, Y0, X1, Y1, width, color, dash_on, dash_off) + { + X0 = Math.round(X0); + Y0 = Math.round(Y0); + X1 = Math.round(X1); + Y1 = Math.round(Y1); + + this.ctx.save(); + this.ctx.lineWidth = width; + this.ctx.strokeStyle = color; + + this.ctx.beginPath(); + if (Y0 === Y1) { + Y0 += 0.5; + Y1 += 0.5; + if (X0 > X1) { + var swap = X0; + X0 = X1; + X1 = swap; + } + this.ctx.moveTo(X0, Y0); + var n=0; + while(X0<=X1) { + if (n%2 === 1) { + X0 += dash_on; + this.ctx.lineTo(X0, Y0); + } else { + X0 += dash_off; + this.ctx.moveTo(X0, Y0); + } + n++; + } + } else if (X0 === X1) { + X0 += 0.5; + X1 += 0.5; + if (Y0 > Y1) { + var swap = Y0; + Y0 = Y1; + Y1 = swap; + } + this.ctx.moveTo(X0, Y0); + var n=0; + while(Y0<=Y1) { + if (n%2 === 1) { + Y0 += dash_on; + this.ctx.lineTo(X0, Y0); + } else { + Y0 += dash_off; + this.ctx.moveTo(X0, Y0); + } + n++; + } + + } else { + this.ctx.moveTo(X0, Y0); + this.ctx.lineTo(X1, Y1); + } + this.ctx.stroke(); + this.ctx.restore(); + }, + gfx_new_area: function (X0, Y0, X1, Y1, X2, Y2, color) + { + X0 = Math.round(X0)+0.5; + Y0 = Math.round(Y0)+0.5; + X1 = Math.round(X1)+0.5; + Y1 = Math.round(Y1)+0.5; + X2 = Math.round(X2)+0.5; + Y2 = Math.round(Y2)+0.5; + this.ctx.fillStyle = color; + this.ctx.beginPath(); + this.ctx.moveTo(X0, Y0); + this.ctx.lineTo(X1, Y1); + this.ctx.lineTo(X2, Y2); + }, + gfx_add_point: function (x, y) + { + this.ctx.lineTo(x, y); + }, + gfx_close_path: function () + { + this.ctx.closePath(); + this.ctx.fill(); + }, + gfx_text: function (x, y, color, font, tabwidth, angle, h_align, v_align, text) + { + x = Math.round(x); + y = Math.round(y); + + this.ctx.save(); + this.ctx.font = font.size+'px '+"'"+font.font+"'"; + + switch (h_align) { + case this.GFX_H.LEFT: + this.ctx.textAlign = 'left'; + break; + case this.GFX_H.RIGHT: + this.ctx.textAlign = 'right'; + break; + case this.GFX_H.CENTER: + this.ctx.textAlign = 'center'; + break; + } + + switch (v_align) { + case this.GFX_V.TOP: + this.ctx.textBaseline = 'top'; + break; + case this.GFX_V.BOTTOM: + this.ctx.textBaseline = 'bottom'; + break; + case this.GFX_V.CENTER: + this.ctx.textBaseline = 'middle'; + break; + } + + this.ctx.fillStyle = color; + this.ctx.translate(x,y); + this.ctx.rotate(-angle*Math.PI/180.0); + this.ctx.fillText(text, 0, 0); + this.ctx.restore(); + }, + gfx_get_text_width: function( start, font, tabwidth, text) + { + this.ctx.save(); + this.ctx.font = font.size+"px "+font.font; + var width = this.ctx.measureText(text); + this.ctx.restore(); + return width.width; + }, + xtr: function (mytime) + { + if (mytime === 0) { + this.xtr_pixie = this.xsize / (this.end - this.start); + return this.xorigin; + } + return this.xorigin + this.xtr_pixie * (mytime - this.start); + }, + ytr: function (value) + { + var yval; + + if (isNaN(value)) { + if (!this.logarithmic) + this.ytr_pixie = this.ysize / (this.maxval - this.minval); + else + this.ytr_pixie = this.ysize / ((Math.log(this.maxval)/Math.LN10) - (Math.log(this.minval)/Math.LN10)); + yval = this.yorigin; + } else if (!this.logarithmic) { + yval = this.yorigin - this.ytr_pixie * (value - this.minval); + } else { + if (value < this.minval) { + yval = this.yorigin; + } else { + yval = this.yorigin - this.ytr_pixie * ((Math.log(value)/Math.LN10) - (Math.log(this.minval)/Math.LN10)); + } + } + return yval; + }, + // http://stackoverflow.com/questions/3077718/converting-a-decimal-value-to-a-32bit-floating-point-hexadecimal + floatToIntBits: function (f) + { + var NAN_BITS = 0|0x7FC00000; + var INF_BITS = 0|0x7F800000; + var ZERO_BITS = 0|0x00000000; + var SIGN_MASK = 0|0x80000000; + var EXP_MASK = 0|0x7F800000; + var MANT_MASK = 0|0x007FFFFF; + var MANT_MAX = Math.pow(2.0, 23) - 1.0; + + if (f != f) + return NAN_BITS; + var hasSign = f < 0.0 || (f == 0.0 && 1.0 / f < 0); + var signBits = hasSign ? SIGN_MASK : 0; + var fabs = Math.abs(f); + + if (fabs == Number.POSITIVE_INFINITY) + return signBits | INF_BITS; + + var exp = 0, x = fabs; + while (x >= 2.0 && exp <= 127) { + exp++; + x /= 2.0; + } + while (x < 1.0 && exp >= -126) { + exp--; + x *= 2.0; + } + if (!(x * Math.pow(2.0, exp) == fabs)) throw "floatToIntBits: error fabs."; + var biasedExp = exp + 127; + if (!(0 <= biasedExp && biasedExp <= 254)) throw "floatToIntBits: error biasedExp "+biasedExp; + + if (biasedExp == 255) + return signBit | INF_BITS; + if (biasedExp == 0) { + if (!(0.0 <= x && x < 2.0)) throw "floatToIntBits: x in [0.0, 1.0) "+x; + var mantissa = x * Math.pow(2.0, 23) / 2.0; + } else { + if (!(1.0 <= x && x < 2.0)) throw "floatToIntBits: x in [0.5; 1.0) "+x; + var mantissa = x * Math.pow(2.0, 23) - Math.pow(2.0, 23); + } + var mantissaBits = mantissa & MANT_MASK; + if (!(0.0 <= mantissaBits && mantissaBits <= MANT_MAX)) throw "floatToIntBits: mantissa in [0.0, 2^23) "+mantissa+" MANT_MAX "+MANT_MAX+" "+(mantissa & MANT_MASK); + + //console.log("number", f, "x", x, "biasedExp", biasedExp, "mantissa", mantissa.toString(16)); + var expBits = (biasedExp << 23) & EXP_MASK; + + //console.log("number", f, "sign", signBits.toString(16), "expBits", expBits.toString(16), "mantissaBits", mantissaBits.toString(16)); + return signBits | expBits | mantissaBits; + }, +/* + AlmostEqual2sComplement: function(A, B, maxUlps) + { + var aInt = this.floatToIntBits(A); + if (aInt < 0) aInt = 0x80000000 - aInt; + + var bInt = this.floatToIntBits(B); + if (bInt < 0) bInt = 0x80000000 - bInt; + + var intDiff = Math.abs(aInt - bInt); + + if (intDiff <= maxUlps) + return true; + + return false; + }, +*/ + AlmostEqual2sComplement: function(A, B, maxUlps) + { + + this.AlmostEqualFloat[0] = A; + this.AlmostEqualFloat[1] = B; + + var aInt = this.AlmostEqualInt[0]; + if (aInt < 0) aInt = 0x80000000 - aInt; + + var bInt = this.AlmostEqualInt[1]; + if (bInt < 0) bInt = 0x80000000 - bInt; + + var intDiff = Math.abs(aInt - bInt); + + if (intDiff <= maxUlps) + return true; + + return false; + }, +/* +//AlmostEqualRelative +//AlmostEqualRelativeOrAbsolute + AlmostEqual2sComplement: function(A, B, error) // FIXME may not work, maxUpls??? + { + error = 0.00001 + + if (A == B) + return true; + + var relerror; + if (Math.abs(B) > Math.abs(A)) + relerror = Math.abs((A - B) / B); + else + relerror = Math.abs((A - B) / A); + + if (relerror <= error) + return true; +//console.log("AlmostEqual2sComplement("+A+","+B+"): Math.abs(A - B):"+(Math.abs(A - B))+" < "+maxUlps+" relativeError: "+error); + return false; + }, +*/ + tmt2str: function (val) + { + switch (val) { + case RRDGraph.TMT.SECOND: return 'sec'; + case RRDGraph.TMT.MINUTE: return 'min'; + case RRDGraph.TMT.HOUR: return 'hour'; + case RRDGraph.TMT.DAY: return 'day'; + case RRDGraph.TMT.WEEK: return 'week'; + case RRDGraph.TMT.MONTH: return 'mon'; + case RRDGraph.TMT.YEAR: return 'year'; + } + return val; + }, + find_first_time: function(start, baseint, basestep) + { + var date = new Date(start*1000); + + switch (baseint) { + case RRDGraph.TMT.SECOND: + var sec = date.getSeconds(); + sec -= sec % basestep; + date.setSeconds(sec); + break; + case RRDGraph.TMT.MINUTE: + date.setSeconds(0); + var min = date.getMinutes(); + min -= min % basestep; + date.setMinutes(min); + break; + case RRDGraph.TMT.HOUR: + date.setSeconds(0); + date.setMinutes(0); + var hour = date.getHours(); + hour -= hour % basestep; + date.setHours(hour); + break; + case RRDGraph.TMT.DAY: + date.setSeconds(0); + date.setMinutes(0); + date.setHours(0); + break; + case RRDGraph.TMT.WEEK: + date.setSeconds(0); + date.setMinutes(0); + date.setHours(0); + var mday = date.getDate(); + var wday = date.getDay(); + mday -= wday - 1; // FIXME find_first_weekday + if (wday === 0) mday -= 7;// FIXME find_first_weekday + date.setDate(mday); + break; + case RRDGraph.TMT.MONTH: + date.setSeconds(0); + date.setMinutes(0); + date.setHours(0); + date.setDate(1); + var mon = date.getMonth(); + mon -= mon % basestep; + date.setMonth(mon); + break; + case RRDGraph.TMT.YEAR: + date.setSeconds(0); + date.setMinutes(0); + date.setHours(0); + date.setDate(1); + date.setMonth(0); + var year = date.getFullYear()-1900; + year -= (year + 1900) %basestep; + date.setFullYear(year+1900); + } + return Math.round(date.getTime()/1000.0); + }, + find_next_time: function(current, baseint, basestep) + { + var date = new Date(current*1000); + var limit = 2; + var madetime; + + switch (baseint) { + case RRDGraph.TMT.SECOND: limit = 7200; break; + case RRDGraph.TMT.MINUTE: limit = 120; break; + case RRDGraph.TMT.HOUR: limit = 2; break; + default: limit = 2; break; + } + + do { + switch (baseint) { + case RRDGraph.TMT.SECOND: + date.setSeconds(date.getSeconds()+basestep); + break; + case RRDGraph.TMT.MINUTE: + date.setMinutes(date.getMinutes()+basestep); + break; + case RRDGraph.TMT.HOUR: + date.setHours(date.getHours()+basestep); + break; + case RRDGraph.TMT.DAY: + date.setDate(date.getDate()+basestep); + break; + case RRDGraph.TMT.WEEK: + date.setDate(date.getDate()+7*basestep); + break; + case RRDGraph.TMT.MONTH: + date.setMonth(date.getMonth()+basestep); + break; + case RRDGraph.TMT.YEAR: + date.setFullYear(date.getFullYear()+basestep); + break; + } + madetime = Math.round(date.getTime()/1000.0); + } while (madetime === -1 && limit-- >= 0); /* this is necessary to skip impossible times like the daylight saving time skips */ // FIXME ?? + return madetime; + }, + print_calc: function() + { + var validsteps; + var printval; + var tmvdef; + var graphelement = 0; + var max_ii; + var magfact = -1; + var si_symb = ""; + var percent_s; + var prline_cnt = 0; + + var now = Math.round((new Date()).getTime() / 1000); + + for (var i = 0, gdes_c = this.gdes.length; i < gdes_c; i++) { + var vidx = this.gdes[i].vidx; + switch (this.gdes[i].gf) { + case RRDGraphDesc.GF.PRINT: + case RRDGraphDesc.GF.GPRINT: + if (this.gdes[vidx].gf === RRDGraphDesc.CF.VDEF) { /* simply use vals */ + printval = this.gdes[vidx].vf.val; + tmvdef = this.gdes[vidx].vf.when; + // localtime_r(&this.gdes[vidx].vf.when, &tmvdef); // FIXME ? + } else { /* need to calculate max,min,avg etcetera */ + max_ii = ((this.gdes[vidx].end - this.gdes[vidx].start) / this.gdes[vidx].step * this.gdes[vidx].ds_cnt); + printval = Number.NaN; + validsteps = 0; + + for (var ii = this.gdes[vidx].ds; ii < max_ii; ii += this.gdes[vidx].ds_cnt) { + if (!isFinite(this.gdes[vidx].data[ii])) continue; + if (isNaN(printval)) { + printval = this.gdes[vidx].data[ii]; + validsteps++; + continue; + } + switch (this.gdes[i].cf) { + case RRDGraphDesc.CF.HWPREDICT: + case RRDGraphDesc.CF.MHWPREDICT: + case RRDGraphDesc.CF.DEVPREDICT: + case RRDGraphDesc.CF.DEVSEASONAL: + case RRDGraphDesc.CF.SEASONAL: + case RRDGraphDesc.CF.AVERAGE: + validsteps++; + printval += this.gdes[vidx].data[ii]; + break; + case RRDGraphDesc.CF.MINIMUM: + printval = Math.min(printval, this.gdes[vidx].data[ii]); + break; + case RRDGraphDesc.CF.FAILURES: + case RRDGraphDesc.CF.MAXIMUM: + printval = Math.max(printval, this.gdes[vidx].data[ii]); + break; + case RRDGraphDesc.CF.LAST: + printval = this.gdes[vidx].data[ii]; + } + } + if (this.gdes[i].cf === RRDGraphDesc.CF.AVERAGE || this.gdes[i].cf > RRDGraphDesc.CF.LAST) { + if (validsteps > 1) printval = (printval / validsteps); + } + } /* prepare printval */ + + if (!this.gdes[i].strftm && (percent_s = this.gdes[i].format.indexOf('%S')) != -1) { + if (magfact < 0.0) { + //[printval, si_symb, magfact] = this.auto_scale(printval, si_symb, magfact); + var dummy = this.auto_scale(printval, si_symb, magfact); printval = dummy[0]; si_symb = dummy[1]; magfact = dummy[2]; + if (printval === 0.0) magfact = -1.0; + } else { + printval /= magfact; + } + this.gdes[i].format = this.gdes[i].format.substr(0, percent_s+1)+'s'+this.gdes[i].format.substr(percent_s+2); + } else if (!this.gdes[i].strftm && this.gdes[i].format.indexOf('%s') != -1) { + //[printval, si_symb, magfact] = this.auto_scale(printval, si_symb, magfact); + var dummy = this.auto_scale(printval, si_symb, magfact); printval = dummy[0]; si_symb = dummy[1]; magfact = dummy[2]; + + } + +// if (this.gdes[i].gf === RRDGraphDesc.GF.PRINT) { +// var prline; +// +// if (this.gdes[i].strftm) { +// var date = new Date(tmvdef*1000); +// prline.u_str = date.strftime(this.gdes[i].format); +// } else { +// prline.u_str = sprintf(this.gdes[i].format, printval, si_symb); +// } +// grinfo_push(im, sprintf_alloc ("print[%ld]", prline_cnt++), RD_I_STR, prline); // FIXME +// } else { + if (this.gdes[i].strftm) { + this.gdes[i].legend = this.strftime(this.gdes[i].format, tmvdef); + } else { + this.gdes[i].legend = this.sprintf(this.gdes[i].format, printval, si_symb); + } + graphelement = 1; +// } + break; + case RRDGraphDesc.GF.LINE: + case RRDGraphDesc.GF.AREA: + case RRDGraphDesc.GF.TICK: + graphelement = 1; + break; + case RRDGraphDesc.GF.HRULE: + if (isNaN(this.gdes[i].yrule)) { /* we must set this here or the legend printer can not decide to print the legend */ + this.gdes[i].yrule = this.gdes[vidx].vf.val; + }; + graphelement = 1; + break; + case RRDGraphDesc.GF.VRULE: + if (this.gdes[i].xrule === 0) { /* again ... the legend printer needs it */ + this.gdes[i].xrule = this.gdes[vidx].vf.when; + }; + graphelement = 1; + break; + case RRDGraphDesc.GF.COMMENT: + case RRDGraphDesc.GF.TEXTALIGN: + case RRDGraphDesc.GF.DEF: + case RRDGraphDesc.GF.CDEF: + case RRDGraphDesc.GF.VDEF: + case RRDGraphDesc.GF.SHIFT: + case RRDGraphDesc.GF.XPORT: + break; + case RRDGraphDesc.GF.STACK: + throw "STACK should already be turned into LINE or AREA here"; + break; + } + } + return graphelement; + }, + reduce_data: function(gdes, cur_step) + { + var reduce_factor = Math.ceil(gdes.step / cur_step); + var col, dst_row, row_cnt, start_offset, end_offset, skiprows = 0; + var srcptr, dstptr; + + gdes.step = cur_step * gdes.reduce_factor; /* set new step size for reduced data */ + dstptr = 0; + srcptr = 0; + row_cnt = (gdes.end - gdes.start) / cur_step; + + end_offset = gdes.end % gdes.step; + start_offset = gdes.start % gdes.step; + + if (start_offset) { + gdes.start = gdes.start - start_offset; + skiprows = reduce_factor - start_offset / cur_step; + srcptr += skiprows * gdes.ds_cnt; + for (col = 0; col < gdes.ds_cnt; col++) + gdes.data[dstptr++] = Number.NaN; + row_cnt -= skiprows; + } + + if (end_offset) { + gdes.end = gdes.end - end_offset + gdes.step; + skiprows = end_offset / cur_step; + row_cnt -= skiprows; + } + + if (row_cnt % reduce_factor) { + throw "BUG in reduce_data(), SANITY CHECK: "+row_cnt+" rows cannot be reduced by "+reduce_factor; + } + + for (dst_row = 0; row_cnt >= reduce_factor; dst_row++) { + for (col = 0; col < gdes.ds_cnt; col++) { + var newval = Number.NaN; + var validval = 0; + + for (i = 0; i < reduce_factor; i++) { + if (isNaN(gdes.data[srcptr + i*gdes.ds_cnt + col])) continue; + validval++; + if (isNaN(newval)) + newval = gdes.data[srcptr + i * gdes.ds_cnt + col]; + else { + switch (gdes.cf_reduce) { + case RRDGraphDesc.CF.HWPREDICT: + case RRDGraphDesc.CF.MHWPREDICT: + case RRDGraphDesc.CF.DEVSEASONAL: + case RRDGraphDesc.CF.DEVPREDICT: + case RRDGraphDesc.CF.SEASONAL: + case RRDGraphDesc.CF.AVERAGE: + newval += gdes.data[srcptr + i*gdes.ds_cnt + col]; + break; + case RRDGraphDesc.CF.MINIMUM: + newval = Math.min(newval, gdes.data[srcptr + i*gdes.ds_cnt + col]); + break; + case RRDGraphDesc.CF.FAILURES: + /* an interval contains a failure if any subintervals contained a failure */ + case RRDGraphDesc.CF.MAXIMUM: + newval = Math.max(newval, gdes.data[srcptr + i*gdes.ds_cnt + col]); + break; + case RRDGraphDesc.CF.LAST: + newval = gdes.data[srcptr + i*gdes.ds_cnt + col]; + break; + } + } + } + if (validval === 0) { + newval = Number.NaN; + } else { + switch (gdes.cf_reduce) { + case RRDGraphDesc.CF.HWPREDICT: + case RRDGraphDesc.CF.MHWPREDICT: + case RRDGraphDesc.CF.DEVSEASONAL: + case RRDGraphDesc.CF.DEVPREDICT: + case RRDGraphDesc.CF.SEASONAL: + case RRDGraphDesc.CF.AVERAGE: + newval /= validval; + break; + case RRDGraphDesc.CF.MINIMUM: + case RRDGraphDesc.CF.FAILURES: + case RRDGraphDesc.CF.MAXIMUM: + case RRDGraphDesc.CF.LAST: + break; + } + } + gdes.data[dstptr++] = newval; + } + srcptr += gdes.ds_cnt * reduce_factor; + row_cnt -= reduce_factor; + } + if (end_offset) + for (col = 0; col < gdes.ds_cnt; col++) + gdes.data[dstptr++] = Number.NaN; + }, + data_fetch: function() + { + var skip; + + for (var i = 0, gdes_c = this.gdes.length; i < gdes_c; i++) { + if (this.gdes[i].gf != RRDGraphDesc.GF.DEF) continue; + + skip = false; + for (var ii = 0; ii < i; ii++) { + if (this.gdes[ii].gf != RRDGraphDesc.GF.DEF) continue; + if ((this.gdes[i].rrd === this.gdes[ii].rrd) + && (this.gdes[i].cf === this.gdes[ii].cf) + && (this.gdes[i].cf_reduce === this.gdes[ii].cf_reduce) + && (this.gdes[i].start_orig === this.gdes[ii].start_orig) + && (this.gdes[i].end_orig === this.gdes[ii].end_orig) + && (this.gdes[i].step_orig === this.gdes[ii].step_orig)) { + this.gdes[i].start = this.gdes[ii].start; + this.gdes[i].end = this.gdes[ii].end; + this.gdes[i].step = this.gdes[ii].step; + this.gdes[i].ds_cnt = this.gdes[ii].ds_cnt; + this.gdes[i].ds_namv = this.gdes[ii].ds_namv; + this.gdes[i].data = this.gdes[ii].data; + this.gdes[i].data_first = 0; + skip = true; + } + if (skip) break; + } + + if (!skip) { + var ft_step = this.gdes[i].step; /* ft_step will record what we got from fetch */ + ft_step = this.rrd_fetch(this.gdes[i], ft_step); + if (ft_step < 0) + return -1; + this.gdes[i].data_first = 1; + if (ft_step < this.gdes[i].step) { + this.reduce_data(this.gdes[i], ft_step); + } else { + this.gdes[i].step = ft_step; + } + } + /* lets see if the required data source is really there */ + for (var ii = 0; ii < this.gdes[i].ds_cnt; ii++) { + if (this.gdes[i].ds_namv[ii] === this.gdes[i].ds_nam) { + this.gdes[i].ds = ii; + break; + } + } + + if (this.gdes[i].ds === -1) + throw "No DS called '"+this.gdes[i].ds_nam+"' in '"+this.gdes[i].rrd+"'"; + } + + return 0; + }, + lcd: function (num) + { + var rest; + for (var i = 0; num[i + 1] != 0; i++) { + do { + rest = num[i] % num[i + 1]; + num[i] = num[i + 1]; + num[i + 1] = rest; + } while (rest != 0); // FIXME infinite loop ? + num[i + 1] = num[i]; + } + return num[i]; + }, + data_calc: function() + { + var dataidx; + var now; + + var rpnstack; + + for (var gdi = 0, gdes_c = this.gdes.length; gdi < gdes_c; gdi++) { + switch (this.gdes[gdi].gf) { + case RRDGraphDesc.GF.XPORT: + break; + case RRDGraphDesc.GF.SHIFT: + var vdp = this.gdes[this.gdes[gdi].vidx]; + /* remove current shift */ + vdp.start -= vdp.shift; + vdp.end -= vdp.shift; + + if (this.gdes[gdi].shidx >= 0) vdp.shift = this.gdes[this.gdes[gdi].shidx].vf.val; + else vdp.shift = this.gdes[gdi].shval; + + vdp.shift = (vdp.shift / vdp.step) * vdp.step; + + vdp.start += vdp.shift; + vdp.end += vdp.shift; + break; + case RRDGraphDesc.GF.VDEF: + this.gdes[gdi].ds_cnt = 0; + if (this.vdef_calc(gdi)) + throw "Error processing VDEF '"+this.gdes[gdi].vname+"%s'"; + break; + case RRDGraphDesc.GF.CDEF: + this.gdes[gdi].ds_cnt = 1; + this.gdes[gdi].ds = 0; + this.gdes[gdi].data_first = 1; + this.gdes[gdi].start = 0; + this.gdes[gdi].end = 0; + var steparray = []; + var stepcnt = 0; + dataidx = -1; + + var rpnp = this.gdes[gdi].rpnp.rpnp; + for (var rpi = 0; rpnp[rpi].op != RRDRpn.OP.END; rpi++) { + if (rpnp[rpi].op === RRDRpn.OP.VARIABLE || rpnp[rpi].op === RRDRpn.OP.PREV_OTHER) { + var ptr = rpnp[rpi].ptr; + if (this.gdes[ptr].ds_cnt === 0) { /* this is a VDEF data source */ + rpnp[rpi].val = this.gdes[ptr].vf.val; + rpnp[rpi].op = RRDRpn.OP.NUMBER; + } else { /* normal variables and PREF(variables) */ + ++stepcnt; + steparray[stepcnt - 1] = this.gdes[ptr].step; + + if (this.gdes[gdi].start < this.gdes[ptr].start) + this.gdes[gdi].start = this.gdes[ptr].start; + if (this.gdes[gdi].end === 0 || this.gdes[gdi].end > this.gdes[ptr].end) + this.gdes[gdi].end = this.gdes[ptr].end; + + rpnp[rpi].data = this.gdes[ptr].data; + rpnp[rpi].pdata = this.gdes[ptr].ds; + rpnp[rpi].step = this.gdes[ptr].step; + rpnp[rpi].ds_cnt = this.gdes[ptr].ds_cnt; + } + } + } + /* move the data pointers to the correct period */ + for (var rpi = 0; rpnp[rpi].op != RRDRpn.OP.END; rpi++) { + if (rpnp[rpi].op === RRDRpn.OP.VARIABLE || rpnp[rpi].op === RRDRpn.OP.PREV_OTHER) { + var ptr = rpnp[rpi].ptr; + var diff = this.gdes[gdi].start - this.gdes[ptr].start; + + if (diff > 0) rpnp[rpi].pdata += (diff / this.gdes[ptr].step) * this.gdes[ptr].ds_cnt; + } + } + + if (steparray === null) { + throw "rpn expressions without DEF or CDEF variables are not supported"; + } + steparray[stepcnt] = 0; + this.gdes[gdi].step = this.lcd(steparray); + this.gdes[gdi].data = []; + + for (now = this.gdes[gdi].start + this.gdes[gdi].step; now <= this.gdes[gdi].end; now += this.gdes[gdi].step) { + if (this.gdes[gdi].rpnp.calc(now, this.gdes[gdi].data, ++dataidx) === -1) + return -1; + } + break; + default: + continue; + } + } + return 0; + }, + data_proc: function() + { + var pixstep = (this.end - this.start) / this.xsize; + var paintval; + var minval = Number.NaN, maxval = Number.NaN; + var gr_time; + + /* memory for the processed data */ + + for (var i = 0, gdes_c = this.gdes.length; i < gdes_c; i++) { + if ((this.gdes[i].gf === RRDGraphDesc.GF.LINE) || (this.gdes[i].gf === RRDGraphDesc.GF.AREA) || (this.gdes[i].gf === RRDGraphDesc.GF.TICK)) { + this.gdes[i].p_data = []; + } + } + + for (var i = 0; i < this.xsize; i++) { /* for each pixel */ + var vidx; + gr_time = this.start + pixstep * i; /* time of the current step */ + paintval = 0.0; + + for (var ii = 0 , gdes_c = this.gdes.length; ii < gdes_c; ii++) { + var value; + switch (this.gdes[ii].gf) { + case RRDGraphDesc.GF.LINE: + case RRDGraphDesc.GF.AREA: + case RRDGraphDesc.GF.TICK: + if (!this.gdes[ii].stack) paintval = 0.0; + value = this.gdes[ii].yrule; + if (isNaN(value) || (this.gdes[ii].gf === RRDGraphDesc.GF.TICK)) { + vidx = this.gdes[ii].vidx; + if (this.gdes[vidx].gf === RRDGraphDesc.GF.VDEF) { + value = this.gdes[vidx].vf.val; + } else if (gr_time >= this.gdes[vidx].start && gr_time < this.gdes[vidx].end) { + value = this.gdes[vidx].data[Math.floor((gr_time - this.gdes[vidx].start) / this.gdes[vidx].step) * this.gdes[vidx].ds_cnt + this.gdes[vidx].ds]; + } else { + value = Number.NaN; + } + } + if (!isNaN(value)) { + paintval += value; + this.gdes[ii].p_data[i] = paintval; + if (isFinite(paintval) && this.gdes[ii].gf != RRDGraphDesc.GF.TICK) { + if ((isNaN(minval) || paintval < minval) && !(this.logarithmic && paintval <= 0.0)) + minval = paintval; + if (isNaN(maxval) || paintval > maxval) + maxval = paintval; + } + } else { + this.gdes[ii].p_data[i] = Number.NaN; + } + break; + case RRDGraphDesc.GF.STACK: + throw "STACK should already be turned into LINE or AREA here"; + break; + default: + break; + } + } + } + + if (this.logarithmic) { + if (isNaN(minval) || isNaN(maxval) || maxval <= 0) { + minval = 0.0; + maxval = 5.1; + } + if (minval <= 0) minval = maxval / 10e8; + } else { + if (isNaN(minval) || isNaN(maxval)) { + minval = 0.0; + maxval = 1.0; + } + } + + if (isNaN(this.minval) || ((!this.rigid) && this.minval > minval)) { + if (this.logarithmic) this.minval = minval / 2.0; + else this.minval = minval; + } + if (isNaN(this.maxval) || (!this.rigid && this.maxval < maxval)) { + if (this.logarithmic) this.maxval = maxval * 2.0; + else this.maxval = maxval; + } + + if (this.minval > this.maxval) { + if (this.minval > 0) this.minval = 0.99 * this.maxval; + else this.minval = 1.01 * this.maxval; + } + + if (this.AlmostEqual2sComplement(this.minval, this.maxval, 4)) { + if (this.maxval > 0) this.maxval *= 1.01; + else this.maxval *= 0.99; + + if (this.AlmostEqual2sComplement(this.maxval, 0, 4)) this.maxval = 1.0; + } + return 0; + }, + leg_place: function (calc_width) + { + var interleg = this.TEXT.LEGEND.size * 1.5; + var border = this.TEXT.LEGEND.size * 1.5; + var fill = 0, fill_last; + var legendwidth; // = this.ximg - 2 * border; + var leg_c = 0; + var leg_x = border; + var leg_y = 0; //this.yimg; + var leg_y_prev = 0; // this.yimg; + var leg_cc; + var glue = 0; + var ii, mark = 0; + var default_txtalign = RRDGraphDesc.TXA.JUSTIFIED; /*default line orientation */ + var legspace; + var tab; + var saved_legend; + + if(calc_width) legendwidth = 0; + else legendwidth = this.legendwidth - 2 * border; + + if (!this.no_legend && !this.only_graph) { + legspace = []; + for (var i = 0 , gdes_c = this.gdes.length; i < gdes_c; i++) { + var prt_fctn; /*special printfunctions */ + if(calc_width) saved_legend = this.gdes[i].legend; + fill_last = fill; + if (this.gdes[i].gf === RRDGraphDesc.GF.TEXTALIGN) + default_txtalign = this.gdes[i].txtalign; + + if (!this.force_rules_legend) { + if (this.gdes[i].gf === RRDGraphDesc.GF.HRULE && (this.gdes[i].yrule < this.minval || this.gdes[i].yrule > this.maxval)) + this.gdes[i].legend = null; + if (this.gdes[i].gf === RRDGraphDesc.GF.VRULE && (this.gdes[i].xrule < this.start || this.gdes[i].xrule > this.end)) + this.gdes[i].legend = null; + } + this.gdes[i].legend = this.gdes[i].legend.replace(/\\t/gi, "\t") /* turn \\t into tab */ + + leg_cc = this.gdes[i].legend.length; + /* is there a controle code at the end of the legend string ? */ + if (leg_cc >= 2 && this.gdes[i].legend.charAt(leg_cc - 2) === '\\') { + prt_fctn = this.gdes[i].legend.charAt(leg_cc - 1); + leg_cc -= 2; + this.gdes[i].legend = this.gdes[i].legend.substr(0,leg_cc); + } else { + prt_fctn = null; + } + /* only valid control codes */ + if (prt_fctn != 'l' && prt_fctn != 'n' && prt_fctn != 'r' && prt_fctn != 'j' && prt_fctn != 'c' && + prt_fctn != 'u' && prt_fctn != 's' && prt_fctn != null && prt_fctn != 'g') { + throw "Unknown control code at the end of "+this.gdes[i].legend+": "+prt_fctn; + } + /* \n -> \l */ + if (prt_fctn === 'n') prt_fctn = 'l'; + + /* remove exess space from the end of the legend for \g */ + while (prt_fctn === 'g' && leg_cc > 0 && this.gdes[i].legend.charAt(leg_cc - 1) === ' ') { + leg_cc--; + this.gdes[i].legend = this.gdes[i].legend.substr(0,leg_cc); + } + + if (leg_cc != 0) { + legspace[i] = (prt_fctn === 'g' ? 0 : interleg); + if (fill > 0) fill += legspace[i]; + fill += this.gfx_get_text_width(fill + border, this.TEXT.LEGEND, this.tabwidth, this.gdes[i].legend); + leg_c++; + } else { + legspace[i] = 0; + } + /* who said there was a special tag ... ? */ + if (prt_fctn === 'g') prt_fctn = null; + + if (prt_fctn === null) { + if(calc_width && (fill > legendwidth)) legendwidth = fill; + + if (i === gdes_c - 1 || fill > legendwidth) { + switch (default_txtalign) { + case RRDGraphDesc.TXA.RIGHT: + prt_fctn = 'r'; + break; + case RRDGraphDesc.TXA.CENTER: + prt_fctn = 'c'; + break; + case RRDGraphDesc.TXA.JUSTIFIED: + prt_fctn = 'j'; + break; + default: + prt_fctn = 'l'; + break; + } + } + /* is it time to place the legends ? */ + if (fill > legendwidth) { + if (leg_c > 1) { + /* go back one */ + i--; + fill = fill_last; + leg_c--; + } + } + if (leg_c === 1 && prt_fctn === 'j') { + prt_fctn = 'l'; + } + } + + if (prt_fctn != null) { + leg_x = border; + if (leg_c >= 2 && prt_fctn === 'j') { + glue = (legendwidth - fill) / (leg_c - 1); + } else { + glue = 0; + } + if (prt_fctn === 'c') + leg_x = (legendwidth - fill) / 2.0; + if (prt_fctn === 'r') + leg_x = legendwidth - fill + border; + for (ii = mark; ii <= i; ii++) { + if (this.gdes[ii].legend === '') continue; + this.gdes[ii].leg_x = leg_x; + this.gdes[ii].leg_y = leg_y + border; + leg_x += this.gfx_get_text_width(leg_x, this.TEXT.LEGEND, this.tabwidth, this.gdes[ii].legend) + legspace[ii] + glue; + } + leg_y_prev = leg_y; + if (leg_x > border || prt_fctn === 's') leg_y += this.TEXT.LEGEND.size * 1.4; + if (prt_fctn === 's') leg_y -= this.TEXT.LEGEND.size; + if (prt_fctn === 'u') leg_y -= this.TEXT.LEGEND.size * 1.4; + + if(calc_width && (fill > legendwidth)) legendwidth = fill; + fill = 0; + leg_c = 0; + mark = ii; + } + + if(calc_width) this.gdes[i].legend = saved_legend; + } + if(calc_width) this.legendwidth = legendwidth + 2 * border; + else this.legendheight = leg_y + border * 0.6; // FIXME 0.6 ?? + } + return 0; + }, + axis_paint: function() + { + this.gfx_line(this.xorigin - 4, this.yorigin, + this.xorigin + this.xsize + 4, this.yorigin, + this.MGRIDWIDTH, this.GRC.AXIS); + + this.gfx_line(this.xorigin, this.yorigin + 4, + this.xorigin, this.yorigin - this.ysize - 4, + this.MGRIDWIDTH, this.GRC.AXIS); + + this.gfx_new_area(this.xorigin + this.xsize + 2, this.yorigin - 3, + this.xorigin + this.xsize + 2, + this.yorigin + 3, this.xorigin + this.xsize + 7, this.yorigin, + this.GRC.ARROW); + this.gfx_close_path(); + + this.gfx_new_area(this.xorigin - 3, this.yorigin - this.ysize - 2, + this.xorigin + 3, this.yorigin - this.ysize - 2, + this.xorigin, this.yorigin - this.ysize - 7, + this.GRC.ARROW); + this.gfx_close_path(); + + if (this.second_axis_scale != 0){ + this.gfx_line (this.xorigin+this.xsize,this.yorigin+4, + this.xorigin+this.xsize,this.yorigin-this.ysize-4, + MGRIDWIDTH, this.graph_col[GRC_AXIS]); + this.gfx_new_area (this.xorigin+this.xsize-2, this.yorigin-this.ysize-2, + this.xorigin+this.xsize+3, this.yorigin-this.ysize-2, + this.xorigin+this.xsize, this.yorigin-this.ysize-7, /* LINEOFFSET */ + this.GRC.ARROW); + this.gfx_close_path(); + } + }, + frexp10: function (x) + { + var mnt; + var iexp; + + iexp = Math.floor(Math.log(Math.abs(x)) / Math.LN10); + mnt = x / Math.pow(10.0, iexp); + if (mnt >= 10.0) { + iexp++; + mnt = x / Math.pow(10.0, iexp); + } + return [mnt, iexp]; + }, + horizontal_log_grid: function () + { + var yloglab = [ + [ 1.0, 10., 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ], + [ 1.0, 5.0, 10., 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ], + [ 1.0, 2.0, 5.0, 7.0, 10., 0.0, 0.0, 0.0, 0.0, 0.0 ], + [ 1.0, 2.0, 4.0, 6.0, 8.0, 10., 0.0, 0.0, 0.0, 0.0 ], + [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10. ], + [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] /* last line */ + ]; + var i, j, val_exp, min_exp; + var nex; /* number of decades in data */ + var logscale; /* scale in logarithmic space */ + var exfrac = 1; /* decade spacing */ + var mid = -1; /* row in yloglab for major grid */ + var mspac; /* smallest major grid spacing (pixels) */ + var flab; /* first value in yloglab to use */ + var value, tmp, pre_value; + var X0, X1, Y0; + var graph_label; + + nex = Math.log(this.maxval / this.minval)/Math.LN10; + logscale = this.ysize / nex; + /* major spacing for data with high dynamic range */ + while (logscale * exfrac < 2.3 * this.TEXT.LEGEND.size) { // FIXME 3 -> 2.34 ?? + if (exfrac === 1) exfrac = 2.3; // ??? 3 -> 2.34 + else exfrac += 2.3 ; // 3-> 2.34 + } + /* major spacing for less dynamic data */ + do { + mid++; + for (i = 0; yloglab[mid][i + 1] < 10.0; i++); + mspac = logscale * Math.log(10.0 / yloglab[mid][i])/Math.LN10; + } while (mspac > 1.56 * this.TEXT.LEGEND.size && yloglab[mid][0] > 0); // FIXME 2->1.56 ?? + if (mid) mid--; + /* find first value in yloglab */ + //for (flab = 0; yloglab[mid][flab] < 10 && this.frexp10(this.minval,tmp) > yloglab[mid][flab]; flab++); + flab = -1; + do { + var ret; + flab++; + // [ret, tmp] = this.frexp10(this.minval); + var dummy = this.frexp10(this.minval); ret = dummy[0]; tmp = dummy[1]; + } while (yloglab[mid][flab] < 10 && ret > yloglab[mid][flab]); + + if (yloglab[mid][flab] === 10.0) { + tmp += 1.0; + flab = 0; + } + val_exp = tmp; + if (val_exp % exfrac) val_exp += Math.abs(-val_exp % exfrac); + X0 = this.xorigin; + X1 = this.xorigin + this.xsize; + /* draw grid */ + pre_value = Number.NAN; + + while (1) { + value = yloglab[mid][flab] * Math.pow(10.0, val_exp); + if (this.AlmostEqual2sComplement(value, pre_value, 4)) // FIXME + break; /* it seems we are not converging */ + pre_value = value; + Y0 = this.ytr(value); + if (Math.floor(Y0 + 0.5) <= this.yorigin - this.ysize) + break; + /* major grid line */ + this.gfx_line(X0 - 2, Y0, X0, Y0, this.MGRIDWIDTH, this.GRC.MGRID); + this.gfx_line(X1, Y0, X1 + 2, Y0, this.MGRIDWIDTH, this.GRC.MGRID); + this.gfx_dashed_line(X0 - 2, Y0, X1 + 2, Y0, this.MGRIDWIDTH, this.GRC.MGRID, this.grid_dash_on, this.grid_dash_off); + /* label */ + if (this.force_units_si) { + var scale; + var pvalue; + var symbol; + + scale = Math.floor(val_exp / 3.0); + if (value >= 1.0) pvalue = Math.pow(10.0, val_exp % 3); + else pvalue = Math.pow(10.0, ((val_exp + 1) % 3) + 2); + pvalue *= yloglab[mid][flab]; + + if (((scale + this.si_symbcenter) < this.si_symbol.length) && ((scale + this.si_symbcenter) >= 0)) + symbol = this.si_symbol[scale + this.si_symbcenter]; + else + symbol = '?'; + graph_label = this.sprintf("%3.0f %s", pvalue, symbol); + } else { + graph_label = this.sprintf("%3.0e", value); + } + if (this.second_axis_scale != 0){ + var graph_label_right; + var sval = value*this.second_axis_scale+this.second_axis_shift; + if (!this.second_axis_format[0]){ + if (this.force_units_si) { + var mfac = 1; + var symb = ''; + //[sval, symb, mfac ] = this.auto_scale(sval, symb, mfac); + var dummy = this.auto_scale(sval, symb, mfac); sval = dummy[0]; symb = dummy[1]; mfac = dummy[2]; + graph_label_right = this.sprintf("%4.0f %s", sval,symb); + } else { + graph_label_right = this.sprintf("%3.0e", sval); + } + } else { + graph_label_right = this.sprintf(this.second_axis_format,sval,""); + } + this.gfx_text( X1+7, Y0, this.GRC.FONT, this.TEXT.AXIS, this.tabwidth,0.0, this.GFX_H.LEFT, this.GFX_V.CENTER, graph_label_right ); + } + + this.gfx_text(X0 - this.TEXT.AXIS.size, Y0, this.GRC.FONT, this.TEXT.AXIS, this.tabwidth, 0.0, this.GFX_H.RIGHT, this.GFX_V.CENTER, graph_label); + if (mid < 4 && exfrac === 1) { /* minor grid */ + if (flab === 0) { /* find first and last minor line behind current major line * i is the first line and j tha last */ + min_exp = val_exp - 1; + for (i = 1; yloglab[mid][i] < 10.0; i++); + i = yloglab[mid][i - 1] + 1; + j = 10; + } else { + min_exp = val_exp; + i = yloglab[mid][flab - 1] + 1; + j = yloglab[mid][flab]; + } + for (; i < j; i++) { /* draw minor lines below current major line */ + value = i * Math.pow(10.0, min_exp); + if (value < this.minval) continue; + Y0 = this.ytr(value); + if (Math.floor(Y0 + 0.5) <= this.yorigin - this.ysize) break; + this.gfx_line(X0 - 2, Y0, X0, Y0, this.GRIDWIDTH, this.GRC.GRID); + this.gfx_line(X1, Y0, X1 + 2, Y0, this.GRIDWIDTH, this.GRC.GRID); + this.gfx_dashed_line(X0 - 1, Y0, X1 + 1, Y0, this.GRIDWIDTH, this.GRC.GRID, this.grid_dash_on, this.grid_dash_off); + } + } else if (exfrac > 1) { + for (i = val_exp - exfrac / 3 * 2; i < val_exp; i += exfrac / 3) { + value = Math.pow(10.0, i); + if (value < this.minval) continue; + Y0 = this.ytr(value); + if (Math.floor(Y0 + 0.5) <= this.yorigin - this.ysize) break; + this.gfx_line(X0 - 2, Y0, X0, Y0, this.GRIDWIDTH, this.GRC.GRID); + this.gfx_line(X1, Y0, X1 + 2, Y0, this.GRIDWIDTH, this.GRC.GRID); + this.gfx_dashed_line(X0 - 1, Y0, X1 + 1, Y0, this.GRIDWIDTH, this.GRC.GRID, this.grid_dash_on, this.grid_dash_off); + } + } + if (yloglab[mid][++flab] === 10.0) { /* next decade */ + flab = 0; + val_exp += exfrac; + } + } + if (mid < 4 && exfrac === 1) { /* draw minor lines after highest major line */ + if (flab === 0) { /* find first and last minor line below current major line * i is the first line and j tha last */ + min_exp = val_exp - 1; + for (i = 1; yloglab[mid][i] < 10.0; i++); + i = yloglab[mid][i - 1] + 1; + j = 10; + } else { + min_exp = val_exp; + i = yloglab[mid][flab - 1] + 1; + j = yloglab[mid][flab]; + } + for (; i < j; i++) { /* draw minor lines below current major line */ + value = i * Math.pow(10.0, min_exp); + if (value < this.minval) continue; + Y0 = this.ytr(value); + if (Math.floor(Y0 + 0.5) <= this.yorigin - this.ysize) break; + this.gfx_line(X0 - 2, Y0, X0, Y0, this.GRIDWIDTH, this.GRC.GRID); + this.gfx_line(X1, Y0, X1 + 2, Y0, this.GRIDWIDTH, this.GRC.GRID); + this.gfx_dashed_line(X0 - 1, Y0, X1 + 1, Y0, this.GRIDWIDTH, this.GRC.GRID, this.grid_dash_on, this.grid_dash_off); + } + } else if (exfrac > 1) { /* fancy minor gridlines */ + for (i = val_exp - exfrac / 3 * 2; i < val_exp; i += exfrac / 3) { + value = Math.pow(10.0, i); + if (value < this.minval) continue; + Y0 = this.ytr(value); + if (Math.floor(Y0 + 0.5) <= this.yorigin - this.ysize) break; + this.gfx_line(X0 - 2, Y0, X0, Y0, this.GRIDWIDTH, this.GRC.GRID); + this.gfx_line(X1, Y0, X1 + 2, Y0, this.GRIDWIDTH, this.GRC.GRID); + this.gfx_dashed_line(X0 - 1, Y0, X1 + 1, Y0, this.GRIDWIDTH, this.GRC.GRID, this.grid_dash_on, this.grid_dash_off); + } + } + return 1; + }, + vertical_grid: function() + { + var xlab_sel; /* which sort of label and grid ? */ + var ti, tilab, timajor; + var factor; + var graph_label; + var X0, Y0, Y1; /* points for filled graph and more */ + + /* the type of time grid is determined by finding the number of seconds per pixel in the graph */ + if (this.xlab_user.minsec === -1) { + factor = (this.end - this.start) / this.xsize; + xlab_sel = 0; + + while (this.xlab[xlab_sel + 1].minsec != -1 && this.xlab[xlab_sel + 1].minsec <= factor) xlab_sel++; + if (xlab_sel === 0) xlab_sel=1; // FIXME XXX XXX xlab_sel == 0 ??? + while (this.xlab[xlab_sel - 1].minsec === this.xlab[xlab_sel].minsec && this.xlab[xlab_sel].length > (this.end - this.start)) xlab_sel--; + this.xlab_user = this.xlab[xlab_sel]; + + } + Y0 = this.yorigin; + Y1 = this.yorigin - this.ysize; + + if (!(this.no_minor)) { + for ( ti = this.find_first_time(this.start, this.xlab_user.gridtm, this.xlab_user.gridst), + timajor = this.find_first_time(this.start, this.xlab_user.mgridtm, this.xlab_user.mgridst); + ti < this.end && ti != -1; + ti = this.find_next_time(ti, this.xlab_user.gridtm, this.xlab_user.gridst)) { + if (ti < this.start || ti > this.end) continue; + while (timajor < ti && timajor != -1) timajor = this.find_next_time(timajor, this.xlab_user.mgridtm, this.xlab_user.mgridst); + if (timajor === -1) break; + if (ti === timajor) continue; + X0 = this.xtr(ti); + this.gfx_line(X0, Y1 - 2, X0, Y1, this.GRIDWIDTH, this.GRC.GRID); + this.gfx_line(X0, Y0, X0, Y0 + 2, this.GRIDWIDTH, this.GRC.GRID); + this.gfx_dashed_line(X0, Y0 + 1, X0, Y1 - 1, this.GRIDWIDTH, this.GRC.GRID, this.grid_dash_on, this.grid_dash_off); + } + } + + for ( ti = this.find_first_time(this.start, this.xlab_user.mgridtm, this.xlab_user.mgridst); + ti < this.end && ti != -1; + ti = this.find_next_time(ti, this.xlab_user.mgridtm, this.xlab_user.mgridst) + ) { + if (ti < this.start || ti > this.end) continue; + X0 = this.xtr(ti); + this.gfx_line(X0, Y1 - 2, X0, Y1, this.MGRIDWIDTH, this.GRC.MGRID); + this.gfx_line(X0, Y0, X0, Y0 + 3, this.MGRIDWIDTH, this.GRC.MGRID); + this.gfx_dashed_line(X0, Y0 + 3, X0, Y1 - 2, this.MGRIDWIDTH, + this.GRC.MGRID, this.grid_dash_on, this.grid_dash_off); + } + + for ( ti = this.find_first_time(this.start - this.xlab_user.precis / 2, this.xlab_user.labtm, this.xlab_user.labst); + (ti <= this.end - this.xlab_user.precis / 2) && ti != -1; + ti = this.find_next_time(ti, this.xlab_user.labtm, this.xlab_user.labst) + ) { + tilab = ti + this.xlab_user.precis / 2; + if (tilab < this.start || tilab > this.end) + continue; + //localtime_r(&tilab, &tm); FIXME + //strftime(graph_label, 99, this.xlab_user.stst, &tm); FIXME + graph_label = this.xlab_user.stst(new Date(tilab*1000)); + this.gfx_text(this.xtr(tilab), Y0 + 3, this.GRC.FONT, + this.TEXT.AXIS, this.tabwidth, 0.0, + this.GFX_H.CENTER, this.GFX_V.TOP, graph_label); + } + }, + auto_scale: function (value, symb_ptr, magfact) + { + var symbol = [ + 'a', /* 10e-18 Atto */ + 'f', /* 10e-15 Femto */ + 'p', /* 10e-12 Pico */ + 'n', /* 10e-9 Nano */ + 'u', /* 10e-6 Micro */ + 'm', /* 10e-3 Milli */ + ' ', /* Base */ + 'k', /* 10e3 Kilo */ + 'M', /* 10e6 Mega */ + 'G', /* 10e9 Giga */ + 'T', /* 10e12 Tera */ + 'P', /* 10e15 Peta */ + 'E' /* 10e18 Exa */ + ]; + + var symbcenter = 6; + var sindex; + + if (value === 0.0 || isNaN(value)) { + sindex = 0; + magfact = 1.0; + } else { + sindex = Math.floor((Math.log(Math.abs(value))/Math.LN10) / (Math.log(this.base)/Math.LN10)); + magfact = Math.pow(this.base, sindex); + value /= magfact; + } + if (sindex <= symbcenter && sindex >= -symbcenter) { + symb_ptr = symbol[sindex + symbcenter]; + } else { + symb_ptr = '?'; + } + return [value, symb_ptr, magfact]; + }, + si_unit: function() + { + var digits; + var viewdigits = 0; + + digits = Math.floor(Math.log(Math.max(Math.abs(this.minval), Math.abs(this.maxval))) / Math.log(this.base)); + + if (this.unitsexponent != 9999) { + /* unitsexponent = 9, 6, 3, 0, -3, -6, -9, etc */ + viewdigits = Math.floor(this.unitsexponent / 3); + } else { + viewdigits = digits; + } + + this.magfact = Math.pow(this.base, digits); + + this.viewfactor = this.magfact / Math.pow(this.base, viewdigits); + + if (((viewdigits + this.si_symbcenter) < this.si_symbol.length) && ((viewdigits + this.si_symbcenter) >= 0)) + this.symbol = this.si_symbol[viewdigits + this.si_symbcenter]; + else + this.symbol = '?'; + }, + expand_range: function () + { + var sensiblevalues = [ 1000.0, 900.0, 800.0, 750.0, 700.0, 600.0, 500.0, 400.0, 300.0, 250.0, 200.0, 125.0, 100.0, 90.0, 80.0, 75.0, 70.0, 60.0, 50.0, 40.0, 30.0, 25.0, 20.0, 10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.5, 3.0, 2.5, 2.0, 1.8, 1.5, 1.2, 1.0, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.0, -1 ]; + var scaled_min, scaled_max; + var adj; + var i; + + if (isNaN(this.ygridstep)) { + if (this.alt_autoscale) { + var delt, fact; + + delt = this.maxval - this.minval; + adj = delt * 0.1; + fact = 2.0 * Math.pow(10.0, Math.floor(Math.log(Math.max(Math.abs(this.minval), Math.abs(this.maxval)) / this.magfact)/Math.LN10) - 2); + if (delt < fact) adj = (fact - delt) * 0.55; + this.minval -= adj; + this.maxval += adj; + } else if (this.alt_autoscale_min) { + adj = (this.maxval - this.minval) * 0.1; + this.minval -= adj; + } else if (this.alt_autoscale_max) { + adj = (this.maxval - this.minval) * 0.1; + this.maxval += adj; + } else { + scaled_min = this.minval / this.magfact; + scaled_max = this.maxval / this.magfact; + + for (i = 1; sensiblevalues[i] > 0; i++) { + if (sensiblevalues[i - 1] >= scaled_min && sensiblevalues[i] <= scaled_min) + this.minval = sensiblevalues[i] * this.magfact; + if (-sensiblevalues[i - 1] <= scaled_min && -sensiblevalues[i] >= scaled_min) + this.minval = -sensiblevalues[i - 1] * this.magfact; + if (sensiblevalues[i - 1] >= scaled_max && sensiblevalues[i] <= scaled_max) + this.maxval = sensiblevalues[i - 1] * this.magfact; + if (-sensiblevalues[i - 1] <= scaled_max && -sensiblevalues[i] >= scaled_max) + this.maxval = -sensiblevalues[i] * this.magfact; + } + } + } else { + this.minval = this.ylabfact * this.ygridstep * Math.floor(this.minval / (this.ylabfact * this.ygridstep)); + this.maxval = this.ylabfact * this.ygridstep * Math.ceil(this.maxval / (this.ylabfact * this.ygridstep)); + } + }, + calc_horizontal_grid: function() + { + var range; + var scaledrange; + var pixel, i; + var gridind = 0; + var decimals, fractionals; + + this.ygrid_scale.labfact = 2; + range = this.maxval - this.minval; + scaledrange = range / this.magfact; + if (isNaN(scaledrange) || !isFinite(scaledrange)) { + return false; + } + + pixel = 1; + if (isNaN(this.ygridstep)) { + if (this.alt_ygrid) { + decimals = Math.ceil(Math.log(Math.max(Math.abs(this.maxval), Math.abs(this.minval)) * this.viewfactor / this.magfact)/Math.LN10); + if (decimals <= 0) decimals = 1; + this.ygrid_scale.gridstep = Math.pow(10, Math.floor(Math.log(range * this.viewfactor / this.magfact)/Math.LN10)) / this.viewfactor * this.magfact; + if (this.ygrid_scale.gridstep === 0) this.ygrid_scale.gridstep = 0.1; + if (range / this.ygrid_scale.gridstep < 5 && this.ygrid_scale.gridstep >= 30) + this.ygrid_scale.gridstep /= 10; + if (range / this.ygrid_scale.gridstep > 15) + this.ygrid_scale.gridstep *= 10; + if (range / this.ygrid_scale.gridstep > 5) { + this.ygrid_scale.labfact = 1; + if (range / this.ygrid_scale.gridstep > 8 || this.ygrid_scale.gridstep < 1.8 * this.TEXT.AXIS.size) // 1.8 + this.ygrid_scale.labfact = 2; + } else { + this.ygrid_scale.gridstep /= 5; + this.ygrid_scale.labfact = 5; + } + + fractionals = Math.floor(Math.log(this.ygrid_scale.gridstep * this.ygrid_scale.labfact * this.viewfactor / this.magfact)/Math.LN10); + if (fractionals < 0) { /* small amplitude. */ + var len = decimals - fractionals + 1; + if (this.unitslength < len + 2) this.unitslength = len + 2; + this.ygrid_scale.labfmt = this.sprintf("%%%d.%df%s", len, -fractionals, (this.symbol != ' ' ? " %s" : "")); + } else { + var len = decimals + 1; + if (this.unitslength < len + 2) this.unitslength = len + 2; + this.ygrid_scale.labfmt = this.sprintf("%%%d.0f%s", len, (this.symbol != ' ' ? " %s" : "")); + } + } else { /* classic rrd grid */ + for (i = 0; this.ylab[i].grid > 0; i++) { + pixel = this.ysize / (scaledrange / this.ylab[i].grid); + gridind = i; + if (pixel >= 5) break; + } + for (i = 0; i < 4; i++) { + if (pixel * this.ylab[gridind].lfac[i] >= 1.8 * this.TEXT.AXIS.size) { // 1.8 + this.ygrid_scale.labfact = this.ylab[gridind].lfac[i]; + break; + } + } + this.ygrid_scale.gridstep = this.ylab[gridind].grid * this.magfact; + } + } else { + this.ygrid_scale.gridstep = this.ygridstep; + this.ygrid_scale.labfact = this.ylabfact; + } + return true; + }, + draw_horizontal_grid: function() + { + var i; + var scaledstep; + var graph_label; + var nlabels = 0; + var X0 = this.xorigin; + var X1 = this.xorigin + this.xsize; + var sgrid = Math.round(this.minval / this.ygrid_scale.gridstep - 1); + var egrid = Math.round(this.maxval / this.ygrid_scale.gridstep + 1); + var MaxY; + var second_axis_magfact = 0; + var second_axis_symb = ''; + var Y0, YN; + var sisym; + + scaledstep = this.ygrid_scale.gridstep / this.magfact * this.viewfactor; + MaxY = scaledstep * egrid; + for (i = sgrid; i <= egrid; i++) { + Y0 = this.ytr(this.ygrid_scale.gridstep * i); + YN = this.ytr(this.ygrid_scale.gridstep * (i + 1)); + if (Math.floor(Y0 + 0.5) >= this.yorigin - this.ysize && Math.floor(Y0 + 0.5) <= this.yorigin) { + if (i % this.ygrid_scale.labfact === 0 || (nlabels === 1 && (YN < this.yorigin - this.ysize || YN > this.yorigin))) { + if (this.symbol === ' ') { + if (this.alt_ygridf) { + graph_label = this.sprintf(this.ygrid_scale.labfmt, scaledstep * i); // FIXME + } else { + if (MaxY < 10) { + graph_label = this.sprintf("%4.1f", scaledstep * i); + //var dummy = scaledstep * i; // FIXME + //graph_label = lpad(dummy.toFixed(1),' ',4); + } else { + graph_label = this.sprintf("%4.0f", scaledstep * i); + //var dummy = scaledstep * i; // FIXME + //graph_label = lpad(dummy.toFixed(),' ',4); + } + } + } else { + sisym = (i === 0 ? ' ' : this.symbol); + if (this.alt_ygrid) { + graph_label = this.sprintf(this.ygrid_scale.labfmt, scaledstep * i, sisym); + } else { + if (MaxY < 10) { + graph_label = this.sprintf("%4.1f %s", scaledstep * i, sisym); + //var dummy = scaledstep * i; // FIXME + //graph_label = lpad(dummy.toFixed(1),' ',4)+' '+sisym; + } else { + graph_label = this.sprintf("%4.0f %s", scaledstep * i, sisym); + //var dummy = scaledstep * i; // FIXME + //graph_label = lpad(dummy.toFixed(),' ',4)+' '+sisym; + } + } + } + nlabels++; + if (this.second_axis_scale != 0){ + var graph_label_right; + sval = this.ygrid_scale.gridstep*i*this.second_axis_scale+this.second_axis_shift; + if (!this.second_axis_format){ + if (!second_axis_magfact){ + var dummy = this.ygrid_scale.gridstep*(sgrid+egrid)/2.0*this.second_axis_scale+this.second_axis_shift; + [dummy, second_axis_symb, second_axis_magfact ] = this.auto_scale(dummy,second_axis_symb,second_axis_magfact); + } + sval /= second_axis_magfact; + if(MaxY < 10) { + graph_label_right = this.sprintf("%5.1f %s", sval, second_axis_symb); + } else { + graph_label_right = this.sprintf("%5.0f %s", sval, second_axis_symb); + } + } else { + graph_label_right = this.sprintf(this.second_axis_format, sval); + } + this.gfx_text (X1+7, Y0, this.GRC.FONT, this.TEXT.AXIS, this.tabwidth, 0.0, this.GFX_H.LEFT, this.GFX_V.CENTER, graph_label_right ); + } + this.gfx_text(X0 - this.TEXT.AXIS.size , Y0, this.GRC.FONT, this.TEXT.AXIS , this.tabwidth, 0.0, this.GFX_H.RIGHT, this.GFX_V.CENTER, graph_label); + this.gfx_line(X0 - 2, Y0, X0, Y0, this.MGRIDWIDTH, this.GRC.MGRID); + this.gfx_line(X1, Y0, X1 + 2, Y0, this.MGRIDWIDTH, this.GRC.MGRID); + this.gfx_dashed_line(X0 - 2, Y0, X1 + 2, Y0, this.MGRIDWIDTH, this.GRC.MGRID, this.grid_dash_on, this.grid_dash_off); + } else if (!this.no_minor) { + this.gfx_line( X0 - 2, Y0, X0, Y0, this.GRIDWIDTH, this.GRC.GRID); + this.gfx_line(X1, Y0, X1 + 2, Y0, this.GRIDWIDTH, this.GRC.GRID); + this.gfx_dashed_line(X0 - 1, Y0, X1 + 1, Y0, this.GRIDWIDTH, this.GRC.GRID, this.grid_dash_on, this.grid_dash_off); + } + } + } + return 1; + }, + grid_paint: function() + { + var i; + var res = 0; + var X0, Y0; + + if (this.draw_3d_border > 0) { + i = this.draw_3d_border; + this.gfx_new_area(0, this.yimg, i, this.yimg - i, i, i, this.GRC.SHADEA); + this.gfx_add_point(this.ximg - i, i); + this.gfx_add_point(this.ximg, 0); + this.gfx_add_point(0, 0); + this.gfx_close_path(); + this.gfx_new_area(i, this.yimg - i, this.ximg - i, this.yimg - i, this.ximg - i, i, this.GRC.SHADEB); + this.gfx_add_point(this.ximg, 0); + this.gfx_add_point(this.ximg, this.yimg); + this.gfx_add_point(0, this.yimg); + this.gfx_close_path(); + } + if (this.draw_x_grid) + this.vertical_grid(); + if (this.draw_y_grid) { + if (this.logarithmic) + res = this.horizontal_log_grid(); + else + res = this.draw_horizontal_grid(); + /* dont draw horizontal grid if there is no min and max val */ + if (!res) { + this.gfx_text(this.ximg / 2, (2 * this.yorigin - this.ysize) / 2, + this.GRC.FONT, this.TEXT.AXIS, + this.tabwidth, 0.0, + this.GFX_H.CENTER, this.GFX_V.CENTER, 'No Data found'); + } + } + + /* yaxis unit description */ + if (this.ylegend){ + this.gfx_text(this.xOriginLegendY+10, this.yOriginLegendY, + this.GRC.FONT, this.TEXT.UNIT, this.tabwidth, this.YLEGEND_ANGLE, + this.GFX_H.CENTER, this.GFX_V.CENTER, this.ylegend); + + } + if (this.second_axis_legend){ + this.gfx_text(this.xOriginLegendY2+10, this.yOriginLegendY2, + this.GRC.FONT, this.TEXT.UNIT, this.tabwidth, this.YLEGEND_ANGLE, + this.GFX_H.CENTER, this.GFX_V.CENTER, this.second_axis_legend); + } + + /* graph title */ + this.gfx_text(this.xOriginTitle, this.yOriginTitle+6, + this.GRC.FONT, this.TEXT.TITLE, this.tabwidth, 0.0, this.GFX_H.CENTER, this.GFX_V.TOP, this.title); + /* rrdtool 'logo' */ + if (!this.no_rrdtool_tag){ + var color = this.parse_color(this.GRC.FONT); + color[3] = 0.3; + var water_color = this.color2rgba(color); + var xpos = this.legendposition === this.LEGEND_POS.EAST ? this.xOriginLegendY : this.ximg - 4; + this.gfx_text(xpos, 5, water_color, this.TEXT.WATERMARK, this.tabwidth, + -90, this.GFX_H.LEFT, this.GFX_V.TOP, "RRDTOOL / TOBI OETIKER"); + } + /* graph watermark */ + if (this.watermark) { + var color = this.parse_color(this.GRC.FONT) + color[3] = 0.3; + var water_color = this.color2rgba(color); + this.gfx_text(this.ximg / 2, this.yimg - 6, water_color, this.TEXT.FONT , this.tabwidth, 0, + this.GFX_H.CENTER, this.GFX_V.BOTTOM, this.watermark); + } + /* graph labels */ + if (!(this.no_legend) && !(this.only_graph)) { + for (var i = 0 , gdes_c = this.gdes.length; i < gdes_c; i++) { + if (!this.gdes[i].legend) continue; + X0 = this.xOriginLegend + this.gdes[i].leg_x; + Y0 = this.legenddirection === this.LEGEND_DIR.TOP_DOWN ? this.yOriginLegend + this.gdes[i].leg_y : this.yOriginLegend + this.legendheight - this.gdes[i].leg_y; + this.gfx_text(X0, Y0, this.GRC.FONT, this.TEXT.LEGEND, this.tabwidth, 0.0, this.GFX_H.LEFT, this.GFX_V.BOTTOM, this.gdes[i].legend); + if (this.gdes[i].gf != RRDGraphDesc.GF.PRINT && this.gdes[i].gf != RRDGraphDesc.GF.GPRINT && this.gdes[i].gf != RRDGraphDesc.GF.COMMENT) { + var boxH, boxV; + var X1, Y1; + + boxH = this.gfx_get_text_width(0,this.TEXT.LEGEND, this.tabwidth, 'o') * 1.2; + boxV = boxH; + + Y0 -= boxV * 0.4; + + if (this.dynamic_labels && this.gdes[i].gf === RRDGraphDesc.GF.HRULE) { + this.gfx_line(X0, Y0 - boxV / 2, X0 + boxH, Y0 - boxV / 2, 1.0, this.gdes[i].col); + } else if (this.dynamic_labels && this.gdes[i].gf === RRDGraphDesc.GF.VRULE) { + this.gfx_line(X0 + boxH / 2, Y0, X0 + boxH / 2, Y0 - boxV, 1.0, this.gdes[i].col); + } else if (this.dynamic_labels && this.gdes[i].gf === RRDGraphDesc.GF.LINE) { + this.gfx_line(X0, Y0, X0 + boxH, Y0 - boxV, this.gdes[i].linewidth, this.gdes[i].col); + } else { + this.gfx_new_area(X0, Y0 - boxV, X0, Y0, X0 + boxH, Y0, this.GRC.BACK); + this.gfx_add_point(Math.round(X0 + boxH)+0.5, Math.round(Y0 - boxV)+0.5); + this.gfx_close_path(); + this.gfx_new_area(X0, Y0 - boxV, X0, Y0, X0 + boxH, Y0, this.gdes[i].col); + this.gfx_add_point(Math.round(X0 + boxH)+0.5, Math.round(Y0 - boxV)+0.5); + this.gfx_close_path(); + this.ctx.save(); + + this.ctx.beginPath(); + this.ctx.lineWidth = 1.0; + X1 = X0 + boxH; + Y1 = Y0 - boxV; + X0 = Math.round(X0)+0.5; + X1 = Math.round(X1)+0.5; + Y0 = Math.round(Y0)+0.5; + Y1 = Math.round(Y1)+0.5; + this.ctx.moveTo(X0, Y0); + this.ctx.lineTo(X1, Y0); + this.ctx.lineTo(X1, Y1); + this.ctx.lineTo(X0, Y1); + this.ctx.closePath(); + this.ctx.strokeStyle = this.GRC.FRAME; + this.ctx.stroke(); + this.ctx.restore(); + } +// if (this.gdes[i].dash) { FIXME +// double dashes[] = { 3.0 }; +// cairo_set_dash(this.cr, dashes, 1, 0.0); +// } + } + } + } + }, + graph_size_location: function (elements) + { + var Xvertical = 0; + var Xvertical2 = 0; + var Ytitle = 0; + var Xylabel = 0; + var Xmain = 0; + var Ymain = 0; + var Yxlabel = 0; + var Xspacing = 15; + var Yspacing = 15; + var Ywatermark = 4; + + if (this.only_graph) { + this.xorigin = 0; + this.ximg = this.xsize; + this.yimg = this.ysize; + this.yorigin = this.ysize; + this.ytr(Number.NaN); + return 0; + } + + if(this.watermark) + Ywatermark = this.TEXT.WATERMARK.size * 1.5; // 2 + if(this.ylegend) + Xvertical = this.TEXT.UNIT.size * 1.5; // 2 + if(this.second_axis_legend) + Xvertical2 = this.TEXT.UNIT.size * 1.5; // 2 + + if(this.title) + Ytitle = this.TEXT.TITLE.size * 1.95 + 10; // 2.6 + else + Ytitle = 1.5 * Yspacing; + + if (elements) { + if (this.draw_x_grid) + Yxlabel = this.TEXT.AXIS.size * 1.35; // 2.5 1.87 + if (this.draw_y_grid || this.forceleftspace) // FIXME + Xylabel = this.gfx_get_text_width(0, this.TEXT.AXIS, this.tabwidth, '0') * this.unitslength; + } + Xylabel += Xspacing; + this.legendheight = 0; + this.legendwidth = 0; + if(!this.no_legend) { + if(this.legendposition === this.LEGEND_POS.WEST || this.legendposition === this.LEGEND_POS.EAST){ + if (this.leg_place(1) === -1) return -1; // FIXME + } + } + + if(this.full_size_mode) { + this.ximg = this.xsize; + this.yimg = this.ysize; + Xmain = this.ximg; + Ymain = this.yimg; + + Xmain -= Xylabel;// + Xspacing; + if((this.legendposition === this.LEGEND_POS.WEST || this.legendposition === this.LEGEND_POS.EAST) && !(this.no_legend) ) + Xmain -= this.legendwidth;// + Xspacing; + if (this.second_axis_scale != 0) Xmain -= Xylabel; + if (!(this.no_rrdtool_tag)) Xmain -= Xspacing; + + Xmain -= Xvertical + Xvertical2; + + if(Xmain < 1) Xmain = 1; + this.xsize = Xmain; + + if (!(this.no_legend)) { + if(this.legendposition === this.LEGEND_POS.NORTH || this.legendposition === this.LEGEND_POS.SOUTH){ + this.legendwidth = this.ximg; + if (this.leg_place(0) === -1) return -1; + } + } + + if( (this.legendposition === this.LEGEND_POS.NORTH || this.legendposition === this.LEGEND_POS.SOUTH) && !(this.no_legend) ) + Ymain -= Yxlabel + this.legendheight; + else Ymain -= Yxlabel; + + Ymain -= Ytitle; + + if (this.nolegened) Ymain -= Yspacing; + if (this.watermark) Ymain -= Ywatermark; + if(Ymain < 1) Ymain = 1; + this.ysize = Ymain; + } else { + if (elements) { +// Xmain = this.xsize; // + Xspacing; + Xmain = this.xsize + Xspacing; //FIXME ??? + Ymain = this.ysize; + } + this.ximg = Xmain + Xylabel; + if (!this.no_rrdtool_tag) this.ximg += Xspacing; + + if( (this.legendposition === this.LEGEND_POS.WEST || this.legendposition === this.LEGEND_POS.EAST) && !this.no_legend ) + this.ximg += this.legendwidth;// + Xspacing; + if (this.second_axis_scale != 0) this.ximg += Xylabel; + + this.ximg += Xvertical + Xvertical2; + + if (!(this.no_legend)) { + if(this.legendposition === this.LEGEND_POS.NORTH || this.legendposition === this.LEGEND_POS.SOUTH){ + this.legendwidth = this.ximg; + if (this.leg_place(0) === -1) return -1; + } + } + + this.yimg = Ymain + Yxlabel; + if( (this.legendposition === this.LEGEND_POS.NORTH || this.legendposition === this.LEGEND_POS.SOUTH) && !(this.no_legend) ) + this.yimg += this.legendheight; + + if (Ytitle) this.yimg += Ytitle; + else this.yimg += 1.5 * Yspacing; + + if (this.no_legend) this.yimg += Yspacing; + if (this.watermark) this.yimg += Ywatermark; + } + + + if (!this.no_legend) { + if(this.legendposition === this.LEGEND_POS.WEST || this.legendposition === this.LEGEND_POS.EAST){ + if (this.leg_place(0) === -1) return -1; + } + } + + switch(this.legendposition){ + case this.LEGEND_POS.NORTH: + this.xOriginTitle = Math.round(Xvertical + Xylabel + (this.xsize / 2)); + this.yOriginTitle = 0; + this.xOriginLegend = 0; + this.yOriginLegend = Math.round(Ytitle); + this.xOriginLegendY = 0; + this.yOriginLegendY = Math.round(Ytitle + this.legendheight + (Ymain / 2) + Yxlabel); + this.xorigin = Math.round(Xvertical + Xylabel); + this.yorigin = Math.round(Ytitle + this.legendheight + Ymain); + this.xOriginLegendY2 = Math.round(Xvertical + Xylabel + Xmain); + if (this.second_axis_scale != 0) this.xOriginLegendY2 += Xylabel; + this.yOriginLegendY2 = Math.round(Ytitle + this.legendheight + (Ymain / 2) + Yxlabel); + break; + case this.LEGEND_POS.WEST: + this.xOriginTitle = Math.round(this.legendwidth + Xvertical + Xylabel + this.xsize / 2); + this.yOriginTitle = 0; + this.xOriginLegend = 0; + this.yOriginLegend = Math.round(Ytitle); + this.xOriginLegendY = Math.round(this.legendwidth); + this.yOriginLegendY = Math.round(Ytitle + (Ymain / 2)); + this.xorigin = Math.round(this.legendwidth + Xvertical + Xylabel); + this.yorigin = Math.round(Ytitle + Ymain); + this.xOriginLegendY2 = Math.round(this.legendwidth + Xvertical + Xylabel + Xmain); + if (this.second_axis_scale != 0) this.xOriginLegendY2 += Xylabel; + this.yOriginLegendY2 = Math.round(Ytitle + (Ymain / 2)); + break; + case this.LEGEND_POS.SOUTH: + this.xOriginTitle = Math.round(Xvertical + Xylabel + this.xsize / 2); + this.yOriginTitle = 0; + this.xOriginLegend = 0; + this.yOriginLegend = Math.round(Ytitle + Ymain + Yxlabel); + this.xOriginLegendY = 0; + this.yOriginLegendY = Math.round(Ytitle + (Ymain / 2)); + this.xorigin = Math.round(Xvertical + Xylabel); + this.yorigin = Math.round(Ytitle + Ymain); + this.xOriginLegendY2 = Math.round(Xvertical + Xylabel + Xmain); + if (this.second_axis_scale != 0) this.xOriginLegendY2 += Xylabel; + this.yOriginLegendY2 = Math.round(Ytitle + (Ymain / 2)); + break; + case this.LEGEND_POS.EAST: + this.xOriginTitle = Math.round(Xvertical + Xylabel + this.xsize / 2); + this.yOriginTitle = 0; + this.xOriginLegend = Math.round(Xvertical + Xylabel + Xmain + Xvertical2); + if (this.second_axis_scale != 0) this.xOriginLegend += Xylabel; + this.yOriginLegend = Math.round(Ytitle); + this.xOriginLegendY = 0; + this.yOriginLegendY = Math.round(Ytitle + (Ymain / 2)); + this.xorigin = Math.round(Xvertical + Xylabel); + this.yorigin = Math.round(Ytitle + Ymain); + this.xOriginLegendY2 = Math.round(Xvertical + Xylabel + Xmain); + if (this.second_axis_scale != 0) this.xOriginLegendY2 += Xylabel; + this.yOriginLegendY2 = Math.round(Ytitle + (Ymain / 2)); + + if (!this.no_rrdtool_tag){ + this.xOriginTitle += Xspacing; + this.xOriginLegend += Xspacing; + this.xOriginLegendY += Xspacing; + this.xorigin += Xspacing; + this.xOriginLegendY2 += Xspacing; + } + break; + } + this.xtr(0); + this.ytr(Number.NaN); + return 0; + }, + graph_paint: function() + { + if (this.logarithmic && this.minval <= 0) + throw "for a logarithmic yaxis you must specify a lower-limit > 0"; + +// var start_end = RRDTime.proc_start_end(this.start_t, this.end_t); +// this.start = start_end[0]; +// this.end = start_end[1]; + + if (this.start < 3600 * 24 * 365 * 10) + throw "the first entry to fetch should be after 1980 ("+this.start+"%ld)"; + + if (this.end < this.start) + throw "start ("+this.start+") should be less than end ("+this.end+")"; + +// this.xlab_form = null + this.xlab_user = { minsec: -1, length: 0, gridtm: 0, gridst: 0, mgridtm: 0, mgridst: 0, labtm: 0, labst: 0, precis: 0, stst: null }; + this.ygrid_scale = { gridstep: 0.0, labfact:0 , labfmt: null }; + this.minval = this.setminval; + this.maxval = this.setmaxval; + + this.step = Math.max(this.step, (this.end - this.start) / this.xsize); + + for (var i = 0, gdes_c = this.gdes.length; i < gdes_c; i++) { + this.gdes[i].step = 0; // FIXME 0? + this.gdes[i].step_orig = this.step; + this.gdes[i].start = this.start; // FIXME SHIFT +// this.gdes[i].start_orig = this.start; + this.gdes[i].end = this.end; // FIXME SHIFT +// this.gdes[i].end_orig = this.end; + } + + var areazero = 0.0 + var lastgdes = null; + + if (this.data_fetch() === -1) + return -1; + if (this.data_calc() === -1) + return -1; + var i = this.print_calc(); + if (i < 0) + return -1; + if (this.graph_size_location(i) === -1) + return -1; + + if (this.data_proc() === -1) + return -1; + if (!this.logarithmic) + this.si_unit(); + if (!this.rigid && !this.logarithmic) + this.expand_range(); + + if (this.magfact === 0) this.magfact =1; // FIXME XXX XXX logarithmic Â? + + if (!this.calc_horizontal_grid()) + return -1; + + this.ytr(Number.NaN); + + this.canvas.height = this.yimg; + this.canvas.width = this.ximg; + + this.gfx_new_area(0, 0, 0, this.yimg, this.ximg, this.yimg, this.GRC.BACK); + this.gfx_add_point(this.ximg, 0); + this.gfx_close_path(); + + this.gfx_new_area(this.xorigin, this.yorigin, this.xorigin + this.xsize, + this.yorigin, this.xorigin + this.xsize, this.yorigin - this.ysize, this.GRC.CANVAS); + this.gfx_add_point(this.xorigin, this.yorigin - this.ysize); + this.gfx_close_path(); + +// this.ctx.rect(this.xorigin, this.yorigin - this.ysize - 1.0, this.xsize, this.ysize + 2.0); +// this.ctx.clip(); + + if (this.minval > 0.0) areazero = this.minval; + if (this.maxval < 0.0) areazero = this.maxval; + + for (var i = 0, gdes_c = this.gdes.length; i < gdes_c; i++) { + switch (this.gdes[i].gf) { + case RRDGraphDesc.GF.CDEF: + case RRDGraphDesc.GF.VDEF: + case RRDGraphDesc.GF.DEF: + case RRDGraphDesc.GF.PRINT: + case RRDGraphDesc.GF.GPRINT: + case RRDGraphDesc.GF.COMMENT: + case RRDGraphDesc.GF.TEXTALIGN: + case RRDGraphDesc.GF.HRULE: + case RRDGraphDesc.GF.VRULE: + case RRDGraphDesc.GF.XPORT: + case RRDGraphDesc.GF.SHIFT: + break; + case RRDGraphDesc.GF.TICK: + for (var ii = 0; ii < this.xsize; ii++) { + if (!isNaN(this.gdes[i].p_data[ii]) && this.gdes[i].p_data[ii] != 0.0) { + if (this.gdes[i].yrule > 0) { + this.gfx_line(this.xorigin + ii, this.yorigin + 1.0, this.xorigin + ii, this.yorigin - this.gdes[i].yrule * this.ysize, 1.0, this.gdes[i].col); + } else if (this.gdes[i].yrule < 0) { + this.gfx_line(this.xorigin + ii, this.yorigin - this.ysize - 1.0, this.xorigin + ii, this.yorigin - this.ysize - this.gdes[i].yrule * this.ysize, 1.0, this.gdes[i].col); + } + } + } + break; + case RRDGraphDesc.GF.LINE: + case RRDGraphDesc.GF.AREA: + var diffval = this.maxval - this.minval; + var maxlimit = this.maxval + 9 * diffval; + var minlimit = this.minval - 9 * diffval; + for (var ii = 0; ii < this.xsize; ii++) { + if (!isNaN(this.gdes[i].p_data[ii])) { // FIXME NaN < ??? + if (!isFinite(this.gdes[i].p_data[ii])) { + if (this.gdes[i].p_data[ii] > 0) this.gdes[i].p_data[ii] = this.maxval; + else this.gdes[i].p_data[ii] = this.minval; + } + if (this.gdes[i].p_data[ii] > maxlimit) this.gdes[i].p_data[ii] = maxlimit; + if (this.gdes[i].p_data[ii] < minlimit) this.gdes[i].p_data[ii] = minlimit; + } + } + var color = this.parse_color(this.gdes[i].col); // if (this.gdes[i].col.alpha != 0.0) { + if (color[3] != 0.0) { + if (this.gdes[i].gf === RRDGraphDesc.GF.LINE) { + var last_y = 0.0; + var draw_on = false; + + this.ctx.save(); + this.ctx.beginPath(); + this.ctx.lineWidth = this.gdes[i].linewidth; + //if (this.gdes[i].dash) cairo_set_dash(this.cr, this.gdes[i].p_dashes, this.gdes[i].ndash, this.gdes[i].offset); FIXME + for (var ii = 1; ii < this.xsize; ii++) { + if (isNaN(this.gdes[i].p_data[ii]) || (this.slopemode && isNaN(this.gdes[i].p_data[ii - 1]))) { + draw_on = false; + continue; + } + if (!draw_on) { + last_y = this.ytr(this.gdes[i].p_data[ii]); + if (!this.slopemode) { + var x = ii - 1 + this.xorigin; + var y = last_y; + x = Math.round(x)+0.5; + y = Math.round(y)+0.5; + this.ctx.moveTo(x, y); + x = ii + this.xorigin; + y = last_y; + x = Math.round(x)+0.5; + y = Math.round(y)+0.5; + this.ctx.lineTo(x, y) + } else { + var x = ii - 1 + this.xorigin; + var y = this.ytr(this.gdes[i].p_data[ii - 1]); + x = Math.round(x)+0.5; + y = Math.round(y)+0.5; + this.ctx.moveTo(x, y); + x = ii + this.xorigin; + y = last_y; + x = Math.round(x)+0.5; + y = Math.round(y)+0.5; + this.ctx.lineTo(x, y); + } + draw_on = true; + } else { + var x1 = ii + this.xorigin; + var y1 = this.ytr(this.gdes[i].p_data[ii]); + + if (!this.slopemode && !this.AlmostEqual2sComplement(y1, last_y, 4)) { + var x = ii - 1 + this.xorigin; + var y = y1; + + x = Math.round(x)+0.5; + y = Math.round(y)+0.5; + this.ctx.lineTo(x, y); + } + last_y = y1; + x1 = Math.round(x1)+0.5; + y1 = Math.round(y1)+0.5; + this.ctx.lineTo(x1, y1); + } + } + //cairo_set_source_rgba(this.cr, this.gdes[i]. col.red, this.gdes[i]. col.green, this.gdes[i]. col.blue, this.gdes[i].col.alpha); + this.ctx.strokeStyle = this.gdes[i].col; + this.ctx.lineCap = 'round'; //cairo_set_line_cap(this.cr, CAIRO_LINE_CAP_ROUND); + this.ctx.round = 'round'; //cairo_set_line_join(this.cr, CAIRO_LINE_JOIN_ROUND); + this.ctx.stroke(); + this.ctx.restore(); + } else { + var idxI = -1; + var foreY = []; + var foreX = []; + var backY = []; + var backX = []; + var drawem = false; + + for (ii = 0; ii <= this.xsize; ii++) { + var ybase, ytop; + + if (idxI > 0 && (drawem || ii === this.xsize)) { + var cntI = 1; + var lastI = 0; + + while (cntI < idxI && this.AlmostEqual2sComplement(foreY [lastI], foreY[cntI], 4) && this.AlmostEqual2sComplement(foreY [lastI], foreY [cntI + 1], 4)) + cntI++; + this.gfx_new_area(backX[0], backY[0], foreX[0], foreY[0], foreX[cntI], foreY[cntI], this.gdes[i].col); + while (cntI < idxI) { + lastI = cntI; + cntI++; + while (cntI < idxI && this.AlmostEqual2sComplement(foreY [lastI], foreY[cntI], 4) && this.AlmostEqual2sComplement(foreY [lastI], foreY [cntI + 1], 4)) + cntI++; + this.gfx_add_point(foreX[cntI], foreY[cntI]); + } + this.gfx_add_point(backX[idxI], backY[idxI]); + while (idxI > 1) { + lastI = idxI; + idxI--; + while (idxI > 1 && this.AlmostEqual2sComplement(backY [lastI], backY[idxI], 4) && this.AlmostEqual2sComplement(backY [lastI], backY [idxI - 1], 4)) + idxI--; + this.gfx_add_point(backX[idxI], backY[idxI]); + } + idxI = -1; + drawem = false; + this.gfx_close_path(); + } + if (drawem) { + drawem = false; + idxI = -1; + } + if (ii === this.xsize) + break; + if (!this.slopemode && ii === 0) + continue; + if (isNaN(this.gdes[i].p_data[ii])) { + drawem = true; + continue; + } + ytop = this.ytr(this.gdes[i].p_data[ii]); + if (lastgdes && this.gdes[i].stack) ybase = this.ytr(lastgdes.p_data[ii]); + else ybase = this.ytr(areazero); + if (ybase === ytop) { + drawem = true; + continue; + } + + if (ybase > ytop) { + var extra = ytop; + ytop = ybase; + ybase = extra; + } + if (!this.slopemode) { + backY[++idxI] = ybase - 0.2; + backX[idxI] = ii + this.xorigin - 1; + foreY[idxI] = ytop + 0.2; + foreX[idxI] = ii + this.xorigin - 1; + } + backY[++idxI] = ybase - 0.2; + backX[idxI] = ii + this.xorigin; + foreY[idxI] = ytop + 0.2; + foreX[idxI] = ii + this.xorigin; + } + } + } + /* if color != 0x0 */ + /* make sure we do not run into trouble when stacking on NaN */ + for (ii = 0; ii < this.xsize; ii++) { + if (isNaN(this.gdes[i].p_data[ii])) { + if (lastgdes && (this.gdes[i].stack)) this.gdes[i].p_data[ii] = lastgdes.p_data[ii]; + else this.gdes[i].p_data[ii] = areazero; + } + } + lastgdes = this.gdes[i]; //lastgdes = &(this.gdes[i]); + break; + case RRDGraphDesc.GF.STACK: + throw "STACK should already be turned into LINE or AREA here"; + break; + } + } +// cairo_reset_clip(this.cr); + if (!this.only_graph) + this.grid_paint(); + if (!this.only_graph) + this.axis_paint(); + /* the RULES are the last thing to paint ... */ + for (var i = 0, gdes_c = this.gdes.length; i < gdes_c; i++) { + switch (this.gdes[i].gf) { + case RRDGraphDesc.GF.HRULE: + if (this.gdes[i].yrule >= this.minval && this.gdes[i].yrule <= this.maxval) { + //if (this.gdes[i].dash) cairo_set_dash(this.cr, this.gdes[i].p_dashes, this.gdes[i].ndash, this.gdes[i].offset); + this.gfx_line(this.xorigin, this.ytr(this.gdes[i].yrule), this.xorigin + this.xsize, this.ytr(this.gdes[i].yrule), 1.0, this.gdes[i].col); + } + break; + case RRDGraphDesc.GF.VRULE: + if (this.gdes[i].xrule >= this.start && this.gdes[i].xrule <= this.end) { + //if (this.gdes[i].dash) cairo_set_dash(this.cr, this.gdes[i].p_dashes, this.gdes[i].ndash, this.gdes[i].offset); + this.gfx_line(this.xtr(this.gdes[i].xrule), this.yorigin, this.xtr(this.gdes[i].xrule), this.yorigin - this.ysize, 1.0, this.gdes[i].col); + } + break; + default: + break; + } + } + return 0; + }, + find_var: function(key) + { + for (var ii = 0, gdes_c = this.gdes.length; ii < gdes_c; ii++) { + if ((this.gdes[ii].gf === RRDGraphDesc.GF.DEF || + this.gdes[ii].gf === RRDGraphDesc.GF.VDEF || + this.gdes[ii].gf === RRDGraphDesc.GF.CDEF) + && this.gdes[ii].vname === key) { + return ii; + } + } + return -1; + }, + // DEF:<vname>=<rrdfile>:<ds-name>:<CF>[:step=<step>][:start=<time>][:end=<time>][:reduce=<CF>] + parse_def: function (line) + { + var args = line.split(/:/); + var n=1; + var vnames = args[n++].split('='); + var vname = vnames[0]; + var rrdfile = vnames[1]; + var name = args[n++]; + var cf = args[n++]; + var step = undefined; + var reduce = undefined; + var start = undefined; + var end = undefined; + if (args.length > n) { + for (var j = n, xlen = args.length ; j < xlen ; j++) { + var opts = args[j].split("="); + if (opts[0] === "step") step = opts[1]; + if (opts[0] === "reduce") reduce = opts[1] + if (opts[0] === "start") start = opts[1]; + if (opts[0] === "end") end = opts[1]; + } + } + this.create_def(vname, rrdfile, name, cf, step, start, end, reduce) + }, + create_def: function (vname, rrdfile, name, cf, step, start, end, reduce) + { + var gdp = new RRDGraphDesc(this); + var start_t = new RRDTime(this.start); + var end_t = new RRDTime(this.end); + + gdp.gf = RRDGraphDesc.GF.DEF; + gdp.vname = vname + gdp.vidx = this.find_var(vname); + gdp.rrd = rrdfile; + gdp.ds_nam = name; + gdp.cf = this.cf_conv(cf); + + if (step != undefined && step != null) + gdp.step = step; + if (start != undefined && start != null) + start_t = new RRDTime(start); + if (end != undefined && end != null) + end_t = new RRDTime(end); + if (reduce === undefined || reduce === null) + gdp.cf_reduce = gdp.cf; // ¿? + else + gdp.cf_reduce = this.cf_conv(reduce); + gdp.legend = ''; + + var start_end = RRDTime.proc_start_end(start_t, end_t); // FIXME here? + gdp.start = start_end[0]; + gdp.end = start_end[1]; + gdp.start_orig = start_end[0]; + gdp.end_orig = start_end[1]; + + this.gdes.push(gdp); + }, + // CDEF:vname=RPN expression + parse_cdef: function (line) + { + var args = line.split(/:|=/); + this.create_cdef(args[1], args[2]); + }, + create_cdef:function (vname, rpn) + { + var gdp = new RRDGraphDesc(this); + gdp.gf = RRDGraphDesc.GF.CDEF; + gdp.vname = vname + gdp.vidx = this.find_var(vname); + + gdp.rpnp = new RRDRpn(rpn,this.gdes); + + gdp.legend = ''; + this.gdes.push(gdp); + }, + // VDEF:vname=RPN expression + parse_vdef: function (line) + { + var args = line.split(/:|=/); + this.create_vdef(args[1], args[2]); + }, + create_vdef:function (vname, rpn) + { + var gdp = new RRDGraphDesc(this); + gdp.gf = RRDGraphDesc.GF.VDEF; + gdp.vname = vname + + var index = rpn.indexOf(','); + var name = rpn.substring(0,index); + gdp.vidx = this.find_var(name); // FIXME checks + if (this.gdes[gdp.vidx].gf != RRDGraphDesc.GF.DEF && this.gdes[gdp.vidx].gf != RRDGraphDesc.GF.CDEF) { + throw 'variable "'+name+'" not DEF nor CDEF in VDEF.'; + } + + this.vdef_parse(gdp, rpn.substring(index+1)); + + gdp.legend = ''; + this.gdes.push(gdp); + }, + // SHIFT:vname:offset + parse_shift: function (line) + { + var args = line.split(':'); + this.create_shift(args[1], args[2]); + }, + create_shift: function (vname, offset) + { + var gdp = new RRDGraphDesc(this); + gdp.gf = RRDGraphDesc.GF.SHIFT; + gdp.vname = vname // Â? + gdp.vidx = this.find_var(vname); // FIXME checks + + if (this.gdes[gdp.vidx].gf === RRDGraphDesc.GF.VDEF) + throw "Cannot shift a VDEF: '%s' in line '"+this.gdes[gdp.vidx].vname+"'"; + if (this.gdes[gdp.vidx].gf !== RRDGraphDesc.GF.DEF && this.gdes[gdp.vidx].gf !== RRDGraphDesc.GF.CDEF) + throw "Encountered unknown type variable '"+this.gdes[gdp.vidx].vname+"'"; + + gdp.shidx = this.find_var(offset); + if (gdp.shidx >= 0) { + if (this.gdes[gdp.shidx].gf === RRDGraphDesc.GF.DEF || this.gdes[gdp.shidx].gf === RRDGraphDesc.GF.CDEF) + throw "Offset cannot be a (C)DEF: '"+this.gdes[gdp.shidx].gf+"'"; + if (this.gdes[gdp.shidx].gf !== RRDGraphDesc.GF.VDEF) + throw "Encountered unknown type variable '"+this.gdes[gdp.shidx].vname+"'"; + } else { + gdp.shval = parseInt(offset); // FIXME check + gdp.shidx = -1; + } + gdp.legend = ''; + this.gdes.push(gdp); + }, + // LINE[width]:value[#color][:[legend][:STACK]][:dashes[=on_s[,off_s[,on_s,off_s]...]][:dash-offset=offset]] + parse_line: function (line) + { + var args = line.split(/#|:/); + var width = parseFloat(args[0].substr(4)); + var stack = args[4] === 'STACK' ? true : undefined; + var color = this.parse_color(args[2]); + this.create_line(width, args[1], this.color2rgba(color), args[3], stack); + }, + create_line: function (width, value, color, legend, stack) + { + var gdp = new RRDGraphDesc(this); + + gdp.gf = RRDGraphDesc.GF.LINE; + gdp.vname = value; + gdp.vidx = this.find_var(value); + gdp.linewidth = width; + gdp.col = color; + if (legend === undefined) gdp.legend = ''; + else gdp.legend = ' '+legend; + if (stack === undefined) gdp.stack = false; + else gdp.stack = stack; + gdp.format = gdp.legend; + this.gdes.push(gdp); + }, + // AREA:value[#color][:[legend][:STACK]] + parse_area: function (line) + { + var args = line.split(/#|:/); + var stack = args[3] === 'STACK' ? true : undefined; + var color = this.parse_color(args[2]); + this.create_area(args[1], this.color2rgba(color), stack); + }, + create_area: function (value, color, legend, stack) + { + var gdp = new RRDGraphDesc(this); + + gdp.gf = RRDGraphDesc.GF.AREA; + gdp.vname = value; + gdp.vidx = this.find_var(value); + gdp.col = color; + if (legend === undefined) gdp.legend = ''; + else gdp.legend = ' '+legend; + if (stack === undefined) gdp.stack = false; + else gdp.stack = stack; + gdp.format = gdp.legend; + this.gdes.push(gdp); + }, + // TICK:vname#rrggbb[aa][:fraction[:legend]] + parse_tick: function (line) + { + var args = line.split(/:|#/); + var color = this.parse_color(args[2]); + this.create_tick(args[1], this.color2rgba(color), args[3], args[4]); + }, + create_tick: function (vname, color, fraction, legend) + { + var gdp = new RRDGraphDesc(this); + gdp.gf = RRDGraphDesc.GF.TICK; + gdp.vname = vname; + gdp.vidx = this.find_var(vname); + gdp.col = color; + if (legend !== undefined) + gdp.yrule = fraction; + if (legend === undefined) gdp.legend = ''; + else gdp.legend = ' '+legend; + gdp.format = gdp.legend; + this.gdes.push(gdp); + }, + // GPRINT:vname:format + parse_gprint: function(line) + { + var args = line.split(':'); + var strftime = false; + var vname = args[1]; + var cf = args[2]; + var format = ""; + if (args.length > 3) { + var m=0; + for (var j = 3, xlen = args.length ; j < xlen ; j++) { + if (args[j] === 'strftime') { + strftime = true; + } else { + if (m>0) { + format = format + ':'+ args[j]; + } else { + format = args[j]; + } + m++; + } + } + } + this.create_gprint(vname, cf, format, strftime); + }, + create_gprint: function (vname, cf, format, strftime) + { + var gdp = new RRDGraphDesc(this); + gdp.gf = RRDGraphDesc.GF.GPRINT; + gdp.vname = vname; + gdp.vidx = this.find_var(vname); + gdp.legend = ''; + if (format === undefined) { + gdp.format = cf; + switch (this.gdes[gdp.vidx].gf) { + case RRDGraphDesc.GF.DEF: + case RRDGraphDesc.GF.CDEF: + gdp.cf = this.gdes[gdp.vidx].cf; + break; + case RRDGraphDesc.GF.VDEF: + break; + default: + throw "Encountered unknown type variable "+this.gdes[gdp.vidx].vname; + } + } else { + gdp.cf = this.cf_conv(cf); + gdp.format = format; + } + // if (this.gdes[gdp.vidx].gf === RRDGraphDesc.GF.VDEF && gdp.strftm === true) // FIXME + if (this.gdes[gdp.vidx].gf === RRDGraphDesc.GF.VDEF && strtime === true) // FIXME + gdp.strftm = true; + this.gdes.push(gdp); + }, + //COMMENT:text + parse_comment: function (line) + { + var index = line.indexOf(':'); + this.create_comment(line.substr(index+1)); + }, + create_comment: function (text) + { + var gdp = new RRDGraphDesc(this); + gdp.gf = RRDGraphDesc.GF.COMMENT; + gdp.vidx = -1; + gdp.legend = text; + this.gdes.push(gdp); + }, + // TEXTALIGN:{left|right|justified|center} + parse_textaling: function (line) + { + var index = line.indexOf(':'); + this.create_textaling(line.substr(index+1)); + }, + create_textalign: function (align) + { + var gdp = new RRDGraphDesc(this); + gdp.gf = RRDGraphDesc.GF.TEXTALIGN; + gdp.vidx = -1; + if (align === "left") { + gdp.txtalign = RRDGraphDesc.TXA.LEFT; + } else if (align === "right") { + gdp.txtalign = RRDGraphDesc.TXA.RIGHT; + } else if (align === "justified") { + gdp.txtalign = RRDGraphDesc.TXA.JUSTIFIED; + } else if (align === "center") { + gdp.txtalign = RRDGraphDesc.TXA.CENTER; + } else { + throw "Unknown alignement type '"+align+"'"; + } + this.gdes.push(gdp); + }, + // VRULE:time#color[:legend][:dashes[=on_s[,off_s[,on_s,off_s]...]][:dash-offset=offset]] + parse_vrule: function (line) + { + var args = line.split(/:|#/); + this.create_vrule(args[1], '#'+args[2], args[3]); + }, + create_vrule: function (time, color, legend) + { + var gdp = new RRDGraphDesc(this); + + gdp.gf = RRDGraphDesc.GF.VRULE; + gdp.xrule = time; + gdp.col = color; + if (legend === undefined) gdp.legend = ''; + else gdp.legend = ' '+legend; + this.gdes.push(gdp); + }, + // HRULE:value#color[:legend][:dashes[=on_s[,off_s[,on_s,off_s]...]][:dash-offset=offset]] + parse_hrule: function (line) + { + var args = line.split(/:|#/); + this.create_hrule(args[1], '#'+args[2], args[3]); + }, + create_hrule: function (value, color, legend) + { + var gdp = new RRDGraphDesc(this); + + gdp.gf = RRDGraphDesc.GF.HRULE; + gdp.yrule = value; + gdp.col = color; + if (legend === undefined) gdp.legend = ''; + else gdp.legend = ' '+legend; + + this.gdes.push(gdp); + }, + cf_conv: function (str) + { + switch (str){ + case 'AVERAGE': return RRDGraphDesc.CF.AVERAGE; + case 'MIN': return RRDGraphDesc.CF.MINIMUM; + case 'MAX': return RRDGraphDesc.CF.MAXIMUM; + case 'LAST': return RRDGraphDesc.CF.LAST; + case 'HWPREDICT': return RRDGraphDesc.CF.HWPREDICT; + case 'MHWPREDICT': return RRDGraphDesc.CF.MHWPREDICT; + case 'DEVPREDICT': return RRDGraphDesc.CF.DEVPREDICT; + case 'SEASONAL': return RRDGraphDesc.CF.SEASONAL; + case 'DEVSEASONAL': return RRDGraphDesc.CF.DEVSEASONAL; + case 'FAILURES': return RRDGraphDesc.CF.FAILURES; + } + return -1; + }, + tmt_conv: function (str) + { + switch (str) { + case 'SECOND': return RRDGraph.TMT.SECOND; + case 'MINUTE': return RRDGraph.TMT.MINUTE; + case 'HOUR': return RRDGraph.TMT.HOUR; + case 'DAY': return RRDGraph.TMT.DAY; + case 'WEEK': return RRDGraph.TMT.WEEK; + case 'MONTH': return RRDGraph.TMT.MONTH; + case 'YEAR': return RRDGraph.TMT.YEAR; + } + return -1; + }, + // struct graph_desc_t *gdes, const char *const str) + vdef_parse: function(gdes, str) + { /* A VDEF currently is either "func" or "param,func" so the parsing is rather simple. Change if needed. */ + var param; + var func; + var n; + + n = 0; + var index = str.indexOf(','); + if (index != -1) { + param = parseFloat(str.substr(0,index)); + func = str.substr(index+1); + } else { + param = Number.NAN; + func = str; + } + + gdes.vf = { op: null, param: null, val: null, when: null }; + + if (func === 'PERCENT') gdes.vf.op = RRDGraphDesc.VDEF.PERCENT; + else if (func === 'PERCENTNAN') gdes.vf.op = RRDGraphDesc.VDEF.PERCENTNAN; + else if (func === 'MAXIMUM') gdes.vf.op = RRDGraphDesc.VDEF.MAXIMUM; + else if (func === 'AVERAGE') gdes.vf.op = RRDGraphDesc.VDEF.AVERAGE; + else if (func === 'STDEV') gdes.vf.op = RRDGraphDesc.VDEF.STDEV; + else if (func === 'MINIMUM') gdes.vf.op = RRDGraphDesc.VDEF.MINIMUM; + else if (func === 'TOTAL') gdes.vf.op = RRDGraphDesc.VDEF.TOTAL; + else if (func === 'FIRST') gdes.vf.op = RRDGraphDesc.VDEF.FIRST; + else if (func === 'LAST') gdes.vf.op = RRDGraphDesc.VDEF.LAST; + else if (func === 'LSLSLOPE') gdes.vf.op = RRDGraphDesc.VDEF.LSLSLOPE; + else if (func === 'LSLINT') gdes.vf.op = RRDGraphDesc.VDEF.LSLINT; + else if (func === 'LSLCORREL') gdes.vf.op = RRDGraphDesc.VDEF.LSLCORREL; + else { + throw 'Unknown function "'+func+'" in VDEF "'+gdes.vame+'"'; + } + + switch (gdes.vf.op) { + case RRDGraphDesc.VDEF.PERCENT: + case RRDGraphDesc.VDEF.PERCENTNAN: + if (isNaN(param)) { /* no parameter given */ + throw "Function '"+func+"' needs parameter in VDEF '"+gdes.vname+"'"; + } + if (param >= 0.0 && param <= 100.0) { + gdes.vf.param = param; + gdes.vf.val = Number.NAN; /* undefined */ + gdes.vf.when = 0; /* undefined */ + } else { + throw "Parameter '"+param+"' out of range in VDEF '"+gdes.vname+"'"; + } + break; + case RRDGraphDesc.VDEF.MAXIMUM: + case RRDGraphDesc.VDEF.AVERAGE: + case RRDGraphDesc.VDEF.STDEV: + case RRDGraphDesc.VDEF.MINIMUM: + case RRDGraphDesc.VDEF.TOTAL: + case RRDGraphDesc.VDEF.FIRST: + case RRDGraphDesc.VDEF.LAST: + case RRDGraphDesc.VDEF.LSLSLOPE: + case RRDGraphDesc.VDEF.LSLINT: + case RRDGraphDesc.VDEF.LSLCORREL: + if (isNaN(param)) { + gdes.vf.param = Number.NAN; + gdes.vf.val = Number.NAN; + gdes.vf.when = 0; + } else { + throw "Function '"+func+"' needs no parameter in VDEF '"+gdes.vname+"'"; + } + break; + } + return 0; + }, + vdef_calc: function(gdi) + { + var src, dst; + var data; + var step, steps; + + dst = this.gdes[gdi]; + src = this.gdes[dst.vidx]; + //data = src.data + src.ds; // FIXME ¿? + data = src.data; + + steps = (src.end - src.start) / src.step; + + switch (dst.vf.op) { + case RRDGraphDesc.VDEF.PERCENT: + var array = []; + var field; + + for (step = 0; step < steps; step++) { + array[step] = data[step * src.ds_cnt]; + } + array.sort(this.vdef_percent_compar); + field = Math.round((dst.vf.param * (steps - 1)) / 100.0); + dst.vf.val = array[field]; + dst.vf.when = 0; /* no time component */ + break; + case RRDGraphDesc.VDEF.PERCENTNAN: + var array = []; + var field; + //var nancount=0; + + field=0; + for (step = 0; step < steps; step++) { + if (!isNaN(data[step * src.ds_cnt])) { + array[field] = data[step * src.ds_cnt]; + } + } + array.sort(vdef_percent_compar); + field = Math.round(dst.vf.param * (field - 1) / 100.0); + dst.vf.val = array[field]; + dst.vf.when = 0; /* no time component */ + break; + case RRDGraphDesc.VDEF.MAXIMUM: + step = 0; + while (step != steps && isNaN(data[step * src.ds_cnt])) step++; + if (step === steps) { + dst.vf.val = Number.NAN; + dst.vf.when = 0; + } else { + dst.vf.val = data[step * src.ds_cnt]; + dst.vf.when = src.start + (step + 1) * src.step; + } + while (step != steps) { + if (isFinite(data[step * src.ds_cnt])) { + if (data[step * src.ds_cnt] > dst.vf.val) { + dst.vf.val = data[step * src.ds_cnt]; + dst.vf.when = src.start + (step + 1) * src.step; + } + } + step++; + } + break; + case RRDGraphDesc.VDEF.TOTAL: + case RRDGraphDesc.VDEF.STDEV: + case RRDGraphDesc.VDEF.AVERAGE: + var cnt = 0; + var sum = 0.0; + var average = 0.0; + + for (step = 0; step < steps; step++) { + if (isFinite(data[step * src.ds_cnt])) { + sum += data[step * src.ds_cnt]; + cnt++; + } + } + + if (cnt) { + if (dst.vf.op === RRDGraphDesc.VDEF.TOTAL) { + dst.vf.val = sum * src.step; + dst.vf.when = 0; /* no time component */ + } else if (dst.vf.op === RRDGraphDesc.VDEF.AVERAGE) { + dst.vf.val = sum / cnt; + dst.vf.when = 0; /* no time component */ + } else { + average = sum / cnt; + sum = 0.0; + for (step = 0; step < steps; step++) { + if (isFinite(data[step * src.ds_cnt])) { + sum += Math.pow((data[step * src.ds_cnt] - average), 2.0); + } + } + dst.vf.val = Math.pow(sum / cnt, 0.5); + dst.vf.when = 0; /* no time component */ + } + } else { + dst.vf.val = Number.NAN; + dst.vf.when = 0; + } + break; + case RRDGraphDesc.VDEF.MINIMUM: + step = 0; + while (step != steps && isNaN(data[step * src.ds_cnt])) step++; + if (step === steps) { + dst.vf.val = Number.NAN; + dst.vf.when = 0; + } else { + dst.vf.val = data[step * src.ds_cnt]; + dst.vf.when = src.start + (step + 1) * src.step; + } + while (step != steps) { + if (isFinite(data[step * src.ds_cnt])) { + if (data[step * src.ds_cnt] < dst.vf.val) { + dst.vf.val = data[step * src.ds_cnt]; + dst.vf.when = src.start + (step + 1) * src.step; + } + } + step++; + } + break; + case RRDGraphDesc.VDEF.FIRST: + step = 0; + while (step != steps && isNaN(data[step * src.ds_cnt])) step++; + if (step === steps) { /* all entries were NaN */ + dst.vf.val = Number.NAN; + dst.vf.when = 0; + } else { + dst.vf.val = data[step * src.ds_cnt]; + dst.vf.when = src.start + step * src.step; + } + break; + case RRDGraphDesc.VDEF.LAST: + step = steps - 1; + while (step >= 0 && isNaN(data[step * src.ds_cnt])) step--; + if (step < 0) { /* all entries were NaN */ + dst.vf.val = Number.NAN; + dst.vf.when = 0; + } else { + dst.vf.val = data[step * src.ds_cnt]; + dst.vf.when = src.start + (step + 1) * src.step; + } + break; + case RRDGraphDesc.VDEF.LSLSLOPE: + case RRDGraphDesc.VDEF.LSLINT: + case RRDGraphDesc.VDEF.LSLCORREL: + var cnt = 0; + var SUMx, SUMy, SUMxy, SUMxx, SUMyy, slope, y_intercept, correl; + + SUMx = 0; + SUMy = 0; + SUMxy = 0; + SUMxx = 0; + SUMyy = 0; + + for (step = 0; step < steps; step++) { + if (isFinite(data[step * src.ds_cnt])) { + cnt++; + SUMx += step; + SUMxx += step * step; + SUMxy += step * data[step * src.ds_cnt]; + SUMy += data[step * src.ds_cnt]; + SUMyy += data[step * src.ds_cnt] * data[step * src.ds_cnt]; + } + } + + slope = (SUMx * SUMy - cnt * SUMxy) / (SUMx * SUMx - cnt * SUMxx); + y_intercept = (SUMy - slope * SUMx) / cnt; + correl = (SUMxy - (SUMx * SUMy) / cnt) / Math.sqrt((SUMxx - (SUMx * SUMx) / cnt) * (SUMyy - (SUMy * SUMy) / cnt)); + + if (cnt) { + if (dst.vf.op === RRDGraphDesc.VDEF.LSLSLOPE) { + dst.vf.val = slope; + dst.vf.when = 0; + } else if (dst.vf.op === RRDGraphDesc.VDEF.LSLINT) { + dst.vf.val = y_intercept; + dst.vf.when = 0; + } else if (dst.vf.op === RRDGraphDesc.VDEF.LSLCORREL) { + dst.vf.val = correl; + dst.vf.when = 0; + } + } else { + dst.vf.val = DNAN; + dst.vf.when = 0; + } + break; + } + return 0; + }, + vdef_percent_compar: function (a, b) + { /* Equality is not returned; this doesn't hurt except (maybe) for a little performance. */ + /* NaN < -INF < finite_values < INF */ + if (isNaN(a)) return -1; + if (isNaN(b)) return 1; + /* NaN doesn't reach this part so INF and -INF are extremes. The sign from isinf() is compatible with the sign we return */ + if (!isFinite(a)) { + if (a === -Infinity) return -1; + else return 1; + } + if (!isFinite(b)) { + if (b === -Infinity) return -1; + else return 1; + } + /* If we reach this, both values must be finite */ + if (a < b) return -1; + else return 1; + }, + rrd_fetch: function(gdp, ft_step) + { + var cal_start, cal_end; + var best_full_rra = 0, best_part_rra = 0, chosen_rra = 0; + var best_full_step_diff = 0, best_part_step_diff = 0, tmp_step_diff = 0, tmp_match = 0, best_match = 0; + var full_match, rra_base; + var first_full = 1; + var first_part = 1; + var rrd; + var data_ptr; + var rows; + + try { + if (this.rrdfiles[gdp.rrd]) { + rrd = this.rrdfiles[gdp.rrd]; + } else { + var bf = FetchBinaryURL(gdp.rrd); + rrd = new RRDFile(bf); + this.rrdfiles[gdp.rrd] = rrd; + } + } catch(err) { + console.log(err.message); + console.log(err.stack); + throw "File "+gdp.rrd+" is not a valid RRD archive!"; + } + + var cf_idx = gdp.cf; + var ds_cnt = rrd.getNrDSs(); + var rra_cnt = rrd.getNrRRAs(); + + for (var i = 0; i < ds_cnt; i++) + gdp.ds_namv[i] = rrd.rrd_header.getDSbyIdx(i).getName(); + + for (var i = 0; i < rra_cnt; i++) { + var rra = rrd.getRRAInfo(i); + if (this.cf_conv(rra.getCFName()) === cf_idx) { + cal_end = (rrd.getLastUpdate() - (rrd.getLastUpdate() % (rra.getPdpPerRow() * rra.pdp_step))); + cal_start = (cal_end - (rra.getPdpPerRow() * rra.row_cnt * rra.pdp_step)); + full_match = gdp.end - gdp.start + + tmp_step_diff = Math.abs(ft_step - (rrd.getMinStep() * rra.pdp_cnt)); + if (cal_start <= gdp.start) { + if (first_full || (tmp_step_diff < best_full_step_diff)) { + first_full = 0; + best_full_step_diff = tmp_step_diff; + best_full_rra = i; + } + } else { + tmp_match = full_match; + if (cal_start > gdp.start) tmp_match -= (cal_start - gdp.start); + if (first_part || (best_match < tmp_match) || (best_match === tmp_match && tmp_step_diff < best_part_step_diff)) { + first_part = 0; + best_match = tmp_match; + best_part_step_diff = tmp_step_diff; + best_part_rra = i; + } + } + } + } + + if (first_full === 0) chosen_rra = best_full_rra; + else if (first_part === 0) chosen_rra = best_part_rra; + else throw "the RRD does not contain an RRA matching the chosen CF"; + + var rra_info = rrd.getRRAInfo(chosen_rra); + var rra = rrd.getRRA(chosen_rra); + + ft_step = rrd.rrd_header.pdp_step * rra_info.getPdpPerRow(); + gdp.start -= (gdp.start % ft_step); + gdp.end += (ft_step - gdp.end % ft_step); + rows = (gdp.end - gdp.start) / ft_step + 1; + + gdp.ds_cnt = ds_cnt; + data_ptr = 0; + + var rra_end_time = (rrd.getLastUpdate() - (rrd.getLastUpdate() % ft_step)); + var rra_start_time = (rra_end_time - (ft_step * (rra_info.row_cnt - 1))); + /* here's an error by one if we don't be careful */ + var start_offset = (gdp.start + ft_step - rra_start_time) / ft_step; + var end_offset = (rra_end_time - gdp.end) / ft_step; + + gdp.data = []; + + for (i = start_offset; i < rra.row_cnt - end_offset; i++) { + if (i < 0) { + for (var ii = 0; ii < ds_cnt; ii++) gdp.data[data_ptr++] = Number.NaN; + } else if (i >= rra.row_cnt) { + for (var ii = 0; ii < ds_cnt; ii++) gdp.data[data_ptr++] = Number.NaN; + } else { + for (var ii = 0; ii < ds_cnt; ii++) { + gdp.data[data_ptr++] = rra.getEl(i, ii); + } + } + } + return ft_step; + } +} |