com.aspose.words

Property Getters/Setters Detail

• getBold

  public boolean getBold()
  

  Indicates whether the current font is bold.

  Example:

  Shows how to define custom logic for handling font exporting when saving to HTML based formats.

  public void saveHtmlExportFonts() throws Exception {
      Document doc = new Document(getMyDir() + "Rendering.docx");
  
      // Set the option to export font resources and create and pass the object which implements the handler methods
      HtmlSaveOptions options = new HtmlSaveOptions(SaveFormat.HTML);
      options.setExportFontResources(true);
      options.setFontSavingCallback(new HandleFontSaving());
  
      // The fonts from the input document will now be exported as .ttf files and saved alongside the output document
      doc.save(getArtifactsDir() + "Document.SaveHtmlExportFonts.html", options);
  }
  
  /// <summary>
  /// Prints information about fonts and saves them alongside their output .html.
  /// </summary>
  public static class HandleFontSaving implements IFontSavingCallback {
      public void fontSaving(FontSavingArgs args) throws Exception {
          // Print information about fonts
          System.out.println(MessageFormat.format("Font:\t{0}", args.getFontFamilyName()));
          if (args.getBold()) System.out.println(", bold");
          if (args.getItalic()) System.out.println(", italic");
          System.out.println(MessageFormat.format("\nSource:\t{0}, {1} bytes\n", args.getOriginalFileName(), args.getOriginalFileSize()));
  
          Assert.assertTrue(args.isExportNeeded());
          Assert.assertTrue(args.isSubsettingNeeded());
  
          // We can designate where each font will be saved by either specifying a file name, or creating a new stream
          String[] parts = args.getOriginalFileName().split(File.separator + File.separator);
          String lastOne = parts[parts.length - 1];
          args.setFontFileName(lastOne);
  
          Assert.assertFalse(args.getKeepFontStreamOpen());
  
          // We can access the source document from here also
          Assert.assertTrue(args.getDocument().getOriginalFileName().endsWith("Rendering.docx"));
      }
  }

• getDocument

  public Document getDocument()
  

  Gets the document object that is being saved.

  Example:

  Shows how to define custom logic for handling font exporting when saving to HTML based formats.

  public void saveHtmlExportFonts() throws Exception {
      Document doc = new Document(getMyDir() + "Rendering.docx");
  
      // Set the option to export font resources and create and pass the object which implements the handler methods
      HtmlSaveOptions options = new HtmlSaveOptions(SaveFormat.HTML);
      options.setExportFontResources(true);
      options.setFontSavingCallback(new HandleFontSaving());
  
      // The fonts from the input document will now be exported as .ttf files and saved alongside the output document
      doc.save(getArtifactsDir() + "Document.SaveHtmlExportFonts.html", options);
  }
  
  /// <summary>
  /// Prints information about fonts and saves them alongside their output .html.
  /// </summary>
  public static class HandleFontSaving implements IFontSavingCallback {
      public void fontSaving(FontSavingArgs args) throws Exception {
          // Print information about fonts
          System.out.println(MessageFormat.format("Font:\t{0}", args.getFontFamilyName()));
          if (args.getBold()) System.out.println(", bold");
          if (args.getItalic()) System.out.println(", italic");
          System.out.println(MessageFormat.format("\nSource:\t{0}, {1} bytes\n", args.getOriginalFileName(), args.getOriginalFileSize()));
  
          Assert.assertTrue(args.isExportNeeded());
          Assert.assertTrue(args.isSubsettingNeeded());
  
          // We can designate where each font will be saved by either specifying a file name, or creating a new stream
          String[] parts = args.getOriginalFileName().split(File.separator + File.separator);
          String lastOne = parts[parts.length - 1];
          args.setFontFileName(lastOne);
  
          Assert.assertFalse(args.getKeepFontStreamOpen());
  
          // We can access the source document from here also
          Assert.assertTrue(args.getDocument().getOriginalFileName().endsWith("Rendering.docx"));
      }
  }

• getFontFamilyName

  public java.lang.String getFontFamilyName()
  

  Indicates the current font family name.

  Example:

  Shows how to define custom logic for handling font exporting when saving to HTML based formats.

  public void saveHtmlExportFonts() throws Exception {
      Document doc = new Document(getMyDir() + "Rendering.docx");
  
      // Set the option to export font resources and create and pass the object which implements the handler methods
      HtmlSaveOptions options = new HtmlSaveOptions(SaveFormat.HTML);
      options.setExportFontResources(true);
      options.setFontSavingCallback(new HandleFontSaving());
  
      // The fonts from the input document will now be exported as .ttf files and saved alongside the output document
      doc.save(getArtifactsDir() + "Document.SaveHtmlExportFonts.html", options);
  }
  
  /// <summary>
  /// Prints information about fonts and saves them alongside their output .html.
  /// </summary>
  public static class HandleFontSaving implements IFontSavingCallback {
      public void fontSaving(FontSavingArgs args) throws Exception {
          // Print information about fonts
          System.out.println(MessageFormat.format("Font:\t{0}", args.getFontFamilyName()));
          if (args.getBold()) System.out.println(", bold");
          if (args.getItalic()) System.out.println(", italic");
          System.out.println(MessageFormat.format("\nSource:\t{0}, {1} bytes\n", args.getOriginalFileName(), args.getOriginalFileSize()));
  
          Assert.assertTrue(args.isExportNeeded());
          Assert.assertTrue(args.isSubsettingNeeded());
  
          // We can designate where each font will be saved by either specifying a file name, or creating a new stream
          String[] parts = args.getOriginalFileName().split(File.separator + File.separator);
          String lastOne = parts[parts.length - 1];
          args.setFontFileName(lastOne);
  
          Assert.assertFalse(args.getKeepFontStreamOpen());
  
          // We can access the source document from here also
          Assert.assertTrue(args.getDocument().getOriginalFileName().endsWith("Rendering.docx"));
      }
  }

• getFontFileName/setFontFileName

  public java.lang.String getFontFileName() / public void setFontFileName(java.lang.String value)
  

  Gets or sets the file name (without path) where the font will be saved to.

  This property allows you to redefine how the font file names are generated during export to HTML.

  When the event is fired, this property contains the file name that was generated by Aspose.Words. You can change the value of this property to save the font into a different file. Note that file names must be unique.

  Aspose.Words automatically generates a unique file name for every embedded font when exporting to HTML format. How the font file name is generated depends on whether you save the document to a file or to a stream.

  When saving a document to a file, the generated font file name looks like <document base file name>.<original file name><optional suffix>.<extension>.

  When saving a document to a stream, the generated font file name looks like Aspose.Words.<document guid>.<original file name><optional suffix>.<extension>.

  FontFileName must contain only the file name without the path. Aspose.Words determines the path for saving using the document file name, the HtmlSaveOptions.FontsFolder and HtmlSaveOptions.FontsFolderAlias properties.

  Example:

  Shows how to define custom logic for handling font exporting when saving to HTML based formats.

  public void saveHtmlExportFonts() throws Exception {
      Document doc = new Document(getMyDir() + "Rendering.docx");
  
      // Set the option to export font resources and create and pass the object which implements the handler methods
      HtmlSaveOptions options = new HtmlSaveOptions(SaveFormat.HTML);
      options.setExportFontResources(true);
      options.setFontSavingCallback(new HandleFontSaving());
  
      // The fonts from the input document will now be exported as .ttf files and saved alongside the output document
      doc.save(getArtifactsDir() + "Document.SaveHtmlExportFonts.html", options);
  }
  
  /// <summary>
  /// Prints information about fonts and saves them alongside their output .html.
  /// </summary>
  public static class HandleFontSaving implements IFontSavingCallback {
      public void fontSaving(FontSavingArgs args) throws Exception {
          // Print information about fonts
          System.out.println(MessageFormat.format("Font:\t{0}", args.getFontFamilyName()));
          if (args.getBold()) System.out.println(", bold");
          if (args.getItalic()) System.out.println(", italic");
          System.out.println(MessageFormat.format("\nSource:\t{0}, {1} bytes\n", args.getOriginalFileName(), args.getOriginalFileSize()));
  
          Assert.assertTrue(args.isExportNeeded());
          Assert.assertTrue(args.isSubsettingNeeded());
  
          // We can designate where each font will be saved by either specifying a file name, or creating a new stream
          String[] parts = args.getOriginalFileName().split(File.separator + File.separator);
          String lastOne = parts[parts.length - 1];
          args.setFontFileName(lastOne);
  
          Assert.assertFalse(args.getKeepFontStreamOpen());
  
          // We can access the source document from here also
          Assert.assertTrue(args.getDocument().getOriginalFileName().endsWith("Rendering.docx"));
      }
  }

  See Also:

  FontStream, HtmlSaveOptions.FontsFolder, HtmlSaveOptions.FontsFolderAlias

• getFontStream/setFontStream

  public java.io.OutputStream getFontStream() / public void setFontStream(java.io.OutputStream value)
  

  Allows to specify the stream where the font will be saved to.

  This property allows you to save fonts to streams instead of files during HTML export.

  The default value is null. When this property is null, the font will be saved to a file specified in the FontFileName property.

  Example:

  Shows how to define custom logic for handling font exporting when saving to HTML based formats.

  public void saveHtmlExportFonts() throws Exception {
      Document doc = new Document(getMyDir() + "Rendering.docx");
  
      // Set the option to export font resources and create and pass the object which implements the handler methods
      HtmlSaveOptions options = new HtmlSaveOptions(SaveFormat.HTML);
      options.setExportFontResources(true);
      options.setFontSavingCallback(new HandleFontSaving());
  
      // The fonts from the input document will now be exported as .ttf files and saved alongside the output document
      doc.save(getArtifactsDir() + "Document.SaveHtmlExportFonts.html", options);
  }
  
  /// <summary>
  /// Prints information about fonts and saves them alongside their output .html.
  /// </summary>
  public static class HandleFontSaving implements IFontSavingCallback {
      public void fontSaving(FontSavingArgs args) throws Exception {
          // Print information about fonts
          System.out.println(MessageFormat.format("Font:\t{0}", args.getFontFamilyName()));
          if (args.getBold()) System.out.println(", bold");
          if (args.getItalic()) System.out.println(", italic");
          System.out.println(MessageFormat.format("\nSource:\t{0}, {1} bytes\n", args.getOriginalFileName(), args.getOriginalFileSize()));
  
          Assert.assertTrue(args.isExportNeeded());
          Assert.assertTrue(args.isSubsettingNeeded());
  
          // We can designate where each font will be saved by either specifying a file name, or creating a new stream
          String[] parts = args.getOriginalFileName().split(File.separator + File.separator);
          String lastOne = parts[parts.length - 1];
          args.setFontFileName(lastOne);
  
          Assert.assertFalse(args.getKeepFontStreamOpen());
  
          // We can access the source document from here also
          Assert.assertTrue(args.getDocument().getOriginalFileName().endsWith("Rendering.docx"));
      }
  }

  See Also:

  FontFileName, KeepFontStreamOpen

• isExportNeeded/isExportNeeded

  public boolean isExportNeeded() / public void isExportNeeded(boolean value)
  

  Allows to specify whether the current font will be exported as a font resource. Default is true.

  Example:

  Shows how to define custom logic for handling font exporting when saving to HTML based formats.

  public void saveHtmlExportFonts() throws Exception {
      Document doc = new Document(getMyDir() + "Rendering.docx");
  
      // Set the option to export font resources and create and pass the object which implements the handler methods
      HtmlSaveOptions options = new HtmlSaveOptions(SaveFormat.HTML);
      options.setExportFontResources(true);
      options.setFontSavingCallback(new HandleFontSaving());
  
      // The fonts from the input document will now be exported as .ttf files and saved alongside the output document
      doc.save(getArtifactsDir() + "Document.SaveHtmlExportFonts.html", options);
  }
  
  /// <summary>
  /// Prints information about fonts and saves them alongside their output .html.
  /// </summary>
  public static class HandleFontSaving implements IFontSavingCallback {
      public void fontSaving(FontSavingArgs args) throws Exception {
          // Print information about fonts
          System.out.println(MessageFormat.format("Font:\t{0}", args.getFontFamilyName()));
          if (args.getBold()) System.out.println(", bold");
          if (args.getItalic()) System.out.println(", italic");
          System.out.println(MessageFormat.format("\nSource:\t{0}, {1} bytes\n", args.getOriginalFileName(), args.getOriginalFileSize()));
  
          Assert.assertTrue(args.isExportNeeded());
          Assert.assertTrue(args.isSubsettingNeeded());
  
          // We can designate where each font will be saved by either specifying a file name, or creating a new stream
          String[] parts = args.getOriginalFileName().split(File.separator + File.separator);
          String lastOne = parts[parts.length - 1];
          args.setFontFileName(lastOne);
  
          Assert.assertFalse(args.getKeepFontStreamOpen());
  
          // We can access the source document from here also
          Assert.assertTrue(args.getDocument().getOriginalFileName().endsWith("Rendering.docx"));
      }
  }

• isSubsettingNeeded/isSubsettingNeeded

  public boolean isSubsettingNeeded() / public void isSubsettingNeeded(boolean value)
  

  Allows to specify whether the current font will be subsetted before exporting as a font resource.

  Fonts can be exported as complete original font files or subsetted to include only the characters that are used in the document. Subsetting allows to reduce the resulting font resource size.

  By default, Aspose.Words decides whether to perform subsetting or not by comparing the original font file size with the one specified in HtmlSaveOptions.FontResourcesSubsettingSizeThreshold. You can override this behavior for individual fonts by setting the IsSubsettingNeeded property.

  Example:

  Shows how to define custom logic for handling font exporting when saving to HTML based formats.

  public void saveHtmlExportFonts() throws Exception {
      Document doc = new Document(getMyDir() + "Rendering.docx");
  
      // Set the option to export font resources and create and pass the object which implements the handler methods
      HtmlSaveOptions options = new HtmlSaveOptions(SaveFormat.HTML);
      options.setExportFontResources(true);
      options.setFontSavingCallback(new HandleFontSaving());
  
      // The fonts from the input document will now be exported as .ttf files and saved alongside the output document
      doc.save(getArtifactsDir() + "Document.SaveHtmlExportFonts.html", options);
  }
  
  /// <summary>
  /// Prints information about fonts and saves them alongside their output .html.
  /// </summary>
  public static class HandleFontSaving implements IFontSavingCallback {
      public void fontSaving(FontSavingArgs args) throws Exception {
          // Print information about fonts
          System.out.println(MessageFormat.format("Font:\t{0}", args.getFontFamilyName()));
          if (args.getBold()) System.out.println(", bold");
          if (args.getItalic()) System.out.println(", italic");
          System.out.println(MessageFormat.format("\nSource:\t{0}, {1} bytes\n", args.getOriginalFileName(), args.getOriginalFileSize()));
  
          Assert.assertTrue(args.isExportNeeded());
          Assert.assertTrue(args.isSubsettingNeeded());
  
          // We can designate where each font will be saved by either specifying a file name, or creating a new stream
          String[] parts = args.getOriginalFileName().split(File.separator + File.separator);
          String lastOne = parts[parts.length - 1];
          args.setFontFileName(lastOne);
  
          Assert.assertFalse(args.getKeepFontStreamOpen());
  
          // We can access the source document from here also
          Assert.assertTrue(args.getDocument().getOriginalFileName().endsWith("Rendering.docx"));
      }
  }

• getItalic

  public boolean getItalic()
  

  Indicates whether the current font is italic.

  Example:

  Shows how to define custom logic for handling font exporting when saving to HTML based formats.

  public void saveHtmlExportFonts() throws Exception {
      Document doc = new Document(getMyDir() + "Rendering.docx");
  
      // Set the option to export font resources and create and pass the object which implements the handler methods
      HtmlSaveOptions options = new HtmlSaveOptions(SaveFormat.HTML);
      options.setExportFontResources(true);
      options.setFontSavingCallback(new HandleFontSaving());
  
      // The fonts from the input document will now be exported as .ttf files and saved alongside the output document
      doc.save(getArtifactsDir() + "Document.SaveHtmlExportFonts.html", options);
  }
  
  /// <summary>
  /// Prints information about fonts and saves them alongside their output .html.
  /// </summary>
  public static class HandleFontSaving implements IFontSavingCallback {
      public void fontSaving(FontSavingArgs args) throws Exception {
          // Print information about fonts
          System.out.println(MessageFormat.format("Font:\t{0}", args.getFontFamilyName()));
          if (args.getBold()) System.out.println(", bold");
          if (args.getItalic()) System.out.println(", italic");
          System.out.println(MessageFormat.format("\nSource:\t{0}, {1} bytes\n", args.getOriginalFileName(), args.getOriginalFileSize()));
  
          Assert.assertTrue(args.isExportNeeded());
          Assert.assertTrue(args.isSubsettingNeeded());
  
          // We can designate where each font will be saved by either specifying a file name, or creating a new stream
          String[] parts = args.getOriginalFileName().split(File.separator + File.separator);
          String lastOne = parts[parts.length - 1];
          args.setFontFileName(lastOne);
  
          Assert.assertFalse(args.getKeepFontStreamOpen());
  
          // We can access the source document from here also
          Assert.assertTrue(args.getDocument().getOriginalFileName().endsWith("Rendering.docx"));
      }
  }

• getKeepFontStreamOpen/setKeepFontStreamOpen

  public boolean getKeepFontStreamOpen() / public void setKeepFontStreamOpen(boolean value)
  

  Specifies whether Aspose.Words should keep the stream open or close it after saving a font.

  Default is false and Aspose.Words will close the stream you provided in the FontStream property after writing a font into it. Specify true to keep the stream open.

  Example:

  Shows how to define custom logic for handling font exporting when saving to HTML based formats.

  public void saveHtmlExportFonts() throws Exception {
      Document doc = new Document(getMyDir() + "Rendering.docx");
  
      // Set the option to export font resources and create and pass the object which implements the handler methods
      HtmlSaveOptions options = new HtmlSaveOptions(SaveFormat.HTML);
      options.setExportFontResources(true);
      options.setFontSavingCallback(new HandleFontSaving());
  
      // The fonts from the input document will now be exported as .ttf files and saved alongside the output document
      doc.save(getArtifactsDir() + "Document.SaveHtmlExportFonts.html", options);
  }
  
  /// <summary>
  /// Prints information about fonts and saves them alongside their output .html.
  /// </summary>
  public static class HandleFontSaving implements IFontSavingCallback {
      public void fontSaving(FontSavingArgs args) throws Exception {
          // Print information about fonts
          System.out.println(MessageFormat.format("Font:\t{0}", args.getFontFamilyName()));
          if (args.getBold()) System.out.println(", bold");
          if (args.getItalic()) System.out.println(", italic");
          System.out.println(MessageFormat.format("\nSource:\t{0}, {1} bytes\n", args.getOriginalFileName(), args.getOriginalFileSize()));
  
          Assert.assertTrue(args.isExportNeeded());
          Assert.assertTrue(args.isSubsettingNeeded());
  
          // We can designate where each font will be saved by either specifying a file name, or creating a new stream
          String[] parts = args.getOriginalFileName().split(File.separator + File.separator);
          String lastOne = parts[parts.length - 1];
          args.setFontFileName(lastOne);
  
          Assert.assertFalse(args.getKeepFontStreamOpen());
  
          // We can access the source document from here also
          Assert.assertTrue(args.getDocument().getOriginalFileName().endsWith("Rendering.docx"));
      }
  }

  See Also:

  FontStream

• getOriginalFileName

  public java.lang.String getOriginalFileName()
  

  Gets the original font file name with an extension.

  This property contains the original file name of the current font if it is known. Otherwise it can be an empty string.

  Example:

  Shows how to define custom logic for handling font exporting when saving to HTML based formats.

  public void saveHtmlExportFonts() throws Exception {
      Document doc = new Document(getMyDir() + "Rendering.docx");
  
      // Set the option to export font resources and create and pass the object which implements the handler methods
      HtmlSaveOptions options = new HtmlSaveOptions(SaveFormat.HTML);
      options.setExportFontResources(true);
      options.setFontSavingCallback(new HandleFontSaving());
  
      // The fonts from the input document will now be exported as .ttf files and saved alongside the output document
      doc.save(getArtifactsDir() + "Document.SaveHtmlExportFonts.html", options);
  }
  
  /// <summary>
  /// Prints information about fonts and saves them alongside their output .html.
  /// </summary>
  public static class HandleFontSaving implements IFontSavingCallback {
      public void fontSaving(FontSavingArgs args) throws Exception {
          // Print information about fonts
          System.out.println(MessageFormat.format("Font:\t{0}", args.getFontFamilyName()));
          if (args.getBold()) System.out.println(", bold");
          if (args.getItalic()) System.out.println(", italic");
          System.out.println(MessageFormat.format("\nSource:\t{0}, {1} bytes\n", args.getOriginalFileName(), args.getOriginalFileSize()));
  
          Assert.assertTrue(args.isExportNeeded());
          Assert.assertTrue(args.isSubsettingNeeded());
  
          // We can designate where each font will be saved by either specifying a file name, or creating a new stream
          String[] parts = args.getOriginalFileName().split(File.separator + File.separator);
          String lastOne = parts[parts.length - 1];
          args.setFontFileName(lastOne);
  
          Assert.assertFalse(args.getKeepFontStreamOpen());
  
          // We can access the source document from here also
          Assert.assertTrue(args.getDocument().getOriginalFileName().endsWith("Rendering.docx"));
      }
  }

  See Also:

  OriginalFileSize

• getOriginalFileSize

  public int getOriginalFileSize()
  

  Gets the original font file size.

  This property contains the original file size of the current font if it is known. Otherwise it can be zero.

  Example:

  Shows how to define custom logic for handling font exporting when saving to HTML based formats.

  public void saveHtmlExportFonts() throws Exception {
      Document doc = new Document(getMyDir() + "Rendering.docx");
  
      // Set the option to export font resources and create and pass the object which implements the handler methods
      HtmlSaveOptions options = new HtmlSaveOptions(SaveFormat.HTML);
      options.setExportFontResources(true);
      options.setFontSavingCallback(new HandleFontSaving());
  
      // The fonts from the input document will now be exported as .ttf files and saved alongside the output document
      doc.save(getArtifactsDir() + "Document.SaveHtmlExportFonts.html", options);
  }
  
  /// <summary>
  /// Prints information about fonts and saves them alongside their output .html.
  /// </summary>
  public static class HandleFontSaving implements IFontSavingCallback {
      public void fontSaving(FontSavingArgs args) throws Exception {
          // Print information about fonts
          System.out.println(MessageFormat.format("Font:\t{0}", args.getFontFamilyName()));
          if (args.getBold()) System.out.println(", bold");
          if (args.getItalic()) System.out.println(", italic");
          System.out.println(MessageFormat.format("\nSource:\t{0}, {1} bytes\n", args.getOriginalFileName(), args.getOriginalFileSize()));
  
          Assert.assertTrue(args.isExportNeeded());
          Assert.assertTrue(args.isSubsettingNeeded());
  
          // We can designate where each font will be saved by either specifying a file name, or creating a new stream
          String[] parts = args.getOriginalFileName().split(File.separator + File.separator);
          String lastOne = parts[parts.length - 1];
          args.setFontFileName(lastOne);
  
          Assert.assertFalse(args.getKeepFontStreamOpen());
  
          // We can access the source document from here also
          Assert.assertTrue(args.getDocument().getOriginalFileName().endsWith("Rendering.docx"));
      }
  }

  See Also:

  OriginalFileName, IsSubsettingNeeded