Exemple #1
0
        protected double GetDataValue(Report rpt, int row, int col)
        {
            MatrixCellEntry mce = _DataDefn[row, col];

            if (mce == null)
            {
                return(0);                                                      // Not sure what this really means TODO:
            }
            if (mce.Value != double.MinValue)
            {
                return(mce.Value);
            }

            // Calculate this value; usually a fairly expensive operation
            //   due to the common use of aggregate values.  We need to
            //   go thru the data more than once if we have to auto scale.
            Row lrow;

            this._ChartDefn.ChartMatrix.SetMyData(rpt, mce.Data);                       // Must set this for evaluation
            if (mce.Data.Data.Count > 0)
            {
                lrow = mce.Data.Data[0];
            }
            else
            {
                lrow = null;
            }
            ChartExpression ce = (ChartExpression)(mce.DisplayItem);

            double v = ce.Value.EvaluateDouble(rpt, lrow);

            mce.Value = v;                                              // cache so we don't need to calculate again
            return(v);
        }
Exemple #2
0
        protected object GetCategoryValue(Report rpt, int row, out TypeCode tc)
        {
            MatrixCellEntry mce = _DataDefn[row, 0];

            if (mce == null)
            {
                tc = TypeCode.String;
                return("");                                                     // Not sure what this really means TODO:
            }

            Row lrow;

            this._ChartDefn.ChartMatrix.SetMyData(rpt, mce.Data);                       // Must set this for evaluation
            if (mce.Data.Data.Count > 0)
            {
                lrow = mce.Data.Data[0];
            }
            else
            {
                lrow = null;
            }
            ChartExpression ce = (ChartExpression)(mce.DisplayItem);

            object v = ce.Value.Evaluate(rpt, lrow);

            tc = ce.Value.GetTypeCode();
            return(v);
        }
		protected Row _row;					// row chart created on

		internal ChartBase(Report r, Row row, Chart c, MatrixCellEntry[,] m)
		{
			_ChartDefn = c;
			_row = row;
			_DataDefn = m;
			_bm = null;
			int width = _ChartDefn.WidthCalc(r, null);
			int height = RSize.PixelsFromPoints(_ChartDefn.HeightOrOwnerHeight);
			Layout = new ChartLayout(width, height);
			_SeriesBrush = null;
			_SeriesMarker = null;
		}
Exemple #4
0
 internal ChartBase(Report r, Row row, Chart c, MatrixCellEntry[,] m, Expression showTooltips, Expression showTooltipsX, Expression _ToolTipYFormat, Expression _ToolTipXFormat)
 {
     this._ChartDefn = c;
       this._row = row;
       this._DataDefn = m;
       this._bm = null;
       int width = this._ChartDefn.WidthCalc(r, null);
       int height = RSize.PixelsFromPoints(this._ChartDefn.HeightOrOwnerHeight);
       this.Layout = new ChartLayout(width, height);
       this._SeriesBrush = null;
       this._SeriesMarker = null;
       this._showToolTips = showTooltips.EvaluateBoolean(r, row);
       this._showToolTipsX = showTooltipsX.EvaluateBoolean(r, row);
       this._tooltipYFormat = _ToolTipYFormat.EvaluateString(r, row);
       this._tooltipXFormat = _ToolTipXFormat.EvaluateString(r, row);
 }
Exemple #5
0
        Rows GetNestedData(Report rpt, Row row)
        {
            if (row == null)
            {
                return(null);
            }

            ReportLink rl = this.Parent;

            while (rl != null)
            {
                if (rl is TableGroup || rl is List || rl is MatrixCell)
                {
                    break;
                }
                rl = rl.Parent;
            }
            if (rl == null)
            {
                return(null);                                   // should have been caught as an error
            }
            Grouping g = null;

            if (rl is TableGroup)
            {
                TableGroup tg = rl as TableGroup;
                g = tg.Grouping;
            }
            else if (rl is List)
            {
                List l = rl as List;
                g = l.Grouping;
            }
            else if (rl is MatrixCell)
            {
                MatrixCellEntry mce = this.GetMC(rpt);
                return(new Rows(rpt, mce.Data));
            }
            if (g == null)
            {
                return(null);
            }

            GroupEntry ge = row.R.CurrentGroups[g.GetIndex(rpt)];

            return(new Rows(rpt, row.R, ge.StartRow, ge.EndRow, null));
        }
Exemple #6
0
        protected string GetSeriesValue(Report rpt, int iCol)
        {
            MatrixCellEntry mce = _DataDefn[0, iCol];
            Row             lrow;

            if (mce.Data.Data.Count > 0)
            {
                lrow = mce.Data.Data[0];
            }
            else
            {
                lrow = null;
            }
            ChartExpression ce = (ChartExpression)(mce.DisplayItem);

            string v = ce.Value.EvaluateString(rpt, lrow);

            return(v);
        }
Exemple #7
0
		void RunColumnStaticHeaders(Report rpt, WorkClass wc, MatrixCellEntry[,] matrix, Rows _Data, int iRow, int iColumn, int level)
		{
			ColumnGrouping cg=null;
			for (int i=level+1; i < _ColumnGroupings.Items.Count; i++)
			{
				iRow++;				// the row will below the headers
				cg = (ColumnGrouping) (_ColumnGroupings.Items[i]);
				if (cg.StaticColumns != null)
					break;
			} 
			if (cg == null || cg.StaticColumns == null)
				return;

			foreach (StaticColumn sc in cg.StaticColumns.Items)
			{
				ReportItem ri = sc.ReportItems.Items[0];
				matrix[iRow, iColumn] = new MatrixCellEntry(_Data, ri);
				matrix[iRow, iColumn].Height = cg.Height.Points;
				matrix[iRow, iColumn].Width = RunGetColumnWidth(matrix[iRow, iColumn]);

				iColumn++;
			}
			return;
		}
Exemple #8
0
		float RunGetColumnWidth(MatrixCellEntry mce)
		{
			if (this.MatrixColumns == null)
				return 0;		// We use this routine for chart(s) and they don't build the matrix columns

			MatrixColumn mcol;	// work variable to hold a MatrixColumn

			mcol = this.MatrixColumns.Items[0] as MatrixColumn;
			float defWidth = mcol.Width.Points;

			if (CountMatrixColumns == 1)	// if only one column width is easy
				return defWidth;

			// find out which static column it is.
			ColumnGrouping cg=null;
			MatrixCells mcells=null;
			ReportItem ri = mce.DisplayItem;
			for (ReportLink rl= ri.Parent; rl != null; rl = rl.Parent)
			{
				if (rl is ColumnGrouping)
				{
					cg = rl as ColumnGrouping;
					break;
				}
				if (rl is MatrixCells)
				{
					mcells = rl as MatrixCells;
					break;
				}
				if (rl is Matrix)
					break;
			}

			int offset = 0;

			// If the item is one of the MatrixCell; then use same offset
			if (mcells != null)
			{
				foreach (MatrixCell mcell in mcells.Items)
				{
					ReportItem ric = mcell.ReportItems.Items[0] as ReportItem;
					if (ric == ri)
					{
						mcol = this.MatrixColumns.Items[offset] as MatrixColumn;
						return mcol.Width.Points;
					}
					offset++;
				}
				return defWidth;
			}

			if (cg == null || cg.StaticColumns == null)
				return defWidth;

			// Otherwise find the same relative Matrix Column from the static columns
			mcol=null;
			foreach (StaticColumn sc in cg.StaticColumns.Items)
			{
				ReportItem cri = sc.ReportItems.Items[0] as ReportItem;
				if (ri == cri)
				{
					mcol = this.MatrixColumns.Items[offset] as MatrixColumn;
					break;
				}
				offset++;
			}

			return mcol == null? defWidth: mcol.Width.Points;
		}
			internal Page CurrentPage;		// the page this reportitem was last put on; 
			internal WorkClass()
			{
				m_Mc=null;
				m_BottomPosition=float.NaN;
				CurrentPage=null;
			}
Exemple #10
0
        void DrawDataPoint(Report rpt, Graphics g, Point p, System.Drawing.Rectangle rect, int row, int col)
        {
            MatrixCellEntry mce = _DataDefn[row, col];

            if (mce == null)
            {
                return;                                                 // Not sure what this really means TODO:
            }
            ChartExpression ce = (ChartExpression)(mce.DisplayItem);
            DataPoint       dp = ce.DP;

            if (dp.DataLabel == null || !dp.DataLabel.Visible)
            {
                return;
            }

            // Calculate the DataPoint value; usually a fairly expensive operation
            //   due to the common use of aggregate values.
            Row lrow;

            this._ChartDefn.ChartMatrix.SetMyData(rpt, mce.Data);                       // Must set this for evaluation
            if (mce.Data.Data.Count > 0)
            {
                lrow = mce.Data.Data[0];
            }
            else
            {
                lrow = null;
            }

            object   v = null;
            TypeCode tc;

            if (dp.DataLabel.Value == null)
            {                           // No DataLabel value specified so we use the actual value
                v  = ce.Value.EvaluateDouble(rpt, lrow);
                tc = TypeCode.Double;
            }
            else
            {                           // Evaluate the DataLable value for the display
                v  = dp.DataLabel.Value.Evaluate(rpt, lrow);
                tc = dp.DataLabel.Value.GetTypeCode();
            }

            if (dp.DataLabel.Style == null)
            {
                if (rect == System.Drawing.Rectangle.Empty)
                {
                    Size size = Style.MeasureStringDefaults(rpt, g, v, tc, lrow, int.MaxValue);
                    rect = new System.Drawing.Rectangle(p, size);
                }
                Style.DrawStringDefaults(g, v, rect);
            }
            else
            {
                if (rect == System.Drawing.Rectangle.Empty)
                {
                    Size size = dp.DataLabel.Style.MeasureString(rpt, g, v, tc, lrow, int.MaxValue);
                    rect = new System.Drawing.Rectangle(p, size);
                }
                dp.DataLabel.Style.DrawString(rpt, g, v, tc, lrow, rect);
            }

            return;
        }
Exemple #11
0
		void RunRowHeaders(Report rpt, WorkClass wc, MatrixEntry m, MatrixCellEntry[,] matrix, Rows _Data, ref int iRow, int iColumn, int level)
		{
			foreach (MatrixEntry ame in m.GetSortedData(rpt))
			{
				matrix[iRow, iColumn] = RunGetRowHeader(rpt, ame, _Data);
				matrix[iRow, iColumn].Height = RunRowHeight(iRow);
				matrix[iRow, iColumn].Width = ame.RowGroup.Width == null? 0: ame.RowGroup.Width.Points;
				if (ame.GetSortedData(rpt) != null)
				{
					RunRowHeaders(rpt, wc, ame, matrix, _Data, ref iRow, iColumn+1, level+1);
				}
				else
					iRow++;
			}

			RowGrouping rg = (RowGrouping) (_RowGroupings.Items[level]);
			// do we need to subtotal this
			if (rg.DynamicRows != null &&
				rg.DynamicRows.Subtotal != null)
			{					   // TODO need to loop thru static??
				ReportItem ri = rg.DynamicRows.Subtotal.ReportItems.Items[0];	
				matrix[iRow, iColumn] = new MatrixCellEntry(_Data, ri);
				matrix[iRow, iColumn].Width = rg.Width.Points;
				matrix[iRow, iColumn].Height = RunRowHeight(iRow);
				RunRowStaticHeaders(rpt, wc, matrix, _Data, iRow, level);
				iRow += Math.Max(1,this.RowGroupings.StaticCount);
			}
		}
Exemple #12
0
 internal Page CurrentPage;                  // the page this reportitem was last put on;
 internal WorkClass()
 {
     MC             = null;
     BottomPosition = float.NaN;
     CurrentPage    = null;
 }
Exemple #13
0
		float HeightOfRow(Pages pgs, MatrixCellEntry[,] matrix, int iRow)
		{
			Report rpt = pgs.Report;
			WorkClass wc = GetValue(rpt);

			int maxColumns = matrix.GetLength(1);
			float height=0;
			bool bResetAllHeights=false;

			// Handle the corner;  it might span rows & columns
			bool bCorner = false;
			float cornerHeight=0;
			if (iRow == 0 && matrix[0, 0] != null &&
				(this.ColumnGroupings.Items.Count > 1 ||
				this.RowGroupings.Items.Count > 1))
			{
				bCorner = true;				
			}

			for (int iCol=0; iCol < maxColumns; iCol++)
			{
				MatrixCellEntry mce = matrix[iRow, iCol];
				if (mce == null)
					continue;
				if (mce.DisplayItem is Textbox)
				{
					Textbox tb = mce.DisplayItem as Textbox;
					if (tb.CanGrow)
					{
						wc.Data = mce.Data;		// Must set this for evaluation

						Row lrow = wc.Data.Data.Count > 0? wc.Data.Data[0]:null;
						mce.DisplayItem.SetMC(rpt, mce);	// set for use by the display item
						SetGroupingValues(rpt, mce);

						float tbh = tb.RunTextCalcHeight(rpt, pgs.G, lrow);
						if (height < tbh)
						{
							if (bCorner && iCol == 0)	
							{
								cornerHeight = tbh;
							}
							else
							{
								bResetAllHeights = true;
								height = tbh;
							}
						}
					}
				}

				if (bCorner && iCol == 0)
					continue;
				if (height < mce.Height)
					height = mce.Height;
			}

			if (bResetAllHeights)	// If any text forces the row to grow; all heights must be fixed
			{
				for (int iCol=0; iCol < maxColumns; iCol++)
				{
					if (bCorner && iCol == 0)
						continue;
					MatrixCellEntry mce = matrix[iRow, iCol];
					if (mce != null)
						mce.Height = height;
				}
			}

			// Even with expansion room; we might need more space for the corner
			if (bCorner && cornerHeight > matrix[0,0].Height)
			{	// add the additional space needed to the first row's height
				float newRow0Height;
				if (ColumnGroupings.Items.Count == 1)
					newRow0Height = cornerHeight;
				else if (matrix[0,1] != null)
					newRow0Height = matrix[0,1].Height + (cornerHeight - matrix[0,0].Height);
				else
					newRow0Height = (cornerHeight - matrix[0,0].Height);
				height = newRow0Height;
				matrix[0,0].Height = cornerHeight;
				for (int iCol=1; iCol < maxColumns; iCol++)
				{
					MatrixCellEntry mce = matrix[0, iCol];
					if (mce != null)
						mce.Height = newRow0Height;
				}
			}

			return height;
		}
Exemple #14
0
		void RunDataColumn(Report rpt, WorkClass wc, MatrixEntry rm, MatrixEntry cm, MatrixCellEntry[,] matrix, Rows _Data, int iRow, ref int iColumn, int level, int rowcell)
		{
			BitArray andData;
			MatrixRow mr = this.MatrixRows.Items[rowcell] as MatrixRow;
			float height = mr.Height == null? 0: mr.Height.Points;

			foreach (MatrixEntry ame in cm.GetSortedData(rpt))
			{
				if (ame.ColumnGroup != LastCg)
				{
					RunDataColumn(rpt, wc, rm, ame, matrix, _Data, iRow, ref iColumn, level+1, rowcell);
					continue;
				}
				andData = new BitArray(ame.Rows);	// copy the data
				andData.And(rm.Rows);				//  because And is destructive
				matrix[iRow, iColumn] = RunGetMatrixCell(rpt, ame, iRow, _Data, andData, 
						Math.Max(rm.FirstRow, ame.FirstRow),
						Math.Min(rm.LastRow, ame.LastRow));
				matrix[iRow, iColumn].Height = height;
				matrix[iRow, iColumn].Width = RunGetColumnWidth(matrix[iRow, iColumn]);
				matrix[iRow, iColumn].ColumnME = ame;
				matrix[iRow, iColumn].RowME = rm;
				
				iColumn++;
			}
			// do we need to subtotal this?
			ColumnGrouping cg = (ColumnGrouping) (_ColumnGroupings.Items[level]);
			if (cg.DynamicColumns != null &&
				cg.DynamicColumns.Subtotal != null)
			{
				andData = new BitArray(cm.Rows);	// copy the data
				andData.And(rm.Rows);				//  because And is destructive
				for (int i=0; i < this.CountMatrixCells; i++)
				{
					matrix[iRow, iColumn] = RunGetMatrixCell(rpt, cm, rowcell, i, _Data, andData, 
						Math.Max(rm.FirstRow, cm.FirstRow),
						Math.Min(rm.LastRow, cm.LastRow));
					matrix[iRow, iColumn].Height = height;
					matrix[iRow, iColumn].Width = RunGetColumnWidth(matrix[iRow, iColumn]);
					matrix[iRow, iColumn].ColumnME = cm;
					matrix[iRow, iColumn].RowME = rm;
					iColumn++;
				}
			}
		}
Exemple #15
0
		MatrixCellEntry RunGetMatrixCell(Report rpt, MatrixEntry me, int rcell, int ccell, Rows _Data, BitArray rows, int firstRow, int lastRow)
		{
			MatrixRow mr = this._MatrixRows.Items[rcell];
			MatrixCell mc = mr.MatrixCells.Items[ccell];
			ReportItem ri = mc.ReportItems.Items[0]; 
			Rows subData = new Rows(rpt, _Data, firstRow, lastRow, rows);
			MatrixCellEntry mce = new MatrixCellEntry(subData, ri);

			return mce;
		}
Exemple #16
0
		private void SetGroupingValues(Report rpt, MatrixCellEntry mce)
		{
			WorkClass wc = GetValue(rpt);
			Rows data = wc.FullData;

			SetGroupingValuesInit(rpt, data, mce.RowME, mce.ColumnME);
			SetGroupingValuesMe(rpt, data, mce.RowME);
			SetGroupingValuesMe(rpt, data, mce.ColumnME);
		
			return;
		}
Exemple #17
0
		MatrixCellEntry RunGetRowHeader(Report rpt, MatrixEntry me, Rows _Data)
		{
			ReportItem ri;
			if (me.RowGroup.StaticRows != null)
			{	// Handle static row reference
				StaticRow sr = me.RowGroup.StaticRows.Items[me.StaticRow] as StaticRow;
				ri = sr.ReportItems.Items[0];	
			}
			else	// handle dynamic row reference
				ri = me.RowGroup.DynamicRows.ReportItems.Items[0];	
			Rows subData = new Rows(rpt, _Data, me.FirstRow, me.LastRow, me.Rows);
			MatrixCellEntry mce = new MatrixCellEntry(subData, ri);

			return mce;

		}
Exemple #18
0
		void RunRowStaticHeaders(Report rpt, WorkClass wc, MatrixCellEntry[,] matrix, Rows _Data, int iRow, int level)
		{
			RowGrouping rg=null;
			int i;
			int iColumn=0;
			for (i=level+1; i < _RowGroupings.Items.Count; i++)
			{
				iColumn++;				// Column for the row static headers
				rg = (RowGrouping) (_RowGroupings.Items[i]);
				if (rg.StaticRows != null)
					break;
			} 
			if (rg == null || rg.StaticRows == null)
				return;

			i=0;
			foreach (StaticRow sr in rg.StaticRows.Items)
			{
				ReportItem ri = sr.ReportItems.Items[0];
				matrix[iRow, iColumn] = new MatrixCellEntry(_Data, ri);
				matrix[iRow, iColumn].Width = rg.Width.Points;
				MatrixRow mr = this.MatrixRows.Items[i++] as MatrixRow;
				float height = mr.Height == null? 0: mr.Height.Points;
				matrix[iRow, iColumn].Height = height;

				iRow++;
			}
			return;
		}
Exemple #19
0
        internal void SetMC(Report rpt, MatrixCellEntry mce)
        {
            WorkClass wc = GetWC(rpt);

            wc.MC = mce;
        }
Exemple #20
0
		MatrixCellEntry RunGetColumnHeader(Report rpt, MatrixEntry me, Rows _Data)
		{
			ReportItem ri;
			if (me.ColumnGroup.StaticColumns != null)
			{	// Handle static column reference
				StaticColumn sc = me.ColumnGroup.StaticColumns.Items[me.StaticColumn] as StaticColumn;
				ri = sc.ReportItems.Items[0];	
			}
			else
				ri = me.ColumnGroup.DynamicColumns.ReportItems.Items[0];	// dynamic column
			Rows subData = new Rows(rpt, _Data, me.FirstRow, me.LastRow, me.Rows);
			MatrixCellEntry mce = new MatrixCellEntry(subData, ri);

			return mce;
		}
Exemple #21
0
		internal ChartLine(Report r, Row row, Chart c, MatrixCellEntry[,] m) : base(r, row, c, m)
		{
		}
Exemple #22
0
		MatrixCellEntry RunCorner(Rows d)
		{
			if (_Corner == null)
				return null;

			ReportItem ri = _Corner.ReportItems.Items[0];	
			MatrixCellEntry mce = new MatrixCellEntry(d, ri);

			float height=0;
			foreach (ColumnGrouping cg in this.ColumnGroupings.Items)
			{
				height += cg.Height.Points;
			}
			mce.Height = height;

			float width=0;
			foreach (RowGrouping rg in this.RowGroupings.Items)
			{
				width += rg.Width.Points;
			}
			mce.Width = width;	

			mce.ColSpan = RowGroupings.Items.Count;
			return mce;
		}
Exemple #23
0
        internal ChartMap(Report r, Row row, Chart c, MatrixCellEntry[,] m, Expression showTooltips, Expression showTooltipsX, Expression _ToolTipYFormat, Expression _ToolTipXFormat)
            : base(r, row, c, m, showTooltips, showTooltipsX, _ToolTipYFormat, _ToolTipXFormat)
		{
		}
Exemple #24
0
		void RunDataRow(Report rpt, WorkClass wc, MatrixEntry rm, MatrixEntry cm, MatrixCellEntry[,] matrix, Rows _Data, ref int iRow, int iColumn, int level)
		{
			int saveColumn;
			int headerRows = _ColumnGroupings.Items.Count;	// number of column headers we have
			int rgsCount = this.RowGroupings.StaticCount;	// count of static row groups
			foreach (MatrixEntry ame in rm.GetSortedData(rpt))
			{
				if (ame.RowGroup != LastRg)
				{
					RunDataRow(rpt, wc, ame, cm, matrix, _Data, ref iRow, iColumn, level+1);
					continue;
				}
				saveColumn = iColumn;
				int rowcell = rgsCount == 0? 0: (iRow - headerRows) % rgsCount;
				RunDataColumn(rpt, wc, ame, cm, matrix, _Data, iRow, ref saveColumn, 0, rowcell);
				iRow++;
			}
			// do we need to subtotal this?
			RowGrouping rg = (RowGrouping) (_RowGroupings.Items[level]);
			if (rg.DynamicRows != null &&
				rg.DynamicRows.Subtotal != null)
			{
				for (int i=0; i < this.CountMatrixRows; i++)
				{
					saveColumn = iColumn;
					RunDataColumn(rpt, wc, rm, cm, matrix, _Data, iRow, ref saveColumn, 0, i);
					iRow++;
				}
			}
		}
			internal Page CurrentPage;		// the page this reportitem was last put on; 
			internal WorkClass()
			{
				MC=null;
				BottomPosition=float.NaN;
				CurrentPage=null;
			}
Exemple #26
0
        // called first
        public bool MatrixStart(Matrix m, MatrixCellEntry[,] matrix, Row r, int headerRows, int maxRows, int maxCols)
        {
            string bookmark = m.BookmarkValue(this.r, r);
            if (bookmark != null)
                tw.WriteLine("<div id=\"{0}\">", bookmark);		// can't use the table id since we're using for css style

            // output some of the table styles
            string cssName = CssAdd(m.Style, m, r);	// get the style name for this item

            tw.WriteLine("<table id='{0}'>", cssName);
            return true;
        }
Exemple #27
0
 internal Page CurrentPage;                  // the page this reportitem was last put on;
 internal WorkClass()
 {
     m_Mc             = null;
     m_BottomPosition = float.NaN;
     CurrentPage      = null;
 }
Exemple #28
0
        internal float[] ColumnWidths(MatrixCellEntry[,] matrix, int maxColumns)
        {
            float[] widths= new float[maxColumns];

            for (int iColumn = 0; iColumn < maxColumns; iColumn++)
            {
                widths[iColumn] = WidthOfColumn(matrix, iColumn);
            }
            return widths;
        }
Exemple #29
0
        // called first
        public bool MatrixStart(Matrix m, MatrixCellEntry[,] matrix, Row r, int headerRows, int maxRows, int maxCols)
        {
            if (m.DataElementOutput != DataElementOutputEnum.Output)
                return false;
            tw.WriteLine("<" + (m.DataElementName == null? "Matrix": m.DataElementName) + ">");

            return true;
        }
Exemple #30
0
        // called first
        public bool MatrixStart(Matrix m, MatrixCellEntry[,] matrix, Row r, int headerRows, int maxRows, int maxCols)
        {
            _MatrixCellSpan = 0;
            _MatrixCols = maxCols;
            _MatrixRows = maxRows;
            _MatrixHeaderRows = headerRows;
            _MatrixData = matrix;

            float[] widths = m.ColumnWidths(this._MatrixData, maxCols);
            _MatrixColumnWidths = new int[maxCols];
            for (int i = 0; i < maxCols; i++)
                _MatrixColumnWidths[i] = RSize.TwipsFromPoints(widths[i]);

            tw.Write(@"\par{");
            return true;
        }
Exemple #31
0
		float WidthOfColumn(MatrixCellEntry[,] matrix, int iCol)
		{
			int maxRows = matrix.GetLength(0);
			for (int iRow=0; iRow < maxRows; iRow++)
			{
				if (matrix[iRow, iCol] != null && matrix[iRow, iCol].ColSpan == 1)
					return matrix[iRow, iCol].Width;
			}
			return 0;
		}
 // called first
 public bool MatrixStart(Matrix m, MatrixCellEntry[,] matrix, Row r, int headerRows, int maxRows, int maxCols)
 {
     _Excel.AddSheet(m.Name.Nm);
     _ExcelRow = -1;
     // set the widths of the columns
     float[] widths = m.ColumnWidths(matrix, maxCols);
     for (int i = 0; i < maxCols; i++)
     {
         _Excel.SetColumnWidth(i, widths[i]);
     }
     return true;
 }
Exemple #33
0
		void RunPageColumns(Pages pgs, WorkClass wc, MatrixCellEntry[,] matrix, int iRow, int maxColumns)
		{
			Report rpt = pgs.Report;

			float xpos = GetOffsetCalc(pgs.Report) + LeftCalc(rpt);
			for (int iColumn = 0; iColumn < maxColumns; iColumn++)
			{
				MatrixCellEntry mce = matrix[iRow, iColumn];
					
				if (mce == null)
				{	// have a null column but we need to fill column space
					xpos += WidthOfColumn(matrix, iColumn);
					continue;
				}
				wc.Data = mce.Data;		// Must set this for evaluation

				Row lrow = wc.Data.Data.Count > 0? wc.Data.Data[0]:null;
				SetGroupingValues(rpt, mce);
				mce.DisplayItem.SetMC(rpt, mce);	// set for use by the display item
				mce.XPosition = xpos;
				mce.DisplayItem.RunPage(pgs, lrow);
				xpos += mce.Width;
				iColumn += (mce.ColSpan-1);			// skip columns already accounted for
			}
		}
		internal void SetMC(Report rpt, MatrixCellEntry mce)
		{
			WorkClass wc = GetWC(rpt);
			wc.MC = mce;
		}
Exemple #35
0
		// RunBuild is used by both Matrix.Run and Chart.Run to obtain the necessary data
		//   used by their respective rendering interfaces
		internal MatrixCellEntry[,] RunBuild(Report rpt, out int numRows, out int numCols)
		{
			WorkClass wc = GetValue(rpt);
			Rows _Data = wc.Data;

			// loop thru all the data;
			//    form bitmap arrays for each unique data value of each grouping (row and column) value
			int maxColumns = _RowGroupings.Items.Count;	// maximum # of columns in matrix
									// at top we need a row per column grouping
			int maxRows = _ColumnGroupings.Items.Count;	// maximum # of rows in matrix
									// at left we need a column per row grouping

			MatrixEntry mcg = new MatrixEntry(null, "", null, _Data.Data.Count);
			_ColumnGroupings.SetME(rpt, mcg);
			mcg.FirstRow=0;
			mcg.LastRow=_Data.Data.Count-1;
			mcg.Rows = new BitArray(_Data.Data.Count, true);	// all data

			MatrixEntry mrg = new MatrixEntry(null, "", null, _Data.Data.Count);
			_RowGroupings.SetME(rpt, mrg);
			mrg.FirstRow=0;
			mrg.LastRow=_Data.Data.Count-1;
			mrg.Rows = new BitArray(_Data.Data.Count, true);		// all data

			int iRow=0;				// row counter
			foreach (Row r in _Data.Data)
			{
				// Handle the column values
				HandleColumnGrouping(rpt, wc, _Data, r, mcg, 0, iRow, ref maxColumns);

				// Handle the row values
				HandleRowGrouping(rpt, wc, _Data, r, mrg, 0, iRow, ref maxRows);

				iRow++;
			}

			// Determine how many subtotal columns are needed
			maxColumns += RunCountSubtotalColumns(rpt, wc, mcg, 0);

			// Determine how many subtotal rows are needed
			maxRows += RunCountSubtotalRows(rpt, wc, mrg, 0);

			/////
			// Build and populate the 2 dimensional table of MatrixCellEntry
			//    that constitute the matrix
			/////
			MatrixCellEntry[,] matrix = new MatrixCellEntry[maxRows, maxColumns];
	
			// Do the column headings
			int iColumn = _RowGroupings.Items.Count;
			RunColumnHeaders(rpt, wc, mcg, matrix, _Data, 0, ref iColumn, 0);

			// Do the row headings
			iRow = _ColumnGroupings.Items.Count;
			RunRowHeaders(rpt, wc, mrg, matrix, _Data, ref iRow, 0, 0);

			// Do the row/column data
			iRow = _ColumnGroupings.Items.Count;		
			RunDataRow(rpt, wc, mrg, mcg, matrix, _Data, ref iRow, _RowGroupings.Items.Count, 0);

			// Do the corner
			matrix[0, 0] = RunCorner(_Data);

			// now return the matrix data
			numRows = maxRows;
			numCols = maxColumns;
			return matrix;
		}
Exemple #36
0
 // called first
 public bool MatrixStart(Matrix m, MatrixCellEntry[,] matrix, Row r, int headerRows, int maxRows, int maxCols)
 {
     return true;
 }
Exemple #37
0
		void RunColumnHeaders(Report rpt, WorkClass wc, MatrixEntry m, MatrixCellEntry[,] matrix, Rows _Data, int iRow, ref int iColumn, int level)
		{
			foreach (MatrixEntry ame in m.GetSortedData(rpt))
			{
				matrix[iRow, iColumn] = RunGetColumnHeader(rpt, ame, _Data);
				matrix[iRow, iColumn].Width = RunGetColumnWidth(matrix[iRow, iColumn]);
				matrix[iRow, iColumn].Height = ame.ColumnGroup.Height == null? 0: ame.ColumnGroup.Height.Points;
				if (ame.GetSortedData(rpt) != null)
				{
					RunColumnHeaders(rpt, wc, ame, matrix, _Data, iRow+1, ref iColumn, level+1);
				}
				else
					iColumn++;
			}

			ColumnGrouping cg = (ColumnGrouping) (_ColumnGroupings.Items[level]);

			// if we need subtotal on the group
			if (cg.DynamicColumns != null &&
				cg.DynamicColumns.Subtotal != null)
			{
				ReportItem ri =  cg.DynamicColumns.Subtotal.ReportItems.Items[0];	
				matrix[iRow, iColumn] = new MatrixCellEntry(_Data, ri);
				matrix[iRow, iColumn].Height = cg.Height.Points;
				matrix[iRow, iColumn].Width = RunGetColumnWidth(matrix[iRow, iColumn]);
				RunColumnStaticHeaders(rpt, wc, matrix, _Data, iRow, iColumn, level);
				iColumn += this.CountMatrixCells;
			}
		}