fcrep.js

一个完整的

		if(i>=row0 && i<=row1 )
			t.rows(i).cells(0).style.color="blue"
		else
			t.rows(i).cells(0).style.color="black"
	}
	for (var i=0;i<t.rows(0).cells.length;i++){
		if(i>=col0 && i<=col1)
			t.rows(0).cells(i).style.color="blue"
		else
			t.rows(0).cells(i).style.color="black"
	}

//显示框的背景色
	if (row0==row1 && col0==col1)//选中单个单元格
		tc.style.background ="white"
	else
		tc.style.background ="#e6e6fa"
//	if (lngStatus==3)//选中一个大的合并单元格
//		tc.style.background ="white"


	tc.style.display ="block"
	tc.style.zIndex =-1
}
function showBlueRect(){
//根据sLeft sTop sWidth sHeight eLeft eTop eWidth eHeight这八个全局变量的值计算兰框的位置
	var curLeft,curTop,curWidth,curHeight
	/*
	var ssWidth,ssHeight
	if(sWidth>eWidth)
		ssWidth=sWidth
	else
		ssWidth=eWidth
	
	if(sHeight>eHeight)
		ssHeight=sHeight
	else
		ssHeight=eHeight
	*/	
	if (sLeft==eLeft && sTop==eTop)	{
		curLeft=sLeft
		curTop=sTop
		curWidth=sWidth
		curHeight=sHeight
	}
	if (sLeft<=eLeft && sTop<=eTop)			
	{
		curLeft=sLeft
		curTop=sTop
		curWidth=eWidth+eLeft-sLeft
		curHeight=eHeight+eTop-sTop
	}
	if (sLeft<=eLeft && sTop>eTop)			
	{
		curLeft=sLeft
		curTop=eTop
		curWidth=eWidth+eLeft-sLeft
		curHeight=sHeight+sTop-eTop

	}
	if (sLeft>=eLeft && sTop>=eTop)			
	{
		curLeft=eLeft
		curTop=eTop
		curWidth=sWidth+sLeft-eLeft
		curHeight=sHeight+sTop-eTop
	}
	if (sLeft>eLeft && sTop<=eTop)			
	{
		curLeft=eLeft
		curTop=sTop
		curWidth=sWidth+sLeft-eLeft
		curHeight=eHeight+eTop-sTop
	}

//	tc.style.display ="block"
//	tc.style.zIndex =-1
	tc.style.left =curLeft
	tc.style.top =curTop
	tc.style.width =curWidth
	tc.style.height =curHeight
}
function selectRange(sRow1,sCol1,eRow1,eCol1){
//选择某个区域的常用函数
	sRow=sRow1
	sCol=sCol1
	eRow=eRow1
	eCol=eCol1
	if(sRow>eRow){
		sRowSort=eRow
		eRowSort=sRow
	}
	else {
		sRowSort=sRow
		eRowSort=eRow
	}
	if(sCol>eCol){
		sColSort=eCol
		eColSort=sCol
	}
	else {
		sColSort=sCol
		eColSort=eCol
	}
	showBlueScale(sRow,sCol,eRow,eCol)
	var arr=PhyToLog(sRow,sCol)
	var td1=t.rows(arr[0]).cells(arr[1])
	sLeft=td1.offsetLeft
	sTop=td1.offsetTop
	sWidth=td1.offsetWidth
	sHeight=td1.offsetHeight
	var arr1=PhyToLog(eRow,eCol)
	var td2=t.rows(arr1[0]).cells(arr1[1])
	eLeft=td2.offsetLeft
	eTop=td2.offsetTop
	eWidth=td2.offsetWidth
	eHeight=td2.offsetHeight
	showBlueRect()
	grid.moveedit(td1)
}
//*****************************************************************************************
//处理合并
//*****************************************************************************************
function Split() {
//单元格拆分
	//show(sCol+" "+sRow+"  "+eCol+"  "+eRow)
	
	var lngStatus=SelStatus(sRow,sCol,eRow,eCol)
	if(lngStatus!=3) return

	//show(tCopy.innerHTML)
	var rCount=eRowSort-sRowSort+1 //合并的行数
	var cCount=eColSort-sColSort+1 //合并的列数
	//增加第一行之后的所有单元格	
	for (var i=eRowSort;i>=sRowSort+1;i--){
		var tdsCol=PhyToLogCol(i,sColSort)
		//show("r="+i+" c="+sCol+" tdCol="+tdsCol)
		var tdeCol=eColSort-sColSort+tdsCol
		//show(tdeCol+" "+tdsCol)
		for (var j=tdsCol;j<=tdeCol;j++){
			if (tdsCol<t.rows(i).cells.length)
				t.rows(i).insertCell(tdsCol)
			else
				t.rows(i).insertCell()
		}
	}
	//增加第一行的第一个单元格之后的单元格
	var tdsCol=PhyToLogCol(sRowSort,sColSort)
	var tdeCol=eColSort-sColSort+tdsCol
	for (var j=tdsCol+1;j<=tdeCol;j++){
		if(tdsCol+1<t.rows(sRowSort).cells.length)
			t.rows(sRowSort).insertCell(tdsCol+1)
		else
			t.rows(sRowSort).insertCell()
	}
	//给第一单元格的rowSpan colSpan
	t.rows(sRowSort).cells(tdsCol).rowSpan=1
	t.rows(sRowSort).cells(tdsCol).colSpan=1

	CopytHtml()
	grid.moveedit()
	blnChange=true
}
function Merge() {
//sRow sCol eRow eCol 单元格合并	
	//show(sCol+" "+sRow+"  "+eCol+"  "+eRow)
	var lngStatus=SelStatus(sRow,sCol,eRow,eCol)
	if(lngStatus!=4 ) return
	
	var rCount=eRowSort-sRowSort+1 //合并的行数
	var cCount=eColSort-sColSort+1 //合并的列数

	//删除第一行之后的所有单元格	
	for (var i=eRowSort;i>=sRowSort+1;i--){
		var tdeCol=PhyToLogCol(i,eColSort)
		var tdsCol=PhyToLogCol(i,sColSort)
		
		for (var j=tdeCol;j>=tdsCol;j--){
			try {
				t.rows(i).deleteCell(j)
			}
			catch (e){}
		}
	}
	//删除第一行的第一个单元格之后的单元格
	var tdeCol=PhyToLogCol(sRowSort,eColSort)
	var tdsCol=PhyToLogCol(sRowSort,sColSort)
	for (var j=tdeCol;j>=tdsCol+1;j--){
		try {
			t.rows(sRowSort).deleteCell(j)
		}
		catch (e){}
	}
	//给第一单元格的rowSpan colSpan
	t.rows(sRowSort).cells(tdsCol).rowSpan=rCount
	t.rows(sRowSort).cells(tdsCol).colSpan=cCount
	
	
	CopytHtml()
	grid.moveedit()
	blnChange=true
}
function PhyToLog(row,col) {
	return PhyToLogTmp(row,col,1)
}
function PhyToLogCol(row,col) {
/*求同一行物理列col的前面有多少个TD被合并了.然后返回col减去这个个数.
用于合并和拆分时找到删除TD和插入TD的位置
*/
	return PhyToLogTmp(row,col,3)

}
function PhyToLogTmp(row,col,iType) {
/*
物理位置-->逻辑位置(td位置)
  A:获得TD 

	找物理位置row,col,
	if物理位置row,col的单元格无tdCol属性
		查找此行且小于此列共有多少个有tdCol属性的单元格,td位置=col-有tdCol属性的单元格个数
		行为当前行.
	if物理位置row,col的单元格有tdCol属性,则td位置=tdCol,tdRow属性值 
*/

//中间函数
//iType=1 返回TD, =2 返回TD对应的逻辑列col, =3返回单元格对应当前行所处的列位置,  
	var t=tCopy.childNodes(0)
	var td_col=parseInt(t.rows(row).cells(col).getAttribute("tdCol"))
	var td_row=0

	var AddCols=0
	for(var j=0;j<col;j++){
		var tmp1=parseInt(t.rows(row).cells(j).getAttribute("tdCol"))
		if (isNaN(tmp1)==false) 
			AddCols++
	}

	if (isNaN(td_col)) {
		td_col=col-AddCols
		td_row=row
	}
	else {
		if(iType==3){
			td_col=col-AddCols
		}
		td_row=parseInt(t.rows(row).cells(col).getAttribute("tdRow"))
		if(isNaN(td_row)) td_row=0 //属于意外
	}
	//
	if(iType==1) {
		//alert("row:"+td_row+"col:"+td_col)
		//return t.rows(td_row).cells(td_col)
		var arr=new Array()
		arr[0]=td_row
		arr[1]=td_col
		return arr
		//返回一个TD行列值组成的数组
	}
	if(iType==2 || iType==3)
		return td_col
}

function LogToPhy(row,col) {
/*
逻辑位置(td位置)-->物理位置		{此时行号是不变,只需求列号}
  A:一个单元格 B:一组单元格	
	找逻辑位置row,由小到大比较此行的列号和col(逻辑位置(td位置)),如单元格有tdCol属性则变量不加1,否则加1,
	直到此变量等于col为至,此时当前单元格的列号即为物理位置的列号.

	如是一组单元格则返回左上角单元格的列号
*/
	var colRet
	var AddCols=-1
	for(var j=0;j<tCopy.childNodes(0).rows(row).cells.length;j++){
		var tmp1=parseInt(tCopy.childNodes(0).rows(row).cells(j).getAttribute("tdCol"))
		if (isNaN(tmp1)) 
			AddCols++
		if(AddCols==col) {
			colRet=j
			break
		}			
	}
	
	return colRet
}
function SelStatus(sRow,sCol,eRow,eCol){
/*
区域物理位置(sRow,sCol,eRow,eCol)-->判断:
				0 意外,超出表格的行或列范围
				1 一个单纯独立的单元格
				2 一个合并单元格中的一部分
				3 一个单纯的合并单元格
				4 多个单纯独立的单元格组成的区域
				5 整个合并单元格和小单元格组成的区域
直接输入或超链接:
	一个小单元格/一个合并单元格
增删行列
	一个小单元格
能合并		
	4多个小单元格组成的区域/5由整个合并单元加一些小单元格组成的区域
不能合并
	一个小单元格/一个合并单元格/一个合并单元格的一部分
能拆分
	3一个合并单元格
不能拆分
	NOT 一个合并单元格
设置字体等单元格属性
	一个小单元格/一个合并单元格/多个小单元格组成的区域/由整个合并单元加一些小单元格组成的区域
	在一个合并单元格的一部分+一些小单元格组成的区域情况下直接取单元格进行设置
	
*/
//如果兰框未显示或行列超范围则返回0
	if(tc.style.display=="none" )
		return 0
	if(sRow==eRow && sCol==eCol) {
		return 1
	}
	var t=tCopy.childNodes(0)
	
	var colCount
	var rowCount=parseInt(t.rows(sRowSort).cells(sColSort).getAttribute("rowCount"))
	if(isNaN(rowCount)==false){
		colCount=parseInt(t.rows(sRowSort).cells(sColSort).getAttribute("colCount"))
		//show(rowCount+"=="+(eRowTmp-sRowTmp))
		if(rowCount-1==eRowSort-sRowSort && colCount-1==eColSort-sColSort){
			//只有一个合并单元格
			return 3
		}
	}

	//-------
	//判断区域中:包含整个合并单元/包含部分合并单元
	//如果合并单元格的主单元格在区域外,则肯定是包含部分合并单元
	//如果有一个合并单元格的主单元格+rowCount/+colCount超出区域的话,则肯定是包含部分合并单元
	var bMerge=false //是否有合并单元标志
	var bAllMerge=true //是否包含整个合并单元标志
	for(var i=sRowSort;i<=eRowSort;i++){
		for(var j=sColSort;j<=eColSort;j++){
			var rowCount=parseInt(t.rows(i).cells(j).getAttribute("rowCount"))
			if(isNaN(rowCount)==false){
				bMerge=true
				var colCount=parseInt(t.rows(i).cells(j).getAttribute("colCount"))
				if(i+rowCount-1>eRowSort || j+colCount-1>eColSort){
					bAllMerge=false
				}
			}

			var td_col=parseInt(t.rows(i).cells(j).getAttribute("tdCol"))
			if(isNaN(td_col)==false){
				var td_row=parseInt(t.rows(i).cells(j).getAttribute("tdRow"))
				if(td_row<sRowSort || td_row>eRowSort || td_col<sColSort || td_col>eColSort){
					//在区域外
					bAllMerge=false
				}
				bMerge=true
			}
		}
	}

	if(bMerge==false){ //一组小单元格
		return 4
	}
	if(bMerge){
		if (bAllMerge){
			//如果包含整个合并单元
			return 5
		}
		else {
			//包含部分合并单元
			return 2
		}
	}

}
//将物理位置-->逻辑位置(td位置)
//td的列号,因行号相同
/*计算方法:
将合并单元格按顺序展开,新加的单元格加一个tdCol属性用于标识此单元格对应的td位置.

物理位置-->逻辑位置(td位置)
  A:获得TD 

	找物理位置row,col,
	if物理位置row,col的单元格无tdCol属性
		查找此行且小于此列共有多少个有tdCol属性的单元格,td位置=col-有tdCol属性的单元格个数
		行为当前行.
	if物理位置row,col的单元格有tdCol属性,则td位置=tdCol,tdRow属性值 

				

逻辑位置(td位置)-->物理位置		{此时行号是不变,只需求列号}
  A:一个单元格 B:一组单元格	
	找逻辑位置row,由小到大比较此行的列号和col(逻辑位置(td位置)),如单元格有tdCol属性则变量不加1,否则加1,
	直到此变量等于col为至,此时当前单元格的列号即为物理位置的列号.



*/
function CopytHtml() {
//复制t.outerHTML
	var s1=t.outerHTML
	s1=fc_RepStr(s1," id=t "," ")
	tCopy.innerHTML=s1
	ExpandTab(tCopy.childNodes(0))
}
function ExpandTab(t) {
//将合并单元格按顺序展开,新加的单元格加一个tdRow,tdCol属性用于标识此单元格对应的td位置.

//	var d=new Date()
//	var t2=d.getTime()
	
	var curAddCell
	for (var i=0;i<t.rows.length ;i++) {
		for (var j=0;j<t.rows(i).cells.length ;j++) {
			var curTD=t.rows(i).cells(j)
			
			var lngRows=parseInt(curTD.rowSpan)
			if (isNaN(lngRows))lngRows=0
			var lngCols=parseInt(curTD.colSpan)
			if (isNaN(lngCols))lngCols=0
			if(lngCols>1 || lngRows>1 ) {
			    var td_col=0
			    var td_row=0
			    td_col=parseInt(curTD.getAttribute("tdCol"))
			    if(isNaN(td_col)==false) {
			    //表示此单元格为一个生成的合并单元格
					td_row=parseInt(curTD.getAttribute("tdRow"))
					if (isNaN(td_row)) td_row=0 //属于意外
					
			    }
			    else {
					//原始合并单元加上如下属性
					curTD.setAttribute("rowCount",curTD.rowSpan)
					curTD.setAttribute("colCount",curTD.colSpan)
					//curTD.innerText="rC="+curTD.rowSpan+" cC="+curTD.colSpan
					//--------
					//因此行以前的合并格已展开,应减去
					var AddCols=0
					for(var jjj=0;jjj<=j;jjj++){
						var tmp1=parseInt(t.rows(i).cells(jjj).getAttribute("tdCol"))
						if (isNaN(tmp1)==false) 
							AddCols++
					}
					td_col=j-AddCols
					td_row=i
					
			    }
			}
			if (lngCols>1) {
				
				curTD.colSpan=1
				//补齐当前行的后面的单元
				for (var jjj=1;jjj<=lngCols-1;jjj++) {
					if (j>=t.rows(i).cells.length)
						curAddCell=t.rows(i).insertCell()//加到结尾
					else
						curAddCell=t.rows(i).insertCell(j+1)
					curAddCell.setAttribute("tdRow",td_row)
					curAddCell.setAttribute("tdCol",td_col)
					//curAddCell.innerText="R="+td_row+" C="+td_col
					curAddCell.innerText=curTD.innerText
				}
				
				
			}
			//rowSpan>1
			if (lngRows>1 ) {
			    curTD.rowSpan=1
				//修改rowspan值,合并单元格下移
				var addCols=0
				//计算下一行同一列之前应缩小多少列
				for (var jjj=0;jjj<j; jjj++) {