// mercurial.js - JavaScript utility functions

 //

 // Rendering of branch DAGs on the client side

 // Display of elapsed time

 // Show or hide diffstat

 //

 // Copyright 2008 Dirkjan Ochtman <dirkjan AT ochtman DOT nl>

 // Copyright 2006 Alexander Schremmer <alex AT alexanderweb DOT de>

 //

 // derived from code written by Scott James Remnant <scott@ubuntu.com>

 // Copyright 2005 Canonical Ltd.

 //

 // This software may be used and distributed according to the terms

 // of the GNU General Public License, incorporated herein by reference.

 var colors = [

 	[ 1.0, 0.0, 0.0 ],

 	[ 1.0, 1.0, 0.0 ],

 	[ 0.0, 1.0, 0.0 ],

 	[ 0.0, 1.0, 1.0 ],

 	[ 0.0, 0.0, 1.0 ],

 	[ 1.0, 0.0, 1.0 ]

 ];

 function Graph() {

 	this.canvas = document.getElementById('graph');

 	this.ctx = this.canvas.getContext('2d');

 	this.ctx.strokeStyle = 'rgb(0, 0, 0)';

 	this.ctx.fillStyle = 'rgb(0, 0, 0)';

 	this.bg = [0, 4];

 	this.cell = [2, 0];

 	this.columns = 0;

 }

 Graph.prototype = {

 	reset: function() {

 		this.bg = [0, 4];

 		this.cell = [2, 0];

 		this.columns = 0;

 	},

 	scale: function(height) {

 		this.bg_height = height;

 		this.box_size = Math.floor(this.bg_height / 1.2);

 		this.cell_height = this.box_size;

 	},

 	setColor: function(color, bg, fg) {

 		// Set the colour.

 		//

 		// If color is a string, expect an hexadecimal RGB

 		// value and apply it unchanged. If color is a number,

 		// pick a distinct colour based on an internal wheel;

 		// the bg parameter provides the value that should be

 		// assigned to the 'zero' colours and the fg parameter

 		// provides the multiplier that should be applied to

 		// the foreground colours.

 		var s;

 		if(typeof color === "string") {

 			s = "#" + color;

 		} else { //typeof color === "number"

 			color %= colors.length;

 			var red = (colors[color][0] * fg) || bg;

 			var green = (colors[color][1] * fg) || bg;

 			var blue = (colors[color][2] * fg) || bg;

 			red = Math.round(red * 255);

 			green = Math.round(green * 255);

 			blue = Math.round(blue * 255);

 			s = 'rgb(' + red + ', ' + green + ', ' + blue + ')';

 		}

 		this.ctx.strokeStyle = s;

 		this.ctx.fillStyle = s;

 		return s;

 	},

 	edge: function(x0, y0, x1, y1, color, width) {

 		this.setColor(color, 0.0, 0.65);

 		if(width >= 0)

 			 this.ctx.lineWidth = width;

 		this.ctx.beginPath();

 		this.ctx.moveTo(x0, y0);

 		this.ctx.lineTo(x1, y1);

 		this.ctx.stroke();

 	},

 	graphNodeCurrent: function(x, y, radius) {

 		this.ctx.lineWidth = 2;

 		this.ctx.beginPath();

 		this.ctx.arc(x, y, radius * 1.75, 0, Math.PI * 2, true);

 		this.ctx.stroke();

 	},

 	graphNodeClosing: function(x, y, radius) {

 		this.ctx.fillRect(x - radius, y - 1.5, radius * 2, 3);

 	},

 	graphNodeUnstable: function(x, y, radius) {

 		var x30 = radius * Math.cos(Math.PI / 6);

 		var y30 = radius * Math.sin(Math.PI / 6);

 		this.ctx.lineWidth = 2;

 		this.ctx.beginPath();

 		this.ctx.moveTo(x, y - radius);

 		this.ctx.lineTo(x, y + radius);

 		this.ctx.moveTo(x - x30, y - y30);

 		this.ctx.lineTo(x + x30, y + y30);

 		this.ctx.moveTo(x - x30, y + y30);

 		this.ctx.lineTo(x + x30, y - y30);

 		this.ctx.stroke();

 	},

 	graphNodeObsolete: function(x, y, radius) {

 		var p45 = radius * Math.cos(Math.PI / 4);

 		this.ctx.lineWidth = 3;

 		this.ctx.beginPath();

 		this.ctx.moveTo(x - p45, y - p45);

 		this.ctx.lineTo(x + p45, y + p45);

 		this.ctx.moveTo(x - p45, y + p45);

 		this.ctx.lineTo(x + p45, y - p45);

 		this.ctx.stroke();

 	},

 	graphNodeNormal: function(x, y, radius) {

 		this.ctx.beginPath();

 		this.ctx.arc(x, y, radius, 0, Math.PI * 2, true);

 		this.ctx.fill();

 	},

 	vertex: function(x, y, radius, color, parity, cur) {

 		this.ctx.save();

 		this.setColor(color, 0.25, 0.75);

 		if (cur.graphnode[0] === '@') {

 			this.graphNodeCurrent(x, y, radius);

 		}

 		switch (cur.graphnode.substr(-1)) {

 			case '_':

 				this.graphNodeClosing(x, y, radius);

 				break;

 			case '*':

 				this.graphNodeUnstable(x, y, radius);

 				break;

 			case 'x':

 				this.graphNodeObsolete(x, y, radius);

 				break;

 			default:

 				this.graphNodeNormal(x, y, radius);

 		}

 		this.ctx.restore();

 		var left = (this.bg_height - this.box_size) + (this.columns + 1) * this.box_size;

 		var item = document.querySelector('[data-node="' + cur.node + '"]');

 		if (item) {

 			item.style.paddingLeft = left + 'px';

 		}

 	},

 	render: function(data) {

 		var i, j, cur, line, start, end, color, x, y, x0, y0, x1, y1, column, radius;

 		var cols = 0;

 		for (i = 0; i < data.length; i++) {

 			cur = data[i];

 			for (j = 0; j < cur.edges.length; j++) {

 				line = cur.edges[j];

 				cols = Math.max(cols, line[0], line[1]);

 			}

 		}

 		this.canvas.width = (cols + 1) * this.bg_height;

 		this.canvas.height = (data.length + 1) * this.bg_height - 27;

 		for (i = 0; i < data.length; i++) {

 			var parity = i % 2;

 			this.cell[1] += this.bg_height;

 			this.bg[1] += this.bg_height;

 			cur = data[i];

 			var fold = false;

 			var prevWidth = this.ctx.lineWidth;

 			for (j = 0; j < cur.edges.length; j++) {

 				line = cur.edges[j];

 				start = line[0];

 				end = line[1];

 				color = line[2];

 				var width = line[3];

 				if(width < 0)

 					 width = prevWidth;

 				var branchcolor = line[4];

 				if(branchcolor)

 					color = branchcolor;

 				if (end > this.columns || start > this.columns) {

 					this.columns += 1;

 				}

 				if (start === this.columns && start > end) {

 					fold = true;

 				}

 				x0 = this.cell[0] + this.box_size * start + this.box_size / 2;

 				y0 = this.bg[1] - this.bg_height / 2;

 				x1 = this.cell[0] + this.box_size * end + this.box_size / 2;

 				y1 = this.bg[1] + this.bg_height / 2;

 				this.edge(x0, y0, x1, y1, color, width);

 			}

 			this.ctx.lineWidth = prevWidth;

 			// Draw the revision node in the right column

 			column = cur.vertex[0];

 			color = cur.vertex[1];

 			radius = this.box_size / 8;

 			x = this.cell[0] + this.box_size * column + this.box_size / 2;

 			y = this.bg[1] - this.bg_height / 2;

 			this.vertex(x, y, radius, color, parity, cur);

 			if (fold) this.columns -= 1;

 		}

 	}

 };

 function process_dates(parentSelector){

 	// derived from code from mercurial/templatefilter.py

 	var scales = {

 		'year':  365 * 24 * 60 * 60,

 		'month':  30 * 24 * 60 * 60,

 		'week':    7 * 24 * 60 * 60,

 		'day':    24 * 60 * 60,

 		'hour':   60 * 60,

 		'minute': 60,

 		'second': 1

 	};

 	function format(count, string){

 		var ret = count + ' ' + string;

 		if (count > 1){

 			ret = ret + 's';

 		}

  		return ret;

  	}

 	function shortdate(date){

 		var ret = date.getFullYear() + '-';

 		// getMonth() gives a 0-11 result

 		var month = date.getMonth() + 1;

 		if (month <= 9){

 			ret += '0' + month;

 		} else {

 			ret += month;

 		}

 		ret += '-';

 		var day = date.getDate();

 		if (day <= 9){

 			ret += '0' + day;

 		} else {

 			ret += day;

 		}

 		return ret;

 	}

  	function age(datestr){

  		var now = new Date();

  		var once = new Date(datestr);

 		if (isNaN(once.getTime())){

 			// parsing error

 			return datestr;

 		}

 		var delta = Math.floor((now.getTime() - once.getTime()) / 1000);

 		var future = false;

 		if (delta < 0){

 			future = true;

 			delta = -delta;

 			if (delta > (30 * scales.year)){

 				return "in the distant future";

 			}

 		}

 		if (delta > (2 * scales.year)){

 			return shortdate(once);

 		}

 		for (var unit in scales){

 			if (!scales.hasOwnProperty(unit)) { continue; }

 			var s = scales[unit];

 			var n = Math.floor(delta / s);

 			if ((n >= 2) || (s === 1)){

 				if (future){

 					return format(n, unit) + ' from now';

 				} else {

 					return format(n, unit) + ' ago';

 				}

 			}

 		}

 	}

 	var nodes = document.querySelectorAll((parentSelector || '') + ' .age');

 	var dateclass = new RegExp('\\bdate\\b');

 	for (var i=0; i<nodes.length; ++i){

 		var node = nodes[i];

 		var classes = node.className;

 		var agevalue = age(node.textContent);

 		if (dateclass.test(classes)){

 			// We want both: date + (age)

 			node.textContent += ' ('+agevalue+')';

 		} else {

 			node.title = node.textContent;

 			node.textContent = agevalue;

 		}

 	}

 }

 function toggleDiffstat(event) {

     var curdetails = document.getElementById('diffstatdetails').style.display;

     var curexpand = curdetails === 'none' ? 'inline' : 'none';

     document.getElementById('diffstatdetails').style.display = curexpand;

     document.getElementById('diffstatexpand').style.display = curdetails;

     event.preventDefault();

 }

 function toggleLinewrap(event) {

     function getLinewrap() {

         var nodes = document.getElementsByClassName('sourcelines');

         // if there are no such nodes, error is thrown here

         return nodes[0].classList.contains('wrap');

     }

     function setLinewrap(enable) {

         var nodes = document.getElementsByClassName('sourcelines');