Skip Headers
Oracle® Outside In Transformation Server Developer's Guide
Release 8.3.7

Part Number E12868-02
Go to Documentation Home
Home
Go to Table of Contents
Contents
Go to Index
Index
Go to Feedback page
Contact Us

Go to previous page
Previous
Go to next page
Next
View PDF

8 Upgrading Applications to Use Transformation Server

This is a guide to incorporating Transformation Server, using its C language client module (SCCTS) into applications that already use the embedded version of the Outside In Export technologies (the SCCEX and SCCDA modules).

This document assumes that the reader is familiar with the Outside In API.

8.1 Basic Transformation Operations

These are the basic tasks involved in updating an application from the embedded Outside In Export APIs to the Transformation Server APIs:

  1. Configure the application to link with SCCTS instead of SCCEX and sccda.

  2. Replace calls to DAInit and DADeinit with calls to TSInit and TSDeinit.

  3. Most calls to DASetOption can be updated by calling TSSetOptionById with identical parameters. Some exceptions to this rule (including DASetFileSpecOption) will be documented below.

  4. Replace callback function with additional calls to TSSetOption or TSSetOptionById.

  5. Replace call to EXRunExport with call to TSRunTransform.

8.2 Initialization and De-initialization

The functions DAInit and DADeinit can just be replaced with calls to TSInit and TSDeinit.

TSInit should be called upon loading SCCTS. It needs to be called only once per process. However, in situations where TSInit is called multiple times, only the first call causes it to initialize. Subsequent calls are ignored, but are counted by an internal reference counter. Therefore, each call to TSInit must be balanced by a corresponding call to TSDeinit. The last call to TSDeInit causes sccts to actually de-initialize.

Unlike DAInit, TSInit requires some parameters be provided. These parameters specify where Transformation Server can be found.

Embedded Version

if( DAERR_OK == DAInit() )
    ; /* everything is OK */

C Client Version

/* Assuming transformation server is listening for requests
   on port 999 of the local host (IP address 127.0.0.1) */
TSINITPARAMS2 tsinit = {0};
tsinit.dwVersion    = SCCTS_INITPARAMS_CURRENTVERSION;
tsinit.szServer     = "127.0.0.1"; /* hostname */
                                      IP address of where client side
                                      redirected IO is taking place,
                                      needed only when source or sink uses
                                      redirected IO. (null terminated) */
init.wPort        = 999;
tsinit.openIO       = NULL;        /* points to redirected IO 
                                   /* open */
tsinit.wIOPort      = 0;           /* function used when */
                                   /* providing redirected IO */

if( TSERR_OK = TSInit(&tsinit) )
    ;  /* everything is OK */

TSDeinit should be called immediately prior to unloading SCCTS, or upon application exit. Like DADeinit, it requires no parameters. It can be simply swapped for existing calls to DADeinit.

8.3 Setting Transformation Parameters

This section describes transformation parameters.

8.3.1 Options

The following information concerns options.

8.3.1.1 Replacing the Document Handle with an "Option Set Handle"

In the embedded versions of the Outside In Export interfaces, options are tied to a "document handle" – an identifier returned from DAOpenDocument that tells the Export module to which input document the options should apply. The Transformation Server C client presents a different model: the input document is not "opened" in any way prior to initiating a transformation; and transformation options are grouped together in an "option set" that may be applied to more than one input document.

Embedded Version

VTHDOC hDoc;     /* document handle */
DAERR deResult ; /* result code*/
deResult = DAOpenDocument(
    &hDoc,                     /* receives handle to document */
    IOTYPE_ANSIPATH,           /* type of path to file */
    (VTLPVOID) pInputPath,     /* input file */
    0);                        /* flags */
/* when the document no longer needs to be open */
DACloseDocument(hDoc);

C Client Version

TSOPTIONS hOpt;     /* option set handle */
TSERR     tsResult; /* result code */
tsResult = TSOpenOptions (
    NULL,    /* name of option set (null term. string or NULL)*/
    &hOpt ); /* receives handle to option set */
/* when the options are no longer needed */
TSCloseOptions(hOpt);

8.3.1.2 Setting Options

The SCCTS module includes a function called TSSetOptionById that supports most of the data structures and option identifiers that were used in the embedded interface function DASetOption. Apart from their names, the functions differ only in the first parameter, which controls how the options are collected (with a "document handle" vs. an "option set handle").

Most options that affect a transformation can be specified with the same data types that were used in the interface to SCCEX. For these options, simply replace the VTHDOC parameter with a TSOPTIONS parameter, and call TSSetOptionById instead of DASetOption. The following is an example:

Embedded Version

DAERR deResult; /* result code*/
DWORD dwVal = FI_GIF;
    deResult = DASetOption( hDoc, SCCOPT_GRAPHIC_TYPE,
        (LPVOID)&dwVal, sizeof(DWORD));

C Client Version

TSERR tsResult; /* result code */
DWORD dwVal = FI_GIF;
    tsResult = TSSetOptionById( hOpt, SCCOPT_GRAPHIC_TYPE,
        (LPVOID)&dwVal, sizeof(DWORD));

8.3.1.3 Exceptions to This Rule (HTML Export Only)

The option SCCOPT_EX_TEMPLATE, which identifies the template to be used when producing output documents, must be specified with a different data type than it was in the embedded API.

In the embedded API this option was specified via a special function called DASetFileSpecOption. In the C client API the template location is described in a TS_IOSpec data structure, which is specified through the TSSetOptionById function. As a result of this difference, the C client uses a different identifier, defined as SCCOPT_TS_TEMPLATE, that is specific to the C client. Any attempt to specify an option identified as SCCOPT_EX_TEMPLATE will fail.

Embedded Version

deResult = DASetFileSpecOption( hDoc, SCCOPT_EX_TEMPLATE,
    IOTYPE_ANSIPATH, "\\exports\templates\template.html" );

C Client Version

TS_IOSpec template;
    template.spec.str = "\\exports\templates\template.html";
    template.spec.charset = ts_windows_1252;
    template.specType = "path";
    tsResult = TSSetOptionById( hOpt, SCCOPT_TS_TEMPLATE,
        (LPVOID)&template, sizeof(TS_IOSpec));

8.3.2 Callbacks

The caller-supplied callback function that was defined in the embedded API does not exist for the Transformation Server C Client API. Where possible, the callback messages have been replaced by new options with equivalent functionality. In other cases, the functionality represented by callback messages is supported in a limited form or not supported by the C Client API. The following sections offer explanations for how each embedded API callback message is supported in the C Client API.

8.3.2.1 EX_CALLBACK_ID_CREATENEWFILE

This functionality represented by this callback has been distributed to different areas of the client API. This callback existed to notify the calling application when a new output file was about to be created, allowing the application to change the both the name and the hyperlink (URL) used to reference the file in the transformation output.

For an application using Transformation Server's built-in input and output facilities, the ability to change the names of the output file or its URL will not be supported in the Transformation Server client. For applications that provide their own IO through the redirected IO interface, this callback's functionality will be supported through the IOGetInfo messages IOGETINFO_CREATENEWOUTPUTSPEC (and IOGETINFO_HYPERLINK for HTML Export). For details, please refer to the documentation for redirected IO.

The reporting capabilities of this message are provided by the results of the TSRunTransform function, which provides an array containing the specifications of all output files created for the transformation.

8.3.2.2 EX_CALLBACK_ID_NEWFILEINFO

The reporting capabilities of this message are provided by the results of the TSRunTransform function, which provides an array containing the specifications of all output files created for the transformation.

8.3.2.3 EX_CALLBACK_ID_ALTLINK (HTML Export Only)

This callback's functionality has been replaced by a new option: SCCOPT_TS_ALTLINK. This option is specified as a data structure (OIT_AltLink) containing two TS_stringData structures, one for the "previous" and one for the "next" alt links.

Embedded Version

case EX_CALLBACK_ID_ALTLINK:
{
   EXALTLINKCALLBACKDATA *pData = 
      (EXALTLINKCALLBACKDATA*)pCommandOrInfoData;
   result = SCCERR_NOTHANDLED;

   if( pData->dwType == EX_ALTLINK_PREV )
   {
      lstrcpy(pData->pAltURLStr, "alternate prev-page link");
      result = SCCERR_OK;   
   }
   else if( pData->dwType == EX_ALTLINK_NEXT )
   {
      lstrcpy(pData->pAltURLStr, "alternate next-page link");
      result = SCCERR_OK;   
   }
}
break;

C Client Version

HWX_AltLink   altLinks;
altLinks.prev.str = "alternate prev-page link";
altLinks.prev.charset = ts_windows_1252;
altLinks.next.str = "alternate next-page link";
altLinks.next.charset = ts_windows_1252;

TSSetOptionById( hOpt, SCCOPT_TS_ALTLINK, (VTLPVOID)&altLinks, 
   sizeof(HWX_AltLink);

8.3.2.4 EX_CALLBACK_ID_PROCESSLINK (HTML Export Only)

This functionality represented by this callback message has limited support in Transformation Server. While the option to insert alternate links is not available, the basic ability to skip or process linked graphics is presented as a Boolean option with the identifier SCCOPT_TS_SKIPLINKEDIMAGES. This option allows the calling application to specify that linked files should be either transformed or skipped.

C Client Example

VTBOOL   bSkipLinkedImages = TRUE;
TSSetOptionById( hOpt, SCCOPT_TS_SKIPLINKEDIMAGES,
   &bSkipLinkedImages, sizeof(VTBOOL) );

8.3.2.5 Unsupported Callbacks

The functionality represented by the following embedded API callback messages is not supported on the Transformation Server client side:

  • EX_CALLBACK_ID_CUSTOMELEMENTLIST

  • EX_CALLBACK_ID_GRAPHICEXPORTFAILURE

  • EX_CALLBACK_ID_OEMOUTPUT

  • EX_CALLBACK_ID_OEMOUTPUT_VER2

  • EX_CALLBACK_ID_PROCESSELEMENTSTR

  • EX_CALLBACK_ID_PROCESSELEMENTSTR_VER2

  • EX_CALLBACK_ID_REFLINK

  • EX_CALLBACK_ID_ENTERARCHIVE

  • EX_CALLBACK_ID_LEAVEARCHIVE

8.4 Performing a Transformation

This information pertains to performing transformations.

8.4.1 Specifying Inputs and Outputs with TS_IOSpec

The input and output documents for a transformation (also referred to as the "source" and "sink", respectively) are specified by a new data structure named TS_IOSpec.

typedef struct TS_IOSpec
{
   TS_stringData spec;    /* specifies the "path" of the doc */
   XSD_string specType;   /* specifies the type of path being 
                       /* specified */
} TS_IOSpec;

The specification of the IO target itself is described by another new data structure, TS_stringData, which has this definition:

typedef struct TS_stringData
{
   TS_char* str;                     /* contents of string */
   enum TS_CharacterSetEnum charset; /* char. set of string */
} TS_stringData;

The specType field of TS_IOSpec is analogous to the embedded API's IOTYPE identifiers, but is stricter in its definition: it describes whether the specification is of a file-system path, a URL, a redirected IO type, or some custom IO type. It does not imply anything about how that specification is encoded.

Examples

TS_IOSpec   input;   /* specifying a file path */
   input.spec.str = "c:\documents\important stuff.doc";
   input.spec.charset = ts_windows_1252;
   input.specType = "path";

TS_IOSpec output;    /* specifying a url */
   output.spec.str = 
      "http://intranet.company.com/docs/important.htm";
   output.spec.charset = ts_windows_1252;
   output.specType = "url";

TS_IOSpec moreInput; /* specifying a redirected IO source */
   moreInput.spec.str = "app.customDATABASE:r244.field8";
   moreInput.spec.charset = ts_windows_1252;
   moreInput.spec.specType = "redirect";

8.4.2 Initiating the Transformation

Once all of the transformation options have been specified, the calling application may now trigger a transformation operation. This is done by replacing the call to EXRunExport with a call to TSRunTransform.

Embedded Version

deResult = EXRunExport( hDoc, ... )

C Client Version

TS_IOSpec input, output;
TSERR tsResultCode;
TSOPTIONS hOpt;
TS_TransformResult * pResults;
/* ... initialize options, input and output specs ... */
   tsResultCode = TSRunTransform(
   &input,    /* source document */
   &output,   /* sink (output) document */
   "html",    /* desired output format */
   NULL,      /* named option set on server (may be NULL) */
   hOpt,      /* option set handle (may be NULL) */
   &pResults  /* data describing results of transformation */
   );

It should also be noted that the data returned in the TS_TransformResult pointer must be freed by the calling application. This is done through a single call to TSMemFree:

if( pResults )
{
   /* make use of the results, then dispose of them... */
   TSMemFree(pResults);
}

8.4.3 Inspecting the Results

In addition to the numeric error code returned from TSRunTransform, a data structure, TS_TransformResult, is also filled in that provides a human-readable result message and a list of the output documents created by the transformation. The TS_TransformResult data structure has the following definition:

typedef struct TS_TransformResult
{
    TSERR          resultCode;   /* numeric error code, same as
                                 return value from
                                 TSRunTransform */
    TS_stringData  resultString; /* descriptive text for result;
                                 may be empty. */
    TS_OutputList  outputList;   /* contains list of IO specs
                                 for transformation output; may
                                 be empty if error occurred. */
} TS_TransformResult;

This data structure makes use of another data structure, TS_OutputList:

typedef struct TS_OutputList
{
   TS_IOSpec *  documents;        /* array of output document
                                  specifications */
   XSD_unsignedInt size;       /* number of items in the array */
} TS_OutputList;

8.5 Advanced Transformation Operations

This section pertains to advanced transformation options.

8.5.1 Handling Redirected IO

Like the embedded version of the Outside In Export API, Transformation Server supports extension of its IO facilities, through a method we call "redirected IO." If your application has implemented redirected IO, you'll find that most of your code will not have to be changed, though it may need to be reorganized a little bit.

8.5.1.1 Server-Side vs. Client-Side Redirected IO

As a client-server application, Transformation Server runs its transformation operations in a separate process from the "client" application that uses it. For maximum flexibility, Transformation Server allows redirected IO to be provided on either the server side or the client side. In other words, the code that provides the IO may execute in the process of the client application or in the process where the transformation occurs. From an implementation point of view, there is little to no difference between the two approaches; it is entirely possible to use the same binary code to provide redirected IO on both the client and server.

As in the embedded API, an application that provides redirected IO must implement the functions defined in the BASEIO interface. In client-side redirected IO, the C client API communicates through TCP/IP with the server-side transformation process, and relays IO operations to the BASEIO interface provided by the application. In server-side redirected IO, the application provides its redirected IO code in a dynamically loadable library that is loaded by the transformation process as needed. Communication with the redirected IO code then proceeds in-process as the transformation is being performed.

While the server-side redirected IO may require a small amount of additional work when compared to client-side redirected IO, it has a significant performance advantage in the fact that all IO occurs in-process. Client-side IO, on the other hand, has the ability to communicate in-process with the client application that is requesting the transformation, which may be a requirement for retrieving or writing the data.

8.5.1.2 What's Different About Redirected IO in Transformation Server

From an implementation point of view, the main differences between redirected IO in Transformation Server versus the embedded API are:

  1. How the IO "targets" are specified in the API.

  2. How IOGetInfo queries are handled.

8.5.1.2.1 Specifying IO Targets

In the embedded API, the application provides the Outside In Export module with a pointer to a BASEIO structure that contains pointers to all of the IO functions that will be used to access one specific target. Transformation Server, however, requires that applications specify IO targets with an IO specification in the same manner that file-system documents are specified. The application must then also provide an "open" function that is used by Transformation Server to obtain a BASEIO structure from the IO specification.

Here's how IO targets are specified using the embedded API:

struct myIOStruct 
{
   BASEIO   baseIO;
   MYDATA   privateData;
};
/* ... initialize myIOStruct ...*/
EXRunExport( hDoc, (HIOFILE) &myIOStruct, FI_HTML, ... )

In the server API, specifying an IO target is a two-step process:

  1. Specifying an IO target:

    TS_IOSpec   input;
    input.spec.str = "my.private.IO.specification";
    input.spec.charset = ts_UTF_8;
    input.specType = "redirect";  /* this value is required for */
                                  /* specType on the client side */
    
  2. Resolving the IO target:

    TSERR OpenIO( TS_IOSpec *pSpec, DWORD dwFlags, 
       IOConsumerInterface *pConsumer, BASEIO *pIOResults )
    {
       struct myIOStruct theIOStruct;
       /* inspect contents of pSpec to determine your IO target */
       /* inspect dwFlags for read/write/create options */
       /* initialize theIOStruct */
       *pIOResults = theDoc;
       return TSERR_OK;
    }
    

This approach to redirected IO is what allows the code that provides redirected IO to execute on the server side as well as the client.

8.5.1.2.2 IOGetInfo Messages

The IOGetInfo function has defined some new messages and redefined some existing ones, to accommodate the differences between the embedded architecture and the Transformation Server architecture. The Redirected IO portion of this manual gives the detailed description of what is required of your IOGetInfo function, but some of the chief differences are:

  1. The use of the callback query SCCEX_CALLBACK_CREATENEWFILE has been replaced with IOGetInfo the queryies IOGETINFO_CREATENEWIOSPEC (and IOGETINFO_HYPERLINK for HTML Export).

  2. The IOGetInfo queries IOGETINFO_PATHNAME, IOGETINFO_FILENAME, and IOGETINFO_GENSECONDARY_IOP have been replaced with new versions that use the Transformation Server's TS_stringData structure to provide unambiguous string and character set information.

8.5.1.3 Redirected IO on the Client Side

The following steps are necessary to take an existing implementation of redirected IO and make it available to the Transformation Server C Client API.

  1. Define a way to represent an IO target in a text string that can be passed in a TS_IOSpec structure.

  2. Implement an OpenIO function that maps from TS_IOSpec to your BASEIO structure.

  3. Modify your IOGetInfo function to handle the new Transformation Server style queries.

  4. Provide the pointer to your OpenIO function in the initialization structure passed to TSInit.

8.5.1.4 Redirected IO on the Server Side

To make redirected IO available on the server side, perform steps 1 through 3 above, and then do the following:

  1. Build your redirected IO code into a loadable module/DLL, with OpenIO specified as an exported function.

  2. Modify the Transformation Server configuration file agent_iospec_types.xml to indicate the location of your IO module.

In the preceding step, you must also define an IO spec type for your module (the specType field in the TS_IOSpec structure). Note that the specType value redirect is reserved for client-side redirected IO, and will not work for a server-side IO provider.

Note that these two approaches are not mutually exclusive. There's no reason an IO Provider built for server-side redirected IO couldn't be used on the client side, as well.

8.6 How Embedded API Options Map to the New SOAP Options

The following table shows how the option names from the embedded technology map to the new option names used by the SOAP interface in Transformation Server. Embedded API options which do not have a corresponding option in the SOAP API are marked as "NA".

For details about the options discussed here, see the Options documentation for your system.

8.6.1 XML Export

This information pertains to XML Export.

Embedded API SOAP API
SCCOPT_ACCEPT_ALT_GRAPHICS acceptAlternateGraphics
SCCOPT_CCFLEX_FORMATOPTIONS Each of the flags in the embedded option has a matching, stand-alone Boolean option in the SOAP API:
charMappingBoth
charMappingText
charMappingNone
charMappingDefault
convertChartObjects
convertDateTimeProperties
convertImageObjects
convertPresentationObjects
convertVectorObjects
delimiters
flattenStyles
generateSystemData
noBitmapElements
noChartElements
noPresentationElements
noVectorElements
removeCurrentPoint
separateStyleTables
useFullFilePath
SCCOPT_CCFLEX_INCLUDETEXTOFFSETS includeTextOffsets
SCCOPT_CCFLEX_REMOVEFONTGROUPS removeFontGroups
SCCOPT_DEFAULTINPUTCHARSET defaultInputCharset
SCCOPT_EX_CALLBACKS NA
SCCOPT_EX_UNICODECALLBACKSTR NA
SCCOPT_EXXML_DEF_METHOD xmlDefinitionMethod
SCCOPT_EXXML_DEF_REFERENCE xmlDefinitionLocation
SCCOPT_EXXML_SUBSTREAMROOTS subStreamRoots
SCCOPT_FALLBACKFORMAT fallbackFormat
SCCOPT_FIFLAGS extendedTestForText
SCCOPT_FILTERJPG allowJPEG
SCCOPT_FILTERLZW allowLZW
SCCOPT_FORMATFLAGS isoDateTimes
SCCOPT_GIF_INTERLACED graphicGifInterlaced
SCCOPT_GRAPHIC_HEIGHTLIMIT graphicHeightLimit
SCCOPT_GRAPHIC_OUTPUTDPI graphicOutputDPI
SCCOPT_GRAPHIC_SIZELIMIT graphicSizeLimit
SCCOPT_GRAPHIC_SIZEMETHOD graphicSizeMethod
SCCOPT_GRAPHIC_TYPE graphicType
SCCOPT_GRAPHIC_WIDTHLIMIT graphicWidthLimit
SCCOPT_IO_BUFFERSIZE Each of the flags in the embedded option has a matching, stand-alone option in the SOAP API:
readBufferSize
memoryMappedInputSize
tempBufferSize
SCCOPT_JPEG_QUALITY graphicJpegQuality
SCCOPT_RENDERING_PREFER_OIT preferOITRendering
SCCOPT_REORDERMETHOD reorderMethod
SCCOPT_TEMPDIR NA
SCCOPT_TIMEZONE timezone
SCCOPT_UNMAPPABLECHAR unmappableCharacter
SCCOPT_XML_DEF_METHOD xmlDefinitionMethod
SCCOPT_XML_DEF_REFERENCE xmlDefinitionLocation

8.6.2 PDF Export

This information pertains to PDF Export.

Embedded API SOAP API
SCCOPT_APPLYFILTER applyZLIB
SCCOPT_DBPRINTFITTOPAGE databaseFitToPage
SCCOPT_DBPRINTGRIDLINES databaseShowGridLines
SCCOPT_DBPRINTHEADINGS databaseShowHeadings
SCCOPT_DEFAULTINPUTCHARSET defaultInputCharset
SCCOPT_DEFAULTPRINTFONT defaultFont
SCCOPT_DEFAULTPRINTMARGINS defaultMargins
SCCOPT_ENABLEWATERMARK enableWatermark
SCCOPT_EX_CALLBACKS NA
SCCOPT_DEFAULTPAGESIZE The functionality of this option is supported by three options in the server implementation:
defaultPageUnits
defaultPageHeight
defaultPageWidth
SCCOPT_DOLINEARIZATION doLinearization
SCCOPT_EMBEDFONTS embedFonts
SCCOPT_EX_UNICODECALLBACKSTR NA
SCCOPT_FALLBACKFORMAT fallbackFormat
SCCOPT_FIFLAGS extendedTestForText
SCCOPT_FILTERJPG allowJPEG
SCCOPT_FILTERLZW allowLZW
SCCOPT_FONTDIRECTORY fontDirectory
SCCOPT_FONTFILTER The functionality of this option is handled by two options in the server implementation:
excludeFont
includeFont
SCCOPT_FORMATFLAGS isoDateTimes
SCCOPT_GRAPHIC_OUTPUTDPI graphicOutputDPI
SCCOPT_GRAPHIC_SIZEMETHOD graphicSizeMethod
SCCOPT_IO_BUFFERSIZE Each of the flags in the embedded option has a matching, stand-alone option in the SOAP API:
readBufferSize
memoryMappedINputSize
tempBufferSize
SCCOPT_MAXSSDBPAGEHEIGHT maxSsDbPageHeight
SCCOPT_MAXSSDBPAGEWIDTH maxSsDbPageWidth
SCCOPT_PRINTENDPAGE endPage
SCCOPT_PRINTFONTALIAS fontAlias
SCCOPT_PRINTSTARTPAGE startPage
SCCOPT_RENDERING_PREFER_OIT preferOITRendering
SCCOPT_REORDERMETHOD reorderMethod
SCCOPT_SSPRINTDIRECTION spreadsheetPageDirection
SCCOPT_SSPRINTFITTOPAGE spreadsheetFitToPage
SCCOPT_SSPRINTGRIDLINES spreadsheetShowGridLines
SCCOPT_SSPRINTHEADINGS spreadsheetShowHeadings
SCCOPT_SSPRINTSCALEPERCENT spreadsheetScalePercentage
SCCOPT_SSPRINTSCALEXHIGH spreadsheetScaleXPagesHigh
SCCOPT_SSPRINTSCALEXWIDE spreadsheetScaleXPagesWide
SCCOPT_TEMPDIR NA
SCCOPT_TIMEZONE timezone
SCCOPT_UNMAPPABLECHAR unmappableCharacter
SCCOPT_USEDOCPAGESETTINGS useDocumentPageSettings
SCCOPT_WATERMARKIO The functionality of this option is supported by three options in the server implementation:
watermarkImage
watermarkScaling
watermarkScalePercent
SCCOPT_WATERMARKPOSITION watermarkPosition
SCCOPT_WHATTOPRINT usePageRange

8.6.3 Image Export

This information pertains to Image Export.

Embedded API SOAP API
SCCOPT_DBPRINTFITTOPAGE databaseFitToPage
SCCOPT_DBPRINTGRIDLINES databaseShowGridLines
SCCOPT_DBPRINTHEADINGS databaseShowHeadings
SCCOPT_DEFAULTINPUTCHARSET defaultInputCharset
SCCOPT_DEFAULTPRINTFONT defaultFont
SCCOPT_DEFAULTPRINTMARGINS defaultMargins
SCCOPT_EX_CALLBACKS NA
SCCOPT_EX_UNICODECALLBACKSTR NA
SCCOPT_FALLBACKFORMAT fallbackFormat
SCCOPT_FIFLAGS extendedTestForText
SCCOPT_FILTERJPG allowJPEG
SCCOPT_FILTERLZW allowLZW
SCCOPT_FORMATFLAGS isoDateTimes
SCCOPT_GIF_INTERLACED graphicGifInterlaced
SCCOPT_GRAPHIC_CROPPING graphicCropping
SCCOPT_GRAPHIC_HEIGHT graphicHeight
SCCOPT_GRAPHIC_HEIGHTLIMIT graphicHeightLimit
SCCOPT_GRAPHIC_OUTPUTDPI graphicOutputDPI
SCCOPT_GRAPHIC_SIZELIMIT graphicSizeLimit
SCCOPT_GRAPHIC_SIZEMETHOD graphicSizeMethod
SCCOPT_GRAPHIC_TRANSPARENCYCOLOR graphicTransparencyColor
SCCOPT_GRAPHIC_WIDTH graphicWidth
SCCOPT_GRAPHIC_WIDTHLIMIT graphicWidthLimit
SCCOPT_IMAGEX_TIFFOPTIONS tiffOptions
SCCOPT_IO_BUFFERSIZE Each of the flags in the embedded option has a matching, stand-alone option in the SOAP API:
readBufferSize
memoryMappedInputSize
tempBufferSize
SCCOPT_JPEG_QUALITY graphicJpegQuality
SCCOPT_MAXSSDBPAGEHEIGHT maxSsDbPageHeight
SCCOPT_MAXSSDBPAGEWIDTH maxSsDbPageWidth
SCCOPT_PRINTENDPAGE endPage
SCCOPT_PRINTFONTALIAS fontAlias
SCCOPT_PRINTSTARTPAGE startPage
SCCOPT_RENDERING_PREFER_OIT preferOITRendering
SCCOPT_REORDERMETHOD reorderMethod
SCCOPT_SSPRINTDIRECTION spreadsheetPageDirection
SCCOPT_SSPRINTFITTOPAGE spreadsheetFitToPage
SCCOPT_SSPRINTGRIDLINES spreadsheetShowGridLines
SCCOPT_SSPRINTHEADINGS spreadsheetShowHeadings
SCCOPT_SSPRINTSCALEPERCENT spreadsheetScalePercentage
SCCOPT_SSPRINTSCALEXHIGH spreadsheetScaleXPagesHigh
SCCOPT_SSPRINTSCALEXWIDE spreadsheetScaleXPagesWide
SCCOPT_TEMPDIR NA
SCCOPT_TIMEZONE timezone
SCCOPT_UNMAPPABLECHAR unmappableCharacter
SCCOPT_USEDOCPAGESETTINGS useDocumentPageSettings
SCCOPT_WHATTOPRINT usePageRange
SCCOPT_WPEMAILHEADEROUTPUT emailHeader

8.6.4 Search Export

This information pertains to Search Export.

Embedded API SOAP API
SCCOPT_DEFAULTINPUTCHARSET defaultInputCharset
SCCOPT_ENABLEALLSUBOBJECTS NA
SCCOPT_EXXML_DEF_METHOD xmlDefinitionMethod
SCCOPT_EXXML_DEF_REFERENCE xmlDefinitionLocation
SCCOPT_FALLBACKFORMAT fallbackFormat
SCCOPT_FIFLAGS extendedTestForText
SCCOPT_FILTERLZW allowLZW
SCCOPT_FORMATFLAGS isoDateTimes
SCCOPT_IO_BUFFERSIZE Each of the flags in the embedded option has a matching, stand-alone option in the SOAP API:
readBufferSize
memoryMappedInputSize
tempBufferSize
SCCOPT_RENDERING_PREFER_OIT preferOITRendering
SCCOPT_TEMPDIR NA
SCCOPT_TIMEZONE timezone
SCCOPT_UNMAPPABLECHAR unmappableCharacter
SCCOPT_XML_DEF_METHOD xmlDefinitionMethod
SCCOPT_XML_DEF_REFERENCE xmlDefinitionLocation
SCCOPT_XML_NULLREPLACECHAR nullReplacementCharacter
SCCOPT_XML_PAGEML_FLAGS Each of the flags in the embedded option has a matching, stand-alone Boolean option in the SOAP API:
textOutOn
xmlDeclarationOff
SCCOPT_XML_PAGEML_PRINTERNAME printerName
SCCOPT_XML_SEARCHML_CHAR_ATTR Each of the flags in the embedded option has a matching, stand-alone Boolean option in the SOAP API:
allCapsOn
boldOn
doubleUnderlineOn
hiddenOn
italicOn
originalCharsetOn
outlineOn
revisionAddOn
revisionDeleteOn
smallCapsOn
strikeoutOn
underlineOn
SCCOPT_XML_SEARCHML_FLAGS Each of the flags in the embedded option has a matching, stand-alone Boolean option in the SOAP API:
cellInfoOn
changeNumbertoTextOn
documentPropertiesOn
embeddingsOn
errorInfoOn
generateSystemData
metadataOnlyOn
paragraphStyleNamesOn
produceURLsOn
revisionsOn
suppressArchiveSubDocsOn
suppressAttachmentsOn
xmlDeclarationOff
SCCOPT_XML_SEARCHML_OFFSET includeTextOffsets
SCCOPT_XML_SEARCHML_PARA_ATTR paragraphAttributes
SCCOPT_XML_SEARCHML_UNMAPPEDTEXT unmappedText

8.6.5 HTML Export

This information pertains to HTML Export.

Embedded API SOAP API
SCCOPT_DEFAULTINPUTCHARSET defaultInputCharset
SCCOPT_DEFAULTPRINTFONT defaultFont
SCCOPT_EX_CALLBACKS NA
SCCOPT_EX_CHANGETRACKING showChangeTracking
SCCOPT_EX_CHARBYTEORDER characterByteOrder
SCCOPT_EX_COLLAPSEWHITESPACE collapseWhiteSpace
SCCOPT_EX_COMPLIANCEFLAGS compliance
SCCOPT_EX_EXTRACTEMBEDDEDFILES extractEmbeddedFiles
SCCOPT_EX_FALLBACKFONT fallbackFont
SCCOPT_EX_FLAVOR flavor
SCCOPT_EX_FONTFLAGS fontFlags
SCCOPT_EX_GENBULLETSANDNUMS genBulletsAndNums
SCCOPT_EX_GRIDADVANCE gridAdvance
SCCOPT_EX_GRIDCOLS gridCols
SCCOPT_EX_GRIDROWS gridRows
SCCOPT_EX_GRIDWRAP gridWrap
SCCOPT_EX_JAVASCRIPTTABS javaScriptTabs
SCCOPT_EX_NOSOURCEFORMATTING noSourceFormatting
SCCOPT_EX_OUTPUTCHARACTERSET outputCharacterSet
SCCOPT_EX_PAGESIZE pageSize
SCCOPT_EX_PREVENTGRAPHICOVERLAP preventGraphicOverlap
SCCOPT_EX_SHOWHIDDENSSDATA showHiddenSpreadsheetData
SCCOPT_EX_SHOWHIDDENTEXT showHiddenText
SCCOPT_EX_SHOWSPREADSHEETBORDER showSpreadsheetBorder
SCCOPT_EX_SIMPLESTYLENAMES simpleStyleNames
SCCOPT_EX_SSDBBORDER spreadsheetBorders
SCCOPT_EX_SSDBROWCOLHEADINGS showSpreadsheetHeadings
SCCOPT_EX_TEMPLATE template
SCCOPT_EX_UNICODECALLBACKSTR NA
SCCOPT_FALLBACKFORMAT fallbackFormat
SCCOPT_FIFLAGS extendedTestForText
SCCOPT_FILTERJPG allowJPEG
SCCOPT_FILTERLZW allowLZW
SCCOPT_FORMATFLAGS isoDateTimes
SCCOPT_GIF_INTERLACED graphicGifInterlaced
SCCOPT_GRAPHIC_HEIGHTLIMIT graphicHeightLimit
SCCOPT_GRAPHIC_OUTPUTDPI graphicOutputDPI
SCCOPT_GRAPHIC_SIZELIMIT graphicSizeLimit
SCCOPT_GRAPHIC_SIZEMETHOD graphicSizeMethod
SCCOPT_GRAPHIC_TRANSPARENCYCOLOR graphicTransparencyColor
SCCOPT_GRAPHIC_TYPE graphicType
SCCOPT_GRAPHIC_WIDTHLIMIT graphicWidthLimit
SCCOPT_IO_BUFFERSIZE Each of the flags in the embedded option has a matching, stand-alone option in the SOAP API:
readBuffermemory
MappedInputSize
tempBufferSize
SCCOPT_JPEG_QUALITY graphicJpegQuality
SCCOPT_PRINTFONTALIAS fontAlias
SCCOPT_RENDERING_PREFER_OIT preferOITRendering
SCCOPT_REORDERMETHOD reorderMethod
SCCOPT_TEMPDIR NA
SCCOPT_TIMEZONE timezone
SCCOPT_UNMAPPABLECHAR unmappableCharacter
SCCOPT_WPEMAILHEADEROUTPUT emailHeader