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;
case "Subtitle":
if (SubTitles == null)
{
SubTitles = new List <RptMtxSubtitle>();
}
RptMtxSubtitle title = new RptMtxSubtitle(this);
title.ReadXml(p_reader);
SubTitles.Add(title);
break;
}
}
/// <summary>
/// 获取最大ID的转换方法
/// </summary>
/// <param name="p_item"></param>
/// <param name="p_preName"></param>
/// <returns></returns>
int GetValidInt(RptItemBase p_item, string p_preName)
{
if (p_item is RptMtxSubtotal)
{
RptMtxSubtotal total = p_item as RptMtxSubtotal;
if (total.Item.Val.Length < p_preName.Length)
{
return(0);
}
int id = 0;
if (int.TryParse(total.Item.Val.Substring(p_preName.Length), out id))
{
return(id);
}
return(0);
}
else
{
RptMtxSubtitle title = p_item as RptMtxSubtitle;
if (title.Item.Val.Length < p_preName.Length)
{
return(0);
}
int id = 0;
if (int.TryParse(title.Item.Val.Substring(p_preName.Length), out id))
{
return(id);
}
return(0);
}
}
public SubTitleCmdArgs(RptItemBase p_parent, RptMtxSubtitle p_title = null, int p_newSpan = -1)
{
Parent = p_parent;
SubTitle = p_title;
NewSpan = p_newSpan;
InitData();
}
public override void Undo(object p_args)
{
SubTitleCmdArgs args = (SubTitleCmdArgs)p_args;
RptMtxSubtitle title = args.SubTitle;
RptMatrix mtx = title.Level.Matrix;
title.Span = args.OldSpan;
mtx.Update(true);
}
public override object Execute(object p_args)
{
SubTitleCmdArgs args = (SubTitleCmdArgs)p_args;
RptMtxSubtitle title = args.SubTitle;
RptMatrix mtx = title.Level.Matrix;
args.OldSpan = title.Span;
title.Span = args.NewSpan;
mtx.Update(true);
return(null);
}
internal void LoadItem(RptText p_item)
{
_title = p_item.Parent as RptMtxSubtitle;
Row row = new Row();
row.AddCell("span", _title.Data.Int("span"));
row.Changed += OnChanged;
_fv.Data = row;
_fvMtx.LoadItem(_title.Level.Matrix);
}
/// <summary>
/// 克隆标题
/// </summary>
/// <param name="p_parent"></param>
/// <returns></returns>
public RptMtxSubtitle Clone(RptItemBase p_parent)
{
RptMtxSubtitle title = new RptMtxSubtitle(p_parent);
title.Data.Copy(this.Data);
title.Item.Data.Copy(Item.Data);
foreach (RptMtxSubtitle sub in SubTitles)
{
title.SubTitles.Add(sub.Clone(title));
}
return(title);
}
/// <summary>
/// 根据行列获取标题
/// </summary>
/// <param name="p_titles"></param>
/// <param name="p_row"></param>
/// <param name="p_col"></param>
/// <returns></returns>
RptMtxSubtitle GetSubtitle(List <RptMtxSubtitle> p_titles, int p_row, int p_col)
{
foreach (RptMtxSubtitle title in p_titles)
{
if ((title.Row <= p_row && p_row < title.Row + title.RowSpan) &&
title.Col <= p_col && p_col < title.Col + title.ColSpan)
{
return(title);
}
RptMtxSubtitle sub = GetSubtitle(title.SubTitles.ToList(), p_row, p_col);
if (sub != null)
{
return(sub);
}
}
return(null);
}
/// <summary>
/// 递归获取标题最大数据值
/// </summary>
/// <param name="p_title"></param>
/// <returns></returns>
int TitleMax(RptMtxSubtitle p_title)
{
int maxIndex = GetValidInt(p_title, "subtitle");
if (p_title.SubTitles.Count > 0)
{
maxIndex = p_title.SubTitles.Max(itm => GetValidInt(itm, "subtitle"));
foreach (RptMtxSubtitle title in p_title.SubTitles)
{
int max = TitleMax(title);
if (maxIndex < max)
{
maxIndex = max;
}
}
}
return(maxIndex);
}
/// <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)
{
SubTitleCmdArgs args = (SubTitleCmdArgs)p_args;
RptMtxSubtitle title = args.SubTitle;
RptItemBase parent = args.Parent;
RptMatrix mtx = null;
if (parent is RptMtxLevel)
{
RptMtxLevel pLevel = parent as RptMtxLevel;
mtx = pLevel.Matrix;
args.BackMtxRow();
pLevel.SubTitles.Insert(args.TilteIndex, title);
}
else
{
RptMtxSubtitle pTotal = parent as RptMtxSubtitle;
mtx = pTotal.Level.Matrix;
args.BackMtxRow();
pTotal.SubTitles.Insert(args.TilteIndex, title);
}
mtx.Update(true);
}
public override void Undo(object p_args)
{
SubTitleCmdArgs args = (SubTitleCmdArgs)p_args;
RptMtxSubtitle title = args.SubTitle;
RptItemBase parent = args.Parent;
RptMatrix mtx = null;
if (parent is RptMtxLevel)
{
RptMtxLevel pLevel = parent as RptMtxLevel;
mtx = pLevel.Matrix;
args.DelMtxRows();
pLevel.SubTitles.Remove(title);
}
else
{
RptMtxSubtitle pTitle = parent as RptMtxSubtitle;
mtx = pTitle.Level.Matrix;
args.DelMtxRows();
pTitle.SubTitles.Remove(title);
}
mtx.Update(true);
}
public override object Execute(object p_args)
{
SubTitleCmdArgs args = (SubTitleCmdArgs)p_args;
RptItemBase parent = args.Parent;
RptMtxSubtitle title = args.SubTitle;
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, title);
args.TilteIndex = pLevel.SubTitles.IndexOf(title);
pLevel.SubTitles.Remove(title);
}
else
{
RptMtxSubtitle pTotal = parent as RptMtxSubtitle;
mtx = pTotal.Level.Matrix;
if (pTotal.Level.Parent is RptMtxRowHeader)
{
headerType = RptMtxHeaderType.Row;
}
DelRows(args, headerType, mtx, title);
args.TilteIndex = pTotal.SubTitles.IndexOf(title);
pTotal.SubTitles.Remove(title);
}
mtx.Update(true);
return(null);
}
public override object Execute(object p_args)
{
SubTitleCmdArgs args = (SubTitleCmdArgs)p_args;
RptItemBase parent = args.Parent;
RptMtxHeaderType headerType = RptMtxHeaderType.Col;
RptMtxSubtitle title = args.SubTitle;
RptMatrix mtx = null;
if (title == null)
{
title = new RptMtxSubtitle(parent);
args.InitData();
if (parent is RptMtxLevel)
{
RptMtxLevel pLevel = parent as RptMtxLevel;
mtx = pLevel.Matrix;
if (pLevel.Parent is RptMtxRowHeader)
{
headerType = RptMtxHeaderType.Row;
}
title.Item.Val = string.Format("subtitle{0}", mtx.GetMaxTitle());
RptMtxHeader header = pLevel.Parent as RptMtxHeader;
if (pLevel.SubTitles.Count > 0 || header.Levels.Count > header.Levels.IndexOf(pLevel) + 1)
{
int curIndex = 0;
if (headerType == RptMtxHeaderType.Row)
{
int subLevelSpan = 0;
if (header.Levels.Count > header.Levels.IndexOf(pLevel) + 1)
{
subLevelSpan = header.Levels[header.Levels.IndexOf(pLevel) + 1].RowSpan;
}
curIndex = pLevel.Row - mtx.ColHeader.Row - mtx.ColHeader.RowSpan + subLevelSpan + pLevel.GetTitleSpan(pLevel.SubTitles);
args.OpsRows.Add(InsertNewRow(mtx, curIndex));
}
else
{
int subLevelSpan = 0;
if (header.Levels.Count > header.Levels.IndexOf(pLevel) + 1)
{
subLevelSpan = header.Levels[header.Levels.IndexOf(pLevel) + 1].ColSpan;
}
curIndex = pLevel.Col - mtx.RowHeader.Col - mtx.RowHeader.ColSpan + subLevelSpan + pLevel.GetTitleSpan(pLevel.SubTitles);
foreach (RptMtxRow row in mtx.Rows)
{
args.OpsCells.Add(row, InsertNewCell(mtx, row, curIndex).ToList());
}
}
args.CurIndex = curIndex;
}
pLevel.SubTitles.Add(title);
}
else
{
RptMtxSubtitle pTitle = parent as RptMtxSubtitle;
mtx = pTitle.Level.Matrix;
if (pTitle.Level.Parent is RptMtxRowHeader)
{
headerType = RptMtxHeaderType.Row;
}
title.Item.Val = string.Format("subtitle{0}", mtx.GetMaxTitle());
if (pTitle.SubTitles.Count > 0)
{
int curIndex = 0;
if (headerType == RptMtxHeaderType.Row)
{
curIndex = pTitle.Row + pTitle.RowSpan - mtx.ColHeader.Row - mtx.ColHeader.RowSpan;
args.OpsRows.Add(InsertNewRow(mtx, curIndex));
}
else
{
curIndex = pTitle.Col + pTitle.ColSpan - mtx.RowHeader.Col - mtx.RowHeader.ColSpan;
foreach (RptMtxRow row in mtx.Rows)
{
args.OpsCells.Add(row, InsertNewCell(mtx, row, curIndex).ToList());
}
}
args.CurIndex = curIndex;
}
pTitle.SubTitles.Add(title);
}
args.SubTitle = title;
}
else
{
mtx = title.Level.Matrix;
if (parent is RptMtxLevel)
{
args.BackMtxRow();
(parent as RptMtxLevel).SubTitles.Add(title);
}
else
{
(parent as RptMtxSubtitle).SubTitles.Add(title);
}
}
mtx.Update(true);
return(title);
}
/// <summary>
/// 删除对应数据
/// </summary>
/// <param name="p_args"></param>
/// <param name="p_headerType"></param>
/// <param name="p_mat"></param>
/// <param name="p_title"></param>
void DelRows(SubTitleCmdArgs p_args, RptMtxHeaderType p_headerType, RptMatrix p_mat, RptMtxSubtitle p_title)
{
if ((p_title.Parent is RptMtxLevel && (p_title.Parent as RptMtxLevel).SubTitles.Count > 1) ||
(p_title.Parent is RptMtxSubtitle && (p_title.Parent as RptMtxSubtitle).SubTitles.Count > 1))
{
if (p_headerType == RptMtxHeaderType.Row)
{
int index = -1;
List <RptMtxRow> opsRows = p_title.GetRptRows(out index);
if (opsRows != null)
{
p_args.OpsRows = opsRows;
p_args.CurIndex = index;
p_mat.Rows.RemoveRange(index, p_title.RowSpan);
}
}
else
{
int index = -1;
Dictionary <RptMtxRow, List <RptText> > opsCells = p_title.GetRptCells(out index);
if (opsCells != null)
{
foreach (RptMtxRow row in opsCells.Keys)
{
row.Cells.RemoveRange(index, p_title.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);
}
}
