Context Navigation

source: Dev/trunk/src/client/dojox/grid/_Builder.js

Last change on this file was 483, checked in by hendrikvanantwerpen, 11 years ago
Added Dojo 1.9.3 release.
File size: 23.0 KB

Rev	Line
[483]	1	define([
	2	"../main",
	3	"dojo/_base/array",
	4	"dojo/_base/lang",
	5	"dojo/_base/window",
	6	"dojo/_base/event",
	7	"dojo/_base/sniff",
	8	"dojo/_base/connect",
	9	"dojo/dnd/Moveable",
	10	"dojox/html/metrics",
	11	"./util",
	12	"dojo/_base/html",
	13	"dojo/dom-geometry"
	14	], function(dojox, array, lang, win, event, has, connect, Moveable, metrics, util, html, domGeometry){
	15
	16	var dg = dojox.grid;
	17
	18	var getTdIndex = function(td){
	19	return td.cellIndex >=0 ? td.cellIndex : array.indexOf(td.parentNode.cells, td);
	20	};
	21
	22	var getTrIndex = function(tr){
	23	return tr.rowIndex >=0 ? tr.rowIndex : array.indexOf(tr.parentNode.childNodes, tr);
	24	};
	25
	26	var getTr = function(rowOwner, index){
	27	return rowOwner && ((rowOwner.rows\|\|0)[index] \|\| rowOwner.childNodes[index]);
	28	};
	29
	30	var findTable = function(node){
	31	for(var n=node; n && n.tagName!='TABLE'; n=n.parentNode){}
	32	return n;
	33	};
	34
	35	var ascendDom = function(inNode, inWhile){
	36	for(var n=inNode; n && inWhile(n); n=n.parentNode){}
	37	return n;
	38	};
	39
	40	var makeNotTagName = function(inTagName){
	41	var name = inTagName.toUpperCase();
	42	return function(node){ return node.tagName != name; };
	43	};
	44
	45	var rowIndexTag = util.rowIndexTag;
	46	var gridViewTag = util.gridViewTag;
	47
	48	// base class for generating markup for the views
	49	var _Builder = dg._Builder = lang.extend(function(view){
	50	if(view){
	51	this.view = view;
	52	this.grid = view.grid;
	53	}
	54	},{
	55	view: null,
	56	// boilerplate HTML
	57	_table: '<table class="dojoxGridRowTable" border="0" cellspacing="0" cellpadding="0" role="presentation"',
	58
	59	// Returns the table variable as an array - and with the view width, if specified
	60	getTableArray: function(){
	61	var html = [this._table];
	62	if(this.view.viewWidth){
	63	html.push([' style="width:', this.view.viewWidth, ';"'].join(''));
	64	}
	65	html.push('>');
	66	return html;
	67	},
	68
	69	// generate starting tags for a cell
	70	generateCellMarkup: function(inCell, inMoreStyles, inMoreClasses, isHeader){
	71	var result = [], html;
	72	if(isHeader){
	73	var sortInfo = inCell.index != inCell.grid.getSortIndex() ? "" : inCell.grid.sortInfo > 0 ? 'aria-sort="ascending"' : 'aria-sort="descending"';
	74	if (!inCell.id){
	75	inCell.id = this.grid.id + "Hdr" + inCell.index;
	76	}
	77	// column headers are not editable, mark as aria-readonly=true
	78	html = ['<th tabIndex="-1" aria-readonly="true" role="columnheader"', sortInfo, ' id="', inCell.id, '"'];
	79	}else{
	80	// cells inherit grid aria-readonly property; default value for aria-readonly is false(grid is editable)
	81	// if grid is editable (had any editable cells), mark non editable cells as aria-readonly=true
	82	// if no editable cells, grid's aria-readonly value will have been set to true and cells will inherit
	83	var editInfo = this.grid.editable && !inCell.editable ? 'aria-readonly="true"' : "";
	84	html = ['<td tabIndex="-1" role="gridcell"', editInfo];
	85	}
	86	if(inCell.colSpan){
	87	html.push(' colspan="', inCell.colSpan, '"');
	88	}
	89	if(inCell.rowSpan){
	90	html.push(' rowspan="', inCell.rowSpan, '"');
	91	}
	92	html.push(' class="dojoxGridCell ');
	93	if(inCell.classes){
	94	html.push(inCell.classes, ' ');
	95	}
	96	if(inMoreClasses){
	97	html.push(inMoreClasses, ' ');
	98	}
	99	// result[0] => td opener, style
	100	result.push(html.join(''));
	101	// SLOT: result[1] => td classes
	102	result.push('');
	103	html = ['" idx="', inCell.index, '" style="'];
	104	if(inMoreStyles && inMoreStyles[inMoreStyles.length-1] != ';'){
	105	inMoreStyles += ';';
	106	}
	107	html.push(inCell.styles, inMoreStyles\|\|'', inCell.hidden?'display:none;':'');
	108	if(inCell.unitWidth){
	109	html.push('width:', inCell.unitWidth, ';');
	110	}
	111	// result[2] => markup
	112	result.push(html.join(''));
	113	// SLOT: result[3] => td style
	114	result.push('');
	115	html = [ '"' ];
	116	if(inCell.attrs){
	117	html.push(" ", inCell.attrs);
	118	}
	119	html.push('>');
	120	// result[4] => td postfix
	121	result.push(html.join(''));
	122	// SLOT: result[5] => content
	123	result.push('');
	124	// result[6] => td closes
	125	result.push(isHeader?'</th>':'</td>');
	126	return result; // Array
	127	},
	128
	129	// cell finding
	130	isCellNode: function(inNode){
	131	return Boolean(inNode && inNode!=win.doc && html.attr(inNode, "idx"));
	132	},
	133
	134	getCellNodeIndex: function(inCellNode){
	135	return inCellNode ? Number(html.attr(inCellNode, "idx")) : -1;
	136	},
	137
	138	getCellNode: function(inRowNode, inCellIndex){
	139	for(var i=0, row; ((row = getTr(inRowNode.firstChild, i)) && row.cells); i++){
	140	for(var j=0, cell; (cell = row.cells[j]); j++){
	141	if(this.getCellNodeIndex(cell) == inCellIndex){
	142	return cell;
	143	}
	144	}
	145	}
	146	return null;
	147	},
	148
	149	findCellTarget: function(inSourceNode, inTopNode){
	150	var n = inSourceNode;
	151	while(n && (!this.isCellNode(n) \|\| (n.offsetParent && gridViewTag in n.offsetParent.parentNode && n.offsetParent.parentNode[gridViewTag] != this.view.id)) && (n!=inTopNode)){
	152	n = n.parentNode;
	153	}
	154	return n!=inTopNode ? n : null;
	155	},
	156
	157	// event decoration
	158	baseDecorateEvent: function(e){
	159	e.dispatch = 'do' + e.type;
	160	e.grid = this.grid;
	161	e.sourceView = this.view;
	162	e.cellNode = this.findCellTarget(e.target, e.rowNode);
	163	e.cellIndex = this.getCellNodeIndex(e.cellNode);
	164	e.cell = (e.cellIndex >= 0 ? this.grid.getCell(e.cellIndex) : null);
	165	},
	166
	167	// event dispatch
	168	findTarget: function(inSource, inTag){
	169	var n = inSource;
	170	while(n && (n!=this.domNode) && (!(inTag in n) \|\| (gridViewTag in n && n[gridViewTag] != this.view.id))){
	171	n = n.parentNode;
	172	}
	173	return (n != this.domNode) ? n : null;
	174	},
	175
	176	findRowTarget: function(inSource){
	177	return this.findTarget(inSource, rowIndexTag);
	178	},
	179
	180	isIntraNodeEvent: function(e){
	181	try{
	182	return (e.cellNode && e.relatedTarget && html.isDescendant(e.relatedTarget, e.cellNode));
	183	}catch(x){
	184	// e.relatedTarget has permission problem in FF if it's an input: https://bugzilla.mozilla.org/show_bug.cgi?id=208427
	185	return false;
	186	}
	187	},
	188
	189	isIntraRowEvent: function(e){
	190	try{
	191	var row = e.relatedTarget && this.findRowTarget(e.relatedTarget);
	192	return !row && (e.rowIndex==-1) \|\| row && (e.rowIndex==row.gridRowIndex);
	193	}catch(x){
	194	// e.relatedTarget on INPUT has permission problem in FF: https://bugzilla.mozilla.org/show_bug.cgi?id=208427
	195	return false;
	196	}
	197	},
	198
	199	dispatchEvent: function(e){
	200	if(e.dispatch in this){
	201	return this[e.dispatch](e);
	202	}
	203	return false;
	204	},
	205
	206	// dispatched event handlers
	207	domouseover: function(e){
	208	if(e.cellNode && (e.cellNode!=this.lastOverCellNode)){
	209	this.lastOverCellNode = e.cellNode;
	210	this.grid.onMouseOver(e);
	211	}
	212	this.grid.onMouseOverRow(e);
	213	},
	214
	215	domouseout: function(e){
	216	if(e.cellNode && (e.cellNode==this.lastOverCellNode) && !this.isIntraNodeEvent(e, this.lastOverCellNode)){
	217	this.lastOverCellNode = null;
	218	this.grid.onMouseOut(e);
	219	if(!this.isIntraRowEvent(e)){
	220	this.grid.onMouseOutRow(e);
	221	}
	222	}
	223	},
	224
	225	domousedown: function(e){
	226	if (e.cellNode)
	227	this.grid.onMouseDown(e);
	228	this.grid.onMouseDownRow(e);
	229	},
	230
	231	_getTextDirStyle: function(textDir, inCell, inRowIndex){
	232	// summary:
	233	// Get BiDi text dir, just a placeholder, defined in dojox/grid/bidi/_BidiMixin
	234	return "";
	235	}
	236	});
	237
	238	// Produces html for grid data content. Owned by grid and used internally
	239	// for rendering data. Override to implement custom rendering.
	240	var _ContentBuilder = dg._ContentBuilder = lang.extend(function(view){
	241	_Builder.call(this, view);
	242	},_Builder.prototype,{
	243	update: function(){
	244	this.prepareHtml();
	245	},
	246
	247	// cache html for rendering data rows
	248	prepareHtml: function(){
	249	var defaultGet=this.grid.get, cells=this.view.structure.cells;
	250	for(var j=0, row; (row=cells[j]); j++){
	251	for(var i=0, cell; (cell=row[i]); i++){
	252	cell.get = cell.get \|\| (cell.value == undefined) && defaultGet;
	253	cell.markup = this.generateCellMarkup(cell, cell.cellStyles, cell.cellClasses, false);
	254	if (!this.grid.editable && cell.editable){
	255	this.grid.editable = true;
	256	}
	257	}
	258	}
	259	},
	260
	261	// time critical: generate html using cache and data source
	262	generateHtml: function(inDataIndex, inRowIndex){
	263	var
	264	html = this.getTableArray(),
	265	v = this.view, dir,
	266	cells = v.structure.cells,
	267	item = this.grid.getItem(inRowIndex);
	268
	269	util.fire(this.view, "onBeforeRow", [inRowIndex, cells]);
	270	for(var j=0, row; (row=cells[j]); j++){
	271	if(row.hidden \|\| row.header){
	272	continue;
	273	}
	274	html.push(!row.invisible ? '<tr>' : '<tr class="dojoxGridInvisible">');
	275	for(var i=0, cell, m, cc, cs; (cell=row[i]); i++){
	276	m = cell.markup; cc = cell.customClasses = []; cs = cell.customStyles = [];
	277	// content (format can fill in cc and cs as side-effects)
	278	m[5] = cell.format(inRowIndex, item);
	279	// classes
	280	m[1] = cc.join(' ');
	281	// styles
	282	m[3] = cs.join(';');
	283	dir = cell.textDir \|\| this.grid.textDir;
	284	if(dir){
	285	m[3] += this._getTextDirStyle(dir, cell, inRowIndex);
	286	}
	287	// in-place concat
	288	html.push.apply(html, m);
	289	}
	290	html.push('</tr>');
	291	}
	292	html.push('</table>');
	293	return html.join(''); // String
	294	},
	295
	296	decorateEvent: function(e){
	297	e.rowNode = this.findRowTarget(e.target);
	298	if(!e.rowNode){return false;}
	299	e.rowIndex = e.rowNode[rowIndexTag];
	300	this.baseDecorateEvent(e);
	301	e.cell = this.grid.getCell(e.cellIndex);
	302	return true; // Boolean
	303	}
	304	});
	305
	306	// Produces html for grid header content. Owned by grid and used internally
	307	// for rendering data. Override to implement custom rendering.
	308	var _HeaderBuilder = dg._HeaderBuilder = lang.extend(function(view){
	309	this.moveable = null;
	310	_Builder.call(this, view);
	311	},_Builder.prototype,{
	312	_skipBogusClicks: false,
	313	overResizeWidth: 4,
	314	minColWidth: 1,
	315
	316	update: function(){
	317	if(this.tableMap){
	318	this.tableMap.mapRows(this.view.structure.cells);
	319	}else{
	320	this.tableMap = new dg._TableMap(this.view.structure.cells);
	321	}
	322	},
	323
	324	generateHtml: function(inGetValue, inValue){
	325	var dir, html = this.getTableArray(), cells = this.view.structure.cells;
	326
	327	util.fire(this.view, "onBeforeRow", [-1, cells]);
	328	for(var j=0, row; (row=cells[j]); j++){
	329	if(row.hidden){
	330	continue;
	331	}
	332	html.push(!row.invisible ? '<tr>' : '<tr class="dojoxGridInvisible">');
	333	for(var i=0, cell, markup; (cell=row[i]); i++){
	334	cell.customClasses = [];
	335	cell.customStyles = [];
	336	if(this.view.simpleStructure){
	337	if(cell.draggable){
	338	if(cell.headerClasses){
	339	if(cell.headerClasses.indexOf('dojoDndItem') == -1){
	340	cell.headerClasses += ' dojoDndItem';
	341	}
	342	}else{
	343	cell.headerClasses = 'dojoDndItem';
	344	}
	345	}
	346	if(cell.attrs){
	347	if(cell.attrs.indexOf("dndType='gridColumn_") == -1){
	348	cell.attrs += " dndType='gridColumn_" + this.grid.id + "'";
	349	}
	350	}else{
	351	cell.attrs = "dndType='gridColumn_" + this.grid.id + "'";
	352	}
	353	}
	354	markup = this.generateCellMarkup(cell, cell.headerStyles, cell.headerClasses, true);
	355	// content
	356	markup[5] = (inValue != undefined ? inValue : inGetValue(cell));
	357	// styles
	358	markup[3] = cell.customStyles.join(';');
	359	dir = cell.textDir \|\| this.grid.textDir;
	360	if(dir){
	361	markup[3] += this._getTextDirStyle(dir, cell, inValue);
	362	}
	363	// classes
	364	markup[1] = cell.customClasses.join(' '); //(cell.customClasses ? ' ' + cell.customClasses : '');
	365	html.push(markup.join(''));
	366	}
	367	html.push('</tr>');
	368	}
	369	html.push('</table>');
	370	return html.join('');
	371	},
	372
	373	// event helpers
	374	getCellX: function(e){
	375	var n, x, pos;
	376	// Calculate starting x position
	377	n = ascendDom(e.target, makeNotTagName("th"));
	378	if(n){
	379	// We have a proper parent node, use that for position
	380	pos = domGeometry.position(n);
	381	x = e.clientX - pos.x;
	382	}else{
	383	// Fall back to layerX
	384	x = e.layerX;
	385	}
	386	return x;
	387	},
	388
	389	// event decoration
	390	decorateEvent: function(e){
	391	this.baseDecorateEvent(e);
	392	e.rowIndex = -1;
	393	e.cellX = this.getCellX(e);
	394	return true;
	395	},
	396
	397	// event handlers
	398	// resizing
	399	prepareResize: function(e, mod){
	400	do{
	401	var i = e.cellIndex;
	402	e.cellNode = (i ? e.cellNode.parentNode.cells[i+mod] : null);
	403	e.cellIndex = (e.cellNode ? this.getCellNodeIndex(e.cellNode) : -1);
	404	}while(e.cellNode && e.cellNode.style.display == "none");
	405	return Boolean(e.cellNode);
	406	},
	407
	408	canResize: function(e){
	409	if(!e.cellNode \|\| e.cellNode.colSpan > 1){
	410	return false;
	411	}
	412	var cell = this.grid.getCell(e.cellIndex);
	413	return !cell.noresize && cell.canResize();
	414	},
	415
	416	overLeftResizeArea: function(e){
	417	// We are never over a resize area if we are in the process of moving
	418	if(html.hasClass(win.body(), "dojoDndMove")){
	419	return false;
	420	}
	421	//Bugfix for crazy IE problem (#8807). IE returns position information for the icon and text arrow divs
	422	//as if they were still on the left instead of returning the position they were 'float: right' to.
	423	//So, the resize check ends up checking the wrong adjacent cell. This checks to see if the hover was over
	424	//the image or text nodes, then just ignored them/treat them not in scale range.
	425	if(has('ie')){
	426	var tN = e.target;
	427	if(html.hasClass(tN, "dojoxGridArrowButtonNode") \|\|
	428	html.hasClass(tN, "dojoxGridArrowButtonChar") \|\|
	429	html.hasClass(tN, "dojoxGridColCaption")){
	430	return false;
	431	}
	432	}
	433
	434	if(this.grid.isLeftToRight()){
	435	return (e.cellIndex>0) && (e.cellX > 0 && e.cellX < this.overResizeWidth) && this.prepareResize(e, -1);
	436	}
	437	var t = e.cellNode && (e.cellX > 0 && e.cellX < this.overResizeWidth);
	438	return t;
	439	},
	440
	441	overRightResizeArea: function(e){
	442	// We are never over a resize area if we are in the process of moving
	443	if(html.hasClass(win.body(), "dojoDndMove")){
	444	return false;
	445	}
	446	//Bugfix for crazy IE problem (#8807). IE returns position information for the icon and text arrow divs
	447	//as if they were still on the left instead of returning the position they were 'float: right' to.
	448	//So, the resize check ends up checking the wrong adjacent cell. This checks to see if the hover was over
	449	//the image or text nodes, then just ignored them/treat them not in scale range.
	450	if(has('ie')){
	451	var tN = e.target;
	452	if(html.hasClass(tN, "dojoxGridArrowButtonNode") \|\|
	453	html.hasClass(tN, "dojoxGridArrowButtonChar") \|\|
	454	html.hasClass(tN, "dojoxGridColCaption")){
	455	return false;
	456	}
	457	}
	458
	459	if(this.grid.isLeftToRight()){
	460	return e.cellNode && (e.cellX >= e.cellNode.offsetWidth - this.overResizeWidth);
	461	}
	462	return (e.cellIndex>0) && (e.cellX >= e.cellNode.offsetWidth - this.overResizeWidth) && this.prepareResize(e, -1);
	463	},
	464
	465	domousemove: function(e){
	466	//console.log(e.cellIndex, e.cellX, e.cellNode.offsetWidth);
	467	if(!this.moveable){
	468	var c = (this.overRightResizeArea(e) ? 'dojoxGridColResize' : (this.overLeftResizeArea(e) ? 'dojoxGridColResize' : ''));
	469	if(c && !this.canResize(e)){
	470	c = 'dojoxGridColNoResize';
	471	}
	472	html.toggleClass(e.sourceView.headerNode, "dojoxGridColNoResize", (c == "dojoxGridColNoResize"));
	473	html.toggleClass(e.sourceView.headerNode, "dojoxGridColResize", (c == "dojoxGridColResize"));
	474	if(c){
	475	event.stop(e);
	476	}
	477	}
	478	},
	479
	480	domousedown: function(e){
	481	if(!this.moveable){
	482	if((this.overRightResizeArea(e) \|\| this.overLeftResizeArea(e)) && this.canResize(e)){
	483	this.beginColumnResize(e);
	484	}else{
	485	this.grid.onMouseDown(e);
	486	this.grid.onMouseOverRow(e);
	487	}
	488	//else{
	489	// this.beginMoveColumn(e);
	490	//}
	491	}
	492	},
	493
	494	doclick: function(e) {
	495	if(this._skipBogusClicks){
	496	event.stop(e);
	497	return true;
	498	}
	499	return false;
	500	},
	501
	502	// column resizing
	503	colResizeSetup: function(/Event Object/e, /boolean/ isMouse ){
	504	//Set up the drag object for column resizing
	505	// Called with mouse event in case of drag and drop,
	506	// Also called from keyboard shift-arrow event when focus is on a header
	507	var headContentBox = html.contentBox(e.sourceView.headerNode);
	508
	509	if(isMouse){ //IE draws line even with no mouse down so separate from keyboard
	510	this.lineDiv = document.createElement('div');
	511
	512	var vw = html.position(e.sourceView.headerNode, true);
	513	var bodyContentBox = html.contentBox(e.sourceView.domNode);
	514	//fix #11340
	515	var l = e.pageX;
	516	if(!this.grid.isLeftToRight() && has('ie') < 8){
	517	l -= metrics.getScrollbar().w;
	518	}
	519	html.style(this.lineDiv, {
	520	top: vw.y + "px",
	521	left: l + "px",
	522	height: (bodyContentBox.h + headContentBox.h) + "px"
	523	});
	524	html.addClass(this.lineDiv, "dojoxGridResizeColLine");
	525	this.lineDiv._origLeft = l;
	526	win.body().appendChild(this.lineDiv);
	527	}
	528	var spanners = [], nodes = this.tableMap.findOverlappingNodes(e.cellNode);
	529	for(var i=0, cell; (cell=nodes[i]); i++){
	530	spanners.push({ node: cell, index: this.getCellNodeIndex(cell), width: cell.offsetWidth });
	531	//console.log("spanner: " + this.getCellNodeIndex(cell));
	532	}
	533
	534	var view = e.sourceView;
	535	var adj = this.grid.isLeftToRight() ? 1 : -1;
	536	var views = e.grid.views.views;
	537	var followers = [];
	538	for(var j=view.idx+adj, cView; (cView=views[j]); j=j+adj){
	539	followers.push({ node: cView.headerNode, left: window.parseInt(cView.headerNode.style.left) });
	540	}
	541	var table = view.headerContentNode.firstChild;
	542	var drag = {
	543	scrollLeft: e.sourceView.headerNode.scrollLeft,
	544	view: view,
	545	node: e.cellNode,
	546	index: e.cellIndex,
	547	w: html.contentBox(e.cellNode).w,
	548	vw: headContentBox.w,
	549	table: table,
	550	tw: html.contentBox(table).w,
	551	spanners: spanners,
	552	followers: followers
	553	};
	554	return drag;
	555	},
	556	beginColumnResize: function(e){
	557	this.moverDiv = document.createElement("div");
	558	html.style(this.moverDiv,{position: "absolute", left:0}); // to make DnD work with dir=rtl
	559	win.body().appendChild(this.moverDiv);
	560	html.addClass(this.grid.domNode, "dojoxGridColumnResizing");
	561	var m = (this.moveable = new Moveable(this.moverDiv));
	562
	563	var drag = this.colResizeSetup(e,true);
	564
	565	m.onMove = lang.hitch(this, "doResizeColumn", drag);
	566
	567	connect.connect(m, "onMoveStop", lang.hitch(this, function(){
	568	this.endResizeColumn(drag);
	569	if(drag.node.releaseCapture){
	570	drag.node.releaseCapture();
	571	}
	572	this.moveable.destroy();
	573	delete this.moveable;
	574	this.moveable = null;
	575	html.removeClass(this.grid.domNode, "dojoxGridColumnResizing");
	576	}));
	577
	578	if(e.cellNode.setCapture){
	579	e.cellNode.setCapture();
	580	}
	581	m.onMouseDown(e);
	582	},
	583
	584	doResizeColumn: function(inDrag, mover, leftTop){
	585	var changeX = leftTop.l;
	586	var data = {
	587	deltaX: changeX,
	588	w: inDrag.w + (this.grid.isLeftToRight() ? changeX : -changeX),//fix #11341
	589	vw: inDrag.vw + changeX,
	590	tw: inDrag.tw + changeX
	591	};
	592
	593	this.dragRecord = {inDrag: inDrag, mover: mover, leftTop:leftTop};
	594
	595	if(data.w >= this.minColWidth){
	596	if (!mover) { // we are using keyboard do immediate resize
	597	this.doResizeNow(inDrag, data);
	598	}
	599	else{
	600	html.style(this.lineDiv, "left", (this.lineDiv._origLeft + data.deltaX) + "px");
	601	}
	602	}
	603	},
	604
	605	endResizeColumn: function(inDrag){
	606	if(this.dragRecord){
	607	var leftTop = this.dragRecord.leftTop;
	608	var changeX = this.grid.isLeftToRight() ? leftTop.l : -leftTop.l;
	609	// Make sure we are not under our minimum
	610	// http://bugs.dojotoolkit.org/ticket/9390
	611	changeX += Math.max(inDrag.w + changeX, this.minColWidth) - (inDrag.w + changeX);
	612	if(has('webkit') && inDrag.spanners.length){
	613	// Webkit needs the pad border extents back in
	614	changeX += html._getPadBorderExtents(inDrag.spanners[0].node).w;
	615	}
	616	var data = {
	617	deltaX: changeX,
	618	w: inDrag.w + changeX,
	619	vw: inDrag.vw + changeX,
	620	tw: inDrag.tw + changeX
	621	};
	622	// Only resize the columns when the drag has finished
	623	this.doResizeNow(inDrag, data);
	624	delete this.dragRecord;
	625	}
	626
	627	html.destroy(this.lineDiv);
	628	html.destroy(this.moverDiv);
	629	html.destroy(this.moverDiv);
	630	delete this.moverDiv;
	631	this._skipBogusClicks = true;
	632	inDrag.view.update();
	633	this._skipBogusClicks = false;
	634	this.grid.onResizeColumn(inDrag.index);
	635	},
	636	doResizeNow: function(inDrag, data){
	637	inDrag.view.convertColPctToFixed();
	638	if(inDrag.view.flexCells && !inDrag.view.testFlexCells()){
	639	var t = findTable(inDrag.node);
	640	if(t){
	641	(t.style.width = '');
	642	}
	643	}
	644	var i, s, sw, f, fl;
	645	for(i=0; (s=inDrag.spanners[i]); i++){
	646	sw = s.width + data.deltaX;
	647	if(sw > 0){
	648	s.node.style.width = sw + 'px';
	649	inDrag.view.setColWidth(s.index, sw);
	650	}
	651	}
	652	if(this.grid.isLeftToRight() \|\| !has('ie')){//fix #11339
	653	for(i=0; (f=inDrag.followers[i]); i++){
	654	fl = f.left + data.deltaX;
	655	f.node.style.left = fl + 'px';
	656	}
	657	}
	658	inDrag.node.style.width = data.w + 'px';
	659	inDrag.view.setColWidth(inDrag.index, data.w);
	660	inDrag.view.headerNode.style.width = data.vw + 'px';
	661	inDrag.view.setColumnsWidth(data.tw);
	662	if(!this.grid.isLeftToRight()){
	663	inDrag.view.headerNode.scrollLeft = inDrag.scrollLeft + data.deltaX;
	664	}
	665	}
	666	});
	667
	668	// Maps an html table into a structure parsable for information about cell row and col spanning.
	669	// Used by HeaderBuilder.
	670	dg._TableMap = lang.extend(function(rows){
	671	this.mapRows(rows);
	672	},{
	673	map: null,
	674
	675	mapRows: function(inRows){
	676	// summary:
	677	// Map table topography
	678
	679	//console.log('mapRows');
	680	// # of rows
	681	var rowCount = inRows.length;
	682	if(!rowCount){
	683	return;
	684	}
	685	// map which columns and rows fill which cells
	686	this.map = [];
	687	var row;
	688	for(var k=0; (row=inRows[k]); k++){
	689	this.map[k] = [];
	690	}
	691	for(var j=0; (row=inRows[j]); j++){
	692	for(var i=0, x=0, cell, colSpan, rowSpan; (cell=row[i]); i++){
	693	while(this.map[j][x]){x++;}
	694	this.map[j][x] = { c: i, r: j };
	695	rowSpan = cell.rowSpan \|\| 1;
	696	colSpan = cell.colSpan \|\| 1;
	697	for(var y=0; y<rowSpan; y++){
	698	for(var s=0; s<colSpan; s++){
	699	this.map[j+y][x+s] = this.map[j][x];
	700	}
	701	}
	702	x += colSpan;
	703	}
	704	}
	705	//this.dumMap();
	706	},
	707
	708	dumpMap: function(){
	709	for(var j=0, row, h=''; (row=this.map[j]); j++,h=''){
	710	for(var i=0, cell; (cell=row[i]); i++){
	711	h += cell.r + ',' + cell.c + ' ';
	712	}
	713	}
	714	},
	715
	716	getMapCoords: function(inRow, inCol){
	717	// summary:
	718	// Find node's map coords by it's structure coords
	719	for(var j=0, row; (row=this.map[j]); j++){
	720	for(var i=0, cell; (cell=row[i]); i++){
	721	if(cell.c==inCol && cell.r == inRow){
	722	return { j: j, i: i };
	723	}
	724	//else{console.log(inRow, inCol, ' : ', i, j, " : ", cell.r, cell.c); };
	725	}
	726	}
	727	return { j: -1, i: -1 };
	728	},
	729
	730	getNode: function(inTable, inRow, inCol){
	731	// summary:
	732	// Find a node in inNode's table with the given structure coords
	733	var row = inTable && inTable.rows[inRow];
	734	return row && row.cells[inCol];
	735	},
	736
	737	_findOverlappingNodes: function(inTable, inRow, inCol){
	738	var nodes = [];
	739	var m = this.getMapCoords(inRow, inCol);
	740	//console.log("node j: %d, i: %d", m.j, m.i);
	741	for(var j=0, row; (row=this.map[j]); j++){
	742	if(j == m.j){ continue; }
	743	var rw = row[m.i];
	744	//console.log("overlaps: r: %d, c: %d", rw.r, rw.c);
	745	var n = (rw?this.getNode(inTable, rw.r, rw.c):null);
	746	if(n){ nodes.push(n); }
	747	}
	748	//console.log(nodes);
	749	return nodes;
	750	},
	751
	752	findOverlappingNodes: function(inNode){
	753	return this._findOverlappingNodes(findTable(inNode), getTrIndex(inNode.parentNode), getTdIndex(inNode));
	754	}
	755	});
	756
	757	return {
	758	_Builder: _Builder,
	759	_HeaderBuilder: _HeaderBuilder,
	760	_ContentBuilder: _ContentBuilder
	761	};
	762	});

Note: See TracBrowser for help on using the repository browser.

Download in other formats: