Interface ExportSVGOutputFormatInterface

The ExportSVGOutputFormatInterface interface defines the output format of a SVG export procedure called by DataSessionInterface.exportSVG.

• outputs is used to create multiple images at once with a list of ExportSVGOutputFormatInterfaceItem (at least one).
• filename is used to set the global filename of the export procedure.

/** 
 * Sample to illustrate the use of a SVG export procedure.
 */
import {
    DataSessionInterface, WorkingSetInterface, ExportJobInterface, ExportJobInterfaceSignal, InfiniteError, InfiniteEvent,
    InfiniteEngineInterface, Vector2, ExportSVGOutputFormat
} from 'generated_files/documentation/appinfiniteapi';

// the DataSessionInterface has been created previously and is connected
let lDataSession: DataSessionInterface;
// the working set to export as a svg image
let lWorkingSetToExport : WorkingSetInterface;
// the export job to monitor
let lExportJob : ExportJobInterface | undefined = undefined;
// the infinite engine in use, created previously
let lInfiniteEngine: InfiniteEngineInterface;

// the file to download
// In this test, we will only download one file
let lFileOffset : number = -1;

// triggers a save file from the browser
const onDownloadReady = (pUrl : string) : void => {
    const downloadLink = document.createElement('a');
    downloadLink.target = '_blank';
    // set object URL as the anchors href
    downloadLink.href = pUrl;
    // append the anchor to document body
    document.body.appendChild(downloadLink);
    // fire a click event on the anchor
    downloadLink.click();
    // cleanup: remove element and revoke object URL
    downloadLink.remove();
};

const startExportProcedure = () : boolean =>
{
    // will will try to export as svg
    lExportJob = lDataSession.exportSVG(
        [{ workingSet: lWorkingSetToExport }],
        {
            type: 'exportSVGOutputFormat',
            outputs: [
                {
                    // the name inside the screenshot procedure, as multiple viewpoint may
                    // be set, in this case this is useless
                    itemName: 'svg_screenshot',
                    // the page size in mm (A4 here)
                    pageSize: new Vector2(210, 287),
                    // camera parameters
                    viewpoint: lInfiniteEngine.getCameraManager().toJSON(),
                    // SVG file format
                    dataFormat: ExportSVGOutputFormat.EOF_SVG
                }
            ],
            // filename without extension
            filename: 'test'
        }
    );
    // sanity check
    if(lExportJob === undefined)
    {
        return false;
    }
    lExportJob.addEventListener(ExportJobInterfaceSignal.ExportJobFinished, (pEvent : InfiniteEvent) : void =>
    {
        // only get the URL if no error
        const lError : InfiniteError | undefined = lExportJob.getLastError();
        if(lError === undefined && (lFileOffset === -1))
        {
            lFileOffset = pEvent.attachments;
            if(lExportJob.isExportSuccess(lFileOffset))
            {
                // trigger the URL computing
                if(!lExportJob.computeDownloadURL(lFileOffset))
                {
                    console.log('Export job failed');
                }
            }
        }
    });
    // URL will be ready
    lExportJob.addEventListener(ExportJobInterfaceSignal.ExportJobURLReady, () : void =>
    {
        const lUrl : string | undefined = lExportJob.getDownloadURL(lFileOffset);
        // sanity check
        if(lUrl === undefined)
        {
            console.log('Export job failed');
            return;
        }
        // trigger the download from the browser
        onDownloadReady(lUrl);
    });
    return true;
};

startExportProcedure();

Copy

or asynchronously :

/** 
 * Sample to illustrate the asynchronous use of a SVG export procedure.
 */
import {
    DataSessionInterface, WorkingSetInterface, ExportJobInterface, AsyncResultReason,
    Vector2, InfiniteEngineInterface, ExportSVGOutputFormat
} from 'generated_files/documentation/appinfiniteapi';

// the DataSessionInterface has been created previously and is connected
let lDataSession: DataSessionInterface;
// the working set to export as a svg image
let lWorkingSetToExport : WorkingSetInterface;
// the export job to monitor
let lExportJob : ExportJobInterface | undefined = undefined;
// the infinite engine in use, created previously
let lInfiniteEngine: InfiniteEngineInterface;

// triggers a save file from the browser
const onDownloadReady = (pUrl : string) : void => {
    const downloadLink = document.createElement('a');
    downloadLink.target = '_blank';
    // set object URL as the anchors href
    downloadLink.href = pUrl;
    // append the anchor to document body
    document.body.appendChild(downloadLink);
    // fire a click event on the anchor
    downloadLink.click();
    // cleanup: remove element and revoke object URL
    downloadLink.remove();
};

const startExportProcedure = async () : Promise<boolean> =>
{
    // will will try to export as svg
    lExportJob = lDataSession.exportSVG(
        [{ workingSet: lWorkingSetToExport }],
        {
            type: 'exportSVGOutputFormat',
            outputs: [
                {
                    // the name inside the screenshot procedure, as multiple viewpoint may
                    // be set, in this case this is useless
                    itemName: 'svg_screenshot',
                    // the page size in mm (A4 here)
                    pageSize: new Vector2(210, 287),
                    // camera parameters
                    viewpoint: lInfiniteEngine.getCameraManager().toJSON(),
                    // SVG file format
                    dataFormat: ExportSVGOutputFormat.EOF_SVG
                }
            ],
            // filename without extension
            filename: 'test'
        }
    );
    // sanity check
    if(lExportJob === undefined)
    {
        return false;
    }
    // wait for file count to be known
    const lWaitForFileCount : AsyncResultReason = await lExportJob.asyncWaitForFileCount();
    if(lWaitForFileCount !== AsyncResultReason.ARR_Success)
    {
        return false;
    }
    const lNbFiles: number = lExportJob.getFileCount();
    console.log('The export procedure consists in ' + lNbFiles + ' files');
    if(lNbFiles < 1)
    {
        // not enough files ?
        // => should not happen
        return false;
    }
    // wait for everything to be computed
    // we could have waited for a specific file with an asyncWaitForFinished(item)
    const lExportResult : AsyncResultReason = await lExportJob.asyncWaitForFinished();
    if(lExportResult !== AsyncResultReason.ARR_Success)
    {
        return false;
    }
    // file is ready
    // claim for a download url for file 0
    console.log('retrieving file ' + lExportJob.getFilename(0));
    await lExportJob.asyncGetDownloadURL(0);
    const lUrl : string | undefined = lExportJob.getDownloadURL(0);
    if(lUrl === undefined)
    {
        return false;
    }
    // trigger a download of the file
    onDownloadReady(lUrl);
    return true;
};

startExportProcedure();

Copy

Please make sure the destination browser supports promises before using async calls.

See

• ExportJobInterface
• DataSessionInterface.exportSVG