Table chart builder - Revision history

Wikicatglobe at 02:21, 18 October 2013

2013-10-18T02:21:06Z

← Older revision		Revision as of 02:21, 18 October 2013
Line 1:		Line 1:
	<accesscontrol>~~Administrators,,Cem,,Maysunshine~~</accesscontrol>		<accesscontrol>Main:MyGroup</accesscontrol>
	[[Category:Miscellaneous]]		[[Category:Miscellaneous]]
	[[New Report Design - 2009]] => [[Diagram generation process]] => [[Table chart builder]]		[[New Report Design - 2009]] => [[Diagram generation process]] => [[Table chart builder]]

Cg_pham at 11:34, 24 October 2011

2011-10-24T11:34:43Z

← Older revision		Revision as of 11:34, 24 October 2011
Line 1:		Line 1:
	<accesscontrol>Administrators,,Cem,,Maysunshine</accesscontrol>		<accesscontrol>Administrators,,Cem,,Maysunshine</accesscontrol>
	[[Category:~~Guidelines~~]]		[[Category:Miscellaneous]]
	[[New Report Design - 2009]] => [[Diagram generation process]] => [[Table chart builder]]		[[New Report Design - 2009]] => [[Diagram generation process]] => [[Table chart builder]]

Cg_pham at 10:26, 4 October 2011

2011-10-04T10:26:43Z

← Older revision		Revision as of 10:26, 4 October 2011
Line 1:		Line 1:
			<accesscontrol>Administrators,,Cem,,Maysunshine</accesscontrol>
			[[Category:Guidelines]]
	[[New Report Design - 2009]] => [[Diagram generation process]] => [[Table chart builder]]		[[New Report Design - 2009]] => [[Diagram generation process]] => [[Table chart builder]]

Catglobe at 08:57, 4 August 2009

2009-08-04T08:57:27Z

← Older revision		Revision as of 08:57, 4 August 2009
Line 137:		Line 137:

	Basically, cell adapter contains a REAL cell and common properties of ''ChartTableCell'' would have same properties in the REAL cell. And the implementation is rather simple, passing value to the REAL cell.		Basically, cell adapter contains a REAL cell and common properties of ''ChartTableCell'' would have same properties in the REAL cell. And the implementation is rather simple, passing value to the REAL cell.

			== Copy data between 2 ''ChartTable'' ==

			=== Why do we need to copy data ? ===
			The root cause is the REAL table that is wrapped inside a ''ChartTable'''s adapter. The only problem is that, with some framework like ''Aspose.Slides'' we could not instantiate a instance of table, but instead table must be created by calling parent container's ''CreateTable'' method.

			If we can create any table using its constructor then this constructor
			<source lang="csharp">
			internal class HtmlChartTableCell : ChartTableCell
			{
			public HtmlChartTableCell(HtmlTableCell innerCell);
			}
			</source>
			is not needed anymore, because we can simply create an instance of REAL table and populate data into it. However, that is not always the case, and we need to pass the REAL table over the constructor of adapter for building up.

			So, the steps of building ''ChartTable'' can be considered as:
			# Build data into a generic ''ChartTable''
			# Copy data from ''ChartTable'' into required adapter which is also a ''ChartTable''

			In term of performance, this 2 phases process is not good but it has to be like that.

			=== Implementation ===
			<source lang="csharp">
			public T CopyTo<T>(T targetTable, IDictionary<StyleType, StyleBase> inlineStyles)
			{
			ChartTable targetChartTable;

			if (targetTable is HtmlTable)
			targetChartTable = new HtmlChartTable(targetTable as HtmlTable, RowCount, ColumnCount);

			else if (targetTable is Aspose.Pdf.Table)
			targetChartTable = new PdfChartTable(targetTable as Aspose.Pdf.Table, RowCount, ColumnCount);

			else if (targetTable is Aspose.Slides.Table)
			targetChartTable = new PptChartTable(targetTable as Aspose.Slides.Table, RowCount, ColumnCount);

			else
			throw new NotSupportedException(targetTable.GetType() + " is not supported for creating a ChartTable.");

			// Copy data for all cells
			ForEachCell(cell => targetChartTable[cell.RowIndex, cell.ColumnIndex].CopyData(cell));

			// Apply style
			targetChartTable.ApplyStyle(Style);

			// Apply inline styles
			if (inlineStyles != null && inlineStyles.Count > 0)
			targetChartTable.ApplyStyle(inlineStyles);

			return (T)targetChartTable.InnerTable;
			}
			</source>

			* Inputs:
			** A REAL table instance which must be either of types: ''System.Web.UI.Controls.HtmlTable'', ''Aspose.Pdf.Table'' or ''Aspose.Slides.Table''
			** Inline stylesheet that need to be applied
			* Output
			** The given REAL table filling with data and stylesheet settings
			* Processing:
			** First of all, create an adapter for the REAL table base on its type
			** For each cell, copy data from ''ChartTable'' to adapter. Copy data between cells is as simple as copying common properties
			** Implement post processing if required
			** Apply external stylesheet
			** Apply inline stylesheet if one is given

	== Document revisions ==		== Document revisions ==

Catglobe: Create first version

2009-08-04T08:41:17Z

Create first version

New page

[[New Report Design - 2009]] => [[Diagram generation process]] => [[Table chart builder]]

== Introduction ==
Nevron chart has the simplicity in term of format, because after all processing it just returns an image which is supported through all formats (html, pdf, ppt, excel). However, this is not the same for table. Each library that we are using provide different API for handling tables. Thus, we need different approach.

Luckily, despite of differences in API of libraries, they still share common processing of a table. So, I decided to make common table interface and adapters to different API. Doing like this allow me to focus on the common table interface only when dealing with CatGlobe business like populating table's data, apply style sheet. And later on, when come to a specific format, I can now only focus on table processing of the correspondence library.

== Class Diagram ==
[[Image: Diagram_-_Table_adaptors_1.gif]]

* ''ChartTable'' and ''ChartTableCell'' are generic table/cell classes that are used inside ''CatGlobe.Report''
* ''xxxChartTable'' and ''xxxChartTableCell'' are adapters for specific implementation of tables and cells. Each adapter contains an instance of concrete table/cell.

Adapters contain similar processing, so to demonstrate the implementation, only ''HtmlChartTable'' is described in this document

== ''ChartTable'' ==

=== ''ChartTable'' ===

==== Common properties ====
This class contains the most common behaviors of a table like
* ''RowCount'', ''CellCount''
* Rows and cells can be accessed using index as: ''this[rowIndex]'' or ''this[rowIndex, columnIndex]''

==== LINQ methods ====
This class also support LINQ methods for looping through the table:
<source lang="csharp">
public void ForEachRow(Action<int, ChartTableCell[]> action);
public void ForEachCell(Action<ChartTableCell> action);
</source>

==== Copy methods ====
There are also method co copy data from ''ChartTable'' to another ''ChartTable'', this feature is the core functionality of ''ChartTable'' and will be explained later.

==== Style methods ====
There are 2 methods correspond to 2 kinds of stylesheet (external and inline):
<source lang="csharp">
public void ApplyStyle(IDictionary<StyleType, StyleBase> inlineStyles);

public void ApplyStyle(TableChartStyle externalStyle)
</source>

=== ''ChartTableCell'' ===
Besides common table cell properties (''RowIndex'', ''ColumnIndex'', ''ColumnSpan'', ''RowSpan'', ''Merged'', ''Value'') it also contains some CatGlobe specific information:
* Cell types: a list of types that this cell belong to, possible values are column header, row header, even row value, odd row value etc. See [[Tabulation Script for setting inline style to Table Chart]] for more explanation
* Copy method to copy data between 2 ''ChatTableCell'' => will be explained later
* Apply style method for apply external and inline stylesheet:
<source lang="csharp">
public void ApplyStyle(TableDiagramStyle inlineStyle)

public void ApplyStyle(TableChartStyle externalStyle)
</source>

== ''HtmlChartTable'' ==

=== ''HtmlChartTable'' ===
<source lang="csharp">
public sealed class HtmlChartTable : ChartTable
{
private readonly HtmlTable _table;

public override object InnerTable
{
get { return _table; }
}

protected override ChartTableCell CreateNewCell(int rowIndex, int columnIndex)
{
var realCell = new HtmlTableCell {InnerHtml = " "};
_table.Rows[rowIndex].Cells.Add(realCell);

return new HtmlChartTableCell(realCell) {RowIndex = rowIndex, ColumnIndex = columnIndex};
}

protected override void OnRowAdded()
{
_table.Rows.Add((new HtmlTableRow()));
}
}
</source>

* The real table that contain data is ''HtmlTable'' whose instance is ''_table'' variable
* The adapter responds to events like new row added, new cell added by inserting into the REAL table

=== ''HtmlTableChartCell'' ===
<source lang="csharp">
internal class HtmlChartTableCell : ChartTableCell
{
private readonly HtmlTableCell _cell;

public override object InnerCell
{
get { return _cell; }
}

public override int ColumnSpan
{
get { return base.ColumnSpan; }
set
{
base.ColumnSpan = value;
_cell.ColSpan = value;
}
}

public override int RowSpan
{
get { return base.RowSpan; }
set
{
base.RowSpan = value;
_cell.RowSpan = value;
}
}

public override bool Merged
{
get { return base.Merged; }
protected set
{
base.Merged = value;
_cell.Visible = !value;
}
}

public override string Value
{
get { return base.Value; }
set
{
base.Value = value;
_cell.InnerText = HttpUtility.HtmlEncode(value);
}
}
}
</source>

Basically, cell adapter contains a REAL cell and common properties of ''ChartTableCell'' would have same properties in the REAL cell. And the implementation is rather simple, passing value to the REAL cell.

== Document revisions ==
{|
|-
| '''Version No.'''
| '''Date'''
| '''Changed By'''
| '''Description'''
| '''Svn revision'''
|-
| 0.1
| 04.08.2009
| Nguyen Trung Chinh
| Create first version
| 54885
|}