Example #1
0
        public void TestSetGetScale()
        {
            CT_Worksheet worksheet = new CT_Worksheet();
            CT_PageSetup pSetup    = worksheet.AddNewPageSetup();

            pSetup.scale = (uint)9;
            XSSFPrintSetup printSetup = new XSSFPrintSetup(worksheet);

            Assert.AreEqual(9, printSetup.Scale);

            printSetup.Scale = ((short)100);
            Assert.AreEqual((uint)100, pSetup.scale);
        }
Example #2
0
        public void TestSetGetLeftToRight()
        {
            CT_Worksheet worksheet = new CT_Worksheet();
            CT_PageSetup pSetup    = worksheet.AddNewPageSetup();

            pSetup.pageOrder = (ST_PageOrder.downThenOver);
            XSSFPrintSetup printSetup = new XSSFPrintSetup(worksheet);

            Assert.AreEqual(false, printSetup.LeftToRight);

            printSetup.LeftToRight = (true);
            Assert.AreEqual(PageOrder.OVER_THEN_DOWN.Value, (int)pSetup.pageOrder);
        }
Example #3
0
        public void TestSetGetPageStart()
        {
            CT_Worksheet worksheet = new CT_Worksheet();
            CT_PageSetup pSetup    = worksheet.AddNewPageSetup();

            pSetup.firstPageNumber = 9;
            XSSFPrintSetup printSetup = new XSSFPrintSetup(worksheet);

            Assert.AreEqual(9, printSetup.PageStart);

            printSetup.PageStart = ((short)1);
            Assert.AreEqual((uint)1, pSetup.firstPageNumber);
        }
Example #4
0
        public void TestSetGetCopies()
        {
            CT_Worksheet worksheet = new CT_Worksheet();
            CT_PageSetup pSetup    = worksheet.AddNewPageSetup();

            pSetup.copies = (9);
            XSSFPrintSetup printSetup = new XSSFPrintSetup(worksheet);

            Assert.AreEqual(9, printSetup.Copies);

            printSetup.Copies = (short)15;
            Assert.AreEqual((uint)15, pSetup.copies);
        }
Example #5
0
        public void TestSetGetValidSettings()
        {
            CT_Worksheet worksheet = new CT_Worksheet();
            CT_PageSetup pSetup    = worksheet.AddNewPageSetup();

            pSetup.usePrinterDefaults = (false);
            XSSFPrintSetup printSetup = new XSSFPrintSetup(worksheet);

            Assert.AreEqual(false, printSetup.ValidSettings);

            printSetup.ValidSettings = (true);
            Assert.AreEqual(true, pSetup.usePrinterDefaults);
        }
Example #6
0
        public void TestSetGetUsePage()
        {
            CT_Worksheet worksheet = new CT_Worksheet();
            CT_PageSetup pSetup    = worksheet.AddNewPageSetup();

            pSetup.useFirstPageNumber = (false);
            XSSFPrintSetup printSetup = new XSSFPrintSetup(worksheet);

            Assert.AreEqual(false, printSetup.UsePage);

            printSetup.UsePage = (true);
            Assert.AreEqual(true, pSetup.useFirstPageNumber);
        }
Example #7
0
        public void TestSetGetNotes()
        {
            CT_Worksheet worksheet = new CT_Worksheet();
            CT_PageSetup pSetup    = worksheet.AddNewPageSetup();

            pSetup.cellComments = ST_CellComments.none;
            XSSFPrintSetup printSetup = new XSSFPrintSetup(worksheet);

            Assert.AreEqual(false, printSetup.Notes);

            printSetup.Notes = true;
            Assert.AreEqual(PrintCellComments.AS_DISPLAYED.Value, (int)pSetup.cellComments);
        }
Example #8
0
        public void TestSetGetDraft()
        {
            CT_Worksheet worksheet = new CT_Worksheet();
            CT_PageSetup pSetup    = worksheet.AddNewPageSetup();

            pSetup.draft = (false);
            XSSFPrintSetup printSetup = new XSSFPrintSetup(worksheet);

            Assert.AreEqual(false, printSetup.Draft);

            printSetup.Draft = (true);
            Assert.AreEqual(true, pSetup.draft);
        }
Example #9
0
        public void TestSetGetNoColor()
        {
            CT_Worksheet worksheet = new CT_Worksheet();
            CT_PageSetup pSetup    = worksheet.AddNewPageSetup();

            pSetup.blackAndWhite = (false);
            XSSFPrintSetup printSetup = new XSSFPrintSetup(worksheet);

            Assert.AreEqual(false, printSetup.NoColor);

            printSetup.NoColor = true;
            Assert.AreEqual(true, pSetup.blackAndWhite);
        }
Example #10
0
 public XSSFPrintSetup(CT_Worksheet worksheet)
 {
     this.ctWorksheet = worksheet;
     this.pageSetup   = !this.ctWorksheet.IsSetPageSetup() ? this.ctWorksheet.AddNewPageSetup() : this.ctWorksheet.pageSetup;
     if (this.ctWorksheet.IsSetPageMargins())
     {
         this.pageMargins = this.ctWorksheet.pageMargins;
     }
     else
     {
         this.pageMargins = this.ctWorksheet.AddNewPageMargins();
     }
 }
Example #11
0
        public void TestSetGetPaperSize()
        {
            CT_Worksheet worksheet = new CT_Worksheet();
            CT_PageSetup pSetup    = worksheet.AddNewPageSetup();

            pSetup.paperSize = (9);
            XSSFPrintSetup printSetup = new XSSFPrintSetup(worksheet);

            Assert.AreEqual(PaperSize.A4, printSetup.GetPaperSizeEnum());
            Assert.AreEqual(9, printSetup.PaperSize);

            printSetup.SetPaperSize(PaperSize.A3);
            Assert.AreEqual((uint)8, pSetup.paperSize);
        }
Example #12
0
        public void TestSetGetFitWidthHeight()
        {
            CT_Worksheet worksheet = new CT_Worksheet();
            CT_PageSetup pSetup    = worksheet.AddNewPageSetup();

            pSetup.fitToWidth  = (50);
            pSetup.fitToHeight = (99);
            XSSFPrintSetup printSetup = new XSSFPrintSetup(worksheet);

            Assert.AreEqual(50, printSetup.FitWidth);
            Assert.AreEqual(99, printSetup.FitHeight);

            printSetup.FitWidth  = ((short)66);
            printSetup.FitHeight = ((short)80);
            Assert.AreEqual((uint)66, pSetup.fitToWidth);
            Assert.AreEqual((uint)80, pSetup.fitToHeight);
        }
Example #13
0
        public void TestSetGetHVResolution()
        {
            CT_Worksheet worksheet = new CT_Worksheet();
            CT_PageSetup pSetup    = worksheet.AddNewPageSetup();

            pSetup.horizontalDpi = (120);
            pSetup.verticalDpi   = (100);
            XSSFPrintSetup printSetup = new XSSFPrintSetup(worksheet);

            Assert.AreEqual(120, printSetup.HResolution);
            Assert.AreEqual(100, printSetup.VResolution);

            printSetup.HResolution = ((short)150);
            printSetup.VResolution = ((short)130);
            Assert.AreEqual((uint)150, pSetup.horizontalDpi);
            Assert.AreEqual((uint)130, pSetup.verticalDpi);
        }
Example #14
0
        public void TestSetGetOrientation()
        {
            CT_Worksheet worksheet = new CT_Worksheet();
            CT_PageSetup pSetup    = worksheet.AddNewPageSetup();

            pSetup.orientation = (ST_Orientation.portrait);
            XSSFPrintSetup printSetup = new XSSFPrintSetup(worksheet);

            Assert.AreEqual(PrintOrientation.PORTRAIT, printSetup.Orientation);
            Assert.AreEqual(false, printSetup.Landscape);
            Assert.AreEqual(false, printSetup.NoOrientation);

            printSetup.Orientation = (PrintOrientation.LANDSCAPE);
            Assert.AreEqual((int)pSetup.orientation, printSetup.Orientation.Value);
            Assert.AreEqual(true, printSetup.Landscape);
            Assert.AreEqual(false, printSetup.NoOrientation);
        }
Example #15
0
 public void WritePageSetup(CT_PageSetup setup)
 {
     this.WriteStandaloneTag(setup, StreamSheetSection.PageSetup, CT_Worksheet.PageSetupElementName);
 }
Example #16
0
 public CT_PageSetup AddNewPageSetup()
 {
     this.pageSetupField = new CT_PageSetup();
     return(this.pageSetupField);
 }
Example #17
0
        public static CT_Worksheet Parse(XmlNode node, XmlNamespaceManager namespaceManager)
        {
            if (node == null)
            {
                return(null);
            }
            CT_Worksheet ctObj = new CT_Worksheet();

            ctObj.cols = new List <CT_Cols>();
            ctObj.conditionalFormatting = new List <CT_ConditionalFormatting>();
            foreach (XmlNode childNode in node.ChildNodes)
            {
                if (childNode.LocalName == "sheetPr")
                {
                    ctObj.sheetPr = CT_SheetPr.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "dimension")
                {
                    ctObj.dimension = CT_SheetDimension.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "sheetViews")
                {
                    ctObj.sheetViews = CT_SheetViews.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "sheetFormatPr")
                {
                    ctObj.sheetFormatPr = CT_SheetFormatPr.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "sheetData")
                {
                    ctObj.sheetData = CT_SheetData.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "sheetCalcPr")
                {
                    ctObj.sheetCalcPr = CT_SheetCalcPr.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "sheetProtection")
                {
                    ctObj.sheetProtection = CT_SheetProtection.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "protectedRanges")
                {
                    ctObj.protectedRanges = CT_ProtectedRanges.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "scenarios")
                {
                    ctObj.scenarios = CT_Scenarios.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "autoFilter")
                {
                    ctObj.autoFilter = CT_AutoFilter.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "sortState")
                {
                    ctObj.sortState = CT_SortState.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "dataConsolidate")
                {
                    ctObj.dataConsolidate = CT_DataConsolidate.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "customSheetViews")
                {
                    ctObj.customSheetViews = CT_CustomSheetViews.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "mergeCells")
                {
                    ctObj.mergeCells = CT_MergeCells.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "phoneticPr")
                {
                    ctObj.phoneticPr = CT_PhoneticPr.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "dataValidations")
                {
                    ctObj.dataValidations = CT_DataValidations.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "hyperlinks")
                {
                    ctObj.hyperlinks = CT_Hyperlinks.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "printOptions")
                {
                    ctObj.printOptions = CT_PrintOptions.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "pageMargins")
                {
                    ctObj.pageMargins = CT_PageMargins.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "pageSetup")
                {
                    ctObj.pageSetup = CT_PageSetup.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "headerFooter")
                {
                    ctObj.headerFooter = CT_HeaderFooter.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "rowBreaks")
                {
                    ctObj.rowBreaks = CT_PageBreak.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "colBreaks")
                {
                    ctObj.colBreaks = CT_PageBreak.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "customProperties")
                {
                    ctObj.customProperties = CT_CustomProperties.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "cellWatches")
                {
                    ctObj.cellWatches = CT_CellWatches.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "ignoredErrors")
                {
                    ctObj.ignoredErrors = CT_IgnoredErrors.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "smartTags")
                {
                    ctObj.smartTags = CT_CellSmartTags.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "drawing")
                {
                    ctObj.drawing = CT_Drawing.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "legacyDrawing")
                {
                    ctObj.legacyDrawing = CT_LegacyDrawing.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "legacyDrawingHF")
                {
                    ctObj.legacyDrawingHF = CT_LegacyDrawing.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "picture")
                {
                    ctObj.picture = CT_SheetBackgroundPicture.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "oleObjects")
                {
                    ctObj.oleObjects = CT_OleObjects.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "controls")
                {
                    ctObj.controls = CT_Controls.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "webPublishItems")
                {
                    ctObj.webPublishItems = CT_WebPublishItems.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "tableParts")
                {
                    ctObj.tableParts = CT_TableParts.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "extLst")
                {
                    ctObj.extLst = CT_ExtensionList.Parse(childNode, namespaceManager);
                }
                else if (childNode.LocalName == "cols")
                {
                    ctObj.cols.Add(CT_Cols.Parse(childNode, namespaceManager));
                }
                else if (childNode.LocalName == "conditionalFormatting")
                {
                    ctObj.conditionalFormatting.Add(CT_ConditionalFormatting.Parse(childNode, namespaceManager));
                }
            }
            return(ctObj);
        }