CSInterface.js

/**************************************************************************************************
 *
 * ADOBE SYSTEMS INCORPORATED
 * Copyright 2020 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 - v10.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 highlight color of the extension panel, if provided by the host application. Otherwise, the operating-system highlight color.
 *
 * @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
}

/**
 * @class MenuItemStatus
 * Stores flyout menu item status
 *
 * Since 5.2.0
 *
 * @param menuItemLabel  The menu item label.
 * @param enabled        True if user wants to enable the menu item.
 * @param checked        True if user wants to check the menu item.
 *
 * @return MenuItemStatus object.
 */
function MenuItemStatus(menuItemLabel, enabled, checked) {
	this.menuItemLabel = menuItemLabel
	this.enabled = enabled
	this.checked = checked
}

/**
 * @class ContextMenuItemStatus
 * Stores the status of the context menu item.
 *
 * Since 5.2.0
 *
 * @param menuItemID     The menu item id.
 * @param enabled        True if user wants to enable the menu item.
 * @param checked        True if user wants to check the menu item.
 *
 * @return MenuItemStatus object.
 */
function ContextMenuItemStatus(menuItemID, enabled, checked) {
	this.menuItemID = menuItemID
	this.enabled = enabled
	this.checked = checked
}
//------------------------------ 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 = window.__adobe_cep__
	? JSON.parse(window.__adobe_cep__.getHostEnvironment())
	: null

/** 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
}

/** Loads binary file created which is located at url asynchronously
*
*@param urlName url at which binary file is located. Local files should start with 'file://'
*@param callback Optional. A callback function that returns after binary is loaded

*@example
* To create JS binary use command ./cep_compiler test.js test.bin
* To load JS binary asyncronously
*   var CSLib = new CSInterface();
*   CSLib.loadBinAsync(url, function () { });
*/
CSInterface.prototype.loadBinAsync = function (urlName, callback) {
	try {
		var xhr = new XMLHttpRequest()
		xhr.responseType = 'arraybuffer' // make response as ArrayBuffer
		xhr.open('GET', urlName, true)
		xhr.onerror = function () {
			console.log('Unable to load snapshot from given URL')
			return false
		}
		xhr.send()
		xhr.onload = () => {
			window.__adobe_cep__.loadSnapshot(xhr.response)
			if (typeof callback === 'function') {
				callback()
			} else if (typeof callback !== 'undefined') {
				console.log('Provided callback is not a function')
			}
		}
	} catch (err) {
		console.log(err)
		return false
	}

	return true
}

/** Loads binary file created synchronously
*
*@param pathName the local path at which binary file is located

*@example
* To create JS binary use command ./cep_compiler test.js test.bin
* To load JS binary syncronously
*   var CSLib = new CSInterface();
*   CSLib.loadBinSync(path);
*/
CSInterface.prototype.loadBinSync = function (pathName) {
	try {
		var OSVersion = this.getOSInformation()
		if (pathName.startsWith('file://')) {
			if (OSVersion.indexOf('Windows') >= 0) {
				pathName = pathName.replace('file:///', '')
			} else if (OSVersion.indexOf('Mac') >= 0) {
				pathName = pathName.replace('file://', '')
			}
			window.__adobe_cep__.loadSnapshot(pathName)
			return true
		}
	} catch (err) {
		console.log(err)
		return false
	}
	//control should not come here
	return false
}

/** 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.length == resKey.length) {
						resEl.innerHTML = resValue
					} else if ('.' == key.charAt(resKey.length)) {
						var attrKey = key.substring(resKey.length + 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".
 * If user customizes the User Agent by setting CEF command parameter "--user-agent", only
 * "Mac OS X" or "Windows" will be returned.
 */
CSInterface.prototype.getOSInformation = function () {
	var userAgent = navigator.userAgent

	if (navigator.platform == 'Win32' || navigator.platform == 'Windows') {
		var winVersion = 'Windows'
		var winBit = ''
		if (userAgent.indexOf('Windows') > -1) {
			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'
			} else if (userAgent.indexOf('Windows NT 6.3') > -1) {
				winVersion = 'Windows 8.1'
			} else if (userAgent.indexOf('Windows NT 10') > -1) {
				winVersion = 'Windows 10'
			}

			if (userAgent.indexOf('WOW64') > -1 || userAgent.indexOf('Win64') > -1) {
				winBit = ' 64-bit'
			} else {
				winBit = ' 32-bit'
			}
		}

		return winVersion + winBit
	} else if (navigator.platform == 'MacIntel' || navigator.platform == 'Macintosh') {
		var result = 'Mac OS X'

		if (userAgent.indexOf('Mac OS X') > -1) {
			result = userAgent.substring(userAgent.indexOf('Mac OS X'), userAgent.indexOf(')'))
			result = result.replace(/_/g, '.')
		}

		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/file to open, or the email address.
 * Must use HTTP/HTTPS/file/mailto protocol. For example:
 *   "http://www.adobe.com"
 *   "https://github.com"
 *   "file:///C:/log.txt"
 *   "mailto:test@adobe.com"
 *
 * @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 the scale factor of screen.
 * On Windows platform, the value of scale factor might be different from operating system's scale factor,
 * since host application may use its self-defined scale factor.
 *
 * Since 4.2.0
 *
 * @return One of the following float number.
 *      <ul>\n
 *          <li> -1.0 when error occurs </li>\n
 *          <li> 1.0 means normal screen </li>\n
 *          <li> >1.0 means HiDPI screen </li>\n
 *      </ul>\n
 */
CSInterface.prototype.getScaleFactor = function () {
	return window.__adobe_cep__.getScaleFactor()
}

/**
 * Retrieves the scale factor of Monitor.
 *
 * Since 8.5.0
 *
 * @return value >= 1.0f
 * only available for windows machine
 */
if (navigator.appVersion.toLowerCase().indexOf('windows') >= 0) {
	CSInterface.prototype.getMonitorScaleFactor = function () {
		return window.__adobe_cep__.getMonitorScaleFactor()
	}
}

/**
 * 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
}

/**
 * Set panel flyout menu by an XML.
 *
 * Since 5.2.0
 *
 * Register a callback function for "com.adobe.csxs.events.flyoutMenuClicked" to get notified when a
 * menu item is clicked.
 * The "data" attribute of event is an object which contains "menuId" and "menuName" attributes.
 *
 * Register callback functions for "com.adobe.csxs.events.flyoutMenuOpened" and "com.adobe.csxs.events.flyoutMenuClosed"
 * respectively to get notified when flyout menu is opened or closed.
 *
 * @param menu     A XML string which describes menu structure.
 * An example menu XML:
 * <Menu>
 *   <MenuItem Id="menuItemId1" Label="TestExample1" Enabled="true" Checked="false"/>
 *   <MenuItem Label="TestExample2">
 *     <MenuItem Label="TestExample2-1" >
 *       <MenuItem Label="TestExample2-1-1" Enabled="false" Checked="true"/>
 *     </MenuItem>
 *     <MenuItem Label="TestExample2-2" Enabled="true" Checked="true"/>
 *   </MenuItem>
 *   <MenuItem Label="---" />
 *   <MenuItem Label="TestExample3" Enabled="false" Checked="false"/>
 * </Menu>
 *
 */
CSInterface.prototype.setPanelFlyoutMenu = function (menu) {
	if ('string' != typeof menu) {
		return
	}

	window.__adobe_cep__.invokeSync('setPanelFlyoutMenu', menu)
}

/**
 * Updates a menu item in the extension window's flyout menu, by setting the enabled
 * and selection status.
 *
 * Since 5.2.0
 *
 * @param menuItemLabel The menu item label.
 * @param enabled       True to enable the item, false to disable it (gray it out).
 * @param checked       True to select the item, false to deselect it.
 *
 * @return false when the host application does not support this functionality (HostCapabilities.EXTENDED_PANEL_MENU is false).
 *         Fails silently if menu label is invalid.
 *
 * @see HostCapabilities.EXTENDED_PANEL_MENU
 */
CSInterface.prototype.updatePanelMenuItem = function (menuItemLabel, enabled, checked) {
	var ret = false
	if (this.getHostCapabilities().EXTENDED_PANEL_MENU) {
		var itemStatus = new MenuItemStatus(menuItemLabel, enabled, checked)
		ret = window.__adobe_cep__.invokeSync('updatePanelMenuItem', JSON.stringify(itemStatus))
	}
	return ret
}

/**
 * Set context menu by XML string.
 *
 * Since 5.2.0
 *
 * There are a number of conventions used to communicate what type of menu item to create and how it should be handled.
 * - an item without menu ID or menu name is disabled and is not shown.
 * - if the item name is "---" (three hyphens) then it is treated as a separator. The menu ID in this case will always be NULL.
 * - Checkable attribute takes precedence over Checked attribute.
 * - a PNG icon. For optimal display results please supply a 16 x 16px icon as larger dimensions will increase the size of the menu item.
     The Chrome extension contextMenus API was taken as a reference.
     https://developer.chrome.com/extensions/contextMenus
 * - the items with icons and checkable items cannot coexist on the same menu level. The former take precedences over the latter.
 *
 * @param menu      A XML string which describes menu structure.
 * @param callback  The callback function which is called when a menu item is clicked. The only parameter is the returned ID of clicked menu item.
 *
 * @description An example menu XML:
 * <Menu>
 *   <MenuItem Id="menuItemId1" Label="TestExample1" Enabled="true" Checkable="true" Checked="false" Icon="./image/small_16X16.png"/>
 *   <MenuItem Id="menuItemId2" Label="TestExample2">
 *     <MenuItem Id="menuItemId2-1" Label="TestExample2-1" >
 *       <MenuItem Id="menuItemId2-1-1" Label="TestExample2-1-1" Enabled="false" Checkable="true" Checked="true"/>
 *     </MenuItem>
 *     <MenuItem Id="menuItemId2-2" Label="TestExample2-2" Enabled="true" Checkable="true" Checked="true"/>
 *   </MenuItem>
 *   <MenuItem Label="---" />
 *   <MenuItem Id="menuItemId3" Label="TestExample3" Enabled="false" Checkable="true" Checked="false"/>
 * </Menu>
 */
CSInterface.prototype.setContextMenu = function (menu, callback) {
	if ('string' != typeof menu) {
		return
	}

	window.__adobe_cep__.invokeAsync('setContextMenu', menu, callback)
}

/**
 * Set context menu by JSON string.
 *
 * Since 6.0.0
 *
 * There are a number of conventions used to communicate what type of menu item to create and how it should be handled.
 * - an item without menu ID or menu name is disabled and is not shown.
 * - if the item label is "---" (three hyphens) then it is treated as a separator. The menu ID in this case will always be NULL.
 * - Checkable attribute takes precedence over Checked attribute.
 * - a PNG icon. For optimal display results please supply a 16 x 16px icon as larger dimensions will increase the size of the menu item.
     The Chrome extension contextMenus API was taken as a reference.
 * - the items with icons and checkable items cannot coexist on the same menu level. The former take precedences over the latter.
     https://developer.chrome.com/extensions/contextMenus
 *
 * @param menu      A JSON string which describes menu structure.
 * @param callback  The callback function which is called when a menu item is clicked. The only parameter is the returned ID of clicked menu item.
 *
 * @description An example menu JSON:
 *
 * {
 *      "menu": [
 *          {
 *              "id": "menuItemId1",
 *              "label": "testExample1",
 *              "enabled": true,
 *              "checkable": true,
 *              "checked": false,
 *              "icon": "./image/small_16X16.png"
 *          },
 *          {
 *              "id": "menuItemId2",
 *              "label": "testExample2",
 *              "menu": [
 *                  {
 *                      "id": "menuItemId2-1",
 *                      "label": "testExample2-1",
 *                      "menu": [
 *                          {
 *                              "id": "menuItemId2-1-1",
 *                              "label": "testExample2-1-1",
 *                              "enabled": false,
 *                              "checkable": true,
 *                              "checked": true
 *                          }
 *                      ]
 *                  },
 *                  {
 *                      "id": "menuItemId2-2",
 *                      "label": "testExample2-2",
 *                      "enabled": true,
 *                      "checkable": true,
 *                      "checked": true
 *                  }
 *              ]
 *          },
 *          {
 *              "label": "---"
 *          },
 *          {
 *              "id": "menuItemId3",
 *              "label": "testExample3",
 *              "enabled": false,
 *              "checkable": true,
 *              "checked": false
 *          }
 *      ]
 *  }
 *
 */
CSInterface.prototype.setContextMenuByJSON = function (menu, callback) {
	if ('string' != typeof menu) {
		return
	}

	window.__adobe_cep__.invokeAsync('setContextMenuByJSON', menu, callback)
}

/**
 * Updates a context menu item by setting the enabled and selection status.
 *
 * Since 5.2.0
 *
 * @param menuItemID    The menu item ID.
 * @param enabled       True to enable the item, false to disable it (gray it out).
 * @param checked       True to select the item, false to deselect it.
 */
CSInterface.prototype.updateContextMenuItem = function (menuItemID, enabled, checked) {
	var itemStatus = new ContextMenuItemStatus(menuItemID, enabled, checked)
	ret = window.__adobe_cep__.invokeSync('updateContextMenuItem', JSON.stringify(itemStatus))
}

/**
 * Get the visibility status of an extension window.
 *
 * Since 6.0.0
 *
 * @return true if the extension window is visible; false if the extension window is hidden.
 */
CSInterface.prototype.isWindowVisible = function () {
	return window.__adobe_cep__.invokeSync('isWindowVisible', '')
}

/**
 * Resize extension's content to the specified dimensions.
 * 1. Works with modal and modeless extensions in all Adobe products.
 * 2. Extension's manifest min/max size constraints apply and take precedence.
 * 3. For panel extensions
 *    3.1 This works in all Adobe products except:
 *        * Premiere Pro
 *        * Prelude
 *        * After Effects
 *    3.2 When the panel is in certain states (especially when being docked),
 *        it will not change to the desired dimensions even when the
 *        specified size satisfies min/max constraints.
 *
 * Since 6.0.0
 *
 * @param width  The new width
 * @param height The new height
 */
CSInterface.prototype.resizeContent = function (width, height) {
	window.__adobe_cep__.resizeContent(width, height)
}

/**
 * Register the invalid certificate callback for an extension.
 * This callback will be triggered when the extension tries to access the web site that contains the invalid certificate on the main frame.
 * But if the extension does not call this function and tries to access the web site containing the invalid certificate, a default error page will be shown.
 *
 * Since 6.1.0
 *
 * @param callback the callback function
 */
CSInterface.prototype.registerInvalidCertificateCallback = function (callback) {
	return window.__adobe_cep__.registerInvalidCertificateCallback(callback)
}

/**
 * Register an interest in some key events to prevent them from being sent to the host application.
 *
 * This function works with modeless extensions and panel extensions.
 * Generally all the key events will be sent to the host application for these two extensions if the current focused element
 * is not text input or dropdown,
 * If you want to intercept some key events and want them to be handled in the extension, please call this function
 * in advance to prevent them being sent to the host application.
 *
 * Since 6.1.0
 *
 * @param keyEventsInterest      A JSON string describing those key events you are interested in. A null object or
                                 an empty string will lead to removing the interest
 *
 * This JSON string should be an array, each object has following keys:
 *
 * keyCode:  [Required] represents an OS system dependent virtual key code identifying
 *           the unmodified value of the pressed key.
 * ctrlKey:  [optional] a Boolean that indicates if the control key was pressed (true) or not (false) when the event occurred.
 * altKey:   [optional] a Boolean that indicates if the alt key was pressed (true) or not (false) when the event occurred.
 * shiftKey: [optional] a Boolean that indicates if the shift key was pressed (true) or not (false) when the event occurred.
 * metaKey:  [optional] (Mac Only) a Boolean that indicates if the Meta key was pressed (true) or not (false) when the event occurred.
 *                      On Macintosh keyboards, this is the command key. To detect Windows key on Windows, please use keyCode instead.
 * An example JSON string:
 *
 * [
 *     {
 *         "keyCode": 48
 *     },
 *     {
 *         "keyCode": 123,
 *         "ctrlKey": true
 *     },
 *     {
 *         "keyCode": 123,
 *         "ctrlKey": true,
 *         "metaKey": true
 *     }
 * ]
 *
 */
CSInterface.prototype.registerKeyEventsInterest = function (keyEventsInterest) {
	return window.__adobe_cep__.registerKeyEventsInterest(keyEventsInterest)
}

/**
 * Set the title of the extension window.
 * This function works with modal and modeless extensions in all Adobe products, and panel extensions in Photoshop, InDesign, InCopy, Illustrator, Flash Pro and Dreamweaver.
 *
 * Since 6.1.0
 *
 * @param title The window title.
 */
CSInterface.prototype.setWindowTitle = function (title) {
	window.__adobe_cep__.invokeSync('setWindowTitle', title)
}

/**
 * Get the title of the extension window.
 * This function works with modal and modeless extensions in all Adobe products, and panel extensions in Photoshop, InDesign, InCopy, Illustrator, Flash Pro and Dreamweaver.
 *
 * Since 6.1.0
 *
 * @return The window title.
 */
CSInterface.prototype.getWindowTitle = function () {
	return window.__adobe_cep__.invokeSync('getWindowTitle', '')
}