Aspose.Words for C++ 22.4 Release Notes

public enum PdfCompliance
{
    /// <summary>
    /// The output file will comply with the PDF/A-4 (ISO 19005-4:2020) standard.
    /// PDF/A-4 has the objective of preserving document static visual appearance over time, independent of the tools
    /// and systems used for creating, storing or rendering the files. Additionally any text contained in the document
    /// can be reliably extracted as a series of Unicode codepoints.
    /// </summary>
    PdfA4
}

public class PdfSaveOptions
{
    /// <summary>
    /// Specifies whether to preserve Microsoft Word form fields as form fields in PDF or convert them to text.
    /// Default is <c>false</c>.
    /// </summary>
    /// <remarks>
    ...
    /// <para>Editable forms are prohibited by PDF/A compliance. <c>false</c> value will be used automatically
    /// when saving to PDF/A.</para>
    /// </remarks>
    public bool PreserveFormFields;

    /// <summary>
    /// Gets or sets the details for encrypting the output PDF document.
    /// </summary>
    /// <remarks>
    ...
    /// <para>Encryption is prohibited by PDF/A compliance. This option will be ignored when saving to PDF/A.</para>
    public PdfEncryptionDetails EncryptionDetails;
      
    /// <summary>
    /// Specifies the font embedding mode.
    /// </summary>
    /// <remarks>
    ...
    /// <para>PDF/A and PDF/UA compliance requires all fonts to be embedded.
    /// <see cref="PdfFontEmbeddingMode.EmbedAll"/> value will be used automatically when saving to
    /// PDF/A and PDF/UA.</para>
    /// </remarks>
    public PdfFontEmbeddingMode FontEmbeddingMode;
      
    /// <summary>
    /// Gets or sets a value determining whether or not to substitute TrueType fonts Arial, Times New Roman,
    /// Courier New and Symbol with core PDF Type 1 fonts.
    /// </summary>
    /// <remarks>
    ...
    /// <para>PDF/A and PDF/UA compliance requires all fonts to be embedded. <c>false</c> value will be used
    /// automatically when saving to PDF/A and PDF/UA.</para>
    /// </remarks>
    public bool UseCoreFonts;
      
    /// <summary>
    /// Gets or sets a value determining the way <see cref="Document.CustomDocumentProperties"/> are exported to PDF file.
    /// </summary>
    /// <remarks>
    ...
    /// <para><see cref="PdfCustomPropertiesExport.Metadata"/> value is not supported when saving to PDF/A.
    /// <see cref="PdfCustomPropertiesExport.Standard"/> will be used instead for PDF/A-1 and PDF/A-2 and
    /// <see cref="PdfCustomPropertiesExport.None"/> for PDF/A-4.</para>
    ...
    /// </remarks>
    public PdfCustomPropertiesExport CustomPropertiesExport;
      
    /// <summary>
    /// Specifies how the color space will be selected for the images in PDF document.
    /// </summary>
    /// <remarks>
    ...
    /// <para><see cref="PdfImageColorSpaceExportMode.SimpleCmyk"/> value is not supported when saving to PDF/A.
    /// <see cref="PdfImageColorSpaceExportMode.Auto"/> value will be used instead.</para>
    /// </remarks>
    public PdfImageColorSpaceExportMode ImageColorSpaceExportMode;
      
    /// <summary>
    /// A flag indicating whether image interpolation shall be performed by a conforming reader.
    /// When <c>false</c> is specified, the flag is not written to the output document and
    /// the default behaviour of reader is used instead.
    /// </summary>
    /// <remarks>
    ...
    /// <para>Interpolation flag is prohibited by PDF/A compliance. <c>false</c> value will be used automatically
    /// when saving to PDF/A.</para>
    /// </remarks>
    public bool InterpolateImages;
}

/// <summary>
/// Gets the path and name of an xls/xlsx file this chart is linked to.
/// </summary>
public string SourceFullName { get; set; }

auto doc = System::MakeObject<Document>(fileName);
auto shape = System::Static_Cast<Shape>(doc->GetChild(NodeType::Shape, 0, true));
shape->get_Chart()->set_SourceFullName(u"C:\\Documents\\ChartData.xlsx");
doc->Save(fileName);

public class HtmlLoadOptions
{
    /// <summary>
    /// Gets or sets a value that specifies how properties of block-level elements are imported.
    /// Default value is <see cref="BlockImportMode.Merge"/>.
    /// </summary>
    public BlockImportMode BlockImportMode { get; set; }
}

/// <summary>
/// Specifies how properties of block-level elements are imported from HTML-based documents.
/// </summary>
public enum BlockImportMode
{
    /// <summary>
    /// Properties of parent blocks are merged and stored on child elements (i.e. paragraphs or tables).
    /// </summary>
    /// <remarks>
    /// <para>
    /// Properties of parent blocks are merged as follows: margins are added together; borders of higher-level blocks
    /// are discarded and only the most inner-level borders are preserved. As a result, when this mode is specified,
    /// some formatting of blocks from the original document will be lost.
    /// </para>
    /// <para>
    /// On the other hand, since all merged block-level properties are stored on document nodes, all formating
    /// in the resulting document will be available for modification.
    /// </para>
    /// </remarks>
    Merge,

    /// <summary>
    /// Properties of parent blocks are imported to a special logical structure and are stored separately from
    /// document nodes.
    /// </summary>
    /// <remarks>
    /// <para>
    /// Only margins and borders of 'body', 'div', and 'blockquote' HTML elements are imported. Properties of each HTML
    /// element are stored individually.
    /// </para>
    /// <para>
    /// This mode allows to better preserve borders and margins seen in the HTML document and get better conversion
    /// results. The downside is that the resulting document gets harder to modify, since borders and margins stored
    /// in the logical structure are not available for editing.
    /// </para>
    /// <para>
    /// This mode mimics MS Word's behavior regarding import of block properties.
    /// </para>
    /// </remarks>
    Preserve
}

System::String html = uR"(
<html>
    <div style='border:dotted'>
        <div style='border:solid'>
            <p>paragraph 1</p>
            <p>paragraph 2</p>
        </div>
    </div>
</html>)";

auto loadOptions = System::MakeObject<HtmlLoadOptions>();

// Set the new mode of import HTML block-level elements.
loadOptions->set_BlockImportMode(BlockImportMode::Preserve);
auto stream = System::MakeObject<MemoryStream>(Encoding::get_UTF8()->GetBytes(html));
auto doc = System::MakeObject<Document>(stream, loadOptions);
doc->Save(u"sample.docx");

namespace Aspose.Words.Drawing.Charts
{
    /// <summary>
    /// Represents a chart legend entry.
    /// </summary>
    /// <remarks>
    /// A legend entry corresponds to a specific chart series or trendline.
    /// The text of the entry is the name of the series or trendline. The text cannot be changed.
    /// </remarks>
    public class ChartLegendEntry
    {
        /// <summary>
        /// Gets or sets a value indicating whether this entry is hidden in the chart legend.
        /// The default value is false.
        /// </summary>
        /// <remarks>
        /// When a chart legend entry is hidden, it does not affect the corresponding chart series or trendline that
        /// is still displayed on the chart.
        /// </remarks>
        public bool IsHidden { get; set; }

        /// <summary>
        /// Provides access to the font formatting of this legend entry.
        /// </summary>
        public Font Font { get; }
    }
     
    /// <summary>
    /// Represents a collection of chart legend entries.
    /// </summary>
    public class ChartLegendEntryCollection : IEnumerable<ChartLegendEntry>
    {
        /// <summary>
        /// Returns the number of ChartLegendEntry in this collection.
        /// </summary>
        public int Count { get; }
     
        /// <summary>
        /// Returns ChartLegendEntry for the specified index.
        /// </summary>
        public ChartLegendEntry this[int index] { get; }
    }
}

/// <summary>
/// Returns a collection of legend entries for all series and trendlines of the parent chart.
/// </summary>
public ChartLegendEntryCollection LegendEntries { get; }

/// <summary>
/// Gets a legend entry for this chart series.
/// </summary>
public ChartLegendEntry LegendEntry { get; }

auto doc = System::MakeObject<Document>();
auto builder = System::MakeObject<DocumentBuilder>(doc);

auto shape = builder->InsertChart(ChartType::Column, 432, 252);

auto chart = shape->get_Chart();
aut series = chart->get_Series();

// Delete default generated series.
series->Clear();

auto categories = System::MakeArray<System::String>({ u"AW Category 1", u"AW Category 2" });

auto series1 = series->Add(u"Series 1", categories, System::MakeArray<double>({ 1, 2 }));
series->Add(u"Series 2", categories, System::MakeArray<double>({ 3, 4 }));
series.Add(u"Series 3", categories, System::MakeArray<double>({ 5, 6 }));
series.Add(u"Series 4", categories, System::MakeArray<double>({ 0, 0 }));

auto legendEntries = chart->get_Legend()->get_LegendEntries();
legendEntries->idx_get(3)->set_IsHidden(true);

for (auto&& legendEntry: legendEntries) {
    legendEntry->get_Font()->set_Size(12);
}

series1->get_LegendEntry()->get_Font()->set_Italic(true);

doc->Save(u"output.docx");

public interface IStructuredDocumentTag
{
    /// <summary>
    /// Returns true if this instance is a ranged structured document tag.
    /// </summary>
    bool IsRanged();

    /// <summary>
    /// Returns Node object that implements this interface.
    /// </summary>
    Node StructuredDocumentTagNode();
     
    /// <summary>
    /// <para>Specifies a unique read-only persistent numerical Id for this <b>SDT</b>.</para>
    /// </summary>
    int Id { get; }
     
    /// <summary>
    /// Specifies a tag associated with the current SDT node.
    /// Can not be null.
    /// </summary>
    string Tag { get; set; }
     
    /// <summary>
    /// Specifies the friendly name associated with this <b>SDT</b>.
    /// Can not be null.
    /// </summary>
    string Title { get; set; }
     
    /// <summary>
    /// Gets the <see cref="BuildingBlock"/> containing placeholder text which should be displayed when this SDT run contents are empty,
    /// the associated mapped XML element is empty as specified via the <see cref="XmlMapping"/> element
    /// or the <see cref="IsShowingPlaceholderText"/> element is true.
    /// </summary>
    /// <remarks>Can be null, meaning that the placeholder is not applicable for this Sdt.</remarks>
    BuildingBlock Placeholder { get; }
     
    /// <summary>
    /// <para>Gets or sets Name of the <see cref="BuildingBlock"/> containing placeholder text.</para>
    /// <para>
    /// BuildingBlock with this name <see cref="BuildingBlock.Name"/> has to be present in the <see cref="Document.GlossaryDocument"/>
    /// otherwise <see cref="InvalidOperationException"/> will occur.</para>
    /// </summary>
    string PlaceholderName { get; set; }
     
    /// <summary>
    /// <para>
    /// Specifies whether the content of this <b>SDT</b> shall be interpreted to contain placeholder text
    /// (as opposed to regular text contents within the SDT).
    /// </para>
    /// <para>
    /// if set to true, this state shall be resumed (showing placeholder text) upon opening this document.
    /// </para>
    /// </summary>
    bool IsShowingPlaceholderText { get; set; }
     
    /// <summary>
    /// Gets the level at which this <b>SDT</b> occurs in the document tree.
    /// </summary>
    MarkupLevel Level { get; }
     
    /// <summary>
    /// Gets type of this <b>Structured document tag</b>.
    /// </summary>
    SdtType SdtType { get; }
     
    /// <summary>
    /// When set to true, this property will prohibit a user from deleting this <b>SDT</b>.
    /// </summary>
    bool LockContentControl { get; set; }
     
    /// <summary>
    /// When set to true, this property will prohibit a user from editing the contents of this <b>SDT</b>.
    /// </summary>
    bool LockContents { get; set; }
     
    /// <summary>
    /// Gets or sets the color of the structured document tag.
    /// </summary>
    System.Drawing.Color Color { get; set; }
     
    /// <summary>
    /// Gets an object that represents the mapping of this structured document tag to XML data
    /// in a custom XML part of the current document.
    /// </summary>
    /// <remarks>
    /// You can use the <see cref="Markup.XmlMapping.SetMapping(CustomXmlPart,string,string)"/> method of this object to map
    /// a structured document tag to XML data.
    /// </remarks>
    /// <dev>
    /// If this element is present and the parent Sdt is not of a rich text type, then the current
    /// value of the Sdt shall be determined by finding the XML element (if any) which is
    /// determined by the attributes on this element.
    /// See Iso29500, chapter 1, 17.5.2.6 dataBinding (XML Mapping).
    /// If DataBinding information does not result in an XML element, then the
    /// application can use any algorithm desired to find the closest available match. If this information does result in an
    /// XML element, then the contents of that element shall be used to replace the current run content within the
    /// document.
    /// </dev>
    XmlMapping XmlMapping { get; }
     
    /// <summary>
    /// Gets a string that represents the XML contained within the node in the <see cref="SaveFormat.FlatOpc"/> format.
    /// </summary>
    string WordOpenXML { get; }
}

public class StructuredDocumentTagCollection : IEnumerable<IStructuredDocumentTag>
{
    /// <summary>
    /// Returns the first structured document tag encountered in the collection with the specified title.
    /// </summary>
    /// <remarks>
    /// <p>Returns null if the structured document tag with the specified title cannot be found.</p>
    /// </remarks>
    /// <param name="title">The title of structured document tag.</param>
    public IStructuredDocumentTag GetByTitle(string title);

    /// <summary>
    /// Returns the first structured document tag encountered in the collection with the specified tag.
    /// </summary>
    /// <remarks>
    /// <p>Returns null if the structured document tag with the specified tag cannot be found.</p>
    /// </remarks>
    /// <param name="tag">The tag of the structured document tag.</param>
    public IStructuredDocumentTag GetByTag(string tag);
     
    /// <summary>
    /// Returns the number of structured document tags in the collection.
    /// </summary>
    public int Count { get; }
     
    /// <summary>
    /// Returns the structured document tag by Id.
    /// </summary>
    /// <param name="id">The structured document tag identifier.</param>
    public IStructuredDocumentTag this[int id] {get; }
     
    /// <summary>
    /// Removes the structured document tag with the specified identifier.
    /// </summary>
    /// <param name="id">The structured document tag identifier.</param>
    public void Remove(int id);
}

/// <summary>
/// Returns a <see cref="StructuredDocumentTags"/> collection that represents all structured document tags in the range.
/// </summary>
public StructuredDocumentTagCollection Range.StructuredDocumentTags { get; }

auto doc = System::MakeObject<Document>(u"some document with markup");

// Get the structured document tag by Id.
auto sdt = doc->get_Range()->get_StructuredDocumentTags()->idx_get(1160505028);
cout << sdt->get_IsRanged() << '\n' << sdt=>get_Title() << '\n';

// Get the structured document tag or ranged tag by Title.
sdt = doc->get_Range()->get_StructuredDocumentTags()->GetByTitle(u"Alias4");
cout << sdt->get_Id();