# Import and export

This page drives you through available possibilities to import content into iink SDK or to export it for external usage.

Interactive Ink SDK differentiates serialization/deserialization (storage of the full content of the model in a fast and space efficient manner for future reuse by the SDK) and import/export (as a way to exchange iink content with other applications).

## Importing content

### Import into a block

This part describes import behavior for all formats but JIIX, JIIX import is described here.

You can import data into content blocks. For example, the following code will import the “Hello iink SDK” text string into a “Text” part:

ContentPart textPart = ... // Get the part
editor.setPart(textPart);
editor.import_(MimeType.TEXT, "Hello iink SDK", editor.getRootBlock());

In this case, you could have omitted to specify the block. As the part only hosts a single root block, iink SDK can figure by itself where to import the content:

editor.import_(MimeType.TEXT, "Hello iink SDK", null);

For parts that can host multiple blocks, such as “Text Document” parts, you need to explicitly specify the target block. If it does not exist yet, you can call addBlock() and directly pass the data to import.

The list of supported mime types for a given block can be obtained by calling getSupportedImportMimeTypes() on the editor. For instance:

MimeType[] supportedMimeTypes = editor.getSupportedImportMimeTypes(editor.getRootBlock());
Importing content is “destructive”: Pre-existing content will be cleared and replaced (except for JIIX import).

### JIIX import

JIIX import is so far limited to text words candidate changes. More import capabilities will be provided later on.

To change the text candidates within a given Text or Diagram block:

1. Export the block to the JIIX format.
2. Replace the label of the target word with another word from the candidates list.
3. Import the modified JIIX data back to your block.
Importing JIIX data is only possible if the target block was not modified since it was exported. For more information, refer to this page.

### Raw ink import

To import raw ink content, instantiate an editor and pass it an array of pointer events. Note that in this scenario, except if you are working on a “Drawing” part, the recognition engine will automatically process the new strokes. This approach is documented in the Editing part of this guide.

## Exporting content

### Make sure that recognition is complete

Recognition can sometimes take a certain time to complete, especially if you send many strokes to the editor at once.

If you want to make sure that you export the final recognition results, you have to call waitForIdle() before export_().

### Select what you want to export

Export operations are made on content blocks. For instance, this allows you to export a specific diagram from a Text Document part).

You can retrieve the list of supported export mime types for a given block by calling getSupportedExportMimeTypes() on the editor:

MimeType[] supportedMimeTypes = editor.getSupportedImportMimeTypes(block);

To export content, call the export_() method of the editor object, passing it the block to export and the desired mime type:

// Export a math block to MathML
String result = editor.export_(mathBlock, MimeType.MATHML);
// Export a text document to docx
editor.export_(textDocBlock, new File("export.docx"), MimeType.DOCX, imageDrawer);

The API provides a convenience method that lets you omit the mime type if iink SDK is able to guess it unambiguously from the file extension:

// Export a text document to docx
editor.export_(block, new File("export.docx"), imageDrawer);
You can call the getFileExtensions() to get the extensions supported for a given mime type.

### Image drawer

Certain formats require you to provide an object implementing the IImageDrawer interface to let iink SDK generate images from the content. This is expectedly the case for png and jpeg exports, but also for formats such as docx.

A default, ready-to-use, image drawer implementation is provided by MyScript as part of the UI Reference Implementation.

If the format does not require an image drawer, you can provide the export method with a null pointer instead.

To know which formats require an image drawer, refer to this page.

### Textual vs. binary exports

Textual format exports are returned as a string that can then be programmatically manipulated. Binary formats, on the other hand, are saved as files on the disk at a location you can specify.

IImageDrawer imageDrawer = new ImageDrawer();
editor.export_(editor.getRootBlock(), new File("out/export.docx"), imageDrawer);

You can call the isTextual() method of a MimeType object to know whether a format is textual or binary.

### Apply a specific configuration

Some export functions let you temporarily “override” the current editor configuration for the need of a specific export. This is useful if you want to tune the export parameters (like the type of information to export to JIIX) without impacting your global or your editor configurations.

The following example shows how you can export a block recognition result as JIIX without including original ink information:

// Create an empty parameter set
ParameterSet params = engine.CreateParameterSet();
// Set the appropriate configuration to exclude strokes from the export
params.setBoolean("export.jiix.strokes", false);
// Export a block with the new configuration
String jiix = editor.export_(block, MimeType.JIIX, params);

## Supported imports/exports

### Exchange format

Interactive Ink SDK defines its own format, called JIIX (short for JSON Interactive Ink eXchange format).

This format provides a consistent representation of the different types of content that are supported, covering semantics, positions, styling and ink-related aspects.

Thanks to its JSON syntax, it stays readable and can be easily parsed, making it appropriate to exchange information with the host application or as a transitory representation to support custom export formats.

The complete JIIX reference can be found here.

### Other formats

Interactive Ink SDK allows you to import and export some commonly used formats, such as LaTeX for math content or Docx in the case of Text Document blocks.

The full list can be found here.

## Back to the example

For the calculator example, you already wrote some code that could let you save the history to the part metadata and retrieve it later. Let’s now see how you can populate the history string list using the export functionality.

Here, you will want to append a new item to the history after each computation that result in a new state (pressing “=” several times will just register a single state). You can thus improve the solve() method:

public void solve(TreeSet<String> history)
{
// ... Do the conversion ...

// Add the item to the history if there was a change
String latexStr = editor.export_(editor.getRootBlock(), MimeType.LATEX);
if (latexStr != null && !latexStr.equals("") && (history.isEmpty()  || history.last() != latexStr))
}