Subversion Repositories Applications.papyrus

if(!dojo._hasResource['dojox.grid._grid.scroller']){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource['dojox.grid._grid.scroller'] = true;

dojo.provide('dojox.grid._grid.scroller');

dojo.declare('dojox.grid.scroller.base', null, {

	// summary:

	//	virtual scrollbox, abstract class

	//	Content must in /rows/

	//	Rows are managed in contiguous sets called /pages/

	//	There are a fixed # of rows per page

	//	The minimum rendered unit is a page

	constructor: function(){

		this.pageHeights = [];

		this.stack = [];

	},

	// specified

	rowCount: 0, // total number of rows to manage

	defaultRowHeight: 10, // default height of a row

	keepRows: 100, // maximum number of rows that should exist at one time

	contentNode: null, // node to contain pages

	scrollboxNode: null, // node that controls scrolling

	// calculated

	defaultPageHeight: 0, // default height of a page

	keepPages: 10, // maximum number of pages that should exists at one time

	pageCount: 0,

	windowHeight: 0,

	firstVisibleRow: 0,

	lastVisibleRow: 0,

	// private

	page: 0,

	pageTop: 0,

	// init

	init: function(inRowCount, inKeepRows, inRowsPerPage){

		switch(arguments.length){

			case 3: this.rowsPerPage = inRowsPerPage;

			case 2: this.keepRows = inKeepRows;

			case 1: this.rowCount = inRowCount;

		}

		this.defaultPageHeight = this.defaultRowHeight * this.rowsPerPage;

		//this.defaultPageHeight = this.defaultRowHeight * Math.min(this.rowsPerPage, this.rowCount);

		this.pageCount = Math.ceil(this.rowCount / this.rowsPerPage);

		this.keepPages = Math.max(Math.ceil(this.keepRows / this.rowsPerPage), 2);

		this.invalidate();

		if(this.scrollboxNode){

			this.scrollboxNode.scrollTop = 0;

			this.scroll(0);

			this.scrollboxNode.onscroll = dojo.hitch(this, 'onscroll');

		}

	},

	// updating

	invalidate: function(){

		this.invalidateNodes();

		this.pageHeights = [];

		this.height = (this.pageCount ? (this.pageCount - 1)* this.defaultPageHeight + this.calcLastPageHeight() : 0);

		this.resize();

	},

	updateRowCount: function(inRowCount){

		this.invalidateNodes();

		this.rowCount = inRowCount;

		// update page count, adjust document height

		oldPageCount = this.pageCount;

		this.pageCount = Math.ceil(this.rowCount / this.rowsPerPage);

		if(this.pageCount < oldPageCount){

			for(var i=oldPageCount-1; i>=this.pageCount; i--){

				this.height -= this.getPageHeight(i);

				delete this.pageHeights[i]

			}

		}else if(this.pageCount > oldPageCount){

			this.height += this.defaultPageHeight * (this.pageCount - oldPageCount - 1) + this.calcLastPageHeight();

		}

		this.resize();

	},

	// abstract interface

	pageExists: function(inPageIndex){

	},

	measurePage: function(inPageIndex){

	},

	positionPage: function(inPageIndex, inPos){

	},

	repositionPages: function(inPageIndex){

	},

	installPage: function(inPageIndex){

	},

	preparePage: function(inPageIndex, inPos, inReuseNode){

	},

	renderPage: function(inPageIndex){

	},

	removePage: function(inPageIndex){

	},

	pacify: function(inShouldPacify){

	},

	// pacification

	pacifying: false,

	pacifyTicks: 200,

	setPacifying: function(inPacifying){

		if(this.pacifying != inPacifying){

			this.pacifying = inPacifying;

			this.pacify(this.pacifying);

		}

	},

	startPacify: function(){

		this.startPacifyTicks = new Date().getTime();

	},

	doPacify: function(){

		var result = (new Date().getTime() - this.startPacifyTicks) > this.pacifyTicks;

		this.setPacifying(true);

		this.startPacify();

		return result;

	},

	endPacify: function(){

		this.setPacifying(false);

	},

	// default sizing implementation

	resize: function(){

		if(this.scrollboxNode){

			this.windowHeight = this.scrollboxNode.clientHeight;

		}

		dojox.grid.setStyleHeightPx(this.contentNode, this.height);

	},

	calcLastPageHeight: function(){

		if(!this.pageCount){

			return 0;

		}

		var lastPage = this.pageCount - 1;

		var lastPageHeight = ((this.rowCount % this.rowsPerPage)||(this.rowsPerPage)) * this.defaultRowHeight;

		this.pageHeights[lastPage] = lastPageHeight;

		return lastPageHeight;

	},

	updateContentHeight: function(inDh){

		this.height += inDh;

		this.resize();

	},

	updatePageHeight: function(inPageIndex){

		if(this.pageExists(inPageIndex)){

			var oh = this.getPageHeight(inPageIndex);

			var h = (this.measurePage(inPageIndex))||(oh);

			this.pageHeights[inPageIndex] = h;

			if((h)&&(oh != h)){

				this.updateContentHeight(h - oh)

				this.repositionPages(inPageIndex);

			}

		}

	},

	rowHeightChanged: function(inRowIndex){

		this.updatePageHeight(Math.floor(inRowIndex / this.rowsPerPage));

	},

	// scroller core

	invalidateNodes: function(){

		while(this.stack.length){

			this.destroyPage(this.popPage());

		}

	},

	createPageNode: function(){

		var p = document.createElement('div');

		p.style.position = 'absolute';

		//p.style.width = '100%';

		p.style.left = '0';

		return p;

	},

	getPageHeight: function(inPageIndex){

		var ph = this.pageHeights[inPageIndex];

		return (ph !== undefined ? ph : this.defaultPageHeight);

	},

	// FIXME: this is not a stack, it's a FIFO list

	pushPage: function(inPageIndex){

		return this.stack.push(inPageIndex);

	},

	popPage: function(){

		return this.stack.shift();

	},

	findPage: function(inTop){

		var i = 0, h = 0;

		for(var ph = 0; i<this.pageCount; i++, h += ph){

			ph = this.getPageHeight(i);

			if(h + ph >= inTop){

				break;

			}

		}

		this.page = i;

		this.pageTop = h;

	},

	buildPage: function(inPageIndex, inReuseNode, inPos){

		this.preparePage(inPageIndex, inReuseNode);

		this.positionPage(inPageIndex, inPos);

		// order of operations is key below

		this.installPage(inPageIndex);

		this.renderPage(inPageIndex);

		// order of operations is key above

		this.pushPage(inPageIndex);

	},

	needPage: function(inPageIndex, inPos){

		var h = this.getPageHeight(inPageIndex), oh = h;

		if(!this.pageExists(inPageIndex)){

			this.buildPage(inPageIndex, (this.keepPages)&&(this.stack.length >= this.keepPages), inPos);

			h = this.measurePage(inPageIndex) || h;

			this.pageHeights[inPageIndex] = h;

			if(h && (oh != h)){

				this.updateContentHeight(h - oh)

			}

		}else{

			this.positionPage(inPageIndex, inPos);

		}

		return h;

	},

	onscroll: function(){

		this.scroll(this.scrollboxNode.scrollTop);

	},

	scroll: function(inTop){

		this.startPacify();

		this.findPage(inTop);

		var h = this.height;

		var b = this.getScrollBottom(inTop);

		for(var p=this.page, y=this.pageTop; (p<this.pageCount)&&((b<0)||(y<b)); p++){

			y += this.needPage(p, y);

		}

		this.firstVisibleRow = this.getFirstVisibleRow(this.page, this.pageTop, inTop);

		this.lastVisibleRow = this.getLastVisibleRow(p - 1, y, b);

		// indicates some page size has been updated

		if(h != this.height){

			this.repositionPages(p-1);

		}

		this.endPacify();

	},

	getScrollBottom: function(inTop){

		return (this.windowHeight >= 0 ? inTop + this.windowHeight : -1);

	},

	// events

	processNodeEvent: function(e, inNode){

		var t = e.target;

		while(t && (t != inNode) && t.parentNode && (t.parentNode.parentNode != inNode)){

			t = t.parentNode;

		}

		if(!t || !t.parentNode || (t.parentNode.parentNode != inNode)){

			return false;

		}

		var page = t.parentNode;

		e.topRowIndex = page.pageIndex * this.rowsPerPage;

		e.rowIndex = e.topRowIndex + dojox.grid.indexInParent(t);

		e.rowTarget = t;

		return true;

	},

	processEvent: function(e){

		return this.processNodeEvent(e, this.contentNode);

	},

	dummy: 0

});

dojo.declare('dojox.grid.scroller', dojox.grid.scroller.base, {

	// summary:

	//	virtual scroller class, makes no assumption about shape of items being scrolled

	constructor: function(){

		this.pageNodes = [];

	},

	// virtual rendering interface

	renderRow: function(inRowIndex, inPageNode){

	},

	removeRow: function(inRowIndex){

	},

	// page node operations

	getDefaultNodes: function(){

		return this.pageNodes;

	},

	getDefaultPageNode: function(inPageIndex){

		return this.getDefaultNodes()[inPageIndex];

	},

	positionPageNode: function(inNode, inPos){

		inNode.style.top = inPos + 'px';

	},

	getPageNodePosition: function(inNode){

		return inNode.offsetTop;

	},

	repositionPageNodes: function(inPageIndex, inNodes){

		var last = 0;

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

			last = Math.max(this.stack[i], last);

		}

		//

		var n = inNodes[inPageIndex];

		var y = (n ? this.getPageNodePosition(n) + this.getPageHeight(inPageIndex) : 0);

		//console.log('detected height change, repositioning from #%d (%d) @ %d ', inPageIndex + 1, last, y, this.pageHeights[0]);

		//

		for(var p=inPageIndex+1; p<=last; p++){

			n = inNodes[p];

			if(n){

				//console.log('#%d @ %d', inPageIndex, y, this.getPageNodePosition(n));

				if(this.getPageNodePosition(n) == y){

					return;

				}

				//console.log('placing page %d at %d', p, y);

				this.positionPage(p, y);

			}

			y += this.getPageHeight(p);

		}

	},

	invalidatePageNode: function(inPageIndex, inNodes){

		var p = inNodes[inPageIndex];

		if(p){

			delete inNodes[inPageIndex];

			this.removePage(inPageIndex, p);

			dojox.grid.cleanNode(p);

			p.innerHTML = '';

		}

		return p;

	},

	preparePageNode: function(inPageIndex, inReusePageIndex, inNodes){

		var p = (inReusePageIndex === null ? this.createPageNode() : this.invalidatePageNode(inReusePageIndex, inNodes));

		p.pageIndex = inPageIndex;

		p.id = 'page-' + inPageIndex;

		inNodes[inPageIndex] = p;

	},

	// implementation for page manager

	pageExists: function(inPageIndex){

		return Boolean(this.getDefaultPageNode(inPageIndex));

	},

	measurePage: function(inPageIndex){

		return this.getDefaultPageNode(inPageIndex).offsetHeight;

	},

	positionPage: function(inPageIndex, inPos){

		this.positionPageNode(this.getDefaultPageNode(inPageIndex), inPos);

	},

	repositionPages: function(inPageIndex){

		this.repositionPageNodes(inPageIndex, this.getDefaultNodes());

	},

	preparePage: function(inPageIndex, inReuseNode){

		this.preparePageNode(inPageIndex, (inReuseNode ? this.popPage() : null), this.getDefaultNodes());

	},

	installPage: function(inPageIndex){

		this.contentNode.appendChild(this.getDefaultPageNode(inPageIndex));

	},

	destroyPage: function(inPageIndex){

		var p = this.invalidatePageNode(inPageIndex, this.getDefaultNodes());

		dojox.grid.removeNode(p);

	},

	// rendering implementation

	renderPage: function(inPageIndex){

		var node = this.pageNodes[inPageIndex];

		for(var i=0, j=inPageIndex*this.rowsPerPage; (i<this.rowsPerPage)&&(j<this.rowCount); i++, j++){

			this.renderRow(j, node);

		}

	},

	removePage: function(inPageIndex){

		for(var i=0, j=inPageIndex*this.rowsPerPage; i<this.rowsPerPage; i++, j++){

			this.removeRow(j);

		}

	},

	// scroll control

	getPageRow: function(inPage){

		return inPage * this.rowsPerPage;

	},

	getLastPageRow: function(inPage){

		return Math.min(this.rowCount, this.getPageRow(inPage + 1)) - 1;

	},

	getFirstVisibleRowNodes: function(inPage, inPageTop, inScrollTop, inNodes){

		var row = this.getPageRow(inPage);

		var rows = dojox.grid.divkids(inNodes[inPage]);

		for(var i=0,l=rows.length; i<l && inPageTop<inScrollTop; i++, row++){

			inPageTop += rows[i].offsetHeight;

		}

		return (row ? row - 1 : row);

	},

	getFirstVisibleRow: function(inPage, inPageTop, inScrollTop){

		if(!this.pageExists(inPage)){

			return 0;

		}

		return this.getFirstVisibleRowNodes(inPage, inPageTop, inScrollTop, this.getDefaultNodes());

	},

	getLastVisibleRowNodes: function(inPage, inBottom, inScrollBottom, inNodes){

		var row = this.getLastPageRow(inPage);

		var rows = dojox.grid.divkids(inNodes[inPage]);

		for(var i=rows.length-1; i>=0 && inBottom>inScrollBottom; i--, row--){

			inBottom -= rows[i].offsetHeight;

		}

		return row + 1;

	},

	getLastVisibleRow: function(inPage, inBottom, inScrollBottom){

		if(!this.pageExists(inPage)){

			return 0;

		}

		return this.getLastVisibleRowNodes(inPage, inBottom, inScrollBottom, this.getDefaultNodes());

	},

	findTopRowForNodes: function(inScrollTop, inNodes){

		var rows = dojox.grid.divkids(inNodes[this.page]);

		for(var i=0,l=rows.length,t=this.pageTop,h; i<l; i++){

			h = rows[i].offsetHeight;

			t += h;

			if(t >= inScrollTop){

				this.offset = h - (t - inScrollTop);

				return i + this.page * this.rowsPerPage;

			}

		}

		return -1;

	},

	findScrollTopForNodes: function(inRow, inNodes){

		var rowPage = Math.floor(inRow / this.rowsPerPage);

		var t = 0;

		for(var i=0; i<rowPage; i++){

			t += this.getPageHeight(i);

		}

		this.pageTop = t;

		this.needPage(rowPage, this.pageTop);

		var rows = dojox.grid.divkids(inNodes[rowPage]);

		var r = inRow - this.rowsPerPage * rowPage;

		for(var i=0,l=rows.length; i<l && i<r; i++){

			t += rows[i].offsetHeight;

		}

		return t;

	},

	findTopRow: function(inScrollTop){

		return this.findTopRowForNodes(inScrollTop, this.getDefaultNodes());

	},

	findScrollTop: function(inRow){

		return this.findScrollTopForNodes(inRow, this.getDefaultNodes());

	},

	dummy: 0

});

dojo.declare('dojox.grid.scroller.columns', dojox.grid.scroller, {

	// summary:

	//	Virtual scroller class that scrolls list of columns. Owned by grid and used internally

	//	for virtual scrolling.

	constructor: function(inContentNodes){

		this.setContentNodes(inContentNodes);

	},

	// nodes

	setContentNodes: function(inNodes){

		this.contentNodes = inNodes;

		this.colCount = (this.contentNodes ? this.contentNodes.length : 0);

		this.pageNodes = [];

		for(var i=0; i<this.colCount; i++){

			this.pageNodes[i] = [];

		}

	},

	getDefaultNodes: function(){

		return this.pageNodes[0] || [];

	},

	scroll: function(inTop) {

		if(this.colCount){

			dojox.grid.scroller.prototype.scroll.call(this, inTop);

		}

	},

	// resize

	resize: function(){

		if(this.scrollboxNode){

			this.windowHeight = this.scrollboxNode.clientHeight;

		}

		for(var i=0; i<this.colCount; i++){

			dojox.grid.setStyleHeightPx(this.contentNodes[i], this.height);

		}

	},

	// implementation for page manager

	positionPage: function(inPageIndex, inPos){

		for(var i=0; i<this.colCount; i++){

			this.positionPageNode(this.pageNodes[i][inPageIndex], inPos);

		}

	},

	preparePage: function(inPageIndex, inReuseNode){

		var p = (inReuseNode ? this.popPage() : null);

		for(var i=0; i<this.colCount; i++){

			this.preparePageNode(inPageIndex, p, this.pageNodes[i]);

		}

	},

	installPage: function(inPageIndex){

		for(var i=0; i<this.colCount; i++){

			this.contentNodes[i].appendChild(this.pageNodes[i][inPageIndex]);

		}

	},

	destroyPage: function(inPageIndex){

		for(var i=0; i<this.colCount; i++){

			dojox.grid.removeNode(this.invalidatePageNode(inPageIndex, this.pageNodes[i]));

		}

	},

	// rendering implementation

	renderPage: function(inPageIndex){

		var nodes = [];

		for(var i=0; i<this.colCount; i++){

			nodes[i] = this.pageNodes[i][inPageIndex];

		}

		//this.renderRows(inPageIndex*this.rowsPerPage, this.rowsPerPage, nodes);

		for(var i=0, j=inPageIndex*this.rowsPerPage; (i<this.rowsPerPage)&&(j<this.rowCount); i++, j++){

			this.renderRow(j, nodes);

		}

	}

});

}