Aspose.Slides for .NET 20.9 Release Notes

/// <summary>
/// Returns the bullet fill format of a paragraph.
/// Read-only <see cref="IFillFormatEffectiveData"/>.
/// </summary>
IFillFormatEffectiveData FillFormat { get; }

using (Presentation pres = new Presentation("SomePresentation.pptx"))
{
    // Assume that the first shape on the first slide is AutoShape with some text...
    // Output information about text paragraphs' bullets
    AutoShape autoShape = (AutoShape)pres.Slides[0].Shapes[0];
    foreach (Paragraph para in autoShape.TextFrame.Paragraphs)
    {
        IBulletFormatEffectiveData bulletFormatEffective = para.ParagraphFormat.Bullet.GetEffective();
        Console.WriteLine("Bullet type: " + bulletFormatEffective.Type);
        if (bulletFormatEffective.Type != BulletType.None)
        {
            Console.WriteLine("Bullet fill type: " + bulletFormatEffective.FillFormat.FillType);
            switch (bulletFormatEffective.FillFormat.FillType)
            {
                case FillType.Solid:
                    Console.WriteLine("Solid fill color: " + bulletFormatEffective.FillFormat.SolidFillColor);
                    break;
                case FillType.Gradient:
                    Console.WriteLine("Gradient stops count: " + bulletFormatEffective.FillFormat.GradientFormat.GradientStops.Count);
                    foreach (IGradientStopEffectiveData gradStop in bulletFormatEffective.FillFormat.GradientFormat.GradientStops)
                        Console.WriteLine(gradStop.Position + ": " + gradStop.Color);
                    break;
                case FillType.Pattern:
                    Console.WriteLine("Pattern style: " + bulletFormatEffective.FillFormat.PatternFormat.PatternStyle);
                    Console.WriteLine("Fore color: " + bulletFormatEffective.FillFormat.PatternFormat.ForeColor);
                    Console.WriteLine("Back color: " + bulletFormatEffective.FillFormat.PatternFormat.BackColor);
                    break;
            }
        }
        Console.WriteLine();
    }
}

/// <summary>
/// Gets effective bullet formatting data with the inheritance applied.
/// </summary>
IBulletFormatEffectiveData GetEffective();

using (Presentation pres = new Presentation(@"MyPresentation.pptx"))
{
    IAutoShape shape = pres.Slides[0].Shapes[0] as IAutoShape;
    IBulletFormatEffectiveData effectiveBulletFormat = shape.TextFrame.Paragraphs[0].ParagraphFormat.Bullet.GetEffective();

    Console.WriteLine("Bullet type: " + effectiveBulletFormat.Type);
    if (effectiveBulletFormat.Type == BulletType.Numbered)
    {
        Console.WriteLine("Numbered style: " + effectiveBulletFormat.NumberedBulletStyle);
        Console.WriteLine("Starting number: " + effectiveBulletFormat.NumberedBulletStartWith);
    }
}

/// <summary>
/// Represents a collection of input elements (templates) for IWebDocument.
/// </summary>
public interface IInput
{
    /// <summary>
    /// Adds a template to the collection.
    /// </summary>
    /// <param name="key">Key for the template in the collection.</param>
    /// <param name="path">Path to the template file.</param>
    void AddTemplate<TContextObject>(string key, string path);
}

/// <summary>
/// Represents a collection of input elements (templates) for IWebDocument.
/// </summary>
public interface IInput
{
    /// <summary>
    /// Adds a template to the collection.
    /// </summary>
    /// <param name="key">Key for the template in the collection.</param>
    /// <param name="path">Path to the template file.</param>
    void AddTemplate<TContextObject>(string key, string path);
}

/// <summary>
/// Represents a collection of output elements for IWebDocument.
/// </summary>
public interface IOutput
{
    /// <summary>
    /// Adds an output element for the context object.
    /// </summary>
    /// <param name="path">Output path.</param>
    /// <param name="templateKey">The key of the template used for context object transformation before output.</param>
    /// <param name="contextObject">Context object.</param>
    void Add<TContextObject>(string path, string templateKey, TContextObject contextObject);

    /// <summary>
    /// Adds an output element for the image.
    /// </summary>
    /// <param name="path">Output path.</param>
    /// <param name="image">Image to output.</param>
    void Add(string path, IPPImage image);

    /// <summary>
    /// Adds an output element for the font.
    /// </summary>
    /// <param name="path">Output path.</param>
    /// <param name="font">Font to output.</param>
    /// <param name="fontStyle">Font style.</param>
    void Add(string path, IFontData font, FontStyle fontStyle);

    /// <summary>
    /// Adds an output element for general output file.
    /// </summary>
    /// <param name="path">Output path.</param>
    /// <param name="outputFile">File to output.</param>
    void Add(string path, IOutputFile outputFile);

    /// <summary>
    /// Adds an output element for the video.
    /// </summary>
    /// <param name="path">Output path.</param>
    /// <param name="video">Video to output.</param>
    void Add(string path, IVideo video);

    /// <summary>
    /// Adds an output element for general output file binded with another object.
    /// </summary>
    /// <param name="path">Output path.</param>
    /// <param name="outputFile">File to output.</param>
    /// <param name="obj">Object binded to the file.</param>
    void Add(string path, IOutputFile outputFile, object obj);

    /// <summary>
    /// Returns the path for a given resource.
    /// </summary>
    /// <param name="obj">Resource object.</param>
    /// <returns>Resource path.</returns>
    string GetResourcePath(object obj);
}

/// <summary>
/// Represents an output saving service.
/// </summary>
public interface IOutputSaver
{
    /// <summary>
    /// Saves the output file to the given path.
    /// </summary>
    /// <param name="path">Path to save the file to.</param>
    /// <param name="outputFile">Output file.</param>
    void Save(string path, IOutputFile outputFile);
}

/// <summary>
/// Represents a temporary data storage for IWebDocument.
/// </summary>
public interface IStorage
{
    /// <summary>
    /// Puts the value into the storage.
    /// </summary>
    /// <param name="key">Key for the value.</param>
    /// <param name="value">Value.</param>
    void Put<TValue>(string key, TValue value);

    /// <summary>
    /// Gets the data from the storage.
    /// </summary>
    /// <param name="key">Key of the value.</param>
    /// <returns>Data value if it is presented in the data collection, null otherwise.</returns>
    TValue Get<TValue>(string key);
}

/// <summary>
/// Represents a template engine that transforms template and data pair into resulting output (usually HTML).
/// </summary>
public interface ITemplateEngine
{
    /// <summary>
    /// Adds the template to the template collection.
    /// </summary>
    /// <param name="key">Key for the template in the template collection.</param>
    /// <param name="template">Template content.</param>
    /// <param name="modelType">Type of a model object for the template.</param>
    void AddTemplate(string key, string template, Type modelType);

    /// <summary>
    /// Transforms the template with the given key and model object to output.
    /// </summary>
    /// <param name="key">Key for the template in the template collection.</param>
    /// <param name="model">Model object with data for transformation.</param>
    /// <returns>Resulting output as a string.</returns>
    string Compile<TModel>(string key, TModel model);
}

/// <summary>
/// Represents a transition form of the presentation for saving into a web format.
/// </summary>
public interface IWebDocument
{
    /// <summary>
    /// Saves the document output.
    /// </summary>
    /// using (Presentation pres = new Presentation("pres.pptx"))
    /// {
    ///     var options = new WebDocumentOptions
    ///     {
    ///         TemplateEngine = new RazorTemplateEngine(),
    ///         OutputSaver = new FileOutputSaver(),
    ///         EmbedImages = false
    ///     };
    ///     
    ///     WebDocument document = new WebDocument(options);
    ///
    ///     // add "index-template.html" template with "index" template key to use it later (for Output)
    ///     document.Input.AddTemplate<Aspose.Slides.Presentation>("index", "index-template.html");
    /// 
    ///     // add "index.html" to output files, using "index" template to generate it and pres variable as model
    ///     document.Output.Add("index.html", "index", pres);
    ///     
    ///     // ... set up other options of the document and then save the document
    ///     document.Global.Put("slideMargin", 10);
    ///     document.Global.Put("imagesPath", "root/site/images");
    ///     // ...
    ///  
    ///     document.Save();
    /// }
    void Save();

    /// <summary>
    /// Returns collection of input elements (templates) of the document.
    /// Read-only <see cref="IInput"/>.
    /// </summary>
    /// using (Presentation pres = new Presentation("pres.pptx"))
    /// {
    ///     var options = new WebDocumentOptions
    ///     {
    ///         TemplateEngine = new RazorTemplateEngine(),
    ///         OutputSaver = new FileOutputSaver(),
    ///         EmbedImages = false
    ///     };
    ///     
    ///     WebDocument document = new WebDocument(options);
    ///
    ///     /// add "index-template.html" template with "index" template key to use it later (for Output). The model type is Aspose.Slides.Presentation
    ///     document.Input.AddTemplate<Aspose.Slides.Presentation>("index", "index-template.html");
    ///     
    ///     /// ... set up other options of the document and then save the document
    ///     document.Save();
    /// }
    IInput Input { get; }

    /// <summary>
    /// Returns collection of output elements of the document.
    /// Read-only <see cref="IOutput"/>.
    /// </summary>
    /// using (Presentation pres = new Presentation("pres.pptx"))
    /// {
    ///     var options = new WebDocumentOptions
    ///     {
    ///         TemplateEngine = new RazorTemplateEngine(),
    ///         OutputSaver = new FileOutputSaver(),
    ///         EmbedImages = false
    ///     };
    ///     
    ///     WebDocument document = new WebDocument(options);
    ///
    ///     // add "index.html" to output files, using "index" template to generate it and pres variable as model
    ///     document.Output.Add("index.html", "index", pres);
    ///
    ///     // ... set up other options of the document and then save the document
    ///     document.Save();
    /// }
    IOutput Output { get; }

    /// <summary>
    /// Returns global storage of the document.
    /// Read-only <see cref="IStorage"/>.
    /// </summary>
    /// <example>Using this <see cref="Global"/> property (implementation of <see cref="IStorage"/> interface) a
    /// property can be put to use it later in the template:
    /// <code>
    /// [C#]
    /// var options = new WebDocumentOptions
    /// {
    ///     TemplateEngine = new RazorTemplateEngine(),
    ///     OutputSaver = new FileOutputSaver(),
    ///     EmbedImages = false
    /// };
    ///
    /// WebDocument document = new WebDocument(options);
    ///
    /// // put "slideMargin" property to use from templates
    /// document.Global.Put("slideMargin", 10);
    /// 
    /// // ... set up other options of the document and then save the document
    /// document.Save();
    /// </code>
    /// </example> 
    IStorage Global { get; }
}

/// <summary>
/// Represents an options set for IWebDocument saving.
/// </summary>
public interface IWebDocumentOptions
{
    /// <summary>
    /// Returns or sets templates engine.
    /// </summary>
    ITemplateEngine TemplateEngine { get; set; }

    /// <summary>
    /// Returns or sets output saver.
    /// </summary>
    IOutputSaver OutputSaver { get; set; }

    /// <summary>
    /// Returns or sets images embedding option.
    /// </summary>
    bool EmbedImages { get; set; }
}

/// <summary>
/// Represents a model object interface for a template engine.
/// </summary>
public sealed class TemplateContext<TObject>
{
    /// <summary>
    /// Creates a child template context.
    /// </summary>
    /// <param name="subModel">Child model object.</param>
    /// <returns>New template context with given model and parent's otput collection and global storage.</returns>
    public TemplateContext<TSubModel> SubModel<TSubModel>(TSubModel subModel)
    {
        /*...*/
    }

    /// <summary>
    /// Returns the model object.
    /// </summary>
    public TObject Object
    {
        get { /*...*/ }
    }

    /// <summary>
    /// Returns collection of output elements of the host document.
    /// </summary>
    public IOutput Output
    { 
        get { /*...*/ } 
    }

    /// <summary>
    /// Returns local storage of the current template context.
    /// </summary>
    public IStorage Local
    {
        get { /*...*/ }
    }

    /// <summary>
    /// Returns global storage of the host document.
    /// </summary>
    public IStorage Global
    {
        get { /*...*/ }
    }
}

public static class PresentationExtensions
{
    public static WebDocument ToSinglePageWebDocument(
        this Presentation pres,
        WebDocumentOptions options,
        string templatesPath,
        string outputPath)
    {
        WebDocument document = new WebDocument(options);

        SetGlobals(document, options, outputPath);
        document.Global.Put("slidesPath", outputPath);
        document.Global.Put("stylesPath", outputPath);

        document.AddCommonInputOutput(options, templatesPath, outputPath, pres);

        return document;
    }
    
    private static void SetGlobals(WebDocument document, WebDocumentOptions options, string outputPath)
    {
        string imagesPath = Path.Combine(outputPath, "images");
        string fontsPath = Path.Combine(outputPath, "fonts");
        string mediaPath = Path.Combine(outputPath, "media");

        document.Global.Put("slideMargin", 10);
        document.Global.Put("embedImages", options.EmbedImages);
        document.Global.Put("imagesPath", imagesPath);
        document.Global.Put("fontsPath", fontsPath);
        document.Global.Put("mediaPath", mediaPath);
    }
    
    private static void AddCommonInputOutput(this WebDocument document, WebDocumentOptions options, string templatesPath, string outputPath, Presentation pres)
    {
        string stylesPath = document.Global.Get<string>("stylesPath");

        document.Input.AddTemplate<Presentation>("styles-pres", Path.Combine(templatesPath, @"styles\pres.css"));
        document.Input.AddTemplate<MasterSlide>("styles-master", Path.Combine(templatesPath, @"styles\master.css"));

        document.Input.AddTemplate<Presentation>("index", Path.Combine(templatesPath, "index.html"));
        document.Input.AddTemplate<Slide>("slide", Path.Combine(templatesPath, "slide.html"));
        document.Input.AddTemplate<AutoShape>("autoshape", Path.Combine(templatesPath, "autoshape.html"));
        document.Input.AddTemplate<TextFrame>("textframe", Path.Combine(templatesPath, "textframe.html"));
        document.Input.AddTemplate<Paragraph>("paragraph", Path.Combine(templatesPath, "paragraph.html"));
        document.Input.AddTemplate<Paragraph>("bullet", Path.Combine(templatesPath, "bullet.html"));
        document.Input.AddTemplate<Portion>("portion", Path.Combine(templatesPath, "portion.html"));

        document.Input.AddTemplate<VideoFrame>("videoframe", Path.Combine(templatesPath, "videoframe.html"));

        document.Input.AddTemplate<PictureFrame>("pictureframe", Path.Combine(templatesPath, "pictureframe.html"));
        document.Input.AddTemplate<Table>("table", Path.Combine(templatesPath, "table.html"));
        document.Input.AddTemplate<Shape>("shape", Path.Combine(templatesPath, "shape.html"));

        document.Output.Add(Path.Combine(outputPath, "index.html"), "index", pres);
        document.Output.Add(Path.Combine(stylesPath, "pres.css"), "styles-pres", pres);
        document.Output.Add(Path.Combine(stylesPath, "master.css"), "styles-master", (MasterSlide)pres.Masters[0]);

        if (!options.EmbedImages)
        {
            string imagesPath = document.Global.Get<string>("imagesPath");
            document.AddImagesOutput(imagesPath, pres);
        }
    }
    
    private static void AddImagesOutput(this WebDocument document, string outputPath, Presentation pres)
    {
        for (int index = 0; index < pres.Images.Count; index++)
        {
            IPPImage image = pres.Images[index];
            string path;
            string ext;

            if (image.ContentType == "image/x-emf"
                || image.ContentType == "image/x-wmf") //save metafile as PNG to make it supported by various browsers  
            {
                ext = "png";
                path = Path.Combine(outputPath, string.Format("image{0}.{1}", index, ext));

                var bitmap = ImageHelper.MetafileToBitmap(image);
                document.Output.Add(path, new ThumbnailOutputFile(bitmap), image);

                continue;
            }

            ext = MimeTypesMap.GetExtension(image.ContentType);
            path = Path.Combine(outputPath, string.Format("image{0}.{1}", index, ext));

            document.Output.Add(path, image);
        }
    }
}

/// <summary>
/// Controls SVG shape and text generation.
/// </summary>
public interface ISvgShapeAndTextFormattingController : ISvgShapeFormattingController
{
    /// <summary>
    /// This function is called before rendering of text portion to SVG to allow user to control resulting SVG.
    /// </summary>
    /// <param name="svgTSpan">Object to control SVG tspan generation.</param>
    /// <param name="portion">Source portion.</param>
    /// <param name="textFrame">Source portion text frame.</param>
    void FormatText(ISvgTSpan svgTSpan, IPortion portion, ITextFrame textFrame);
}

public void SaveSlideToSVG()
{
    using (Presentation pres = new Presentation(path + "presentation.pptx"))
    {
        SVGOptions svgOptions = new SVGOptions
        {
            ShapeFormattingController = new CustomSvgShapeFormattingController(0)
        };

        using (FileStream fs = new FileStream(path + "slide.svg", FileMode.Create, FileAccess.Write))
        {
            pres.Slides[0].WriteAsSvg(fs, svgOptions);
            fs.Close();
        }
    }
}

class CustomSvgShapeFormattingController : ISvgShapeAndTextFormattingController
{
    private int m_shapeIndex, m_portionIndex, m_tspanIndex;

    public CustomSvgShapeFormattingController(int shapeStartIndex = 0)
    {
        m_shapeIndex = shapeStartIndex;
        m_portionIndex = 0;
    }

    public void FormatShape(Aspose.Slides.Export.ISvgShape svgShape, IShape shape)
    {
        svgShape.Id = string.Format("shape-{0}", m_shapeIndex++);
        m_portionIndex = m_tspanIndex = 0;
    }

    public void FormatText(Aspose.Slides.Export.ISvgTSpan svgTSpan, IPortion portion, ITextFrame textFrame)
    {
        int paragraphIndex = 0; int portionIndex = 0;
        for (int i = 0; i < textFrame.Paragraphs.Count; i = i + 1)
        {
            portionIndex = textFrame.Paragraphs[i].Portions.IndexOf(portion);
            if (portionIndex > -1) { paragraphIndex = i; break; }
        }
        if (m_portionIndex != portionIndex)
        {
            m_tspanIndex = 0;
            m_portionIndex = portionIndex;
        }
        
        svgTSpan.Id = string.Format("paragraph-{0}_portion-{1}_{2}", paragraphIndex, m_portionIndex, m_tspanIndex++);
    }
}