/**************************************************************************************************

*

* ADOBE SYSTEMS INCORPORATED

* Copyright 2013 Adobe Systems Incorporated

* All Rights Reserved.

*

* NOTICE:  Adobe permits you to use, modify, and distribute this file in accordance with the

* terms of the Adobe license agreement accompanying it.  If you have received this file from a

* source other than Adobe, then your use, modification, or distribution of it requires the prior

* written permission of Adobe.

*

**************************************************************************************************/



/** CSInterface - v5.0.0 */



/**

 * Stores constants for the window types supported by the CSXS infrastructure.

 */

function CSXSWindowType()

{

};



/** Constant for the CSXS window type Panel. */

CSXSWindowType._PANEL = "Panel";



/** Constant for the CSXS window type Modeless. */

CSXSWindowType._MODELESS = "Modeless";



/** Constant for the CSXS window type ModalDialog. */

CSXSWindowType._MODAL_DIALOG = "ModalDialog";



/** EvalScript error message */

EvalScript_ErrMessage = "EvalScript error.";



/**

 * @class Version

 * Defines a version number with major, minor, micro, and special

 * components. The major, minor and micro values are numeric; the special

 * value can be any string.

 *

 * @param major   The major version component, a positive integer up to nine digits long.

 * @param minor   The minor version component, a positive integer up to nine digits long.

 * @param micro   The micro version component, a positive integer up to nine digits long.

 * @param special The special version component, an arbitrary string.

 *

 * @return A new \c Version object.

 */

function Version(major, minor, micro, special)

{

    this.major = major;

    this.minor = minor;

    this.micro = micro;

    this.special = special;

};



/**

 * The maximum value allowed for a numeric version component.

 * This reflects the maximum value allowed in PlugPlug and the manifest schema.

 */

Version.MAX_NUM = 999999999;



/**

 * @class VersionBound

 * Defines a boundary for a version range, which associates a \c Version object

 * with a flag for whether it is an inclusive or exclusive boundary.

 *

 * @param version   The \c #Version object.

 * @param inclusive True if this boundary is inclusive, false if it is exclusive.

 *

 * @return A new \c VersionBound object.

 */

function VersionBound(version, inclusive)

{

    this.version = version;

    this.inclusive = inclusive;

};



/**

 * @class VersionRange

 * Defines a range of versions using a lower boundary and optional upper boundary.

 *

 * @param lowerBound The \c #VersionBound object.

 * @param upperBound The \c #VersionBound object, or null for a range with no upper boundary.

 *

 * @return A new \c VersionRange object.

 */

function VersionRange(lowerBound, upperBound)

{

    this.lowerBound = lowerBound;

    this.upperBound = upperBound;

};



/**

 * @class Runtime

 * Represents a runtime related to the CEP infrastructure.

 * Extensions can declare dependencies on particular

 * CEP runtime versions in the extension manifest.

 *

 * @param name    The runtime name.

 * @param version A \c #VersionRange object that defines a range of valid versions.

 *

 * @return A new \c Runtime object.

 */

function Runtime(name, versionRange)

{

    this.name = name;

    this.versionRange = versionRange;

};



/**

* @class Extension

* Encapsulates a CEP-based extension to an Adobe application.

*

* @param id              The unique identifier of this extension.

* @param name            The localizable display name of this extension.

* @param mainPath        The path of the "index.html" file.

* @param basePath        The base path of this extension.

* @param windowType          The window type of the main window of this extension.

                 Valid values are defined by \c #CSXSWindowType.

* @param width           The default width in pixels of the main window of this extension.

* @param height          The default height in pixels of the main window of this extension.

* @param minWidth        The minimum width in pixels of the main window of this extension.

* @param minHeight       The minimum height in pixels of the main window of this extension.

* @param maxWidth        The maximum width in pixels of the main window of this extension.

* @param maxHeight       The maximum height in pixels of the main window of this extension.

* @param defaultExtensionDataXml The extension data contained in the default \c ExtensionDispatchInfo section of the extension manifest.

* @param specialExtensionDataXml The extension data contained in the application-specific \c ExtensionDispatchInfo section of the extension manifest.

* @param requiredRuntimeList     An array of \c Runtime objects for runtimes required by this extension.

* @param isAutoVisible       True if this extension is visible on loading.

* @param isPluginExtension   True if this extension has been deployed in the Plugins folder of the host application.

*

* @return A new \c Extension object.

*/

function Extension(id, name, mainPath, basePath, windowType, width, height, minWidth, minHeight, maxWidth, maxHeight,

                   defaultExtensionDataXml, specialExtensionDataXml, requiredRuntimeList, isAutoVisible, isPluginExtension)

{

    this.id = id;

    this.name = name;

    this.mainPath = mainPath;

    this.basePath = basePath;

    this.windowType = windowType;

    this.width = width;

    this.height = height;

    this.minWidth = minWidth;

    this.minHeight = minHeight;

    this.maxWidth = maxWidth;

    this.maxHeight = maxHeight;

    this.defaultExtensionDataXml = defaultExtensionDataXml;

    this.specialExtensionDataXml = specialExtensionDataXml;

    this.requiredRuntimeList = requiredRuntimeList;

    this.isAutoVisible = isAutoVisible;

    this.isPluginExtension = isPluginExtension;

};



/**

 * @class CSEvent

 * A standard JavaScript event, the base class for CEP events.

 *

 * @param type        The name of the event type.

 * @param scope       The scope of event, can be "GLOBAL" or "APPLICATION".

 * @param appId       The unique identifier of the application that generated the event.

 * @param extensionId     The unique identifier of the extension that generated the event.

 *

 * @return A new \c CSEvent object

 */

function CSEvent(type, scope, appId, extensionId)

{

    this.type = type;

    this.scope = scope;

    this.appId = appId;

    this.extensionId = extensionId;

};



/** Event-specific data. */

CSEvent.prototype.data = "";



/**

 * @class SystemPath

 * Stores operating-system-specific location constants for use in the

 * \c #CSInterface.getSystemPath() method.

 * @return A new \c SystemPath object.

 */

function SystemPath()

{

};



/** The path to user data.  */

SystemPath.USER_DATA = "userData";



/** The path to common files for Adobe applications.  */

SystemPath.COMMON_FILES = "commonFiles";



/** The path to the user's default document folder.  */

SystemPath.MY_DOCUMENTS = "myDocuments";



/** @deprecated. Use \c #SystemPath.Extension.  */

SystemPath.APPLICATION = "application";



/** The path to current extension.  */

SystemPath.EXTENSION = "extension";



/** The path to hosting application's executable.  */

SystemPath.HOST_APPLICATION = "hostApplication";



/**

 * @class ColorType

 * Stores color-type constants.

 */

function ColorType()

{

};



/** RGB color type. */

ColorType.RGB = "rgb";



/** Gradient color type. */

ColorType.GRADIENT = "gradient";



/** Null color type. */

ColorType.NONE = "none";



/**

 * @class RGBColor

 * Stores an RGB color with red, green, blue, and alpha values.

 * All values are in the range [0.0 to 255.0]. Invalid numeric values are

 * converted to numbers within this range.

 *

 * @param red   The red value, in the range [0.0 to 255.0].

 * @param green The green value, in the range [0.0 to 255.0].

 * @param blue  The blue value, in the range [0.0 to 255.0].

 * @param alpha The alpha (transparency) value, in the range [0.0 to 255.0].

 *      The default, 255.0, means that the color is fully opaque.

 *

 * @return A new RGBColor object.

 */

function RGBColor(red, green, blue, alpha)

{

    this.red = red;

    this.green = green;

    this.blue = blue;

    this.alpha = alpha;

};



/**

 * @class Direction

 * A point value  in which the y component is 0 and the x component

 * is positive or negative for a right or left direction,

 * or the x component is 0 and the y component is positive or negative for

 * an up or down direction.

 *

 * @param x     The horizontal component of the point.

 * @param y     The vertical component of the point.

 *

 * @return A new \c Direction object.

 */

function Direction(x, y)

{

    this.x = x;

    this.y = y;

};



/**

 * @class GradientStop

 * Stores gradient stop information.

 *

 * @param offset   The offset of the gradient stop, in the range [0.0 to 1.0].

 * @param rgbColor The color of the gradient at this point, an \c #RGBColor object.

 *

 * @return GradientStop object.

 */

function GradientStop(offset, rgbColor)

{

    this.offset = offset;

    this.rgbColor = rgbColor;

};



/**

 * @class GradientColor

 * Stores gradient color information.

 *

 * @param type          The gradient type, must be "linear".

 * @param direction     A \c #Direction object for the direction of the gradient

                (up, down, right, or left).

 * @param numStops          The number of stops in the gradient.

 * @param gradientStopList  An array of \c #GradientStop objects.

 *

 * @return A new \c GradientColor object.

 */

function GradientColor(type, direction, numStops, arrGradientStop)

{

    this.type = type;

    this.direction = direction;

    this.numStops = numStops;

    this.arrGradientStop = arrGradientStop;

};



/**

 * @class UIColor

 * Stores color information, including the type, anti-alias level, and specific color

 * values in a color object of an appropriate type.

 *

 * @param type          The color type, 1 for "rgb" and 2 for "gradient".

                The supplied color object must correspond to this type.

 * @param antialiasLevel    The anti-alias level constant.

 * @param color         A \c #RGBColor or \c #GradientColor object containing specific color information.

 *

 * @return A new \c UIColor object.

 */

function UIColor(type, antialiasLevel, color)

{

    this.type = type;

    this.antialiasLevel = antialiasLevel;

    this.color = color;

};



/**

 * @class AppSkinInfo

 * Stores window-skin properties, such as color and font. All color parameter values are \c #UIColor objects except that systemHighlightColor is \c #RGBColor object.

 *

 * @param baseFontFamily        The base font family of the application.

 * @param baseFontSize          The base font size of the application.

 * @param appBarBackgroundColor     The application bar background color.

 * @param panelBackgroundColor      The background color of the extension panel.

 * @param appBarBackgroundColorSRGB     The application bar background color, as sRGB.

 * @param panelBackgroundColorSRGB      The background color of the extension panel, as sRGB.

 * @param systemHighlightColor          The operating-system highlight color, as sRGB.

 *

 * @return AppSkinInfo object.

 */

function AppSkinInfo(baseFontFamily, baseFontSize, appBarBackgroundColor, panelBackgroundColor, appBarBackgroundColorSRGB, panelBackgroundColorSRGB, systemHighlightColor)

{

    this.baseFontFamily = baseFontFamily;

    this.baseFontSize = baseFontSize;

    this.appBarBackgroundColor = appBarBackgroundColor;

    this.panelBackgroundColor = panelBackgroundColor;

    this.appBarBackgroundColorSRGB = appBarBackgroundColorSRGB;

    this.panelBackgroundColorSRGB = panelBackgroundColorSRGB;

    this.systemHighlightColor = systemHighlightColor;

};



/**

 * @class HostEnvironment

 * Stores information about the environment in which the extension is loaded.

 *

 * @param appName   The application's name.

 * @param appVersion    The application's version.

 * @param appLocale The application's current license locale.

 * @param appUILocale   The application's current UI locale.

 * @param appId     The application's unique identifier.

 * @param isAppOnline  True if the application is currently online.

 * @param appSkinInfo   An \c #AppSkinInfo object containing the application's default color and font styles.

 *

 * @return A new \c HostEnvironment object.

 */

function HostEnvironment(appName, appVersion, appLocale, appUILocale, appId, isAppOnline, appSkinInfo)

{

    this.appName = appName;

    this.appVersion = appVersion;

    this.appLocale = appLocale;

    this.appUILocale = appUILocale;

    this.appId = appId;

    this.isAppOnline = isAppOnline;

    this.appSkinInfo = appSkinInfo;

};



/**

 * @class HostCapabilities

 * Stores information about the host capabilities.

 *

 * @param EXTENDED_PANEL_MENU True if the application supports panel menu.

 * @param EXTENDED_PANEL_ICONS True if the application supports panel icon.

 * @param DELEGATE_APE_ENGINE True if the application supports delegated APE engine.

 * @param SUPPORT_HTML_EXTENSIONS True if the application supports HTML extensions.

 * @param DISABLE_FLASH_EXTENSIONS True if the application disables FLASH extensions.

 *

 * @return A new \c HostCapabilities object.

 */

function HostCapabilities(EXTENDED_PANEL_MENU, EXTENDED_PANEL_ICONS, DELEGATE_APE_ENGINE, SUPPORT_HTML_EXTENSIONS, DISABLE_FLASH_EXTENSIONS)

{

    this.EXTENDED_PANEL_MENU = EXTENDED_PANEL_MENU;

    this.EXTENDED_PANEL_ICONS = EXTENDED_PANEL_ICONS;

    this.DELEGATE_APE_ENGINE = DELEGATE_APE_ENGINE;

    this.SUPPORT_HTML_EXTENSIONS = SUPPORT_HTML_EXTENSIONS;

	this.DISABLE_FLASH_EXTENSIONS = DISABLE_FLASH_EXTENSIONS; // Since 5.0.0

};



/**

 * @class ApiVersion

 * Stores current api version.

 *

 * Since 4.2.0

 *

 * @param major  The major version

 * @param minor  The minor version.

 * @param micro  The micro version.

 *

 * @return ApiVersion object.

 */

function ApiVersion(major, minor, micro)

{

    this.major = major;

    this.minor = minor;

    this.micro = micro;

};



//------------------------------ CSInterface ----------------------------------



/**

 * @class CSInterface

 * This is the entry point to the CEP extensibility infrastructure.

 * Instantiate this object and use it to:

 * <ul>

 * <li>Access information about the host application in which an extension is running</li>

 * <li>Launch an extension</li>

 * <li>Register interest in event notifications, and dispatch events</li>

 * </ul>

 *

 * @return A new \c CSInterface object

 */

function CSInterface()

{

};



/**

 * User can add this event listener to handle native application theme color changes.

 * Callback function gives extensions ability to fine-tune their theme color after the

 * global theme color has been changed.

 * The callback function should be like below:

 *

 * @example

 * // event is a CSEvent object, but user can ignore it.

 * function OnAppThemeColorChanged(event)

 * {

 *    // Should get a latest HostEnvironment object from application.

 *    var skinInfo = JSON.parse(window.__adobe_cep__.getHostEnvironment()).appSkinInfo;

 *    // Gets the style information such as color info from the skinInfo,

 *    // and redraw all UI controls of your extension according to the style info.

 * }

 */

CSInterface.THEME_COLOR_CHANGED_EVENT = "com.adobe.csxs.events.ThemeColorChanged";



/** The host environment data object. */

CSInterface.prototype.hostEnvironment = JSON.parse(window.__adobe_cep__.getHostEnvironment());



/** Retrieves information about the host environment in which the

 *  extension is currently running.

 *

 *   @return A \c #HostEnvironment object.

 */

CSInterface.prototype.getHostEnvironment = function()

{

    this.hostEnvironment = JSON.parse(window.__adobe_cep__.getHostEnvironment());

    return this.hostEnvironment;

};



/** Closes this extension. */

CSInterface.prototype.closeExtension = function()

{

    window.__adobe_cep__.closeExtension();

};



/**

 * Retrieves a path for which a constant is defined in the system.

 *

 * @param pathType The path-type constant defined in \c #SystemPath ,

 *

 * @return The platform-specific system path string.

 */

CSInterface.prototype.getSystemPath = function(pathType)

{

    var path = decodeURI(window.__adobe_cep__.getSystemPath(pathType));

    var OSVersion = this.getOSInformation();

    if (OSVersion.indexOf("Windows") >= 0)

    {

      path = path.replace("file:///", "");

    }

    else if (OSVersion.indexOf("Mac") >= 0)

    {

      path = path.replace("file://", "");

    }

    return path;

};



/**

 * Evaluates a JavaScript script, which can use the JavaScript DOM

 * of the host application.

 *

 * @param script    The JavaScript script.

 * @param callback  Optional. A callback function that receives the result of execution.

 *          If execution fails, the callback function receives the error message \c EvalScript_ErrMessage.

 */

CSInterface.prototype.evalScript = function(script, callback)

{

    if(callback == null || callback == undefined)

    {

        callback = function(result){};

    }

    window.__adobe_cep__.evalScript(script, callback);

};



/**

 * Retrieves the unique identifier of the application.

 * in which the extension is currently running.

 *

 * @return The unique ID string.

 */

CSInterface.prototype.getApplicationID = function()

{

    var appId = this.hostEnvironment.appId;

    return appId;

};



/**

 * Retrieves host capability information for the application

 * in which the extension is currently running.

 *

 * @return A \c #HostCapabilities object.

 */

CSInterface.prototype.getHostCapabilities = function()

{

    var hostCapabilities = JSON.parse(window.__adobe_cep__.getHostCapabilities() );

    return hostCapabilities;

};



/**

 * Triggers a CEP event programmatically. Yoy can use it to dispatch

 * an event of a predefined type, or of a type you have defined.

 *

 * @param event A \c CSEvent object.

 */

CSInterface.prototype.dispatchEvent = function(event)

{

    if (typeof event.data == "object")

    {

        event.data = JSON.stringify(event.data);

    }



    window.__adobe_cep__.dispatchEvent(event);

};



/**

 * Registers an interest in a CEP event of a particular type, and

 * assigns an event handler.

 * The event infrastructure notifies your extension when events of this type occur,

 * passing the event object to the registered handler function.

 *

 * @param type     The name of the event type of interest.

 * @param listener The JavaScript handler function or method.

 * @param obj      Optional, the object containing the handler method, if any.

 *         Default is null.

 */

CSInterface.prototype.addEventListener = function(type, listener, obj)

{

    window.__adobe_cep__.addEventListener(type, listener, obj);

};



/**

 * Removes a registered event listener.

 *

 * @param type      The name of the event type of interest.

 * @param listener  The JavaScript handler function or method that was registered.

 * @param obj       Optional, the object containing the handler method, if any.

 *          Default is null.

 */

CSInterface.prototype.removeEventListener = function(type, listener, obj)

{

    window.__adobe_cep__.removeEventListener(type, listener, obj);

};



/**

 * Loads and launches another extension, or activates the extension if it is already loaded.

 *

 * @param extensionId       The extension's unique identifier.

 * @param startupParams     Not currently used, pass "".

 *

 * @example

 * To launch the extension "help" with ID "HLP" from this extension, call:

 * <code>requestOpenExtension("HLP", ""); </code>

 *

 */

CSInterface.prototype.requestOpenExtension = function(extensionId, params)

{

    window.__adobe_cep__.requestOpenExtension(extensionId, params);

};



/**

 * Retrieves the list of extensions currently loaded in the current host application.

 * The extension list is initialized once, and remains the same during the lifetime

 * of the CEP session.

 *

 * @param extensionIds  Optional, an array of unique identifiers for extensions of interest.

 *          If omitted, retrieves data for all extensions.

 *

 * @return Zero or more \c #Extension objects.

 */

CSInterface.prototype.getExtensions = function(extensionIds)

{

    var extensionIdsStr = JSON.stringify(extensionIds);

    var extensionsStr = window.__adobe_cep__.getExtensions(extensionIdsStr);



    var extensions = JSON.parse(extensionsStr);

    return extensions;

};



/**

 * Retrieves network-related preferences.

 *

 * @return A JavaScript object containing network preferences.

 */

CSInterface.prototype.getNetworkPreferences = function()

{

    var result = window.__adobe_cep__.getNetworkPreferences();

    var networkPre = JSON.parse(result);



    return networkPre;

};



/**

 * Initializes the resource bundle for this extension with property values

 * for the current application and locale.

 * To support multiple locales, you must define a property file for each locale,

 * containing keyed display-string values for that locale.

 * See localization documentation for Extension Builder and related products.

 *

 * Keys can be in the

 * form <code>key.value="localized string"</code>, for use in HTML text elements.

 * For example, in this input element, the localized \c key.value string is displayed

 * instead of the empty \c value string:

 *

 * <code><input type="submit" value="" data-locale="key"/></code>

 *

 * @return An object containing the resource bundle information.

 */

CSInterface.prototype.initResourceBundle = function()

{

    var resourceBundle = JSON.parse(window.__adobe_cep__.initResourceBundle());

    var resElms = document.querySelectorAll('[data-locale]');

    for (var n = 0; n < resElms.length; n++)

    {

       var resEl = resElms[n];

       // Get the resource key from the element.

       var resKey = resEl.getAttribute('data-locale');

       if (resKey)

       {

           // Get all the resources that start with the key.

           for (var key in resourceBundle)

           {

               if (key.indexOf(resKey) == 0)

               {

                   var resValue = resourceBundle[key];

                   if (key.indexOf('.') == -1)

                   {

                       // No dot notation in resource key,

                       // assign the resource value to the element's

                       // innerHTML.

                       resEl.innerHTML = resValue;

                   }

                   else

                   {

                       // Dot notation in resource key, assign the

                       // resource value to the element's property

                       // whose name corresponds to the substring

                       // after the dot.

                       var attrKey = key.substring(key.indexOf('.') + 1);

                       resEl[attrKey] = resValue;

                   }

               }

           }

       }

    }

    return resourceBundle;

};



/**

 * Writes installation information to a file.

 *

 * @return The file path.

 */

CSInterface.prototype.dumpInstallationInfo = function()

{

    return window.__adobe_cep__.dumpInstallationInfo();

};



/**

 * Retrieves version information for the current Operating System,

 * See http://www.useragentstring.com/pages/Chrome/ for Chrome \c navigator.userAgent values.

 *

 * @return A string containing the OS version, or "unknown Operation System".

 */

CSInterface.prototype.getOSInformation = function()

{

    var userAgent = navigator.userAgent;



    if ((navigator.platform == "Win32") || (navigator.platform == "Windows"))

    {

        var winVersion = "Windows platform";

        if (userAgent.indexOf("Windows NT 5.0") > -1)

        {

            winVersion = "Windows 2000";

        }

        else if (userAgent.indexOf("Windows NT 5.1") > -1)

        {

            winVersion = "Windows XP";

        }

        else if (userAgent.indexOf("Windows NT 5.2") > -1)

        {

            winVersion = "Windows Server 2003";

        }

        else if (userAgent.indexOf("Windows NT 6.0") > -1)

        {

            winVersion = "Windows Vista";

        }

        else if (userAgent.indexOf("Windows NT 6.1") > -1)

        {

            winVersion = "Windows 7";

        }

        else if (userAgent.indexOf("Windows NT 6.2") > -1)

        {

            winVersion = "Windows 8";

        }



        var winBit = "32-bit";

        if (userAgent.indexOf("WOW64") > -1)

        {

            winBit = "64-bit";

        }



        return winVersion + " " + winBit;

    }

    else if ((navigator.platform == "MacIntel") || (navigator.platform == "Macintosh"))

    {

        var agentStr = new String();

        agentStr = userAgent;

        var verLength = agentStr.indexOf(")") - agentStr.indexOf("Mac OS X");

        var verStr = agentStr.substr(agentStr.indexOf("Mac OS X"), verLength);

        var result = verStr.replace("_", ".");

        result = result.replace("_", ".");

        return result;

    }



    return "Unknown Operation System";

};



/**

 * Opens a page in the default system browser.

 *

 * Since 4.2.0

 *

 * @param url   The URL of the page to open. Must use HTTP or HTTPS protocol.

 *

 * @return One of these error codes:\n

 *      <ul>\n

 *          <li>NO_ERROR - 0</li>\n

 *          <li>ERR_UNKNOWN - 1</li>\n

 *          <li>ERR_INVALID_PARAMS - 2</li>\n

 *          <li>ERR_INVALID_URL - 201</li>\n

 *      </ul>\n

 */

CSInterface.prototype.openURLInDefaultBrowser = function(url)

{

    return cep.util.openURLInDefaultBrowser(url);

};



/**

 * Retrieves extension ID.

 *

 * Since 4.2.0

 *

 * @return extension ID.

 */

CSInterface.prototype.getExtensionID = function()

{

     return window.__adobe_cep__.getExtensionId();

};



/**

 * Retrieves scale factor of screen. This only works on Mac.

 *

 * Since 4.2.0

 *

 * @return One of the following integer.

 *      <ul>\n

 *          <li>-1 means fail to get scale factor or this API has not been available on Windows yet</li>\n

 *          <li>1 means normal screen</li>\n

 *          <li>2 means HiDPI screen</li>\n

 *      </ul>\n

 */

CSInterface.prototype.getScaleFactor = function()

{

    return window.__adobe_cep__.getScaleFactor();

};



/**

 * Set a handler to detect any changes of scale factor. This only works on Mac.

 *

 * Since 4.2.0

 *

 * @param handler   The function to be called when scale factor is changed.

 *

 */

CSInterface.prototype.setScaleFactorChangedHandler = function(handler)

{

    window.__adobe_cep__.setScaleFactorChangedHandler(handler);

};



/**

 * Retrieves current API version.

 *

 * Since 4.2.0

 *

 * @return ApiVersion object.

 *

 */

CSInterface.prototype.getCurrentApiVersion = function()

{

    var apiVersion = JSON.parse(window.__adobe_cep__.getCurrentApiVersion());

    return apiVersion;

};