internal void RunPage(Pages pgs, Row row)
		{
			// Start each row in the same location
			//   e.g. if there are two embedded tables in cells they both start at same location
			Page savepg = pgs.CurrentPage;
			float savey = savepg.YOffset;
			Page maxpg = savepg;
			float maxy = savey;

			foreach (TableCell tc in _Items)
			{
				tc.RunPage(pgs, row);
				if (maxpg != pgs.CurrentPage)
				{	// a page break
					if (maxpg.PageNumber < pgs.CurrentPage.PageNumber)
					{
						maxpg = pgs.CurrentPage;
						maxy = maxpg.YOffset;
					}
				}
				else if (maxy > pgs.CurrentPage.YOffset)
				{
					// maxy = maxy;      TODO what was this meant to do
				}
				// restore the beginning start of the row
				pgs.CurrentPage = savepg;
				savepg.YOffset = savey;
			}
			pgs.CurrentPage = maxpg;
			savepg.YOffset = maxy;
			return ;
		}

		override internal void RunPage(Pages pgs, Row row)
		{
			Report r = pgs.Report;
            bool bHidden = IsHidden(r, row);

			SetPagePositionBegin(pgs);
			PageLine pl = new PageLine();
            SetPagePositionAndStyle(r, pl, row);
            if (!bHidden)
			    pgs.CurrentPage.AddObject(pl);
			SetPagePositionEnd(pgs, pl.Y);
		}

		internal void RunPage(Pages pgs, Row row)
		{

			Page p = pgs.CurrentPage;
			if (p.YOffset + HeightOfRows(pgs, row) > pgs.BottomOfPage)
			{
				p = OwnerTable.RunPageNew(pgs, p);
				OwnerTable.RunPageHeader(pgs, row, false, null);
			}
			_TableRows.RunPage(pgs, row);

			return;
		}

        public void RunPages(Pages pgs)
        {
            //TODO : Why Cairo is broken when CurrentThread.CurrentCulture is set to local ?
            //At Linux when CurrentCulture is set to local culture, Cairo rendering is serious broken
            CultureInfo oldci = Thread.CurrentThread.CurrentCulture;
            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

            try {
                foreach (Page p in pgs) {
                    ProcessPage (g, p);
                    break;
                }
            } finally {
                Thread.CurrentThread.CurrentCulture = oldci;
            }
        }

        public PageDrawing(Pages pgs)
        {
            // Set up the tooltip
            _tt = new ToolTip();
            _tt.Active = false;
            _tt.ShowAlways = true;

            _HitList = new List<HitListEntry>();
            _SelectList = new List<PageItem>();
            _LastZoom = 1;

            _pgs = pgs;

            // Get our graphics DPI
            Graphics ga = null;
            try
            {
                ga = this.CreateGraphics();
                DpiX = ga.DpiX;
                DpiY = ga.DpiY;
            }
            catch
            {
                DpiX = DpiY = 96;
            }
            finally
            {
                if (ga != null)
                    ga.Dispose();
            }
            // force to double buffering for smoother drawing
            //this.SetStyle(ControlStyles.DoubleBuffer |
            //    ControlStyles.UserPaint |
            //    ControlStyles.AllPaintingInWmPaint,
            //    true);

            this.DoubleBuffered = true;
        }

		override internal void RunPage(Pages pgs, Row row)
		{
			Report r = pgs.Report;
			if (IsHidden(r, row))
				return;

			SetPagePositionBegin(pgs);
			PageLine pl = new PageLine();
            SetPagePositionAndStyle(r, pl, row);
            //pl.X = GetOffsetCalc(r) + LeftCalc(r);
            //if (Top != null)
            //    pl.Y = Top.Points;
            //pl.Y2 = Y2;
            //pl.X2 = GetX2(pgs.Report);

            //if (Style != null)
            //    pl.SI = Style.GetStyleInfo(r, row);
            //else
            //    pl.SI = new StyleInfo();	// this will just default everything

			pgs.CurrentPage.AddObject(pl);
			SetPagePositionEnd(pgs, pl.Y);
		}

		internal void RunPage(Pages pgs, Row row)
		{
			WorkClass wc = this.GetValue(pgs.Report);

			if (wc.OutputRow == row && wc.OutputPage == pgs.CurrentPage)
				return;

			Page p = pgs.CurrentPage;

			float height = p.YOffset + HeightOfRows(pgs, row);
			if (height > pgs.BottomOfPage)
			{
				Table t = OwnerTable;
				p = t.RunPageNew(pgs, p);
				t.RunPageHeader(pgs, row, false, null);
				if (this.RepeatOnNewPage)
					return;		// should already be on the page
			}

			_TableRows.RunPage(pgs, row);
			wc.OutputRow = row;
			wc.OutputPage = pgs.CurrentPage;
			return;
		}

        void RefreshReport()
        {
            SetParametersFromControls();
            report.RunGetData(Parameters);
            pages = report.BuildPages();

            foreach (Gtk.Widget w in vboxPages.AllChildren)
            {
                vboxPages.Remove(w);
            }

            for (int pageCount = 0; pageCount < pages.Count; pageCount++)
            {
                ReportArea area = new ReportArea();
                area.SetReport(report, pages[pageCount]);
                //area.Scale
                vboxPages.Add(area);
            }
            this.ShowAll();

            SetErrorMessages (report.ErrorItems);

            if (report.ErrorMaxSeverity == 0)
                show_errors = false;

            errorsAction.VisibleHorizontal = report.ErrorMaxSeverity > 0;

            //			Title = string.Format ("RDL report viewer - {0}", report.Name);
            EnableActions();
            CheckVisibility();
        }

        // this does all the work
        public void RunPages(Pages pgs)
        {
            foreach (Page p in pgs)
            {
                //Create a Page Dictionary representing a visible page
                page=new PdfPage(anchor);
                content=new PdfContent(anchor);

                PdfPageSize pSize=new PdfPageSize((int) r.ReportDefinition.PageWidth.Points,
                                    (int) r.ReportDefinition.PageHeight.Points);
                page.CreatePage(pageTree.objectNum,pSize);
                pageTree.AddPage(page.objectNum);

                //Create object that presents the elements in the page
                elements=new PdfElements(page, pSize);

                ProcessPage(pgs, p);

                // after a page
                content.SetStream(elements.EndElements());

                page.AddResource(fonts,content.objectNum);
                page.AddResource(patterns,content.objectNum);
                //get the pattern colorspace...
                PatternObj po = new PatternObj(anchor);
                page.AddResource(po,content.objectNum);

                int size=0;
                tw.Write(page.GetPageDict(filesize,out size),0,size);
                filesize += size;

                tw.Write(content.GetContentDict(filesize,out size),0,size);
                filesize += size;

                tw.Write(po.GetPatternObj(filesize, out size),0,size);
                filesize += size;
            }
            return;
        }

		internal void SetPagePositionEnd(Pages pgs, float pos)
		{
			if (_TC != null || _InMatrix)			// don't mess with page if part of a table or in a matrix
				return;
			WorkClass wc = GetWC(pgs.Report);
			wc.CurrentPage = pgs.CurrentPage;
			wc.BottomPosition = pos;
		}

		internal Page RunPageNew(Pages pgs, Page p)
		{
			if (p.IsEmpty())			// if the page is empty it won't help to create another one
				return p;

			// Do we need a new page or have should we fill out more body columns
			Body b = OwnerReport.Body;
			int ccol = b.IncrCurrentColumn(pgs.Report);	// bump to next column

			float top = OwnerReport.TopOfPage;	// calc top of page

			if (ccol < b.Columns)
			{		// Stay on same page but move to new column
				p.XOffset = 
					((OwnerReport.Width.Points + b.ColumnSpacing.Points) * ccol);
				p.YOffset = top;
				p.SetEmpty();			// consider this page empty
			}
			else
			{		// Go to new page
				b.SetCurrentColumn(pgs.Report, 0);
				pgs.NextOrNew();
				p = pgs.CurrentPage;
				p.YOffset = top;
				p.XOffset = 0;
			}

			return p;
		}

 // we don't have paging turned on for xml
 public void RunPages(Pages pgs)
 {
     return;
 }

		internal void RunPageRegionEnd(Pages pgs)
		{
			if (this.TC == null && this.PageBreakAtEnd && !pgs.CurrentPage.IsEmpty())
			{	// force page break at beginning of dataregion
				pgs.NextOrNew();
				pgs.CurrentPage.YOffset = OwnerReport.TopOfPage;
			}
		}

		override internal void RunPage(Pages pgs, Row row)
		{
			Report r = pgs.Report;
            bool bHidden = IsHidden(r, row);

			WorkClass wc = GetWC(r);
			string mtype=null; 
			Stream strm=null;
			System.Drawing.Image im=null;

			SetPagePositionBegin(pgs);
            if (bHidden)
            {
                PageImage pi = new PageImage(ImageFormat.Jpeg, null, 0, 0);
                this.SetPagePositionAndStyle(r, pi, row);
                SetPagePositionEnd(pgs, pi.Y + pi.H);
                return;
            }

			if (wc.PgImage != null)
			{	// have we already generated this one
				// reuse most of the work; only position will likely change
				PageImage pi = new PageImage(wc.PgImage.ImgFormat, wc.PgImage.ImageData, wc.PgImage.SamplesW, wc.PgImage.SamplesH);
				pi.Name = wc.PgImage.Name;				// this is name it will be shared under
				pi.Sizing = this._Sizing;
				this.SetPagePositionAndStyle(r, pi, row);
				pgs.CurrentPage.AddObject(pi);
                SetPagePositionEnd(pgs, pi.Y + pi.H);
				return;
			}

			try 
			{
				strm = GetImageStream(r, row, out mtype);
                if (strm == null)
                {
                    r.rl.LogError(4, string.Format("Unable to load image {0}.", this.Name.Nm));
                    return;
                }
				im = System.Drawing.Image.FromStream(strm);
				int height = im.Height;
				int width = im.Width;
				MemoryStream ostrm = new MemoryStream();
				strm.Position = 0;
				ImageFormat imf;
				switch(mtype.ToLower())
				{	
					case "image/jpeg" :
						imf = ImageFormat.Jpeg;
						CopyStream(strm, ostrm);
						break;
					case "image/png":
						imf = ImageFormat.Png;
						CopyStream(strm, ostrm);
						break;
					default: // from old code where all images convert to jpeg, i don't know why. May be need delete it and add all support formats.
						imf = ImageFormat.Jpeg;
						System.Drawing.Imaging.ImageCodecInfo[] info;
						info = ImageCodecInfo.GetImageEncoders();
						EncoderParameters encoderParameters;
						encoderParameters = new EncoderParameters(1);
						encoderParameters.Param[0] = new EncoderParameter(Encoder.Quality, ImageQualityManager.EmbeddedImageQuality);
						System.Drawing.Imaging.ImageCodecInfo codec = null;
						for (int i = 0; i < info.Length; i++)
						{
							if (info[i].FormatDescription == "JPEG")
							{
								codec = info[i];
								break;
							}
						}
						im.Save(ostrm, codec, encoderParameters);
						break;
				}

				byte[] ba = ostrm.ToArray();
				ostrm.Close();
				PageImage pi = new PageImage(imf, ba, width, height);
				pi.Sizing = this._Sizing;
				this.SetPagePositionAndStyle(r, pi, row);

				pgs.CurrentPage.AddObject(pi);
				if (_ConstantImage)
				{
					wc.PgImage = pi;
					// create unique name; PDF generation uses this to optimize the saving of the image only once
					pi.Name = "pi" + Interlocked.Increment(ref Parser.Counter).ToString();	// create unique name
				}

                SetPagePositionEnd(pgs, pi.Y + pi.H);
            }
			catch (Exception e)
			{	
				// image failed to load, continue processing
				r.rl.LogError(4, "Image load failed.  " + e.Message);
			}
			finally
			{
				if (strm != null)
					strm.Close();
//.........这里部分代码省略.........

 // we don't have paging turned on for html
 public void RunPages(Pages pgs)
 {
 }

        public void RunPages(Pages pgs)	// this does all the work
        {
            foreach (Page p in pgs)
            {
                //Create a Page Dictionary representing a visible page
                page = new PdfPage(anchor);
                content = new PdfContent(anchor);

                PdfPageSize pSize = new PdfPageSize((int)r.ReportDefinition.PageWidth.ToPoints(),
                                    (int)r.ReportDefinition.PageHeight.ToPoints());
                _pSize = pSize;
                page.CreatePage(pageTree.objectNum, pSize);
                pageTree.AddPage(page.objectNum);
                if (r.ItextPDF)
                {
                    //Itextsharp pdf handler, set pagesize
                    pdfdocument.SetPageSize(new iTextSharp.text.Rectangle(r.ReportDefinition.PageWidth.ToPoints(), r.ReportDefinition.PageHeight.ToPoints()));
                    pdfdocument.NewPage();
                }
                //Create object that presents the elements in the page
                elements = new PdfElements(page, pSize);

                ProcessPage(pgs, p);

                // after a page
                content.SetStream(elements.EndElements());

                page.AddResource(fonts, content.objectNum);
                page.AddResource(patterns, content.objectNum);
                //get the pattern colorspace...
                PatternObj po = new PatternObj(anchor);
                page.AddResource(po, content.objectNum);
                if (r.ItextPDF == false)
                {
                    int size = 0;
                    tw.Write(page.GetPageDict(filesize, out size), 0, size);
                    filesize += size;

                    tw.Write(content.GetContentDict(filesize, out size), 0, size);
                    filesize += size;

                    tw.Write(po.GetPatternObj(filesize, out size), 0, size);
                    filesize += size;
                }
            }
            return;
        }

		override internal void RunPage(Pages pgs, Row row)
		{
			Report r = pgs.Report;
			if (IsHidden(r, row))
				return;

			WorkClass wc = GetValue(r);
			wc.Data = GetFilteredData(r, row);

			SetPagePositionBegin(pgs);

			if (!AnyRowsPage(pgs, wc.Data))		// if no rows return
				return;						//   nothing left to do

			RunPageRegionBegin(pgs);

			RunSetGrouping(pgs.Report, wc);

			RunPageGroups(pgs, wc, wc.Groups);

			RunPageRegionEnd(pgs);
			SetPagePositionEnd(pgs, pgs.CurrentPage.YOffset);
			RemoveValue(r);
		}

		internal bool AnyRowsPage(Pages pgs, Rows data)
		{
			if (data != null && data.Data != null &&
				data.Data.Count > 0)
				return true;

			string msg;
			if (this.NoRows != null)
				msg = this.NoRows.EvaluateString(pgs.Report, null);
			else
				msg = null;

			if (msg == null)
				return false;

			// OK we have a message we need to put out
			RunPageRegionBegin(pgs);				// still perform page break if needed

			PageText pt = new PageText(msg);
			SetPagePositionAndStyle(pgs.Report, pt, null);

			if (pt.SI.BackgroundImage != null)
				pt.SI.BackgroundImage.H = pt.H;		//   and in the background image

			pgs.CurrentPage.AddObject(pt);

			RunPageRegionEnd(pgs);					// perform end page break if needed
			return false;
		}

		private void RunPageGroups(Pages pgs, WorkClass wc, List<GroupEntry> groupEntries)
		{
			Report rpt = pgs.Report;
			Page p = pgs.CurrentPage;
			float pagebottom = OwnerReport.BottomOfPage;
			p.YOffset += (Top == null? 0: this.Top.Points); 
			float listoffset = GetOffsetCalc(pgs.Report)+LeftCalc(pgs.Report);

			float height;	
			Row row;

			foreach (GroupEntry ge in groupEntries)
			{
				// set the group entry value
				int index;
				if (ge.Group != null)	// groups?
				{
					ge.Group.ResetHideDuplicates(rpt);	// reset duplicate checking
					index = ge.Group.GetIndex(rpt);	// yes
				}
				else					// no; must be main dataset
					index = 0;
				wc.Data.CurrentGroups[index] = ge;
				if (ge.NestedGroup.Count > 0)
					RunGroupsSetGroups(rpt, wc, ge.NestedGroup);

				if (ge.Group == null)
				{	// need to run all the rows since no group defined
					for (int r=ge.StartRow; r <= ge.EndRow; r++)
					{
						row = wc.Data.Data[r];
						height = HeightOfList(rpt, pgs.G, row);
                        float saveYoffset = p.YOffset;              // this can be affected by other page items
						_ReportItems.RunPage(pgs, row, listoffset);
                        p.YOffset = saveYoffset + height;
						if (p.YOffset + height > pagebottom)		// need another page for next row?
						{
							p = RunPageNew(pgs, p);					// yes; if at end this page is empty
						}											// and will be cleaned up later				
					}
				}
				else
				{	// need to process just whole group as a List entry
					if (ge.Group.PageBreakAtStart && !p.IsEmpty())
						p = RunPageNew(pgs, p);

					// pass the first row of the group
					row = wc.Data.Data[ge.StartRow];
					height = HeightOfList(rpt, pgs.G, row);
                    float saveYoffset = p.YOffset;              // this can be affected by other page items
                    _ReportItems.RunPage(pgs, row, listoffset);
					p.YOffset = saveYoffset + height;
					if (ge.Group.PageBreakAtEnd ||					// need another page for next group?
						p.YOffset + height > pagebottom)
					{
						p = RunPageNew(pgs, p);						// yes; if at end empty page will be cleaned up later
					}
				}
			}
		}

		internal virtual void RunPage(Pages pgs, Row row)
		{
			return;
		}