Example #1
0
        public virtual void AddCustomAnd()
        {
            PageRange range = new PageRange();

            PageRange.IPageRangePart odd = PageRange.PageRangePartOddEven.ODD;
            PageRange.IPageRangePart seq = new PageRange.PageRangePartSequence(2, 14);
            PageRange.IPageRangePart and = new PageRange.PageRangePartAnd(odd, seq);
            range.AddPageRangePart(and);
            NUnit.Framework.Assert.AreEqual(range.GetQualifyingPageNums(15), iText.IO.Util.JavaUtil.ArraysAsList(3, 5,
                                                                                                                 7, 9, 11, 13));
        }
        public PageRangeDocumentPaginator(
            DocumentPaginator paginator,
            PageRange pageRange)
        {
            _startIndex = pageRange.PageFrom - 1;
            _endIndex   = pageRange.PageTo - 1;
            _paginator  = paginator;

            // Adjust the _endIndex
            _endIndex = Math.Min(_endIndex, _paginator.PageCount - 1);
        }
Example #3
0
 protected override PdfWriter GetNextPdfWriter(PageRange documentPageRange)
 {
     try
     {
         return(new PdfWriter("splitDocument1_" + _partNumber++ + ".pdf"));
     }
     catch (FileNotFoundException e)
     {
         throw new Exception();
     }
 }
        /// <summary>
        /// Returns true if PdfAnnotateParameters instances are equal
        /// </summary>
        /// <param name="input">Instance of PdfAnnotateParameters to be compared</param>
        /// <returns>Boolean</returns>
        public bool Equals(PdfAnnotateParameters input)
        {
            if (input == null)
            {
                return(false);
            }

            return
                ((
                     FileId == input.FileId ||
                     (FileId != null &&
                      FileId.Equals(input.FileId))
                     ) &&
                 (
                     PageRange == input.PageRange ||
                     (PageRange != null &&
                      PageRange.Equals(input.PageRange))
                 ) &&
                 (
                     AnnotationType == input.AnnotationType ||
                     AnnotationType.Equals(input.AnnotationType)
                 ) &&
                 (
                     StickyNoteAnnotationParameters == input.StickyNoteAnnotationParameters ||
                     (StickyNoteAnnotationParameters != null &&
                      StickyNoteAnnotationParameters.Equals(input.StickyNoteAnnotationParameters))
                 ) &&
                 (
                     LinkAnnotationParameters == input.LinkAnnotationParameters ||
                     (LinkAnnotationParameters != null &&
                      LinkAnnotationParameters.Equals(input.LinkAnnotationParameters))
                 ) &&
                 (
                     FreeTextAnnotationParameters == input.FreeTextAnnotationParameters ||
                     (FreeTextAnnotationParameters != null &&
                      FreeTextAnnotationParameters.Equals(input.FreeTextAnnotationParameters))
                 ) &&
                 (
                     LineAnnotationParameters == input.LineAnnotationParameters ||
                     (LineAnnotationParameters != null &&
                      LineAnnotationParameters.Equals(input.LineAnnotationParameters))
                 ) &&
                 (
                     SquareAndCircleAnnotationParameters == input.SquareAndCircleAnnotationParameters ||
                     (SquareAndCircleAnnotationParameters != null &&
                      SquareAndCircleAnnotationParameters.Equals(input.SquareAndCircleAnnotationParameters))
                 ) &&
                 (
                     RubberStampAnnotationParameters == input.RubberStampAnnotationParameters ||
                     (RubberStampAnnotationParameters != null &&
                      RubberStampAnnotationParameters.Equals(input.RubberStampAnnotationParameters))
                 ));
        }
Example #5
0
 public SaveResult(FileFinder _form, SaveForm _saveForm, Search _serach, string _fullName,
                   PageRange _pageRange)
 {
     this.saveForm  = _saveForm;
     this.form      = _form;
     this.lvStatus  = this.form.LVStatus;
     this.fullName  = _fullName;
     this.search    = _serach;
     this.pageRange = _pageRange;
     this.setpValue = 100 / (this.pageRange.End - this.pageRange.Begin + 2);
     this.lastValue = 100 - this.setpValue * (this.pageRange.End - this.pageRange.Begin + 1);
 }
        /// <summary>
        /// Returns true if ImageMICRParameters instances are equal
        /// </summary>
        /// <param name="input">Instance of ImageMICRParameters to be compared</param>
        /// <returns>Boolean</returns>
        public bool Equals(ImageMICRParameters input)
        {
            if (input == null)
            {
                return(false);
            }

            return
                ((
                     FileId == input.FileId ||
                     (FileId != null &&
                      FileId.Equals(input.FileId))
                     ) &&
                 (
                     PageRange == input.PageRange ||
                     (PageRange != null &&
                      PageRange.Equals(input.PageRange))
                 ) &&
                 (
                     Font == input.Font ||
                     Font.Equals(input.Font)
                 ) &&
                 (
                     Context == input.Context ||
                     Context.Equals(input.Context)
                 ) &&
                 (
                     WhiteList == input.WhiteList ||
                     (WhiteList != null &&
                      WhiteList.Equals(input.WhiteList))
                 ) &&
                 (
                     RoiLeft == input.RoiLeft ||
                     RoiLeft.Equals(input.RoiLeft)
                 ) &&
                 (
                     RoiTop == input.RoiTop ||
                     RoiTop.Equals(input.RoiTop)
                 ) &&
                 (
                     RoiWidth == input.RoiWidth ||
                     RoiWidth.Equals(input.RoiWidth)
                 ) &&
                 (
                     RoiHeight == input.RoiHeight ||
                     RoiHeight.Equals(input.RoiHeight)
                 ) &&
                 (
                     ExpectedSymbolsCount == input.ExpectedSymbolsCount ||
                     ExpectedSymbolsCount.Equals(input.ExpectedSymbolsCount)
                 ));
        }
        public void PageRangeCalculatedCorrectlyForMariaDb(uint page, int start)
        {
            const ushort pageSize = 14;
            var          actual   = PageRangeCalculator.GetPageRange(0, page, pageSize);
            var          expected = new PageRange
            {
                Start    = start,
                PageSize = pageSize
            };

            Assert.Equal(expected.Start, actual.Start);
            Assert.Equal(expected.PageSize, pageSize);
        }
        public void PageRangeCalculatedCorrectlyForSqlServer(uint page, int start, int end)
        {
            const ushort pageSize = 14;
            var          actual   = PageRangeCalculator.GetPageRange(1, page, pageSize);
            var          expected = new PageRange
            {
                Start    = start,
                PageSize = pageSize,
                End      = end
            };

            Assert.Equal(expected, actual);
        }
Example #9
0
 /// <summary>
 /// Export task with transformation pipeline.
 /// </summary>
 /// <param name="transformPipeline"></param>
 public ExportTask(PageRange pages, List <IPageTransformation> transformPipeline)
 {
     Pages = pages ?? throw new ArgumentException("PageRange must not be null");
     if (transformPipeline is null)
     {
         // Interpret null-transformPipeline argument as no transformation
         TransformPipeline = new List <IPageTransformation>();
     }
     else
     {
         TransformPipeline = transformPipeline;
     }
 }
        /// <summary>
        /// Returns true if ImageSaveAsPDFMRCParameters instances are equal
        /// </summary>
        /// <param name="input">Instance of ImageSaveAsPDFMRCParameters to be compared</param>
        /// <returns>Boolean</returns>
        public bool Equals(ImageSaveAsPDFMRCParameters input)
        {
            if (input == null)
            {
                return(false);
            }

            return
                ((
                     FileId == input.FileId ||
                     (FileId != null &&
                      FileId.Equals(input.FileId))
                     ) &&
                 (
                     PageRange == input.PageRange ||
                     (PageRange != null &&
                      PageRange.Equals(input.PageRange))
                 ) &&
                 (
                     Conformance == input.Conformance ||
                     Conformance.Equals(input.Conformance)
                 ) &&
                 (
                     ColorImageCompression == input.ColorImageCompression ||
                     ColorImageCompression.Equals(input.ColorImageCompression)
                 ) &&
                 (
                     BitonalImageCompression == input.BitonalImageCompression ||
                     BitonalImageCompression.Equals(input.BitonalImageCompression)
                 ) &&
                 (
                     ImageQuality == input.ImageQuality ||
                     ImageQuality.Equals(input.ImageQuality)
                 ) &&
                 (
                     DownscaleResolution == input.DownscaleResolution ||
                     DownscaleResolution.Equals(input.DownscaleResolution)
                 ) &&
                 (
                     PreserveSmoothing == input.PreserveSmoothing ||
                     PreserveSmoothing.Equals(input.PreserveSmoothing)
                 ) &&
                 (
                     FastWebView == input.FastWebView ||
                     FastWebView.Equals(input.FastWebView)
                 ) &&
                 (
                     JBIG2PMSThreshold == input.JBIG2PMSThreshold ||
                     JBIG2PMSThreshold.Equals(input.JBIG2PMSThreshold)
                 ));
        }
Example #11
0
            private void ExtractPrintDataAndDevMode(IntPtr unmanagedBuffer, out string printerName, out uint flags, out PageRange pageRange, out IntPtr devModeHandle)
            {
                IntPtr intPtr  = IntPtr.Zero;
                IntPtr intPtr2 = IntPtr.Zero;

                if (!this.Is64Bit())
                {
                    NativeMethods.PRINTDLGEX32 printdlgex = (NativeMethods.PRINTDLGEX32)Marshal.PtrToStructure(unmanagedBuffer, typeof(NativeMethods.PRINTDLGEX32));
                    devModeHandle = printdlgex.hDevMode;
                    intPtr        = printdlgex.hDevNames;
                    flags         = printdlgex.Flags;
                    intPtr2       = printdlgex.lpPageRanges;
                }
                else
                {
                    NativeMethods.PRINTDLGEX64 printdlgex2 = (NativeMethods.PRINTDLGEX64)Marshal.PtrToStructure(unmanagedBuffer, typeof(NativeMethods.PRINTDLGEX64));
                    devModeHandle = printdlgex2.hDevMode;
                    intPtr        = printdlgex2.hDevNames;
                    flags         = printdlgex2.Flags;
                    intPtr2       = printdlgex2.lpPageRanges;
                }
                if ((flags & 2U) == 2U && intPtr2 != IntPtr.Zero)
                {
                    NativeMethods.PRINTPAGERANGE printpagerange = (NativeMethods.PRINTPAGERANGE)Marshal.PtrToStructure(intPtr2, typeof(NativeMethods.PRINTPAGERANGE));
                    pageRange = new PageRange((int)printpagerange.nFromPage, (int)printpagerange.nToPage);
                }
                else
                {
                    pageRange = new PageRange(1);
                }
                if (intPtr != IntPtr.Zero)
                {
                    IntPtr intPtr3 = IntPtr.Zero;
                    try
                    {
                        intPtr3 = UnsafeNativeMethods.GlobalLock(intPtr);
                        NativeMethods.DEVNAMES devnames = (NativeMethods.DEVNAMES)Marshal.PtrToStructure(intPtr3, typeof(NativeMethods.DEVNAMES));
                        int offset = checked ((int)devnames.wDeviceOffset * Marshal.SystemDefaultCharSize);
                        printerName = Marshal.PtrToStringAuto(intPtr3 + offset);
                        return;
                    }
                    finally
                    {
                        if (intPtr3 != IntPtr.Zero)
                        {
                            UnsafeNativeMethods.GlobalUnlock(intPtr);
                        }
                    }
                }
                printerName = string.Empty;
            }
Example #12
0
        private static void Print(FrameworkElement kundeInfo, ScrollViewer scrollViewer)
        {
            if (kundeInfo == null && scrollViewer == null)
            {
                return;
            }

            PrintDocumentImageableArea area      = null;
            PageRangeSelection         selection = PageRangeSelection.AllPages;
            PageRange         range  = new PageRange();
            XpsDocumentWriter xpsdw1 = PrintQueue.CreateXpsDocumentWriter("Corinor prisforslag", ref area, ref selection, ref range);

            if (xpsdw1 == null)
            {
                return;
            }

            //TODO: DEBUG
            //if (File.Exists("D:\\test.xps")) File.Delete("D:\\test.xps");
            //XpsDocument _xpsDocument = new XpsDocument("D:\\test.xps", FileAccess.ReadWrite);
            //XpsDocumentWriter xpsdw = XpsDocument.CreateXpsDocumentWriter(_xpsDocument);


            Thickness Margins = new Thickness(96);

            double leftMargin   = Margins.Left - area.OriginWidth;
            double topMargin    = Margins.Top - area.OriginHeight;
            double rightMargin  = Margins.Right - (area.MediaSizeWidth - area.ExtentWidth - area.OriginWidth);
            double bottomMargin = Margins.Bottom - (area.MediaSizeHeight - area.ExtentHeight - area.OriginHeight);
            Size   outputSize   = new Size(
                area.MediaSizeWidth - leftMargin - rightMargin,
                area.MediaSizeHeight - topMargin - bottomMargin);

            SerializerWriterCollator batchPrinter = xpsdw1.CreateVisualsCollator();

            batchPrinter.BeginBatchWrite();

            if (kundeInfo != null)
            {
                printKundeinfo(batchPrinter, kundeInfo, outputSize, leftMargin, topMargin);
            }
            if (scrollViewer != null && scrollViewer.Content != null)
            {
                printScrollViewer(batchPrinter, scrollViewer, outputSize, leftMargin, topMargin);
            }

            batchPrinter.EndBatchWrite();

            //TODO: Debug
            //_xpsDocument.Close();
        }
        /// <summary>
        /// Constructs a web request to write or clear a range of pages in a page blob.
        /// </summary>
        /// <param name="uri">The absolute URI to the blob.</param>
        /// <param name="timeout">The server timeout interval.</param>
        /// <param name="properties">The blob's properties.</param>
        /// <param name="accessCondition">The access condition to apply to the request.</param>
        /// <returns>A web request to use to perform the operation.</returns>
        public static HttpRequestMessage PutPage(Uri uri, int?timeout, PageRange pageRange, PageWrite pageWrite, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
        {
            UriQueryBuilder builder = new UriQueryBuilder();

            builder.Add(Constants.QueryConstants.Component, "page");

            HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext);

            request.AddOptionalHeader(Constants.HeaderConstants.RangeHeader, pageRange.ToString());
            request.Headers.Add(Constants.HeaderConstants.PageWrite, pageWrite.ToString());

            request.ApplyAccessCondition(accessCondition);
            return(request);
        }
        public static PageRange GetPageRange(byte absoluteFirstRecordIndex, uint page, ushort pageSize)
        {
            const byte pagesAdvanceRate    = 1;
            var        previousPage        = page - pagesAdvanceRate;
            var        relativeStartRecord = pagesAdvanceRate + (pageSize * previousPage);
            var        range = new PageRange
            {
                Start    = GetAbsoluteStartRecord(absoluteFirstRecordIndex, relativeStartRecord),
                PageSize = pageSize,
            };

            range.End = range.Start + pageSize - pagesAdvanceRate;
            return(range);
        }
Example #15
0
        public void Parse_Invalid()
        {
            var input = string.Empty;

            Assert.Throws <ArgumentNullException>(() => PageRange.Parse(null !));
            Assert.Throws <ArgumentException>(() => PageRange.Parse(input));
            Assert.Throws <ArgumentException>(() => PageRange.Parse("-"));
            Assert.Throws <FormatException>(() => PageRange.Parse("InvalidNumber-6"));
            Assert.Throws <FormatException>(() => PageRange.Parse("6-InvalidNumber"));

            Assert.Throws <ArgumentOutOfRangeException>(() => PageRange.Parse("6-4"));

            Assert.Throws <ArgumentException>(() => PageRange.Parse("4,6"));
        }
Example #16
0
 private void PageRange_TextChanged(object sender, TextChangedEventArgs e)
 {
     try
     {
         selectedPageRange = PageRange.FromPattern(loadedFileList[0].Document, PageRangeInput.Text);
         PageRangeInvalidLabel.Visibility = Visibility.Collapsed;
     }
     catch (Exception)
     {
         PageRangeInvalidLabel.Visibility = Visibility.Visible;
     }
     ControlSaveButtonState();
     SetToggleButtonState();
     ShowSummary();
 }
        /// <summary>
        /// Constructs a web request to write or clear a range of pages in a page blob.
        /// </summary>
        /// <param name="uri">The absolute URI to the blob.</param>
        /// <param name="timeout">The server timeout interval.</param>
        /// <param name="properties">The blob's properties.</param>
        /// <param name="accessCondition">The access condition to apply to the request.</param>
        /// <returns>A web request to use to perform the operation.</returns>
        public static StorageRequestMessage PutPage(Uri uri, int?timeout, PageRange pageRange, PageWrite pageWrite, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials)
        {
            UriQueryBuilder builder = new UriQueryBuilder();

            builder.Add(Constants.QueryConstants.Component, "page");

            StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials);

            request.Headers.Add(Constants.HeaderConstants.RangeHeader, pageRange.ToString());
            request.Headers.Add(Constants.HeaderConstants.PageWrite, pageWrite.ToString());

            request.ApplyAccessCondition(accessCondition);
            request.ApplySequenceNumberCondition(accessCondition);
            return(request);
        }
Example #18
0
        public void Range_NotEquals()
        {
            var r1 = new PageRange(5, 10);
            var r2 = new PageRange(6, 10);

            Assert.That(r1, Is.Not.EqualTo(r2));

            Assert.True(r1 != r2);

            Assert.False(Equals(r1, r2));
            Assert.False(r1.Equals(null));
            Assert.That(r1, Is.Not.EqualTo(null));
            // ReSharper disable once SuspiciousTypeConversion.Global
            Assert.False(r1.Equals(5));
            Assert.That(r1.GetHashCode(), Is.Not.EqualTo(r2.GetHashCode()));
        }
Example #19
0
        private async void MergeButton_Click(object sender, RoutedEventArgs e)
        {
            if (loadedFilesList.Count > 0)
            {
                var savePicker = new FileSavePicker();
                savePicker.FileTypeChoices.Add("PDF-Document", new List <String>()
                {
                    ".pdf"
                });
                savePicker.SuggestedFileName = "MergedPdfDocuments";
                if (!StorageApplicationPermissions.FutureAccessList.ContainsItem(App.RECENT_FILE_DIRECTORY_TOKEN))
                {
                    savePicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
                }
                StorageFile savedFile = await savePicker.PickSaveFileAsync();

                if (savedFile != null)
                {
                    Task <Stream> outputStreamTask = savedFile.OpenStreamForWriteAsync();
                    Stream        outputStream     = await outputStreamTask;
                    if (outputStream != null)
                    {
                        PdfAssembler pdfAssembler = new PdfAssembler(outputStream);
                        foreach (var obj in loadedFilesList)
                        {
                            var        file      = (InternalFile)obj;
                            PageRange  pageRange = PageRange.EntireDocument(file.Document);
                            ExportTask task      = new ExportTask(pageRange);
                            pdfAssembler.AppendTask(task);
                        }
                        pdfAssembler.ExportFile();
                    }
                    else
                    {
                        ToolPage.Current.NotifyUser("Error occured while while exporting the merged file. Try again.", NotifyType.ErrorMessage);
                    }
                }
                else
                {
                    ToolPage.Current.NotifyUser("No output file has been selected.", NotifyType.ErrorMessage);
                }
            }
            else
            {
                ToolPage.Current.NotifyUser("No files loaded.", NotifyType.ErrorMessage);
            }
        }
Example #20
0
        /// <summary>
        /// Returns true if ImageSaveAsPDFParameters instances are equal
        /// </summary>
        /// <param name="input">Instance of ImageSaveAsPDFParameters to be compared</param>
        /// <returns>Boolean</returns>
        public bool Equals(ImageSaveAsPDFParameters input)
        {
            if (input == null)
            {
                return(false);
            }

            return
                ((
                     FileId == input.FileId ||
                     (FileId != null &&
                      FileId.Equals(input.FileId))
                     ) &&
                 (
                     PageRange == input.PageRange ||
                     (PageRange != null &&
                      PageRange.Equals(input.PageRange))
                 ) &&
                 (
                     Conformance == input.Conformance ||
                     Conformance.Equals(input.Conformance)
                 ) &&
                 (
                     ColorImageCompression == input.ColorImageCompression ||
                     ColorImageCompression.Equals(input.ColorImageCompression)
                 ) &&
                 (
                     BitonalImageCompression == input.BitonalImageCompression ||
                     BitonalImageCompression.Equals(input.BitonalImageCompression)
                 ) &&
                 (
                     EnableColorDetection == input.EnableColorDetection ||
                     EnableColorDetection.Equals(input.EnableColorDetection)
                 ) &&
                 (
                     ImageQuality == input.ImageQuality ||
                     ImageQuality.Equals(input.ImageQuality)
                 ) &&
                 (
                     DownscaleResolution == input.DownscaleResolution ||
                     DownscaleResolution.Equals(input.DownscaleResolution)
                 ) &&
                 (
                     FastWebView == input.FastWebView ||
                     FastWebView.Equals(input.FastWebView)
                 ));
        }
        /// <summary>
        /// Returns true if ImageCleanupDocumentParameters instances are equal
        /// </summary>
        /// <param name="input">Instance of ImageCleanupDocumentParameters to be compared</param>
        /// <returns>Boolean</returns>
        public bool Equals(ImageCleanupDocumentParameters input)
        {
            if (input == null)
            {
                return(false);
            }

            return
                ((
                     FileId == input.FileId ||
                     (FileId != null &&
                      FileId.Equals(input.FileId))
                     ) &&
                 (
                     PageRange == input.PageRange ||
                     (PageRange != null &&
                      PageRange.Equals(input.PageRange))
                 ) &&
                 (
                     RemoveBlackBorders == input.RemoveBlackBorders ||
                     RemoveBlackBorders.Equals(input.RemoveBlackBorders)
                 ) &&
                 (
                     Deskew == input.Deskew ||
                     Deskew.Equals(input.Deskew)
                 ) &&
                 (
                     RemoveLeftMarginPunchHoles == input.RemoveLeftMarginPunchHoles ||
                     RemoveLeftMarginPunchHoles.Equals(input.RemoveLeftMarginPunchHoles)
                 ) &&
                 (
                     RemoveTopMarginPunchHoles == input.RemoveTopMarginPunchHoles ||
                     RemoveTopMarginPunchHoles.Equals(input.RemoveTopMarginPunchHoles)
                 ) &&
                 (
                     RemoveRightMarginPunchHoles == input.RemoveRightMarginPunchHoles ||
                     RemoveRightMarginPunchHoles.Equals(input.RemoveRightMarginPunchHoles)
                 ) &&
                 (
                     RemoveBottomMarginPunchHoles == input.RemoveBottomMarginPunchHoles ||
                     RemoveBottomMarginPunchHoles.Equals(input.RemoveBottomMarginPunchHoles)
                 ) &&
                 (
                     DespeckleStrength == input.DespeckleStrength ||
                     DespeckleStrength.Equals(input.DespeckleStrength)
                 ));
        }
Example #22
0
        /// <summary>
        /// Returns true if PdfReadBarcodesParameters instances are equal
        /// </summary>
        /// <param name="input">Instance of PdfReadBarcodesParameters to be compared</param>
        /// <returns>Boolean</returns>
        public bool Equals(PdfReadBarcodesParameters input)
        {
            if (input == null)
            {
                return(false);
            }

            return
                ((
                     FileId == input.FileId ||
                     (FileId != null &&
                      FileId.Equals(input.FileId))
                     ) &&
                 (
                     PageRange == input.PageRange ||
                     (PageRange != null &&
                      PageRange.Equals(input.PageRange))
                 ) &&
                 (
                     ScanMode == input.ScanMode ||
                     ScanMode.Equals(input.ScanMode)
                 ) &&
                 (
                     ScanBarcode1D == input.ScanBarcode1D ||
                     ScanBarcode1D.Equals(input.ScanBarcode1D)
                 ) &&
                 (
                     ScanBarcodeQR == input.ScanBarcodeQR ||
                     ScanBarcodeQR.Equals(input.ScanBarcodeQR)
                 ) &&
                 (
                     ScanBarcodeMicroQR == input.ScanBarcodeMicroQR ||
                     ScanBarcodeMicroQR.Equals(input.ScanBarcodeMicroQR)
                 ) &&
                 (
                     ScanBarcodePDF417 == input.ScanBarcodePDF417 ||
                     ScanBarcodePDF417.Equals(input.ScanBarcodePDF417)
                 ) &&
                 (
                     ScanBarcodeDataMatrix == input.ScanBarcodeDataMatrix ||
                     ScanBarcodeDataMatrix.Equals(input.ScanBarcodeDataMatrix)
                 ) &&
                 (
                     ScanBarcodeAztec == input.ScanBarcodeAztec ||
                     ScanBarcodeAztec.Equals(input.ScanBarcodeAztec)
                 ));
        }
Example #23
0
        int GetPageNumber(PageRange pageRange)
        {
            if (pageRange == null)
            {
                return(1);
            }
            if (pageRange.StartPage == null)
            {
                return(1);
            }
            if (pageRange.StartPage.Number == null)
            {
                return(1);
            }

            return(pageRange.StartPage.Number.GetValueOrDefault(1));
        }
Example #24
0
        /// <summary>
        /// Returns true if PdfDrawImageParameters instances are equal
        /// </summary>
        /// <param name="input">Instance of PdfDrawImageParameters to be compared</param>
        /// <returns>Boolean</returns>
        public bool Equals(PdfDrawImageParameters input)
        {
            if (input == null)
            {
                return(false);
            }

            return
                ((
                     FileId == input.FileId ||
                     (FileId != null &&
                      FileId.Equals(input.FileId))
                     ) &&
                 (
                     PageRange == input.PageRange ||
                     (PageRange != null &&
                      PageRange.Equals(input.PageRange))
                 ) &&
                 (
                     ImageData == input.ImageData ||
                     (ImageData != null &&
                      ImageData.Equals(input.ImageData))
                 ) &&
                 (
                     ImageFileId == input.ImageFileId ||
                     (ImageFileId != null &&
                      ImageFileId.Equals(input.ImageFileId))
                 ) &&
                 (
                     Quality == input.Quality ||
                     Quality.Equals(input.Quality)
                 ) &&
                 (
                     ColorImageCompression == input.ColorImageCompression ||
                     ColorImageCompression.Equals(input.ColorImageCompression)
                 ) &&
                 (
                     BitonalCompression == input.BitonalCompression ||
                     BitonalCompression.Equals(input.BitonalCompression)
                 ) &&
                 (
                     ImageLayout == input.ImageLayout ||
                     (ImageLayout != null &&
                      ImageLayout.Equals(input.ImageLayout))
                 ));
        }
        /// <summary>
        /// Constructs a web request to write or clear a range of pages in a page blob.
        /// </summary>
        /// <param name="uri">The absolute URI to the blob.</param>
        /// <param name="timeout">The server timeout interval.</param>
        /// <param name="pageRange">The page range, defined by an object of type <see cref="PageRange"/>.</param>
        /// <param name="pageWrite">A value of type <see cref="PageWrite"/>, indicating the operation to perform on the page blob.</param>
        /// <param name="accessCondition">The <see cref="AccessCondition"/> to apply to the request.</param>
        /// <param name="operationContext">An <see cref="OperationContext" /> object for tracking the current operation.</param>
        /// <returns>
        /// A web request to use to perform the operation.
        /// </returns>
        public static HttpWebRequest PutPage(Uri uri, int?timeout, PageRange pageRange, PageWrite pageWrite, AccessCondition accessCondition, OperationContext operationContext)
        {
            CommonUtility.AssertNotNull("pageRange", pageRange);

            UriQueryBuilder builder = new UriQueryBuilder();

            builder.Add(Constants.QueryConstants.Component, "page");

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, operationContext);

            request.Headers.Add(Constants.HeaderConstants.RangeHeader, pageRange.ToString());
            request.Headers.Add(Constants.HeaderConstants.PageWrite, pageWrite.ToString());

            request.ApplyAccessCondition(accessCondition);
            request.ApplySequenceNumberCondition(accessCondition);
            return(request);
        }
 /// <summary>
 /// Gets the hash code
 /// </summary>
 /// <returns>Hash code</returns>
 public override int GetHashCode()
 {
     unchecked // Overflow is fine, just wrap
     {
         int hashCode = 41;
         if (FileId != null)
         {
             hashCode = hashCode * 59 + FileId.GetHashCode();
         }
         if (PageRange != null)
         {
             hashCode = hashCode * 59 + PageRange.GetHashCode();
         }
         hashCode = hashCode * 59 + RemoveOnlyHiddenText.GetHashCode();
         return(hashCode);
     }
 }
 /// <summary>
 /// Gets the hash code
 /// </summary>
 /// <returns>Hash code</returns>
 public override int GetHashCode()
 {
     unchecked // Overflow is fine, just wrap
     {
         int hashCode = 41;
         if (FileId != null)
         {
             hashCode = hashCode * 59 + FileId.GetHashCode();
         }
         if (PageRange != null)
         {
             hashCode = hashCode * 59 + PageRange.GetHashCode();
         }
         hashCode = hashCode * 59 + ThumbnailWidth.GetHashCode();
         hashCode = hashCode * 59 + ThumbnailHeight.GetHashCode();
         return(hashCode);
     }
 }
        // ExStart:ConvertDocumentToPNG
        public static void ConvertDocumentToPNG()
        {
            // The path to the documents directory.
            string dataDir = RunExamples.GetDataDir_LoadingAndSaving();

            // Load a document
            Document doc = new Document(dataDir + "SampleImages.doc");

            ImageSaveOptions imageSaveOptions = new ImageSaveOptions(SaveFormat.Png);

            PageRange pageRange = new PageRange(0, doc.PageCount - 1);

            imageSaveOptions.PageSet            = new PageSet(pageRange);
            imageSaveOptions.PageSavingCallback = new HandlePageSavingCallback();
            doc.Save(dataDir + "output.png", imageSaveOptions);

            Console.WriteLine("\nDocument converted to PNG successfully.");
        }
 /// <summary>
 /// Gets the hash code
 /// </summary>
 /// <returns>Hash code</returns>
 public override int GetHashCode()
 {
     unchecked // Overflow is fine, just wrap
     {
         int hashCode = 41;
         if (FileId != null)
         {
             hashCode = hashCode * 59 + FileId.GetHashCode();
         }
         if (PageRange != null)
         {
             hashCode = hashCode * 59 + PageRange.GetHashCode();
         }
         hashCode = hashCode * 59 + ScaleX.GetHashCode();
         hashCode = hashCode * 59 + ScaleY.GetHashCode();
         return(hashCode);
     }
 }
 /// <summary>
 /// Gets the hash code
 /// </summary>
 /// <returns>Hash code</returns>
 public override int GetHashCode()
 {
     unchecked // Overflow is fine, just wrap
     {
         int hashCode = 41;
         if (FileId != null)
         {
             hashCode = hashCode * 59 + FileId.GetHashCode();
         }
         if (PageRange != null)
         {
             hashCode = hashCode * 59 + PageRange.GetHashCode();
         }
         hashCode = hashCode * 59 + Compression.GetHashCode();
         hashCode = hashCode * 59 + JpegQuality.GetHashCode();
         return(hashCode);
     }
 }
        public void ClearPageRangeScenarioTest(string containerName, string blobName, HttpStatusCode? expectedError)
        {
            // 1. Create Sparse Page Blob
            int blobSize = 128 * 1024;

            BlobProperties properties = new BlobProperties() { BlobType = BlobType.PageBlob };
            Uri uri = BlobTests.ConstructPutUri(BlobContext.Address, containerName, blobName);
            OperationContext opContext = new OperationContext();
            HttpWebRequest webRequest = BlobHttpWebRequestFactory.Put(uri, BlobContext.Timeout, properties, BlobType.PageBlob, blobSize, null, opContext);

            BlobTests.SignRequest(webRequest, BlobContext);

            using (HttpWebResponse response = webRequest.GetResponse() as HttpWebResponse)
            {
                BlobTests.PutBlobResponse(response, BlobContext, expectedError);
            }

            // 2. Now upload some page ranges
            for (int m = 0; m * 512 * 4 < blobSize; m++)
            {
                int startOffset = 512 * 4 * m;
                int length = 512;
                
                PageRange range = new PageRange(startOffset, startOffset + length - 1);
                opContext = new OperationContext();
                HttpWebRequest pageRequest = BlobHttpWebRequestFactory.PutPage(uri, BlobContext.Timeout, range, PageWrite.Update, null, opContext);
                pageRequest.ContentLength = 512;
                BlobTests.SignRequest(pageRequest, BlobContext);

                Stream outStream = pageRequest.GetRequestStream();

                for (int n = 0; n < 512; n++)
                {
                    outStream.WriteByte((byte)m);
                }

                outStream.Close();
                using (HttpWebResponse pageResponse = pageRequest.GetResponse() as HttpWebResponse)
                {
                }
            }

            // 3. Now do a Get Page Ranges
            List<PageRange> pageRanges = new List<PageRange>();
            opContext = new OperationContext();
            HttpWebRequest pageRangeRequest = BlobHttpWebRequestFactory.GetPageRanges(uri, BlobContext.Timeout, null, null, null, null, opContext);
            BlobTests.SignRequest(pageRangeRequest, BlobContext);
            using (HttpWebResponse pageRangeResponse = pageRangeRequest.GetResponse() as HttpWebResponse)
            {
                GetPageRangesResponse getPageRangesResponse = new GetPageRangesResponse(pageRangeResponse.GetResponseStream());
                pageRanges.AddRange(getPageRangesResponse.PageRanges.ToList());
            }

            // 4. Now Clear some pages
            bool skipFlag = false;
            foreach (PageRange pRange in pageRanges)
            {
                skipFlag = !skipFlag;
                if (skipFlag)
                {
                    continue;
                }

                opContext = new OperationContext();
                HttpWebRequest clearPageRequest = BlobHttpWebRequestFactory.PutPage(uri, BlobContext.Timeout, pRange, PageWrite.Clear, null, opContext);
                clearPageRequest.ContentLength = 0;
                BlobTests.SignRequest(clearPageRequest, BlobContext);
                using (HttpWebResponse clearResponse = clearPageRequest.GetResponse() as HttpWebResponse)
                {
                }
            }

            // 5. Get New Page ranges and verify
            List<PageRange> newPageRanges = new List<PageRange>();

            opContext = new OperationContext();
            HttpWebRequest newPageRangeRequest = BlobHttpWebRequestFactory.GetPageRanges(uri, BlobContext.Timeout, null, null, null, null, opContext);
            BlobTests.SignRequest(newPageRangeRequest, BlobContext);
            using (HttpWebResponse newPageRangeResponse = newPageRangeRequest.GetResponse() as HttpWebResponse)
            {
                GetPageRangesResponse getNewPageRangesResponse = new GetPageRangesResponse(newPageRangeResponse.GetResponseStream());
                newPageRanges.AddRange(getNewPageRangesResponse.PageRanges.ToList());
            }

            Assert.AreEqual(pageRanges.Count(), newPageRanges.Count() * 2);
            for (int l = 0; l < newPageRanges.Count(); l++)
            {
                Assert.AreEqual(pageRanges[2 * l].StartOffset, newPageRanges[l].StartOffset);
                Assert.AreEqual(pageRanges[2 * l].EndOffset, newPageRanges[l].EndOffset);
            }
        }
        /// <summary>
        /// Constructs a web request to write or clear a range of pages in a page blob.
        /// </summary>
        /// <param name="uri">The absolute URI to the blob.</param>
        /// <param name="timeout">The server timeout interval.</param>
        /// <param name="pageRange">The page range, defined by an object of type <see cref="PageRange"/>.</param>
        /// <param name="pageWrite">A value of type <see cref="PageWrite"/>, indicating the operation to perform on the page blob.</param>
        /// <param name="accessCondition">The <see cref="AccessCondition"/> to apply to the request.</param>
        /// <param name="operationContext">An <see cref="OperationContext" /> object for tracking the current operation.</param>
        /// <returns>
        /// A web request to use to perform the operation.
        /// </returns>
        public static HttpWebRequest PutPage(Uri uri, int? timeout, PageRange pageRange, PageWrite pageWrite,  AccessCondition accessCondition, OperationContext operationContext)
        {
            UriQueryBuilder builder = new UriQueryBuilder();
            builder.Add(Constants.QueryConstants.Component, "page");

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, operationContext);
            request.ContentLength = 0;
            
            request.AddOptionalHeader(Constants.HeaderConstants.RangeHeader, pageRange.ToString());
            request.Headers.Add(Constants.HeaderConstants.PageWrite, pageWrite.ToString());
            
            request.ApplyAccessCondition(accessCondition);
            return request;
        }
 public static void ContentRangeHeader(HttpWebResponse response, PageRange expectedValue)
 {
     Assert.IsNotNull(response);
     Assert.IsNotNull(response.Headers[HttpResponseHeader.ContentRange]);
     Assert.AreEqual(expectedValue.ToString(), response.Headers[HttpResponseHeader.ContentRange]);
 }
        /// <summary>
        /// Constructs a web request to write or clear a range of pages in a page blob.
        /// </summary>
        /// <param name="uri">The absolute URI to the blob.</param>
        /// <param name="timeout">The server timeout interval.</param>
        /// <param name="properties">The blob's properties.</param>
        /// <param name="accessCondition">The access condition to apply to the request.</param>
        /// <returns>A web request to use to perform the operation.</returns>
        public static HttpRequestMessage PutPage(Uri uri, int? timeout, PageRange pageRange, PageWrite pageWrite, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
        {
            UriQueryBuilder builder = new UriQueryBuilder();
            builder.Add(Constants.QueryConstants.Component, "page");

            HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext);

            request.Headers.Add(Constants.HeaderConstants.RangeHeader, pageRange.ToString());
            request.Headers.Add(Constants.HeaderConstants.PageWrite, pageWrite.ToString());

            request.ApplyAccessCondition(accessCondition);
            request.ApplySequenceNumberCondition(accessCondition);
            return request;
        }
        /// <summary>
        /// Constructs a web request to write or clear a range of pages in a page blob.
        /// </summary>
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="pageRange">A <see cref="PageRange"/> object.</param>
        /// <param name="pageWrite">A <see cref="PageWrite"/> enumeration value indicating the operation to perform on the page blob.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the <i>x-ms-version</i> HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>
        /// A web request to use to perform the operation.
        /// </returns>
        public static HttpWebRequest PutPage(Uri uri, int? timeout, PageRange pageRange, PageWrite pageWrite, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            CommonUtility.AssertNotNull("pageRange", pageRange);

            UriQueryBuilder builder = new UriQueryBuilder();
            builder.Add(Constants.QueryConstants.Component, "page");

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext);

            request.Headers.Add(Constants.HeaderConstants.RangeHeader, pageRange.ToString());
            request.Headers.Add(Constants.HeaderConstants.PageWrite, pageWrite.ToString());

            request.ApplyAccessCondition(accessCondition);
            request.ApplySequenceNumberCondition(accessCondition);
            return request;
        }
 /// <summary>
 /// Constructs a web request to write or clear a range of pages in a page blob.
 /// </summary>
 /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
 /// <param name="timeout">An integer specifying the server timeout interval.</param>
 /// <param name="pageRange">A <see cref="PageRange"/> object.</param>
 /// <param name="pageWrite">A <see cref="PageWrite"/> enumeration value indicating the operation to perform on the page blob.</param>
 /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
 /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
 /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
 public static HttpWebRequest PutPage(Uri uri, int? timeout, PageRange pageRange, PageWrite pageWrite, AccessCondition accessCondition, OperationContext operationContext)
 {
     return BlobHttpWebRequestFactory.PutPage(uri, timeout, pageRange, pageWrite, accessCondition, true /* useVersionHeader */, operationContext);
 }