Beispiel #1
0
        private ParagraphProperties GetListProperties(int id)
        {
            var paragraphProperties = new ParagraphProperties();
            var paragraphStyleId    = new ParagraphStyleId()
            {
                Val = "ListParagraph"
            };
            var numbering = new NumberingProperties(
                new NumberingLevelReference()
            {
                Val = 0
            },
                new NumberingId()
            {
                Val = id
            });
            var spacing = new SpacingBetweenLines()
            {
                After  = "0",
                Before = "0"
            };

            paragraphProperties.AppendChild(numbering);
            paragraphProperties.AppendChild(spacing);
            paragraphProperties.AppendChild(paragraphStyleId);
            return(paragraphProperties);
        }
Beispiel #2
0
 CreateParagraphProperties(WordParagraphProperties paragraphProperties)
 {
     if (paragraphProperties != null)
     {
         ParagraphProperties properties = new ParagraphProperties();
         properties.AppendChild(new Justification()
         {
             Val = paragraphProperties.JustificationValues
         });
         properties.AppendChild(new SpacingBetweenLines
         {
             LineRule = LineSpacingRuleValues.Auto
         });
         properties.AppendChild(new Indentation());
         ParagraphMarkRunProperties paragraphMarkRunProperties = new ParagraphMarkRunProperties();
         if (!string.IsNullOrEmpty(paragraphProperties.Size))
         {
             paragraphMarkRunProperties.AppendChild(new FontSize
             {
                 Val = paragraphProperties.Size
             });
         }
         if (paragraphProperties.Bold)
         {
             paragraphMarkRunProperties.AppendChild(new Bold());
         }
         properties.AppendChild(paragraphMarkRunProperties);
         return(properties);
     }
     return(null);
 }
Beispiel #3
0
        private static TableCell SetupCell(HetOwner owner, double widthInCm, double start)
        {
            try
            {
                var tableCell = new TableCell();

                var tableCellProperties = new TableCellProperties();
                tableCellProperties.AppendChild(new TableCellWidth {
                    Width = CentimeterToDxa(widthInCm).ToString(), Type = TableWidthUnitValues.Dxa
                });
                tableCellProperties.AppendChild(new TableCellVerticalAlignment()
                {
                    Val = TableVerticalAlignmentValues.Center
                });
                tableCell.AppendChild(tableCellProperties);

                var paragraphProperties = new ParagraphProperties();

                var paragraphMarkRunProperties = new ParagraphMarkRunProperties();
                paragraphMarkRunProperties.AppendChild(new Color {
                    Val = "000000"
                });
                paragraphMarkRunProperties.AppendChild(new RunFonts {
                    Ascii = "Arial"
                });
                paragraphMarkRunProperties.AppendChild(new FontSize()
                {
                    Val = "13pt"
                });
                paragraphProperties.AppendChild(paragraphMarkRunProperties);

                paragraphProperties.AppendChild(new Justification {
                    Val = JustificationValues.Left
                });
                paragraphProperties.AppendChild(new Indentation {
                    Start = CentimeterToDxa(start).ToString()
                });

                var paragraph = new Paragraph();
                paragraph.AppendChild(paragraphProperties);

                if (owner != null)
                {
                    PopulateParagraph(owner, paragraph);
                }

                tableCell.AppendChild(paragraph);

                return(tableCell);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
Beispiel #4
0
 public void Transform(string firstName, string lastName, string city)
 {
     using (WordprocessingDocument wordprocessingDocument =
                WordprocessingDocument.Open(LastConvertedWordFileName ?? LastWordFileName, true))
     {
         Body body           = wordprocessingDocument.MainDocumentPart.Document.Body;
         var  firstParagraph = body.ChildElements.FirstOrDefault(c => c is Paragraph);
         if (firstParagraph != null)
         {
             AddPersonalRow(body, firstParagraph, firstName, lastName, city);
         }
         ApplyColorsFormat(body);
         Paragraph           breakParagraph    = new Paragraph();
         ParagraphProperties breakProperties   = new ParagraphProperties();
         SectionProperties   sectionProperties = new SectionProperties();
         SectionType         sectionType       = new SectionType()
         {
             Val = SectionMarkValues.NextPage
         };
         sectionProperties.AppendChild(sectionType);
         breakProperties.AppendChild(sectionProperties);
         breakParagraph.AppendChild(breakProperties);
         body.AppendChild(breakParagraph);
         AddSecondPageTable(body);
     }
 }
        /// <summary>
        /// Pushes a new paragraph onto the <see cref="OpenXmlCompositeElement"/> stack,
        /// applying the paragraph styles elements that are currently on the paragraph format stack.
        /// If a matching paragraph style could not be found in the OpenXML document, an empty style is created.
        /// This leaves the user the chance to modify the paragraph style afterwards in the document.
        /// </summary>
        /// <returns>The newly created paragraph, with the paragraph style already appended.</returns>
        public Paragraph PushNewParagraph()
        {
            var paragraph = new Paragraph();

            if (_currentParagraphFormatStack.Count == 0)
            {
                // there is no need to add paragraph properties here, because the "Normal" style is assumed in this case
            }
            else
            {
                var paragraphStyleId    = GetOrCreateNewParagraphStyleRecursivelyFromParagraphStack();
                var paragraphProperties = new ParagraphProperties {
                    ParagraphStyleId = new ParagraphStyleId()
                    {
                        Val = paragraphStyleId
                    }
                };
                if (null != NumberingProperties)
                {
                    paragraphProperties.AppendChild(NumberingProperties);
                    NumberingProperties = null;
                }
                paragraph.AppendChild(paragraphProperties);
            }
            Push(paragraph);
            return(paragraph);
        }
Beispiel #6
0
        private static TableCell CreateCell(string text, bool?isThead = false)
        {
            var cell      = new TableCell();
            var paragraph = new Paragraph(new Run(new Text(text)));
            ParagraphProperties paragraphProperties = new ParagraphProperties();
            TableCellProperties cellProperties      = new TableCellProperties();

            cellProperties.AppendChild(new TableCellVerticalAlignment()
            {
                Val = TableVerticalAlignmentValues.Center
            });
            cellProperties.AppendChild(new Justification()
            {
                Val = JustificationValues.Center
            });

            TableCellWidth cellWidth = new TableCellWidth()
            {
                Type = TableWidthUnitValues.Auto
            };

            if (isThead.HasValue && isThead.Value)
            {
                paragraphProperties.AppendChild(new Justification()
                {
                    Val = JustificationValues.Center
                });
            }
            else
            {
                paragraphProperties.AppendChild(new Justification()
                {
                    Val = JustificationValues.Left
                });
            }
            paragraphProperties.AppendChild(new TextAlignment()
            {
                Val = VerticalTextAlignmentValues.Center
            });
            cell.AppendChild(cellWidth);
            cell.AppendChild(cellProperties);
            cell.AppendChild(paragraphProperties);
            cell.AppendChild(paragraph);
            return(cell);
        }
Beispiel #7
0
        private static ParagraphProperties GetJustifiedParagraphProperties(string heading)
        {
            var paragraphProperties = new ParagraphProperties();

            if (heading != null)
            {
                var paragraphStyleId = new ParagraphStyleId()
                {
                    Val = heading
                };
                paragraphProperties.AppendChild(paragraphStyleId);
            }

            var justification = new Justification {
                Val = JustificationValues.Left
            };

            paragraphProperties.AppendChild(justification);

            return(paragraphProperties);
        }
Beispiel #8
0
        /// <summary>
        /// Add a style based on the given style name.
        /// </summary>
        /// <param name="style">The name of the style.</param>
        /// <returns></returns>
        protected virtual ParagraphProperties ooxmlParagraphProp(string style)
        {
            var paraProp = new ParagraphProperties();
            var styleId  = new ParagraphStyleId
            {
                Val = string.Format(CultureInfo.CurrentCulture, style)
            };

            paraProp.AppendChild(styleId);

            return(paraProp);
        }
Beispiel #9
0
        /// <summary>
        /// Add a style based on the given paragraph level.
        /// </summary>
        /// <param name="paragraphLevel">The level of the paragraph.</param>
        /// <returns></returns>
        protected virtual ParagraphProperties ooxmlParagraphProp(int paragraphLevel)
        {
            var paraProp = new ParagraphProperties();
            var styleId  = new ParagraphStyleId
            {
                Val = string.Format(CultureInfo.CurrentCulture, "normal{0}", paragraphLevel == 0 ? string.Empty : paragraphLevel.ToString(CultureInfo.CurrentCulture))
            };

            paraProp.AppendChild(styleId);

            return(paraProp);
        }
        public void RemoveChildExceptionTest()
        {
            Assert.Throws <System.InvalidOperationException>(() =>
            {
                Paragraph p             = new Paragraph();
                ParagraphProperties ppr = p.AppendChild(new ParagraphProperties());
                var autoSpace           = ppr.AppendChild(new AutoSpaceDE());
                autoSpace.Val           = true;

                p.RemoveChild(autoSpace);
            });
        }
Beispiel #11
0
        /// <summary>
        /// Add a style based on the given paragraph level.
        /// </summary>
        /// <param name="paragraphLevel">The level of the paragraph.</param>
        /// <returns></returns>
        protected override ParagraphProperties ooxmlParagraphProp(int paragraphLevel)
        {
            var paraProp = new ParagraphProperties();
            var styleId  = new ParagraphStyleId
            {
                Val = string.Format(CultureInfo.CurrentCulture, "Heading{0}", paragraphLevel == 0 ? "1" : paragraphLevel.ToString(CultureInfo.CurrentCulture))
            };

            paraProp.AppendChild(styleId);

            return(paraProp);
        }
Beispiel #12
0
        public static ParagraphProperties GetParagraphProperties(ResumeParagraph resumeParagraph, IEnumerable <OpenXmlElement> insertBefore = null)
        {
            var pargraphProperties = new ParagraphProperties();

            if (insertBefore != null)
            {
                pargraphProperties.Append(insertBefore);
            }

            pargraphProperties.AppendChild(GetJustification(resumeParagraph.HorisontalAlignment));

            return(pargraphProperties);
        }
        public static void Render(this Page page, Models.Document document, OpenXmlElement wdDoc, ContextModel context, MainDocumentPart mainDocumentPart, IFormatProvider formatProvider)
        {
            if (!string.IsNullOrWhiteSpace(page.ShowKey) && context.ExistItem <BooleanModel>(page.ShowKey) && !context.GetItem <BooleanModel>(page.ShowKey).Value)
            {
                return;
            }

            // add page content
            ((BaseElement)page).Render(document, wdDoc, context, mainDocumentPart, formatProvider);

            // add section to manage orientation. Last section is at the end of document
            var pageSize = new PageSize()
            {
                Orient = page.PageOrientation.ToOOxml(),
                Width  = UInt32Value.FromUInt32(page.PageOrientation == PageOrientationValues.Landscape ? (uint)16839 : 11907),
                Height = UInt32Value.FromUInt32(page.PageOrientation == PageOrientationValues.Landscape ? (uint)11907 : 16839)
            };
            var sectionProps = new SectionProperties(pageSize);

            // document margins
            if (page.Margin != null)
            {
                var pageMargins = new PageMargin()
                {
                    Left   = page.Margin.Left,
                    Top    = page.Margin.Top,
                    Right  = page.Margin.Right,
                    Bottom = page.Margin.Bottom,
                    Footer = page.Margin.Footer,
                    Header = page.Margin.Header
                };
                sectionProps.AppendChild(pageMargins);
            }
            var p   = new DocumentFormat.OpenXml.Wordprocessing.Paragraph();
            var ppr = new ParagraphProperties();

            p.AppendChild(ppr);
            ppr.AppendChild(sectionProps);
            wdDoc.AppendChild(p);
        }
        public static OpenXmlElement Convert(Paragraph paragraph,
                                             WordprocessingDocument document,
                                             int?defaultFontSize = null)
        {
            var docxParagraph = new DocumentFormat.OpenXml.Wordprocessing.Paragraph();
            var parameters    = paragraph.Parameters;

            var paragraphProperties = new ParagraphProperties();

            if (parameters.Alignment.HasValue)
            {
                paragraphProperties.Justification = new Justification {
                    Val = GetJustificationValues(parameters.Alignment.Value)
                }
            }
            ;

            if (parameters.SpaceBetweenLines.HasValue)
            {
                paragraphProperties.SpacingBetweenLines = new SpacingBetweenLines
                {
                    LineRule = LineSpacingRuleValues.Auto,
                    Line     = (240 * parameters.SpaceBetweenLines.Value).ToString()
                }
            }
            ;

            var runProperties = new RunProperties();

            if (parameters.Bold)
            {
                runProperties.Bold = new Bold();
            }

            var fontSize = parameters.FontSize ?? defaultFontSize;

            if (fontSize.HasValue)
            {
                var rPr = new ParagraphMarkRunProperties(new FontSize {
                    Val = (fontSize.Value * 2).ToString()
                },
                                                         new FontSizeComplexScript {
                    Val = (fontSize.Value * 2).ToString()
                });
                paragraphProperties.AppendChild(rPr);
                runProperties.FontSize = new FontSize {
                    Val = (fontSize.Value * 2).ToString()
                };
                runProperties.FontSizeComplexScript = new FontSizeComplexScript {
                    Val = (fontSize.Value * 2).ToString()
                };
            }

            var defaultFont = FontFamily.GenericSansSerif.Name;

            runProperties.RunFonts = new RunFonts
            {
                Ascii         = defaultFont,
                ComplexScript = defaultFont,
                HighAnsi      = defaultFont
            };

            if (parameters.BackgroundColor.HasValue)
            {
                runProperties.Shading = new Shading
                {
                    Val   = ShadingPatternValues.Clear,
                    Color = "auto",
                    Fill  = parameters.BackgroundColor.Value.ToHex()
                }
            }
            ;

            foreach (var run in parameters.Parts.Select(x => GetRun(document, x, runProperties)))
            {
                docxParagraph.AppendChild(run);
            }
            docxParagraph.ParagraphProperties = paragraphProperties;
            return(docxParagraph);
        }
        private void ValidatePpr(SdbSchemaDatas sdbSchemaDatas)
        {
            ValidationContext validationContext = new ValidationContext();
            OpenXmlElement    errorChild;

            ParagraphProperties pPr = new ParagraphProperties();
            var particleConstraint  = sdbSchemaDatas.GetSchemaTypeData(pPr).ParticleConstraint;
            var target = particleConstraint.ParticleValidator as ParticleValidator;

            validationContext.Element = pPr;
            var expected = pPr;

            //<xsd:complexType name="CT_PPr">
            //  <xsd:complexContent>
            //    <xsd:extension base="CT_PPrBase">
            //      <xsd:sequence>
            //        <xsd:element name="rPr" type="CT_ParaRPr" minOccurs="0">
            //        <xsd:element name="sectPr" type="CT_SectPr" minOccurs="0">
            //        <xsd:element name="pPrChange" type="CT_PPrChange" minOccurs="0">
            //      </xsd:sequence>
            //    </xsd:extension>
            //  </xsd:complexContent>
            //</xsd:complexType>

            //<xsd:complexType name="CT_PPrBase">
            //  <xsd:sequence>
            //    <xsd:element name="pStyle" type="CT_String" minOccurs="0">
            //    <xsd:element name="keepNext" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="keepLines" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="pageBreakBefore" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="framePr" type="CT_FramePr" minOccurs="0">
            //    <xsd:element name="widowControl" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="numPr" type="CT_NumPr" minOccurs="0">
            //    <xsd:element name="suppressLineNumbers" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="pBdr" type="CT_PBdr" minOccurs="0">
            //    <xsd:element name="shd" type="CT_Shd" minOccurs="0">
            //    <xsd:element name="tabs" type="CT_Tabs" minOccurs="0">
            //    <xsd:element name="suppressAutoHyphens" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="kinsoku" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="wordWrap" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="overflowPunct" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="topLinePunct" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="autoSpaceDE" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="autoSpaceDN" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="bidi" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="adjustRightInd" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="snapToGrid" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="spacing" type="CT_Spacing" minOccurs="0">
            //    <xsd:element name="ind" type="CT_Ind" minOccurs="0">
            //    <xsd:element name="contextualSpacing" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="mirrorIndents" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="suppressOverlap" type="CT_OnOff" minOccurs="0">
            //    <xsd:element name="jc" type="CT_Jc" minOccurs="0">
            //    <xsd:element name="textDirection" type="CT_TextDirection" minOccurs="0">
            //    <xsd:element name="textAlignment" type="CT_TextAlignment" minOccurs="0">
            //    <xsd:element name="textboxTightWrap" type="CT_TextboxTightWrap" minOccurs="0">
            //    <xsd:element name="outlineLvl" type="CT_DecimalNumber" minOccurs="0">
            //    <xsd:element name="divId" type="CT_DecimalNumber" minOccurs="0">
            //    <xsd:element name="cnfStyle" type="CT_Cnf" minOccurs="0" maxOccurs="1">
            //  </xsd:sequence>
            //</xsd:complexType>

            // ***** good case ******

            // empty is ok
            target.Validate(validationContext);
            Assert.True(validationContext.Valid);

            //
            pPr.AppendChild(new KeepLines());
            target.Validate(validationContext);
            Assert.True(validationContext.Valid);

            //
            pPr.AppendChild(new Tabs());
            target.Validate(validationContext);
            Assert.True(validationContext.Valid);

            //
            pPr.AppendChild(new Kinsoku());
            target.Validate(validationContext);
            Assert.True(validationContext.Valid);

            //
            pPr.AppendChild(new OutlineLevel());
            target.Validate(validationContext);
            Assert.True(validationContext.Valid);

            //
            pPr.AppendChild(new ConditionalFormatStyle());
            target.Validate(validationContext);
            Assert.True(validationContext.Valid);

            //
            pPr.AppendChild(new ParagraphMarkRunProperties());
            target.Validate(validationContext);
            Assert.True(validationContext.Valid);

            //
            pPr.AppendChild(new SectionProperties());
            target.Validate(validationContext);
            Assert.True(validationContext.Valid);

            //
            pPr.AppendChild(new ParagraphPropertiesChange());
            target.Validate(validationContext);
            Assert.True(validationContext.Valid);

            // ***** error case ******

            // SectionProperties dup error
            errorChild = pPr.AppendChild(new SectionProperties());
            target.Validate(validationContext);
            Assert.False(validationContext.Valid);
            Assert.Single(validationContext.Errors);
            Assert.Same(expected, validationContext.Errors[0].Node);
            Assert.Equal(ValidationErrorType.Schema, validationContext.Errors[0].ErrorType);
            Assert.Equal("Sch_UnexpectedElementContentExpectingComplex", validationContext.Errors[0].Id);
            Assert.DoesNotContain(ValidationErrorStrings.Fmt_ListOfPossibleElements, validationContext.Errors[0].Description);
            pPr.RemoveChild(errorChild);

            validationContext.Clear();
            // SectionProperties order wrong
            errorChild = pPr.FirstChild;
            pPr.PrependChild(new SectionProperties());
            target.Validate(validationContext);
            Assert.False(validationContext.Valid);
            Assert.Single(validationContext.Errors);
            Assert.Same(expected, validationContext.Errors[0].Node);
            Assert.Same(errorChild, validationContext.Errors[0].RelatedNode);
            Assert.Equal(ValidationErrorType.Schema, validationContext.Errors[0].ErrorType);
            Assert.Equal("Sch_UnexpectedElementContentExpectingComplex", validationContext.Errors[0].Id);
            Assert.DoesNotContain(ValidationErrorStrings.Fmt_ListOfPossibleElements, validationContext.Errors[0].Description);
            pPr.RemoveChild(pPr.FirstChild);
        }
Beispiel #16
0
        public TFluent SetFontSize(double fontSize)
        {
            OpenXmlElement textBody       = this.element.GetOrCreateTextBody();
            BodyProperties bodyProperties = textBody.GetFirstChild <BodyProperties>() ?? textBody.AppendChild(new BodyProperties());

            foreach (Paragraph paragraph in textBody.Elements <Paragraph>())
            {
                ParagraphProperties  paragraphProperties  = paragraph.GetFirstChild <ParagraphProperties>() ?? paragraph.PrependChild(new ParagraphProperties());
                DefaultRunProperties defaultRunProperties = paragraphProperties.GetFirstChild <DefaultRunProperties>() ?? paragraphProperties.AppendChild(new DefaultRunProperties());
                defaultRunProperties.FontSize = (int)(fontSize * 100);

                foreach (Run run in paragraph.Elements <Run>())
                {
                    RunProperties runProperties = run.GetFirstChild <RunProperties>() ?? run.PrependChild(new RunProperties());
                    runProperties.FontSize = (int)(fontSize * 100);
                }
            }

            return(this.result);
        }
Beispiel #17
0
        public TFluent SetFont(string typeface)
        {
            OpenXmlElement textBody       = this.element.GetOrCreateTextBody();
            BodyProperties bodyProperties = textBody.GetFirstChild <BodyProperties>() ?? textBody.AppendChild(new BodyProperties());

            foreach (Paragraph paragraph in textBody.Elements <Paragraph>())
            {
                ParagraphProperties  paragraphProperties  = paragraph.GetFirstChild <ParagraphProperties>() ?? paragraph.PrependChild(new ParagraphProperties());
                DefaultRunProperties defaultRunProperties = paragraphProperties.GetFirstChild <DefaultRunProperties>() ?? paragraphProperties.AppendChild(new DefaultRunProperties());
                defaultRunProperties.RemoveAllChildren <LatinFont>();
                defaultRunProperties.RemoveAllChildren <ComplexScriptFont>();

                defaultRunProperties.AppendChild(new LatinFont()
                {
                    Typeface = typeface
                });
                defaultRunProperties.AppendChild(new ComplexScriptFont()
                {
                    Typeface = typeface
                });

                foreach (Run run in paragraph.Elements <Run>())
                {
                    RunProperties runProperties = run.GetFirstChild <RunProperties>() ?? run.PrependChild(new RunProperties());
                    runProperties.RemoveAllChildren <LatinFont>();
                    runProperties.RemoveAllChildren <ComplexScriptFont>();

                    runProperties.AppendChild(new LatinFont()
                    {
                        Typeface = typeface
                    });
                    runProperties.AppendChild(new ComplexScriptFont()
                    {
                        Typeface = typeface
                    });
                }
            }

            return(this.result);
        }
Beispiel #18
0
        public TFluent SetFontColor(OpenXmlColor color)
        {
            OpenXmlElement textBody       = this.element.GetOrCreateTextBody();
            BodyProperties bodyProperties = textBody.GetFirstChild <BodyProperties>() ?? textBody.AppendChild(new BodyProperties());

            foreach (Paragraph paragraph in textBody.Elements <Paragraph>())
            {
                ParagraphProperties  paragraphProperties  = paragraph.GetFirstChild <ParagraphProperties>() ?? paragraph.PrependChild(new ParagraphProperties());
                DefaultRunProperties defaultRunProperties = paragraphProperties.GetFirstChild <DefaultRunProperties>() ?? paragraphProperties.AppendChild(new DefaultRunProperties());
                defaultRunProperties.RemoveAllChildren <NoFill>();
                defaultRunProperties.RemoveAllChildren <SolidFill>();
                defaultRunProperties.RemoveAllChildren <GradientFill>();
                defaultRunProperties.RemoveAllChildren <BlipFill>();
                defaultRunProperties.RemoveAllChildren <PatternFill>();
                defaultRunProperties.RemoveAllChildren <GroupFill>();

                defaultRunProperties.AppendChild(new SolidFill().AppendChildFluent(color.CreateColorElement()));

                foreach (Run run in paragraph.Elements <Run>())
                {
                    RunProperties runProperties = run.GetFirstChild <RunProperties>() ?? run.PrependChild(new RunProperties());
                    runProperties.RemoveAllChildren <NoFill>();
                    runProperties.RemoveAllChildren <SolidFill>();
                    runProperties.RemoveAllChildren <GradientFill>();
                    runProperties.RemoveAllChildren <BlipFill>();
                    runProperties.RemoveAllChildren <PatternFill>();
                    runProperties.RemoveAllChildren <GroupFill>();

                    runProperties.AppendChild(new SolidFill().AppendChildFluent(color.CreateColorElement()));
                }
            }

            return(this.result);
        }
Beispiel #19
0
        private static TableCell SetupCell(string text, bool center = false)
        {
            try
            {
                TableCell tableCell = new TableCell();

                TableCellProperties tableCellProperties = new TableCellProperties();

                // border & padding
                TableCellBorders borders = new TableCellBorders();

                TopBorder topBorder = new TopBorder {
                    Val = new EnumValue <BorderValues>(BorderValues.Thick), Color = "A1A2A3"
                };
                borders.AppendChild(topBorder);

                BottomBorder bottomBorder = new BottomBorder {
                    Val = new EnumValue <BorderValues>(BorderValues.Thick), Color = "A1A2A3"
                };
                borders.AppendChild(bottomBorder);

                RightBorder rightBorder = new RightBorder {
                    Val = new EnumValue <BorderValues>(BorderValues.Nil)
                };
                borders.AppendChild(rightBorder);

                LeftBorder leftBorder = new LeftBorder {
                    Val = new EnumValue <BorderValues>(BorderValues.Nil)
                };
                borders.AppendChild(leftBorder);

                TableCellMargin margin    = new TableCellMargin();
                TopMargin       topMargin = new TopMargin()
                {
                    Width = "40"
                };
                BottomMargin bottomMargin = new BottomMargin()
                {
                    Width = "40"
                };
                margin.AppendChild(topMargin);
                margin.AppendChild(bottomMargin);

                tableCellProperties.AppendChild(borders);
                tableCellProperties.AppendChild(margin);

                tableCell.AppendChild(tableCellProperties);

                // add text (with specific formatting)
                Paragraph paragraph = new Paragraph()
                {
                    RsidParagraphAddition = "00607D74", RsidRunAdditionDefault = "00607D74", ParagraphId = "6ED85602", TextId = "77777777"
                };

                ParagraphProperties        paragraphProperties        = new ParagraphProperties();
                ParagraphMarkRunProperties paragraphMarkRunProperties = new ParagraphMarkRunProperties();

                paragraphMarkRunProperties.AppendChild(new Color {
                    Val = "000000"
                });
                paragraphMarkRunProperties.AppendChild(new RunFonts {
                    Ascii = "Arial"
                });
                paragraphMarkRunProperties.AppendChild(new FontSize()
                {
                    Val = "7pt"
                });

                Justification justification = new Justification()
                {
                    Val = JustificationValues.Left
                };
                if (center)
                {
                    justification.Val = JustificationValues.Center;
                }

                paragraphProperties.AppendChild(paragraphMarkRunProperties);
                paragraphProperties.AppendChild(justification);
                paragraph.AppendChild(paragraphProperties);

                paragraph.AppendChild(new Text(text));

                // add to table cell
                tableCell.AppendChild(paragraph);

                return(tableCell);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
Beispiel #20
0
        private static TableCell SetupHeaderCell(string text, string width, bool center = false)
        {
            try
            {
                TableCell tableCell = new TableCell();

                TableCellProperties tableCellProperties = new TableCellProperties();
                TableCellWidth      tableCellWidth      = new TableCellWidth()
                {
                    Width = width, Type = TableWidthUnitValues.Dxa
                };
                Shading shading = new Shading()
                {
                    Val = ShadingPatternValues.Clear, Fill = "FFFFFF", Color = "auto"
                };

                // border & padding
                TableCellBorders borders = new TableCellBorders();

                TopBorder topBorder = new TopBorder {
                    Val = new EnumValue <BorderValues>(BorderValues.Thick), Color = "000000"
                };
                borders.AppendChild(topBorder);

                BottomBorder bottomBorder = new BottomBorder {
                    Val = new EnumValue <BorderValues>(BorderValues.Thick), Color = "000000"
                };
                borders.AppendChild(bottomBorder);

                TableCellMargin margin    = new TableCellMargin();
                TopMargin       topMargin = new TopMargin()
                {
                    Width = "40"
                };
                BottomMargin bottomMargin = new BottomMargin()
                {
                    Width = "40"
                };
                margin.AppendChild(topMargin);
                margin.AppendChild(bottomMargin);

                tableCellProperties.AppendChild(tableCellWidth);
                tableCellProperties.AppendChild(shading);
                tableCellProperties.AppendChild(borders);
                tableCellProperties.AppendChild(margin);
                tableCellProperties.AppendChild(new TableCellVerticalAlignment()
                {
                    Val = TableVerticalAlignmentValues.Center
                });

                tableCell.AppendChild(tableCellProperties);

                // add text (with specific formatting)
                Paragraph paragraph = new Paragraph()
                {
                    RsidParagraphAddition = "00607D74", RsidRunAdditionDefault = "00607D74", ParagraphId = "6ED85602", TextId = "77777777"
                };

                ParagraphProperties        paragraphProperties        = new ParagraphProperties();
                ParagraphMarkRunProperties paragraphMarkRunProperties = new ParagraphMarkRunProperties();

                paragraphMarkRunProperties.AppendChild(new Color {
                    Val = "000000"
                });
                paragraphMarkRunProperties.AppendChild(new RunFonts {
                    Ascii = "Arial"
                });
                paragraphMarkRunProperties.AppendChild(new FontSize()
                {
                    Val = "8pt"
                });
                paragraphMarkRunProperties.AppendChild(new Bold());

                Justification justification = new Justification()
                {
                    Val = JustificationValues.Left
                };
                if (center)
                {
                    justification.Val = JustificationValues.Center;
                }

                paragraphProperties.AppendChild(paragraphMarkRunProperties);
                paragraphProperties.AppendChild(justification);
                paragraph.AppendChild(paragraphProperties);

                paragraph.AppendChild(new Text(text));

                // add to table cell
                tableCell.AppendChild(paragraph);

                return(tableCell);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
Beispiel #21
0
        public TableCell ToTableCell()
        {
            TableCell tableCell = new TableCell();

            TableCellProperties tableCellProperties = new TableCellProperties();

            // Specify the width property of the table cell.
            TableCellWidth tableCellWidth = new TableCellWidth()
            {
                Width = Width.ToString(), Type = TableWidthUnitValues.Dxa
            };

            TableCellMargin tableCellMargin = new TableCellMargin();
            LeftMargin      leftMargin      = new LeftMargin()
            {
                Width = "100", Type = TableWidthUnitValues.Dxa
            };
            RightMargin rightMargin = new RightMargin()
            {
                Width = "100", Type = TableWidthUnitValues.Dxa
            };

            tableCellMargin.Append(leftMargin);
            tableCellMargin.Append(rightMargin);
            TableCellVerticalAlignment tableCellVerticalAlignment = new TableCellVerticalAlignment()
            {
                Val = TableVerticalAlignmentValues.Center
            };

            switch (TipoDeCelula)
            {
            case TipoDeCelula.HEADER:
                tableCellProperties.Append(new Shading()
                {
                    Val = ShadingPatternValues.Percent10, Color = "000000", Fill = "auto"
                });
                break;

            case TipoDeCelula.RESUME:
                tableCellProperties.Append(new Shading()
                {
                    Val = ShadingPatternValues.Percent10, Color = "000000", Fill = "auto"
                });
                break;

            default:     // TipoDeCelula.NORMAL
                break;
            }

            tableCellProperties.Append(tableCellWidth);
            tableCellProperties.Append(tableCellMargin);
            tableCellProperties.Append(tableCellVerticalAlignment);

            switch (Merge)
            {
            case TipoDeMerge.RESTART:
                tableCellProperties.Append(new HorizontalMerge()
                {
                    Val = MergedCellValues.Restart
                });
                break;

            case TipoDeMerge.CONTINUE:
                tableCellProperties.Append(new HorizontalMerge()
                {
                    Val = MergedCellValues.Continue
                });
                break;

            default:     // TipoDeMerge.NENHUM
                break;
            }

            tableCell.Append(tableCellProperties);

            Paragraph           paragraph           = new Paragraph();
            ParagraphProperties paragraphProperties = new ParagraphProperties();

            switch (Alinhamento)
            {
            case TipoDeAlinhamento.ESQUERDO:
                paragraphProperties.Append(new ParagraphStyleId()
                {
                    Val = "LeftTextTable"
                });
                paragraphProperties.AppendChild(
                    new RunProperties(new Bold()
                {
                    Val = OnOffValue.FromBoolean(true)
                }));
                break;

            case TipoDeAlinhamento.CENTRO:
                paragraphProperties.Append(new ParagraphStyleId()
                {
                    Val = "CenteredTextTable"
                });
                paragraphProperties.AppendChild(
                    new RunProperties(new Bold()
                {
                    Val = OnOffValue.FromBoolean(true)
                }));
                break;

            case TipoDeAlinhamento.DIREITO:
                paragraphProperties.Append(new ParagraphStyleId()
                {
                    Val = "RightTextTable"
                });
                paragraphProperties.AppendChild(
                    new RunProperties(new Bold()
                {
                    Val = OnOffValue.FromBoolean(true)
                }));
                break;

            default:      //TipoDeAlinhamento.NENHUM:
                paragraphProperties.Append(new ParagraphStyleId()
                {
                    Val = "NormalTextTable"
                });
                paragraphProperties.AppendChild(
                    new RunProperties(new Bold()
                {
                    Val = OnOffValue.FromBoolean(true)
                }));
                break;
            }

            paragraph.AppendChild(paragraphProperties);

            foreach (OpenXmlElement run in _runList)
            {
                switch (TipoDeCelula)
                {
                case TipoDeCelula.HEADER:
                    if (!run.Elements <RunProperties>().Any())
                    {
                        run.AppendChild(new RunProperties());
                    }
                    run.Elements <RunProperties>().First().AppendChild(new Bold()
                    {
                        Val = OnOffValue.FromBoolean(true)
                    });
                    break;

                case TipoDeCelula.RESUME:
                    if (!run.Elements <RunProperties>().Any())
                    {
                        run.AppendChild(new RunProperties());
                    }
                    run.Elements <RunProperties>().First().AppendChild(new Italic()
                    {
                        Val = OnOffValue.FromBoolean(true)
                    });
                    run.Elements <RunProperties>().First().AppendChild(new Bold()
                    {
                        Val = OnOffValue.FromBoolean(true)
                    });
                    break;
                }

                paragraph.AppendChild(run);
            }

            // Write some text in the cell.
            tableCell.Append(paragraph);

            return(tableCell);
        }
Beispiel #22
0
        /// <summary>
        /// Render a cell in a word document
        /// </summary>
        /// <param name="cell"></param>
        /// <param name="document"></param>
        /// <param name="parent"></param>
        /// <param name="context"></param>
        /// <param name="documentPart"></param>
        /// <param name="isInAlternateRow"></param>
        /// <param name="formatProvider"></param>
        /// <returns></returns>
        public static TableCell Render(this Cell cell,
                                       Models.Document document,
                                       OpenXmlElement parent,
                                       ContextModel context,
                                       OpenXmlPart documentPart,
                                       bool isInAlternateRow,
                                       IFormatProvider formatProvider)
        {
            context.ReplaceItem(cell, formatProvider);

            TableCell wordCell = new TableCell();

            TableCellProperties cellProp = new TableCellProperties();

            wordCell.AppendChild(cellProp);

            if (isInAlternateRow)
            {
                cell.ReplaceAlternateConfiguration();
            }

            cellProp.AddBorders(cell);
            cellProp.AddShading(cell);
            cellProp.AddMargin(cell);
            cellProp.AddJustifications(cell);

            if (cell.CellWidth != null)
            {
                cellProp.AppendChild(new TableCellWidth()
                {
                    Width = cell.CellWidth.Width, Type = cell.CellWidth.Type.ToOOxml()
                });
            }

            // manage cell column and row span
            if (cell.ColSpan > 1)
            {
                cellProp.AppendChild(new GridSpan()
                {
                    Val = cell.ColSpan
                });
            }
            if (cell.Fusion)
            {
                if (cell.FusionChild)
                {
                    cellProp.AppendChild(new VerticalMerge()
                    {
                        Val = MergedCellValues.Continue
                    });
                }
                else
                {
                    cellProp.AppendChild(new VerticalMerge()
                    {
                        Val = MergedCellValues.Restart
                    });
                }
            }

            if (!cell.Show)
            {
                return(wordCell);
            }

            if (cell.ChildElements.Any(x => x is Models.TemplateModel))
            {
                // Need to replace elements :
                for (int i = 0; i < cell.ChildElements.Count; i++)
                {
                    var e = cell.ChildElements[i];

                    if (e is TemplateModel)
                    {
                        var elements = (e as TemplateModel).ExtractTemplateItems(document);
                        if (i == cell.ChildElements.Count - 1)
                        {
                            cell.ChildElements.AddRange(elements);
                        }
                        else
                        {
                            cell.ChildElements.InsertRange(i + 1, elements);
                        }
                    }
                }
            }

            if (cell.ChildElements.Any(x => x is Models.Paragraph) || cell.ChildElements.Any(x => x is ForEach))
            {
                foreach (var element in cell.ChildElements)
                {
                    element.InheritFromParent(cell);
                    if (element is Models.Paragraph ||
                        element is ForEach)
                    {
                        element.Render(document, wordCell, context, documentPart, formatProvider);
                    }
                    else
                    {
                        var paragraph = new DocumentFormat.OpenXml.Wordprocessing.Paragraph();
                        if (cell.Justification.HasValue)
                        {
                            var ppr = new ParagraphProperties();
                            ppr.AppendChild(new Justification()
                            {
                                Val = cell.Justification.Value.ToOOxml()
                            });
                            paragraph.AppendChild(ppr);
                        }
                        wordCell.AppendChild(paragraph);
                        var r = new Run();
                        paragraph.AppendChild(r);
                        element.Render(document, r, context, documentPart, formatProvider);
                    }
                }
            }
            else
            {
                // fill cell content (need at least an empty paragraph)
                var paragraph = new DocumentFormat.OpenXml.Wordprocessing.Paragraph();
                if (cell.Justification.HasValue)
                {
                    var ppr = new ParagraphProperties();
                    ppr.AppendChild(new Justification()
                    {
                        Val = cell.Justification.Value.ToOOxml()
                    });
                    paragraph.AppendChild(ppr);
                }
                wordCell.AppendChild(paragraph);
                var r = new Run();
                paragraph.AppendChild(r);
                foreach (var element in cell.ChildElements)
                {
                    element.InheritFromParent(cell);
                    element.Render(document, r, context, documentPart, formatProvider);
                }
            }

            return(wordCell);
        }