/**************************************************************************************************
*
* 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 - v8.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 {number} major The major version component, a positive integer up to nine digits long.
* @param {number} minor The minor version component, a positive integer up to nine digits long.
* @param {number} micro The micro version component, a positive integer up to nine digits long.
* @param {string} special The special version component, an arbitrary string.
*
* @return A new 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 Version object
* with a flag for whether it is an inclusive or exclusive boundary.
*
* @param {object} version The #Version object.
* @param {boolean} inclusive True if this boundary is inclusive, false if it is exclusive.
*
* @return A new 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 {object} lowerBound The #VersionBound object.
* @param {object} upperBound The #VersionBound object, or null for a range with no upper boundary.
*
* @return A new 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 {string} name The runtime name.
* @param version A {@link VersionRange} object that defines a range of valid versions.
*
* @return A new Runtime object.
*/
function Runtime(name, versionRange)
{
this.name = name;
this.versionRange = versionRange;
}
/**
* @class Extension
* Encapsulates a CEP-based extension to an Adobe application.
*
* @param {string} id The unique identifier of this extension.
* @param {string} name The localizable display name of this extension.
* @param {string} mainPath The path of the "index.html" file.
* @param {string} basePath The base path of this extension.
* @param {string} windowType The window type of the main window of this extension. Valid values are defined by {@link CSXSWindowType}.
* @param {number} width The default width in pixels of the main window of this extension.
* @param {number} height The default height in pixels of the main window of this extension.
* @param {number} minWidth The minimum width in pixels of the main window of this extension.
* @param {number} minHeight The minimum height in pixels of the main window of this extension.
* @param {number} maxWidth The maximum width in pixels of the main window of this extension.
* @param {number} maxHeight The maximum height in pixels of the main window of this extension.
* @param defaultExtensionDataXml The extension data contained in the default ExtensionDispatchInfo section of the extension manifest.
* @param specialExtensionDataXml The extension data contained in the application-specific ExtensionDispatchInfo section of the extension manifest.
* @param {object[]} requiredRuntimeList An array of Runtime objects for runtimes required by this extension.
* @param {boolean} isAutoVisible True if this extension is visible on loading.
* @param {boolean} isPluginExtension True if this extension has been deployed in the Plugins folder of the host application.
*
* @return A new 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 {string} type The name of the event type.
* @param {string} scope The scope of event, can be "GLOBAL" or "APPLICATION".
* @param {string} appId The unique identifier of the application that generated the event.
* @param {string} extensionId The unique identifier of the extension that generated the event.
*
* @return A new 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
* #CSInterface.getSystemPath() method.
* @return A new 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 #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 {number} red The red value, in the range [0.0 to 255.0].
* @param {number} green The green value, in the range [0.0 to 255.0].
* @param {number} blue The blue value, in the range [0.0 to 255.0].
* @param {number} 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 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 #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 #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 #GradientStop objects.
*
* @return A new 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 #RGBColor or #GradientColor object containing specific color information.
*
* @return A new 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 #UIColor objects except that systemHighlightColor is #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 #AppSkinInfo object containing the application's default color and font styles.
*
* @return A new 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 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 CSInterface object
*/
function CSInterface()
{
}
/**
* Users 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 #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 #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 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 #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 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 #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 key.value string is displayed
* instead of the empty 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 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:
* <ul>
* <li>NO_ERROR - 0</li>
* <li>ERR_UNKNOWN - 1</li>
* <li>ERR_INVALID_PARAMS - 2</li>
* <li>ERR_INVALID_URL - 201</li>
* </ul>
*/
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>
* <li> -1.0 when error occurs </li>
* <li> 1.0 means normal screen </li>
* <li> >1.0 means HiDPI screen </li>
* </ul>
*/
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;
};
/**
* Set panel flyout menu by an XML.
*
* @since 5.2.0<br/>
*
* Register a callback function for <code>"com.adobe.csxs.events.flyoutMenuClicked"</code> to get notified when a
* menu item is clicked.
* The <code>"data"</code> attribute of event is an object which contains <code>"menuId"</code> and <code>"menuName"</code> attributes.
*
* Register callback functions for <code>"com.adobe.csxs.events.flyoutMenuOpened"</code> and <code>"com.adobe.csxs.events.flyoutMenuClosed"</code>
* respectively to get notified when flyout menu is opened or closed.
*
* @param {string} menu An XML string which describes menu structure.
* @example
* 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 {string} menuItemLabel The menu item label.
* @param {boolean} enabled True to enable the item, false to disable it (gray it out).
* @param {boolean} checked True to select the item, false to deselect it.
*
* @return false when the host application does not support this functionality (<code>HostCapabilities.EXTENDED_PANEL_MENU</code> 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<br />
*
* There are a number of conventions used to communicate what type of menu item to create and how it should be handled.
* <ul>
* <li>an item without menu ID or menu name is disabled and is not shown.</li>
* <li>if the item label is "---" (three hyphens) then it is treated as a separator. The menu ID in this case will always be NULL.</li>
* <li>checkable attribute takes precedence over Checked attribute.</li>
* <li>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.</li>
* <li>the items with icons and checkable items cannot coexist on the same menu level. The former take precedences over the latter.</li>
* </ul>
*
* The Chrome extension {@link https://developer.chrome.com/extensions/contextMenus|contextMenus API} was taken as a reference.
*
* @param {string} menu A XML string which describes menu structure.
* @param {function} callback The callback function which is called when a menu item is clicked. The only parameter is the returned ID of clicked menu item.
*
* @example 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<br />
*
* There are a number of conventions used to communicate what type of menu item to create and how it should be handled.
* <ul>
* <li>an item without menu ID or menu name is disabled and is not shown.</li>
* <li>if the item label is "---" (three hyphens) then it is treated as a separator. The menu ID in this case will always be NULL.</li>
* <li>checkable attribute takes precedence over Checked attribute.</li>
* <li>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.</li>
* <li>the items with icons and checkable items cannot coexist on the same menu level. The former take precedences over the latter.</li>
* </ul>
*
* The Chrome extension {@link https://developer.chrome.com/extensions/contextMenus|contextMenus API} was taken as a reference.
*
* @param menu A JSON string which describes menu structure.
* @param {function} callback The callback function which is called when a menu item is clicked. The only parameter is the returned ID of clicked menu item.
*
* @example 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 {string} menuItemID The menu item ID.
* @param {boolean} enabled True to enable the item, false to disable it (gray it out).
* @param {boolean} 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 {number} width The new width
* @param {number} 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 {function} callback the callback function
*/
CSInterface.prototype.registerInvalidCertificateCallback = function(callback)
{
return window.__adobe_cep__.registerInvalidCertificateCallback(callback);
};
/**
* @typedef {object} JSON_String
* @property {number} keyCode Required, represents an OS system dependent virtual key code identifying the unmodified value of the pressed key.
* @property {boolean} ctrlKey [optional] a Boolean that indicates if the control key was pressed (true) or not (false) when the event occurred.
* @property {boolean} altKey [optional] a Boolean that indicates if the alt key was pressed (true) or not (false) when the event occurred.
* @property {boolean} shiftKey [optional] a Boolean that indicates if the shift key was pressed (true) or not (false) when the event occurred.
* @property {boolean} 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.
*
*/
/**
* 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 {JSON_String} 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
*
* @example
* 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 {string} 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", "");
};