private void AddNewDocument()
{
OpenFileDialog fileWindow = new OpenFileDialog();
fileWindow.Filter = "Pdf files(*.pdf)|*.pdf|Doc files(*.docx)|*.docx|Png files(*.png)|*.png|Jpg files(*.jpg)|*.jpg";
DialogResult result = fileWindow.ShowDialog();
if (result == System.Windows.Forms.DialogResult.OK)
{
Random rand = new Random();
var newDocument = new PrintableDocument()
{
Title = fileWindow.SafeFileName.Split('.')[0],
TimeInSec = rand.Next(5, 15).ToString(),
DocumentType = fileWindow.SafeFileName.Split('.')[1],
ListSizes = new Tuple <int, int>(rand.Next(500, 2000), rand.Next(500, 2000)),
Size = rand.Next(10, 10000).ToString(),
Status = LOADED
};
DocumentsList.Add(newDocument);
}
ShowDocuments(_currentDocumentsStatuses);
}
public void Save_WithValueOnPrint_CallFileWriterSaveWithCorrectFileContent()
{
var outPath = "/usr/desktop";
var testPrintValue = "value";
var testPrintableDocument = new Mock <ITestPrintableDocument>();
testPrintableDocument.Setup(x => x.Print()).Returns(testPrintValue);
var documentBuilderMock = new Mock <IFormattableDocumentBuilder>();
documentBuilderMock.Setup(db => db.Build <ITestPrintableDocument>()).Returns(testPrintableDocument.Object);
var fileWriterMock = new Mock <IFileWriter>();
var document =
new PrintableDocument <ITestPrintableDocument>(documentBuilderMock.Object, fileWriterMock.Object);
var formattableDocument = document.Create("Title");
document.Save(outPath, formattableDocument);
fileWriterMock.Verify(fw =>
fw.WriteAllText(It.IsAny <string>(), It.Is <string>(s => s.Equals(testPrintValue))));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="file">File object representing the msbuild project file</param>
/// <param name="documentBuilder">Factory for creating the output documentation file</param>
public ProjectOverviewGenerator(IFile file, IFormattableDocumentBuilder documentBuilder)
{
_printableDocumentBuilder = new PrintableDocument <T>(documentBuilder);
_msBuildProject = LoadMsBuildProject(file);
_outputDocument = CreateOutputDocument(file, _printableDocumentBuilder);
}
public PrintableDocument GeneratePrintableDocument()
{
PrintableDocument doc = new PrintableDocument();
XDocument xdoc = XDocument.Parse(xml);
XElement xdocument = xdoc.Root;
XElement xpages = xdocument.Element("Pages");
if (xpages != null)
{
foreach (var p in xpages.Elements())
{
PrintablePage page = parsePage(p, doc);
if (p.Element("Binding") != null)
{
parseBinding(p.Element("Binding"), page);
}
if (p.Element("Children") != null)
{
foreach (XElement childelem in p.Element("Children").Elements())
{
parseComponent(childelem, page);
}
page.Children.Sort(delegate(PrintableComponent pc1, PrintableComponent pc2) { return((pc1.Left + pc2.Top).CompareTo((pc2.Left + pc2.Top))); });
}
}
}
return(doc);
}
public void PrintDocuments(IEnumerable <IDocument> documents)
{
foreach (var document in documents)
{
var printableDocument = PrintableDocument.Create(document);
printableDocument.Print(printer);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="project">MsBuild-Project file to generate the documentation for</param>
/// <param name="file">File object representing the msbuild project file</param>
/// <param name="printableDocument">Object representing output documentation file</param>
public ProjectOverviewGenerator(IMsBuildProject project, IFile file, PrintableDocument <T> printableDocument)
{
_msBuildProject = project;
_printableDocumentBuilder = printableDocument;
_outputDocument = CreateOutputDocument(file, _printableDocumentBuilder);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="project">MsBuild-Project file to generate the documentation for</param>
/// <param name="file">File object representing the msbuild project file</param>
public ProjectOverviewGenerator(IMsBuildProject project, IFile file)
{
_msBuildProject = project;
_printableDocumentBuilder = new PrintableDocument <T>(new FileWriter());
_outputDocument = CreateOutputDocument(file, _printableDocumentBuilder);
}
NewDocument_WithDefaultEmptyConstructor_ShouldInitializeDocumentBuilderAndFileWriterAndNotThrowException()
{
var document = new PrintableDocument <ITestPrintableDocument>();
var printableDocument = document.Create("Test");
Assert.AreEqual("Test", printableDocument.Title);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="file">File object representing the msbuild project file</param>
public ProjectOverviewGenerator(IFile file)
{
var formattableDocumentBuilder = new PrintableDocument <T>();
_msBuildProject = LoadMsBuildProject(file);
_outputDocument = CreateOutputDocument(file, formattableDocumentBuilder);
_printableDocumentBuilder = formattableDocumentBuilder;
}
public IndexBuilder(PrintableDocument pd)
{
doc = pd;
components = new List <IndexItem>();
indexElements = new List <IndexComponent>();
// loop through the whole document, picking up the elements designated as index holders and adding all other elements to the components list;
foreach (PrintablePage pp in pd.Pages)
{
if (indexPage == null)
{
indexesPerIndexPage = 0;
}
foreach (PrintableComponent pc in pp.Children)
{
if (pc is CompositeComponent)
{
AddComponent((CompositeComponent)pc);
}
if ((indexPage == null || indexPage == pp) && pc is TextComponent && ((TextComponent)pc).BindingOption == TextComponent.SpecialBinding.Index)
{
if (indexPage == null) // no index page set?
{
indexPage = pp;
indexPageOriginalIndex = doc.Pages.IndexOf(indexPage);
}
if (indexElementHeight == 0.0)
{
indexElementHeight = pc.Height;
}
else
{
pc.Height = indexElementHeight;
}
if (indexStyle == null)
{
indexStyle = ((TextComponent)pc).Style;
lineHeight = Util.PointToMillimeter(((TextComponent)pc).Style.AsXFont().GetHeight());
}
else
{
((TextComponent)pc).Style = indexStyle;
}
indexesPerIndexPage++;
}
}
}
if (indexPage != null)
{
doc.Pages.Remove(indexPage);
}
}
public void Create_ReturnsMatchingProperties()
{
var source = TestUtils.CreateRandom <StubDocument>();
var actual = PrintableDocument.Create(source);
Assert.That(actual.DocumentType, Is.EqualTo(source.DocumentType));
Assert.That(actual.Path, Is.EqualTo(source.Path));
}
public void NewDocument_WithExistentPrintableDocumentType_ShouldCallCreateMethodOnFactory()
{
var testPrintableDocument = new Mock <ITestPrintableDocument>();
var documentBuilderMock = new Mock <IFormattableDocumentBuilder>();
documentBuilderMock.Setup(db => db.Build <ITestPrintableDocument>()).Returns(testPrintableDocument.Object);
var document = new PrintableDocument <ITestPrintableDocument>(documentBuilderMock.Object);
document.Create("Title");
documentBuilderMock.Verify(db => db.Build <ITestPrintableDocument>(), Times.Exactly(1));
}
public void Save_WithPathFromPrintableDocument_CallFileWriterSaveWithCorrectPath()
{
var outPath = "/usr/desktop";
var fileWriterMock = new Mock <IFileWriter>();
var document =
new PrintableDocument <ITestPrintableDocument>(fileWriterMock.Object);
IPrintableDocument formattableDocument = document.Create("Title");
document.Save(outPath, formattableDocument);
fileWriterMock.Verify(fw => fw.WriteAllText(It.Is <string>(s => s.Equals(outPath)), It.IsAny <string>()));
}
public void NewDocument_WithExistentPrintableDocumentTypeAndTitle_ShouldCallSetTitleOnPrintableDocument()
{
var testPrintableDocument = new Mock <ITestPrintableDocument>();
var documentBuilderMock = new Mock <IFormattableDocumentBuilder>();
documentBuilderMock.Setup(db => db.Build <ITestPrintableDocument>()).Returns(testPrintableDocument.Object);
testPrintableDocument.SetupSet(tpd => tpd.Title = It.IsAny <string>()).Verifiable();
var document = new PrintableDocument <ITestPrintableDocument>(documentBuilderMock.Object);
document.Create("Title");
testPrintableDocument.VerifySet(tpd => tpd.Title = It.Is <string>(s => s.Equals("Title")));
}
public MainPageViewModel()
{
payService = DependencyService.Get <IPayService>();
ReadCommand = new Command((e) =>
{
IsRunning = true;
CreditCard = new CreditCard();
switch ((string)e)
{
case "Nfc":
payService.Read(ReadType.Nfc);
break;
case "Ic":
payService.Read(ReadType.Ic);
break;
case "Magnetic":
payService.Read(ReadType.Magnetic);
break;
case "All":
payService.Read(ReadType.Nfc | ReadType.Ic | ReadType.Magnetic);
break;
}
});
PrintCommand = new Command(() =>
{
if (CreditCard == null)
{
return;
}
var entry = new PrintableDocument();
var print = entry.GenerateDocument(CreditCard);
DependencyService.Get <IPrinterService>().Print(print);
});
MessagingCenter.Instance.Unsubscribe <CreditCard>("PaymentCallback", "CreditCardReaded");
MessagingCenter.Instance.Subscribe <CreditCard>("PaymentCallback", "CreditCardReaded", (card) =>
{
if (string.IsNullOrWhiteSpace(card.CardHolderName))
{
card.CardHolderName = "Unreaded";
}
CreditCard = card;
IsRunning = false;
});
}
private void btnCargarXml_Click(object sender, EventArgs e)
{
try
{
string pathFile = txtXmlFilePath.Text;
string xml = File.ReadAllText(pathFile, Encoding.GetEncoding("ISO-8859-1"));
var dte = ChileSystems.DTE.Engine.XML.XmlHandler.DeserializeFromString <ChileSystems.DTE.Engine.Documento.DTE>(xml);
document = PrintableDocument.FromDTE(dte);
pictureBoxTimbre.BackgroundImage = document.TimbreImage = dte.Documento.TimbrePDF417(out string outMessage);
BindData();
}
catch (Exception ex)
{
MessageBox.Show("Ha ocurrido un error al cargar el archivo.\n\nError: " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void btn_Print_Click(object sender, RoutedEventArgs e)
{
//try
//{
string textToPrint = txt_Console.Text;
if (fontName == String.Empty)
{
fontName = "Consolas";
fontStyles = 0;
fontSize = 12;
}
textColor = ((SolidColorBrush)txt_Console.Foreground).Color;
PrintableDocument printableDocument = new PrintableDocument();
Font f = new Font(fontName, fontSize, (FontStyle)fontStyles);
printableDocument.PrintPage += delegate(object o, PrintPageEventArgs args)
{
args.Graphics.DrawString(textToPrint, f, new SolidBrush(System.Drawing.Color.Black), 0, 0);
};
#if DEBUG
Assembly ass = Assembly.GetEntryAssembly();
string directory = ass.Location;
string fileName = directory.Substring(0, directory.Length - 21) + @"\Test Print";
printableDocument.PrinterSettings.PrintToFile = true;
printableDocument.PrinterSettings.PrintFileName = fileName;
printableDocument.PrinterSettings.Copies = 1;
txt_Console.Text += "\n Printing To File: " + printableDocument.PrinterSettings.PrintFileName + "\n";
txt_Console.CaretIndex = txt_Console.Text.Length;
printableDocument.Print();
PrintSystemJobInfo info = defaultPrintQueue.AddJob(fileName, fileName, false);
#else
printableDocument.PrinterSettings.PrintToFile = false;
printableDocument.Print();
#endif
//}
//catch (Exception ex)
//{
// System.Console.WriteLine(ex.StackTrace);
// MessageBox.Show("There was an error while printing the document");
//}
}
/// <summary>
/// Parses an XElement with page information into a PrintablePage
/// </summary>
/// <param name="pageElement">XElement with information for a page</param>
/// <param name="doc">Optional document object, page and styles will be added to this</param>
/// <returns>PrintablePage with the information from the element</returns>
private PrintablePage parsePage(XElement pageElement, PrintableDocument doc = null)
{
double width = 0.0, height = 0.0;
try {
width = double.Parse(pageElement.Attribute("Width").Value);
height = double.Parse(pageElement.Attribute("Height").Value);
}
catch (Exception e) {
throw new Exception("Page has invalid size");
}
PrintablePage page = new PrintablePage(width, height);
if (doc != null)
{
doc.Pages.Add(page);
}
return(page);
}
public DocumentPaginatorWrapper(DocumentPaginator paginator, PrintableDocumentDefinition definition)
{
if (!(paginator.Source is PrintableDocument))
{
throw new Exception("This paginator can be used only in PrintableDocument classes");
}
_paginator = paginator;
_definition = definition;
doc = Source as PrintableDocument;
var headerSize = GetModelContentSize(doc.DataContext, doc.Header, _definition.PageSize);
var footerSize = GetModelContentSize(doc.DataContext, doc.Footer, _definition.PageSize);
_definition.HeaderHeight = double.IsInfinity(headerSize.Height) ? 0 : headerSize.Height;
_definition.FooterHeight = double.IsInfinity(footerSize.Height) ? 0 : footerSize.Height;
_paginator.PageSize = _definition.ContentSize;
ComputePageCount();
doc.DataSource.PageCount = _paginator.PageCount;
}
private PrintableDocument CreateRandomDocument()
{
return(PrintableDocument.Create(TestUtils.CreateRandom <StubDocument>()));
}
/// <summary>
/// Constructor
/// </summary>
public TargetOverviewSiteGenerator()
{
_printableDocument = new PrintableDocument <T>();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="printableDocument">Builder for the target output document</param>
public TargetOverviewSiteGenerator(PrintableDocument <T> printableDocument)
{
_printableDocument = printableDocument;
}
/// <summary>
/// Creates the output file from the document builder for the given generic type.
/// </summary>
/// <param name="file">The file for which the output documentation file should be created</param>
/// <param name="printableDocument">The document builder which is used for creating the output file</param>
/// <returns>Instance of the requested generic type</returns>
private IPrintableDocument CreateOutputDocument(IFile file, PrintableDocument <T> printableDocument)
{
return(printableDocument.Create(file.FileName));
}
public void ChangeDocumentStatus(PrintableDocument currentDocument, string status)
{
currentDocument.Status = status;
ChangeControlButtonsVisibility();
ShowDocuments(_currentDocumentsStatuses);
}
/// <summary>
/// Constructor
/// </summary>
public MsBuildDocumentationGenerator()
{
_printableDocument = new PrintableDocument <T>();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="filePath">Path of the file for which the documentation should be created</param>
/// <param name="printableDocument">The printable document</param>
public MsBuildDocumentationGenerator(string filePath, PrintableDocument <T> printableDocument) : this(filePath)
{
_printableDocument = printableDocument;
}
void IPrintingContext.PrintPrintableDocument(PrintableDocument printableDocument)
{
this.PrintPrintableDocument(printableDocument);
}
protected internal abstract void PrintPrintableDocument(PrintableDocument printableDocument);
