BES/ReportManager.NET
9
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
ReportManager.NET/Consulenza.ReportWriter.Business/RendererPDF.cs

4092 lines
198 KiB
C#
Raw Blame History

using System;
using System.Collections.Generic;
using ceTe.DynamicPDF.Merger;
using ceTe.DynamicPDF.PageElements;
using ceTe.DynamicPDF;
using System.Data;
using System.Collections;
using System.Linq;
using Consulenza.ReportCommon;
using Consulenza.ReportWriter.Business.CHART_PDF;
using Consulenza.ReportWriter.Business.OBJ_PDF;
using System.Configuration;
using Consulenza.ReportWriter.Business.Entity;
using RisorseEmbeddedRM;
using Consulenza.DataServices;
using ceTe.DynamicPDF.Text;
using Consulenza.ReportWriter.Business.Headers;
namespace Consulenza.ReportWriter.Business
{
/// <summary>
/// Implementa i metodi di assegnazione degli elementi ObjectPDF alla pagina.
/// </summary>
public class RendererPDF
{
# region Fields
private int numberPageOnChapter = 0; // Numero della pagina aggiunta al singolo capitolo. Si resetta a 0 ad ogni cambio capitolo. (Evita di doppiare il titolo del capitolo aggiunto da WriteChapterTitle e dall'invocazione del capitolo stesso)
private readonly Document _document;
private readonly List<ObjectPDF> _elements = new List<ObjectPDF>();
private List<EntityBase> _entities = new List<EntityBase>();
private EntityBase _currentchapter; // puntatore al chapter correntetra quelli aggiunti alla collezione _entities.
private ImportedPage _page;
private readonly PdfDocument _generictemplate;
private readonly PdfDocument _covertemplate;
// Margini
private readonly float _yendpage; // limite prefissato e non variabile, corrisponde alla linea di chiusura pagina.
private readonly float _ylowerlimitoriginal; // non variabile in funzione della presenza delle note di piè di pagina. la differenza tra _ylowerlimitoriginal - _ylowerlimit indica lo spazio dell apagina in cui vengono scritte le note di fondo pagina.
/// <summary>
/// Y corrente su cui verrà disegnato ObjectPDF
/// </summary>
private float _ywritable;
public float YWritable
{
get { return _ywritable; }
set { _ywritable = value; }
}
/// <summary>
/// Permette di accedere alle impostazioni di "ambiente" specifiche del Report corrente (chiavi di invocazione etc...).
/// </summary>
private readonly ReportEnvironment _reportEnvironment;
private float _spacenotefooterpagePerpage;
/// <summary>
/// Indica se il prossimo elemento che sarà stampatoo sulla pagina, verrà stampato in una nuova pagina.
/// </summary>
private bool _printinginnewpage = true;
/// <summary>
/// Limite sinitro della pagina (è già considerato lo spazio necessario per le avvertenze.)
/// Di default 37
/// </summary>
public float XLeftLimit { get; set; }
/// <summary>
/// Limite destro della pagina.
/// Di default 560
/// </summary>
public float XRightLimit { get; set; }
/// <summary>
/// Limite massimo superiore della pagina (corrisponde alla linea rossa superiore)
/// Di default 130
/// </summary>
public float YUpperLimit { get; set; }
/// <summary>
/// Limite massimo superiore della pagina (corrisponde alla linea rossa inferiore)
/// Di default 750
/// </summary>
public float YLowerLimit { get; set; }
private List<ObjectPDF> _repeaterElements;
#endregion
/// <summary>
/// Costruttore.
/// Imposta la il Template, la Page e passa una rappresentazione del DataModel all'implementazione estesa della classe corrente
/// al fine di supportare l'invocazione dei metodi di rendering delle classi specifiche del Layout esteso di ciascuna pagina (vedere FrameClassMapperManager invocato dall'estensione RendererExtender.cs).
/// </summary>
/// <param name="environment"></param>
public RendererPDF(ReportEnvironment environment)
{
_reportEnvironment = environment;
_document = new Document();
Document.AddLicense(ConfigurationManager.AppSettings["Licenza"]);
#region Template
// Imposto il documento per la copertina del report
var fileCoverTemplate = RisorseEmbedded.GetResourceByName(_reportEnvironment.ResourceNameCover);
_covertemplate = new PdfDocument(fileCoverTemplate);
// Imposto il documento per le pagine generiche del report.
var fileGenericTemplate = RisorseEmbedded.GetResourceByName(_reportEnvironment.ResourceNameTemplate);
_generictemplate = new PdfDocument(fileGenericTemplate);
#endregion
#region Margini del documento
switch (environment.ReportType)
{
case ReportType.Base_Proposta:
// Template A4 Verticale
XLeftLimit = 37;
XRightLimit = 560;
YUpperLimit = 105;
YLowerLimit = 745;
_yendpage = 766F;
_ylowerlimitoriginal = 745F;
break;
case ReportType.Immobiliare_Diagnosi:
case ReportType.Immobiliare_DiagnosiNucleo:
case ReportType.Immobiliare_MappaturaPreliminare:
case ReportType.Immobiliare_Finalita:
// Template A4 Orizzontale
XLeftLimit = 50;
XRightLimit = 805;
YUpperLimit = 35;
_yendpage = 510;
_ylowerlimitoriginal = 485;
YLowerLimit = 485;
break;
case ReportType.Unica_Diagnosi:
case ReportType.Unica_Monitoraggio:
case ReportType.Unica_Proposta:
case ReportType.Unica_Nucleo:
// Template A4 Verticale
XLeftLimit = 37;
XRightLimit = 560;
YUpperLimit = 122;
YLowerLimit = 745;
_yendpage = 740F;
_ylowerlimitoriginal = 740F;
break;
case ReportType.Immobiliare_Monitoraggio:
// Template A4 Orizzontale
XLeftLimit = 14;
XRightLimit = 805;
YUpperLimit = 17;
_yendpage = 474;
_ylowerlimitoriginal = 480;
YLowerLimit = 490;
break;
case ReportType.Immobiliare_MonitoraggioNuclei:
// Template A4 Orizzontale
XLeftLimit = 14;
XRightLimit = 805;
YUpperLimit = 17;
_yendpage = 474;
_ylowerlimitoriginal = 480;
YLowerLimit = 490;
break;
default:
throw new Exception("ReportType da definire: [Consulenza.ReportWriter.Business.RendererPDF()]");
}
#endregion
#region Compression Level
_document.CompressionLevel = 9;
#endregion
#region Security
// Create a standard security object
//var security = new StandardSecurity { AllowCopy = false, AllowEdit = false };
//FC 26/01/2017
//richiesta Casoli Abilitazione Copia e Modifica documenti
var security = new StandardSecurity { AllowCopy = true, AllowEdit = true };
// Add the security object to the document
_document.Security = security;
#endregion
#region Pdf Version
_document.PdfVersion = PdfVersion.v1_7;
_document.PdfXVersion = PdfXVersion.PDF_X_3_2003;
#endregion
#region ICCProfile
var iccProfile = new IccProfile(RisorseEmbedded.GetResourceByName("RisorseEmbeddedRM.PDFTemplates.sRGB.icc"));
const string configurationPath1 = "CGATS TR 001-1995 (SWOP)";
const string configurationPath2 = "CGATS TR 001";
const string configurationPath3 = "http://www.color.org";
const string configurationPath4 = "U.S. Web Coated (SWOP) v2";
var outputIntent = new OutputIntent(configurationPath1, configurationPath2, configurationPath3, configurationPath4, iccProfile);
_document.OutputIntents.Add(outputIntent);
_document.Trapped = Trapped.False;
#endregion
if (_ywritable == 0)
_ywritable = YUpperLimit;
}
/// <summary>
/// Ritorna la rappresentazione in array di byte[] del report.
/// </summary>
/// <returns></returns>
public byte[] Render(List<EntityBase> entities)
{
_entities = entities;
WriteElements();
if (_reportEnvironment.ReportType == ReportType.Immobiliare_Monitoraggio || _reportEnvironment.ReportType == ReportType.Immobiliare_MonitoraggioNuclei)
{
ReplaceHeadersIndexes();
ReplaceIndexPagePageNumbers();
}
return _document.Draw();
}
private void ReplaceIndexPagePageNumbers()
{
if (_document != null && _document.Pages != null)
{
foreach (Page page in _document.Pages)
{
foreach (var element in page.Elements)
{
if (element is FormattedTextArea)
{
FormattedTextArea el = element as FormattedTextArea;
foreach (var tuple in MonitoraggioImmobiliarePageHeaderManager.IndexPagesPageNumbersToReplace)
{
if (el != null && (el.Text != null && el.Text.Contains(tuple.Item2)))
{
el.Text = el.Text.Replace(tuple.Item2, (headers.IndexOf(headers.Where(x => x.Item1.BelongToIndex == tuple.Item1).First()) + 3).ToString());
}
}
}
}
}
}
MonitoraggioImmobiliarePageHeaderManager.IndexPagesPageNumbersToReplace.Clear();
}
private void ReplaceHeadersIndexes()
{
if (_document != null & _document.Pages != null && headers.Count() > 0)
{
foreach (var header in headers)
{
var sectionId = header.Item1;
var sameSectionHeaders = headers.Where(x => x.Item1 == sectionId).ToList();
if (sameSectionHeaders.Count() == 1)
{
var guid = sameSectionHeaders.FirstOrDefault().Item1.TextReplaceGuid;
var newHeaderText = sameSectionHeaders.FirstOrDefault().Item2.Text.Replace(
guid, string.Empty);
for (int i = 0; i < _document.Pages.Count; i++)
{
for (int j = 0; j < _document.Pages[i].Elements.Count; j++)
{
FormattedTextArea el = _document.Pages[i].Elements[j] as FormattedTextArea;
if (el != null && (el.Text != null & el.Text.Contains(guid)))
{
el.Text = newHeaderText;
}
}
}
}
else if (sameSectionHeaders.Count() > 1)
{
int maxPages = sameSectionHeaders.Count();
int indexPage = 1;
for (int i = 0; i < maxPages; i++)
{
var guid = sameSectionHeaders[i].Item1.TextReplaceGuid;
for (int a = 0; a < _document.Pages.Count; a++)
{
for (int j = 0; j < _document.Pages[a].Elements.Count; j++)
{
FormattedTextArea el = _document.Pages[a].Elements[j] as FormattedTextArea;
if (el != null && (el.Text != null && el.Text.Contains(guid)))
{
var newHeaderText = sameSectionHeaders[i].Item2.Text.Replace(guid, string.Format(" ({0}/{1})", indexPage, maxPages));
el.Text = newHeaderText;
indexPage++;
break;
}
}
}
}
}
}
}
}
#region WriteElements
/// <summary>
/// Disegna sulla pagina tutti gli elementi aggiunti al documento.
/// Riduce lo spazio scrivibile della pagina se ci sono note a piedipagina da stampare
/// </summary>
private void WriteElements()
{
foreach (var entity in _entities)
{
// puntatore al chapter corrente.
if (entity.EntityType == EntityTypePdf.Chapter)
{
_currentchapter = entity;
numberPageOnChapter = 0;
}
// elementi Repeater
var elementRepeater = entity.Elements.FirstOrDefault(o => o.ObjectType == ObjectTypePdf.REPEATER);
if (elementRepeater != null)
_repeaterElements = ((RepeaterPDF)elementRepeater).Elements;
// Disegno tutti gli elementi (Elements)
foreach (var element in entity.Elements)
{
_elements.Add(element);
#region switch ObjectType elemento
switch (element.ObjectType)
{
case ObjectTypePdf.FORMATTEDTEXTAREA:
WriteElement((FormattedTextAreaPDF)element);
break;
case ObjectTypePdf.LINE:
WriteElement((LinePDF)element);
break;
case ObjectTypePdf.IMAGE:
WriteElement((ImagePDF)element);
break;
case ObjectTypePdf.TABLE:
WriteElement((TablePDF)element);
break;
case ObjectTypePdf.SPACE:
WriteElement((SpacePDF)element);
break;
case ObjectTypePdf.RECTANGLE:
WriteElement((RectanglePDF)element);
break;
case ObjectTypePdf.UNORDEREDLIST:
WriteElement((UnorderedListPDF)element);
break;
case ObjectTypePdf.PAGE:
var page = (PagePDF)element;
switch (page.Type)
{
case PagePDF.PagePDFType.Generic:
AddPage();
numberPageOnChapter++;
break;
case PagePDF.PagePDFType.Cover:
AddPage(PagePDF.PagePDFType.Cover);
break;
}
break;
case ObjectTypePdf.CIRCLE:
WriteElement((CirclePDF)element);
break;
case ObjectTypePdf.RESETTER_Y:
WriteElement((ResetterYPDF)element);
break;
case ObjectTypePdf.ACTIONPDF:
WriteElement((ActionPDF)element);
break;
case ObjectTypePdf.COMPOSITE:
WriteElement((CompositePDF)element);
break;
case ObjectTypePdf.CHART:
var chart = element as ChartPDF;
switch (chart.ChartType)
{
case ChartTypePdf.PIE:
chart = element as PiePDF;
break;
case ChartTypePdf.STACKED:
chart = element as StackedPDF;
break;
case ChartTypePdf.COMBINATION:
chart = element as CombinationPDF;
break;
default:
throw new Exception("Grafico non esistente");
}
WriteElement(chart);
break;
case ObjectTypePdf.CIRCLEREAL:
WriteElement((CircleRealPDF)element);
break;
case ObjectTypePdf.CUSTOMCHART:
WriteElement((CustomChartPDF)element);
break;
}
#endregion
}
_repeaterElements = null;
}
}
#endregion
#region WriteElement
private void WriteElement(ObjectPDF element)
{
//var genericElement = Activator.CreateInstance(element.GetType());
switch (element.ObjectType)
{
case ObjectTypePdf.FORMATTEDTEXTAREA:
case ObjectTypePdf.TABLENOTE:
WriteElement((FormattedTextAreaPDF)element);
break;
case ObjectTypePdf.IMAGE:
WriteElement((ImagePDF)element);
break;
case ObjectTypePdf.SPACE:
WriteElement((SpacePDF)element);
break;
case ObjectTypePdf.LINE:
WriteElement((LinePDF)element);
break;
case ObjectTypePdf.RECTANGLE:
WriteElement((RectanglePDF)element);
break;
case ObjectTypePdf.CIRCLE:
WriteElement((CirclePDF)element);
break;
case ObjectTypePdf.CIRCLEREAL:
WriteElement((CircleRealPDF)element);
break;
case ObjectTypePdf.UNORDEREDLIST:
WriteElement((UnorderedListPDF)element);
break;
case ObjectTypePdf.CHART:
WriteElement((ChartPDF)element);
break;
case ObjectTypePdf.TABLE:
WriteElement((TablePDF)element);
break;
case ObjectTypePdf.RESETTER_Y:
WriteElement((ResetterYPDF)element);
break;
case ObjectTypePdf.ACTIONPDF:
WriteElement((ActionPDF)element);
break;
case ObjectTypePdf.COMPOSITE:
WriteElement((CompositePDF)element);
break;
case ObjectTypePdf.CUSTOMCHART:
WriteElement((CustomChartPDF)element);
break;
}
}
/// <summary>
/// Scrive l'elemento NotePDF nella pagina
/// </summary>
/// <param name="element"></param>
private void WriteElement(TableNotePDF element)
{
if (element.Image == null)
{
var elementConverted = element as FormattedTextAreaPDF;
if (element.TypeMarker != TableNotePDF.TableNoteTypemarker.Numeri)
elementConverted.Text = element.AsterisksNumber > 0 ? "(" + element.ToAsteriskString() + ") " + element.Text : element.Text;
else
elementConverted.Text = element.AsterisksNumber > 0 ? "(" + element.ToNumberAsteriskString() + ") " + element.Text : element.Text;
WriteElement(elementConverted);
}
else
{
var elements = new List<ObjectPDF>();
// testo della nota
var elementText = element as FormattedTextAreaPDF;
elementText.Text = element.Text;
elementText.X += 20;
// immagine della nota
var elementImage = element.Image;
elementImage.AutoIncrementYWritable = false;
elements.Add(elementImage);
elements.Add(elementText);
// disegno gli oggetti aggiunti
foreach (var item in elements)
WriteElement(item);
}
}
/// <summary>
/// Scrive l'elemento RectanglePDF nella pagina
/// </summary>
/// <param name="element"></param>
private void WriteElement(RectanglePDF element)
{
var color = new RgbColor((byte)element.Color.Red, (byte)element.Color.Green, (byte)element.Color.Blue);
element.BaseElement = new Rectangle(element.X, element.Y, element.Width, element.Height, color, color);
//element.BaseElement.X += element.DeltaX;
// Imposto Y
if (element.Y == 0)
element.BaseElement.Y = _ywritable + element.DeltaY;
// CornerRadius
if (element.CornerRadius > 0)
element.BaseElement.CornerRadius = element.CornerRadius;
// Angle
if (element.Angle != 0)
element.BaseElement.Angle = element.Angle;
// Disegno BaseElement
if (_ywritable + element.Height <= YLowerLimit)
_page.Elements.Add(element.ToElement());
else
{
// aggiungere una pagina
AddPage();
element.BaseElement.Y = _ywritable + element.DeltaY;
_page.Elements.Add(element.ToElement());
}
// Imposto Border
if (element.BorderWidth > 0)
{
var colorBorder = new RgbColor((byte)element.BorderColor.Red, (byte)element.BorderColor.Green, (byte)element.BorderColor.Blue);
element.BaseElement.BorderWidth = element.BorderWidth;
element.BaseElement.BorderColor = colorBorder;
element.BaseElement.BorderStyle = LineStyle.Solid;
}
// Incremento _ywritable
if (element.AutoIncrementYWritable)
_ywritable += element.Height;
}
/// <summary>
/// Scrive l'elemento CirclePDF nella pagina
/// </summary>
/// <param name="element"></param>
private void WriteElement(CirclePDF element)
{
WriteElement((RectanglePDF)element);
}
private void WriteElement(CircleRealPDF element)
{
var color = new RgbColor((byte)element.Color.Red, (byte)element.Color.Green, (byte)element.Color.Blue);
element.BaseElement = new Circle(element.X, element.Y, element.Radius, color)
{
FillColor = color
};
element.BaseElement.X += element.DeltaX;
// Imposto Y
if (element.Y == 0)
element.BaseElement.Y = _ywritable + element.DeltaY;
// Disegno BaseElement
if (_ywritable + element.Radius * 2 <= YLowerLimit)
_page.Elements.Add(element.ToElement());
else
{
// aggiungere una pagina
AddPage();
element.BaseElement.Y = _ywritable + element.DeltaY;
_page.Elements.Add(element.ToElement());
}
// Incremento _ywritable
if (element.AutoIncrementYWritable)
_ywritable += element.Radius * 2;
}
/// <summary>
/// Scrive l'elemento FormattedTextAreaPDF nella pagina
/// </summary>
/// <param name="element"></param>
private void WriteElement(FormattedTextAreaPDF element)
{
// Style
var color = new RgbColor((byte)element.FontColor.Red, (byte)element.FontColor.Green, (byte)element.FontColor.Blue);
var styleFormattedTextArea = new FormattedTextAreaStyle(_reportEnvironment.FontFamily, element.FontSize, false) { Bold = element.FontBold };
element.BaseElement = new FormattedTextArea(element.Text, element.X, element.Y, element.Width, element.Height, styleFormattedTextArea)
{
Style = styleFormattedTextArea
};
element.BaseElement.Style.Font.Color = color;
element.BaseElement.Style.Paragraph.Align = element.TextHorizontalAlign;
element.BaseElement.VAlign = element.TextVerticalAlign;
// Imposto Height
if (element.Width > 0 && !string.IsNullOrEmpty(element.Text))
{
element.SetHeight(element.FixedHeight > 0 ? element.FixedHeight : element.BaseElement.GetRequiredHeight());
}
//else
// element.Height = element.FixedHeight;
element.BaseElement.Height = element.Height;
// Imposto Y
element.BaseElement.Y = element.Y == 0 ? _ywritable + element.DeltaY : element.Y + element.DeltaY;
// Imposto X
element.BaseElement.X += element.DeltaX;
// Imposto testo in verticale.
if (element.TextVerticalDirection)
{
element.BaseElement.Angle = -90;
}
#region BackGround
if (element.BackGroundColor != null)
{
var rectangleBackColor = new RectanglePDF(element.BackGroundHeight, element.Width, element.BackGroundColor)
{
X = element.X
};
rectangleBackColor.Y = element.BaseElement.Y - (rectangleBackColor.Height / 2) + (element.FontSize / 2);
if (element.BaseElement.VAlign == VAlign.Top)
element.BaseElement.Y = _ywritable - (rectangleBackColor.Height / 2) + (element.FontSize / 2);
rectangleBackColor.AutoIncrementYWritable = false;
WriteElement(rectangleBackColor);
// Margine sinistro dell'etichetta (BackGroundMarginLeft)
element.BaseElement.X += element.BackGroundMarginLeft;
}
#endregion
// Disegno BaseElement
if (_ywritable + element.Height <= YLowerLimit || element.AbsolutePosition)
{
if (element.ID == "debug")
_page.Elements.Add(new Line(element.BaseElement.X, element.BaseElement.Y, element.BaseElement.X + element.Width, element.BaseElement.Y, RgbColor.Red));
_page.Elements.Add(element.ToElement());
if (element.ID == "debug")
_page.Elements.Add(new Line(element.BaseElement.X, element.BaseElement.Y + element.Height, element.BaseElement.X + element.Width, element.BaseElement.Y + element.Height, RgbColor.Yellow));
}
else
{
// aggiungere una pagina
AddPage();
element.BaseElement.Y = _ywritable + element.DeltaY;
_page.Elements.Add(element.ToElement());
}
if (element.AutoIncrementYWritable && element.BackGroundColor == null)
_ywritable += element.Height;
if (element.AutoIncrementYWritable && element.BackGroundColor != null)
_ywritable += element.BackGroundHeight - (element.BackGroundHeight / 2) + (element.FontSize / 2);
}
/// <summary>
/// Scrive l'elemento LinePDF nella pagina
/// </summary>
/// <param name="element"></param>
private void WriteElement(LinePDF element)
{
var color = new RgbColor((byte)element.Color.Red, (byte)element.Color.Green, (byte)element.Color.Blue);
element.BaseElement = new Line(element.X1, element.Y1, element.X2, element.Y2, element.Width, color, element.BorderStyle);
if (element.Y1 == 0)
{
element.BaseElement.Y1 = _ywritable;
element.BaseElement.Y2 = _ywritable;
}
element.BaseElement.Y1 += element.DeltaY;
element.BaseElement.Y2 += element.DeltaY;
element.BaseElement.Y2 += element.DeltaY2ForVerticalLine;
// Disegno il BaseElement
_page.Elements.Add(element.ToElement());
if (element.DeltaY2ForVerticalLine == 0 && element.AutoIncrementYWritable)
_ywritable += element.Width;
}
/// <summary>
/// Scrive l'elemento ImagePDF nella pagina
/// </summary>
/// <param name="element"></param>
private void WriteElement(ImagePDF element)
{
var imageFound = true;
try
{
// Imposto il sorgente dell'immagine
element.BaseElement = string.IsNullOrEmpty(element.Path)
? new Image(element.File, element.X + element.DeltaX, element.Y, element.Scale)
: new Image(element.Path, element.X + element.DeltaX, element.Y, element.Scale);
}
catch (Exception ex)
{
imageFound = false;
}
if (imageFound)
{
// Imposto Y
element.BaseElement.Y = element.Y == 0 ? _ywritable : element.Y;
element.BaseElement.Y += element.DeltaY;
// Imposto dimensioni e allineamento
element.BaseElement.Align = element.Align;
if (element.Height > 0)
element.BaseElement.Height = element.Height;
if (element.Width > 0)
element.BaseElement.Width = element.Width;
// Disegno il BaseElement.
_page.Elements.Add(element.ToElement());
if (element.AutoIncrementYWritable)
_ywritable += element.BaseElement.Height;
}
}
/// <summary>
/// Scrive l'elemento TabellaPDF nella pagina
/// La tabella è disegnata come un insieme di LabelPDF separate da LinePDF
/// </summary>
/// <param name="element"></param>
private void WriteElement(TablePDF element)
{
_ywritable += element.YOffset;
var originalYWritable = _ywritable;
if (element.Y == 0)
element.Y = _ywritable;
var dataSourceInput = element.DataSource;
var rowsHeightList = new List<float>();
int columnIndex = 0;
int rowIndex = 0;
int rowIndexPerPage = 0; // è l'indice della riga che si azzera al saltopagina.
var columnsWidthOriginal = new List<int>(); // è la larghezza originale delle colonne non modificata se impostata la Cell.ColSpan
columnsWidthOriginal.AddRange(element.Columns.Select(o => o.Width));
// Imposto HeaderFontSize di tutte le colonne per cui non è stato impostato (=0) uguale a HeaderFontSize della relativa tabella.
// Questo perché HeaderFontSize della tabella è variabile in funzione dello Style.
element.Columns.FindAll(o => o.HeaderFontSize == 0).ToList().ForEach(c => c.HeaderFontSize = element.HeaderFontSize);
#region Controllo dimensione della larghezza della tabella
if (element.X + element.Width > XRightLimit)
throw new Exception("La tabella è troppo grande in larghezza");
#endregion
// TABLE TITLE
//if (element.TableTitle != null)
//{
// FormattedTextAreaPDF title = new FormattedTextAreaPDF(element.TableTitle, element.X + element.TableTitleDeltaX, element.Width) { FontBold = element.TableTitleFontBold, FontSize = element.TableTitleFontSize, FontColor = element.TableTitleFontColor, AutoIncrementYWritable = true };
// WriteElement(title);
// WriteElement(new SpacePDF(5));
//}
#region Recupero colonne del datatable da stampare e imposto il Datasource
// Recupera le colonne in base alla proprietà Colonne della tabella.
// Vengono escluse le colonne che non hanno la proprietà Nome impostata.
var arrList = new ArrayList();
foreach (ColumnPDF c in element.Columns)
{
switch (c.TipoColonna)
{
case ColumnType.Testo:
case ColumnType.Decimale:
case ColumnType.Intero:
case ColumnType.Percentuale:
if (!string.IsNullOrEmpty(c.Name))
arrList.Add(c.Name);
break;
case ColumnType.Immagine:
case ColumnType.Objectpdf:
if (!string.IsNullOrEmpty(c.Id))
arrList.Add(c.Id);
break;
}
// Imposto la colonna a visible=false se la larghezza è pari a 0
c.Visibile = c.Width != 0;
}
var strArray = (string[])arrList.ToArray(typeof(string));
#region Settaggio DataSource
int numeroRigheInvisibili = 0;
int numeroRigheTotali;
if (element.DataSource == null)
{
#region Impostazione del datasource se non passato in input
var dtDataSource = new DataTable("DataSource");
// Creo le colonne del dtDataSource
foreach (var colonnaDataSource in element.Columns)
{
dtDataSource.Columns.Add(colonnaDataSource.Id);
}
for (int nRiga = 0; nRiga < element.RowsCount; nRiga++)
{
var drToAdd = dtDataSource.NewRow();
for (int nColonna = 0; nColonna < element.Columns.Count; nColonna++)
{
if (!string.IsNullOrEmpty(element.Cells[nColonna, nRiga].Value))
drToAdd[nColonna] = element.Cells[nColonna, nRiga].Value;
else
{
try
{
var formattedtextareaToPrint = (FormattedTextAreaPDF)element.Cells[nColonna, nRiga].ValueObject;
if (formattedtextareaToPrint != null)
drToAdd[nColonna] = formattedtextareaToPrint.Text;
}
catch (Exception)
{
drToAdd[nColonna] = string.Empty;
}
}
}
if (element.Row[nRiga].Visible)
dtDataSource.Rows.Add(drToAdd);
}
element.DataSource = dtDataSource;
numeroRigheTotali = element.DataSource.Rows.Count;
#endregion
}
else
{
#region Impostazione del datasource se passato in input
#region Aggiunta manuale dei dati relativi alle colonne di tipo RISORSEEMBEDDED
// Controllo se sono state aggiunte colonne di tipo IMMAGINE o OBJECTPDF.
// Le colonne IMMAGINE con un "Name" impostato vengono escluse dall'aggiunta manuale. [In questo modo nella colonna verrà rendirizzata l'immagine definita del datasource, ad esempio "riseva.png, liquidita.png, etc"]
var columnsEmbeddedOrObject = element.Columns.FindAll(col => col.TipoColonna == ColumnType.Objectpdf || (col.TipoColonna == ColumnType.Immagine && col.Name == string.Empty));
if (columnsEmbeddedOrObject.Count > 0)
{
foreach (ColumnPDF column in columnsEmbeddedOrObject)
element.DataSource.Columns.Add(column.Id);
}
#endregion
// imposto il datasource
element.DataSource = element.DataSource.DefaultView.ToTable(false, strArray);
if (columnsEmbeddedOrObject.Count > 0)
{
for (int nRiga = 0; nRiga < element.RowsCount; nRiga++)
{
for (int nColonna = 0; nColonna < element.Columns.Count; nColonna++)
{
if (!string.IsNullOrEmpty(element.Cells[nColonna, nRiga].Value))
element.DataSource.Rows[nRiga][nColonna] = element.Cells[nColonna, nRiga].Value;
}
}
}
numeroRigheTotali = element.DataSource.Rows.Count;
// elimino le righe rese invisibili.
for (int nRiga = element.RowsCount - 1; nRiga >= 0; nRiga--)
{
if (element.Row[nRiga].Visible == false)
{
element.DataSource.Rows[nRiga].Delete();
element.DataSource.AcceptChanges();
numeroRigheInvisibili++;
}
}
#endregion
}
#region Merge da Cell.Value
// Tutto ciò che è impostato a livello di Cell deve essere riportato nel DataSource
for (int col = 0; col < element.DataSource.Columns.Count; col++)
{
for (int row = 0; row < element.DataSource.Rows.Count; row++)
{
if (!string.IsNullOrEmpty(element.Cells[col, row].Value))
{
element.DataSource.Rows[row][col] = element.Cells[col, row].Value;
}
}
}
#endregion
#endregion
#endregion
#region Righe alternate con sfondo bianco a sfondo grigio
if (element.AlternateRow)
{
for (int i = 0; i < element.Row.Length; i++)
{
if (i % 2 != 0)
element.Row[i].BackgroundGray = true;
}
}
#endregion
#region Recupero le note, associate alla tabella, da inserire sotto il footer della tabella e nel footer della pagina
#region Note footer della pagina
var notesFooterPage = element.Notes.FindAll(o => o.Position == TableNotePDF.TableNotePositionType.PièDiPagina);
if (notesFooterPage.Count > 0)
YLowerLimit -= _spacenotefooterpagePerpage + (notesFooterPage.Count * notesFooterPage[0].FontSize) * 2;
else
YLowerLimit -= _spacenotefooterpagePerpage;
#endregion
#region Note footer della tabella
var notesFooterTable = element.Notes.FindAll(o => o.Position == TableNotePDF.TableNotePositionType.PièDiTabella);
float variabileAltezzaTabellaPerPresenzaNote = element.AdditionalSpaceBelow;
foreach (var note in notesFooterTable)
{
variabileAltezzaTabellaPerPresenzaNote += GetTextHeigth(note.Text, XRightLimit - XLeftLimit, note.FontSize);
if (note.Image != null)
variabileAltezzaTabellaPerPresenzaNote += 10; // ulteriore 10 se la nota contiene immagine
}
#endregion
var arrayAsterischiNote_Intestazione = new string[1, element.DataSource.Columns.Count]; // array di righe e colonne dell'intestazione della tabella dove sono contenuti gli asterischi
var arrayAsterischiNote_Corpo = new string[element.DataSource.Rows.Count, element.DataSource.Columns.Count]; // array di righe e colonne del dettaglio della tabella dove sono contenuti gli asterischi
var arrayAsterischiNote_PieDiPagina = new string[1, element.FooterColumns.Count]; // array di righe e colonne del footer della tabella dove sono contenuti gli asterischi
foreach (TableNotePDF note in element.Notes)
{
if (note.TypeMarker == TableNotePDF.TableNoteTypemarker.Asterisco)
{
if (note.AsterisksPosition == TableNotePDF.TableNoteAsteriskPositionType.CorpoTabella)
{
#region Asterischi del dettaglio della tabella
var rowNoteFooterTable = dataSourceInput.Select(note.Condition); //element.DataSource.Select(note.Condition);
if (rowNoteFooterTable.Length.Equals(0))
{
notesFooterTable.Remove(note); //Rimuovo le note che non trovano corrispondenza.
continue;
}
if (note.MappingFields != null)
{
// ToLower di tutti gli elementi memorizzati in ListIdColumnsAssociatedNote.
for (int i = 0; i < note.MappingFields.Length; i++)
note.MappingFields[i] = note.MappingFields[i].ToLower();
foreach (var row in rowNoteFooterTable)
{
int indiceColonna = 0;
int indiceRiga;
foreach (ColumnPDF column in element.Columns)
{
switch (note.MappingType)
{
case TableNotePDF.TableNoteMappingType.Fisso:
indiceRiga = dataSourceInput.Rows.IndexOf(row);
if (note.MappingFields.Contains(column.Id.ToLower()))
{
if (string.IsNullOrEmpty(arrayAsterischiNote_Corpo[indiceRiga, indiceColonna]))
arrayAsterischiNote_Corpo[indiceRiga, indiceColonna] = TableNotePDF.ToAsteriskString(GetAsterisksNumber(note));
else
arrayAsterischiNote_Corpo[indiceRiga, indiceColonna] += " " + TableNotePDF.ToAsteriskString(GetAsterisksNumber(note));
}
break;
case TableNotePDF.TableNoteMappingType.Dinamico:
bool astericoPresente = false;
indiceRiga = new DataView(dataSourceInput).ToTable(false, new[] { note.MappingKey })
.AsEnumerable()
.Select(riga => riga.Field<Int32>(note.MappingKey))
.ToList()
.FindIndex(o => o == Convert.ToInt32(row[note.MappingKey]));
//Recupero la ConditionFields che ha il nome che inizia con column.Id
var campo = note.ConditionFields.FirstOrDefault(o => o.ToLower().StartsWith(column.Id.ToLower()));
if (campo != null)
astericoPresente = Convert.ToInt32(dataSourceInput.Rows[indiceRiga][campo]) == note.ConditionValue;
if (astericoPresente)
{
if (string.IsNullOrEmpty(arrayAsterischiNote_Corpo[indiceRiga, indiceColonna]))
arrayAsterischiNote_Corpo[indiceRiga, indiceColonna] = TableNotePDF.ToAsteriskString(GetAsterisksNumber(note));
else
arrayAsterischiNote_Corpo[indiceRiga, indiceColonna] += " " + TableNotePDF.ToAsteriskString(GetAsterisksNumber(note));
}
break;
}
indiceColonna++;
}
}
}
#endregion
}
else if (note.AsterisksPosition == TableNotePDF.TableNoteAsteriskPositionType.IntestazioneTabella)
{
#region Asterischi dell'intestazione della tabella
if (note.MappingFields != null)
{
// ToLower di tutti gli elementi memorizzati in ListIdColumnsAssociatedNote.
for (int i = 0; i < note.MappingFields.Length; i++)
note.MappingFields[i] = note.MappingFields[i].ToLower();
int indiceColonna = 0;
foreach (ColumnPDF column in element.Columns)
{
if (note.MappingFields.Contains(column.Id.ToLower()))
arrayAsterischiNote_Intestazione[0, indiceColonna] = TableNotePDF.ToAsteriskString(GetAsterisksNumber(note));
indiceColonna++;
}
}
#endregion
}
else if (note.AsterisksPosition == TableNotePDF.TableNoteAsteriskPositionType.PieDiTabella)
{
#region Asterischi del footer della tabella
if (note.MappingFields != null)
{
// ToLower di tutti gli elementi memorizzati in ListIdColumnsAssociatedNote.
for (int i = 0; i < note.MappingFields.Length; i++)
note.MappingFields[i] = note.MappingFields[i].ToLower();
int indiceColonna = 0;
foreach (ColumnPDF column in element.FooterColumns)
{
if (note.MappingFields.Contains(column.Id.ToLower()))
arrayAsterischiNote_PieDiPagina[0, indiceColonna] = TableNotePDF.ToAsteriskString(GetAsterisksNumber(note));
indiceColonna++;
}
}
#endregion
}
}
else
{
if (note.AsterisksPosition == TableNotePDF.TableNoteAsteriskPositionType.CorpoTabella)
{
#region Asterischi del dettaglio della tabella
var rowNoteFooterTable = dataSourceInput.Select(note.Condition); //element.DataSource.Select(note.Condition);
if (rowNoteFooterTable.Length.Equals(0))
{
notesFooterTable.Remove(note); //Rimuovo le note che non trovano corrispondenza.
continue;
}
if (note.MappingFields != null)
{
// ToLower di tutti gli elementi memorizzati in ListIdColumnsAssociatedNote.
for (int i = 0; i < note.MappingFields.Length; i++)
note.MappingFields[i] = note.MappingFields[i].ToLower();
foreach (var row in rowNoteFooterTable)
{
int indiceColonna = 0;
int indiceRiga;
foreach (ColumnPDF column in element.Columns)
{
switch (note.MappingType)
{
case TableNotePDF.TableNoteMappingType.Fisso:
indiceRiga = dataSourceInput.Rows.IndexOf(row);
if (note.MappingFields.Contains(column.Id.ToLower()))
{
if (string.IsNullOrEmpty(arrayAsterischiNote_Corpo[indiceRiga, indiceColonna]))
arrayAsterischiNote_Corpo[indiceRiga, indiceColonna] = TableNotePDF.ToNumberAsteriskString(GetAsterisksNumber(note));
else
arrayAsterischiNote_Corpo[indiceRiga, indiceColonna] += " " + TableNotePDF.ToNumberAsteriskString(GetAsterisksNumber(note));
}
break;
case TableNotePDF.TableNoteMappingType.Dinamico:
bool astericoPresente = false;
indiceRiga = new DataView(dataSourceInput).ToTable(false, new[] { note.MappingKey })
.AsEnumerable()
.Select(riga => riga.Field<Int32>(note.MappingKey))
.ToList()
.FindIndex(o => o == Convert.ToInt32(row[note.MappingKey]));
//Recupero la ConditionFields che ha il nome che inizia con column.Id
var campo = note.ConditionFields.FirstOrDefault(o => o.ToLower().StartsWith(column.Id.ToLower()));
if (campo != null)
astericoPresente = Convert.ToInt32(dataSourceInput.Rows[indiceRiga][campo]) == note.ConditionValue;
if (astericoPresente)
{
if (string.IsNullOrEmpty(arrayAsterischiNote_Corpo[indiceRiga, indiceColonna]))
arrayAsterischiNote_Corpo[indiceRiga, indiceColonna] = TableNotePDF.ToNumberAsteriskString(GetAsterisksNumber(note));
else
arrayAsterischiNote_Corpo[indiceRiga, indiceColonna] += " " + TableNotePDF.ToNumberAsteriskString(GetAsterisksNumber(note));
}
break;
}
indiceColonna++;
}
}
}
#endregion
}
else if (note.AsterisksPosition == TableNotePDF.TableNoteAsteriskPositionType.IntestazioneTabella)
{
#region Asterischi dell'intestazione della tabella
if (note.MappingFields != null)
{
// ToLower di tutti gli elementi memorizzati in ListIdColumnsAssociatedNote.
for (int i = 0; i < note.MappingFields.Length; i++)
note.MappingFields[i] = note.MappingFields[i].ToLower();
int indiceColonna = 0;
foreach (ColumnPDF column in element.Columns)
{
if (note.MappingFields.Contains(column.Id.ToLower()))
arrayAsterischiNote_Intestazione[0, indiceColonna] = TableNotePDF.ToNumberAsteriskString(GetAsterisksNumber(note));
indiceColonna++;
}
}
#endregion
}
else if (note.AsterisksPosition == TableNotePDF.TableNoteAsteriskPositionType.PieDiTabella)
{
#region Asterischi del footer della tabella
if (note.MappingFields != null)
{
// ToLower di tutti gli elementi memorizzati in ListIdColumnsAssociatedNote.
for (int i = 0; i < note.MappingFields.Length; i++)
note.MappingFields[i] = note.MappingFields[i].ToLower();
int indiceColonna = 0;
foreach (ColumnPDF column in element.FooterColumns)
{
if (note.MappingFields.Contains(column.Id.ToLower()))
arrayAsterischiNote_PieDiPagina[0, indiceColonna] = TableNotePDF.ToNumberAsteriskString(GetAsterisksNumber(note));
indiceColonna++;
}
}
#endregion
}
}
}
#endregion
#region Recupero le altezze di ogni riga e popolo la rowsHeightList
float rowHeight; // altezza calcolata della riga corrente;
foreach (DataRow dr in element.DataSource.Rows)
{
rowHeight = element.RowHeight; // altezza calcolata della riga corrente;
columnIndex = 0;
foreach (DataColumn dc in element.DataSource.Columns)
{
var testoCella = string.Format("{0}{1}", dr[dc], arrayAsterischiNote_Corpo[rowIndex, columnIndex] ?? string.Empty);
var fontBold = false;
if (element.DataSource.Columns.Contains("FontBold"))
fontBold = Convert.ToBoolean(dr["FontBold"]);
float tempRowHeight = GetTextHeigth(testoCella,
element.Columns[columnIndex].Width - element.Columns[columnIndex].PaddingLeft,
element.Columns[columnIndex].FontSize,
fontBold,
element.Columns[columnIndex].TipoColonna); // altezza calcolata della riga corrente;
rowHeight = tempRowHeight > rowHeight ? tempRowHeight : rowHeight;
if (element.MinimumRowHeight > 0)
rowHeight = rowHeight < element.MinimumRowHeight ? element.MinimumRowHeight : rowHeight;
columnIndex++;
}
if (element.SpecifiedRowHeights.Count > rowIndex)
{
rowHeight = element.SpecifiedRowHeights[rowIndex];
}
//Aggiungo alla lista
rowsHeightList.Add(rowHeight);
rowIndex++;
}
rowIndex = 0;
columnIndex = 0;
#endregion
float y = element.Y;
float yTextToPrint = y + variabileAltezzaTabellaPerPresenzaNote;
float xTextToPrint;
bool autoincrementY = true;
bool printedTitleRow = false; // il title row di una tabella deve essere stampato una sola volta, anche se la tabella effettuta un salto pagina
_printinginnewpage = true;
#region Stampo l'Header della tabella se sono state rese invisibili tutte le righe del datasource
if (numeroRigheInvisibili == numeroRigheTotali) // in questo caso devo stampare comunque l'header della tabella.
{
TablePDF_DrawHeader(element, arrayAsterischiNote_Intestazione);
y = _ywritable;
y += element.HeaderHeight + element.HeaderMargin;
}
#endregion
foreach (DataRow dr in element.DataSource.Rows) // Scorro tutte le righe del DataSource
{
float x = element.X;
if (element.Y > YLowerLimit)
_ywritable = YUpperLimit;
// --- Patryk: RowsIndexesThatCantEndPage
// Ernesto Usare questo per Salto Pagina
if (element.RowsIndexesThatCantEndPage.Count() > 0 &&
element.RowsIndexesThatCantEndPage.Contains(rowIndex) &&
yTextToPrint > element.RowsIndexesThatCantEndPageYLimit &&
element.RowsIndexesThatCantEndPageYLimit != 0)
//if (element.RowsIndexesThatCantEndPage.Count() > 0 &&
// element.RowsIndexesThatCantEndPage.Contains(rowIndex) &&
// _ywritable > element.RowsIndexesThatCantEndPageYLimit &&
// element.RowsIndexesThatCantEndPageYLimit != 0)
{
WriteElement(new LinePDF(element.X, y, element.X + element.Width, y, 0.5F, new ColorPDF(153, 148, 133))); // lineaOrizzontale
WriteNoteFooterPage(notesFooterPage);
TablePDF_ContinuedOnNextPage();
}
// ---------------------------------------
#region Recupero altezza massima della riga corrente e quella successiva (necessario per il salto pagina)
rowHeight = rowsHeightList[rowIndex];
float nextRowHeight = rowIndex == rowsHeightList.Count - 1 ? 0 : rowsHeightList[rowIndex + 1]; // altezza temporanea della riga successiva;
#endregion
#region Salto pagina su ultime 2 righe della tabella
// Se sto per stampare le ultime 2 righe, e la tabella contiene un footer, controllo che
// il footer sia contenuto comunque nella pagina corrente, altrimenti ne aggiungo 1 e
// gli elementi restanti (2 righe + footer) vengono stampati nella nuova pagina.
// Considero anche la possibilità che la tabella abbia note aggiuntive sotto al footer
float variabilePerPresenzaTitleRow = 0;
float variabilePerPresenzaFooterDatasource = 0;
if (rowIndex == element.DataSource.Rows.Count - 2 &&
element.Footer &&
element.PageBreak)
{
//variabileAltezzaTabellaPerPresenzaNota = 10 * notesFooterTable.Count;
variabilePerPresenzaTitleRow = element.TitleRow ? element.TitleRowHeight + element.TitleRowSpace : 0;
variabilePerPresenzaFooterDatasource = element.FooterDatasource != null ? element.FooterHeight * element.FooterDatasource.Rows.Count : element.FooterHeight;
if (y + (rowHeight + nextRowHeight) + variabilePerPresenzaFooterDatasource + variabileAltezzaTabellaPerPresenzaNote + variabilePerPresenzaTitleRow + 10 > YLowerLimit) //+ 10: ulteriore margine di sicurezza per evitare sforamenti
{
if (element.ShowBorderLastLineInPageBreak)
WriteElement(new LinePDF(element.X, y, element.X + element.Width, y, 0.5F, new ColorPDF(153, 148, 133))); // lineaOrizzontale
_ywritable = YLowerLimit;
// Controllo qui se la tabella ha solamente 2 righe.
// In tal caso non disegno ne le note nel footer ne il salto pagina ma vado direttamente a pagina nuova.
if (!element.DataSource.Rows.Count.Equals(2))
{
WriteNoteFooterPage(notesFooterPage);
TablePDF_ContinuedOnNextPage();
}
y = _ywritable;
element.Y = y;
rowIndexPerPage = -1;
}
}
#endregion
#region Disegno il TitleRow ( Titolo sopra l'Header della tabella )
if (element.TitleRow && _printinginnewpage && printedTitleRow == false)
{
if (_reportEnvironment.ReportType == ReportType.Base_Proposta)
{
printedTitleRow = TablePDF_DrawTitleRow(element);
y = _ywritable;
}
else
{
printedTitleRow = TablePDF_DrawTitleRow(element, true);
y = _ywritable;// +element.TitleRowHeight;
}
}
#endregion
#region Disegno dell'Header della tabella
if (element.Header && _printinginnewpage)
{
TablePDF_DrawHeader(element, arrayAsterischiNote_Intestazione);
y = _ywritable;
y += element.HeaderHeight + element.HeaderMargin;
}
#endregion
#region Disegno il BorderContent
if (element.ShowBorderContent)
{
if (rowIndex == 0) // Disegno il bordo sulla prima riga
{
if (element.ShowBorderFooter)
{
//bordoSuperiore
WriteElement(new LinePDF(element.X - 1, ((element.X - 1) + element.Width + 1)) { AutoIncrementYWritable = false, DeltaY = -1 });
//bordoSuperioreSinistro
WriteElement(new LinePDF(element.X - 1, element.X - 1) { AutoIncrementYWritable = false, DeltaY2ForVerticalLine = 10 });
//bordoSuperioreDestro
WriteElement(new LinePDF((element.X - 1) + (element.Width + 1) + 1, (element.X - 1) + (element.Width + 1) + 1) { AutoIncrementYWritable = false, DeltaY2ForVerticalLine = 10 });
}
}
else if (rowIndex == element.DataSource.Rows.Count - 1) // Disegno il bordo sull'ultima riga
{
//bordoInferiore
WriteElement(new LinePDF(element.X - 1, y + rowHeight, ((element.X - 1) + element.Width + 1), y + rowHeight) { AutoIncrementYWritable = false, DeltaY = -1 });
//bordoInferioreSinistro
WriteElement(new LinePDF(element.X - 1, y + rowHeight, element.X - 1, y + rowHeight) { AutoIncrementYWritable = false, DeltaY2ForVerticalLine = -10 });
//bordoInferioreDestro
WriteElement(new LinePDF((element.X - 1) + (element.Width + 1) + 1, y + rowHeight, (element.X - 1) + (element.Width + 1) + 1, y + rowHeight) { AutoIncrementYWritable = false, DeltaY2ForVerticalLine = -10 });
}
}
#endregion
// -start
foreach (DataColumn dc in element.DataSource.Columns) // Scorro tutte le colonne del DataSource
{
// Il testo della cella è recuperato dalla relativa colonna del DataSource
var testoCella = string.Format("{0}{1}", dr[dc], arrayAsterischiNote_Corpo[rowIndex, columnIndex] ?? string.Empty);
// Recupero il testo della cella dalla collezione Cells se specificato un value.
if (!string.IsNullOrEmpty(element.Cells[columnIndex, rowIndex].Value))
testoCella = element.Cells[columnIndex, rowIndex].Value;
#region Gestione del ColSpan della cella e ridefinizione della larghezza della colonna.
if (element.Cells[columnIndex, rowIndex].ColSpan > 0)
{
int countcolumnspan = element.Cells[columnIndex, rowIndex].ColSpan;//quante colonne compongono il colspan inclusa la cella che ha la proprietà
if ((columnIndex + countcolumnspan) > element.Columns.Count)
throw new Exception("TablePDF: ColSpan non può essere maggiore del numero di colonne");
for (int f = 1; f < countcolumnspan; f++)
{
//aumento la larghezza della colonna corrente (columnIndex) con la somma delle altre colonne interessate da colspan
element.Columns[columnIndex].Width += element.Columns[columnIndex + f].Width;
// Azzero tutte le restanti interessate dal colspan
element.Columns[columnIndex + f].Width = 0;
element.Columns[columnIndex + f].Visibile = false;
}
}
#endregion
#region Allineamento orizzontale
// Allineamento preso a livello di colonna
var textHorizontalAlign = GetTextAlign(element.Columns[columnIndex].HorizontalAlignment);
// Allineamento preso a livello di cella
if (element.Cells[columnIndex, rowIndex].HorizontalAlignment != HorizontalAlignmentType.Nonimpostato)
textHorizontalAlign = GetTextAlign(element.Cells[columnIndex, rowIndex].HorizontalAlignment);
#endregion
#region Allineamento verticale e recupero della Y su cui scrivere la riga
switch (element.Columns[columnIndex].VerticalAlignment)
{
case VerticalAlignmentType.Alto:
yTextToPrint = y + element.Columns[columnIndex].DeltaYContent;
break;
case VerticalAlignmentType.Basso:
yTextToPrint = y + rowHeight - element.Columns[columnIndex].FontSize;
break;
case VerticalAlignmentType.Centrato:
var fontBold = false;
if (element.DataSource.Columns.Contains("FontBold"))
fontBold = Convert.ToBoolean(dr["FontBold"]);
float textHeight = GetTextHeigth(
testoCella,
element.Columns[columnIndex].Width - element.Columns[columnIndex].PaddingLeft,
element.Columns[columnIndex].FontSize,
fontBold,
element.Columns[columnIndex].TipoColonna);
float delta = textHeight == 0 ? 0 : rowHeight - textHeight;
yTextToPrint = y + (delta / 2) + element.Columns[columnIndex].DeltaYContent; // + incrementWidthSeparationLines;
break;
}
#endregion
var colorRectangleBackground = ColorPDF.Bianco; // Bianco di default
#region BackgroundGray della riga
if (element.Row[rowIndex].BackgroundColor != null)
colorRectangleBackground = element.Row[rowIndex].BackgroundColor;
if (element.Row[rowIndex].BackgroundGray)
colorRectangleBackground = ColorPDF.Standard_Grigio_SfondoColonnaTabella;
// Disegno lo sfondo grigio se impostata la proprietà BackgroundGray dell'oggetto Row.
if (element.Row[rowIndex].BackgroundGray || element.Row[rowIndex].BackgroundColor != null)
WriteElement(new RectanglePDF(x, y, rowHeight + element.RowsPadding, element.Columns[columnIndex].Width, colorRectangleBackground) { AutoIncrementYWritable = false }); // x+1 per evitare che il riquadro grigio copra il testo
#endregion
//start2
#region BackgroundGray e BackgroundColor della colonna
// Aggiungo un rettangolo di sfondo (BackgroundGray o BackgroundColor) della COLONNA.
if (element.Columns[columnIndex].BackgroundGray || element.Columns[columnIndex].BackgroundColor != null)
{
colorRectangleBackground = element.Columns[columnIndex].BackgroundColor;
if (element.Columns[columnIndex].BackgroundGray)
colorRectangleBackground = ColorPDF.Standard_Grigio_SfondoColonnaTabella;
RectanglePDF rectangleBackground = null;
if (element.WhiteSpacesHorizontalSeparator)
{
rectangleBackground = new RectanglePDF(x, y, rowHeight - 3, element.Columns[columnIndex].Width, colorRectangleBackground) { AutoIncrementYWritable = false };
}
else
{
rectangleBackground = new RectanglePDF(x, y, rowHeight, element.Columns[columnIndex].Width, colorRectangleBackground) { AutoIncrementYWritable = false };
}
// Se è impostato un BackgroundColor sulla colonna, rectangleBackground avrà Height pari a Height + RowsPadding,
// in modo da riempire completamente la colonna senza lasciare spazi bianchi.
if (element.Columns[columnIndex].BackgroundColor != null)
{
rectangleBackground.Height += element.RowsPadding + 1;
}
rectangleBackground.Height += element.RowsHeightOffset;
if (!element.RowsIndexesThatIgnoreColumnBackgroundColor.Contains(rowIndex))
{
WriteElement(rectangleBackground);
}
}
#endregion
#region BackgroundGray e BackgroundColor della cella
// Aggiungo un rettangolo di sfondo (BackgroundColor) della CELLA.
if (element.Cells[columnIndex, rowIndex].BackgroundColor != null)
{
colorRectangleBackground = element.Cells[columnIndex, rowIndex].BackgroundColor;
RectanglePDF rectangleBackground = null;
if (element.WhiteSpacesHorizontalSeparator)
{
// Quando è impostato un BackgroundColor sulla riga, rectangleBackground avrà Height pari a Height + RowsPadding,
// in modo da riempire completamente la riga senza lasciare spazi bianchi.
rectangleBackground = new RectanglePDF(x, y, rowHeight + element.RowsPadding - 1, element.Columns[columnIndex].Width, colorRectangleBackground) { AutoIncrementYWritable = false };
var rectangleWhiteSpace = new RectanglePDF(x, y + rectangleBackground.Height, 1, element.Columns[columnIndex].Width, new ColorPDF(255, 255, 255)) { AutoIncrementYWritable = true };
WriteElement(rectangleBackground);
WriteElement(rectangleWhiteSpace);
}
else
{
rectangleBackground = new RectanglePDF(x, y, rowHeight + element.RowsPadding + element.RowsHeightOffset + (element.RowsHeightOffset != 0 ? +1 : 0), element.Columns[columnIndex].Width, colorRectangleBackground) { AutoIncrementYWritable = false };
WriteElement(rectangleBackground);
}
}
#endregion
//end2
#region Disegno cella
// Disegno la cella. La cella è una FormattedTextAreaPDF
if (element.Columns[columnIndex].Visibile)
{
if ((element.Columns[columnIndex].TipoColonna == ColumnType.Testo ||
element.Columns[columnIndex].TipoColonna == ColumnType.Decimale ||
element.Columns[columnIndex].TipoColonna == ColumnType.Intero ||
element.Columns[columnIndex].TipoColonna == ColumnType.Percentuale) &&
!(dr[dc].ToString().ToLower().Contains("flags") && dr[dc].ToString().ToLower().Contains(".png")))
{
#region TIPO DI COLONNA TESTO o DECIMALE o INTERO o PERCENTUALE
// FormattedTextAreaPDF testo della singola cella.
var textToPrint = new FormattedTextAreaPDF();
var fontColor = ColorPDF.Nero;
switch (element.Style)
{
case Style.ConsulenzaBase:
case Style.ConsulenzaUnica:
fontColor = ColorPDF.Nero;
break;
case Style.Immobiliare:
fontColor = ColorPDF.Immobiliare_Grigio_TestoStandard; // Grigio
break;
default:
break;
}
bool fontBold = false;
var fontSize = 0F;
bool forcestylerow_fontbold = false;
bool forcestylerow_fontcolor = false;
bool forcestylecolumn_fontbold = false;
bool forcestylecolumn_fontcolor = false;
#region Attributi FontSize, FontBold, FontColor della RIGA
if (element.Row != null)
{
if (element.Row[rowIndex].FontBold.HasValue) // grassetto dell'intera riga (se specificato)
fontBold = element.Row[rowIndex].FontBold.Value;
if (element.Row[rowIndex].FontColor != null) // colore dell'intera riga (se specificato)
fontColor = element.Row[rowIndex].FontColor;
forcestylerow_fontbold = element.Row[rowIndex].ForceStyleFontBold;
forcestylerow_fontcolor = element.Row[rowIndex].ForceStyleFontColor;
}
#endregion
#region Attributi FontSize, FontBold, FontColor della COLONNA
forcestylecolumn_fontbold = element.Columns[columnIndex].ForceStyleFontBold;
forcestylecolumn_fontcolor = element.Columns[columnIndex].ForceStyleFontColor;
if (!forcestylerow_fontcolor || forcestylecolumn_fontcolor)
{
if (element.Columns[columnIndex].FontColor != null)
fontColor = element.Columns[columnIndex].FontColor;
}
if (!forcestylerow_fontbold || forcestylecolumn_fontbold)
{
if (element.Columns[columnIndex].FontBold.HasValue)
fontBold = element.Columns[columnIndex].FontBold.Value;
}
#endregion
#region Attributi FontSize, FontBold, FontColor della CELLA
fontSize = element.Columns[columnIndex].FontSize; // eredito quello della colonna.
if (!forcestylerow_fontcolor)
{
if (element.Cells[columnIndex, rowIndex].FontColor != null)
fontColor = element.Cells[columnIndex, rowIndex].FontColor;
}
if (!forcestylerow_fontbold)
{
if (element.Cells[columnIndex, rowIndex].FontBold.HasValue)
fontBold = element.Cells[columnIndex, rowIndex].FontBold.Value;
}
#endregion
// Testo della singola cella.
var stringTextToPrint = string.Empty;
switch (element.Columns[columnIndex].TipoColonna)
{
case ColumnType.Testo:
stringTextToPrint = testoCella;
if (element.Cells[columnIndex, rowIndex].ReplaceIfZero != string.Empty)
if (testoCella.Equals("0,00"))
stringTextToPrint = testoCella.Replace("0,00", element.Cells[columnIndex, rowIndex].ReplaceIfZero);
break;
case ColumnType.Decimale:
stringTextToPrint = element.Cells[columnIndex, rowIndex].ReplaceIfZero != string.Empty
? Convert.ToDecimal(testoCella).Equals(0) ? element.Cells[columnIndex, rowIndex].ReplaceIfZero : Helper.FormatCurrency(testoCella)
: Helper.FormatCurrency(testoCella);
break;
case ColumnType.Intero:
stringTextToPrint = element.Cells[columnIndex, rowIndex].ReplaceIfZero != string.Empty
? Convert.ToDecimal(testoCella).Equals(0) ? element.Cells[columnIndex, rowIndex].ReplaceIfZero : Helper.FormatInteger(testoCella)
: Helper.FormatInteger(testoCella);
break;
case ColumnType.Percentuale:
stringTextToPrint = Helper.FormatPercentage(testoCella, 2);
break;
}
// Incremento della X a livello di Colonna.
// Se è impostato un allineamento a livello di Cella, l'incremento viene fatto solo se tale allineamento è Nonimpostato oppure Sinistra.
if (element.Cells[columnIndex, rowIndex].HorizontalAlignment == HorizontalAlignmentType.Nonimpostato ||
element.Cells[columnIndex, rowIndex].HorizontalAlignment == HorizontalAlignmentType.Sinistra)
xTextToPrint = TablePDF_GetXTextContent(x + element.Columns[columnIndex].PaddingLeft, columnIndex, element);
else
xTextToPrint = x + element.Columns[columnIndex].PaddingLeft;
xTextToPrint += element.Cells[columnIndex, rowIndex].XContentOffset;
textToPrint = new FormattedTextAreaPDF(stringTextToPrint,
xTextToPrint,
element.Columns[columnIndex].Width - element.Columns[columnIndex].PaddingLeft - element.Columns[columnIndex].PaddingRight,
textHorizontalAlign)
{
Y = yTextToPrint + element.Cells[columnIndex, rowIndex].YContentOffset,
FontSize = fontSize,
FontColor = fontColor,
FontBold = fontBold,
AutoIncrementYWritable = autoincrementY
};
//Scrivo il testo.
WriteElement(textToPrint);
#endregion
}
else if (element.Columns[columnIndex].TipoColonna == ColumnType.Immagine ||
(dr[dc].ToString().ToLower().Contains("flags") && dr[dc].ToString().ToLower().Contains(".png")))
{
#region TIPO DI COLONNA IMMAGINE
ImagePDF imageToPrint;
if (dr[dc].ToString() != string.Empty)
{
#region Allineamento orizzontale dell'immagine
float xImmagine = x;
Align imageAlignX;
switch (textHorizontalAlign)
{
case TextAlign.Center:
imageAlignX = Align.Center;
xImmagine = xImmagine + (element.Columns[columnIndex].Width / 2);
break;
case TextAlign.Left:
imageAlignX = Align.Left;
break;
case TextAlign.Right:
imageAlignX = Align.Right;
xImmagine = xImmagine + element.Columns[columnIndex].Width;
break;
default:
imageAlignX = Align.Left;
break;
}
#endregion
xTextToPrint = xImmagine + element.Columns[columnIndex].PaddingLeft;
imageToPrint = new ImagePDF(TablePDF_GetXTextContent(xTextToPrint, columnIndex, element), element.Columns[columnIndex].ScaleColumnTypeImage, dr[dc].ToString(), imageAlignX, yTextToPrint + element.Columns[columnIndex].PaddingTopImage);
//float deltaYOffset = 0;
//switch (element.Columns[columnIndex].VerticalAlignment)
//{
// case VerticalAlignmentType.Centrato:
// var testElement = new Image(imageToPrint.Path, 0, 0, imageToPrint.Scale);
// deltaYOffset = (rowHeight - testElement.Height) / 2;
// break;
//}
//imageToPrint.DeltaY += deltaYOffset;
WriteElement(imageToPrint);
}
#endregion
}
else if (element.Columns[columnIndex].TipoColonna == ColumnType.Objectpdf)
{
#region TIPO DI COLONNA OBJECTPDF
var itemsList = element.Cells[columnIndex, rowIndex].ValueObjectList;
if (!itemsList.Any())
if (element.Cells[columnIndex, rowIndex].ValueObject != null)
itemsList.Add(element.Cells[columnIndex, rowIndex].ValueObject);
// Disegno l'oggetto PDF associato alla proprietà ValuePDF dell'oggetto Cella ( RectanglePDF o CirclePDF ).
// Per ora si possono aggiungere solo RectanglePDF, CirclePDF, FormattedTextAreaPDF se dovesse esserci necessità andrà migliorata la funzionalità.
if (itemsList.Any())
{
foreach (var item in itemsList)
{
var parameterType = item.GetType();
string name = parameterType.Name;
switch (name.ToLower())
{
case "rectanglepdf":
{
var rectToPrint = (RectanglePDF)item;
#region Allineamento orizzontale
var xObjectPdf = 0F;
switch (element.Columns[columnIndex].HorizontalAlignment)
{
case HorizontalAlignmentType.Nonimpostato:
case HorizontalAlignmentType.Sinistra:
xObjectPdf = x + element.Columns[columnIndex].PaddingLeft;
break;
case HorizontalAlignmentType.Centrato:
xObjectPdf = ((x + element.Columns[columnIndex].Width / 2) - (rectToPrint.Width / 2)) + element.Columns[columnIndex].PaddingLeft;
break;
case HorizontalAlignmentType.Destra:
xObjectPdf = x + element.Columns[columnIndex].Width - rectToPrint.Width;
break;
}
#endregion
rectToPrint.X = xObjectPdf;
rectToPrint.X += rectToPrint.DeltaX;
rectToPrint.Y = yTextToPrint + rectToPrint.DeltaY;
rectToPrint.AutoIncrementYWritable = false;
WriteElement(rectToPrint);
}
break;
case "circlepdf":
{
var circleToPrint = (CirclePDF)item;
#region Allineamento orizzontale
var xObjectPdf = 0F;
switch (element.Columns[columnIndex].HorizontalAlignment)
{
case HorizontalAlignmentType.Nonimpostato:
case HorizontalAlignmentType.Sinistra:
xObjectPdf = x + element.Columns[columnIndex].PaddingLeft;
break;
case HorizontalAlignmentType.Centrato:
break;
case HorizontalAlignmentType.Destra:
xObjectPdf = x + element.Columns[columnIndex].Width - circleToPrint.Width;
break;
}
#endregion
circleToPrint.X = xObjectPdf;
circleToPrint.Y = yTextToPrint + circleToPrint.DeltaY;
circleToPrint.AutoIncrementYWritable = false;
WriteElement(circleToPrint);
}
break;
case "formattedtextareapdf":
{
var formattedtextareaToPrint = (FormattedTextAreaPDF)item;
#region Allineamento orizzontale
var xObjectPdf = 0F;
switch (element.Columns[columnIndex].HorizontalAlignment)
{
case HorizontalAlignmentType.Nonimpostato:
case HorizontalAlignmentType.Sinistra:
xObjectPdf = x + element.Columns[columnIndex].PaddingLeft;
break;
case HorizontalAlignmentType.Centrato:
break;
case HorizontalAlignmentType.Destra:
xObjectPdf = x + element.Columns[columnIndex].Width - formattedtextareaToPrint.Width;
break;
}
#endregion
formattedtextareaToPrint.X = xObjectPdf;
formattedtextareaToPrint.Y = yTextToPrint + formattedtextareaToPrint.DeltaY;
formattedtextareaToPrint.AutoIncrementYWritable = false;
WriteElement(formattedtextareaToPrint);
}
break;
case "imagepdf":
{
var imageToPrint = (ImagePDF)item;
#region Allineamento orizzontale
var xObjectPdf = 0F;
switch (element.Columns[columnIndex].HorizontalAlignment)
{
case HorizontalAlignmentType.Nonimpostato:
case HorizontalAlignmentType.Sinistra:
xObjectPdf = x + element.Columns[columnIndex].PaddingLeft;
break;
case HorizontalAlignmentType.Centrato:
xObjectPdf = ((x + element.Columns[columnIndex].Width / 2) - (imageToPrint.Width / 2)) + element.Columns[columnIndex].PaddingLeft;
break;
case HorizontalAlignmentType.Destra:
xObjectPdf = x + element.Columns[columnIndex].Width - imageToPrint.Width;
break;
}
#endregion
imageToPrint.X = xObjectPdf;
imageToPrint.X += imageToPrint.DeltaX;
imageToPrint.Y = yTextToPrint + imageToPrint.DeltaY;
imageToPrint.AutoIncrementYWritable = false;
WriteElement(imageToPrint);
}
break;
}
}
}
#endregion
}
#region Linee di separazione delle righe (ShowSeparationLines)
if (element.ShowSeparationLines)
{
if (!element.IndexesOfSeparatorsToIgnore.Contains(columnIndex))
{
if (!element.IndexesOfRowLinesToIgnoreSeparators.Contains(rowIndex))
{
var colorSeparationLine = element.Columns[columnIndex].BackgroundGray ? ColorPDF.Bianco : ColorPDF.Standard_Grigio_SfondoColonnaTabella;
if (element.Cells[columnIndex, rowIndex].HorizontalSeparatorColor != null)
{
colorSeparationLine = element.Cells[columnIndex, rowIndex].HorizontalSeparatorColor;
}
// linea separatrice
var separationLine = new RectanglePDF(x, y + rowHeight, element.WidthSeparationLines, element.Columns[columnIndex].Width, colorSeparationLine) { AutoIncrementYWritable = false };
if (y < YLowerLimit)
{
if (element.HideLastSeparationLine)
{
// Non viene disegnata la linea di separazione all'ultima riga
if (rowIndex != element.DataSource.Rows.Count - 1)
WriteElement(separationLine);
}
else if (element.HideFirstSeparationLine)
{
if (rowIndex != 0)
WriteElement(separationLine);
}
else
WriteElement(separationLine);
}
}
}
}
#endregion
#region Border della riga
// Disegno una riga in alto e una in basso che fanno da bordo alla riga
if (element.Row[rowIndex].Border)
{
bool drawBorder = !element.Row[rowIndex].ShowBorderInColumnImage == false && element.Columns[columnIndex].TipoColonna == ColumnType.Immagine;
if (drawBorder)
{
var colorBorderLine = ColorPDF.Nero;
switch (element.Style)
{
case Style.ConsulenzaBase:
case Style.ConsulenzaUnica:
colorBorderLine = ColorPDF.Nero;
break;
case Style.Immobiliare:
colorBorderLine = ColorPDF.Immobiliare_Grigio_TitoloPiccolo;
break;
default:
break;
}
if (element.Columns[columnIndex].BackgroundGray || element.Columns[columnIndex].BackgroundColor != null)
colorBorderLine = ColorPDF.Bianco; //Bianco
if (element.Row[rowIndex].BorderType == BorderRowType.Entrambi || element.Row[rowIndex].BorderType == BorderRowType.Alto)
{
// Linea superiore
if (rowIndexPerPage > 0) // la prima riga, essendo poco stotto la linea di chiusura della header della tabella, non viene disegnata.
WriteElement(new LinePDF(x, y - element.RowsPadding / 2, (float)(x + element.Columns[columnIndex].Width), y - element.RowsPadding / 2, 0.1F, colorBorderLine) { AutoIncrementYWritable = false });
}
if (element.Row[rowIndex].BorderType == BorderRowType.Entrambi || element.Row[rowIndex].BorderType == BorderRowType.Basso)
{
//// Linea inferiore
WriteElement(new LinePDF(x, y + rowHeight + (element.RowsPadding / 2), (float)(x + element.Columns[columnIndex].Width), y + rowHeight + (element.RowsPadding / 2), 0.1F, colorBorderLine) { AutoIncrementYWritable = false });
}
}
}
#endregion
x += element.Columns[columnIndex].Width;
}
#endregion
columnIndex++;
autoincrementY = false;
}
// -end
columnIndex = 0;
if (element.ID == "debug")
WriteElement(new LinePDF(element.X, y, element.X + element.Width, y, 1, ColorPDF.Rosso) { AutoIncrementYWritable = false });
// ******************* INCREMENTO DELLA Y ***************************
y += rowHeight + element.RowsPadding + (element.ShowSeparationLines ? element.WidthSeparationLines + 1 : 0);
// ******************* FINE INCREMENTO DELLA Y **********************
if (element.ID == "debug")
WriteElement(new LinePDF(element.X, y, element.X + element.Width, y, 1, ColorPDF.Giallo) { AutoIncrementYWritable = false });
#region Salto pagina e Stampa delle Note associate alla tabella da stampare a piè di pagina
#region Salto pagina forzato "CanLastRow"
bool pageBreakForced = false;
if (dataSourceInput != null && dataSourceInput.Columns.Contains("CanLastRow"))
{
// indica se la prossima riga che sarà stampata può essere l'ultima.
var prossimaPuoEssereUltimaRiga = true;
if (rowIndex + 1 <= dataSourceInput.Rows.Count - 1)
prossimaPuoEssereUltimaRiga = Convert.ToBoolean(dataSourceInput.Rows[rowIndex + 1]["CanLastRow"]);
if (prossimaPuoEssereUltimaRiga == false)
{
// Se la prossima riga non può essere l'ultima nella pagina devo anticipare il salto pagina e renderlo "forzato". (pageBreakForced)
// Controllo dunque:
// 1) la nextRowHeight abbia spazio a sufficienza per essere disegnata (*2 non è un calcolo corretto. Dovrei sapere quanto è alta la riga ancora successiva ma attualmente non è possibile.)
// 2) possibile salto pagina nel caso in cui le ultime 2 righe della tabella non entrino nella pagina corrente.
var altezzaProssimeRighe = rowsHeightList.Skip(rowIndex + 1).Take(2).Sum(); // Sommo l'altezza delle successive 2 righe (take 2) alla riga successiva a quella corrente (Skip rowIndex + 1)
var ySaltoPagina = y + altezzaProssimeRighe + variabilePerPresenzaFooterDatasource + variabileAltezzaTabellaPerPresenzaNote + variabilePerPresenzaTitleRow + 10;
pageBreakForced =
(ySaltoPagina > YLowerLimit) ||
((rowIndex + 2 == element.DataSource.Rows.Count - 2) && ySaltoPagina + altezzaProssimeRighe > YLowerLimit);
}
}
#endregion
// Verifico se l'altezza della prossima riga che dovrà essere scritta (nextRowHeight) supera il _ylowerlimit.
// Se supera il limite aggiungo una nuova pagina al documento e il resto della tabella verrà disegnata nella nuova pagina.
if ((y + nextRowHeight + 15 >= YLowerLimit && element.PageBreak) || pageBreakForced ||
(element.TableCantReachThisYPosition != 0 && y + nextRowHeight + 15 >= element.TableCantReachThisYPosition)) // +15 = spazio per scivere il testo di cambio pagina
{
if (element.ShowBorderLastLineInPageBreak)
WriteElement(new LinePDF(element.X, y, element.X + element.Width, y, 0.5F, new ColorPDF(153, 148, 133))); // lineaOrizzontale
if (element.ShowNotesFooterPageForAllPages)
WriteNoteFooterPage(notesFooterPage);
_ywritable = YLowerLimit;
// effettuo il saltopagina della tabella.
TablePDF_ContinuedOnNextPage();
y = _ywritable;
element.Y = y;
rowIndexPerPage = -1;
}
else if (rowIndex == element.DataSource.Rows.Count - 1) // sto stampando l'ultima riga e quindi stampo le Note associate alla tabella da stampare a piè di pagina
{
WriteNoteFooterPage(notesFooterPage);
_ywritable = y;
}
#endregion
#region Disegno il Border sull'ultima riga se richiesto e non è presente il footer
if (element.ShowBorderLastLine && element.Footer == false && rowIndex == element.DataSource.Rows.Count - 1)
{
switch (element.Style)
{
case Style.ConsulenzaBase:
WriteElement(new LinePDF(element.X, y, element.Width + element.X, y)); // lineaOrizzontale
WriteElement(new LinePDF(element.X, y, element.X, y) { DeltaY2ForVerticalLine = -10 }); //lineaVerticaleSinistra
WriteElement(new LinePDF(element.Width + element.X, y, element.Width + element.X, y) { DeltaY2ForVerticalLine = -10 }); // lineaVerticaleDestra
break;
case Style.Immobiliare:
WriteElement(new LinePDF(element.X, element.X + element.Width, 0.5F, new ColorPDF(153, 148, 133))); // lineaOrizzontale
break;
case Style.ConsulenzaUnica:
WriteElement(new LinePDF(element.X, element.X + element.Width, 1F, ColorPDF.Standard_Grigio_SfondoColonnaTabella)); // lineaOrizzontale
break;
}
}
else if (element.ShowBorderLastLine && element.Footer == true && rowIndex == element.DataSource.Rows.Count - 1)
{
switch (element.Style)
{
case Style.ConsulenzaBase:
WriteElement(new LinePDF(element.X, y, element.Width + element.X, y)); // lineaOrizzontale
WriteElement(new LinePDF(element.X, y, element.X, y) { DeltaY2ForVerticalLine = -10 }); //lineaVerticaleSinistra
WriteElement(new LinePDF(element.Width + element.X, y, element.Width + element.X, y) { DeltaY2ForVerticalLine = -10 }); // lineaVerticaleDestra
break;
case Style.Immobiliare:
WriteElement(new LinePDF(element.X, element.X + element.Width, 0.5F, new ColorPDF(153, 148, 133))); // lineaOrizzontale
break;
case Style.ConsulenzaUnica:
WriteElement(new SpacePDF(5));
WriteElement(new LinePDF(element.X, element.X + element.Width, 1F, ColorPDF.Standard_Grigio_SfondoColonnaTabella)); // lineaOrizzontale
break;
}
}
#endregion
#region Reset delle larghezza originale delle colonne. [Modificata se impostato ColSpan della Cella]
int i = 0;
foreach (var item in element.Columns)
{
item.Width = columnsWidthOriginal[i];
item.Visibile = item.Width > 0 ? true : false;
i++;
}
#endregion
rowIndex++;
rowIndexPerPage++;
}
// Y iniziale su cui disegnare il testo del Footer
yTextToPrint = y;
#region Disegno il Footer della tabella.
//#region Imposto il FooterDatasource
if (element.FooterDatasource != null)
{
element.Footer = true;
//var arrListFooter = new ArrayList();
//foreach (ColumnPDF c in element.FooterColumns)
//{
// switch (c.TipoColonna)
// {
// case ColumnType.Testo:
// case ColumnType.Decimale:
// case ColumnType.Intero:
// case ColumnType.Percentuale:
// if (!string.IsNullOrEmpty(c.Name))
// arrListFooter.Add(c.Name);
// break;
// case ColumnType.Immagine:
// case ColumnType.Objectpdf:
// if (!string.IsNullOrEmpty(c.Id))
// arrListFooter.Add(c.Id);
// break;
// }
// // Imposto la colonna a visible=false se la larghezza è pari a 0
// c.Visibile = c.Width != 0;
//}
//var strArrayFooter = (string[])arrListFooter.ToArray(typeof(string));
//var columnsEmbeddedOrObject = element.FooterColumns.FindAll(col => col.TipoColonna == ColumnType.Objectpdf || (col.TipoColonna == ColumnType.Immagine && col.Name == string.Empty));
//if (columnsEmbeddedOrObject.Count > 0)
//{
// foreach (ColumnPDF column in columnsEmbeddedOrObject)
// element.DataSource.Columns.Add(column.Id);
//}
//// imposto il datasource
//element.DataSource = element.DataSource.DefaultView.ToTable(false, strArrayFooter);
//if (columnsEmbeddedOrObject.Count > 0)
//{
// for (int nColonna = 0; nColonna < element.FooterColumns.Count; nColonna++)
// {
// if (!string.IsNullOrEmpty(element.FooterCells[nColonna, 0].Value))
// element.DataSource.Rows[0][nColonna] = element.FooterCells[nColonna, 0].Value;
// }
//}
}
else
{
var footerDatasource = new DataTable();
for (int i = 0; i < element.FooterColumns.Count(); i++)
{
Type typeFooterColumn = typeof(string);
switch (element.FooterColumns[i].TipoColonna)
{
case ColumnType.Decimale:
case ColumnType.Intero:
typeFooterColumn = typeof(decimal);
break;
case ColumnType.Immagine:
typeFooterColumn = typeof(string);
break;
case ColumnType.Objectpdf:
typeFooterColumn = typeof(ImagePDF);
break;
default:
typeFooterColumn = typeof(string);
break;
}
footerDatasource.Columns.Add(element.FooterColumns[i].Id, typeFooterColumn);
}
var rowFooterDatasource = footerDatasource.NewRow();
for (int i = 0; i < element.FooterColumns.Count(); i++)
{
if (element.FooterCells[i, 0] != null)
rowFooterDatasource[i] = element.FooterCells[i, 0].Value;
}
footerDatasource.Rows.Add(rowFooterDatasource);
element.FooterDatasource = footerDatasource;
}
#endregion
if (element.Footer)
{
#region Style del Footer
switch (element.Style)
{
case Style.ConsulenzaBase:
if (element.ShowBorderFooter)
{
//Disegno un rettangolo in secondo piano che dia l'effetto cornice all'intestazione
var rectangleFrame = new RectanglePDF(element.X - 1, y + (element.FooterHeight / 2) + 1, (element.FooterHeight / 2), element.Width + 2, ColorPDF.ConsulenzaBase_Grigio_BordoColonnaHeaderFooterTabella) { AutoIncrementYWritable = false };
WriteElement(rectangleFrame);
}
// rettangolo contenitore grigio
var rectangleFooter = new RectanglePDF(element.X, y, element.FooterHeight, element.Width, ColorPDF.ConsulenzaBase_Grigio_SfondoColonnaHeaderFooterTabella) { AutoIncrementYWritable = false };
WriteElement(rectangleFooter);
break;
case Style.Immobiliare:
//lineHeaderUp
WriteElement(new LinePDF(element.X, element.X + element.Width, 0.5F, new ColorPDF(153, 148, 133)));
//lineHeaderDown
WriteElement(new LinePDF(element.X, element.X + element.Width, 0.5F, new ColorPDF(153, 148, 133)) { DeltaY = element.FooterHeight });
break;
case Style.ConsulenzaUnica:
//Lo stile del rettangolo grigio è definito in FooterColumns e FooterCells. La gestione è diversa in quanto per ConsulenzaUnica le tabelle possono avre il FooterDatasource impostato.
break;
}
#endregion
// Testo che sarà scritto sul footer
var textToPrint = new FormattedTextAreaPDF();
if (element.FooterColumns.Count > 0)
{
y += element.FooterYOffset;
rowIndex = 0;
foreach (DataRow rigaFooter in element.FooterDatasource.Rows)
{
//patryk5
if (_ywritable + element.FooterHeight > YLowerLimit)
{
_ywritable = YLowerLimit;
TablePDF_ContinuedOnNextPage();
_ywritable = YUpperLimit + 15;
y = _ywritable;
}
float xLabelForCaptionFooter = element.X;
columnIndex = 0;
if (element.ShowFooterSeparationLines)
{
var colorSeparationLine = element.Columns[columnIndex].BackgroundGray ? ColorPDF.Bianco : ColorPDF.Standard_Grigio_SfondoColonnaTabella;
// linea separatrice
var separationLine = new RectanglePDF(xLabelForCaptionFooter, y + element.RowHeight, element.WidthSeparationLines, element.Width, colorSeparationLine) { AutoIncrementYWritable = false };
if (y < YLowerLimit)
{
if (element.HideLastSeparationLine)
{
// Non viene disegnata la linea di separazione all'ultima riga
if (rowIndex != element.FooterDatasource.Rows.Count - 1)
WriteElement(separationLine);
}
else if (element.HideFirstSeparationLine)
{
if (rowIndex != 0)
WriteElement(separationLine);
}
else
WriteElement(separationLine);
}
}
foreach (ColumnPDF colonnaFooter in element.FooterColumns)
{
var colorRectangleBackground = ColorPDF.Bianco;
var fontColor = ColorPDF.Nero;
float fontSize;
var fontBold = true;
TextAlign textAlignFooter = GetTextAlign(colonnaFooter.HorizontalAlignment);
#region Attributi della colonna [fontColor, fontSize, fontBold]
#region Attibuti impostati a livello COLONNA [FooterColumns]
// Colore
fontColor = element.FooterColumns[columnIndex].FontColor != null ? element.FooterColumns[columnIndex].FontColor : ColorPDF.Nero;
// Size
fontSize = colonnaFooter.FontSize;
// Grassetto
fontBold = colonnaFooter.FontBold.HasValue ? colonnaFooter.FontBold.Value : true;
#endregion
#region Attibuti impostati a livello CELLA [FooterColumns]
if (element.FooterCells[columnIndex, rowIndex].FontBold != null)
fontBold = element.FooterCells[columnIndex, rowIndex].FontBold.HasValue ? element.FooterCells[columnIndex, rowIndex].FontBold.Value : true;
#endregion
#endregion
#region Allineamento verticale e impostazione Y del testo
switch (element.FooterTextVerticalAlign)
{
case VerticalAlignmentType.Alto:
yTextToPrint = y + element.FooterColumns[columnIndex].DeltaYContent;
break;
case VerticalAlignmentType.Basso:
yTextToPrint = y + (element.FooterHeight - element.FooterColumns[columnIndex].FontSize - (element.FooterColumns[columnIndex].FontSize / 2)) + element.FooterColumns[columnIndex].DeltaYContent;
break;
case VerticalAlignmentType.Centrato:
yTextToPrint = y + ((element.FooterHeight / 2) - (element.FooterColumns[columnIndex].FontSize / 2)) + element.FooterColumns[columnIndex].DeltaYContent;
break;
}
#endregion
#region BackgroundGray e BackgroundColor della colonna
// Aggiungo un rettangolo di sfondo (BackgroundGray o BackgroundColor) della COLONNA.
if (element.FooterColumns[columnIndex].BackgroundGray || element.FooterColumns[columnIndex].BackgroundColor != null)
{
colorRectangleBackground = element.FooterColumns[columnIndex].BackgroundColor;
if (element.FooterColumns[columnIndex].BackgroundGray)
colorRectangleBackground = ColorPDF.Standard_Grigio_SfondoColonnaTabella;
var rectangleBackground = new RectanglePDF(xLabelForCaptionFooter, y + 0.5F, element.FooterHeight - 0.5F, element.FooterColumns[columnIndex].Width, colorRectangleBackground) { AutoIncrementYWritable = false };
WriteElement(rectangleBackground);
if (element.FooterColumns[columnIndex].BackgroundColor != null)
{
// Sovrascrivo le linee Up e Down del Footer nel caso in cui le colonne abbiano un BackgroundColor impostato. Le righe vengono impostate a bianco per maggiore leggibilità.
var lineHeaderUp = new LinePDF(xLabelForCaptionFooter, y, xLabelForCaptionFooter + element.FooterColumns[columnIndex].Width, y, 0.5F, ColorPDF.Bianco) { AutoIncrementYWritable = false };
WriteElement(lineHeaderUp);
var lineHeaderDown = new LinePDF(xLabelForCaptionFooter, y, xLabelForCaptionFooter + element.FooterColumns[columnIndex].Width, y, 0.5F, ColorPDF.Bianco) { DeltaY = element.FooterHeight + 0.5F, AutoIncrementYWritable = false };
WriteElement(lineHeaderDown);
}
}
#endregion
#region BackgroundColor della cella [Solo per ConsulenzaUnica]
// Aggiungo un rettangolo di sfondo (BackgroundColor) della CELLA.
if (element.FooterCells[columnIndex, rowIndex].BackgroundColor != null && element.Style == Style.ConsulenzaUnica)
{
colorRectangleBackground = element.FooterCells[columnIndex, rowIndex].BackgroundColor;
var rectangleBackground = new RectanglePDF(xLabelForCaptionFooter, y, element.FooterHeight, element.FooterColumns[columnIndex].Width, colorRectangleBackground) { AutoIncrementYWritable = false };
WriteElement(rectangleBackground);
}
#endregion
#region Testo del Footer
switch (colonnaFooter.TipoColonna)
{
case ColumnType.Percentuale:
case ColumnType.Intero:
case ColumnType.Decimale:
case ColumnType.Testo:
if (string.IsNullOrEmpty(colonnaFooter.Name))
{
// Non è stata impostata la proprietà "nome" che mappa la colonna del FooterDatasource dalla quale prendere il dato da stampare.
// Viene quindi stampata il "Titolo" della colonna o se impostata la proprietà FooterCell, ne viene preso il rispettivo valore.
if (!string.IsNullOrEmpty(colonnaFooter.HeaderText))
{
textToPrint = new FormattedTextAreaPDF(colonnaFooter.HeaderText, xLabelForCaptionFooter, colonnaFooter.Width - colonnaFooter.PaddingLeft - colonnaFooter.PaddingRight, textAlignFooter) { Y = yTextToPrint, AutoIncrementYWritable = false, FontBold = fontBold, FontSize = fontSize, FontColor = fontColor };
}
else if (element.FooterCells != null)
{
string stringTextToPrint = string.Empty;
if (colonnaFooter.TipoColonna == ColumnType.Testo)
stringTextToPrint = rigaFooter[columnIndex].ToString();
else if (colonnaFooter.TipoColonna == ColumnType.Decimale)
stringTextToPrint = Helper.FormatCurrency(rigaFooter[columnIndex].ToString());
else if (colonnaFooter.TipoColonna == ColumnType.Intero)
stringTextToPrint = Helper.FormatInteger(rigaFooter[columnIndex].ToString());
else if (colonnaFooter.TipoColonna == ColumnType.Percentuale)
stringTextToPrint = Helper.FormatPercentage(rigaFooter[columnIndex].ToString(), 2);
// ReplaceIfZero
if (element.FooterCells[columnIndex, rowIndex].ReplaceIfZero != string.Empty)
if (stringTextToPrint.Equals("0,00"))
stringTextToPrint = stringTextToPrint.Replace("0,00", element.FooterCells[columnIndex, rowIndex].ReplaceIfZero);
stringTextToPrint += arrayAsterischiNote_PieDiPagina[0, columnIndex] ?? string.Empty;
textToPrint = new FormattedTextAreaPDF(stringTextToPrint, TablePDF_GetXTextFooter(xLabelForCaptionFooter, columnIndex, element), colonnaFooter.Width - colonnaFooter.PaddingLeft - colonnaFooter.PaddingRight, textAlignFooter)
{
Y = yTextToPrint,
AutoIncrementYWritable = false,
FontBold = fontBold,
FontSize = fontSize,
FontColor = fontColor
};
}
}
//else // è stata impostata la proprietà "nome" che mappa la colonna del FooterDatasource dalla quale prendere il dato da stampare. Stampo il valore della colonna.
//{
// if (element.FooterDatasource == null)
// throw new Exception("Proprietà FooterDatasource della tabella non impostata");
// string stringColumnValueFooter = element.FooterDatasource.Rows[0][colonnaFooter.Name].ToString();
// textToPrint = new FormattedTextAreaPDF(stringColumnValueFooter, TablePDF_GetXTextFooter(xLabelForCaptionFooter, columnIndex, element), colonnaFooter.Width, textAlignFooter)
// {
// Y = yTextToPrint,
// AutoIncrementYWritable = false,
// FontSize = colonnaFooter.FontSize
// };
//}
WriteElement(textToPrint);
break;
case ColumnType.Immagine:
case ColumnType.Objectpdf:
{
#region TIPO DI COLONNA FOOTER IMMAGINE
ImagePDF imageToPrint;
if (element.FooterCells[columnIndex, 0].Value != string.Empty)
{
#region Allineamento orizzontale dell'immagine
float xImmagine = xLabelForCaptionFooter;
Align imageAlignX;
switch (textAlignFooter)
{
case TextAlign.Center:
imageAlignX = Align.Center;
xImmagine = xImmagine + (element.FooterColumns[columnIndex].Width / 2);
break;
case TextAlign.Left:
imageAlignX = Align.Left;
xImmagine = xLabelForCaptionFooter;
break;
case TextAlign.Right:
imageAlignX = Align.Right;
xImmagine = xLabelForCaptionFooter + element.FooterColumns[columnIndex].Width;
break;
default:
imageAlignX = Align.Left;
xImmagine = xLabelForCaptionFooter;
break;
}
#endregion
imageToPrint = new ImagePDF(TablePDF_GetXTextFooter(xImmagine + element.FooterColumns[columnIndex].PaddingLeft, columnIndex, element), element.FooterColumns[columnIndex].ScaleColumnTypeImage, element.FooterCells[columnIndex, 0].Value, imageAlignX, yTextToPrint);
WriteElement(imageToPrint);
}
#endregion
}
break;
}
#endregion
columnIndex++;
xLabelForCaptionFooter += colonnaFooter.Width;
}
rowIndex++;
y += element.FooterHeight;
yTextToPrint += element.FooterHeight;
//int rowsCountLeft = element.FooterDatasource.Rows.Count - element.FooterDatasource.Rows.IndexOf(rigaFooter) + 1;
//float restOfFooter = rowsCountLeft * element.FooterHeight;
//if (y >= YLowerLimit - 100)
//{
// //_ywritable = YLowerLimit;
// //TablePDF_ContinuedOnNextPage();
// //_ywritable = 100;
// //y = _ywritable;
// int test = 2;
//}
}
}
// Incremento _ywritable con l'altezza del footer
_ywritable += (element.FooterHeight * element.FooterDatasource.Rows.Count);
}
#endregion
#region Stampo le note,associate alla tabella, da inserire sotto il footer della tabella.
foreach (TableNotePDF note in notesFooterTable)
{
WriteElement(new SpacePDF(5));
note.X = element.X;
note.AsterisksNumber = GetAsterisksNumber(note);
note.Width = element.Width;
note.AutoIncrementYWritable = true;
WriteElement(note);
}
#endregion
_printinginnewpage = false;
// AutoIncrementYWritable = false : la _ywritable è quella originale
if (!element.AutoIncrementYWritable)
_ywritable = originalYWritable;
}
/// <summary>
/// Scrive l'elemento SpacePDF sul documento
/// </summary>
/// <param name="element"></param>
private void WriteElement(SpacePDF element)
{
_ywritable += element.Height;
if (_ywritable > YLowerLimit)
AddPage();
}
/// <summary>
/// Scrive l'elemento UnorderedListPDF sul documento
/// </summary>
/// <param name="element"></param>
private void WriteElement(UnorderedListPDF element)
{
element.BaseElement = new UnorderedList(element.X, element.Y, element.Width, element.Height, _reportEnvironment.FontFamily.Regular, element.FontSize)
{
ListItemTopMargin = element.Margin,
ListItemBottomMargin = element.Margin,
TextAlign = element.TextAlign
};
foreach (string item in element.Items)
element.BaseElement.Items.Add(item);
if (element.Y == 0)
element.BaseElement.Y = _ywritable;
if (element.Height == 0)
{
element.Height = element.BaseElement.GetRequiredHeight();
element.BaseElement.Height = element.Height;
}
// Tipo di bullet
if (element.BulletType == BulletType.Pallino)
element.BaseElement.BulletStyle = UnorderedListStyle.Disc;
else if (element.BulletType == BulletType.Trattino)
element.BaseElement.BulletStyle = UnorderedListStyle.Dash;
if (_ywritable <= YLowerLimit)
_page.Elements.Add(element.ToElement());
else
{
// aggiunge una pagina
AddPage();
element.BaseElement.Y = _ywritable;
_page.Elements.Add(element.ToElement());
}
if (element.AutoIncrementYWritable)
_ywritable += element.Height;
}
/// <summary>
/// Scrive l'elemento ResetterYPDF.
/// Se Y = 0 _ywritable = _yupperlimit altrimenti _ywritable= Y
/// </summary>
/// <param name="element"></param>
private void WriteElement(ResetterYPDF element)
{
_ywritable = element.Y.Equals(0) ? YUpperLimit : element.Y;
}
private void WriteElement(ActionPDF element)
{
if (element.YPositionAction != null)
{
foreach (ObjectPDF obj in element.YPositionAction.Invoke(_ywritable))
{
if (obj is PagePDF)
{
AddPage(((PagePDF)obj).Type);
}
else
{
WriteElement(obj);
}
}
}
}
/// <summary>
/// Scrive l'elemento CompositePDF sul documento.
/// </summary>
/// <param name="element"></param>
/// <remarks>
/// DA IMPLEMETARE
/// </remarks>
private void WriteElement(CompositePDF element)
{
const float totalHeight = 0F;
if (_ywritable + totalHeight > YLowerLimit)
AddPage();
foreach (var item in element.Elements)
{
WriteElement(item);
}
}
/// <summary>
/// Disegna tutti gli Elements (List di ObjectPDF) di cui si compone un ChartPDF.
/// Se la somma di tutti i punti delle serie è 0, il grafico non sarà disegnato.
/// </summary>
/// <param name="element"></param>
private void WriteElement(ChartPDF element)
{
var originalYWritable = _ywritable;
//Se tutti i Point.Value aggiunti a tutte le serie sono = 0 non stampo il grafico
var print = element.SeriesCollection.FindAll(o => o.Points.Sum(p => p.Value) > 0).Any();
// Se tutti i Point.Values.X o Point.Values.Y aggiunti a tutte le serie sono = 0 non stampo il grafico
if (!print)
print = element.SeriesCollection.FindAll(o => o.Points.Sum(p => p.Values.X) > 0 || o.Points.Sum(p => p.Values.Y) > 0).Any();
if (!print) return;
#region Grafico Stacked con salto pagina
bool stackedChartWithPageBreak = false;
try
{
var stackedChart = element as StackedPDF; // grafico Stacked
stackedChartWithPageBreak = stackedChart.PageBreak;
}
catch
{
stackedChartWithPageBreak = false;
}
#endregion
if (stackedChartWithPageBreak)
{
#region Disegno con salto pagina per i grafici Stacked
var stackedChart = element as StackedPDF; // grafico Stacked
stackedChart.MaximumValueAxisY = stackedChart.GetMaximumValuePoints();
var pointsCopy = new List<Point>(stackedChart.SeriesCollection[0].Points);
List<Point> pointsCopy2 = null;
if (stackedChart.SeriesCollection.Count > 1)
pointsCopy2 = new List<Point>(stackedChart.SeriesCollection[1].Points);
int rowsIncrement = 0;
int remainingRows = stackedChart.SeriesCollection[0].Points.Count; //Righe restanti
do
{
element.ChartBase.Series.Clear();
element.SeriesCollection[0].Points.Clear();
element.Elements.Clear();
var remainingSpace = YLowerLimit - _ywritable;
switch (_reportEnvironment.ReportType)
{
case ReportType.Unica_Diagnosi:
case ReportType.Unica_Monitoraggio:
case ReportType.Unica_Nucleo:
case ReportType.Unica_Proposta:
// stackedChart.HeightSingleBar = pointsCopy.Count < 3 ? 40 : 25;
break;
default:
stackedChart.HeightSingleBar = stackedChart.HeightSingleBar;
break;
}
int rowsInPage = Convert.ToInt32((remainingSpace / stackedChart.HeightSingleBar)) - 5;
// aggiunto il reverse perchè con il salto di pagine scombina l'ordinamento.
element.SeriesCollection[0].Points = pointsCopy.Skip(rowsIncrement).Take(rowsInPage).ToList();
if (element.SeriesCollection.Count > 1)
element.SeriesCollection[1].Points = pointsCopy2.Skip(rowsIncrement).Take(rowsInPage).ToList();
int i = 0;
foreach (var item in element.SeriesCollection)
{
element.SeriesCollection[i].Points.Reverse();
i++;
}
// Popola la Elements di tutti gli oggetti di cui si compone il grafico.
element.ToElement();
// Disegna tutti gli Elements
foreach (ObjectPDF item in element.Elements)
WriteElement(item);
rowsIncrement += rowsInPage;
remainingRows -= rowsInPage;
if (remainingRows > 0)
{
StackedPDF_ContinuedOnNextPage();
//AddPage();
//AddSpace(20);
}
}
while (remainingRows > 0);
#endregion
}
else
{
// Popola la Elements di tutti gli oggetti di cui si compone il grafico.
int i = 0;
foreach (var item in element.SeriesCollection)
{
element.SeriesCollection[i].Points.Reverse();
i++;
}
element.ToElement();
// Salto pagina nel caso in cui il grafico non possa essere contenuto in pagina.
if (_ywritable + element.TotalHeight > YLowerLimit)
AddPage(); // aggiungere una pagina
// Disegna tutti gli Elements
float _ywritableTmp = _ywritable;
foreach (ObjectPDF item in element.Elements)
WriteElement(item);
float yWritableTmp2 = _ywritable;
_ywritable = _ywritableTmp;
foreach (Marker m in element.Markers)
{
WriteElement(new ImagePDF(((m.X < 0 ? 0 : m.X) * element.Width / (float)element.ChartBase.ChartAreas[0].AxisX.Maximum) + element.X - (m.Width * m.Scale / 2), m.Scale, m.Image)
{
Width = m.Width,
Height = m.Height,
Y = _ywritable + element.Height - (element.Height * m.Y / (float)element.ChartBase.ChartAreas[0].AxisY.Maximum) - (m.Height * m.Scale / 2),
AutoIncrementYWritable = false
});
}
_ywritable = yWritableTmp2;
}
try
{
var stackedChart = element as StackedPDF;
var max = stackedChart.GetMaximumValuePoints();
var valoreeperintervallo = Helper.Round(max) / stackedChart.IntervalNumberAxisY;
var valoreultimoAsseX = (valoreeperintervallo * stackedChart.IntervalNumberAxisY);
float _x = stackedChart.X;
float TotalHeight = stackedChart.GetHeight();
float y1Linea = originalYWritable;
float y2Linea = y1Linea + TotalHeight;
foreach (VerticalMarkerWithLine marker in stackedChart.VerticalMarkersWithLines)
{
var valorePatrimoni = (marker.XValue * stackedChart.Width) / valoreultimoAsseX;
WriteElement(new LinePDF((float)valorePatrimoni + _x, y1Linea, (float)valorePatrimoni + _x, y2Linea) { AutoIncrementYWritable = false, Color = marker.Color });
var img = new ImagePDF((float)valorePatrimoni + _x + 6, 0.50F/*0.30F*/, marker.ImagePath, ceTe.DynamicPDF.Align.Right, y1Linea) { AutoIncrementYWritable = false, DeltaY = -15 };
img.Y += marker.ImageYOffset;
WriteElement(img);
}
}
catch
{
}
// AutoIncrementYWritable = false : la _ywritable è quella originale
if (!element.AutoIncrementYWritable)
_ywritable = originalYWritable;
}
private void WriteElement(CustomChartPDF element)
{
var originalYWritable = _ywritable;
// Popola la Elements di tutti gli oggetti di cui si compone il grafico.
element.ToElement();
// Disegna tutti gli Elements
foreach (ObjectPDF item in element.Elements)
{
WriteElement(item);
}
// AutoIncrementYWritable = false : la _ywritable è quella originale
if (!element.AutoIncrementYWritable)
_ywritable = originalYWritable;
}
/// <summary>
/// Ritorna l'altezza della FormattedTextArea contenente il testo passato in input.
/// </summary>
/// <param name="texttoprint">testo da scrivere</param>
/// <param name="width">larghezza della FormattedTextArea contenente il testo</param>
/// <param name="fontsize">font size della FormattedTextArea contenente il testo </param>
/// <param name="fontbold">bold della FormattedTextArea contenente il testo</param>
/// <param name="tipocolonna">tipo di colonna contenente il testo. Di default = TESTO</param>
/// <returns></returns>
private float GetTextHeigth(string texttoprint, float width, float fontsize, bool fontbold = false, ColumnType tipocolonna = ColumnType.Testo)
{
if (tipocolonna == ColumnType.Immagine || width == 0 || texttoprint.Length == 0) return 0;
var formattedTextArea = new FormattedTextArea(texttoprint, 0, 0, width - 3, 0, _reportEnvironment.FontFamily, fontsize, true) // sottraggo - 3 alla width per un valore più preciso dell'altezza di ritorno.
{
Style = { Bold = fontbold }
};
return formattedTextArea.GetRequiredHeight();
}
/// <summary>
/// Recupera l'allineamento TextAlign a partire dal TipoAllineamentoOrizzontale della colonna.
/// </summary>
/// <param name="allineamentoOrizzontaleColonna">allineamento orizzontale della colonna</param>
/// <returns></returns>
private TextAlign GetTextAlign(HorizontalAlignmentType allineamentoOrizzontaleColonna)
{
var textAlign = new TextAlign();
switch (allineamentoOrizzontaleColonna)
{
case HorizontalAlignmentType.Destra:
textAlign = TextAlign.Right;
break;
case HorizontalAlignmentType.Sinistra:
textAlign = TextAlign.Left;
break;
case HorizontalAlignmentType.Centrato:
textAlign = TextAlign.Center;
break;
}
return textAlign;
}
/// <summary>
/// Recupera il numero di asterischi più basso disponibile tra quelli gia inseriti nel documento.
/// Ogni volta che nel documento è aggiunta una ObjectTypePDF.PAGE, il numero di asterischi viene resettato.
/// </summary>
/// <returns></returns>
private int GetAsterisksNumber(TableNotePDF currentNote)
{
int result = 1;
// Indice dell'elemento corrente
int indexCurrentElement = _elements.Count;
// Cerco l'indice in _elements dell'ultimo ObjectPDF di tipo ObjectTypePDF.PAGE
int indexLastPage = _elements.FindLastIndex(r => r.ObjectType == ObjectTypePdf.PAGE);
var rangeList = _elements.GetRange(indexLastPage, indexCurrentElement - indexLastPage);
// Conto quante TABLE con alemno 1 nota sono presenti in rangeList
var tableList = rangeList.FindAll(r => r.ObjectType == ObjectTypePdf.TABLE && ((TablePDF)r).Notes.Count > 0);
// Cliclo le TABLE trovate e per ognuno ciclo sulle proprie Note
foreach (var objectPdf in tableList)
{
var table = (TablePDF)objectPdf;
foreach (var note in table.Notes)
{
if (currentNote == note)
return result;
result++;
}
}
return result;
}
/// <summary>
/// Incrementa o decrementa la prima colonna se allineata a sinistra e l'ultima colonna se allineata a destra,
/// del valore impostato come margine alla tabella.
/// Serve per dare la spaziatura tra la prima e l'ultima colonna tra il bordo e il testo.
/// </summary>
/// <param name="xcorrente">valore della x corrente</param>
/// <param name="currentcolumn">indice della colonna corrente</param>
/// <param name="table">tabella</param>
/// <returns></returns>
private float TablePDF_GetXTextContent(float xcorrente, int currentcolumn, TablePDF table)
{
#region Imposto il valore della proprietà Margin per la prima colonna se l'allineamento è a SINISTRA
if (currentcolumn == 0 && table.Columns[currentcolumn].HorizontalAlignment == HorizontalAlignmentType.Sinistra)
return xcorrente += table.Margin;
#endregion
#region Imposto il valore della proprietà Margin per l'ultima colonna se l'allineamento è a DESTRA
if (currentcolumn == table.Columns.Count - 1 && table.Columns[currentcolumn].HorizontalAlignment == HorizontalAlignmentType.Destra)
return xcorrente -= table.Margin;
#endregion
return xcorrente;
}
/// <summary>
/// Incrementa o decrementa la prima colonna se allineata a sinistra e l'ultima colonna se allineata a destra,
/// del valore impostato come margine alla tabella.
/// Serve per dare la psaziatura tra la prima e l'ultima colonna tra il bordo e il testo.
/// </summary>
/// <param name="xcorrente">valore della x corrente</param>
/// <param name="currentcolumn">indice della colonna corrente</param>
/// <param name="table">tabella</param>
/// <returns></returns>
private float TablePDF_GetXTextFooter(float xcorrente, int currentcolumn, TablePDF table)
{
#region Imposto il valore della proprietà Margin per la prima colonna se l'allineamento è a SINISTRA
if (currentcolumn == 0 && table.FooterColumns[currentcolumn].HorizontalAlignment == HorizontalAlignmentType.Sinistra)
return xcorrente + table.Margin;
#endregion
#region Imposto il valore della proprietà Margin per l'ultima colonna se l'allineamento è a DESTRA
if (currentcolumn == table.FooterColumns.Count - 1 && table.FooterColumns[currentcolumn].HorizontalAlignment == HorizontalAlignmentType.Destra)
return xcorrente - table.Margin;
#endregion
return xcorrente;
}
/// <summary>
/// Disegna la riga del titolo della tabella.
/// Imposta automaticamente a false la proprietà ShowBorderHeader della TablePDF (element).
/// Aggiunge uno SpacePDF pari a 10.
/// </summary>
private bool TablePDF_DrawTitleRow(TablePDF element)
{
element.ShowBorderHeader = false;
bool printedTitleRow = false;
//// Il TitleRow della tabella deve essere stampato in una nuova pagina se lo spazio rimanente non può contenere il titlerow stesso, l'header e 2 righe della tabella.
//if (element.TitleRowHeight + element.HeaderHeight + (element.CellHeight * 2) + element.TitleRowSpace > RemainingSpace)
//{
// AddPage();
// element.Y = _yupperlimit;
//}
switch (element.TitleRowBorder)
{
case BorderTitleRowType.Pieno:
{
//Disegno un rettangolo in secondo piano che dia l'effetto cornice all'intestazione
var rectangleFrame = new RectanglePDF(element.X - 1, _ywritable - 1, element.TitleRowHeight / 2, element.Width + 2, ColorPDF.ConsulenzaBase_Grigio_BordoColonnaHeaderFooterTabella)
{
AutoIncrementYWritable = false
};
WriteElement(rectangleFrame);
// rettangolo contenitore grigio
var rectangleHeader = new RectanglePDF(element.X, _ywritable, element.TitleRowHeight, element.Width, ColorPDF.ConsulenzaBase_Grigio_SfondoColonnaHeaderFooterTabella)
{
AutoIncrementYWritable = false
};
WriteElement(rectangleHeader);
// TitleRowText
var labelTitle = new FormattedTextAreaPDF(element.TitleRowText, element.X + element.Margin, element.Width);
labelTitle.Y = _ywritable + ((element.TitleRowHeight / 2) - (labelTitle.Height / 2));
labelTitle.AutoIncrementYWritable = false;
labelTitle.FontBold = true;
//labelTitle.TextColor = element.HeaderFontColor;
WriteElement(labelTitle);
printedTitleRow = true;
}
break;
case BorderTitleRowType.Nessuno:
{
var labelTitle = new FormattedTextAreaPDF(element.TitleRowText, element.X + element.Margin, element.Width);
labelTitle.Y = _ywritable + ((element.TitleRowHeight / 2) - (labelTitle.Height / 2));
labelTitle.AutoIncrementYWritable = false;
WriteElement(labelTitle);
printedTitleRow = true;
}
break;
}
AddSpace(element.TitleRowHeight);
// SUBTITLE
if (element.SubTitleTable != null)
{
WriteElement(element.SubTitleTable);
_printinginnewpage = true;
}
if (element.SubTitleElements != null)
{
foreach (ObjectPDF item in element.SubTitleElements)
{
WriteElement(item);
_printinginnewpage = true;
}
}
AddSpace(element.TitleRowSpace);
return printedTitleRow;
}
private bool TablePDF_DrawTitleRow(TablePDF element, bool unica = true) //row unica per es. scheda 31
{
element.ShowBorderHeader = false;
bool printedTitleRow = false;
var remainingSpace = YLowerLimit - _ywritable;
if (element.TitleRowHeight + element.HeaderHeight + (element.RowHeight * 2) + element.TitleRowSpace > remainingSpace)
{
AddPage();
AddSpace(1);
element.Y = YUpperLimit;
}
var rectangleHeader = new RectanglePDF(element.X, _ywritable, element.TitleRowHeight, element.Width, ColorPDF.Bianco)
{
AutoIncrementYWritable = false
};
WriteElement(rectangleHeader);
// TitleRowText
var labelTitle = new FormattedTextAreaPDF(element.TitleRowText, element.X + element.Margin, element.Width) { FontSize = 11, FontColor = ColorPDF.Nero, FontBold = true };
labelTitle.Y = _ywritable + ((element.TitleRowHeight / 2) - (labelTitle.Height / 2));
labelTitle.AutoIncrementYWritable = false;
WriteElement(labelTitle);
printedTitleRow = true;
AddSpace(element.TitleRowHeight);
// SUBTITLE
if (element.SubTitleTable != null)
{
WriteElement(element.SubTitleTable);
_printinginnewpage = true;
}
if (element.SubTitleElements != null)
{
foreach (ObjectPDF item in element.SubTitleElements)
{
WriteElement(item);
_printinginnewpage = true;
}
}
AddSpace(element.TitleRowSpace);
return printedTitleRow;
}
/// <summary>
/// Disegna l'header della tabella.
/// </summary>
private void TablePDF_DrawHeader(TablePDF element, string[,] arrayAsterischiNote_Intestazione)
{
var yHeader = _ywritable; // recupero la posizione y su cui è stato disegnato il rettangolo dell' Header
var backgroundColor = ColorPDF.ConsulenzaBase_Grigio_SfondoColonnaHeaderFooterTabella; //Grigio : standard per Proposta Consulenzabase.
var fontColorHeaderColumn = ColorPDF.Nero;
// Salto pagina se non c'è abbastanza spazio per stampare l'header + 2 righe
if (_ywritable + element.HeaderHeight + element.AdditionalSpaceBetweenHeadersAndTable + element.HeaderMargin + ((element.RowHeight + element.RowsPadding) * 2) > _ylowerlimitoriginal
|| (_ywritable + element.HeaderHeight + element.AdditionalSpaceBetweenHeadersAndTable + element.HeaderMargin + ((element.RowHeight + element.RowsPadding) * 2) >= element.TableCantReachThisYPosition && element.TableCantReachThisYPosition != 0))
{
AddPage();
if (element.AddSpaceBeforeTableAfterEntireTableIsMovedToNextPage)
{
AddSpace(5); // adds space at the very begining, so while inserting a table at the top of the page, there is a space for
// a built in header
}
yHeader = _ywritable;
element.Y = _ywritable;
}
if (element.HeaderNoteObjects.Count > 0)
{
//if (!element.HeaderTextDrawJustOnce || (element.HeaderTextDrawJustOnce && element.HeaderNoteObjectsCounter < 1))
//{
element.HeaderNoteObjectsCounter++;
foreach (var e in element.HeaderNoteObjects)
{
WriteElement(e);
}
//}
}
// label dell'intestazione delle colonne
float xLabelHeaderText = element.X;
FormattedTextAreaPDF labelHeaderText;
if (!string.IsNullOrEmpty(element.TableTitle))//if (!element.HeaderTextDrawJustOnce || (element.HeaderTextDrawJustOnce && element.HeaderTextCounter < 1))
{
element.HeaderTextCounter++;
#region stampo nell'header della tabella il testo contenuto in HeaderText.
labelHeaderText = new FormattedTextAreaPDF(element.TableTitle,
TablePDF_GetXTextContent(xLabelHeaderText, 0, element),
element.Width,
TextAlign.Left)
{
Y = yHeader,
FontBold = true,
AutoIncrementYWritable = false
};
if (element.TableTitleDeltaX != 0)
{
labelHeaderText.X += element.TableTitleDeltaX;
}
if (element.TableTitleFontSize != 0)
{
labelHeaderText.FontSize = element.TableTitleFontSize;
}
if (element.TableTitleFontColor != null)
{
labelHeaderText.FontColor = element.TableTitleFontColor;
}
labelHeaderText.GetAndSetHeight(_reportEnvironment.FontFamily, labelHeaderText.FontBold);
#region Allineamento verticale
switch (element.HeaderTextVerticalAlign)
{
case VerticalAlignmentType.Alto:
labelHeaderText.Y = yHeader;
break;
case VerticalAlignmentType.Basso:
labelHeaderText.Y = yHeader + (element.HeaderHeight - labelHeaderText.Height);
break;
case VerticalAlignmentType.Centrato:
labelHeaderText.Y = yHeader + ((element.HeaderHeight / 2) - (labelHeaderText.Height / 2));
break;
}
#endregion
WriteElement(labelHeaderText);
#endregion
}
_ywritable += element.HeadersObjectsHeight;
yHeader += element.HeadersObjectsHeight;
switch (element.Style)
{
case Style.ConsulenzaBase:
#region ConsulenzaBase
if (element.ShowBorderHeader)
{
//Disegno un rettangolo in secondo piano che dia l'effetto cornice all'intestazione
var rectangleFrame = new RectanglePDF(element.X - 1, _ywritable - 1, element.HeaderHeight / 2, element.Width + 2, ColorPDF.ConsulenzaBase_Grigio_BordoColonnaHeaderFooterTabella) { AutoIncrementYWritable = false };
WriteElement(rectangleFrame);
}
// rettangolo contenitore grigio
var rectangleHeader = new RectanglePDF(element.X, _ywritable, element.HeaderHeight, element.Width, backgroundColor) { AutoIncrementYWritable = false };
WriteElement(rectangleHeader);
#endregion
break;
case Style.Immobiliare:
#region Immobiliare
if (element.DrawLineHeaderUP)
{
var lineHeaderUp = new LinePDF(element.X, element.X + element.Width, 0.5F, new ColorPDF(153, 148, 133));
WriteElement(lineHeaderUp);
}
var lineHeaderDown = new LinePDF(element.X, element.X + element.Width, 0.5F, new ColorPDF(153, 148, 133)) { DeltaY = element.HeaderHeight };
WriteElement(lineHeaderDown);
#endregion
break;
case Style.ConsulenzaUnica:
#region ConsulenzaUnica
// rettangolo contenitore grigio
backgroundColor = ColorPDF.ConsulenzaUnica_Grigio_SfondoColonnaHeaderFooterTabella;
WriteElement(new RectanglePDF(element.X, yHeader, element.HeaderHeight, element.Width, backgroundColor) { AutoIncrementYWritable = false });
break;
#endregion
}
// label dell'intestazione delle colonne
// float xLabelHeaderText = element.X;
// FormattedTextAreaPDF labelHeaderText;
if (element.HeaderText == string.Empty)
{
#region stampo nell'header della tabella le caption delle singole colonne della tabella
int columnIndex = 0;
int widthcurrent = 0;
foreach (var column in element.Columns)
{
if (column.Visibile)
{
#region Aggiungo un rettangolo di sfondo (BackgroundColor).
if (column.HeaderBackgroundColor != null)
{
var colorRectangleBackground = column.HeaderBackgroundColor;
var rectangleBackground = new RectanglePDF(xLabelHeaderText, yHeader, element.HeaderHeight, column.Width, colorRectangleBackground) { AutoIncrementYWritable = false };
WriteElement(rectangleBackground);
// Sovrascrivo la linea Down dell' Header nel caso in cui le colonne abbiano un BackgroundColor impostato. La riga viene impostata a bianco per maggiore leggibilità.
var lineHeaderDown = new LinePDF(xLabelHeaderText, yHeader + element.HeaderHeight, xLabelHeaderText + column.Width, yHeader + element.HeaderHeight, 1F, ColorPDF.Bianco) { DeltaY = 0.5F, AutoIncrementYWritable = false };
WriteElement(lineHeaderDown);
}
#endregion
var stringAsteriscoIntestazione = arrayAsterischiNote_Intestazione[0, columnIndex] ?? string.Empty;
labelHeaderText = new FormattedTextAreaPDF(column.HeaderText + stringAsteriscoIntestazione,
TablePDF_GetXTextContent(xLabelHeaderText, columnIndex, element) + column.HeaderPaddingLeft,
column.Width - column.HeaderPaddingRight,
GetTextAlign(column.HorizontalAlignment))
{
Y = yHeader,
FontBold = column.HeaderFontBold,
FontSize = column.HeaderFontSize,
AutoIncrementYWritable = false,
TextVerticalDirection = column.HeaderTextVerticalDirection
};
#region Altezza del TESTO
if (labelHeaderText.TextVerticalDirection)
labelHeaderText.Width = element.HeaderHeight;
labelHeaderText.GetAndSetHeight(_reportEnvironment.FontFamily, labelHeaderText.FontBold);
#endregion
#region Direzione VERTICALE del TESTO
if (labelHeaderText.TextVerticalDirection)
{
labelHeaderText.FixedHeight = labelHeaderText.Height;
labelHeaderText.TextHorizontalAlign = TextAlign.Left;
labelHeaderText.Y = (yHeader + element.HeaderHeight) - 2;
if (_reportEnvironment.ReportType == ReportType.Unica_Diagnosi || _reportEnvironment.ReportType == ReportType.Unica_Monitoraggio || _reportEnvironment.ReportType == ReportType.Unica_Nucleo || _reportEnvironment.ReportType == ReportType.Unica_Proposta)
labelHeaderText.X = labelHeaderText.X + (element.Columns[columnIndex].Width / 2) - (labelHeaderText.FontSize);
else
labelHeaderText.X = labelHeaderText.X + (element.Columns[columnIndex].Width / 2) - (labelHeaderText.FontSize / 2);
}
#endregion
#region Colore del TESTO
switch (element.Style)
{
case Style.ConsulenzaBase:
case Style.Immobiliare:
fontColorHeaderColumn = ColorPDF.Nero;
break;
case Style.ConsulenzaUnica:
fontColorHeaderColumn = ColorPDF.ConsulenzaUnica_Rosso;
break;
}
labelHeaderText.FontColor = fontColorHeaderColumn;
if (column.HeaderFontColor != null)
labelHeaderText.FontColor = column.HeaderFontColor;
#endregion
#region Allineamento verticale del TESTO (Recupero Y)
if (!labelHeaderText.TextVerticalDirection)
{
switch (column.HeaderVerticalAlignment)
{
case VerticalAlignmentType.Alto:
labelHeaderText.Y = yHeader;
break;
case VerticalAlignmentType.Basso:
labelHeaderText.Y = yHeader + (element.HeaderHeight - labelHeaderText.Height);
break;
case VerticalAlignmentType.Centrato:
labelHeaderText.Y = yHeader + ((element.HeaderHeight / 2) - (labelHeaderText.Height / 2));
break;
}
}
#endregion
// Incremento la X
xLabelHeaderText += column.Width;
// widthcurrent += xLabelHeaderText + column.Width;
// Disegno la label di HeaderText
WriteElement(labelHeaderText);
if (element.ShowBorderHeader)
{
WriteElement(new RectanglePDF(xLabelHeaderText + 1, yHeader, element.HeaderHeight, 1, ColorPDF.Bianco) { AutoIncrementYWritable = false });
}
}
columnIndex++;
}
#region HeaderGroupText e HeaderGroupPathImage
//Aggiungo un HeaderGroupText alle colonne che hanno impostato HeaderGroupPathImage, in modo da sfruttare il codice scritto per HeaderGroupText.
element.Columns.Where(o => o.HeaderGroupPathImage != null).ToList().ForEach(i => i.HeaderGroupText = new List<string>() { " " });
// Controllo se esiste almeno una colonna con HeaderGroupText impostato.
if (element.Columns.Any(o => o.HeaderGroupText.Any()))
{
columnIndex = 0;
xLabelHeaderText = element.X;
foreach (var column in element.Columns)
{
if (column.Visibile)
{
var scostamentoX = 0F;
foreach (var itemHeaderGroupText in column.HeaderGroupText)
{
var xHeaderGroupText = column.HeaderGroupTextVerticalDirection
? xLabelHeaderText + (column.HeaderGroupWidth / 2) + column.HeaderGroupTextDeltaX + scostamentoX
: xLabelHeaderText + column.HeaderGroupTextDeltaX;
var yHeaderGroupText = element.Y + element.HeaderHeight + column.HeaderGroupTextDeltaY;
var labelHeaderGroupText = new FormattedTextAreaPDF(
itemHeaderGroupText,
xHeaderGroupText,
column.HeaderGroupWidth)
{
FontBold = true,
AutoIncrementYWritable = false,
TextVerticalDirection = column.HeaderGroupTextVerticalDirection,
FontColor = column.HeaderFontColor != null ? column.HeaderFontColor : ColorPDF.Nero
};
#region Altezza del TESTO
if (labelHeaderGroupText.TextVerticalDirection)
labelHeaderGroupText.Width = element.HeaderHeight + column.HeaderGroupTextDeltaY;
labelHeaderGroupText.GetAndSetHeight(_reportEnvironment.FontFamily, labelHeaderGroupText.FontBold);
#endregion
#region Direzione VERTICALE del TESTO HeaderGroupText
if (column.HeaderGroupTextVerticalDirection)
{
labelHeaderGroupText.FixedHeight = labelHeaderGroupText.Height;
labelHeaderGroupText.TextHorizontalAlign = TextAlign.Left;
labelHeaderGroupText.Y = yHeaderGroupText;
labelHeaderGroupText.X = xHeaderGroupText + labelHeaderGroupText.FontSize;
}
#endregion
#region Allineamento verticale del TESTO (se TextVerticalDirection = false)
if (!labelHeaderGroupText.TextVerticalDirection)
{
switch (column.HeaderVerticalAlignment)
{
case VerticalAlignmentType.Alto:
labelHeaderGroupText.Y = element.Y + column.HeaderGroupTextDeltaY;
break;
case VerticalAlignmentType.Basso:
labelHeaderGroupText.Y = element.Y + (element.HeaderHeight - labelHeaderGroupText.FontSize) + column.HeaderGroupTextDeltaY;
break;
case VerticalAlignmentType.Centrato:
labelHeaderGroupText.Y = element.Y + ((element.HeaderHeight / 2) - (labelHeaderGroupText.FontSize / 2)) + column.HeaderGroupTextDeltaY;
break;
}
}
#endregion
// Disegno la label di GroupHeaderText
WriteElement(labelHeaderGroupText);
//Disegno le immagini aggiunte a HeaderGroupPathImage
if (column.HeaderGroupPathImage != null)
WriteElement(new ImagePDF(labelHeaderGroupText.X, column.HeaderGroupScaleImage, column.HeaderGroupPathImage));
scostamentoX += labelHeaderGroupText.FixedHeight;
//Linea di separazione in basso.
if (column.HeaderGroupBorderLine)
WriteElement(new LinePDF(xHeaderGroupText, yHeaderGroupText + 3, xHeaderGroupText + column.HeaderGroupWidth - column.HeaderGroupTextDeltaX, yHeaderGroupText + 3, 0.5F, new ColorPDF(153, 148, 133)) { AutoIncrementYWritable = false });
}
xLabelHeaderText += column.Width;
}
columnIndex++;
}
}
#endregion
#endregion
}
else
{
element.HeaderTextCounter++;
#region stampo nell'header della tabella il testo contenuto in HeaderText.
labelHeaderText = new FormattedTextAreaPDF(element.HeaderText,
TablePDF_GetXTextContent(xLabelHeaderText, 0, element),
element.Width,
TextAlign.Left)
{
Y = yHeader,
FontBold = true,
AutoIncrementYWritable = false
};
labelHeaderText.GetAndSetHeight(_reportEnvironment.FontFamily, labelHeaderText.FontBold);
#region Allineamento verticale
switch (element.HeaderTextVerticalAlign)
{
case VerticalAlignmentType.Alto:
labelHeaderText.Y = yHeader;
break;
case VerticalAlignmentType.Basso:
labelHeaderText.Y = yHeader + (element.HeaderHeight - labelHeaderText.Height);
break;
case VerticalAlignmentType.Centrato:
labelHeaderText.Y = yHeader + ((element.HeaderHeight / 2) - (labelHeaderText.Height / 2));
break;
}
#endregion
WriteElement(labelHeaderText);
#endregion
}
AddSpace(element.AdditionalSpaceBetweenHeadersAndTable); // tmp
_printinginnewpage = false;
}
/// <summary>
/// Disegna il salto pagina per l'ogetto TablePDF.
/// Aggiunge una pagina.
/// </summary>
private void StackedPDF_ContinuedOnNextPage()
{
switch (_reportEnvironment.ReportType)
{
case ReportType.Base_Proposta:
break;
case ReportType.Unica_Diagnosi:
case ReportType.Unica_Monitoraggio:
case ReportType.Unica_Proposta:
case ReportType.Unica_Nucleo:
WriteElement(new ImagePDF(435, 0.15F, "changepage.png") { Y = 745 - 5, AutoIncrementYWritable = false });
WriteElement(new FormattedTextAreaPDF("continua alla pagina successiva", 450, 200) { Y = 745 - 5, FontSize = 6, AutoIncrementYWritable = false, AbsolutePosition = true });
AddPage(false);
AddSpace(2);
WriteElement(new ImagePDF(XLeftLimit, 0.15F, "changepage.png") { AutoIncrementYWritable = false });
WriteElement(new FormattedTextAreaPDF("continua dalla pagina precedente", XLeftLimit + 15, 200) { FontSize = 6, AutoIncrementYWritable = true });
AddSpace(20);
break;
case ReportType.Immobiliare_Diagnosi:
case ReportType.Immobiliare_Monitoraggio:
case ReportType.Immobiliare_DiagnosiNucleo:
case ReportType.Immobiliare_MappaturaPreliminare:
case ReportType.Immobiliare_Finalita:
//#region Immobiliare
//WriteElement(new FormattedTextAreaPDF("continua alla pagina successiva", XRightLimit - 200, 200) { Y = _ylowerlimitoriginal - 10, AutoIncrementYWritable = false, TextHorizontalAlign = TextAlign.Right, FontSize = 6, AbsolutePosition = true });
//AddPage(false);
//#endregion
break;
default:
throw new Exception("ReportType da gestire: [Consulenza.ReportWriter.Business.TablePDF_ContinuedOnNextPage()]");
}
}
/// <summary>
/// Disegna il salto pagina per l'ogetto TablePDF.
/// Aggiunge una pagina.
/// </summary>
private void TablePDF_ContinuedOnNextPage()
{
switch (_reportEnvironment.ReportType)
{
case ReportType.Base_Proposta:
case ReportType.Unica_Diagnosi:
case ReportType.Unica_Monitoraggio:
case ReportType.Unica_Proposta:
case ReportType.Unica_Nucleo:
WriteElement(new ImagePDF(435, 0.15F, "changepage.png") { AutoIncrementYWritable = false });
WriteElement(new FormattedTextAreaPDF("continua alla pagina successiva", 450, 200) { FontSize = 6, AutoIncrementYWritable = false, AbsolutePosition = true });
AddPage(false);
AddSpace(2);
WriteElement(new ImagePDF(XLeftLimit, 0.15F, "changepage.png") { Y = YUpperLimit + 2, AutoIncrementYWritable = false });
WriteElement(new FormattedTextAreaPDF("continua dalla pagina precedente", XLeftLimit + 15, 200) { Y = YUpperLimit + 2, FontSize = 6, AutoIncrementYWritable = true, AbsolutePosition = true });
AddSpace(20);
break;
case ReportType.Immobiliare_Diagnosi:
case ReportType.Immobiliare_DiagnosiNucleo:
case ReportType.Immobiliare_MappaturaPreliminare:
case ReportType.Immobiliare_Finalita:
#region Immobiliare
WriteElement(new FormattedTextAreaPDF("continua alla pagina successiva", XRightLimit - 200, 200) { Y = _ylowerlimitoriginal - 10, AutoIncrementYWritable = false, TextHorizontalAlign = TextAlign.Right, FontSize = 6, AbsolutePosition = true });
AddPage(false);
#endregion
break;
case ReportType.Immobiliare_Monitoraggio:
#region Immobiliare Monitoraggio
//WriteElement(new FormattedTextAreaPDF("continua alla pagina successiva", XRightLimit - 350, 200) { Y = _ylowerlimitoriginal-2, AutoIncrementYWritable = false, TextHorizontalAlign = TextAlign.Right, FontSize = 6, AbsolutePosition = true });
WriteElement(new FormattedTextAreaPDF("continua alla pagina successiva", XRightLimit - 350, 200) { Y = _ylowerlimitoriginal - 8, AutoIncrementYWritable = false, TextHorizontalAlign = TextAlign.Right, FontSize = 6, AbsolutePosition = true });
AddPage(false);
#endregion
break;
case ReportType.Immobiliare_MonitoraggioNuclei:
#region Immobiliare Monitoraggio
WriteElement(new FormattedTextAreaPDF("continua alla pagina successiva", XRightLimit - 350, 200) { Y = _ylowerlimitoriginal-10, AutoIncrementYWritable = false, TextHorizontalAlign = TextAlign.Right, FontSize = 6, AbsolutePosition = true });
AddPage(false);
#endregion
break;
default:
throw new Exception("ReportType da gestire: [Consulenza.ReportWriter.Business.TablePDF_ContinuedOnNextPage()]");
}
}
/// <summary>
/// Scrive le note della tabella nel footer della pagina.
/// </summary>k
/// <param name="notesFooterPage"></param>
private void WriteNoteFooterPage(List<TableNotePDF> notesFooterPage)
{
if (notesFooterPage.Count <= 0) return;
var newnotesFooterPage = notesFooterPage;
newnotesFooterPage.Reverse();
float yNote = (_ylowerlimitoriginal) - _spacenotefooterpagePerpage;
foreach (var noteFooterPage in newnotesFooterPage)
{
var areatoWrite = new FormattedTextAreaPDF(noteFooterPage.Text, XLeftLimit, XRightLimit - XLeftLimit)
{
Y = yNote,
FontSize = noteFooterPage.FontSize
};
WriteElement(areatoWrite);
yNote -= noteFooterPage.FontSize;
_spacenotefooterpagePerpage += noteFooterPage.FontSize;
}
}
/// <summary>
/// Scrive le informazioni da riportare nel footer della pagina.
/// Le informazioni vengono recuperate a questo livello dalla struttura _reportEnvironment.
/// </summary>
private void WriteFooterPage(ReportType reportType)
{
switch (reportType)
{
case ReportType.Base_Proposta:
{
#region Recupero le informazione necessarie
string nomeCliente = Helper.CapitalizeWords(_reportEnvironment.Cliente.Nome);
string cognomeCliente = Helper.CapitalizeWords(_reportEnvironment.Cliente.Cognome);
string nominativoPrivateBanker = Helper.CapitalizeWords(_reportEnvironment.PrivateBanker.Nominativo);
string indirizzoPrivateBanker = Helper.CapitalizeWords(
_reportEnvironment.PrivateBanker.Indirizzo) + " " +
_reportEnvironment.PrivateBanker.NumeroCivico + " - " +
_reportEnvironment.PrivateBanker.Cap + " " +
Helper.CapitalizeWords(_reportEnvironment.PrivateBanker.Citta);
string telefonoPrivateBanker = "Tel. " +
_reportEnvironment.PrivateBanker.PrefissoTelefono +
_reportEnvironment.PrivateBanker.Telefono;
#endregion
#region Footer parte sinistra
// Footer parte sinistra
var labelProduzioneReport = new FormattedTextAreaPDF("Report prodotto per", XLeftLimit, 200, TextAlign.Left) { Y = _yendpage + 15, FontSize = 7, AutoIncrementYWritable = false };
var labelCliente = new FormattedTextAreaPDF(string.Format("{0} {1}", nomeCliente, cognomeCliente), XLeftLimit, 200, TextAlign.Left) { Y = _yendpage + 25, FontSize = 7, FontBold = true, AutoIncrementYWritable = false };
WriteElement(labelProduzioneReport);
WriteElement(labelCliente);
#endregion
#region Footer parte destra
// Footer parte destra
var labelPrivateBanker = new FormattedTextAreaPDF("Private Banker", 350F, 200, TextAlign.Right) { Y = _yendpage + 15, FontSize = 7, FontBold = true, AutoIncrementYWritable = false };
var labelNomeCognomePrivateBanker = new FormattedTextAreaPDF(nominativoPrivateBanker, 350F, 200, TextAlign.Right) { Y = _yendpage + 25, FontSize = 7, FontBold = true, AutoIncrementYWritable = false };
var labelIndirizzoPrivateBanker = new FormattedTextAreaPDF(indirizzoPrivateBanker, 350F, 200, TextAlign.Right) { Y = _yendpage + 35, FontSize = 7, AutoIncrementYWritable = false };
var labelTelefonoPrivateBanker = new FormattedTextAreaPDF(telefonoPrivateBanker, 350F, 200, TextAlign.Right) { Y = _yendpage + 45, FontSize = 7, AutoIncrementYWritable = false };
WriteElement(labelPrivateBanker);
WriteElement(labelNomeCognomePrivateBanker);
WriteElement(labelIndirizzoPrivateBanker);
WriteElement(labelTelefonoPrivateBanker);
#endregion
}
break;
case ReportType.Immobiliare_Diagnosi:
case ReportType.Immobiliare_MappaturaPreliminare:
case ReportType.Immobiliare_Finalita:
{
var nomeCliente = Helper.CapitalizeWords(_reportEnvironment.Cliente.Nome);
var cognomeCliente = Helper.CapitalizeWords(_reportEnvironment.Cliente.Cognome);
string labelCliente = _reportEnvironment.Cliente.Tipo == ClienteType.Fisico ? "Codice fiscale" : _reportEnvironment.Cliente.CodiceFiscale != "" ? "Codice fiscale" : "Partita Iva";
string datoCliente = _reportEnvironment.Cliente.Tipo == ClienteType.Fisico ? _reportEnvironment.Cliente.CodiceFiscale : _reportEnvironment.Cliente.CodiceFiscale != "" ? _reportEnvironment.Cliente.CodiceFiscale : _reportEnvironment.Cliente.PartitaIva;
var cliente = new FormattedTextAreaPDF(string.Format("{0} {1} {2} - {3} {4}", "<B>Cliente:</B>", nomeCliente, cognomeCliente, "Codice fiscale", datoCliente), XLeftLimit) { Y = _yendpage + 40, AutoIncrementYWritable = false };
var privateBanker = new FormattedTextAreaPDF(string.Format("{0} {1}", "<B>Private Banker:</B>", Helper.CapitalizeWords(_reportEnvironment.PrivateBanker.Nominativo)), XLeftLimit) { Y = _yendpage + 54, AutoIncrementYWritable = false };
WriteElement(cliente);
WriteElement(privateBanker);
}
break;
case ReportType.Immobiliare_Monitoraggio:
{
var nomeCliente = Helper.CapitalizeWords(_reportEnvironment.Cliente.Nome);
var cognomeCliente = Helper.CapitalizeWords(_reportEnvironment.Cliente.Cognome);
string labelCliente = _reportEnvironment.Cliente.Tipo == ClienteType.Fisico ? "Codice fiscale" : _reportEnvironment.Cliente.CodiceFiscale != "" ? "Codice fiscale" : "Partita Iva";
string datoCliente = _reportEnvironment.Cliente.Tipo == ClienteType.Fisico ? _reportEnvironment.Cliente.CodiceFiscale : _reportEnvironment.Cliente.CodiceFiscale != "" ? _reportEnvironment.Cliente.CodiceFiscale : _reportEnvironment.Cliente.PartitaIva;
var cliente = new FormattedTextAreaPDF(string.Format("{0} {1} {2} - {3} {4}", "<B>Cliente:</B>", nomeCliente, cognomeCliente, "Codice fiscale", datoCliente), XLeftLimit + 4) { Y = _yendpage + 47, AutoIncrementYWritable = false, FontSize = 6 };
var privateBanker = new FormattedTextAreaPDF(string.Format("{0} {1}", "<B>Private Banker:</B>", Helper.CapitalizeWords(_reportEnvironment.PrivateBanker.Nominativo)), XLeftLimit + 4) { Y = _yendpage + 56, AutoIncrementYWritable = false, FontSize = 6 };
WriteElement(cliente);
WriteElement(privateBanker);
}
break;
case ReportType.Immobiliare_DiagnosiNucleo:
{
var nomeNucleo = Helper.CapitalizeWords(_reportEnvironment.NucleoImmobiliare.NomeNucleo);
var nucleo = new FormattedTextAreaPDF(string.Format("{0} {1}", "<B>Nucleo:</B>", nomeNucleo), XLeftLimit) { Y = _yendpage + 40, AutoIncrementYWritable = false };
var privateBanker = new FormattedTextAreaPDF(string.Format("{0} {1}", "<B>Private Banker:</B>", Helper.CapitalizeWords(_reportEnvironment.PrivateBanker.Nominativo)), XLeftLimit) { Y = _yendpage + 54, AutoIncrementYWritable = false };
WriteElement(nucleo);
WriteElement(privateBanker);
}
break;
case ReportType.Immobiliare_MonitoraggioNuclei:
{
var nomeNucleo = Helper.CapitalizeWords(_reportEnvironment.NucleoImmobiliare.NomeNucleo);
var nucleo = new FormattedTextAreaPDF(string.Format("{0} {1}", "<B>Nucleo:</B>", nomeNucleo), XLeftLimit + 4) { Y = _yendpage + 47, AutoIncrementYWritable = false, FontSize = 6 };
var privateBanker = new FormattedTextAreaPDF(string.Format("{0} {1}", "<B>Private Banker:</B>", Helper.CapitalizeWords(_reportEnvironment.PrivateBanker.Nominativo)), XLeftLimit + 4) { Y = _yendpage + 56, AutoIncrementYWritable = false, FontSize = 6 };
WriteElement(nucleo);
WriteElement(privateBanker);
}
break;
case ReportType.Unica_Diagnosi:
case ReportType.Unica_Monitoraggio:
case ReportType.Unica_Proposta:
case ReportType.Unica_Nucleo:
var reportAnonimo = _reportEnvironment.ReportStruct.GetOptionReport<Opzione1>().ReportAnonimo;
#region Colonna Sinistra
var sProduzioneReport = reportAnonimo ? "Report prodotto {0}" : "Report prodotto {0} per";
var ftaProduzioneReport = new FormattedTextAreaPDF(string.Format(sProduzioneReport, DateTime.Now.ToLongDateString()), XLeftLimit, 500)
{
Y = YLowerLimit + 17,
AutoIncrementYWritable = false,
AbsolutePosition = true,
FontSize = 7
};
WriteElement(ftaProduzioneReport);
if (!reportAnonimo)
{
string nome = reportType == ReportType.Unica_Nucleo ? _reportEnvironment.Cliente.Cognome : Helper.CapitalizeWords(_reportEnvironment.Cliente.Cognome + " " + _reportEnvironment.Cliente.Nome);
var ftaNominativoCliente = new FormattedTextAreaPDF(string.Format("{0}", nome), XLeftLimit, 500)
{
Y = YLowerLimit + 26,
AutoIncrementYWritable = false,
AbsolutePosition = true,
FontBold = true,
FontSize = 7
};
WriteElement(ftaNominativoCliente);
}
#endregion
#region Colonna Destra
var ftaPrivateBanker = new FormattedTextAreaPDF("Private Banker", XRightLimit - 300, 300)
{
Y = YLowerLimit + 17,
AutoIncrementYWritable = false,
AbsolutePosition = true,
FontBold = true,
TextHorizontalAlign = TextAlign.Right,
FontSize = 7
};
WriteElement(ftaPrivateBanker);
var ftaNominativoPrivateBanker = new FormattedTextAreaPDF(Helper.CapitalizeWords(_reportEnvironment.PrivateBanker.Nominativo), XRightLimit - 300, 300)
{
Y = YLowerLimit + 26,
AutoIncrementYWritable = false,
AbsolutePosition = true,
FontBold = true,
TextHorizontalAlign = TextAlign.Right,
FontSize = 7
};
WriteElement(ftaNominativoPrivateBanker);
var ftaIndirizzoPrivateBanker = new FormattedTextAreaPDF(string.Format("{0} {1} - {2} {3}", Helper.CapitalizeWords(_reportEnvironment.PrivateBanker.Indirizzo), _reportEnvironment.PrivateBanker.NumeroCivico, _reportEnvironment.PrivateBanker.Cap, _reportEnvironment.PrivateBanker.Citta), XRightLimit - 500, 500)
{
Y = YLowerLimit + 35,
AutoIncrementYWritable = false,
AbsolutePosition = true,
TextHorizontalAlign = TextAlign.Right,
FontSize = 7
};
WriteElement(ftaIndirizzoPrivateBanker);
var ftaTelefonoPrivateBanker = new FormattedTextAreaPDF(string.Format("Tel. {0} - {1}", _reportEnvironment.PrivateBanker.PrefissoTelefono, _reportEnvironment.PrivateBanker.Telefono), XRightLimit - 300, 300)
{
Y = YLowerLimit + 44,
AutoIncrementYWritable = false,
AbsolutePosition = true,
TextHorizontalAlign = TextAlign.Right,
FontSize = 7
};
WriteElement(ftaTelefonoPrivateBanker);
#endregion
break;
default:
throw new Exception("ReportType da gestire: [Consulenza.ReportWriter.Business.WriteFooterPage()]");
}
}
private List<Tuple<PageHeader, FormattedTextAreaPDF>> headers = new List<Tuple<PageHeader, FormattedTextAreaPDF>>();
/// <summary>
/// Scrive tutti gli elementi di tipo FORMATTEDTEXTAREA o IMAGE aggiunti al capitolo.
/// </summary>
private void WriteChapterTitle(ReportType reportType)
{
// ES Modifica 20190322 per Semestrale
if (reportType == ReportType.Immobiliare_Monitoraggio || reportType == ReportType.Immobiliare_MonitoraggioNuclei)
{
// we've never encountered a problem of typing page (1/3)
// the problem is, that we need now to generate all pages first and then
// come back to all added elements, and see whether there are pages belonging to same chapter/section
// and add strings (eg. (1/2))
// here, we add all headers to headers list and after generating all elements (and pages)
// we will fix headers with proper values
// keep in mind, that across entire solution, we use convention 1 chapter = 1 section
int chapterId = int.Parse(_currentchapter.ToString());
var currentChapterHeader = MonitoraggioImmobiliarePageHeaderManager.GetHeader(chapterId);
int xOffset = 20;
if (currentChapterHeader.ImagePath != null)
{
var image = new ImagePDF(XLeftLimit + xOffset, 0, currentChapterHeader.ImagePath)
{
Width = currentChapterHeader.ImageWidth,
Height = currentChapterHeader.ImageHeight,
AutoIncrementYWritable = false,
//Y = 14 + currentChapterHeader.DeltaY
Y = 10 + currentChapterHeader.DeltaY
};
WriteElement(image);
xOffset += (int)image.Width;
}
string headerText = string.Empty;
headerText += currentChapterHeader.SectionName ?? string.Empty;
if (currentChapterHeader.SectionName != null && currentChapterHeader.ChapterName != null)
{
headerText += " - ";
}
headerText += currentChapterHeader.ChapterName != null ? (string.Format("<font color='AE9651'><b>{0}{1}</b></font>", currentChapterHeader.ChapterName, currentChapterHeader.TextReplaceGuid)) : string.Empty;
//FormattedTextAreaPDF pageHeader = new FormattedTextAreaPDF(headerText, XLeftLimit + xOffset + 6) { FontSize = 16, FontColor = ColorPDF.Immobiliare_Grigio_TitoloPiccolo, AutoIncrementYWritable = false, Width = 700, Y = 20, FixedHeight = 20 };
FormattedTextAreaPDF pageHeader = new FormattedTextAreaPDF(headerText, XLeftLimit + xOffset + 6) { FontSize = 16, FontColor = ColorPDF.Immobiliare_Grigio_TitoloPiccolo, AutoIncrementYWritable = false, Width = 700, Y = 16, FixedHeight = 20 };
headers.Add(new Tuple<PageHeader, FormattedTextAreaPDF>(currentChapterHeader, pageHeader));
WriteElement(pageHeader);
}
else
{
// Quando numberPageOnChapter = 0 non c'è bisogno di disegnare gli oggetti aggiunti al capitolo perché sara l'invocazione alla classe del capitolo stesso che lo farà.
if (!_currentchapter.ChapterFacade.RepeatOnEachPage || numberPageOnChapter == 0)
return;
foreach (var item in _currentchapter.Elements.Where(o => o.ObjectType == ObjectTypePdf.FORMATTEDTEXTAREA || o.ObjectType == ObjectTypePdf.IMAGE))
{
switch (item.ObjectType)
{
case ObjectTypePdf.FORMATTEDTEXTAREA:
WriteElement((FormattedTextAreaPDF)item);
break;
case ObjectTypePdf.IMAGE:
WriteElement((ImagePDF)item);
break;
}
}
}
}
/// <summary>
/// Invoca il gestore delle classi che devono renderizzare le intestazioni di pagina (istanze di DTOPageFrameDataClassImplementation).
/// </summary>
/// <param name="pagetype">Tipo di template da utilizzare per la pagina da aggiungere.</param>
private void AddPage(PagePDF.PagePDFType pagetype = PagePDF.PagePDFType.Generic)
{
_spacenotefooterpagePerpage = 0;
YLowerLimit = _ylowerlimitoriginal;
_ywritable = YUpperLimit;
if (pagetype == PagePDF.PagePDFType.Generic)
{
_page = new ImportedPage(_generictemplate.GetPage(1));
switch (_reportEnvironment.ReportType)
{
case ReportType.Base_Proposta:
_page.Elements.Add(new PageNumberingLabel("Pagina %%SP%% di %%ST%%", XLeftLimit, _yendpage, XRightLimit - XLeftLimit, 12, Font.Helvetica, 7, TextAlign.Left));
break;
case ReportType.Immobiliare_Diagnosi:
case ReportType.Immobiliare_DiagnosiNucleo:
case ReportType.Immobiliare_MappaturaPreliminare:
case ReportType.Immobiliare_Finalita:
_page.Elements.Add(new PageNumberingLabel("%%SP%% di %%ST%%", XLeftLimit, _yendpage, XRightLimit - XLeftLimit, 12) { FontSize = 7 });
break;
case ReportType.Immobiliare_Monitoraggio:
_page.Elements.Add(new PageNumberingLabel("%%SP%% di %%ST%%", XLeftLimit + 5, _yendpage + 6, XRightLimit - XLeftLimit, 12, new OpenTypeFont("verdanab.TTF"), 6) { FontSize = 6 });
break;
case ReportType.Immobiliare_MonitoraggioNuclei:
_page.Elements.Add(new PageNumberingLabel("%%SP%% di %%ST%%", XLeftLimit + 5, _yendpage + 6, XRightLimit - XLeftLimit, 12, new OpenTypeFont("verdanab.TTF"), 6) { FontSize = 6 });
break;
case ReportType.Unica_Proposta:
string titolo = string.Empty;
if (!_reportEnvironment.Adeguata)
{
WriteElement(new RectanglePDF(XLeftLimit, 15, 41, 220, ColorPDF.ConsulenzaUnica_Grigio_SfondoColonnaHeaderFooterTabella) { AutoIncrementYWritable = false, Y = 15 });
WriteElement(new LinePDF(XLeftLimit, 260, 1) { AutoIncrementYWritable = false, Y1 = 37, Y2 = 37, Color = ColorPDF.ConsulenzaUnica_Rosso });
titolo = "REPORT OPERAZIONI RICHIESTE";
}
else
titolo = "REPORT PROPOSTA";
WriteElement(new FormattedTextAreaPDF(titolo, XLeftLimit, 300) { FontBold = true, FontSize = 11, FontColor = ColorPDF.ConsulenzaUnica_Rosso, AutoIncrementYWritable = false, Y = 40 });
break;
case ReportType.Unica_Nucleo: //tolta paginazione per ticket #1728
case ReportType.Unica_Diagnosi:
case ReportType.Unica_Monitoraggio:
//_page.Elements.Add(new PageNumberingLabel("pagina %%SP%% di %%ST%%", XRightLimit - 65, _yendpage + 80, XRightLimit - XLeftLimit, 12) { FontSize = 7 });
WriteElement(new FormattedTextAreaPDF(string.Format("REPORT {0}", HelperEnum<ReportType>.GetDescription(_reportEnvironment.ReportType)), XLeftLimit, 300) { FontBold = true, FontSize = 11, FontColor = ColorPDF.ConsulenzaUnica_Rosso, AutoIncrementYWritable = false, Y = 40 });
break;
default:
throw new Exception("ReportType da gestire: [Consulenza.ReportWriter.Business.AddPage(PagePDF.PagePDFType pagetype)]");
}
WriteChapterTitle(_reportEnvironment.ReportType);
WriteFooterPage(_reportEnvironment.ReportType);
// Aggiungo gli elementi di _repeaterElements
if (_repeaterElements != null)
{
foreach (var item in _repeaterElements)
WriteElement(item);
}
}
else
_page = new ImportedPage(_covertemplate.GetPage(1));
_document.Pages.Add(_page);
int count = _document.Pages.Count;
_printinginnewpage = true;
}
/// <summary>
/// Invoca il gestore delle classi che devono renderizzare le intestazioni di pagina
/// (istanze di DTOPageFrameDataClassImplementation) ed aggiunge una nuova pagina vuota e numerata al documento.
/// Se resetylowerlimit=true viene impostato _ylowerlimit=_ylowerlimitoriginal.
/// </summary>
/// <param name="resetylowerlimit"></param>
private void AddPage(bool resetylowerlimit)
{
AddPage();
if (resetylowerlimit)
YLowerLimit = _ylowerlimitoriginal;
}
/// <summary>
/// Aggiunge uno spazio sull'asse y pari a space
/// </summary>
/// <param name="space"></param>
private void AddSpace(float space)
{
_ywritable += space;
}
}
}
Reference in New Issue View Git Blame Copy Permalink