Frame13/ayon-core
1
0
Fork 1
mirror of https://github.com/ynput/ayon-core.git synced 2026-01-02 00:44:52 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
ayon-core/pype/premiere/extensions/com.pype.rename/lib/CSInterface.js
Jakub Jezek 110c6413e6 premiere extention update
2019-01-16 17:53:38 +01:00

1291 lines
42 KiB
JavaScript
Raw Blame History

/**************************************************************************************************
*
* 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 - v9.2.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", "");
};
Reference in a new issue View git blame Copy permalink