Merge pull request #10 from Hanzalazia131/ParagraphAttributesFeatrue

Allignment Code pushed

Author: sabir-aspose

FileFormat.Words/FileFormat.Words.IElements.cs

@@ -13,6 +13,14 @@ public interface IElement
         int ElementId { get; }
     }
 
+    public class Indentation
+    {
+        public double Left { get; set; }
+        public double Right { get; set; }
+        public double FirstLine { get; set; }
+        public double Hanging { get; set; }
+    }
+
     /// <summary>
     /// Represents a paragraph element in a Word document.
     /// </summary>
@@ -38,13 +46,48 @@ public class Paragraph : IElement
         /// </summary>
         public string Style { get; set; }
 
+        /// <summary>
+        /// Gets or Sets Alignment of the word paragraph
+        /// </summary>
+        public string Alignment { get; set; }
+
+        /// <summary>
+        /// Gets or Sets Indentation of the word paragraph
+        /// </summary>
+        public Indentation Indentation { get; set; }
+
+        /// <summary>
+        /// Gets or sets the numbering ID for the paragraph.
+        /// </summary>
+        public int? NumberingId { get; set; }
+
+        /// <summary>
+        /// Gets or sets the numbering level for the paragraph.
+        /// </summary>
+        public int? NumberingLevel { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether the paragraph has bullet points.
+        /// </summary>
+        public bool IsBullet { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether the paragraph has numbering.
+        /// </summary>
+        public bool IsNumbered { get; set; }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="Paragraph"/> class.
         /// </summary>
         public Paragraph()
         {
             Runs = new List<Run>();
             Style = "Normal";
+            Indentation = new Indentation();
+            NumberingId = null;
+            NumberingLevel = null;
+            IsBullet = false;
+            IsNumbered = false;
             UpdateText(); // Initialize the Text property
         }
 
@@ -563,8 +606,4 @@ public ElementStyles()
         }
     }
 
-}
-
-
-
-
+}

FileFormat.Words/OpenXML.Words.cs

@@ -21,6 +21,13 @@ internal class OwDocument
         private MemoryStream _ms;
         private PKG.MainDocumentPart _mainPart;
         private readonly object _lockObject = new object();
+        public enum ParagraphAlignment
+        {
+            Left,
+            Center,
+            Right,
+            Justify
+        }
         private OwDocument()
         {
             lock (_lockObject)
@@ -130,6 +137,37 @@ internal WP.Paragraph CreateParagraph(FF.Paragraph ffP)
                         var paragraphProperties = new WP.ParagraphProperties();
                         var paragraphStyleId = new WP.ParagraphStyleId { Val = ffP.Style };
                         paragraphProperties.Append(paragraphStyleId);
+                        
+                        if (Enum.TryParse<ParagraphAlignment>(ffP.Alignment, true, out var alignmentEnum))
+                        {
+                            WP.JustificationValues justificationValue = MapAlignmentToJustification(alignmentEnum);
+                            paragraphProperties.Append(new WP.Justification { Val = justificationValue });
+                        }
+
+                        if (ffP.Indentation != null)
+                        {
+                            SetIndentation(paragraphProperties, ffP.Indentation);
+                        }
+                        
+                        if (ffP.IsNumbered)
+                        {
+                            var numberingProperties = new WP.NumberingProperties
+                            {
+                                NumberingId = new WP.NumberingId { Val = ffP.NumberingId },
+                                NumberingLevelReference = new WP.NumberingLevelReference { Val = ffP.NumberingLevel.Value }
+                            };
+                            paragraphProperties.Append(numberingProperties);
+                        }
+
+                        if (ffP.IsBullet)
+                        {
+                            var bulletProperties = new WP.NumberingProperties
+                            {
+                                NumberingId = new WP.NumberingId { Val = 1 },
+                                NumberingLevelReference = new WP.NumberingLevelReference { Val = 0 }
+                            };
+                            paragraphProperties.Append(bulletProperties);
+                        }
                         wpParagraph.Append(paragraphProperties);
                     }
 
@@ -194,6 +232,50 @@ internal WP.Paragraph CreateParagraph(FF.Paragraph ffP)
             }
         }
 
+        private void SetIndentation(WP.ParagraphProperties paragraphProperties, FF.Indentation ffIndentation)
+        {
+            var indentation = new WP.Indentation();
+
+            if (ffIndentation.Left > 0)
+            {
+                indentation.Left = (ffIndentation.Left * 1440).ToString();
+            }
+
+            if (ffIndentation.Right > 0)
+            {
+                indentation.Right = (ffIndentation.Right * 1440).ToString();
+            }
+
+            if (ffIndentation.FirstLine > 0)
+            {
+                indentation.FirstLine = (ffIndentation.FirstLine * 1440).ToString();
+            }
+
+            if (ffIndentation.Hanging > 0)
+            {
+                indentation.Hanging = (ffIndentation.Hanging * 1440).ToString();
+            }
+
+            paragraphProperties.Append(indentation);
+        }
+
+        private WP.JustificationValues MapAlignmentToJustification(ParagraphAlignment alignment)
+        {
+            switch (alignment)
+            {
+                case ParagraphAlignment.Left:
+                    return WP.JustificationValues.Left;
+                case ParagraphAlignment.Center:
+                    return WP.JustificationValues.Center;
+                case ParagraphAlignment.Right:
+                    return WP.JustificationValues.Right;
+                case ParagraphAlignment.Justify:
+                    return WP.JustificationValues.Both;
+                default:
+                    return WP.JustificationValues.Left;
+            }
+        }
+
         internal WP.Table CreateTable(FF.Table ffTable)
         {
             lock (_lockObject)
@@ -458,7 +540,41 @@ internal FF.Paragraph LoadParagraph(WP.Paragraph wpPara, int id)
                         if (paraStyleId != null)
                         {
                             if (paraStyleId.Val != null) ffP.Style = paraStyleId.Val.Value;
+
+                            if (IsBulletStyle(paraStyleId.Val.Value))
+                            {
+                                ffP.IsBullet = true;
+                            }
                         }
+                        var numberingProperties = paraProps.Elements<WP.NumberingProperties>().FirstOrDefault();
+                        if (numberingProperties != null)
+                        {
+                            ffP.IsNumbered = true;
+                            ffP.NumberingId = numberingProperties.NumberingId?.Val ?? 0;
+                            ffP.NumberingLevel = numberingProperties.NumberingLevelReference?.Val ?? 0;
+                        }
+                    }
+                    var justificationElement = paraProps.Elements<WP.Justification>().FirstOrDefault();
+                    if (justificationElement != null)
+                    {
+                        ffP.Alignment = MapJustificationToAlignment(justificationElement.Val);
+                    }
+                    var Indentation = paraProps.Elements<WP.Indentation>().FirstOrDefault();
+                    if (Indentation.Left != null)
+                    {
+                        ffP.Indentation.Left = int.Parse(Indentation.Left);                        
+                    }
+                    if (Indentation.Right != null)
+                    {
+                        ffP.Indentation.Right = int.Parse(Indentation.Right);
+                    }
+                    if (Indentation.Hanging != null)
+                    {
+                        ffP.Indentation.Hanging = int.Parse(Indentation.Hanging);
+                    }
+                    if (Indentation.FirstLine != null)
+                    {                        
+                        ffP.Indentation.FirstLine = int.Parse(Indentation.FirstLine);
                     }
 
                     var runs = wpPara.Elements<WP.Run>();
@@ -473,7 +589,7 @@ internal FF.Paragraph LoadParagraph(WP.Paragraph wpPara, int id)
                         {
                             Text = wpR.InnerText,
                             FontFamily = wpR.RunProperties?.RunFonts?.Ascii ?? null,
-                            FontSize = fontSize ?? 0, //int.Parse(wpR.RunProperties?.FontSize?.Val ?? null),
+                            FontSize = fontSize ?? 0,
                             Color = wpR.RunProperties?.Color?.Val ?? null,
                             Bold = (wpR.RunProperties != null && wpR.RunProperties.Bold != null),
                             Italic = (wpR.RunProperties != null && wpR.RunProperties.Italic != null),
@@ -492,6 +608,28 @@ internal FF.Paragraph LoadParagraph(WP.Paragraph wpPara, int id)
             }
         }
 
+        private bool IsBulletStyle(string styleId)
+        {            
+            return styleId == "BulletStyle";
+        }
+
+        private string MapJustificationToAlignment(WP.JustificationValues justificationValue)
+        {
+            switch (justificationValue)
+            {
+                case WP.JustificationValues.Left:
+                    return "Left";
+                case WP.JustificationValues.Center:
+                    return "Center";
+                case WP.JustificationValues.Right:
+                    return "Right";
+                case WP.JustificationValues.Both:
+                    return "Justify";
+                default:
+                    return "Left";
+            }
+        }
+
         internal FF.Image LoadImage(WP.Drawing drawing, int sequence)
         {
             lock (_lockObject)