PS是一款栅格图像编辑软件，具有许多强大的功能，本文演示如何通过脚本实现HDR风格四相关功能，展示从互联网收集而来的一个小插件，供大家学习交流，请勿用于商业用途。
1.插件界面
本文界面是一系列功能的一部分，将逐步展示，但是功能界面是共同的，如下图所示：
fa554861ea0947a1af4f546b0b1788c8.png
2.关键代码--HDR风格四
大家可通过源代码阅读，来掌握相关技巧，源代码如下：
historyState = "U 2.0";
if (app.documents) {
ErrStrs = {};
ErrStrs.USER_CANCELED = localize("$$$/ScriptingSupport/Errors/UserCancelled");
var historyStateNow = -1;
do {
historyStateNow++
} while (app.activeDocument.activeHistoryState != app.activeDocument.historyStates[historyStateNow])
try {
app.activeDocument.suspendHistory(historyState, "Name()");
} catch (e) {
if (e.number != 8007) {
alert(e + " : " + e.line);
} else {
app.activeDocument.activeHistoryState = app.activeDocument.historyStates[historyStateNow];
app.activeDocument.suspendHistory(historyState + " [cancelled]", "");
app.activeDocument.activeHistoryState = app.activeDocument.historyStates[historyStateNow];
}
}
}
function Name() {
if (typeof jamEngine !== "object") {
var jamEngine = {};
function() {
function putInReference(ref, containers) {
if (containers.constructor === Array) {
var count = containers.length;
for (var i = 0; i < count; i += 1) {
var container = that.parseCompact(containers[i]);
var desiredClassId = that.uniIdStrToId(container[0]);
var typedValue = that.parseCompact(container[1]);
var form = typedValue[0];
var value = typedValue[1];
switch (form) {
case "<class>":
ref.putClass(desiredClassId);
break;
case "<enumerated>":
var enumerated = that.parseCompact(value);
ref.putEnumerated(desiredClassId, that.uniIdStrToId(enumerated[0]), that.uniIdStrToId(enumerated[1]));
break;
case "<identifier>":
ref.putIdentifier(desiredClassId, value);
break;
case "<index>":
ref.putIndex(desiredClassId, value);
break;
case "<name>":
ref.putName(desiredClassId, value);
break;
case "<offset>":
ref.putOffset(desiredClassId, value);
break;
case "<property>":
ref.putProperty(desiredClassId, that.uniIdStrToId(value));
break;
default:
throw new Error("[jamEngine putInReference] Unknown reference form: " + form)
break;
}
}
} else {
throw new Error("[jamEngine putInReference] JavaScript array expected")
}
}
function putInList(list, items) {
if (items.constructor === Array) {
var count = items.length;
for (var i = 0; i < count; i += 1) {
var item = that.parseCompact(items[i]);
var type = item[0];
var value = item[1];
switch (type) {
case "<boolean>":
list.putBoolean(value);
break;
case "<class>":
list.putClass(that.uniIdStrToId(value));
break;
case "<data>":
list.putData(value);
break;
case "<double>":
list.putDouble(value);
break;
case "<enumerated>":
var enumerated = that.parseCompact(value);
list.putEnumerated(that.uniIdStrToId(enumerated[0]), that.uniIdStrToId(enumerated[1]));
break;
case "<integer>":
list.putInteger(value);
break;
case "<largeInteger>":
list.putLargeInteger(value);
break;
case "<list>":
var actionList = new ActionList();
putInList(actionList, value);
list.putList(actionList);
break;
case "<object>":
var object = that.parseCompact(value);
if (object[1]) {
var actionDescriptor = new ActionDescriptor();
putInDescriptor(actionDescriptor, object[1]);
list.putObject(that.uniIdStrToId(object[0]), actionDescriptor);
} else {
list.putClass(that.uniIdStrToId(object[0]));
}
break;
case "<path>":
var fileRef = new File(value);
list.putPath(fileRef);
break;
case "<reference>":
var actionReference = new ActionReference();
putInReference(actionReference, value);
list.putReference(actionReference);
break;
case "<string>":
list.putString(value);
break;
case "<unitDouble>":
var unitDouble = that.parseCompact(value);
list.putUnitDouble(that.uniIdStrToId(unitDouble[0]), unitDouble[1]);
break;
default:
throw new Error("[jamEngine putInList] Unknown list type: " + type)
break;
}
}
} else {
throw new Error("[jamEngine putInList] JavaScript array expected")
}
}
function putInDescriptor(desc, members) {
if (members.constructor === Object) {
for (var key in members) {
if (members.hasOwnProperty(key)) {
var keyID = that.uniIdStrToId(key);
var member = that.parseCompact(members[key]);
var type = member[0];
var value = member[1];
switch (type) {
case "<boolean>":
desc.putBoolean(keyID, value);
break;
case "<class>":
desc.putClass(keyID, that.uniIdStrToId(value));
break;
case "<data>":
desc.putData(keyID, value);
break;
case "<double>":
desc.putDouble(keyID, value);
break;
case "<enumerated>":
var enumerated = that.parseCompact(value);
desc.putEnumerated(keyID, that.uniIdStrToId(enumerated[0]), that.uniIdStrToId(enumerated[1]));
break;
case "<integer>":
desc.putInteger(keyID, value);
break;
case "<largeInteger>":
desc.putLargeInteger(keyID, value);
break;
case "<list>":
var actionList = new ActionList();
putInList(actionList, value);
desc.putList(keyID, actionList);
break;
case "<object>":
var object = that.parseCompact(value);
if (object[1]) {
var actionDescriptor = new ActionDescriptor();
putInDescriptor(actionDescriptor, object[1]);
desc.putObject(keyID, that.uniIdStrToId(object[0]), actionDescriptor);
} else {
desc.putClass(keyID, that.uniIdStrToId(object[0]));
}
break;
case "<path>":
var fileRef = new File(value);
desc.putPath(keyID, fileRef);
break;
case "<reference>":
var actionReference = new ActionReference();
putInReference(actionReference, value);
desc.putReference(keyID, actionReference);
break;
case "<string>":
desc.putString(keyID, value);
break;
case "<unitDouble>":
var unitDouble = that.parseCompact(value);
desc.putUnitDouble(keyID, that.uniIdStrToId(unitDouble[0]), unitDouble[1]);
break;
default:
throw new Error("[jamEngine putInDescriptor] Unknown descriptor type: " + type)
break;
}
}
}
} else {
throw new Error("[jamEngine putInDescriptor] JavaScript object expected")
}
}
function getFromId(context, parentContext) {
var kind = context[0];
var id = context[1];
if (id < smallestHashValue) {
uniIdStr = app.typeIDToStringID(id);
} else {
uniIdStr = "'" + app.typeIDToCharID(id) + "'";
if (that.meaningfulIds) {
if (uniIdStr in contextRules) {
function resolveIdStr(candidates) {
var idStr = "";
for (var parentString in candidates) {
if (candidates.hasOwnProperty(parentString)) {
if (parentContext[1] === that.uniIdStrToId(parentString)) {
idStr = candidates[parentString];
break;
}
}
}
return idStr;
}
var resolvedIdStr = "";
var rule = contextRules[uniIdStr];
if (parentContext) {
switch (kind) {
case "<key>":
if (parentContext[0] === "<class>" && "<classKey>" in rule) {
resolvedIdStr = resolveIdStr(rule["<classKey>"]);
} else {
if (parentContext[0] === "<event>" && "<eventKey>" in rule) {
resolvedIdStr = resolveIdStr(rule["<eventKey>"]);
}
}
break;
case "<enumValue>":
if (parentContext[0] === "<enumType>" && "<typeValue>" in rule) {
resolvedIdStr = resolveIdStr(rule["<typeValue>"]);
}
break;
}
}
if (resolvedIdStr !== "") {
uniIdStr = resolvedIdStr;
} else {
if (kind in rule) {
uniIdStr = rule[kind];
}
}
} else {
var stringIDStr = app.typeIDToStringID(id);
if (stringIDStr !== "") {
uniIdStr = stringIDStr;
}
}
}
}
return uniIdStr;
}
function getFromReference(ref) {
var propertyId = 0;
var arr = [];
do {
try {
var desiredClassId = ref.getDesiredClass();
} catch (e) {
break;
}
if (propertyId !== 0) {
var propertyCompact = that.buildCompact("<property>", getFromId(["<key>", propertyId], ["<class>", desiredClassId]));
arr.push(that.buildCompact(getFromId(["<class>", propertyClassId]), propertyCompact));
propertyId = 0;
}
var aFormID = ref.getForm();
switch (aFormID) {
case ReferenceFormType.CLASSTYPE:
desiredCompact = that.buildCompact("<class>", null);
break;
case ReferenceFormType.ENUMERATED:
var enumTypeContext = ["<enumType>", ref.getEnumeratedType()];
var enumValueContext = ["<enumValue>", ref.getEnumeratedValue()];
desiredCompact = that.buildCompact("<enumerated>", that.buildCompact(getFromId(enumTypeContext), getFromId(enumValueContext, enumTypeContext)));
break;
case ReferenceFormType.IDENTIFIER:
desiredCompact = that.buildCompact("<identifier>", ref.getIdentifier());
break;
case ReferenceFormType.INDEX:
desiredCompact = that.buildCompact("<index>", ref.getIndex());
break;
case ReferenceFormType.NAME:
desiredCompact = that.buildCompact("<name>", ref.getName());
break;
case ReferenceFormType.OFFSET:
desiredCompact = that.buildCompact("<offset>", ref.getOffset());
break;
case ReferenceFormType.PROPERTY:
if (desiredClassId === propertyClassId) {
propertyId = ref.getProperty();
} else {
desiredCompact = that.buildCompact("<property>", getFromId(["<key>", ref.getProperty()], ["<class>", desiredClassId]));
}
break;
default:
throw new Error("[jamEngine getFromReference] Unknown reference form type: " + aFormID)
break;
}
if (desiredClassId !== propertyClassId) {
arr.push(that.buildCompact(getFromId(["<class>", desiredClassId]), desiredCompact));
}
ref = ref.getContainer();
} while (ref)
return arr;
}
function getFromList(list) {
var arr = [];
var itemCount = list.count;
for (var itemIndex = 0; itemIndex < itemCount; itemIndex += 1) {
try {
typeID = list.getType(itemIndex);
} catch (e) {
continue;
}
switch (typeID) {
case DescValueType.BOOLEANTYPE:
itemCompact = that.buildCompact("<boolean>", list.getBoolean(itemIndex));
break;
case DescValueType.CLASSTYPE:
itemCompact = that.buildCompact("<class>", getFromId(["<class>", list.getClass(itemIndex)]));
break;
case DescValueType.DOUBLETYPE:
itemCompact = that.buildCompact("<double>", list.getDouble(itemIndex));
break;
case DescValueType.ENUMERATEDTYPE:
var enumTypeContext = ["<enumType>", list.getEnumerationType(itemIndex)];
var enumValueContext = ["<enumValue>", list.getEnumerationValue(itemIndex)];
itemCompact = that.buildCompact("<enumerated>", that.buildCompact(getFromId(enumTypeContext), getFromId(enumValueContext, enumTypeContext)));
break;
case DescValueType.INTEGERTYPE:
itemCompact = that.buildCompact("<integer>", list.getInteger(itemIndex));
break;
case DescValueType.LISTTYPE:
itemCompact = that.buildCompact("<list>", getFromList(list.getList(itemIndex)));
break;
case DescValueType.OBJECTTYPE:
var objectTypeContext = ["<class>", list.getObjectType(itemIndex)];
var objectValue = list.getObjectValue(itemIndex);
itemCompact = that.buildCompact("<object>", that.buildCompact(getFromId(objectTypeContext), getFromDescriptor(objectValue, objectTypeContext)));
break;
case DescValueType.ALIASTYPE:
try {
var fileRef = list.getPath(itemIndex);
itemCompact = that.buildCompact("<path>", fileRef.fsName);
} catch (e) {
itemCompact = that.buildCompact("<path>", incompatiblePlatformPath);
}
break;
case DescValueType.REFERENCETYPE:
itemCompact = that.buildCompact("<reference>", getFromReference(list.getReference(itemIndex)));
break;
case DescValueType.STRINGTYPE:
itemCompact = that.buildCompact("<string>", list.getString(itemIndex));
break;
case DescValueType.UNITDOUBLE:
var unitTypeContext = ["<unit>", list.getUnitDoubleType(itemIndex)];
var doubleValue = list.getUnitDoubleValue(itemIndex);
itemCompact = that.buildCompact("<unitDouble>", that.buildCompact(getFromId(unitTypeContext), doubleValue));
break;
default:
try {
isRawType = typeID === DescValueType.RAWTYPE;
} catch (e) {
}
try {
isLargeIntegerType = typeID === DescValueType.LARGEINTEGERTYPE;
} catch (e) {
}
if (isRawType) {
itemCompact = that.buildCompact("<data>", list.getData(itemIndex));
} else if (isLargeIntegerType) {
itemCompact = that.buildCompact("<largeInteger>", list.getLargeInteger(itemIndex));
} else {
throw new Error("[jamEngine getFromList] Unknown descriptor value type: " + typeID)
}
break;
}
arr[itemIndex] = itemCompact;
}
return arr;
}
function getFromDescriptor(desc, parentContext) {
if (desc) {
var obj = {};
try {
keyCount = desc.count;
} catch (e) {
return null;
}
for (var keyIndex = 0; keyIndex < keyCount; keyIndex += 1) {
var keyID = desc.getKey(keyIndex);
var keyString = getFromId(["<key>", keyID], parentContext);
try {
typeID = desc.getType(keyID);
} catch (e) {
continue;
}
switch (typeID) {
case DescValueType.BOOLEANTYPE:
keyCompact = that.buildCompact("<boolean>", desc.getBoolean(keyID));
break;
case DescValueType.CLASSTYPE:
keyCompact = that.buildCompact("<class>", getFromId(["<class>", desc.getClass(keyID)]));
break;
case DescValueType.DOUBLETYPE:
keyCompact = that.buildCompact("<double>", desc.getDouble(keyID));
break;
case DescValueType.ENUMERATEDTYPE:
var enumTypeContext = ["<enumType>", desc.getEnumerationType(keyID)];
var enumValueContext = ["<enumValue>", desc.getEnumerationValue(keyID)];
keyCompact = that.buildCompact("<enumerated>", that.buildCompact(getFromId(enumTypeContext), getFromId(enumValueContext, enumTypeContext)));
break;
case DescValueType.INTEGERTYPE:
keyCompact = that.buildCompact("<integer>", desc.getInteger(keyID));
break;
case DescValueType.LISTTYPE:
keyCompact = that.buildCompact("<list>", getFromList(desc.getList(keyID)));
break;
case DescValueType.OBJECTTYPE:
var objectTypeContext = ["<class>", desc.getObjectType(keyID)];
var objectValue = desc.getObjectValue(keyID);
keyCompact = that.buildCompact("<object>", that.buildCompact(getFromId(objectTypeContext), getFromDescriptor(objectValue, objectTypeContext)));
break;
case DescValueType.ALIASTYPE:
try {
var fileRef = desc.getPath(keyID);
keyCompact = that.buildCompact("<path>", fileRef.fsName);
} catch (e) {
keyCompact = that.buildCompact("<path>", incompatiblePlatformPath);
}
break;
case DescValueType.REFERENCETYPE:
keyCompact = that.buildCompact("<reference>", getFromReference(desc.getReference(keyID)));
break;
case DescValueType.STRINGTYPE:
keyCompact = that.buildCompact("<string>", desc.getString(keyID));
break;
case DescValueType.UNITDOUBLE:
var unitTypeContext = ["<unit>", desc.getUnitDoubleType(keyID)];
var doubleValue = desc.getUnitDoubleValue(keyID);
keyCompact = that.buildCompact("<unitDouble>", that.buildCompact(getFromId(unitTypeContext), doubleValue));
break;
default:
try {
isRawType = typeID === DescValueType.RAWTYPE;
} catch (e) {
}
try {
isLargeIntegerType = typeID === DescValueType.LARGEINTEGERTYPE;
} catch (e) {
}
if (isRawType) {
keyCompact = that.buildCompact("<data>", desc.getData(keyID));
} else if (isLargeIntegerType) {
keyCompact = that.buildCompact("<largeInteger>", desc.getLargeInteger(keyID));
} else {
throw new Error("[jamEngine getFromDescriptor] Unknown descriptor value type: " + typeID)
}
break;
}
obj[keyString] = keyCompact;
}
return obj;
} else {
return null;
}
}
function getReferenceClassId(ref) {
classId = 0;
do {
try {
var desiredClassId = ref.getDesiredClass();
} catch (e) {
break;
}
if (desiredClassId !== propertyClassId) {
classId = desiredClassId;
break;
}
ref = ref.getContainer();
} while (ref)
return classId;
}
function simplifyRef(ref) {
var simplifiedRef = [];
for (var i = 0; i < ref.length; i += 1) {
var element = ref[i];
var simplifiedElement = {};
var desiredClass = element[0];
var form = element[1][0];
var value = element[1][1];
switch (form) {
case "<class>":
case "<identifier>":
case "<index>":
case "<name>":
case "<offset>":
case "<property":
simplifiedElement[desiredClass] = value;
break;
case "<enumerated>":
simplifiedElement[desiredClass] = value[1];
break;
default:
throw new Error("[jamEngine simplifyRef] Unexpected element form: " + form)
break;
}
simplifiedRef.push(simplifiedElement);
}
return simplifiedRef;
}
function simplifyItem(item, hook) {
var type = item[0];
var value = item[1];
switch (type) {
case "<boolean>":
case "<class>":
case "<data>":
case "<double>":
case "<integer>":
case "<largeInteger>":
case "<path>":
case "<string>":
simplifiedItem = value;
break;
case "<list>":
simplifiedItem = simplifyList(value, hook);
break;
case "<enumerated>":
case "<unitDouble>":
simplifiedItem = value[1];
break;
case "<object>":
simplifiedItem = simplifyDesc(value[1], hook);
break;
case "<reference>":
simplifiedItem = simplifyRef(value);
break;
default:
throw new Error("[jamEngine simplifyItem] Unexpected item type: " + type)
break;
}
return simplifiedItem;
}
function simplifyList(list, hook) {
var simplifiedList = [];
for (var i = 0; i < list.length; i += 1) {
simplifiedList.push(simplifyItem(list[i], hook));
}
return simplifiedList;
}
function simplifyDesc(desc, hook) {
var getDefaultValue = function(desc, key) {
return simplifyItem(desc[key], hook);
};
var simplifiedDesc = {};
for (var key in desc) {
if (desc.hasOwnProperty(key)) {
var value = undefined;
if (typeof hook === "function") {
value = hook(desc, key, getDefaultValue);
}
if (typeof value === "undefined") {
value = simplifyItem(desc[key], hook);
}
simplifiedDesc[key] = value;
}
}
return simplifiedDesc;
}
jamEngine.meaningfulIds = false;
jamEngine.parseFriendly = false;
jamEngine.displayDialogs = DialogModes.ERROR;
var conflictingStringIdStrs = {
"'Algn'": ["align", "alignment"],
"'AntA'": ["antiAlias", "antiAliasedPICTAcquire"],
"'BckL'": ["backgroundLayer", "backgroundLevel"],
"'BlcG'": ["blackGenerationType", "blackGenerationCurve"],
"'BlcL'": ["blackLevel", "blackLimit"],
"'Blks'": ["blacks", "blocks"],
"'BlrM'": ["blurMethod", "blurMore"],
"'BrgC'": ["brightnessEvent", "brightnessContrast"],
"'BrsD'": ["brushDetail", "brushesDefine"],
"'Brsh'": ["brush", "brushes"],
"'Clcl'": ["calculation", "calculations"],
"'ClrP'": ["colorPalette", "coloredPencil"],
"'Cnst'": ["constant", "constrain"],
"'CntC'": ["centerCropMarks", "conteCrayon"],
"'Cntr'": ["center", "contrast"],
"'CrtD'": ["createDroplet", "createDuplicate"],
"'CstP'": ["customPalette", "customPhosphors"],
"'Cstm'": ["custom", "customPattern"],
"'Drkn'": ["darken", "darkness"],
"'Dstr'": ["distort", "distortion", "distribute", "distribution"],
"'Dstt'": ["desaturate", "destWhiteMax"],
"'FlIn'": ["fileInfo", "fillInverse"],
"'Gd '": ["good", "guide"],
"'GnrP'": ["generalPreferences", "generalPrefs", "preferencesClass"],
"'GrSt'": ["grainStippled", "graySetup"],
"'Grdn'": ["gradientClassEvent", "gridMinor"],
"'Grn '": ["grain", "green"],
"'Grns'": ["graininess", "greens"],
"'HstP'": ["historyPreferences", "historyPrefs"],
"'HstS'": ["historyState", "historyStateSourceType"],
"'ImgP'": ["imageCachePreferences", "imagePoint"],
"'In '": ["in", "stampIn"],
"'IntW'": ["interfaceWhite", "intersectWith"],
"'Intr'": ["interfaceIconFrameDimmed", "interlace", "interpolation", "intersect"],
"'JPEG'": ["JPEG", "JPEGFormat"],
"'LghD'": ["lightDirection", "lightDirectional"],
"'LghO'": ["lightOmni", "lightenOnly"],
"'LghS'": ["lightSource", "lightSpot"],
"'Lns '": ["lens", "lines"],
"'Mgnt'": ["magenta", "magentas"],
"'MrgL'": ["mergeLayers", "mergedLayers"],
"'Mxm '": ["maximum", "maximumQuality"],
"'NTSC'": ["NTSC", "NTSCColors"],
"'NmbL'": ["numberOfLayers", "numberOfLevels"],
"'PlgP'": ["pluginPicker", "pluginPrefs"],
"'Pncl'": ["pencilEraser", "pencilWidth"],
"'Pnt '": ["paint", "point"],
"'Prsp'": ["perspective", "perspectiveIndex"],
"'PrvM'": ["previewMacThumbnail", "previewMagenta"],
"'Pstr'": ["posterization", "posterize"],
"'RGBS'": ["RGBSetup", "RGBSetupSource"],
"'Rds '": ["radius", "reds"],
"'ScrD'": ["scratchDisks", "screenDot"],
"'ShdI'": ["shadingIntensity", "shadowIntensity"],
"'ShpC'": ["shapeCurveType", "shapingCurve"],
"'ShrE'": ["sharpenEdges", "shearEd"],
"'Shrp'": ["sharpen", "sharpness"],
"'SplC'": ["splitChannels", "supplementalCategories"],
"'Spot'": ["spot", "spotColor"],
"'SprS'": ["separationSetup", "sprayedStrokes"],
"'StrL'": ["strokeLength", "strokeLocation"],
"'Strt'": ["saturation", "start"],
"'TEXT'": ["char", "textType"],
"'TIFF'": ["TIFF", "TIFFFormat"],
"'TglO'": ["toggleOptionsPalette", "toggleOthers"],
"'TrnG'": ["transparencyGamutPreferences", "transparencyGrid", "transparencyGridSize"],
"'TrnS'": ["transferSpec", "transparencyShape", "transparencyStop"],
"'Trns'": ["transparency", "transparent"],
"'TxtC'": ["textClickPoint", "textureCoverage"],
"'TxtF'": ["textureFile", "textureFill"],
"'UsrM'": ["userMaskEnabled", "userMaskOptions"],
"'c@#^'": ["inherits", "pInherits"],
"'comp'": ["comp", "sInt64"],
"'doub'": ["floatType", "IEEE64BitFloatingPoint", "longFloat"],
"'long'": ["integer", "longInteger", "sInt32"],
"'magn'": ["magnitude", "uInt32"],
"'null'": ["null", "target"],
"'shor'": ["sInt16", "sMInt", "shortInteger"],
"'sing'": ["IEEE32BitFloatingPoint", "sMFloat", "shortFloat"]
};
jamEngine.getConflictingStringIdStrs = function(charIdStr) {
return conflictingStringIdStrs[charIdStr] || null;
};
jamEngine.uniIdStrToId = function(uniIdStr) {
var id = 0;
if (typeof uniIdStr === "string") {
if (uniIdStr.length === 6 && uniIdStr.charAt(0) === "'" && uniIdStr.charAt(5) === "'") {
id = app.charIDToTypeID(uniIdStr.substring(1, 5));
} else {
id = app.stringIDToTypeID(uniIdStr);
}
}
return id;
};
var smallestHashValue = app.charIDToTypeID(" ");
jamEngine.idToUniIdStrs = function(id) {
var charIdStr = "";
var stringIdStr = app.typeIDToStringID(id);
if (id >= smallestHashValue) {
charIdStr = "'" + app.typeIDToCharID(id) + "'";
if (stringIdStr !== "") {
if (charIdStr in conflictingStringIdStrs) {
stringIdStr = conflictingStringIdStrs[charIdStr];
}
}
}
return [charIdStr, stringIdStr];
};
jamEngine.equivalentUniIdStrs = function(uniIdStr1, uniIdStr2) {
return this.uniIdStrToId(uniIdStr1) === this.uniIdStrToId(uniIdStr2);
};
var contextRules = {
"'Algn'": {
"<classKey>": {
bevelEmboss: "align",
frameFX: "align",
gradientFill: "align",
gradientLayer: "align",
patternFill: "align",
patternLayer: "align"
},
"<event>": "align",
"<key>": "alignment"
},
"'AntA'": {
"<class>": "antiAliasedPICTAcquire",
"<key>": "antiAlias"
},
"'BckL'": {
"<class>": "backgroundLayer",
"<key>": "backgroundLevel"
},
"'BlcG'": {
"<enumType>": "blackGenerationType",
"<key>": "blackGenerationCurve"
},
"'BlcL'": {
"<classKey>": {
"'GEfc'": "blackLevel",
CMYKSetup: "blackLimit"
},
"<eventKey>": {
reticulation: "blackLevel"
}
},
"'Blks'": {
"<typeValue>": {
colors: "blacks",
extrudeType: "blocks"
}
},
"'BlrM'": {
"<enumType>": "blurMethod",
"<event>": "blurMore",
"<key>": "blurMethod"
},
"'BrgC'": {
"<class>": "brightnessContrast",
"<event>": "brightnessContrast"
},
"'BrsD'": {
"<enumValue>": "brushesDefine",
"<key>": "brushDetail"
},
"'Brsh'": {
"<class>": "brush",
"<key>": "brushes"
},
"'Clcl'": {
"<class>": "calculation",
"<enumValue>": "calculations",
"<key>": "calculation"
},
"'ClrP'": {
"<typeValue>": {
"'GEft'": "coloredPencil"
},
"<enumType>": "colorPalette",
"<event>": "coloredPencil"
},
"'Cnst'": {
"<classKey>": {
channelMatrix: "constant"
},
"<unknown>": "constrain"
},
"'CntC'": {
"<typeValue>": {
"'GEft'": "conteCrayon"
},
"<event>": "conteCrayon",
"<key>": "centerCropMarks"
},
"'Cntr'": {
"<classKey>": {
"'GEfc'": "contrast",
brightnessContrast: "contrast",
document: "center",
polygon: "center",
quadrilateral: "center"
},
"<eventKey>": {
adaptCorrect: "contrast",
brightnessEvent: "contrast",
grain: "contrast",
halftoneScreen: "contrast",
sumie: "contrast",
tornEdges: "contrast",
waterPaper: "contrast"
},
"<enumValue>": "center"
},
"'CrtD'": {
"<enumValue>": "createDuplicate",
"<event>": "createDroplet"
},
"'CstP'": {
"<class>": "customPhosphors",
"<key>": "customPalette"
},
"'Cstm'": {
"<enumValue>": "customPattern",
"<event>": "custom",
"<key>": "custom"
},
"'Drkn'": {
"<enumValue>": "darken",
"<key>": "darkness"
},
"'Dstr'": {
"<classKey>": {
"'GEfc'": "distortion"
},
"<eventKey>": {
glass: "distortion",
addNoise: "distribution"
},
"<enumType>": "distribution",
"<enumValue>": "distort",
"<event>": "distribute"
},
"'Dstt'": {
"<enumValue>": "desaturate",
"<event>": "desaturate",
"<key>": "destWhiteMax"
},
"'FlIn'": {
"<typeValue>": {
fillColor: "fillInverse",
menuItemType: "fileInfo"
},
"<class>": "fileInfo",
"<key>": "fileInfo"
},
"'Gd '": {
"<class>": "guide",
"<enumValue>": "good"
},
"'GnrP'": {
"<class>": "preferencesClass",
"<enumValue>": "generalPreferences",
"<key>": "generalPrefs"
},
"'GrSt'": {
"<class>": "graySetup",
"<enumValue>": "grainStippled",
"<key>": "graySetup"
},
"'Grdn'": {
"<class>": "gradientClassEvent",
"<event>": "gradientClassEvent",
"<key>": "gridMinor"
},
"'Grn '": {
"<typeValue>": {
"'GEft'": "grain"
},
"<classKey>": {
"'GEfc'": "grain",
RGBColor: "green",
blackAndWhite: "green",
channelMatrix: "green",
channelMixer: "green"
},
"<eventKey>": {
blackAndWhite: "green",
channelMixer: "green",
filmGrain: "grain"
},
"<enumValue>": "green",
"<event>": "grain"
},
"'Grns'": {
"<enumValue>": "greens",
"<key>": "graininess"
},
"'HstP'": {
"<enumValue>": "historyPreferences",
"<key>": "historyPrefs"
},
"'HstS'": {
"<class>": "historyState",
"<enumType>": "historyStateSourceType"
},
"'ImgP'": {
"<class>": "imagePoint",
"<enumValue>": "imageCachePreferences"
},
"'In '": {
"<enumValue>": "stampIn",
"<key>": "in"
},
"'IntW'": {
"<event>": "intersectWith",
"<key>": "interfaceWhite"
},
"'Intr'": {
"<typeValue>": {
shapeOperation: "intersect"
},
"<classKey>": {
GIFFormat: "interlace",
SaveForWeb: "interlace",
application: "interfaceIconFrameDimmed",
computedBrush: "interpolation",
dBrush: "interpolation",
gradientClassEvent: "interpolation",
photoshopEPSFormat: "interpolation",
sampledBrush: "interpolation"
},
"<eventKey>": {
convertMode: "interpolation",
imageSize: "interpolation",
transform: "interpolation"
},
"<event>": "intersect"
},
"'JPEG'": {
"<class>": "JPEGFormat",
"<enumValue>": "JPEG"
},
"'LghD'": {
"<enumType>": "lightDirection",
"<enumValue>": "lightDirectional",
"<key>": "lightDirection"
},
"'LghO'": {
"<typeValue>": {
diffuseMode: "lightenOnly",
lightType: "lightOmni"
}
},
"'LghS'": {
"<class>": "lightSource",
"<enumValue>": "lightSpot",
"<key>": "lightSource"
},
"'Lns '": {
"<enumType>": "lens",
"<enumValue>": "lines",
"<key>": "lens"
},
"'Mgnt'": {
"<typeValue>": {
channel: "magenta",
colors: "magentas",
guideGridColor: "magenta"
},
"<key>": "magenta"
},
"'MrgL'": {
"<enumValue>": "mergedLayers",
"<event>": "mergeLayers"
},
"'Mxm '": {
"<enumValue>": "maximumQuality",
"<event>": "maximum",
"<key>": "maximum"
},
"'NTSC'": {
"<enumValue>": "NTSC",
"<event>": "NTSCColors"
},
"'NmbL'": {
"<classKey>": {
"'GEfc'": "numberOfLevels",
document: "numberOfLayers"
},
"<eventKey>": {
cutout: "numberOfLevels"
}
},
"'PlgP'": {
"<class>": "pluginPrefs",
"<enumValue>": "pluginPicker",
"<key>": "pluginPrefs"
},
"'Pncl'": {
"<enumValue>": "pencilEraser",
"<key>": "pencilWidth"
},
"'Pnt '": {
"<typeValue>": {
textType: "point"
},
"<class>": "point",
"<event>": "paint"
},
"'Prsp'": {
"<enumValue>": "perspective",
"<key>": "perspectiveIndex"
},
"'PrvM'": {
"<enumValue>": "previewMagenta",
"<key>": "previewMacThumbnail"
},
"'Pstr'": {
"<class>": "posterize",
"<event>": "posterize",
"<key>": "posterization"
},
"'RGBS'": {
"<enumType>": "RGBSetupSource",
"<key>": "RGBSetup"
},
"'Rds '": {
"<enumValue>": "reds",
"<key>": "radius"
},
"'ScrD'": {
"<enumValue>": "screenDot",
"<key>": "scratchDisks"
},
"'ShdI'": {
"<classKey>": {
"'GEfc'": "shadowIntensity"
},
"<eventKey>": {
watercolor: "shadowIntensity"
},
"<unknown>": "shadingIntensity"
},
"'ShpC'": {
"<classKey>": {
application: "shapingCurve"
},
"<class>": "shapingCurve",
"<key>": "shapeCurveType"
},
"'ShrE'": {
"<event>": "sharpenEdges",
"<key>": "shearEd"
},
"'Shrp'": {
"<event>": "sharpen",
"<key>": "sharpness"
},
"'SplC'": {
"<event>": "splitChannels",
"<key>": "supplementalCategories"
},
"'Spot'": {
"<enumValue>": "spotColor",
"<key>": "spot"
},
"'SprS'": {
"<typeValue>": {
"'GEft'": "sprayedStrokes"
},
"<enumValue>": "separationSetup",
"<event>": "sprayedStrokes"
},
"'StrL'": {
"<enumType>": "strokeLocation",
"<key>": "strokeLength"
},
"'Strt'": {
"<classKey>": {
currentToolOptions: "saturation",
fileNamingRules: "start",
HSBColorClass: "saturation",
hueSatAdjustment: "saturation",
hueSatAdjustmentV2: "saturation",
lineClass: "start",
range: "start",
vibrance: "saturation"
},
"<eventKey>": {
replaceColor: "saturation",
variations: "saturation",
vibrance: "saturation"
},
"<enumValue>": "saturation"
},
"'TEXT'": {
"<enumType>": "textType",
"<key>": "textType"
},
"'TIFF'": {
"<class>": "TIFFFormat",
"<enumValue>": "TIFF"
},
"'TglO'": {
"<enumValue>": "toggleOptionsPalette",
"<key>": "toggleOthers"
},
"'TrnG'": {
"<classKey>": {
application: "transparencyGrid",
transparencyPrefs: "transparencyGridSize"
},
"<enumType>": "transparencyGridSize",
"<enumValue>": "transparencyGamutPreferences"
},
"'TrnS'": {
"<classKey>": {
bevelEmboss: "transparencyShape",
dropShadow: "transparencyShape",
innerGlow: "transparencyShape",
innerShadow: "transparencyShape",
outerGlow: "transparencyShape"
},
"<class>": "transparencyStop",
"<unknown>": "transferSpec"
},
"'Trns'": {
"<enumValue>": "transparent",
"<key>": "transparency"
},
"'TxtC'": {
"<classKey>": {
"'GEfc'": "textureCoverage",
textLayer: "textClickPoint"
},
"<eventKey>": {
underpainting: "textureCoverage"
}
},
"'TxtF'": {
"<event>": "textureFill",
"<key>": "textureFile"
},
"'UsrM'": {
"<enumType>": "userMaskOptions",
"<key>": "userMaskEnabled"
},
"'null'": {
"<class>": "null",
"<enumValue>": "null",
"<event>": "null",
"<key>": "target"
}
};
var incompatiblePlatformPath = "";
var getEventId = app.stringIDToTypeID("get");
var targetKeyId = app.stringIDToTypeID("target");
var propertyClassId = app.stringIDToTypeID("property");
jamEngine.jsonToActionDescriptor = function(descriptorObj) {
that = this;
if (descriptorObj) {
actionDescriptor = new ActionDescriptor();
putInDescriptor(actionDescriptor, descriptorObj);
}
return actionDescriptor;
};
//代码过长，部分代码省略，如需请私信博主获取
3.代码转执行
使用记事本或者notepad++等文本编辑器，将代码拷贝至文本文件，然后修改后缀名为js或者jsx，最后再PS软件菜单文件》脚本》浏览，点执行即可，也可以将脚本放在预设文件夹内，会显示再脚本下的二级子菜单。如下图所示：
PS脚本执行.png
4.作者答疑
文章引用至 作者知了-联系方式1
文章引用至 作者知了-联系方式2
