public void FillKey(System.Data.DataTable table, int rowIndex)
{
if (!isFixedValue)
{
// use context key value ;
if (string.IsNullOrEmpty(colName))
{
keyValue = null;
}
if (rKey == null)
{
rKey = ReusedKey.FindReusedKey(this);
}
keyValue = rKey.GetReusedValue(table, rowIndex);
// RangeHelper.GetColValue (table, rowIndex, colName) ;
}
if (nextKey != null)
{
nextKey.FillKey(table, rowIndex);
}
}
public object GetGroupValue(GroupDataHolder holder, DataTable table, int valueIndex)
{
if (rGroupKey == null)
{
SearchKey key = new SearchKey();
key.colName = this.tplGroupColName;
rGroupKey = ReusedKey.FindReusedKey(key);
}
return(rGroupKey.GetReusedValue(table, valueIndex));
// return RangeHelper.GetColValue(table, valueIndex, tplGroupColName);
}
public static ReusedKey FindReusedKey(SearchKey key)
{
for (int i = 0; i < keyPool.Count; i++)
{
ReusedKey reusedKey = keyPool [i];
if (Equals(reusedKey.colName, key.colName))
{
return(reusedKey);
}
}
ReusedKey rKey = new ReusedKey();
rKey.colName = key.colName;
keyPool.Add(rKey);
return(rKey);
}
public void InsertOneColumn(TplBlock block, int colIndex, GroupDataHolder holder, DataTable table, int valueIndex, bool hasData)
{
if (hasData)
{
// block.startRowIndex ;
Range colRange = RangeHelper.GetRange(tplRange.Worksheet,
startColIndex + colIndex, block.startRowIndex,
1, block.rowCount);
// Insert new ;
RangeHelper.InsertCopyRange(tplRange.Worksheet, colRange,
1, block.rowCount,
startColIndex + gCols + insertCount, block.startRowIndex,
XlInsertShiftDirection.xlShiftToRight, tplLastColCount);
}
// Insert new Col in Template.
Range tplColRange = RangeHelper.GetRange(tplRange.Worksheet,
startColIndex + colIndex, block.tplRange.Row,
1, block.tplRowCount);
RangeHelper.InsertCopyRange(tplRange.Worksheet, tplColRange,
1, block.tplRowCount,
startColIndex + gCols + insertCount, tplColRange.Row,
XlInsertShiftDirection.xlShiftToRight, tplLastColCount);
// Refresh Line.TplRange ;
RefreshLineTplRanges(block, 1);
block.tplColumCount += 1;
block.colCount += 1;
// Insert cell into exsit lineList.
for (int lineIndex = 0; lineIndex < block.lineList.Count; lineIndex++)
{
TplLine line = block.lineList[lineIndex];
int cellIndex = startCellIndex + colIndex;
TplCell cell0 = line.cellList[cellIndex];
TplCell cell = cell0.Copy();
cell.lastColIndex += 1;
line.cellList.Insert(startCellIndex + gCols + insertCount, cell);
/*
* if (cell.useExcelFormula)
* {
* cell.tplRange = cell0.tplRange ;
* }
*/
if (cell.formula != null)
{
for (int keyIndex = 0; keyIndex < cell.formula.keyList.Count; keyIndex++)
{
GroupValueSearchKey gkey = cell.formula.keyList[keyIndex];
if (gkey.rKey == null)
{
SearchKey key0 = new SearchKey();
key0.colName = gkey.valueColName;
gkey.rKey = ReusedKey.FindReusedKey(key0);
}
SearchKey key = gkey.key;
while (key != null)
{
if (IsGroupedColumn(key.colName))
{
key.keyValue = RangeHelper.GetColValue(table, valueIndex, key.colName);
key.isFixedValue = true;
}
key = key.nextKey;
}
block.gkeyList.Add(gkey.Copy());
if (gkey.key != null)
{
gkey.key.FillKey(table, valueIndex);
}
block.holder.AddValue(block.countedMap, gkey, table, valueIndex);
}
}
/*
* else if (cell.hgOption != InsertOption.never)
* {
* // set fixed text
* cell.tplTextContent = Convert.ToString(RangeHelper.GetColValue (table, valueIndex, cell.tplValueColName)) ;
* }
*/
cell.align = GroupAlign.none;
Console.WriteLine("Inserted hg Line[" + lineIndex + "]cell[" + cellIndex + "] = " + cell.formula);
/* update Row Value */
if (lineIndex < block.rowCount)
{
Range cellRange = RangeHelper.GetCell(tplRange.Worksheet, startColIndex + gCols + insertCount,
block.startRowIndex + lineIndex);
cell.WriteCell(tpl, holder, cellRange, table, valueIndex);
}
}
// Console.WriteLine ("---- End of " + valueIndex);
// increment next
nextCloIndex += 1;
insertCount++;
}
public int FillBlock(DataTable table)
{
int rowIndex = startRowIndex;
for (int valueIndex = 0; valueIndex < table.Rows.Count; valueIndex++)
{
countedMap.Clear();
// fill key for each line, and count Data.
// Check is Need Row ;
if (dColumn != null && !dCloumnsCreated)
{
dColumn.CheckColumn(this, holder, rowIndex,
table, valueIndex);
}
// fill key for each line, and count Data.
for (int j = 0; j < gkeyList.Count; j++)
{
GroupValueSearchKey gkey = gkeyList [j];
if (gkey.rKey == null)
{
SearchKey key = new SearchKey();
key.colName = gkey.valueColName;
gkey.rKey = ReusedKey.FindReusedKey(key);
}
gkey = gkey.Copy();
if (gkey.key != null)
{
gkey.key.FillKey(table, valueIndex);
}
holder.AddValue(countedMap, gkey, table, valueIndex);
}
// fill Data
for (int j = 0; j < lineList.Count; j++)
{
TplLine line = lineList[j];
/*
* if (j == 4)
* j = 4 ;
*/
int nl = line.FillLine(holder, rowIndex, table, valueIndex);
if (nl > 0)
{
FillLastLine(j, lastUsedLine, rowIndex - 1, table, lastUsedLineValueIndex);
lastUsedLine = line;
lastUsedLineValueIndex = valueIndex;
// is LastLine, update current line
if (valueIndex + 1 >= table.Rows.Count)
{
FillLastLine(j, line, rowIndex, table, lastUsedLineValueIndex);
}
}
/*else
* {
* // Ensure Each Column is OK.
* if (dColumn != null && lastUsedLine != null && lastUsedLine == line)
* {
* if (! lastUsedLine.containsHGroup)
* lastUsedLine.UpdateRowData (holder, rowIndex - 1, table, valueIndex);
*
* if (updateAllRow)
* {
* for (int k = 0 ; k <= j ; k ++)
* {
* TplLine hLine = lineList [k] ;
* if (hLine.containsHGroup && hLine.insertedRowList.Count > 0)
* {
* hLine.UpdateRowData(holder,
* hLine.insertedRowList[hLine.insertedRowList.Count - 1],
* table, valueIndex);
* }
* }
* }
*
* }
* }*/
rowIndex += nl;
rowCount += nl;
}
}
MergeHGroupCells();
//if the table is custum empty ,ignor the MergeVGroupCells
if (table.ExtendedProperties.ContainsKey("TableType") &&
table.ExtendedProperties["TableType"].ToString() == "CustumEmpty")
{
return(rowCount);
}
MergeVGroupCells();
return(rowCount);
}
public void AddValue(Dictionary <GroupValueSearchKey, bool> map, GroupValueSearchKey gkey,
System.Data.DataTable table, int valueIndex)
{
if (map.ContainsKey(gkey))
{
// ignored.
return;
}
// judge Data is Match
if (gkey.key != null)
{
SearchKey tmpKey = gkey.key;
while (tmpKey != null)
{
if (tmpKey.rKey == null)
{
tmpKey.rKey = ReusedKey.FindReusedKey(tmpKey);
}
if (tmpKey.isFixedValue)
{
// Compare Fixed value Key only
object keyValue = null;
keyValue = tmpKey.rKey.GetReusedValue(table, valueIndex);
// RangeHelper.GetColValue (table, valueIndex, tmpKey.colName) ;
// Not match, return .
if (!Equals(keyValue, tmpKey.keyValue))
{
return;
}
}
tmpKey = tmpKey.nextKey;
}
/*SearchKey copyKey = gkey.key.Copy0 (false) ;
* copyKey.FillKey (table, valueIndex);
*
* // not match.
* if (! copyKey.Equals (gkey.key))
* return ;*/
}
object lastValue;
if (!valueList.TryGetValue(gkey, out lastValue))
{
lastValue = 0;
valueList.Add(gkey, lastValue);
}
if (gkey.rKey == null)
{
SearchKey key = new SearchKey();
key.colName = gkey.valueColName;
gkey.rKey = ReusedKey.FindReusedKey(key);
}
valueList [gkey] = CalculateForumla(gkey.formula, lastValue,
gkey.rKey.GetReusedValue(table, valueIndex));
map[gkey /*.Copy()*/] = true;
}