private void AddTotalItems(MatrixHeaderItem rootItem, int descriptorIndex, bool isTemplate) { if (descriptorIndex >= Count) { return; } foreach (MatrixHeaderItem item in rootItem.Items) { AddTotalItems(item, descriptorIndex + 1, isTemplate); } if (this[descriptorIndex].Totals && (isTemplate || !this[descriptorIndex].SuppressTotals || rootItem.Items.Count > 1)) { MatrixHeaderItem totalItem = new MatrixHeaderItem(rootItem); totalItem.IsTotal = true; totalItem.Value = rootItem.Value; totalItem.DataRowNo = rootItem.DataRowNo; totalItem.TemplateColumn = this[descriptorIndex].TemplateTotalColumn; totalItem.TemplateRow = this[descriptorIndex].TemplateTotalRow; totalItem.TemplateCell = this[descriptorIndex].TemplateTotalCell; totalItem.Index = FNextIndex; FNextIndex++; if (this[descriptorIndex].TotalsFirst && !isTemplate) { rootItem.Items.Insert(0, totalItem); } else { rootItem.Items.Add(totalItem); } } }
/// <summary> /// Adds a value in the matrix. /// </summary> /// <param name="columnValues">Array of column values.</param> /// <param name="rowValues">Array of row values.</param> /// <param name="cellValues">Array of data values.</param> /// <param name="dataRowNo">Datasource row index.</param> /// <remarks> /// See the <see cref="AddValue(object[],object[],object[])"/> method for more details. /// </remarks> public void AddValue(object[] columnValues, object[] rowValues, object[] cellValues, int dataRowNo) { MatrixHeaderItem column = Columns.Find(columnValues, true, dataRowNo); MatrixHeaderItem row = Rows.Find(rowValues, true, dataRowNo); Cells.AddValue(column.Index, row.Index, cellValues); }
/// <summary> /// Removes a header item with the address specified. /// </summary> /// <param name="address">The address of a header.</param> public void RemoveItem(object[] address) { MatrixHeaderItem item = Find(address, false, 0); if (item != null) { item.Parent.Items.Remove(item); } }
/// <summary> /// Gets an index of header with the address specified. If there is no such header item, it will be created. /// </summary> /// <param name="address">The address of a header.</param> /// <returns>The index of header.</returns> public int FindOrCreate(object[] address) { MatrixHeaderItem item = Find(address, true, 0); if (item != null) { return(item.Index); } return(-1); }
private object GetCellValue(MatrixHeaderItem columnItem, MatrixHeaderItem rowItem, int cellIndex) { if (columnItem.IsTotal || rowItem.IsTotal) { return(GetAggregatedTotalValue(columnItem, rowItem, cellIndex)); } else { return(GetAggregatedValue(Matrix.Data.GetValues(columnItem.Index, rowItem.Index, cellIndex), cellIndex)); } }
private int[] GetTerminalIndices(MatrixHeaderItem rootItem) { List <MatrixHeaderItem> terminalItems = rootItem.GetTerminalItems(); int[] result = new int[terminalItems.Count]; for (int i = 0; i < result.Length; i++) { result[i] = terminalItems[i].Index; } return(result); }
private void PrintHeaderCell(MatrixHeaderItem item, TableCellData resultCell, bool isEven) { TableCell templateCell = item.TemplateCell; if (templateCell != null) { if (FDesignTime) { if (!item.IsTotal) { templateCell.Text = item.Value.ToString(); } resultCell.RunTimeAssign(templateCell, true); } else { if (Matrix.DataSource != null) { Matrix.DataSource.CurrentRowNo = item.DataRowNo; } templateCell.SetValue(item.Value); if (!item.IsTotal) { templateCell.Text = templateCell.Format.FormatValue(item.Value); } templateCell.SaveState(); templateCell.GetData(); if (String.IsNullOrEmpty(templateCell.Hyperlink.Expression) && (templateCell.Hyperlink.Kind == HyperlinkKind.DetailReport || templateCell.Hyperlink.Kind == HyperlinkKind.DetailPage || templateCell.Hyperlink.Kind == HyperlinkKind.Custom)) { templateCell.Hyperlink.Value = templateCell.Text; } if (isEven) { templateCell.ApplyEvenStyle(); } resultCell.RunTimeAssign(templateCell, true); templateCell.RestoreState(); } } else { templateCell = CreateCell(item.IsTotal ? Res.Get("ComponentsMisc,Matrix,Total") : item.Value.ToString()); resultCell.RunTimeAssign(templateCell, true); } }
internal MatrixHeaderItem Find(object[] address, bool create, int dataRowNo) { // Note that the top header itself does not contain a value. // It is used as a list of first-level headers only. MatrixHeaderItem rootItem = RootItem; for (int i = 0; i < address.Length; i++) { int index = rootItem.Find(address[i], this[i].Sort); if (matrix.SplitRows && address.Length == 1 && index >= 0) { rootItem = rootItem.Items[index]; } else if (!matrix.SplitRows && index >= 0) { rootItem = rootItem.Items[index]; } else if (create) { // create new item if necessary. MatrixHeaderItem newItem = new MatrixHeaderItem(rootItem); newItem.Value = address[i]; newItem.TemplateColumn = this[i].TemplateColumn; newItem.TemplateRow = this[i].TemplateRow; newItem.TemplateCell = this[i].TemplateCell; newItem.DataRowNo = dataRowNo; newItem.PageBreak = this[i].PageBreak; // index is used as a cell address in a matrix if (i == address.Length - 1) { // create index for bottom-level header newItem.Index = nextIndex; nextIndex++; } rootItem.Items.Insert(index >= 0 ? index : ~index, newItem); rootItem = newItem; } else { return(null); } } return(rootItem); }
private object GetAggregatedTotalValue(MatrixHeaderItem column, MatrixHeaderItem row, int cellIndex) { ArrayList list = new ArrayList(); if (column.IsTotal) { column = column.Parent; } if (row.IsTotal) { row = row.Parent; } List <MatrixHeaderItem> columnTerminalItems = column.GetTerminalItems(); List <MatrixHeaderItem> rowTerminalItems = row.GetTerminalItems(); // collect all values in the specified items foreach (MatrixHeaderItem rowItem in rowTerminalItems) { if (rowItem.IsTotal) { continue; } foreach (MatrixHeaderItem columnItem in columnTerminalItems) { if (columnItem.IsTotal) { continue; } ArrayList values = Matrix.Data.GetValues(columnItem.Index, rowItem.Index, cellIndex); if (values != null) { list.AddRange(values); } } } object value = GetAggregatedValue(list, cellIndex); // totals cannot be empty, return null values as 0 return(value == null ? 0 : value); }
public int Find(object value, SortOrder sort) { if (Items.Count == 0) { return(-1); } if (sort == SortOrder.None) { for (int i = 0; i < Items.Count; i++) { IComparable i1 = Items[i].Value as IComparable; int result = 0; if (i1 != null) { result = i1.CompareTo(value); } else if (value != null) { result = -1; } if (result == 0) { return(i); } } return(~Items.Count); } else { MatrixHeaderItem header = new MatrixHeaderItem(null); header.Value = value; return(Items.BinarySearch(header, new HeaderComparer(sort))); } }
public MatrixHeaderItem(MatrixHeaderItem parent) { FParent = parent; FItems = new List <MatrixHeaderItem>(); }
internal MatrixHeader() { FRootItem = new MatrixHeaderItem(null); }
public MatrixHeaderItem(MatrixHeaderItem parent) { this.parent = parent; items = new List <MatrixHeaderItem>(); }
private void PrintRowHeader(MatrixHeaderItem root, int left, int top) { int dataHeight = 1; int width = HeaderWidth; if (Matrix.Data.Cells.Count > 1 && !Matrix.CellsSideBySide) { dataHeight = Matrix.Data.Cells.Count; width--; } int index = 1; foreach (MatrixHeaderItem item in root.Items) { Matrix.RowValues = item.Values; TableCellData resultCell = ResultTable.GetCellData(left, top); int span = item.Span * dataHeight; resultCell.RowSpan = span; if (item.IsTotal) { resultCell.ColSpan = width - left; } PrintHeaderCell(item, resultCell, index % 2 == 0); PrintRowHeader(item, left + resultCell.ColSpan, top); if (item.PageBreak && top > HeaderHeight) { ResultTable.Rows[top].PageBreak = true; } top += span; index++; } // print cell header if (root.Items.Count == 0 && dataHeight > 1) { foreach (MatrixCellDescriptor descr in Matrix.Data.Cells) { TableCell templateCell = null; TableCellData resultCell = ResultTable.GetCellData(left, top); if (root.TemplateRow != null && descr.TemplateRow != null && FCellHeaderDescriptor.TemplateColumn != null && FCellHeaderDescriptor.TemplateRow != null) { templateCell = Matrix[FCellHeaderDescriptor.TemplateColumn.Index, root.TemplateRow.Index + (descr.TemplateRow.Index - FCellHeaderDescriptor.TemplateRow.Index)]; } else { templateCell = CreateCell(ExtractColumnName(descr.Expression)); } templateCell.SaveState(); templateCell.GetData(); resultCell.RunTimeAssign(templateCell, true); templateCell.RestoreState(); top++; } } }
/// <summary> /// Gets the list of indices of terminal items of the header with specified address. /// </summary> /// <param name="address">The address of a header.</param> /// <returns>The list of indices.</returns> public int[] GetTerminalIndices(object[] address) { MatrixHeaderItem rootItem = Find(address, false, 0); return(GetTerminalIndices(rootItem)); }
internal MatrixHeader(MatrixObject matrix) { rootItem = new MatrixHeaderItem(null); this.matrix = matrix; }
private void PrintRowHeader(MatrixHeaderItem root, int left, int top, int level) { int dataHeight = 1; int width = HeaderWidth; if (Matrix.Data.Cells.Count > 1 && !Matrix.CellsSideBySide) { dataHeight = Matrix.Data.Cells.Count; width--; } for (int index = 0; index < root.Items.Count; index++) { MatrixHeaderItem item = root.Items[index]; Matrix.RowValues = item.Values; TableCellData resultCell = ResultTable.GetCellData(left, top); int span = item.Span * dataHeight; if (Matrix.SplitRows) { MatrixHeaderItem duplicate = new MatrixHeaderItem(root); duplicate.IsSplitted = true; duplicate.Value = item.Value; duplicate.TemplateRow = item.TemplateRow; duplicate.TemplateCell = item.TemplateCell; duplicate.TemplateColumn = item.TemplateColumn; for (int i = 1; i < span; i++) { root.Items.Insert(index + 1, duplicate); } span = 1; } resultCell.RowSpan = span; if (item.IsTotal) { resultCell.ColSpan = width - left; // correct FEvenStyleIndices for (int i = level + 1; i < evenStyleIndices.Length; i++) { evenStyleIndices[i]++; } } PrintHeaderCell(item, resultCell, evenStyleIndices[level] % 2 != 0); PrintRowHeader(item, left + resultCell.ColSpan, top, level + 1); if (item.PageBreak && top > HeaderHeight) { ResultTable.Rows[top].PageBreak = true; } top += span; evenStyleIndices[level]++; } // print cell header if (root.Items.Count == 0 && dataHeight > 1) { foreach (MatrixCellDescriptor descr in Matrix.Data.Cells) { TableCell templateCell = null; TableCellData resultCell = ResultTable.GetCellData(left, top); if (root.TemplateRow != null && descr.TemplateRow != null && cellHeaderDescriptor.TemplateColumn != null && cellHeaderDescriptor.TemplateRow != null) { templateCell = Matrix[cellHeaderDescriptor.TemplateColumn.Index, root.TemplateRow.Index + (descr.TemplateRow.Index - cellHeaderDescriptor.TemplateRow.Index)]; } else { templateCell = CreateCell(ExtractColumnName(descr.Expression)); } templateCell.SaveState(); templateCell.GetData(); resultCell.RunTimeAssign(templateCell, true); templateCell.RestoreState(); top++; } } }
private void PrintColumnHeader(MatrixHeaderItem root, int left, int top, int level) { int dataWidth = 1; int height = HeaderHeight; if (Matrix.Data.Cells.Count > 1 && Matrix.CellsSideBySide) { dataWidth = Matrix.Data.Cells.Count; height--; } foreach (MatrixHeaderItem item in root.Items) { Matrix.ColumnValues = item.Values; TableCellData resultCell = ResultTable.GetCellData(left, top); int span = item.Span * dataWidth; resultCell.ColSpan = span; if (item.IsTotal) { resultCell.RowSpan = height - top; // correct FEvenStyleIndices for (int i = level + 1; i < evenStyleIndices.Length; i++) { evenStyleIndices[i]++; } } PrintHeaderCell(item, resultCell, evenStyleIndices[level] % 2 != 0); PrintColumnHeader(item, left, top + resultCell.RowSpan, level + 1); if (item.PageBreak && left > HeaderWidth) { ResultTable.Columns[left].PageBreak = true; } left += span; evenStyleIndices[level]++; } // print cell header if (root.Items.Count == 0 && dataWidth > 1) { foreach (MatrixCellDescriptor descr in Matrix.Data.Cells) { TableCell templateCell = null; TableCellData resultCell = ResultTable.GetCellData(left, top); if (root.TemplateColumn != null && descr.TemplateColumn != null && cellHeaderDescriptor.TemplateColumn != null && cellHeaderDescriptor.TemplateRow != null) { templateCell = Matrix[ root.TemplateColumn.Index + (descr.TemplateColumn.Index - cellHeaderDescriptor.TemplateColumn.Index), cellHeaderDescriptor.TemplateRow.Index]; } else { templateCell = CreateCell(ExtractColumnName(descr.Expression)); } templateCell.SaveState(); templateCell.GetData(); resultCell.RunTimeAssign(templateCell, true); templateCell.RestoreState(); left++; } } }
public MatrixHeaderItem(MatrixHeaderItem parent) { this.parent = parent; items = new List <MatrixHeaderItem>(); isSplitted = false; }