/// <summary>
/// 递归获取小计最大数据值
/// </summary>
/// <param name="p_total"></param>
/// <returns></returns>
int TotalMax(RptMtxSubtotal p_total)
{
int maxIndex = GetValidInt(p_total, "subtotal");
if (p_total.SubTotals.Count > 0)
{
maxIndex = p_total.SubTotals.Max(itm => GetValidInt(itm, "subtotal"));
foreach (RptMtxSubtotal total in p_total.SubTotals)
{
int max = TotalMax(total);
if (maxIndex < max)
{
maxIndex = max;
}
}
}
return(maxIndex);
}
protected override void ReadChildXml(XmlReader p_reader)
{
switch (p_reader.Name)
{
case "Text":
Item.ReadXml(p_reader);
break;
case "Subtotal":
if (SubTotals == null)
{
SubTotals = new List <RptMtxSubtotal>();
}
RptMtxSubtotal sub = new RptMtxSubtotal(this);
sub.ReadXml(p_reader);
SubTotals.Add(sub);
break;
}
}
/// <summary>
/// 获取所属层下的 类型
/// </summary>
/// <param name="p_levels"></param>
/// <param name="p_row"></param>
/// <param name="p_col"></param>
/// <returns></returns>
MtxRangeType GetRangeTypeByLevel(List <RptMtxLevel> p_levels, int p_row, int p_col)
{
foreach (RptMtxLevel level in p_levels)
{
if ((level.Row <= p_row && p_row < level.Row + level.RowSpan) &&
level.Col <= p_col && p_col < level.Col + level.ColSpan)
{
return(MtxRangeType.Level);
}
RptMtxSubtotal total = GetSubtotal(level.SubTotals.ToList(), p_row, p_col);
if (total != null)
{
return(MtxRangeType.Subtotal);
}
RptMtxSubtitle title = GetSubtitle(level.SubTitles.ToList(), p_row, p_col);
if (title != null)
{
return(MtxRangeType.Subtitle);
}
}
return(MtxRangeType.HeaderEmpty);
}
public override void Undo(object p_args)
{
SubTotalCmdArgs args = (SubTotalCmdArgs)p_args;
RptMtxSubtotal total = args.SubTotal;
RptItemBase parent = args.Parent;
RptMatrix mtx = null;
if (parent is RptMtxLevel)
{
RptMtxLevel pLevel = parent as RptMtxLevel;
mtx = pLevel.Matrix;
args.BackMtxRow();
pLevel.SubTotals.Insert(args.TotalIndex, total);
}
else
{
RptMtxSubtotal pTotal = parent as RptMtxSubtotal;
mtx = pTotal.Level.Matrix;
args.BackMtxRow();
pTotal.SubTotals.Insert(args.TotalIndex, total);
}
mtx.Update(true);
}
public override object Execute(object p_args)
{
SubTotalCmdArgs args = (SubTotalCmdArgs)p_args;
RptItemBase parent = args.Parent;
RptMtxSubtotal total = args.SubTotal;
RptMtxHeaderType headerType = RptMtxHeaderType.Col;
RptMatrix mtx = null;
args.InitData();
if (parent is RptMtxLevel)
{
RptMtxLevel pLevel = parent as RptMtxLevel;
mtx = pLevel.Matrix;
if (pLevel.Parent is RptMtxRowHeader)
{
headerType = RptMtxHeaderType.Row;
}
DelRows(args, headerType, mtx, total);
args.TotalIndex = pLevel.SubTotals.IndexOf(total);
pLevel.SubTotals.Remove(total);
}
else
{
RptMtxSubtotal pTotal = parent as RptMtxSubtotal;
mtx = pTotal.Level.Matrix;
if (pTotal.Level.Parent is RptMtxRowHeader)
{
headerType = RptMtxHeaderType.Row;
}
DelRows(args, headerType, mtx, total);
args.TotalIndex = pTotal.SubTotals.IndexOf(total);
pTotal.SubTotals.Remove(total);
}
mtx.Update(true);
return(total);
}
public override object Execute(object p_args)
{
SubTotalCmdArgs args = (SubTotalCmdArgs)p_args;
RptItemBase parent = args.Parent;
RptMtxHeaderType headerType = RptMtxHeaderType.Col;
RptMtxSubtotal total = args.SubTotal;
RptMatrix mtx = null;
if (total == null)
{
total = new RptMtxSubtotal(parent);
args.InitData();
if (parent is RptMtxLevel)
{
RptMtxLevel pLevel = parent as RptMtxLevel;
mtx = pLevel.Matrix;
if (pLevel.Parent is RptMtxRowHeader)
{
headerType = RptMtxHeaderType.Row;
}
total.Item.Val = string.Format("subtotal{0}", mtx.GetMaxTotal());
int curIndex = 0;
if (headerType == RptMtxHeaderType.Row)
{
curIndex = pLevel.Row;
if (!mtx.HideRowHeader && !mtx.HideColHeader)
{
curIndex -= (mtx.Corner.Row + mtx.Corner.RowSpan);
}
args.OpsRows.Add(InsertNewRow(mtx, curIndex));
}
else
{
curIndex = pLevel.Col - mtx.Rows[0].Col;
foreach (RptMtxRow row in mtx.Rows)
{
args.OpsCells.Add(row, InsertNewCell(mtx, row, curIndex).ToList());
}
}
args.CurIndex = curIndex;
}
else
{
RptMtxSubtotal pTotal = parent as RptMtxSubtotal;
mtx = pTotal.Level.Matrix;
if (pTotal.Level.Parent is RptMtxRowHeader)
{
headerType = RptMtxHeaderType.Row;
}
total.Item.Val = string.Format("subtotal{0}", mtx.GetMaxTotal());
if (pTotal.SubTotals.Count > 0)
{
int curIndex = 0;
if (headerType == RptMtxHeaderType.Row)
{
curIndex = pTotal.Row + pTotal.GetCount();
if (!mtx.HideColHeader && !mtx.HideRowHeader)
{
curIndex -= (mtx.Corner.Row + mtx.Corner.RowSpan);
}
args.OpsRows.Add(InsertNewRow(mtx, curIndex));
}
else
{
curIndex = pTotal.Col - mtx.Rows[0].Col + pTotal.GetCount();
foreach (RptMtxRow row in mtx.Rows)
{
args.OpsCells.Add(row, InsertNewCell(mtx, row, curIndex).ToList());
}
}
args.CurIndex = curIndex;
}
}
}
else
{
mtx = total.Level.Matrix;
args.BackMtxRow();
}
if (parent is RptMtxLevel)
{
(parent as RptMtxLevel).SubTotals.Add(total);
}
else
{
(parent as RptMtxSubtotal).SubTotals.Add(total);
}
args.SubTotal = total;
mtx.Update(true);
return(total);
}
public override object Execute(object p_args)
{
SubTotalCmdArgs args = (SubTotalCmdArgs)p_args;
RptMtxLevel pLevel = args.Parent as RptMtxLevel;
RptMtxSubtotal total = args.SubTotal;
RptMatrix mtx = pLevel.Matrix;
if (pLevel != null)
{
int count = 0;
int newIndex = 0;
int index = 0;
if (pLevel.Parent is RptMtxRowHeader)
{
args.OpsRows = total.GetRptRows(out index);
mtx.Rows.RemoveRange(index, args.OpsRows.Count);
if (total.TotalLoc == TotalLocation.Before)
{
count = (from c in pLevel.SubTotals
where c.TotalLoc == total.TotalLoc &&
pLevel.SubTotals.IndexOf(c) >= pLevel.SubTotals.IndexOf(total)
select c).Count();
newIndex = pLevel.Row - count - (mtx.Row + mtx.ColHeader.RowSpan);
}
else
{
count = (from c in pLevel.SubTotals
where c.TotalLoc == total.TotalLoc &&
pLevel.SubTotals.IndexOf(c) < pLevel.SubTotals.IndexOf(total)
select c).Count();
newIndex = pLevel.Row + pLevel.RowSpan + count - (mtx.Row + mtx.ColHeader.RowSpan);
}
mtx.Rows.InsertRange(newIndex, args.OpsRows);
}
else
{
args.OpsCells = total.GetRptCells(out index);
foreach (RptMtxRow row in args.OpsCells.Keys)
{
row.Cells.RemoveRange(index, args.OpsCells[row].Count);
if (total.TotalLoc == TotalLocation.Before)
{
count = (from c in pLevel.SubTotals
where c.TotalLoc == total.TotalLoc &&
pLevel.SubTotals.IndexOf(c) >= pLevel.SubTotals.IndexOf(total)
select c).Count();
newIndex = pLevel.Col - count - (mtx.Col + mtx.RowHeader.ColSpan);
}
else
{
count = (from c in pLevel.SubTotals
where c.TotalLoc == total.TotalLoc &&
pLevel.SubTotals.IndexOf(c) < pLevel.SubTotals.IndexOf(total)
select c).Count();
newIndex = pLevel.Col + pLevel.ColSpan + count - (mtx.Col + mtx.RowHeader.ColSpan);
}
row.Cells.InsertRange(newIndex, args.OpsCells[row]);
}
}
args.BefIndex = index;
args.CurIndex = newIndex;
}
mtx.Update(true);
return(null);
}
/// <summary>
/// 删除对应数据
/// </summary>
/// <param name="p_args"></param>
/// <param name="p_headerType"></param>
/// <param name="p_mat"></param>
/// <param name="p_total"></param>
void DelRows(SubTotalCmdArgs p_args, RptMtxHeaderType p_headerType, RptMatrix p_mat, RptMtxSubtotal p_total)
{
if (p_total.Parent is RptMtxLevel || (p_total.Parent as RptMtxSubtotal).SubTotals.Count > 1)
{
if (p_headerType == RptMtxHeaderType.Row)
{
int index = -1;
List <RptMtxRow> opsRows = p_total.GetRptRows(out index);
if (opsRows != null)
{
p_args.OpsRows = opsRows;
p_args.CurIndex = index;
p_mat.Rows.RemoveRange(index, p_total.RowSpan);
}
}
else
{
int index = -1;
Dictionary <RptMtxRow, List <RptText> > opsCells = p_total.GetRptCells(out index);
if (opsCells != null)
{
foreach (RptMtxRow row in opsCells.Keys)
{
row.Cells.RemoveRange(index, p_total.ColSpan);
}
p_args.CurIndex = index;
p_args.OpsCells = opsCells;
}
}
}
}
/// <summary>
/// 获取内部指定位置的文本
/// </summary>
/// <param name="p_row"></param>
/// <param name="p_col"></param>
/// <returns></returns>
public RptText GetText(int p_row, int p_col)
{
MtxRangeType mtxType = GetRangeType(p_row, p_col);
switch (mtxType)
{
case MtxRangeType.Corner:
{
return(Corner.Item);
}
case MtxRangeType.Level:
{
foreach (RptMtxLevel level in RowHeader.Levels)
{
if ((level.Row <= p_row && p_row < level.Row + level.RowSpan) &&
level.Col <= p_col && p_col < level.Col + level.ColSpan)
{
return(level.Item);
}
}
foreach (RptMtxLevel level in ColHeader.Levels)
{
if ((level.Row <= p_row && p_row < level.Row + level.RowSpan) &&
level.Col <= p_col && p_col < level.Col + level.ColSpan)
{
return(level.Item);
}
}
return(null);
}
case MtxRangeType.Subtotal:
{
foreach (RptMtxLevel level in RowHeader.Levels)
{
RptMtxSubtotal total = GetSubtotal(level.SubTotals.ToList(), p_row, p_col);
if (total != null)
{
return(total.Item);
}
}
foreach (RptMtxLevel level in ColHeader.Levels)
{
RptMtxSubtotal total = GetSubtotal(level.SubTotals.ToList(), p_row, p_col);
if (total != null)
{
return(total.Item);
}
}
return(null);
}
case MtxRangeType.Subtitle:
{
foreach (RptMtxLevel level in RowHeader.Levels)
{
RptMtxSubtitle title = GetSubtitle(level.SubTitles.ToList(), p_row, p_col);
if (title != null)
{
return(title.Item);
}
}
foreach (RptMtxLevel level in ColHeader.Levels)
{
RptMtxSubtitle title = GetSubtitle(level.SubTitles.ToList(), p_row, p_col);
if (title != null)
{
return(title.Item);
}
}
return(null);
}
case MtxRangeType.Body:
{
return(Rows[p_row - Row - Corner.RowSpan].Cells[p_col - Col - Corner.ColSpan]);
}
case MtxRangeType.HeaderEmpty:
{
return(null);
}
default:
return(null);
}
}
