//=======================================================\\
//                    13thparallel.org                   \\
//                   Copyright (c) 2002                  \\ 
//   see (13thparallel.org/?title=about) for more info   \\
//=======================================================\\

// Columns object to split a load of innerHTML into columns.
// 08/04/02

var Columns = {
	singleTags : ["br", "img", "hr", "input", "!--"],
	devmode : "off",		// "on" or "off", if set to "on" some info will be displayed in the statusbar.
	cols : new Array(),		// Stores the columns during calculations.
	onSplitStart : new Function(),
	onSplitEnd : new Function(),
	onSplit : new Function()
}


// The chop array holds strings that should be removed from the start of every column.
// Don't remove only one part of a tag pair, like </p>, always remove whole pairs, like <p></p>.

Columns.chop = [
'<SPAN class=colbreak></SPAN>',
'<span class="colbreak"></span>',
'<span class="colnobreakbefore"></span>',
'<span class="colnobreakafter"></span>',
'<BR>',
'<br>',
'<br/>',
'<br />',
'<p></p>',
'<P></P>'
]


Columns.popFragment = function(text, width, height) {
        if (!document.getElementById
        || !document.getElementById("divSizer")
        || typeof document.getElementById("divSizer").innerHTML == "undefined") return;

        this.onSplitStart(text, width, height);

        if (!this.cols) {this.cols = new Array();}
	if (!this.remainingText) {this.remainingText = "";}
	if (!this.idxCol) {this.idxCol = 0;}

        this.innerHTMLHits = 0;
        var startDate = new Date();
        var x = "";

//        for (var i = 0; text != ""; i++) {
	i = this.idxCol;

                // put a fitting fragment in cols array and slice it from the text
                this.cols[i] = this.getFragment(text, width, height);
                text = text.slice(this.cols[i].length);
                // remove chop strings from the start of the text
                for (var j = 0; j < this.chop.length; j++) {
                        if (text.charAt(0) == "\n") text = text.slice(1);
                        x = this.chop[j];
                        while (text.indexOf(x) == 0) text = text.slice(x.length);
                }

                // add tags from opentags array
                for (var k = this.openTags.length - 1; k >= 0; k--) {
                        this.cols[i] += "</" + this.openTags[k].split(" ")[0] + ">";
                        if (text != "") text = "<" + this.openTags[k] + ">" + text;
                }

                // remove chop strings from the start of the text again
                for (var m = 0; m < this.chop.length; m++) {
                        if (text.charAt(0) == "\n") text = text.slice(1);
                        x = this.chop[m];
                        while (text.indexOf(x) == 0) text = text.slice(x.length);
                }
	this.remainingText = text;
	this.idxCol++;

                // fire onSplit event
                this.onSplit(this.cols[i]);
//        }

       if (this.devmode == "on") {
                var endDate = new Date();
                var message = "Time taken for splitting text = " + (endDate-startDate)/1000 + " seconds";
                message += " Number of unclosed tags found = " + this.openTags.length;
                message += " innerHTMLHits = " + this.innerHTMLHits;
                defaultStatus = message;
        }

        this.onSplitEnd(this.cols);
        return this;
}


// Splits a load of text into fragments that will fit in the
// specified width and height and returns them in an array.
// It automatically closes unclosed tags and creates opening tags for the following columns.

Columns.splitText = function(text, width, height) {
	if (!document.getElementById 
	|| !document.getElementById("divSizer") 
	|| typeof document.getElementById("divSizer").innerHTML == "undefined") return;
	
	this.onSplitStart(text, width, height);

	this.cols = new Array();
	this.innerHTMLHits = 0;
	var startDate = new Date();
	var x = "";
	
	for (var i = 0; text != ""; i++) {
		
		// put a fitting fragment in cols array and slice it from the text
		this.cols[i] = this.getFragment(text, width, height);
		text = text.slice(this.cols[i].length);
		
		// remove chop strings from the start of the text
		for (var j = 0; j < this.chop.length; j++) {
			if (text.charAt(0) == "\n") text = text.slice(1);
			x = this.chop[j];
			while (text.indexOf(x) == 0) text = text.slice(x.length);
		}
		
		// add tags from opentags array
		for (var k = this.openTags.length - 1; k >= 0; k--) {
			this.cols[i] += "</" + this.openTags[k].split(" ")[0] + ">";
			if (text != "") text = "<" + this.openTags[k] + ">" + text;
		}
		
		// remove chop strings from the start of the text again
		for (var m = 0; m < this.chop.length; m++) {
			if (text.charAt(0) == "\n") text = text.slice(1);
			x = this.chop[m];
			while (text.indexOf(x) == 0) text = text.slice(x.length);
		}
		
		// fire onSplit event
		this.onSplit(this.cols[i]);
	}
	
	if (this.devmode == "on") {
		var endDate = new Date();
		var message = "Time taken for splitting text = " + (endDate-startDate)/1000 + " seconds";
		message += " Number of unclosed tags found = " + this.openTags.length;
		message += " innerHTMLHits = " + this.innerHTMLHits;
		defaultStatus = message;
	}
	
	this.onSplitEnd(this.cols);
	return this.cols;
}

var APPEL=0;

Columns.getFragment = function(text, width, height) {
	var objSizer = document.getElementById("divSizer");
	objSizer.style.width = width + "px";
	
	var i = 0;
	var limit = 0;
	var add = 0;
	var doloop = false;
	this.openTags = new Array();
	this.glueafter = new Array();
	this.glueaftertext = new Array();
	this.gluebefore = new Array();
	this.gluebeforetext = new Array();

//	var jcons = Components.classes['@mozilla.org/consoleservice;1'].getService(Components.interfaces.nsIConsoleService);
	
//	dump("Entering getFragment\n");
	APPEL++;

	objSizer.innerHTML = text;
	if (objSizer.offsetHeight <= height) i = text.length;
	else {
		doloop = true;
		limit = text.length;
	}
	
	
	// This loop determines the raw piece of text that fits in the specified width and height.
	// It is the most powerhungry part of the script because of the repeated innerHTML manipulation.
	// It uses a binary search between 0 and text.length.

	while (doloop) {
		add = Math.round((limit - i) / 2);
		if (add <= 1) doloop = false;
		i += add;
		objSizer.innerHTML = text.substr(0, i);
		
		if (objSizer.offsetHeight > height){
			limit = i;
			i -= add;
		}
		this.innerHTMLHits ++;
	}

	
	// Making sure there are no broken words or tags like "<img" at the end of this fragment.
	// This also ensures there will be no broken words or tags at the start of the next fragment.
	if (text.substr(0, i) != text) {
		var lastSpace = text.substr(0, i).lastIndexOf(" ");
		var lastNewline = text.substr(0, i).lastIndexOf("\n")
		var lastGreater = text.substr(0, i).lastIndexOf(">");
		var lastLess = text.substr(0, i).lastIndexOf("<");
		if (lastLess <= lastGreater && lastNewline == i - 1) i = i;
		else if (lastSpace != -1 && lastSpace > lastGreater && lastGreater > lastLess) i = lastSpace + 1;
		else if (lastLess > lastGreater) i = lastLess;
		else if (lastGreater != -1)  i = lastGreater + 1;
	}
	

	// Doing the column breaks.
	text = text.substr(0, i).split('<SPAN class=colbreak></SPAN>')[0];
	text = text.substr(0, i).split('<span class="colbreak"></span>')[0];
	

	
	// Seeking unclosed tag pairs in this fragment and storing them in the openTags array.
	var doPush = true;
	var tags = text.split("<");
	var reste = text.split("<");
	tags.shift(); 
	
	for (var j=0; j<tags.length; j++) {
	 	// Splitting at ">" and taking the first item.
		// Now we have the whole tag with its attributes and without "<" and ">".
		tags[j] = tags[j].split(">")[0];
		
		// If it's a selfclosing xhtml or xml tag there's no need to do anything with it.
		if (tags[j].charAt(tags[j].length-1) == "/") continue;
		
		if (tags[j].charAt(0) != "/") {
			for (var k=0; k<this.singleTags.length; k++) {
				if (tags[j].split(" ")[0].toLowerCase() == this.singleTags[k]) doPush = false;
			}
			var attributes = tags[j].split(" ");
			for (var k=0; k<attributes.length; k++) {
				if (attributes[k] == 'glue="after"')  {
					this.glueafter.push(0);
//	dump("["+APPEL+"]  glue=after detecte "+tags[j]+"\n");
					var lereste = "";
					for (var l=j;l<reste.length;l++) {lereste += "<"+reste[l];}
					this.glueaftertext.push(lereste);
				}
			}
			if (doPush) {
				this.openTags.push(tags[j]);
				for (var k=0; k<this.glueafter.length; k++) {
					this.glueafter[k]++;
//	dump("["+APPEL+"]  +glueafter["+k+"]="+this.glueafter[k]+"\n");
				}
			}
			doPush = true;
		}
		else {
			this.openTags.pop();
			for (var k=0; k<this.glueafter.length; k++) {
				this.glueafter[k]--;
//	dump("["+APPEL+"]  -glueafter["+k+"]="+this.glueafter[k]+"\n");
				if (this.glueafter[k] == 0) {
					this.glueafter.pop();
					this.glueaftertext.pop();
				}
			}
		}
	}

	// Seeking not desired orphans and widows 

	// this.glueafter[0] contient le nombre de tags restant ouverts a partir du 
	// tag "glue=after" (y compris ce dernier)

//	dump("["+APPEL+"]  glueafterlength["+this.glueafter.length+"]\n");
	if (this.glueafter.length != 0) {
		for (k=0;k<this.glueafter.length;k++) {
			this.openTags.pop();
		}
		text = text.substr(0, i).split(this.glueaftertext[0])[0];
//	dump("["+APPEL+"]  "+this.glueaftertext[0]+"\n");
	}
	
	return text;
}



// Array and String prototypes.
// Internet Explorer 5 didn't have Push, Pop and Shift so here we create them.
// Split and Join are normally supported by every DHTML capable browser, 
// but they were broken in IE5/MacOSX, madness.

// push appends new elements to an array, and returns the new length
if (Array.prototype && !Array.prototype.push) {
	Array.prototype.push = function() {
		for (var i=0; i<arguments.length; i++) this[this.length] = arguments[i];
		return this.length;
	};
}

// pop removes the last element from an array and returns it
if (Array.prototype && !Array.prototype.pop) {
	Array.prototype.pop = function() {
		var lastitem = this.length > 0 ? this[this.length - 1] : undefined;
		if (this.length > 0) this.length--;
		return lastitem;
	};
}

// shift removes the first element from an array and returns it
if (Array.prototype && !Array.prototype.shift) {
	Array.prototype.shift = function() {
		var firstitem = this.length > 0 ? this[0] : undefined;
		for (var i=0; i<this.length-1; i++) this[i] = this[i + 1];
		if (this.length > 0) this.length--;
		return firstitem;
	};
}

// join returns a string value consisting of all the elements of an array 
// concatenated together and separated by the separator argument
if (Array.prototype && !Array.prototype.join) {
	Array.prototype.join = function(separator) {
		if (typeof separator != "string") separator = ",";
		var s = "";
		for (var i=0; i<this.length; i++) {
			if (this[i] != null && this[i] != undefined) s += this[i];
			if (i != this.length - 1) s += separator;
		}
		return s;
	};
}

// split returns the array that results when a string is separated into substrings
if (String.prototype && !String.prototype.split) {
	String.prototype.split = function(separator, limit) {
		var s = "" + this;
		var a = new Array();
		var sepIndex;
		
		if (typeof separator != "string") return new Array(s);
		if (separator == "") {
			while (s.length) {
				a[a.length] = s.substring(0, 1);
				s = s.substring(1);
				if (typeof limit == "number" && a.length >= limit) break;
			}
		}
		else {
			while (s.length) {
				sepIndex = s.indexOf(separator);
				a[a.length] = s.substring(0, sepIndex);
				s = s.substring(sepIndex+separator.length);
				if (typeof limit == "number" && a.length >= limit) break;
				if (s.length == 0) a[a.length] = s;
			}
		}
		return a;
	};
}

// end