1446 lines
61 KiB
C#
1446 lines
61 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel.Design;
|
|
using System.IO;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using TSpdf.IO.Font.Constants;
|
|
using TSpdf.IO.Image;
|
|
using TSpdf.Kernel.Colors;
|
|
using TSpdf.Kernel.Font;
|
|
using TSpdf.Kernel.Geom;
|
|
using TSpdf.Kernel.Pdf.Canvas;
|
|
using TSpdf.Kernel.Pdf.Extgstate;
|
|
using TSpdf.Layout;
|
|
using TSpdf.Layout.Element;
|
|
using TSpdf.Layout.Properties;
|
|
using TSpdf.Layout.Splitting;
|
|
using static tsPDFUtilsCore.Enums;
|
|
|
|
namespace tsPDFUtilsCore
|
|
{
|
|
public class Sellado
|
|
{
|
|
|
|
public async static Task<bool> SellaPDFAsync(Stream PdfOrigen, Stream PdfDestino, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, CancellationTokenSource cts = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
|
|
{
|
|
bool Res = false;
|
|
await Task.Factory.StartNew(() =>
|
|
{
|
|
Res = SellaPDF(PdfOrigen, PdfDestino, TextosAInsertar, ImagenesAInsertar, dlgpr, cts, ConvertirPDFA, PDFAObligatorio);
|
|
});
|
|
return Res;
|
|
}
|
|
public static bool SellaPDF(Stream PdfOrigen, Stream PdfDestino, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, CancellationTokenSource cts = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
|
|
{
|
|
try
|
|
{
|
|
Progreso prg = new Progreso();
|
|
if (dlgpr != null)
|
|
{
|
|
prg.Estado = "Cargando Documento";
|
|
dlgpr.Invoke(prg);
|
|
}
|
|
|
|
|
|
Stream pdfLectura;
|
|
|
|
if (ConvertirPDFA)
|
|
{
|
|
try
|
|
{
|
|
pdfLectura = Utilidades.crearPDFA(PdfOrigen);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (PDFAObligatorio)
|
|
{
|
|
throw new Exception(ex.Message, ex);
|
|
}
|
|
else
|
|
{
|
|
PdfOrigen.Position = 0;
|
|
pdfLectura = PdfOrigen;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pdfLectura = PdfOrigen;
|
|
}
|
|
|
|
|
|
TSpdf.Kernel.Pdf.PdfReader reader = new TSpdf.Kernel.Pdf.PdfReader(pdfLectura);
|
|
reader.SetUnethicalReading(true);
|
|
|
|
TSpdf.Kernel.Pdf.PdfWriter writer = new TSpdf.Kernel.Pdf.PdfWriter(PdfDestino);
|
|
|
|
TSpdf.Kernel.Pdf.PdfDocument pdf = new TSpdf.Kernel.Pdf.PdfDocument(reader, writer);
|
|
|
|
Document document = new Document(pdf);
|
|
|
|
int numeroPaginas = pdf.GetNumberOfPages();
|
|
|
|
if (dlgpr != null)
|
|
{
|
|
|
|
prg.NumeroPaginasTotal = numeroPaginas;
|
|
prg.Estado = "Sellando Documento";
|
|
dlgpr.Invoke(prg);
|
|
}
|
|
|
|
Image[] imagenes = null;
|
|
if (ImagenesAInsertar != null)
|
|
{
|
|
imagenes = new Image[ImagenesAInsertar.Count];
|
|
for (int k = 0; k < ImagenesAInsertar.Count; k++)
|
|
{
|
|
if (cts != null && cts.Token.IsCancellationRequested) return false;
|
|
ImageData imageData = ImageDataFactory.Create(ImagenesAInsertar[k].Imagen);
|
|
imagenes[k] = new Image(imageData);
|
|
}
|
|
}
|
|
|
|
|
|
for (int i = 1; i <= numeroPaginas; i++)
|
|
{
|
|
if (cts != null && cts.Token.IsCancellationRequested) return false;
|
|
if (dlgpr != null)
|
|
{
|
|
prg.NumeroPaginaActual = i;
|
|
prg.Estado = "Procesando Página " + i.ToString() + " / " + prg.NumeroPaginasTotal.ToString();
|
|
dlgpr.Invoke(prg);
|
|
}
|
|
if (TextosAInsertar != null)
|
|
{
|
|
for (int j = 0; j < TextosAInsertar.Count; j++)
|
|
{
|
|
if (cts != null && cts.Token.IsCancellationRequested) return false;
|
|
if (TextosAInsertar[j].PaginaInicio <= i && (TextosAInsertar[j].PaginaFin >= i || TextosAInsertar[j].PaginaFin == 0))
|
|
{
|
|
controlarTextos(pdf, TextosAInsertar[j],i,numeroPaginas);
|
|
}
|
|
}
|
|
}
|
|
if (ImagenesAInsertar != null)
|
|
{
|
|
if (cts != null && cts.Token.IsCancellationRequested) return false;
|
|
for (int k = 0; k < ImagenesAInsertar.Count; k++)
|
|
if (ImagenesAInsertar[k].PaginaInicio <= i && (ImagenesAInsertar[k].PaginaFin >= i || ImagenesAInsertar[k].PaginaFin == 0))
|
|
{
|
|
controlarImagenes(pdf, ImagenesAInsertar[k], i, imagenes[k]);
|
|
}
|
|
}
|
|
}
|
|
|
|
pdf.Close();
|
|
document.Close();
|
|
writer.Close();
|
|
writer.Dispose();
|
|
reader.Close();
|
|
if (cts != null && cts.IsCancellationRequested)
|
|
return false;
|
|
else return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new Exception(ex.Message,ex);
|
|
}
|
|
}
|
|
public static bool SellaPDF(string PdfOrigen, string PdfDestino, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, CancellationTokenSource cts = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
|
|
{
|
|
try
|
|
{
|
|
Progreso prg = new Progreso();
|
|
if (dlgpr != null)
|
|
{
|
|
prg.Estado = "Cargando Documento";
|
|
dlgpr.Invoke(prg);
|
|
}
|
|
|
|
Stream pdfLectura;
|
|
if (ConvertirPDFA)
|
|
{
|
|
FileStream fs = null;
|
|
try
|
|
{
|
|
fs = new FileStream(PdfOrigen, FileMode.Open, FileAccess.Read);
|
|
pdfLectura = Utilidades.crearPDFA(fs);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (fs != null) fs.Close();
|
|
if(PDFAObligatorio)
|
|
{
|
|
throw new Exception(ex.Message,ex);
|
|
}
|
|
else
|
|
{
|
|
pdfLectura = new FileStream(PdfOrigen, FileMode.Open, FileAccess.Read);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pdfLectura = new FileStream(PdfOrigen, FileMode.Open, FileAccess.Read);
|
|
}
|
|
|
|
TSpdf.Kernel.Pdf.PdfReader reader = new TSpdf.Kernel.Pdf.PdfReader(pdfLectura);
|
|
reader.SetUnethicalReading(true);
|
|
|
|
TSpdf.Kernel.Pdf.PdfWriter writer = new TSpdf.Kernel.Pdf.PdfWriter(PdfDestino);
|
|
|
|
TSpdf.Kernel.Pdf.PdfDocument pdf = new TSpdf.Kernel.Pdf.PdfDocument(reader, writer);
|
|
|
|
Document document = new Document(pdf);
|
|
|
|
int numeroPaginas = pdf.GetNumberOfPages();
|
|
|
|
if (dlgpr != null)
|
|
{
|
|
|
|
prg.NumeroPaginasTotal = numeroPaginas;
|
|
prg.Estado = "Sellando Documento";
|
|
dlgpr.Invoke(prg);
|
|
}
|
|
|
|
Image[] imagenes = null;
|
|
if (ImagenesAInsertar != null)
|
|
{
|
|
imagenes = new Image[ImagenesAInsertar.Count];
|
|
for (int k = 0; k < ImagenesAInsertar.Count; k++)
|
|
{
|
|
if (cts != null && cts.Token.IsCancellationRequested) return false;
|
|
ImageData imageData = ImageDataFactory.Create(ImagenesAInsertar[k].Imagen);
|
|
imagenes[k] = new Image(imageData);
|
|
}
|
|
}
|
|
|
|
|
|
for (int i = 1; i <= numeroPaginas; i++)
|
|
{
|
|
if (cts != null && cts.Token.IsCancellationRequested) return false;
|
|
if (dlgpr != null)
|
|
{
|
|
prg.NumeroPaginaActual = i;
|
|
prg.Estado = "Procesando Página " + i.ToString() + " / " + prg.NumeroPaginasTotal.ToString();
|
|
dlgpr.Invoke(prg);
|
|
}
|
|
if (TextosAInsertar != null)
|
|
{
|
|
for (int j = 0; j < TextosAInsertar.Count; j++)
|
|
{
|
|
if (cts != null && cts.Token.IsCancellationRequested) return false;
|
|
if (TextosAInsertar[j].PaginaInicio <= i && (TextosAInsertar[j].PaginaFin >= i || TextosAInsertar[j].PaginaFin == 0))
|
|
{
|
|
controlarTextos(pdf, TextosAInsertar[j], i, numeroPaginas);
|
|
}
|
|
}
|
|
}
|
|
if (ImagenesAInsertar != null)
|
|
{
|
|
if (cts != null && cts.Token.IsCancellationRequested) return false;
|
|
for (int k = 0; k < ImagenesAInsertar.Count; k++)
|
|
if (ImagenesAInsertar[k].PaginaInicio <= i && (ImagenesAInsertar[k].PaginaFin >= i || ImagenesAInsertar[k].PaginaFin == 0))
|
|
{
|
|
controlarImagenes(pdf, ImagenesAInsertar[k], i, imagenes[k]);
|
|
}
|
|
}
|
|
}
|
|
|
|
pdf.Close();
|
|
document.Close();
|
|
writer.Close();
|
|
writer.Dispose();
|
|
reader.Close();
|
|
if (cts != null && cts.IsCancellationRequested)
|
|
return false;
|
|
else return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new Exception(ex.Message, ex);
|
|
}
|
|
|
|
}
|
|
|
|
private static void controlarImagenes(TSpdf.Kernel.Pdf.PdfDocument pdf, ImagenEnPdf ImagenAInsertar, int numeroPagina, Image imagen)
|
|
{
|
|
TSpdf.Kernel.Pdf.PdfPage pagina = pdf.GetPage(numeroPagina);
|
|
Rectangle tamanoPagina = pagina.GetPageSizeWithRotation();
|
|
|
|
var anchoPagina = tamanoPagina.GetWidth();
|
|
var altoPagina = tamanoPagina.GetHeight();
|
|
|
|
// Cambia el ancho y alto de la página dependiendo de sus medidas
|
|
tamanoPagina.SetWidth(comprobarAncho(anchoPagina, altoPagina, pagina.GetRotation()));
|
|
tamanoPagina.SetHeight(comprobarAlto(anchoPagina, altoPagina, pagina.GetRotation()));
|
|
|
|
var cropBoxPagina = pagina.GetCropBox();
|
|
var mediaBox = pagina.GetMediaBox();
|
|
|
|
Rectangle diferenciaTamano;
|
|
if (mediaBox.GetWidth() != cropBoxPagina.GetWidth() || mediaBox.GetHeight() != cropBoxPagina.GetHeight())
|
|
{
|
|
diferenciaTamano = new Rectangle(cropBoxPagina.GetX() - mediaBox.GetX(), cropBoxPagina.GetY() - mediaBox.GetY(), mediaBox.GetWidth() - cropBoxPagina.GetWidth(), mediaBox.GetHeight() - cropBoxPagina.GetHeight());
|
|
}
|
|
else
|
|
{
|
|
diferenciaTamano = new Rectangle(cropBoxPagina.GetX(), cropBoxPagina.GetY(), mediaBox.GetWidth(), mediaBox.GetHeight());
|
|
}
|
|
|
|
PdfCanvas pdfCanvas = new PdfCanvas(pagina);
|
|
PdfExtGState pdfExtGState = new PdfExtGState();
|
|
pdfExtGState.SetFillOpacity((float)(1 - ImagenAInsertar.Transparencia));
|
|
pdfExtGState.SetStrokeOpacity((float)(1 - ImagenAInsertar.Transparencia));
|
|
pdfCanvas.SetExtGState(pdfExtGState);
|
|
|
|
Canvas canvas = new Canvas(pdfCanvas, pagina.GetPageSizeWithRotation(), true);
|
|
|
|
Image image = imagen.ScaleToFit(ImagenAInsertar.EscalaHorizontal, ImagenAInsertar.EscalaVertical).SetRotationAngle(ImagenAInsertar.AnguloRotacion);
|
|
|
|
// Suma del ángulo del texto + el ángulo de la página, para que el ángulo final sea el correcto.
|
|
float anguloImgPag = ((ImagenAInsertar.AnguloRotacion + pagina.GetRotation()));
|
|
|
|
medidasTextoImagen medidasImagenInsertar = comprobarMedidasImagen(pagina.GetRotation(), ImagenAInsertar, anguloImgPag,image);
|
|
|
|
var distanciaX = calcularDistanciaX((int)ImagenAInsertar.EsquinaReferencia, tamanoPagina, ImagenAInsertar.CoordenadaX, medidasImagenInsertar.ancho, medidasImagenInsertar.alto, anguloImgPag, pagina.GetRotation(), diferenciaTamano);
|
|
var distanciaY = calcularDistanciaY((int)ImagenAInsertar.EsquinaReferencia, tamanoPagina, ImagenAInsertar.CoordenadaY, medidasImagenInsertar.ancho, medidasImagenInsertar.alto, anguloImgPag, pagina.GetRotation(), diferenciaTamano);
|
|
|
|
|
|
canvas.Add(image.SetFixedPosition(distanciaX
|
|
, distanciaY
|
|
)
|
|
.SetRotationAngle((ImagenAInsertar.AnguloRotacion + pagina.GetRotation()) * (float)0.017453));
|
|
|
|
|
|
canvas.Close();
|
|
}
|
|
private static void controlarTextos(TSpdf.Kernel.Pdf.PdfDocument pdf, TextoEnPdf TextoAInsertar, int numeroPagina, int totalNumeroPagina)
|
|
{
|
|
TSpdf.Kernel.Pdf.PdfPage pagina = pdf.GetPage(numeroPagina);
|
|
|
|
|
|
Rectangle tamanoPagina = pagina.GetPageSizeWithRotation();
|
|
|
|
var anchoPagina = tamanoPagina.GetWidth();
|
|
var altoPagina = tamanoPagina.GetHeight();
|
|
|
|
// Cambia el ancho y alto de la página dependiendo de sus medidas
|
|
tamanoPagina.SetWidth(comprobarAncho(anchoPagina, altoPagina, pagina.GetRotation()));
|
|
tamanoPagina.SetHeight(comprobarAlto(anchoPagina, altoPagina, pagina.GetRotation()));
|
|
|
|
var cropBoxPagina = pagina.GetCropBox();
|
|
var mediaBox = pagina.GetMediaBox();
|
|
PdfCanvas pdfCanvas = new PdfCanvas(pagina);
|
|
|
|
// Suma del ángulo del texto + el ángulo de la página, para que el ángulo final sea el correcto.
|
|
float anguloTextPag = (TextoAInsertar.AnguloRotacion + pagina.GetRotation());
|
|
|
|
|
|
Rectangle diferenciaTamano;
|
|
if (mediaBox.GetWidth() != cropBoxPagina.GetWidth() || mediaBox.GetHeight() != cropBoxPagina.GetHeight())
|
|
{
|
|
diferenciaTamano = new Rectangle(cropBoxPagina.GetX() - mediaBox.GetX(), cropBoxPagina.GetY() - mediaBox.GetY(), mediaBox.GetWidth() - cropBoxPagina.GetWidth(), mediaBox.GetHeight() - cropBoxPagina.GetHeight());
|
|
}
|
|
else
|
|
{
|
|
diferenciaTamano = new Rectangle(cropBoxPagina.GetX(), cropBoxPagina.GetY(), mediaBox.GetWidth(), mediaBox.GetHeight());
|
|
}
|
|
|
|
PdfExtGState pdfExtGState = new PdfExtGState();
|
|
pdfExtGState.SetFillOpacity((float)(1 - TextoAInsertar.Transparencia));
|
|
pdfCanvas.SetExtGState(pdfExtGState);
|
|
Canvas canvas = new Canvas(pdfCanvas, pagina.GetPageSizeWithRotation(), true);
|
|
Paragraph texto = new Paragraph(TextoAInsertar.Texto)
|
|
.SetWidth(TextoAInsertar.anchoTexto)
|
|
.SetHeight(TextoAInsertar.altoTexto)
|
|
.SetRotationAngle(anguloTextPag * (float)0.017453)
|
|
//.SetBackgroundColor(new DeviceRgb(TextoAInsertar.Color.R, TextoAInsertar.Color.G, TextoAInsertar.Color.B))
|
|
.SetTextAlignment(devolverAlineamiento((int)TextoAInsertar.Alineamiento));
|
|
|
|
canvas.SetFont(devolverTipoFuente(TextoAInsertar.Fuente.ToString()));
|
|
canvas.SetFontSize(TextoAInsertar.TamañoFuente);
|
|
canvas.SetFontColor(new DeviceRgb(TextoAInsertar.Color.R, TextoAInsertar.Color.G, TextoAInsertar.Color.B));
|
|
|
|
// Controla como se muestra el número de páginas
|
|
switch (TextoAInsertar.TipoTexto)
|
|
{
|
|
case TipoTextoEnum.NUMERO_PAGINA_TOTAL_PAGINAS:
|
|
TextoAInsertar.Texto = "PAG " + numeroPagina.ToString().PadLeft(4, '0') + "/" + totalNumeroPagina.ToString().PadLeft(4, '0');
|
|
texto = new Paragraph(TextoAInsertar.Texto)
|
|
.SetWidth(TextoAInsertar.anchoTexto)
|
|
.SetHeight(TextoAInsertar.altoTexto)
|
|
/* Resultado de fórmula matemática(pi/180º) para que el
|
|
ángulo sea el correcto */
|
|
.SetRotationAngle(anguloTextPag * (float)0.017453)
|
|
.SetTextAlignment(devolverAlineamiento((int)TextoAInsertar.Alineamiento));
|
|
break;
|
|
}
|
|
|
|
medidasTextoImagen medidasTextoInsertar = comprobarMedidasTexto(pagina.GetRotation(), TextoAInsertar, anguloTextPag);
|
|
|
|
canvas.ShowTextAligned(texto,
|
|
calcularDistanciaX((int)TextoAInsertar.EsquinaReferencia, tamanoPagina, comprobarEjeXPagRotada(TextoAInsertar.CoordenadaX, TextoAInsertar.CoordenadaY, pagina.GetRotation()), medidasTextoInsertar.ancho, medidasTextoInsertar.alto, anguloTextPag, pagina.GetRotation(), diferenciaTamano),
|
|
calcularDistanciaY((int)TextoAInsertar.EsquinaReferencia, tamanoPagina, comprobarEjeYPagRotada(TextoAInsertar.CoordenadaX, TextoAInsertar.CoordenadaY, pagina.GetRotation()), medidasTextoInsertar.ancho, medidasTextoInsertar.alto, anguloTextPag, pagina.GetRotation(), diferenciaTamano),
|
|
devolverAlineamiento((int)TextoAInsertar.Alineamiento));
|
|
|
|
canvas.Close();
|
|
}
|
|
public static medidasTextoImagen comprobarMedidasTexto(int rotacionPagina, TextoEnPdf TextoAInsertar, float anguloTextPag)
|
|
{
|
|
medidasTextoImagen medidas = new medidasTextoImagen();
|
|
|
|
switch (rotacionPagina)
|
|
{
|
|
case 0:
|
|
if (TextoAInsertar.AnguloRotacion != 0)
|
|
{
|
|
medidas.ancho = 0;
|
|
medidas.alto = 0;
|
|
}
|
|
else
|
|
{
|
|
if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_DERECHA || TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_DERECHA)
|
|
{
|
|
medidas.alto = TextoAInsertar.altoTexto;
|
|
}
|
|
else
|
|
{
|
|
if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
|
|
{
|
|
if (TextoAInsertar.AnguloRotacion == 0)
|
|
{
|
|
medidas.alto = TextoAInsertar.altoTexto;
|
|
}
|
|
else
|
|
{
|
|
medidas.ancho = TextoAInsertar.anchoTexto;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
medidas.ancho = TextoAInsertar.anchoTexto;
|
|
medidas.alto = TextoAInsertar.altoTexto;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
case 90:
|
|
if (TextoAInsertar.AnguloRotacion != 0)
|
|
{
|
|
if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_IZQUIERDA || TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
|
|
{
|
|
medidas.ancho = TextoAInsertar.anchoTexto;
|
|
}
|
|
else
|
|
{
|
|
medidas.ancho = TextoAInsertar.anchoTexto;
|
|
medidas.alto = TextoAInsertar.altoTexto;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_IZQUIERDA || TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
|
|
{
|
|
medidas.alto = TextoAInsertar.altoTexto;
|
|
medidas.ancho = TextoAInsertar.anchoTexto;
|
|
}
|
|
else
|
|
{
|
|
medidas.alto = TextoAInsertar.altoTexto;
|
|
}
|
|
}
|
|
break;
|
|
case 180:
|
|
if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_IZQUIERDA)
|
|
{
|
|
if (anguloTextPag == 270)
|
|
{
|
|
medidas.ancho = TextoAInsertar.altoTexto;
|
|
medidas.alto = TextoAInsertar.anchoTexto;
|
|
}
|
|
else
|
|
{
|
|
medidas.alto = TextoAInsertar.altoTexto;
|
|
}
|
|
}
|
|
else if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
|
|
{
|
|
if (anguloTextPag == 180)
|
|
{
|
|
medidas.alto = TextoAInsertar.altoTexto;
|
|
}
|
|
else
|
|
{
|
|
medidas.ancho = TextoAInsertar.altoTexto;
|
|
}
|
|
}
|
|
else if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_DERECHA)
|
|
{
|
|
if (anguloTextPag == 180)
|
|
{
|
|
medidas.alto = TextoAInsertar.altoTexto;
|
|
medidas.ancho = TextoAInsertar.anchoTexto;
|
|
}
|
|
else
|
|
{
|
|
medidas.ancho = TextoAInsertar.altoTexto;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
medidas.ancho = TextoAInsertar.anchoTexto;
|
|
medidas.alto = TextoAInsertar.altoTexto;
|
|
}
|
|
|
|
break;
|
|
case 270:
|
|
|
|
if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_DERECHA)
|
|
{
|
|
if (TextoAInsertar.AnguloRotacion == 90)
|
|
{
|
|
medidas.alto = TextoAInsertar.altoTexto;
|
|
}
|
|
else
|
|
{
|
|
medidas.ancho = TextoAInsertar.anchoTexto;
|
|
medidas.alto = TextoAInsertar.altoTexto;
|
|
}
|
|
}
|
|
if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
|
|
{
|
|
if (TextoAInsertar.AnguloRotacion == 90)
|
|
{
|
|
medidas.alto = TextoAInsertar.altoTexto;
|
|
}
|
|
else
|
|
{
|
|
medidas.ancho = TextoAInsertar.anchoTexto;
|
|
|
|
}
|
|
}
|
|
else if (TextoAInsertar.EsquinaReferencia != EsquinaEnum.SUPERIOR_DERECHA)
|
|
{
|
|
if (TextoAInsertar.AnguloRotacion == 0)
|
|
{
|
|
medidas.ancho = TextoAInsertar.anchoTexto;
|
|
medidas.alto = TextoAInsertar.altoTexto;
|
|
}
|
|
else
|
|
{
|
|
medidas.alto = TextoAInsertar.altoTexto;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
return medidas;
|
|
}
|
|
public static medidasTextoImagen comprobarMedidasImagen(int rotacionPagina, ImagenEnPdf ImagenAInsertar, float anguloImgPag, Image image)
|
|
{
|
|
medidasTextoImagen medidas = new medidasTextoImagen();
|
|
|
|
switch (rotacionPagina)
|
|
{
|
|
case 0:
|
|
if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_DERECHA || ImagenAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_DERECHA)
|
|
{
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
medidas.ancho = image.GetImageScaledWidth();
|
|
}
|
|
if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
|
|
{
|
|
if (ImagenAInsertar.AnguloRotacion == 0)
|
|
{
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
}
|
|
else
|
|
{
|
|
medidas.ancho = image.GetImageScaledWidth();
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
}
|
|
break;
|
|
case 90:
|
|
switch (anguloImgPag)
|
|
{
|
|
case 180:
|
|
if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_DERECHA || ImagenAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_IZQUIERDA)
|
|
{
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
medidas.ancho = image.GetImageScaledWidth();
|
|
}
|
|
else
|
|
{
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
}
|
|
break;
|
|
|
|
case 90:
|
|
if (ImagenAInsertar.EsquinaReferencia != EsquinaEnum.SUPERIOR_IZQUIERDA)
|
|
{
|
|
if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_DERECHA)
|
|
{
|
|
medidas.ancho = image.GetImageScaledWidth();
|
|
}
|
|
else
|
|
{
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
}
|
|
|
|
if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_DERECHA)
|
|
{
|
|
medidas.ancho = image.GetImageScaledWidth();
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
medidas.ancho = image.GetImageScaledWidth();
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
break;
|
|
}
|
|
break;
|
|
case 180:
|
|
if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_IZQUIERDA)
|
|
{
|
|
if (anguloImgPag == 270)
|
|
{
|
|
medidas.ancho = image.GetImageScaledHeight();
|
|
}
|
|
else if (anguloImgPag != 180)
|
|
{
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
|
|
}
|
|
else
|
|
{
|
|
medidas.ancho = image.GetImageScaledWidth();
|
|
}
|
|
}
|
|
|
|
if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
|
|
{
|
|
if (anguloImgPag == 270)
|
|
{
|
|
medidas.alto = image.GetImageScaledWidth();
|
|
medidas.ancho = image.GetImageScaledHeight();
|
|
}
|
|
else if (anguloImgPag == 180)
|
|
{
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
medidas.ancho = image.GetImageScaledWidth();
|
|
}
|
|
}
|
|
|
|
if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_DERECHA)
|
|
{
|
|
if (anguloImgPag == 270)
|
|
{
|
|
medidas.alto = image.GetImageScaledWidth();
|
|
}
|
|
else if (anguloImgPag == 180)
|
|
{
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
}
|
|
}
|
|
break;
|
|
case 270:
|
|
if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_IZQUIERDA || ImagenAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
|
|
{
|
|
if (anguloImgPag == 360)
|
|
{
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
medidas.ancho = image.GetImageScaledWidth();
|
|
}
|
|
else
|
|
{
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_DERECHA)
|
|
{
|
|
medidas.ancho = image.GetImageScaledWidth();
|
|
if (ImagenAInsertar.AnguloRotacion == 0)
|
|
{
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
}
|
|
}
|
|
else if (ImagenAInsertar.AnguloRotacion != 90)
|
|
{
|
|
medidas.ancho = image.GetImageScaledWidth();
|
|
medidas.alto = image.GetImageScaledHeight();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return medidas;
|
|
}
|
|
public static float PuntosAMilimetros(float puntos)
|
|
{
|
|
float valorPunto = 2.83465f;
|
|
return puntos / valorPunto;
|
|
}
|
|
public static float comprobarEjeXPagRotada(float ejeX, float ejeY, float angulo)
|
|
{
|
|
float resultado = 0;
|
|
|
|
if (angulo == 90 || angulo == 270)
|
|
{
|
|
ejeX = ejeY;
|
|
}
|
|
|
|
resultado = ejeX;
|
|
|
|
return resultado;
|
|
}
|
|
public static float comprobarEjeYPagRotada(float ejeX, float ejeY, float angulo)
|
|
{
|
|
float resultado = 0;
|
|
|
|
if (angulo == 90 || angulo == 270)
|
|
{
|
|
ejeY = ejeX;
|
|
}
|
|
|
|
resultado = ejeY;
|
|
|
|
return resultado;
|
|
}
|
|
public static float comprobarAncho(float ancho, float alto, float angulo)
|
|
{
|
|
float resultado = 0;
|
|
|
|
if (angulo == 90 || angulo == 270)
|
|
{
|
|
ancho = alto;
|
|
}
|
|
resultado = ancho;
|
|
|
|
return resultado;
|
|
}
|
|
public static float comprobarAlto(float ancho, float alto, float angulo)
|
|
{
|
|
float resultado = 0;
|
|
|
|
if (angulo == 90 || angulo == 270)
|
|
{
|
|
alto = ancho;
|
|
}
|
|
|
|
resultado = alto;
|
|
|
|
return resultado;
|
|
}
|
|
public async static Task<bool> SellaPDFAsync(string PdfOrigen, string PdfDestino, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, CancellationTokenSource cts = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
|
|
{
|
|
FileStream fsR = new FileStream(PdfOrigen, FileMode.Open, FileAccess.Read, FileShare.Read);
|
|
FileStream fsW = new FileStream(PdfDestino, FileMode.Create, FileAccess.Write, FileShare.None);
|
|
Task<bool> t;
|
|
t = SellaPDFAsync(fsR, fsW, TextosAInsertar, ImagenesAInsertar, dlgpr, cts,ConvertirPDFA,PDFAObligatorio);
|
|
await t;
|
|
return t.Result;
|
|
}
|
|
public static void SellaPDF(string PdfOrigen, string PdfDestino, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
|
|
{
|
|
|
|
|
|
FileStream fsR = new FileStream(PdfOrigen, FileMode.Open, FileAccess.Read, FileShare.Read);
|
|
FileStream fsW = new FileStream(PdfDestino, FileMode.Create, FileAccess.Write, FileShare.None);
|
|
SellaPDF(fsR, fsW, TextosAInsertar, ImagenesAInsertar, dlgpr,ConvertirPDFA:ConvertirPDFA,PDFAObligatorio:PDFAObligatorio);
|
|
}
|
|
public static async Task<Stream> SellaPDFAsync(Stream PdfOrigen, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, CancellationTokenSource cts = null, bool ConvertirPDFA=false)
|
|
{
|
|
|
|
MemoryStream ms = new MemoryStream();
|
|
await Task.Factory.StartNew(() => SellaPDFAsync(PdfOrigen, ms, TextosAInsertar, ImagenesAInsertar, dlgpr, cts, ConvertirPDFA: ConvertirPDFA));
|
|
return ms;
|
|
}
|
|
public static Stream SellaPDF(Stream PdfOrigen, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
|
|
{
|
|
|
|
MemoryStream ms = new MemoryStream();
|
|
SellaPDF(PdfOrigen, ms, TextosAInsertar, ImagenesAInsertar, dlgpr,ConvertirPDFA: ConvertirPDFA, PDFAObligatorio: PDFAObligatorio);
|
|
return ms;
|
|
}
|
|
public static async Task<Stream> SellaPDFAsync(String PdfOrigen, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, CancellationTokenSource cts = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
|
|
{
|
|
|
|
MemoryStream ms = new MemoryStream();
|
|
MemoryStream mso = new MemoryStream(System.IO.File.ReadAllBytes(PdfOrigen));
|
|
await Task.Factory.StartNew(() => SellaPDFAsync(mso, ms, TextosAInsertar, ImagenesAInsertar, dlgpr, cts, ConvertirPDFA: ConvertirPDFA, PDFAObligatorio: PDFAObligatorio));
|
|
return ms;
|
|
}
|
|
public static Stream SellaPDF(String PdfOrigen, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
|
|
{
|
|
|
|
|
|
MemoryStream ms = new MemoryStream();
|
|
MemoryStream mso = new MemoryStream(System.IO.File.ReadAllBytes(PdfOrigen));
|
|
SellaPDF(mso, ms, TextosAInsertar, ImagenesAInsertar, dlgpr, ConvertirPDFA: ConvertirPDFA, PDFAObligatorio: PDFAObligatorio);
|
|
return ms;
|
|
}
|
|
public static float calcularDistanciaX(int esquina, Rectangle tamanoPagina, float coordenada, float anchoImagen, float altoImagen, float anguloImagen, float anguloPagina, Rectangle cropBoxPagina)
|
|
{
|
|
float distanciaX = 0;
|
|
|
|
float anchoImagenOrig = anchoImagen;
|
|
float altoImagenOrig = altoImagen;
|
|
|
|
float diferenciaAncho = 0;
|
|
float diferenciaAlto = 0;
|
|
|
|
if (tamanoPagina.GetWidth() != cropBoxPagina.GetWidth())
|
|
{
|
|
diferenciaAncho = tamanoPagina.GetWidth() - cropBoxPagina.GetWidth();
|
|
}
|
|
else
|
|
{
|
|
diferenciaAncho = cropBoxPagina.GetWidth();
|
|
}
|
|
|
|
if (tamanoPagina.GetHeight() != cropBoxPagina.GetHeight())
|
|
{
|
|
diferenciaAlto = tamanoPagina.GetHeight() - cropBoxPagina.GetHeight();
|
|
}
|
|
else
|
|
{
|
|
diferenciaAlto = cropBoxPagina.GetHeight();
|
|
}
|
|
|
|
switch (esquina)
|
|
{
|
|
case 0:
|
|
switch (anguloImagen)
|
|
{
|
|
case 90:
|
|
if (anguloPagina == 90)
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (PuntosAMilimetros(coordenada) + altoImagen);
|
|
}
|
|
else
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + PuntosAMilimetros(coordenada);
|
|
}
|
|
break;
|
|
|
|
case 180:
|
|
if (anguloPagina == 90)
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (PuntosAMilimetros(coordenada) + anchoImagenOrig);
|
|
}
|
|
else if (anguloPagina == 180)
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (PuntosAMilimetros(coordenada) + anchoImagen);
|
|
}
|
|
else
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + PuntosAMilimetros(coordenada);
|
|
}
|
|
break;
|
|
|
|
case 270:
|
|
if (anguloPagina == 180)
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (PuntosAMilimetros(coordenada) + anchoImagen);
|
|
}
|
|
else
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + PuntosAMilimetros(coordenada) + altoImagen;
|
|
}
|
|
break;
|
|
|
|
case 360:
|
|
distanciaX = cropBoxPagina.GetX() + (PuntosAMilimetros(coordenada));
|
|
break;
|
|
|
|
default:
|
|
distanciaX = cropBoxPagina.GetX() + PuntosAMilimetros(coordenada) - anchoImagenOrig;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
switch (anguloImagen)
|
|
{
|
|
case 0:
|
|
distanciaX = (diferenciaAncho + cropBoxPagina.GetX()) - (anchoImagenOrig + PuntosAMilimetros(coordenada));
|
|
break;
|
|
case 90:
|
|
|
|
if (anguloPagina == 90)
|
|
{
|
|
distanciaX = (diferenciaAncho + cropBoxPagina.GetX()) - (altoImagenOrig + PuntosAMilimetros(coordenada));
|
|
}
|
|
else
|
|
{
|
|
distanciaX = (diferenciaAncho + cropBoxPagina.GetX()) - (altoImagenOrig + PuntosAMilimetros(coordenada));
|
|
}
|
|
|
|
break;
|
|
|
|
case 180:
|
|
anchoImagen = altoImagen;
|
|
|
|
if (anguloPagina == 90)
|
|
{
|
|
|
|
distanciaX = (diferenciaAncho + cropBoxPagina.GetX()) - (anchoImagenOrig + PuntosAMilimetros(coordenada));
|
|
}
|
|
else if (anguloPagina == 180)
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + (PuntosAMilimetros(coordenada) - anchoImagenOrig);
|
|
}
|
|
else
|
|
{
|
|
distanciaX = (diferenciaAncho + cropBoxPagina.GetX()) - (anchoImagen + PuntosAMilimetros(coordenada));
|
|
}
|
|
break;
|
|
|
|
case 270:
|
|
if (anguloPagina == 270)
|
|
{
|
|
distanciaX = (PuntosAMilimetros(coordenada) + cropBoxPagina.GetX());
|
|
}
|
|
else if (anguloPagina == 180)
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + (PuntosAMilimetros(coordenada) - altoImagen);
|
|
}
|
|
break;
|
|
case 360:
|
|
distanciaX = (PuntosAMilimetros(coordenada + anchoImagenOrig) + cropBoxPagina.GetX());
|
|
break;
|
|
|
|
default:
|
|
distanciaX = (diferenciaAncho + tamanoPagina.GetX()) - (anchoImagen + PuntosAMilimetros(coordenada));
|
|
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
switch (anguloImagen)
|
|
{
|
|
case 90:
|
|
if (anguloPagina == 90)
|
|
{
|
|
if (PuntosAMilimetros(coordenada) < altoImagenOrig)
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + altoImagenOrig - PuntosAMilimetros(coordenada);
|
|
}
|
|
else
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + PuntosAMilimetros(coordenada) - altoImagenOrig;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + PuntosAMilimetros(coordenada);
|
|
}
|
|
|
|
break;
|
|
case 180:
|
|
if (anguloPagina == 180)
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (PuntosAMilimetros(coordenada) + anchoImagen);
|
|
}
|
|
else
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + PuntosAMilimetros(coordenada) - anchoImagenOrig;
|
|
}
|
|
break;
|
|
case 270:
|
|
if (anguloPagina == 180)
|
|
{
|
|
|
|
distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (PuntosAMilimetros(coordenada) + anchoImagen);
|
|
}
|
|
else
|
|
{
|
|
distanciaX = (diferenciaAncho + cropBoxPagina.GetX()) - (altoImagenOrig + PuntosAMilimetros(coordenada));
|
|
}
|
|
break;
|
|
case 360:
|
|
distanciaX = (diferenciaAncho + cropBoxPagina.GetX()) - (anchoImagenOrig + PuntosAMilimetros(coordenada));
|
|
break;
|
|
default:
|
|
distanciaX = (PuntosAMilimetros(coordenada) + anchoImagenOrig) + cropBoxPagina.GetX();
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
switch (anguloImagen)
|
|
{
|
|
case 90:
|
|
if (anguloPagina == 90)
|
|
{
|
|
if (PuntosAMilimetros(coordenada) > altoImagenOrig)
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + (PuntosAMilimetros(coordenada));
|
|
}
|
|
else
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + (altoImagenOrig + PuntosAMilimetros(coordenada));
|
|
}
|
|
}
|
|
else if (anguloPagina == 0)
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (altoImagenOrig + PuntosAMilimetros(coordenada));
|
|
}
|
|
break;
|
|
|
|
case 180:
|
|
|
|
if (anguloPagina == 180)
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + (PuntosAMilimetros(coordenada) - anchoImagen);
|
|
}
|
|
else
|
|
{
|
|
if (PuntosAMilimetros(coordenada) > anchoImagenOrig)
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + (PuntosAMilimetros(coordenada) - anchoImagenOrig);
|
|
}
|
|
else
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + (anchoImagenOrig - PuntosAMilimetros(coordenada));
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case 270:
|
|
if (anguloPagina == 180)
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + (PuntosAMilimetros(coordenada) - anchoImagen);
|
|
}
|
|
else
|
|
{
|
|
distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (altoImagen + PuntosAMilimetros(coordenada));
|
|
}
|
|
break;
|
|
|
|
case 360:
|
|
distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (anchoImagenOrig + PuntosAMilimetros(coordenada));
|
|
break;
|
|
|
|
default:
|
|
distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (anchoImagen + PuntosAMilimetros(coordenada));
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return distanciaX;
|
|
}
|
|
public static float calcularDistanciaY(int esquina, Rectangle tamanoPagina, float coordenada, float anchoImagen, float altoImagen, float anguloImagen, float anguloPagina, Rectangle cropBoxPagina)
|
|
{
|
|
float distanciaY = 0;
|
|
float anchoImagenOrig = anchoImagen;
|
|
float altoImagenOrig = altoImagen;
|
|
|
|
float diferenciaAncho = 0;
|
|
float diferenciaAlto = 0;
|
|
|
|
if (tamanoPagina.GetWidth() != cropBoxPagina.GetWidth())
|
|
{
|
|
diferenciaAncho = tamanoPagina.GetWidth() - cropBoxPagina.GetWidth();
|
|
}
|
|
else
|
|
{
|
|
diferenciaAncho = cropBoxPagina.GetWidth();
|
|
}
|
|
|
|
if (tamanoPagina.GetHeight() != cropBoxPagina.GetHeight())
|
|
{
|
|
diferenciaAlto = tamanoPagina.GetHeight() - cropBoxPagina.GetHeight();
|
|
}
|
|
else
|
|
{
|
|
diferenciaAlto = cropBoxPagina.GetHeight();
|
|
}
|
|
switch (esquina)
|
|
{
|
|
case 0:
|
|
switch (anguloImagen)
|
|
{
|
|
case 90:
|
|
if (anguloPagina == 90)
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada) - anchoImagen;
|
|
}
|
|
else
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada);
|
|
}
|
|
break;
|
|
|
|
case 180:
|
|
if (anguloPagina == 90)
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada) + altoImagenOrig;
|
|
}
|
|
else if (anguloPagina == 180)
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagen + PuntosAMilimetros(coordenada));
|
|
}
|
|
else
|
|
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada);
|
|
}
|
|
break;
|
|
|
|
case 270:
|
|
if (anguloPagina == 180)
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagen + PuntosAMilimetros(coordenada));
|
|
}
|
|
else
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagen + PuntosAMilimetros(coordenada));
|
|
}
|
|
break;
|
|
|
|
case 360:
|
|
distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagen + PuntosAMilimetros(coordenada));
|
|
break;
|
|
default:
|
|
distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
switch (anguloImagen)
|
|
{
|
|
case 90:
|
|
if (anguloPagina == 90)
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (anchoImagenOrig + PuntosAMilimetros(coordenada));
|
|
}
|
|
else
|
|
{
|
|
|
|
distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada);
|
|
}
|
|
break;
|
|
case 180:
|
|
|
|
if (anguloPagina == 90)
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (PuntosAMilimetros(coordenada));
|
|
}
|
|
else if (anguloPagina == 180)
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (PuntosAMilimetros(coordenada) + altoImagenOrig);
|
|
}
|
|
else
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + (anchoImagenOrig + PuntosAMilimetros(coordenada));
|
|
}
|
|
|
|
break;
|
|
case 270:
|
|
if (anguloPagina == 270)
|
|
{
|
|
if ((PuntosAMilimetros(coordenada) < anchoImagenOrig))
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + anchoImagenOrig + (PuntosAMilimetros(coordenada));
|
|
}
|
|
else
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + (PuntosAMilimetros(coordenada) - anchoImagenOrig);
|
|
}
|
|
|
|
}
|
|
else if (anguloPagina == 180)
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (PuntosAMilimetros(coordenada) + anchoImagen);
|
|
|
|
}
|
|
break;
|
|
case 360:
|
|
distanciaY = cropBoxPagina.GetY() + (PuntosAMilimetros(coordenada) - altoImagenOrig);
|
|
break;
|
|
|
|
default:
|
|
distanciaY = PuntosAMilimetros(coordenada) + cropBoxPagina.GetY();
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
|
|
switch (anguloImagen)
|
|
{
|
|
case 90:
|
|
if (anguloPagina == 90)
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + (PuntosAMilimetros(coordenada) - anchoImagenOrig);
|
|
}
|
|
else
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (anchoImagenOrig + PuntosAMilimetros(coordenada));
|
|
}
|
|
break;
|
|
|
|
case 180:
|
|
if (anguloPagina == 180)
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + (PuntosAMilimetros(coordenada) + altoImagen);
|
|
}
|
|
else
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + (altoImagenOrig + PuntosAMilimetros(coordenada));
|
|
}
|
|
break;
|
|
case 270:
|
|
if (anguloPagina == 180)
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + (PuntosAMilimetros(coordenada) + altoImagen);
|
|
}
|
|
else
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (PuntosAMilimetros(coordenada));
|
|
}
|
|
break;
|
|
|
|
case 360:
|
|
distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagenOrig + PuntosAMilimetros(coordenada));
|
|
|
|
break;
|
|
default:
|
|
distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagenOrig + PuntosAMilimetros(coordenada));
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
case 3:
|
|
switch (anguloImagen)
|
|
{
|
|
case 90:
|
|
altoImagen = anchoImagen;
|
|
distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagen + PuntosAMilimetros(coordenada));
|
|
break;
|
|
case 180:
|
|
if (anguloPagina == 180)
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada) + altoImagen;
|
|
}
|
|
else
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (PuntosAMilimetros(coordenada));
|
|
}
|
|
break;
|
|
case 270:
|
|
if (anguloPagina == 180)
|
|
{
|
|
distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada) + altoImagen;
|
|
}
|
|
else
|
|
{
|
|
distanciaY = PuntosAMilimetros(coordenada) > anchoImagenOrig ? cropBoxPagina.GetY() + PuntosAMilimetros(coordenada) - anchoImagenOrig : cropBoxPagina.GetY() + anchoImagenOrig + PuntosAMilimetros(coordenada);
|
|
}
|
|
break;
|
|
case 360:
|
|
distanciaY = PuntosAMilimetros(coordenada) > altoImagenOrig ? cropBoxPagina.GetY() + PuntosAMilimetros(coordenada) - altoImagenOrig : cropBoxPagina.GetY() + altoImagenOrig - PuntosAMilimetros(coordenada);
|
|
break;
|
|
default:
|
|
distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagen + PuntosAMilimetros(coordenada));
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return distanciaY;
|
|
}
|
|
public static string devolverDatosFecha(DateTime fecha, string datoADevolver)
|
|
{
|
|
|
|
string datoFecha = string.Empty;
|
|
|
|
|
|
|
|
switch (datoADevolver.ToUpper())
|
|
{
|
|
|
|
case "DIA":
|
|
|
|
datoFecha = fecha.ToString("dd/MM/yyyy").Split('/')[0];
|
|
|
|
break;
|
|
|
|
case "MES":
|
|
|
|
datoFecha = fecha.ToString("MMMM").ToUpper();
|
|
|
|
|
|
break;
|
|
|
|
case "AÑO":
|
|
|
|
datoFecha = fecha.ToString("dd/MM/yyyy").Split('/')[2];
|
|
break;
|
|
|
|
}
|
|
return datoFecha;
|
|
}
|
|
public static string devolverDatos(string cadenaDatos, int seleccionarDato)
|
|
{
|
|
string datos = string.Empty;
|
|
|
|
switch (seleccionarDato)
|
|
{
|
|
|
|
case 1:
|
|
|
|
datos = cadenaDatos.Split(' ')[0];
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
datos = cadenaDatos.Split(' ')[1];
|
|
|
|
break;
|
|
|
|
|
|
case 3:
|
|
|
|
datos = cadenaDatos.Split(' ')[2];
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
return datos;
|
|
|
|
|
|
}
|
|
private static TextAlignment devolverAlineamiento(int alineamiento)
|
|
{
|
|
TextAlignment obtenerAlineamiento = new TextAlignment();
|
|
|
|
switch (alineamiento)
|
|
{
|
|
case 0:
|
|
obtenerAlineamiento = TextAlignment.LEFT;
|
|
break;
|
|
|
|
case 1:
|
|
obtenerAlineamiento = TextAlignment.RIGHT;
|
|
break;
|
|
|
|
case 2:
|
|
obtenerAlineamiento = TextAlignment.CENTER;
|
|
break;
|
|
|
|
case 3:
|
|
obtenerAlineamiento = TextAlignment.JUSTIFIED_ALL;
|
|
break;
|
|
}
|
|
|
|
return obtenerAlineamiento;
|
|
|
|
}
|
|
private static TSpdf.Kernel.Font.PdfFont devolverTipoFuente(string nombreFuente)
|
|
{
|
|
|
|
TSpdf.Kernel.Font.PdfFont tipoFuente;
|
|
switch (nombreFuente)
|
|
{
|
|
case "COURIER":
|
|
tipoFuente = PdfFontFactory.CreateFont(StandardFonts.COURIER);
|
|
break;
|
|
|
|
case "COURIER_BOLD":
|
|
tipoFuente = PdfFontFactory.CreateFont(StandardFonts.COURIER_BOLD);
|
|
break;
|
|
|
|
case "COURIER_BOLDOBLIQUE":
|
|
tipoFuente = PdfFontFactory.CreateFont(StandardFonts.COURIER_BOLDOBLIQUE);
|
|
break;
|
|
|
|
case "COURIER_OBLIQUE":
|
|
tipoFuente = PdfFontFactory.CreateFont(StandardFonts.COURIER_OBLIQUE);
|
|
break;
|
|
|
|
case "HELVETICA":
|
|
tipoFuente = PdfFontFactory.CreateFont(StandardFonts.HELVETICA);
|
|
break;
|
|
|
|
case "HELVETICA_BOLD":
|
|
tipoFuente = PdfFontFactory.CreateFont(StandardFonts.HELVETICA_BOLD);
|
|
break;
|
|
|
|
case "HELVETICA_BOLDOBLIQUE":
|
|
tipoFuente = PdfFontFactory.CreateFont(StandardFonts.HELVETICA_BOLDOBLIQUE);
|
|
break;
|
|
|
|
case "HELVETICA_OBLIQUE":
|
|
tipoFuente = PdfFontFactory.CreateFont(StandardFonts.HELVETICA_OBLIQUE);
|
|
break;
|
|
|
|
case "SYMBOL":
|
|
tipoFuente = PdfFontFactory.CreateFont(StandardFonts.SYMBOL);
|
|
break;
|
|
|
|
case "TIMES_ROMAN":
|
|
tipoFuente = PdfFontFactory.CreateFont(StandardFonts.TIMES_ROMAN);
|
|
break;
|
|
|
|
case "TIMES_BOLD":
|
|
tipoFuente = PdfFontFactory.CreateFont(StandardFonts.TIMES_BOLD);
|
|
break;
|
|
|
|
case "TIMES_BOLDITALIC":
|
|
tipoFuente = PdfFontFactory.CreateFont(StandardFonts.TIMES_BOLDITALIC);
|
|
break;
|
|
|
|
case "TIMES_ITALIC":
|
|
tipoFuente = PdfFontFactory.CreateFont(StandardFonts.TIMES_ITALIC);
|
|
break;
|
|
|
|
case "ZAPFDINGBATS":
|
|
tipoFuente = PdfFontFactory.CreateFont(StandardFonts.ZAPFDINGBATS);
|
|
break;
|
|
|
|
default:
|
|
tipoFuente = PdfFontFactory.CreateFont(StandardFonts.TIMES_ROMAN);
|
|
break;
|
|
}
|
|
|
|
return tipoFuente;
|
|
}
|
|
public delegate void DelegadoProgreso(Progreso progreso);
|
|
public class Progreso
|
|
{
|
|
public int NumeroPaginasTotal { get; set; }
|
|
public int NumeroPaginaActual { get; set; }
|
|
public string Estado { get; set; }
|
|
}
|
|
public class medidasTextoImagen
|
|
{
|
|
public float ancho { get; set; }
|
|
public float alto { get; set; }
|
|
}
|
|
|
|
}
|
|
} |