public void StoreValues(Data data, string path) { data.SetValue(@"" + path + @"Duplex", Duplex.ToString()); data.SetValue(@"" + path + @"Enabled", Enabled.ToString()); data.SetValue(@"" + path + @"PrinterName", Data.EscapeString(PrinterName)); data.SetValue(@"" + path + @"SelectPrinter", SelectPrinter.ToString()); }
public bool Finish() { lock (Sync) { if (State == ParseState.Dormant) { return(false); } State = ParseState.Dormant; if (IsTransforming) { if (IsTransformFinishable && !(Transform as IFinishable).Finish()) { return(false); } if (Transform.BufferedReadable > 0 && !HandleReadable(Transform.Read())) { return(false); } } Transform = null; Malformed = false; IsTransforming = IsTransformFinishable = false; ChunkLengthString = null; ChunkIndex = ChunkLength = 0; OnFinish?.Invoke(); return(true); } }
private Duplex DuplexIntToDuplex(int dup) { Duplex a = new Duplex(); switch (dup) { case 1: a = Duplex.Simplex; break; case 2: a = Duplex.Vertical; break; case 3: a = Duplex.Horizontal; break; default: a = Duplex.Default; break; } return(a); }
public override bool Equals(object o) { if (!(o is Printing)) { return(false); } Printing v = o as Printing; if (!Duplex.Equals(v.Duplex)) { return(false); } if (!Enabled.Equals(v.Enabled)) { return(false); } if (!PrinterName.Equals(v.PrinterName)) { return(false); } if (!SelectPrinter.Equals(v.SelectPrinter)) { return(false); } return(true); }
/// <summary> /// Método que usa la librería PdfiumViewer para imprimir PDF sin Adobe. /// Duplex usa varios valores: horizontal (dos lados horizontal), simplex (un lado), vertical (dos lados vertical), default. /// Copias es el número de veces que se va a imprimir el archivo. /// </summary> /// <param name="impresora"></param> /// <param name="archivo"></param> /// <param name="copias"></param> /// <param name="duplex"></param> /// <returns></returns> public bool imprimePDF(string impresora, string archivo, int copias, Duplex duplex) { try { // Propiedades impresora var printerSettings = new PrinterSettings { PrinterName = impresora, Copies = (short)copias, Duplex = duplex }; // Imprimir PDF using (var document = PdfDocument.Load(archivo)) { using (var printDocument = document.CreatePrintDocument()) { printDocument.PrinterSettings = printerSettings; printDocument.PrintController = new StandardPrintController(); printDocument.Print(); } } return(true); } catch (Exception e) { Console.WriteLine(e.ToString()); return(false); } }
// Convert this object into a string. public override String ToString() { StringBuilder builder = new StringBuilder(); builder.Append("[PrinterSettings "); builder.Append(PrinterName); builder.Append(" Copies="); builder.Append(Copies.ToString()); builder.Append(" Collate="); builder.Append(Collate.ToString()); builder.Append(" Duplex="); builder.Append(Duplex.ToString()); builder.Append(" FromPage="); builder.Append(FromPage.ToString()); builder.Append(" LandscapeAngle="); builder.Append(LandscapeAngle.ToString()); builder.Append(" MaximumCopies="); builder.Append(MaximumCopies.ToString()); builder.Append(" OutputPort="); builder.Append(ToolkitPrinter.OutputPort.ToString()); builder.Append(" ToPage="); builder.Append(ToPage.ToString()); builder.Append(']'); return(builder.ToString()); }
/// <summary> /// 打印PDF /// </summary> /// <param name="path"></param> /// <param name="horizontal"></param> public static void PrintPDF(string path, int Copies = 1, Duplex horizontal = Duplex.Simplex, string range = null) { PdfDocument pdf = new PdfDocument(path);//Set the printer PrintDocument print = pdf.PrintDocument; Print(print, path, Copies, horizontal, range); }
/// <summary> /// Método que usa el comando "print" de Windows para imprimir un archivo. /// Duplex usa varios valores: horizontal (dos lados horizontal), simplex (un lado), vertical (dos lados vertical), default. /// Copias es el número de veces que se va a imprimir el archivo. /// </summary> /// <param name="impresora"></param> /// <param name="archivo"></param> /// <param name="copias"></param> /// <param name="duplex"></param> /// <returns></returns> public bool imprime(string impresora, string archivo, short copias, Duplex duplex) { try { PrinterSettings opciones = new PrinterSettings(); opciones.PrinterName = nombreImpresora; opciones.Duplex = duplex; opciones.Copies = copias; Process p = new Process(); // p.StartInfo.UseShellExecute = false; p.StartInfo.CreateNoWindow = true; p.StartInfo.FileName = archivo; p.StartInfo.Verb = "print"; p.Start(); p.StartInfo.WindowStyle = ProcessWindowStyle.Hidden; if (p.HasExited == false) { p.WaitForExit(10000); } p.EnableRaisingEvents = true; //p.CloseMainWindow(); p.Close(); return(true); } catch (Exception) { return(false); } }
public bool Finish() { lock (Sync) { if (Finished) { return(false); } if (IsTransforming) { if (IsTransformFinishable && !(Transform as IFinishable).Finish()) { return(false); } if (Transform.BufferedReadable > 0 && !WriteChunk(Transform.Read())) { return(false); } } if (!WriteLast()) { return(false); } Transform = null; IsTransforming = false; IsTransformFinishable = false; Finished = true; Type = null; CurrentLength = CurrentEncodedLength = 0; OnFinish?.Invoke(); return(true); } }
/// <summary> /// 根据格式 自动识别打印 /// </summary> /// <param name="path"></param> /// <param name="horizontal"></param> /// <returns></returns> public static bool Print(string path, int copies, Duplex horizontal = Duplex.Simplex) { if (Utils.CheckFileExists(path)) { string exName = Path.GetExtension(path).ToLower().Remove(0, 1); if (exName.Contains("doc")) { PrintDoc(path, copies, horizontal); } if (exName.Contains("xls")) { PrintXLS(path, copies, horizontal); } else if (exName.Equals("pdf")) { PrintPDF(path, copies, horizontal); } else if (Array.IndexOf(ImageFormatNameArray, exName) != -1) { PrintPicture(path, copies, horizontal); } return(true); } return(false); }
/// <summary> /// Sets special variables by printer settings. /// </summary> private void SetByPrinterSettings() { try { // check the printer settings if (PrinterSettings != null) { PrintDuplex = PrinterSettings.Duplex; PrintWithColor = PrinterSettings.DefaultPageSettings.Color; //NumberOfPages = PostScriptMetaData.NumberOfPages; NumberOfCopies = PrinterSettings.Copies; if (!string.IsNullOrWhiteSpace(PrintBooklet)) { if (PrintBooklet.Contains("2-sided")) { PrintBooklet = null; } else if (PrintBooklet.Equals("None")) { PrintBooklet = null; } } LogHelper.LogDebug(PrintBooklet); } } catch (Exception ex) { LogHelper.Log(ex); } SetStatus(); }
public override void QueryPageSettings(object sender, QueryPageSettingsEventArgs e) { if (FFirstTime) { Page = GetNextPage(); } FFirstTime = false; if (Page != null) { SetPaperSize(Report.PrintSettings.PrintOnSheetWidth, Report.PrintSettings.PrintOnSheetHeight, Report.PrintSettings.PrintOnSheetRawPaperSize, e); // rotate page if print 2 or 8 pages per sheet bool rotate = Report.PrintSettings.PagesOnSheet == PagesOnSheet.Two || Report.PrintSettings.PagesOnSheet == PagesOnSheet.Eight; e.PageSettings.Landscape = rotate ? !Page.Landscape : Page.Landscape; SetPaperSource(Page, e); Duplex duplex = Page.Duplex; if (duplex != Duplex.Default) { e.PageSettings.PrinterSettings.Duplex = duplex; } } }
/// <summary> /// 打印excel /// </summary> /// <param name="path"></param> /// <param name="copies"></param> /// <param name="horizontal"></param> public static void PrintXLS(string path, int copies, Duplex horizontal = Duplex.Simplex) { var tempbook = new Workbook(); tempbook.LoadFromFile(path); var document = tempbook.PrintDocument; Print(document, path, copies, horizontal); }
public void Duplex_SetValue_ReturnsExpected(Duplex duplex) { var printerSettings = new PrinterSettings() { Duplex = duplex }; Assert.Equal(duplex, printerSettings.Duplex); }
///<summary>Gets a PrintDocument that has some added functionality. All printing in Open Dental should use this method (or an ODprintout object) for printing.</summary> ///<param name="printPageEventHandler">The handler that will get invoked when printing. This defines how to draw each page.</param> ///<param name="printSit">ODprintout does not do anything with this field. But when ValidationDelegate is invoked we will provide the information if needed.</param> ///<param name="auditPatNum">ODprintout does not do anything with this field. But when ValidationDelegate is invoked we will provide the information if needed.</param> ///<param name="auditDescription">ODprintout does not do anything with this field. But when ValidationDelegate is invoked we will provide the information if needed.</param> ///<param name="margins">When set, this will override the default margins of "new Margins(25,25,40,40)".</param> ///<param name="printoutOrigin">Defaults to printer default. Set to AtMargin if the graphics origin starts at the page margins; AtZero if the graphics origin is at the top-left corner of the printable page.</param> ///<param name="paperSize">When set, this will override the default paperSize of "new PaperSize("default",850,1100)".</param> ///<param name="totalPages">When creating an ODprintout for print previewing, this defines the total number of pages.</param> ///<param name="printoutOrientation">Defaults to printers default value. Otherwise specify a value for either landscape or portrait.</param> ///<param name="duplex">Typically set when performing double-sided printing.</param> ///<param name="copies">Gets or sets the number of copies of the document to print.</param> ///<param name="totalPages">ODprintout does not do anything with this field. But when ValidationDelegate is invoked we will provide the information if needed. Defaults to 1.</param> ///<param name="printOrPreviewExceptionDelegate">Any custom delegate that the calling method wants to happen when printing or previewing throws an exception.</param> ///<param name="tryPreviewDelegate">Required to be implemented if the calling method needs the ability to preview.</param> ///<param name="tryPrintOrDebugPreviewDelegate">Same as tryPreviewDelegate, but defines isPreview based on if program is in DEBUG mode.</param> ///<returns>A new ODprintout with the given args that serves as a conduit safe printing and previewing methods.</returns> public ODprintout(PrintPageEventHandler printPageEventHandler = null, PrintSituation printSit = PrintSituation.Default, long auditPatNum = 0, string auditDescription = "" , Margins margins = null, PrintoutOrigin printoutOrigin = PrintoutOrigin.Default, PaperSize paperSize = null, PrintoutOrientation printoutOrientation = PrintoutOrientation.Default , Duplex duplex = Duplex.Default, short copies = 1, int totalPages = 1) : base() { CurPrintout = this; _printDoc = new PrintDocument(); //if(InitPrintSettings!=null) { // _printDoc.PrinterSettings=InitPrintSettings; // InitPrintSettings=null; //} Situation = printSit; AuditPatNum = auditPatNum; AuditDescription = auditDescription; TotalPages = totalPages; if (!HasValidSettings) { return; } _printDoc.PrintPage += printPageEventHandler; if (printoutOrientation != PrintoutOrientation.Default) { _printDoc.DefaultPageSettings.Landscape = (printoutOrientation == PrintoutOrientation.Landscape)?true:false; } if (printoutOrigin != PrintoutOrigin.Default) { _printDoc.OriginAtMargins = (printoutOrigin == PrintoutOrigin.AtMargin)?true:false; } _printDoc.DefaultPageSettings.Margins = (margins ?? new Margins(25, 25, 40, 40)); if (paperSize == null) { //This prevents a bug caused by some printer drivers not reporting their papersize. //But remember that other countries use A4 paper instead of 8 1/2 x 11. if ((InvalidMinDefaultPageWidth != -1 && _printDoc.DefaultPageSettings.PrintableArea.Width <= InvalidMinDefaultPageWidth) || (InvalidMinDefaultPageHeight != -1 && _printDoc.DefaultPageSettings.PrintableArea.Height <= InvalidMinDefaultPageHeight)) { _printDoc.DefaultPageSettings.PaperSize = new PaperSize("default", 850, 1100); } InvalidMinDefaultPageHeight = 0; InvalidMinDefaultPageWidth = -1; } else { _printDoc.DefaultPageSettings.PaperSize = paperSize; } _printDoc.PrinterSettings.Copies = copies; if (duplex != Duplex.Default) { _printDoc.PrinterSettings.Duplex = duplex; } if (ODBuild.IsWeb()) { //https://referencesource.microsoft.com/#System.Drawing/commonui/System/Drawing/Printing/PrintDocument.cs,3f3c2622b65be86a //The PrintController property will create a PrintControllerWithStatusDialog if no print controller is explictly set. _printDoc.PrintController = new StandardPrintController(); //Default PrintController shows a dialog that locks up web. } }
} //The SW in 10/100T-SW-A public portSpeed(Duplex duplex, Tuple <int, int, int, int> speed, char speedMod, string midMod) { this.duplex = duplex; this.speed = speed; this.speedMod = speedMod; this.midMod = midMod; }
/// <summary> /// doc转为pdf打印 /// </summary> /// <param name="path"></param> /// <param name="horizontal"></param> public static void DocToPDFPrint(string path, int copies = 1, Duplex horizontal = Duplex.Simplex, string range = null) { string descPath = "c:/" + Path.GetFileNameWithoutExtension(path); WordToPDF(path, descPath); PrintPDF(descPath, copies, horizontal, range); File.Delete(descPath); }
public override string ToString() { StringBuilder sb = new StringBuilder(); sb.AppendLine("Duplex=" + Duplex.ToString()); sb.AppendLine("Enabled=" + Enabled.ToString()); sb.AppendLine("PrinterName=" + PrinterName.ToString()); sb.AppendLine("SelectPrinter=" + SelectPrinter.ToString()); return(sb.ToString()); }
/// <summary> /// word打印 /// </summary> /// <param name="path"></param> /// <param name="horizontal"></param> public static void PrintDoc(string path, int copies = 1, Duplex horizontal = Duplex.Simplex) { Document document = new Document(path); PrinterSettings settings = new PrinterSettings(); settings.Copies = (short)copies; if (settings.CanDuplex) { settings.Duplex = horizontal; } document.Print(settings); }
private void PrintInternal(PrinterSettings printerSettings, int curPage) { using (PrintDocument doc = new PrintDocument()) { if (printerSettings != null) { doc.PrinterSettings = printerSettings; } PrintControllerBase controller = null; switch (FReport.PrintSettings.PrintMode) { case PrintMode.Default: controller = new DefaultPrintController(FReport, doc, curPage); break; case PrintMode.Split: controller = new SplitPrintController(FReport, doc, curPage); break; case PrintMode.Scale: controller = new ScalePrintController(FReport, doc, curPage); break; } doc.PrintController = new StandardPrintController(); doc.PrintPage += new PrintPageEventHandler(controller.PrintPage); doc.QueryPageSettings += new QueryPageSettingsEventHandler(controller.QueryPageSettings); Duplex duplex = FReport.PrintSettings.Duplex; if (duplex != Duplex.Default) { doc.PrinterSettings.Duplex = duplex; } try { FReport.SetOperation(ReportOperation.Printing); Config.ReportSettings.OnStartProgress(FReport); doc.Print(); Config.ReportSettings.OnReportPrinted(FReport); } finally { Config.ReportSettings.OnFinishProgress(FReport); FReport.SetOperation(ReportOperation.None); } } }
public Duplex <bool, decimal?> CheckOnFs(string appNumber, string fsPath) { Duplex <bool, decimal?> result = new Duplex <bool, decimal?>(); string fsPathWithAppNumber = GetFullPath(appNumber, fsPath); result.Item1 = Directory.Exists(fsPathWithAppNumber); if (result.Item1) { result.Item2 = CalculateDirectorySize(fsPathWithAppNumber); } _log.Debug($"'{appNumber}' in '{fsPathWithAppNumber}' -> '{result.Item1}'| size '{result.Item2}'"); return(result); }
// Constructor. public PrinterSettings() { collate = false; copies = 1; duplex = Duplex.Default; fromPage = 0; landscapeAngle = 0; maximumCopies = 1; maximumPage = 9999; minimumPage = 0; printerName = null; printRange = PrintRange.AllPages; printToFile = false; toPage = 0; toolkitPrinter = null; }
public void CreateDuplex(Duplex duplex) { if (!IsDuplexExists(duplex)) { duplex.MW = duplex.AntiSenseStrand.MW + duplex.SenseStrand.MW; duplex.AntiSenseStrand = null; duplex.SenseStrand = null; duplex.Target = null; _db.Entry(duplex).State = EntityState.Added; _db.SaveChanges(); duplex.DuplexId = GetNextDuplexId(duplex.Id); _db.Entry(duplex).State = EntityState.Modified; _db.SaveChanges(); } }
public override void QueryPageSettings(object sender, QueryPageSettingsEventArgs e) { Page = GetNextSplittedPage(); if (Page != null) { SetPaperSize(Report.PrintSettings.PrintOnSheetWidth, Report.PrintSettings.PrintOnSheetHeight, Report.PrintSettings.PrintOnSheetRawPaperSize, e); e.PageSettings.Landscape = FLandscape; SetPaperSource(Page, e); Duplex duplex = Page.Duplex; if (duplex != Duplex.Default) { e.PageSettings.PrinterSettings.Duplex = duplex; } } }
public override void QueryPageSettings(object sender, QueryPageSettingsEventArgs e) { Page = GetNextPage(); if (Page != null) { SetPaperSize(Page, e); e.PageSettings.Landscape = Page.Landscape; SetPaperSource(Page, e); Duplex duplex = Page.Duplex; if (duplex != Duplex.Default) { e.PageSettings.PrinterSettings.Duplex = duplex; } } }
public void DeleteDuplex(Duplex duplex) { _db.DuplexBatchStrandBatches.RemoveRange(duplex.Batches.SelectMany(ds => ds.DuplexBatchStrandBatches)); _db.DuplexBatches.RemoveRange(duplex.Batches); var materialRequests = _db.DuplexMaterialRequests .Where(r => r.DuplexId == duplex.Id) .ToList(); foreach (var request in materialRequests) { _db.SetEntityStateDeleted(request); } _db.Entry(duplex).State = EntityState.Deleted; _db.SaveChanges(); }
public bool TrySetFor(BodyType type) { lock (Sync) { if (State != ParseState.Dormant) { return(false); } if (type.Compression == TransferCompression.Compress) { return(false); } if (type.Encoding == TransferEncoding.None) { return(true); } Type = type; switch (type.Compression) { case TransferCompression.None: IsTransforming = false; break; case TransferCompression.Deflate: IsTransforming = true; Transform = new DeflateDecompressor(); IsTransformFinishable = true; break; case TransferCompression.Gzip: IsTransforming = true; Transform = new GzipDecompressor(); IsTransformFinishable = true; break; } switch (type.Encoding) { case TransferEncoding.Binary: State = ParseState.Binary; break; case TransferEncoding.Chunked: State = ParseState.Chunked_Length; break; } return(true); } }
/// <summary> /// Update data by DEVMODE structure. /// </summary> private void UpdateDataDevMode() { try { // get job info var jobInfo2 = CubiclesPrinterLib.Win32.Print.PrintJob.GetJobInfo(PrintJobData.RemotePrinterName, PrintJobData.PrintJobTitle.JobID); if (jobInfo2 != null) { NumberOfCopies = (short)jobInfo2.dmOut.dmCopies; PrintDuplex = (Duplex)jobInfo2.dmOut.dmDuplex; } else { WPFNotifier.Warning(PrintJobData.RemotePrinterName + Environment.NewLine + " Can't access printer, data corrupted, default values set."); } } catch (Exception ex) { WPFNotifier.Error(ex); } }
public bool TrySetFor(BodyType type) { lock (Sync) { if (!Finished) { return(false); } if (type.Compression == TransferCompression.Compress) { return(false); } if (type.Encoding == TransferEncoding.None) { return(true); } Finished = false; Type = type; switch (type.Compression) { case TransferCompression.None: IsTransforming = false; break; case TransferCompression.Deflate: IsTransforming = true; Transform = new DeflateCompressor(); IsTransformFinishable = true; break; case TransferCompression.Gzip: IsTransforming = true; Transform = new GzipCompressor(); IsTransformFinishable = true; break; } return(true); } }
/// <summary> /// Resets all settings to its default values. /// </summary> public void Clear() { FPrinter = ""; FSavePrinterWithReport = false; FPrintToFile = false; FPrintToFileName = ""; FPageRange = PageRange.All; FPageNumbers = ""; FCopies = 1; FCollate = true; FPrintPages = PrintPages.All; FReverse = false; FDuplex = Duplex.Default; FPaperSource = 7; FPrintMode = PrintMode.Default; FPrintOnSheetWidth = 210; FPrintOnSheetHeight = 297; FPrintOnSheetRawPaperSize = 0; FPagesOnSheet = PagesOnSheet.One; FCopyNames = new string[0]; FShowDialog = true; DisposeMeasureGraphics(); }
public void SetHdevmode(IntPtr hdevmode) { IntSecurity.AllPrintingAndUnmanagedCode.Demand(); // Don't assert unmanaged code -- anyone using handles should have unmanaged code permission if (hdevmode == IntPtr.Zero) throw new ArgumentException(SR.GetString(SR.InvalidPrinterHandle, hdevmode)); IntPtr pointer = SafeNativeMethods.GlobalLock(new HandleRef(null, hdevmode)); SafeNativeMethods.DEVMODE mode = (SafeNativeMethods.DEVMODE) UnsafeNativeMethods.PtrToStructure(pointer, typeof(SafeNativeMethods.DEVMODE)); //Copy entire public devmode as a byte array... devmodebytes = mode.dmSize; if (devmodebytes > 0) { cachedDevmode = new byte[devmodebytes]; Marshal.Copy(pointer, cachedDevmode, 0, devmodebytes); } //Copy private devmode as a byte array.. extrabytes = mode.dmDriverExtra; if (extrabytes > 0) { extrainfo = new byte[extrabytes]; Marshal.Copy((IntPtr)(checked((long)pointer + (long)mode.dmSize)), extrainfo, 0, extrabytes); } if ((mode.dmFields & SafeNativeMethods.DM_COPIES) == SafeNativeMethods.DM_COPIES) { copies = mode.dmCopies; } if ((mode.dmFields & SafeNativeMethods.DM_DUPLEX) == SafeNativeMethods.DM_DUPLEX ) { duplex = (Duplex) mode.dmDuplex; } if ((mode.dmFields & SafeNativeMethods.DM_COLLATE) == SafeNativeMethods.DM_COLLATE) { collate = (mode.dmCollate == SafeNativeMethods.DMCOLLATE_TRUE); } SafeNativeMethods.GlobalUnlock(new HandleRef(null, hdevmode)); }