490 lines
19 KiB
C#
490 lines
19 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Avalonia.Controls;
|
|
|
|
using PdfSharp.Pdf;
|
|
using PdfSharp.Drawing;
|
|
using PdfSharp.Drawing.Layout;
|
|
|
|
using System.Globalization;
|
|
using MigraDoc.DocumentObjectModel;
|
|
using System.Net.NetworkInformation;
|
|
using Avalonia.Styling;
|
|
using System.IO;
|
|
|
|
namespace PLG_Exam;
|
|
|
|
public class PFDExporter
|
|
{
|
|
public Exam exam;
|
|
public async void ExportToPdf(Exam examData, int correctionMargin, double lineSpacing, bool hasCorrectionLines, string textPosition, string filePath = null)
|
|
{
|
|
try
|
|
{
|
|
exam = examData;
|
|
corr_margin = correctionMargin*3;
|
|
if(corr_margin == 0){
|
|
corr_margin = 50;
|
|
}
|
|
if(lineSpacing == 1.0){
|
|
lineHeight = 15;
|
|
} else if(lineSpacing == 1.5){
|
|
lineHeight = 21;
|
|
} else if(lineSpacing == 2.0){
|
|
lineHeight = 27;
|
|
}
|
|
this.hasCorrectionLines = hasCorrectionLines;
|
|
this.textPosition = textPosition;
|
|
//_ = GetCurrentExamDataAsJson();
|
|
|
|
if(examData.Name.IsValueNullOrEmpty() || examData.Vorname.IsValueNullOrEmpty() || examData.Title.IsValueNullOrEmpty() || examData.Datum == null){
|
|
await MessageBox.Show(MainWindow._instance, "Bitte füllen Sie mindestens die Felder für Name, Vorname, Titel und Datum aus", "Fehler", MessageBoxButton.Ok);
|
|
return;
|
|
}
|
|
|
|
if(filePath==null){
|
|
var saveDialog = new SaveFileDialog
|
|
{
|
|
DefaultExtension = "pdf",
|
|
Filters = { new FileDialogFilter { Name = "PDF files", Extensions = { "pdf" } } }
|
|
};
|
|
filePath = await saveDialog.ShowAsync(MainWindow._instance);
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(filePath)) return;
|
|
|
|
var font = new XFont("Cantarell", 14, XFontStyleEx.Bold);
|
|
var fontB = new XFont("Cantarell", 14, XFontStyleEx.Bold);
|
|
var fontsmall = new XFont("Cantarell", 10, XFontStyleEx.Regular);
|
|
var descriptionFont = new XFont("Cantarell", 12, XFontStyleEx.Regular);
|
|
|
|
using var document = new PdfDocument();
|
|
|
|
document.Info.Title = examData.Title;
|
|
document.Info.Author = examData.Vorname + " " + examData.Name;
|
|
document.Info.Subject = "PLG Exam Submission";
|
|
document.Info.Keywords = "Exam, PLG, Report, PDF";
|
|
SetPdfLanguage(document);
|
|
|
|
|
|
var firstPage = document.AddPage();
|
|
var gfx = XGraphics.FromPdfPage(firstPage);
|
|
gfx.DrawString(examData.Title, fontB, XBrushes.Black, new XRect(0, 40, firstPage.Width, 50), XStringFormats.TopCenter);
|
|
|
|
gfx.DrawString($"Name: {examData.Name}", fontB, XBrushes.Black, new XRect(50, 100, firstPage.Width, firstPage.Height), XStringFormats.TopLeft);
|
|
gfx.DrawString($"Vorname: {examData.Vorname}", fontB, XBrushes.Black, new XRect(50, 130, firstPage.Width, firstPage.Height), XStringFormats.TopLeft);
|
|
gfx.DrawString($"Datum: {examData.Datum?.ToShortDateString() ?? "N/A"}", fontB, XBrushes.Black, new XRect(50, 160, firstPage.Width, firstPage.Height), XStringFormats.TopLeft);
|
|
|
|
foreach (var tab in examData.Tabs)
|
|
{
|
|
DrawTaskWithPageBreak(document, tab, descriptionFont, font, fontsmall);
|
|
}
|
|
|
|
|
|
var endpage = document.AddPage();
|
|
var endpageGfx = XGraphics.FromPdfPage(endpage);
|
|
|
|
// Beschreibung am unteren Rand platzieren
|
|
var bottomDescriptionRect = new XRect(
|
|
50, // X-Position (horizontaler Abstand)
|
|
endpage.Height - 100, // Y-Position (Seitenhöhe - Textbereichshöhe - Margin)
|
|
endpage.Width - 100, // Breite des Bereichs
|
|
100 // Höhe des Bereichs
|
|
);
|
|
|
|
var endformatter = new XTextFormatter(endpageGfx)
|
|
{
|
|
Alignment = XParagraphAlignment.Left
|
|
};
|
|
|
|
// Text zeichnen
|
|
endformatter.DrawString(
|
|
"Erstellt mit PLG Exam - powered by PLG Development\nhttps://github.com/PLG-Development/PLG-Exam\n(c) 2025 - PLG Development",
|
|
fontsmall,
|
|
XBrushes.Black,
|
|
bottomDescriptionRect
|
|
);
|
|
|
|
// Beschreibung am unteren Rand platzieren
|
|
var informationRect = new XRect(
|
|
50, // X-Position (horizontaler Abstand)
|
|
50, // Y-Position (Seitenhöhe - Textbereichshöhe - Margin)
|
|
endpage.Width - 100, // Breite des Bereichs
|
|
300 // Höhe des Bereichs
|
|
);
|
|
|
|
string outinfo = $"Dieses Dokument wurde automatisch erstellt und enthält alle Bestandteile Ihrer Prüfung. Bitte prüfen Sie alle Inhalte vor der Abgabe und speichern das Dokument an einem sicheren Ort. Nutzen Sie zur Abgabe bitte einen durch die Lehrkraft gestellten USB-Stick.";
|
|
outinfo += $"\n\nAbgabedatum: {DateTime.Now.ToString("dd.MM.yyyy", CultureInfo.CreateSpecificCulture("de-DE"))}";
|
|
outinfo += $"\nAbgabezeit: {DateTime.Now.ToString("HH:mm:ss", CultureInfo.CreateSpecificCulture("de-DE"))} Uhr";
|
|
outinfo += $"\nGerätename: {Environment.MachineName}";
|
|
outinfo += $"\nBenutzername: {Environment.UserName}";
|
|
outinfo += $"\nBetriebssystem: {Environment.OSVersion.VersionString}";
|
|
outinfo += $"\nIP-Adresse: {System.Net.Dns.GetHostEntry(System.Net.Dns.GetHostName()).AddressList.FirstOrDefault(ip => ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)}";
|
|
outinfo += $"\nInternetverbindung: {(isInternetAvailable() ? "8.8.8.8 ist erreichbar (!)" : "8.8.8.8 ist nicht erreichbar")}";
|
|
|
|
endformatter.DrawString(
|
|
outinfo,
|
|
fontsmall,
|
|
XBrushes.Black,
|
|
informationRect
|
|
);
|
|
|
|
var page = $"Seite {document.PageCount}";
|
|
endpageGfx.DrawString(page, fontsmall, XBrushes.Gray, new XRect(50, gfx.PageSize.Height - 50 + 15, gfx.PageSize.Width - 50 * 2, 50), XStringFormats.TopRight);
|
|
|
|
|
|
endpageGfx.Dispose();
|
|
gfx.Dispose();
|
|
//AddPageNumbers(document, fontsmall, 35);
|
|
document.Save(filePath);
|
|
await MessageBox.Show(MainWindow._instance, "PDF erfolgreich gespeichert!", "Erfolg", MessageBoxButton.Ok);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"Fehler beim PDF-Export: {ex.Message}");
|
|
await MessageBox.Show(MainWindow._instance, "Fehler beim PDF-Export.", "Fehler", MessageBoxButton.Ok);
|
|
}
|
|
}
|
|
|
|
private bool isInternetAvailable()
|
|
{
|
|
try
|
|
{
|
|
using (var ping = new Ping())
|
|
{
|
|
var reply = ping.Send("8.8.8.8", 2000); // 3000 ms timeout
|
|
return reply.Status == IPStatus.Success;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
public bool isEscaped = false;
|
|
public bool isBold = false;
|
|
public bool isUnderline = false;
|
|
private List<(string Text, XFont Font, XBrush Brush)> ParseFormattedText(string text, XFont regularFont, XFont boldFont, XFont underlineFont)
|
|
{
|
|
var result = new List<(string Text, XFont Font, XBrush Brush)>();
|
|
var currentFont = regularFont;
|
|
var currentBrush = XBrushes.Black;
|
|
|
|
var buffer = new System.Text.StringBuilder();
|
|
|
|
|
|
for (int i = 0; i < text.Length; i++)
|
|
{
|
|
char c = text[i];
|
|
|
|
if (isEscaped)
|
|
{
|
|
buffer.Append(c);
|
|
isEscaped = false;
|
|
continue;
|
|
}
|
|
|
|
if (c == '\\')
|
|
{
|
|
isEscaped = true;
|
|
continue;
|
|
}
|
|
|
|
if (c == '*' && i + 1 < text.Length && text[i + 1] == '*')
|
|
{
|
|
if (isBold)
|
|
{
|
|
result.Add((buffer.ToString(), currentFont, currentBrush));
|
|
buffer.Clear();
|
|
currentFont = isUnderline ? underlineFont : regularFont;
|
|
isBold = false;
|
|
}
|
|
else
|
|
{
|
|
result.Add((buffer.ToString(), currentFont, currentBrush));
|
|
buffer.Clear();
|
|
currentFont = boldFont;
|
|
isBold = true;
|
|
}
|
|
i++; // Skip the second '*'
|
|
continue;
|
|
}
|
|
|
|
if (c == '_')
|
|
{
|
|
if (isUnderline)
|
|
{
|
|
result.Add((buffer.ToString(), currentFont, currentBrush));
|
|
buffer.Clear();
|
|
currentFont = isBold ? boldFont : regularFont;
|
|
isUnderline = false;
|
|
}
|
|
else
|
|
{
|
|
result.Add((buffer.ToString(), currentFont, currentBrush));
|
|
buffer.Clear();
|
|
currentFont = underlineFont;
|
|
isUnderline = true;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if(isUnderline){
|
|
currentFont = underlineFont;
|
|
} else if (isBold){
|
|
currentFont = boldFont;
|
|
} else {
|
|
currentFont = regularFont;
|
|
}
|
|
|
|
buffer.Append(c);
|
|
}
|
|
|
|
if (buffer.Length > 0)
|
|
{
|
|
result.Add((buffer.ToString(), currentFont, currentBrush));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private void DrawFormattedText(XGraphics gfx, string text, XFont regularFont, XFont boldFont, XFont underlineFont, XRect rect)
|
|
{
|
|
var parsedText = ParseFormattedText(text, regularFont, boldFont, underlineFont);
|
|
double x = rect.X;
|
|
double y = rect.Y;
|
|
|
|
foreach (var (Text, Font, Brush) in parsedText)
|
|
{
|
|
var size = gfx.MeasureString(Text, Font);
|
|
gfx.DrawString(Text, Font, Brush, new XRect(x, y, rect.Width, rect.Height), XStringFormats.TopLeft);
|
|
x += size.Width;
|
|
}
|
|
}
|
|
|
|
private double corr_margin = 300; // Seitenrand Korrektur
|
|
private double lineHeight = 21; // Höhe einer Textzeile
|
|
private bool hasCorrectionLines = false; // Korrekturrand aktiv
|
|
private string textPosition = "left"; // Textposition (links, rechts, zentriert)
|
|
|
|
private void DrawTaskWithPageBreak(PdfDocument document, ExamTab tab, XFont font, XFont headerFont, XFont smallFont)
|
|
{
|
|
const double margin = 50; // Seitenränder
|
|
const double headerHeight = 30; // Platz für die Kopfzeile pro Seite
|
|
const double footerHeight = 20; // Platz für die Fußzeile
|
|
const double usableHeight = 842 - margin * 2 - headerHeight - footerHeight; // Höhe des nutzbaren Bereichs
|
|
|
|
var lines = SplitTextIntoLines(tab.Inhalt, document.Pages[0].Width - margin - corr_margin, font);
|
|
|
|
double currentHeight = 0;
|
|
PdfPage page = null;
|
|
XGraphics gfx = null;
|
|
|
|
foreach (var line in lines)
|
|
{
|
|
// Wenn eine neue Seite benötigt wird (Seitenumbruch)
|
|
if (page == null || currentHeight + lineHeight > usableHeight)
|
|
{
|
|
page = document.AddPage();
|
|
gfx = XGraphics.FromPdfPage(page);
|
|
currentHeight = 0;
|
|
|
|
// Kopfzeile zeichnen
|
|
DrawName(gfx, tab, smallFont, margin, headerHeight, document.PageCount);
|
|
DrawHeader(gfx, tab, headerFont, margin, headerHeight);
|
|
}
|
|
|
|
// Berechnung der Textposition
|
|
XRect rect;
|
|
|
|
|
|
// Berechnung der Textposition basierend auf `textPosition`
|
|
if (textPosition == "right")
|
|
{
|
|
rect = new XRect(margin + corr_margin - margin, margin + headerHeight + currentHeight, page.Width - margin - corr_margin, lineHeight);
|
|
if (hasCorrectionLines && corr_margin > margin)
|
|
{
|
|
// Korrekturlinie wird nur neben dem Text gezeichnet (nur so breit wie der Korrekturrand)
|
|
var correctionLineRect = new XRect(margin, margin + headerHeight + currentHeight + 15, corr_margin-margin-10, 1);
|
|
gfx.DrawRectangle(XBrushes.LightGray, correctionLineRect);
|
|
currentHeight += 1; // Korrekturlinie nimmt Platz ein
|
|
}
|
|
}
|
|
else // links
|
|
{
|
|
rect = new XRect(margin, margin + headerHeight + currentHeight, page.Width - (2 * margin) - corr_margin, lineHeight);
|
|
if (hasCorrectionLines && corr_margin > margin)
|
|
{
|
|
// Korrekturlinie wird nur neben dem Text gezeichnet (nur so breit wie der Korrekturrand)
|
|
var correctionLineRect = new XRect(page.Width - corr_margin, margin + headerHeight + currentHeight + 15, corr_margin - margin, 1);
|
|
gfx.DrawRectangle(XBrushes.LightGray, correctionLineRect);
|
|
currentHeight += 1; // Korrekturlinie nimmt Platz ein
|
|
}
|
|
}
|
|
|
|
// Text formatieren und zeichnen
|
|
DrawFormattedText(gfx, line, font, new XFont(font.Name, font.Size, XFontStyleEx.Bold), new XFont(font.Name, font.Size, XFontStyleEx.Underline), rect);
|
|
currentHeight += lineHeight; // Zeilenhöhe für die nächste Zeile erhöhen
|
|
}
|
|
|
|
gfx?.Dispose();
|
|
}
|
|
|
|
|
|
|
|
private int headerline_count = 0;
|
|
private void DrawHeader(XGraphics gfx, ExamTab tab, XFont font, double margin, double headerHeight)
|
|
{
|
|
var maxWidth = gfx.PageSize.Width - margin * 2; // verfügbare Breite
|
|
var lines = SplitTextIntoLines($"Aufgabe {tab.Aufgabennummer}: {tab.Überschrift}", maxWidth, font);
|
|
|
|
double currentY = margin;
|
|
headerline_count=0;
|
|
foreach (var line in lines)
|
|
{
|
|
gfx.DrawString(line, font, XBrushes.Gray, new XRect(margin, currentY, maxWidth, headerHeight), XStringFormats.TopLeft);
|
|
currentY += font.Height;
|
|
|
|
headerline_count++;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
private void AddPageNumbers(PdfDocument document, XFont font, double margin)
|
|
{
|
|
|
|
int totalPages = document.PageCount;
|
|
for (int i = 1; i < totalPages; i++) // Beginnt ab der zweiten Seite (Index 1)
|
|
{
|
|
PdfPage page = document.Pages[i];
|
|
XGraphics gfx = XGraphics.FromPdfPage(page);
|
|
string text = $"Seite {i + 1} von {totalPages}";
|
|
double yPosition = page.Height - margin;
|
|
gfx.DrawString(text, font, XBrushes.Gray, new XRect(margin, yPosition, page.Width - 2 * margin, 20), XStringFormats.Center);
|
|
gfx.Dispose();
|
|
|
|
}
|
|
}
|
|
|
|
private void DrawName(XGraphics gfx, ExamTab tab, XFont font, double margin, double headerHeight, int page_num)
|
|
{
|
|
var headerText = $"{exam.Name}, {exam.Vorname}";
|
|
gfx.DrawString(headerText, font, XBrushes.Gray, new XRect(margin, margin-15, gfx.PageSize.Width - margin * 2, headerHeight), XStringFormats.TopLeft);
|
|
|
|
var headerText2 = exam.Datum.Value.ToString("dd.MM.yyyy", CultureInfo.CreateSpecificCulture("de-DE"));
|
|
gfx.DrawString(headerText2, font, XBrushes.Gray, new XRect(margin, margin-15, gfx.PageSize.Width - margin * 2, headerHeight), XStringFormats.TopRight);
|
|
|
|
var page = $"Seite {page_num}";
|
|
gfx.DrawString(page, font, XBrushes.Gray, new XRect(margin, gfx.PageSize.Height - margin + 15, gfx.PageSize.Width - margin * 2, headerHeight), XStringFormats.TopRight);
|
|
|
|
}
|
|
|
|
// Methode zum Aufteilen des Textes in Zeilen
|
|
private List<string> SplitTextIntoLines(string text, double maxWidth, XFont font)
|
|
{
|
|
var lines = new List<string>();
|
|
|
|
// Text anhand von \n aufteilen, einschließlich leerer Zeilen
|
|
var manualLines = text.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None);
|
|
|
|
using (var gfx = XGraphics.CreateMeasureContext(new XSize(maxWidth, 842), XGraphicsUnit.Point, XPageDirection.Downwards))
|
|
{
|
|
foreach (var manualLine in manualLines)
|
|
{
|
|
// Falls die Zeile leer ist (z. B. durch mehrere \n), direkt hinzufügen
|
|
if (string.IsNullOrWhiteSpace(manualLine))
|
|
{
|
|
lines.Add(""); // Leere Zeile hinzufügen
|
|
continue;
|
|
}
|
|
|
|
// Falls eine Zeile zu lang ist, weiter aufteilen
|
|
var words = manualLine.Split(' ');
|
|
var currentLine = "";
|
|
|
|
foreach (var word in words)
|
|
{
|
|
var testLine = string.IsNullOrEmpty(currentLine) ? word : $"{currentLine} {word}";
|
|
var size = gfx.MeasureString(testLine, font);
|
|
|
|
if (size.Width > maxWidth)
|
|
{
|
|
lines.Add(currentLine);
|
|
currentLine = word;
|
|
}
|
|
else
|
|
{
|
|
currentLine = testLine;
|
|
}
|
|
}
|
|
|
|
// Letzte Zeile hinzufügen
|
|
if (!string.IsNullOrEmpty(currentLine))
|
|
{
|
|
lines.Add(currentLine);
|
|
}
|
|
|
|
|
|
}
|
|
gfx.Dispose();
|
|
}
|
|
|
|
return lines;
|
|
}
|
|
|
|
|
|
|
|
private void SetPdfLanguage(PdfSharp.Pdf.PdfDocument document, string language = "de")
|
|
{
|
|
var catalog = document.Internals.Catalog;
|
|
|
|
if (catalog.Elements.ContainsKey("/Lang"))
|
|
{
|
|
catalog.Elements["/Lang"] = new PdfSharp.Pdf.PdfString(language);
|
|
}
|
|
else
|
|
{
|
|
catalog.Elements.Add("/Lang", new PdfSharp.Pdf.PdfString(language));
|
|
}
|
|
}
|
|
|
|
public void ExportAllCombinations(Exam curr_exam)
|
|
{
|
|
exam = curr_exam;
|
|
// Mögliche Werte für die Variablen
|
|
var textPositions = new[] { "left", "right" };
|
|
var hasCorrectionLinesOptions = new[] { true, false };
|
|
var correctionMargins = new[] { 100.0, 50.0, 0.0 };
|
|
var lineHeights = new[] { 2.0, 1.5, 1.0 };
|
|
|
|
// Ordner für die gespeicherten PDFs
|
|
string folderPath = "/home/fierke/Schreibtisch";
|
|
if (!Directory.Exists(folderPath))
|
|
{
|
|
Directory.CreateDirectory(folderPath); // Ordner erstellen, falls nicht vorhanden
|
|
}
|
|
|
|
// Generiere alle Kombinationen und exportiere das PDF
|
|
foreach (var textPosition in textPositions)
|
|
{
|
|
foreach (var hasCorrectionLines in hasCorrectionLinesOptions)
|
|
{
|
|
foreach (var correctionMargin in correctionMargins)
|
|
{
|
|
foreach (var lineHeight in lineHeights)
|
|
{
|
|
// Dateiname basierend auf den aktuellen Parametern
|
|
string fileName = $"{textPosition}_{hasCorrectionLines}_{correctionMargin}_{lineHeight}.pdf";
|
|
string filePath = Path.Combine(folderPath, fileName);
|
|
|
|
// Erstelle das PDF für diese Kombination
|
|
ExportToPdf(curr_exam,(int)correctionMargin,lineHeight, hasCorrectionLines,textPosition,filePath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|