/*******************************************************************/
/*                                                                 */
/*                      ADOBE CONFIDENTIAL                         */
/*                   _ _ _ _ _ _ _ _ _ _ _ _ _                     */
/*                                                                 */
/* Copyright 2000 Adobe Systems Incorporated                       */
/* All Rights Reserved.                                            */
/*                                                                 */
/* NOTICE:  All information contained herein is, and remains the   */
/* property of Adobe Systems Incorporated and its suppliers, if    */
/* any.  The intellectual and technical concepts contained         */
/* herein are proprietary to Adobe Systems Incorporated and its    */
/* suppliers and may be covered by U.S. and Foreign Patents,       */
/* patents in process, and are protected by trade secret or        */
/* copyright law.  Dissemination of this information or            */
/* reproduction of this material is strictly forbidden unless      */
/* prior written permission is obtained from Adobe Systems         */
/* Incorporated.                                                   */
/*                                                                 */
/*******************************************************************/
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
//
//	File:
//		PIUActionUtils.cpp
//
//	Description:
//		Utility routines for getting information out of descriptors.
//		This is the heart of the Listener debug version PIUDumpDescriptor.
//
//	Version history:
//		Version 1.0.0	6/29/2000	Created for Photoshop 6.0.
//			Written by Thomas Ruark.
//
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
//	Includes
//-------------------------------------------------------------------------------
#include "PIUActionUtils.h"



//-------------------------------------------------------------------------------
//	Classes
//-------------------------------------------------------------------------------
// Handy class for the listener debug output
// Keeps track of objects that need to be freed
class FreeZone {
public:
	FreeZone();
	~FreeZone();

	void Add(PIActionReference);
	void Add(PIActionList);
	void Add(PIActionDescriptor);
	void Add(Handle);
	void Output(ofstream&);
	
private:
	void Add(char* text, long value);
	vector<char*> v_array;
};



//-------------------------------------------------------------------------------
//	Locals
//-------------------------------------------------------------------------------
// Local variables so the output file looks nicer
static int16 tabLevel;
const char* ecs = "if (error) goto returnError;\n\n";
// Local variable that keeps track of things I need to free
static FreeZone* freeZone = NULL;
// What is the maximum string I have in the PSConst array
static int16 maxHashStringSize = 0;



//-------------------------------------------------------------------------------
//	Local functions
//-------------------------------------------------------------------------------
// Local function definitions
static void DumpInfoFromReference(PIActionReference inputRef, ofstream& fileOut);
static void DumpInfoFromList(const PIActionList inputList, ofstream& fileOut);
static void DumpInfoFromDescriptor(const PIActionDescriptor inputDesc, ofstream& fileOut);
static void TabOver(ofstream & fileOut);
static void LongToStr(int32 inputLong, char* inputKeyType, char* returnString);
static unsigned long StrToLong(const char* inputStr);
static void PIUIDToChar(const unsigned long inType, char* outChars);
static void CalcMaxHashStringSize(void);



//-------------------------------------------------------------------------------
//
//	PIUCheckPlayResult
//
//	Check the descriptor and see if it was a good Play(). 
//
//	NOTE:
//	Some Play() commands are not expected to return a valid result desciptor.
//
//-------------------------------------------------------------------------------
SPErr PIUCheckPlayResult(PIActionDescriptor result)
{
	SPErr error = kSPNoError;
	Boolean hasKey = false;

	if (result == NULL)
	{
		error = -1;
	}
	else
	{
		error = sPSActionDescriptor->HasKey(result, keyMessage, &hasKey);
		if (hasKey)
		{
			error = -1;
		}
	}
	return error;
}



//-------------------------------------------------------------------------------
//
//	PIUDumpDescriptor
//
//	Goes through everything in the result descriptor and dumps it and its
//	type. Has recursive functions that can get descriptors out of descriptors,
//	lists out of descriptors, descriptors out of lists, 
//	and all other combinations.
//
//-------------------------------------------------------------------------------
void PIUDumpDescriptor(const DescriptorEventID event,	
					   const PIActionDescriptor result, 
					   const char* fullpathtofile)
{

	// You probably don't want the overhead of this routine in your
	// non-debug code, so I'll define this and its strings only for
	// a debug build:
	#ifdef _DEBUG

	CalcMaxHashStringSize();
	
	if (sPSActionDescriptor == NULL ||
	    sPSActionList == NULL ||
	    sPSActionReference == NULL ||
	    sPSActionControl == NULL)
	    return;
	    
	freeZone = new FreeZone;
	if (freeZone == NULL)	return;

	char* eventIDAsString = new char[maxHashStringSize];// the string name of the event
	if (eventIDAsString == NULL) return;

	tabLevel = 0;    // indentation of the output strings

	// Create the output file and append to whatever is there
	ofstream fileOut(fullpathtofile, ios_base::app|ios_base::out);

	// Get the event define name for this event
	LongToStr(event, "event", eventIDAsString);

	// Wrap each event into a function call with the event as the
	// function name
	fileOut << "SPErr Play" << eventIDAsString << "(/*your parameters go here*/void)" << endl;
	fileOut << "{" << endl;

	// Set the tab level over one for clarity
	tabLevel++;
	TabOver(fileOut);

	// Create a variable for the "Play" result
	fileOut << "PIActionDescriptor result = NULL;" << endl;

	// Create variables to hold all of the possible runtime ID(s)
	TabOver(fileOut);
	fileOut << "DescriptorTypeID runtimeKeyID;" << endl;
	TabOver(fileOut);
	fileOut << "DescriptorTypeID runtimeTypeID;" << endl;
	TabOver(fileOut);
	fileOut << "DescriptorTypeID runtimeObjID;" << endl;
	TabOver(fileOut);
	fileOut << "DescriptorTypeID runtimeEnumID;" << endl;
	TabOver(fileOut);
	fileOut << "DescriptorTypeID runtimeClassID;" << endl;
	TabOver(fileOut);
	fileOut << "DescriptorTypeID runtimePropID;" << endl;
	TabOver(fileOut);
	fileOut << "DescriptorTypeID runtimeUnitID;" << endl;
	TabOver(fileOut);
	fileOut << "SPErr error = kSPNoError;" << endl;

	// Main recursive routine for pulling apart a descriptor
	DumpInfoFromDescriptor(result, fileOut);

	// Check to see if this is a 'Hash' type of event or a unique ID 
	// string. If it is a unique ID string then you have to get the 
	// runtime ID for that event and play.
	if (event < SmallestHashValue)
	{
		// Format the output
		TabOver(fileOut);
		fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
				<< eventIDAsString << "\", &runtimeEventID);" << endl;
		TabOver(fileOut);
		fileOut << ecs;

		// Update for the "Play" string
		strcpy(eventIDAsString, "runtimeEventID");
	}

	// Format the "Play" call to the log file
	TabOver(fileOut);
	if (result)
		fileOut << "error = sPSActionControl->Play(&result, " 
				<< eventIDAsString << ", desc" << result 
				<< ", plugInDialogSilent);" << endl;
	else
		fileOut << "error = sPSActionControl->Play(&result, " 
				<< eventIDAsString << ", NULL, plugInDialogSilent);" << endl;

	TabOver(fileOut);
	fileOut << ecs;

	fileOut << "returnError:" << endl;

	TabOver(fileOut);
	fileOut << "if (result != NULL) sPSActionDescriptor->Free(result);" << endl;

	freeZone->Output(fileOut);

	// Finish off the function call
	TabOver(fileOut);
	fileOut << "return error;" << endl;

	fileOut << "}" << endl << endl;

	delete [] eventIDAsString;
	delete freeZone;

	#else // not in debug mode
		#ifdef __MWERKS__
			#pragma unused (event)
			#pragma unused (result)
			#pragma unused (fullpathtofile)
		#endif // I know we're not using these in the Mac version. Don't warn.
	#endif // _DEBUG
} // end DumpDescriptor


	
//-------------------------------------------------------------------------------
//
//	DumpInfoFromReference
//
//	Goes through the reference and dumps it and its	type. The while loop takes
//	care of containers in the reference.
//
//-------------------------------------------------------------------------------
static void DumpInfoFromReference(PIActionReference  inputRef, ofstream & fileOut)
{

	// You probably don't want the overhead of this routine in your
	// non-debug code, so I'll define this and its strings only for
	// a debug build:
	#ifdef _DEBUG

	PIActionReference containerRef = NULL;
	const char* sar = "error = sPSActionReference->";

	// If their is no reference, don't bother.
	if (inputRef == NULL) return;

	// Create a new reference item
	TabOver(fileOut);
	fileOut << "// Move this to the top of the routine!" << endl;

	TabOver(fileOut);
	fileOut << "PIActionReference ref" << inputRef << " = NULL;" << endl;

	// The making of this reference
	TabOver(fileOut);
	fileOut << sar << "Make(&ref" << inputRef << ");" << endl;
	TabOver(fileOut);
	fileOut << ecs;

	freeZone->Add(inputRef);

	// As long as their is a valid reference keep going.
	// Reference's can have container's which are more pieces to the reference.

	// They look like another reference but are actually part of the same reference.
	// So keep track of the original reference number here and use it always below.
	PIActionReference originalRef = inputRef;

	while (inputRef)
	{

		// Get the form type for this reference.
		DescriptorFormID	formType;
		sPSActionReference->GetForm(inputRef, &formType);

		// What class is in the reference
		DescriptorClassID	desiredClass;
		sPSActionReference->GetDesiredClass(inputRef, &desiredClass);

		// Convert the class 'Hash' to the string for output later, "classHash"
		char* desiredClassStr = new char[maxHashStringSize];
		if (desiredClassStr == NULL) return;

		LongToStr(desiredClass, "class", desiredClassStr); 
		
		if (desiredClass < SmallestHashValue)
		{
			// Format the output
			TabOver(fileOut);
			fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
					<< desiredClassStr << "\", &runtimeClassID);" << endl;
			TabOver(fileOut);
			fileOut << ecs;
			
			strcpy(desiredClassStr, "runtimeClassID");
		}
		
		// Pull the next bit of information out based on the type
		switch(formType)
		{
			case formName:
				// Get some local variables
				uint32 nameLength;
				char* nameString;
				size_t actualLength;

				// See how long this string is
				sPSActionReference->GetNameLength(inputRef, &nameLength);
				
				// Make some room
				actualLength = ++nameLength; // make room for the null termination
				nameString = new char[actualLength];
				if (nameString == NULL) return;

				if ((actualLength == nameLength) && nameString)
				{
					// Pull the name out of the reference
					sPSActionReference->GetName(inputRef, nameString, nameLength);

					// Format the output
					TabOver(fileOut);
					fileOut << sar << "PutName(ref" << originalRef << ", " 
							<< desiredClassStr << ", \"" << nameString 
							<< "\");" << endl;
				}
				else
				{
					// Report the error in the file
					TabOver(fileOut);
					fileOut << "ERROR: " << sar << "PutName" << endl;
				}

				//sPSBuffer->Dispose(&nameString);
				delete [] nameString;
				break;

			case formIndex:
				// Get some local variables
				uint32 indexValue;

				// Pull the index out of the reference
				sPSActionReference->GetIndex(inputRef, &indexValue);

				// Format the output
				TabOver(fileOut);
				fileOut << sar << "PutIndex(ref" << originalRef << ", " 
						<< desiredClassStr << ", " << indexValue << ");" << endl;
				break;
			
			case formClass:
				// Get some local variable
				DescriptorClassID	classValue;
				char* cvString;
				cvString = new char[maxHashStringSize];
				if (cvString == NULL) return;

				// Get the desired class out of the reference
				sPSActionReference->GetDesiredClass(inputRef, &classValue);

				// Convert the 'Hash' to a "hashString"
				LongToStr(classValue, "class", cvString);

				if (classValue < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
							<< cvString << "\", &runtimeClassID);" << endl;
					TabOver(fileOut);
					fileOut << ecs;
			
					strcpy(cvString, "runtimeClassID");
				}
		
				// Format the output
				TabOver(fileOut);
				fileOut << sar << "PutClass(ref" << originalRef << ", " 
						<< cvString << ");" << endl;

				delete [] cvString;
				break;
			
			case formEnumerated:
				// Get some local variable
				DescriptorEnumTypeID enumTypeID;
				DescriptorEnumID	 enumID;
				char* enumTypeIDStr;
				enumTypeIDStr = new char[maxHashStringSize];
				if (enumTypeIDStr == NULL) return;
				char* enumIDStr;
				enumIDStr = new char[maxHashStringSize];
				if (enumIDStr == NULL) return;

				// Get the enumeration and it's type out
				sPSActionReference->GetEnumerated(inputRef, &enumTypeID, &enumID);

				// Convert the 'Hash' to a "hashString"
				LongToStr(enumTypeID, "type", enumTypeIDStr);

				if (enumTypeID < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
							<< enumTypeIDStr << "\", &runtimeTypeID);" << endl;
					TabOver(fileOut);
					fileOut << ecs;
			
					strcpy(enumTypeIDStr, "runtimeTypeID");
				}
		
				LongToStr(enumID, "enum", enumIDStr);

				if (enumID < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
							<< enumIDStr << "\", &runtimeEnumID);" << endl;
					TabOver(fileOut);
					fileOut << ecs;
			
					strcpy(enumIDStr, "runtimeEnumID");
				}
		
				// Format the output
				TabOver(fileOut);
				fileOut << sar << "PutEnumerated(ref" << originalRef << ", " 
						<< desiredClassStr << ", " << enumTypeIDStr << ", " 
						<< enumIDStr << ");" << endl;
				delete [] enumIDStr;
				delete [] enumTypeIDStr;
				break;
			
			case formProperty:
				// Get some local variable
				DescriptorKeyID	propID;
				char* propIDStr;
				propIDStr = new char[maxHashStringSize];
				if (propIDStr == NULL) return;

				// Pull the information
				sPSActionReference->GetProperty(inputRef, &propID);

				LongToStr(propID, "key", propIDStr);
					
				if (propID < SmallestHashValue)
				{
					//Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
						<< propIDStr << "\", &runtimePropID);" << endl;

					TabOver(fileOut);
					fileOut << ecs;

					// Update for the string
					strcpy(propIDStr, "runtimePropID");
					
				}

				// Format the output
				TabOver(fileOut);
				fileOut << sar << "PutProperty(ref" << originalRef << ", " 
						<< desiredClassStr << ", " << propIDStr << ");" << endl;

				delete [] propIDStr;
				break;
			
			case formIdentifier:
				// Get some local variable
				uint32 identifierID;

				sPSActionReference->GetIdentifier(inputRef, &identifierID);

				// Format the output
				TabOver(fileOut);
				fileOut << sar << "PutIdentifier(ref" << originalRef << ", " 
						<< desiredClassStr << ", " << identifierID << ");" << endl;
				break;
			
			case formOffset:
				// Get some local variable
				int32 offset;

				// Pull the info
				sPSActionReference->GetOffset(inputRef, &offset);
				
				// Format the output
				TabOver(fileOut);
				fileOut << sar << "PutOffset(ref" << originalRef << ", " 
					<< desiredClassStr << ", " << offset << ");" << endl;
				break;
			
			default:
				// Better not ever, never get into here
				// Get some local variable
				char* formTypeStr;
				formTypeStr = new char[maxHashStringSize];
				if (formTypeStr == NULL) return;

				// Convert the 'Hash' to a "hashString"
				LongToStr(formType, "form", formTypeStr);

				if (formType < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
							<< formTypeStr << "\", &runtimeTypeID);" << endl;
					TabOver(fileOut);
					fileOut << ecs;
			
					strcpy(formTypeStr, "runtimeTypeID");
				}
		
				// Format the output
				TabOver(fileOut);
				fileOut << "ERROR: DumpInfoFromReferene on formID = " 
					<< formTypeStr << endl;
				delete [] formTypeStr;
				break;
			
		} // end switch on formType
		
		TabOver(fileOut);
		fileOut << ecs;

		// make sure you free the ref value in case this is the second time through the loop
		if (containerRef != NULL)
		{
			sPSActionReference->Free(containerRef);
			containerRef = NULL;
		}

		// see if this reference has a container reference to pull apart
		OSErr err = sPSActionReference->GetContainer(inputRef, &containerRef);

		// it could either err or have a refVale of NULL which is like an error
		if (!err && containerRef != NULL)
			// Update the inputRef and let the while loop continue
			inputRef = containerRef;
		else
			// Update the inputRef and stop the while loop
			inputRef = NULL;

		delete [] desiredClassStr;
		
	} // end while
	#else
		#ifdef __MWERKS__
			#pragma unused (inputRef)
			#pragma unused (fileOut)
		#endif // I know we're not using these in the Mac version. Don't warn.
	#endif // _DEBUG

}// end DumpInfoFromReference
	


//-------------------------------------------------------------------------------
//
//	DumpInfoFromList
//
//	Goes through the list and dumps it and its types. Has recursive functions
//  that can get descriptors out of descriptors and other combinations.
//
//-------------------------------------------------------------------------------
static void DumpInfoFromList(const PIActionList inputList,
							 ofstream & fileOut)
{

	// You probably don't want the overhead of this routine in your
	// non-debug code, so I'll define this and its strings only for
	// a debug build:
	#ifdef _DEBUG

	const char* sal = "error = sPSActionList->";
	
	// If no list then no go.
	if (inputList == NULL)
		return;
		
	// Get the number of items in this list, return on error
	uint32 listCount = 0;
	uint32 counter = 0;
	if (sPSActionList->GetCount(inputList, &listCount))
		return;

	// Format the output
	TabOver(fileOut);
	fileOut << "// Move this to the top of the routine!" << endl;

	TabOver(fileOut);
	fileOut << "PIActionList list" << inputList << " = NULL;" << endl;

	TabOver(fileOut);
	fileOut << sal << "Make(&list" << inputList << ");" << endl;

	TabOver(fileOut);
	fileOut << ecs;

	freeZone->Add(inputList);

	// Loop throught until all the items are pulled out
	while (counter < listCount)
	{
		DescriptorTypeID typeID;

		// Get the type information for this list item
		sPSActionList->GetType(inputList, counter, &typeID);

		// Pull the next bit of information out based on the type
		switch (typeID)
		{
			case typeInteger:
				// Get some local data
				int32	intValue;

				// Pull the info
				sPSActionList->GetInteger(inputList, counter, &intValue);

				// Format the output
				TabOver(fileOut);
				fileOut << sal << "PutInteger(list" << inputList << ", " 
					<< intValue << ");" << endl;
				break;

			case typeFloat:
				// Get some local data
				double	doubleValue;

				// Pull the info
				sPSActionList->GetFloat(inputList, counter, &doubleValue);

				// Format the output
				TabOver(fileOut);
				fileOut << sal << "PutFloat(list" << inputList << ", " 
					<< doubleValue << ");" << endl;
				break;

			case typeUnitFloat:
				// Get some local data
				double	unitDoubleValue;
				DescriptorUnitID unitID;
				char* unitIDStr;
				unitIDStr = new char[maxHashStringSize];
				if (unitIDStr == NULL) return;

				// Pull the info
				sPSActionList->GetUnitFloat(inputList, 
					                        counter, 
											&unitID, 
											&unitDoubleValue);

				// Convert the 'Hash' to a "hashString"
				LongToStr(unitID, "unit", unitIDStr);

				if (unitID < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
							<< unitIDStr << "\", &runtimeUnitID);" << endl;
					TabOver(fileOut);
					fileOut << ecs;
			
					strcpy(unitIDStr, "runtimeUnitID");
				}
		
				// Format the output
				TabOver(fileOut);
				fileOut << sal << "PutUnitFloat(list" << inputList << ", " 
					<< unitIDStr << ", " << unitDoubleValue << ");" << endl;
				delete [] unitIDStr;
				break;

			case typeChar:
				// Get some local data
				uint32 charLen;
				char* charValue;
				size_t actualLength;

				// Pull the info
				sPSActionList->GetStringLength(inputList, counter, &charLen);

				// Make some room
				actualLength = ++charLen; // make room for the null termination
				charValue = new char[actualLength];
				if (charValue == NULL) return;

				if ((actualLength == charLen) && charValue)
				{
					sPSActionList->GetString(inputList, 
										     counter, 
											 charValue, 
											 actualLength);

					// Format the output
					TabOver(fileOut);
					fileOut << sal << "PutString(list" << inputList << ", \"" 
						<< charValue << "\");" << endl;
				}
				else
				{
					TabOver(fileOut);
					fileOut << "ERROR: " << sal << "PutString" << endl;
				}

				// Give back the memory
				//sPSBuffer->Dispose(&charValue);
				delete [] charValue;
				break;

			case typeBoolean:
				// Get some local data
				Boolean boolValue;

				// Pull the info
				sPSActionList->GetBoolean(inputList, counter, &boolValue);

				// Format the output
				TabOver(fileOut);
				fileOut << sal << "PutBoolean(list" << inputList << ", " 
					<< (boolValue ? "true" : "false") << ");" << endl;
				break;

			case typeObject:
				// Get some local data
				DescriptorClassID objClassID;
				char* objClassIDStr;
				objClassIDStr = new char[maxHashStringSize];
				if (objClassIDStr == NULL) return;
				PIActionDescriptor objDesc;
				objDesc = NULL;

				// Pull the info
				sPSActionList->GetObject(inputList, counter, &objClassID, &objDesc);

				// Convert the 'Hash' to a "hashString"
				LongToStr(objClassID, "class", objClassIDStr);

				// change the indentation level for this object in a list
				// this makes it easier to read the output file
				// Recurse into this routine to pull apart the objDesc
				tabLevel++;
				DumpInfoFromDescriptor(objDesc, fileOut);
				tabLevel--;

				// Check to see if this is a 'Hash' type of event or a unique ID 
				// string. If it is a unique ID string then you have to get the 
				// runtime ID for that event and play.
				if (objClassID < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
						<< objClassIDStr << "\", &runtimeClassID);" << endl;

					// Update for the string
					strcpy(objClassIDStr, "runtimeClassID");

					TabOver(fileOut);
					fileOut << ecs;
				}

				// Format the output
				TabOver(fileOut);
				fileOut << sal << "PutObject(list" << inputList << ", " 
					<< objClassIDStr << ", desc" << objDesc << ");" << endl;

				if (objDesc != NULL) sPSActionDescriptor->Free(objDesc);

				delete [] objClassIDStr;

				break;

			case typeGlobalObject:
				// Get some local data
				DescriptorClassID globObjClassID;
				char* globObjClassIDStr;
				globObjClassIDStr = new char[maxHashStringSize];
				if (globObjClassIDStr == NULL) return;
				PIActionDescriptor globObjDesc;
				globObjDesc = NULL;

				// Pull the info
				sPSActionList->GetGlobalObject(inputList, 
											   counter, 
											   &globObjClassID, 
											   &globObjDesc);

				// Convert the 'Hash' to a "hashString"
				LongToStr(globObjClassID, "class", globObjClassIDStr);

				// change the indentation level for this object in a list
				// this makes it easier to read the output file
				// Recurse into this routine to pull apart the globOsbjDesc
				tabLevel++;
				DumpInfoFromDescriptor(globObjDesc, fileOut);
				tabLevel--;

				// Check to see if this is a 'Hash' type of event or a unique ID 
				// string. If it is a unique ID string then you have to get the 
				// runtime ID for that event and play.
				if (globObjClassID < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
						<< globObjClassIDStr << "\", &runtimeClassID);" << endl;

					// Update for the string
					strcpy(globObjClassIDStr, "runtimeClassID");

					TabOver(fileOut);
					fileOut << ecs;
				}

				// Format the output
				TabOver(fileOut);
				fileOut << sal << "PutGlobalObject(list" << inputList << ", " 
					<< globObjClassIDStr << ", desc" << globObjDesc << ");" 
					<< endl;

				if (globObjDesc != NULL) sPSActionDescriptor->Free(globObjDesc);

				delete [] globObjClassIDStr;
				break;

			case 'enum'://typeEnumerated:
				// Get some local data
				DescriptorEnumTypeID	enumType;
				DescriptorEnumID enumValue;
				char* enumTypeStr;
				enumTypeStr = new char[maxHashStringSize];
				if (enumTypeStr == NULL) return;
				char* enumValueStr;
				enumValueStr = new char[maxHashStringSize];
				if (enumValueStr == NULL) return;

				// Pull the info
				sPSActionList->GetEnumerated(
					inputList, 
					counter, 
					&enumType, 
					&enumValue);

				// Convert the 'Hash' to a "hashString"
				LongToStr(enumValue, "enum", enumValueStr);

				if (enumValue < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
							<< enumValueStr << "\", &runtimeEnumID);" << endl;
					TabOver(fileOut);
					fileOut << ecs;
			
					strcpy(enumValueStr, "runtimeEnumID");
				}
		
				LongToStr(enumType, "type", enumTypeStr);

				if (enumType < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
							<< enumTypeStr << "\", &runtimeTypeID);" << endl;
					TabOver(fileOut);
					fileOut << ecs;
			
					strcpy(enumTypeStr, "runtimeTypeID");
				}
		
				// Format the output
				TabOver(fileOut);
				fileOut << sal << "PutEnumerated(list" << inputList << ", " 
					<< enumTypeStr << ", " << enumValueStr << ");" << endl;

				delete [] enumValueStr;
				delete [] enumTypeStr;
				break;

			case typePath:
			case typeAlias:
				// Get some local data
				Handle aliasValue;
				char* fullPath;
				fullPath = new char[BigStrMaxLen*2];
				if (fullPath == NULL) return;
				
				// Pull the info
				sPSActionList->GetAlias(inputList, counter, &aliasValue);
				
				// Get the information out of the Handle
				// On Windows it's a char**, on Mac it's a mess
				if (fullPath != NULL)
					AliasToFullPath(aliasValue, fullPath);

				// Format the output
				TabOver(fileOut);
				fileOut << "// Move this to the top of the routine!" << endl;
				TabOver(fileOut);
				fileOut << "Handle aliasValue = NULL;" << endl;

				TabOver(fileOut);
				fileOut << "FullPathToAlias(\"" << fullPath << "\", aliasValue);" 
					    << endl;
				TabOver(fileOut);
				fileOut << sal << "PutAlias(list" << inputList 
					<< ", aliasValue);" << endl;

				freeZone->Add(aliasValue);

				delete [] fullPath;

				break;

			case typeValueList:
				// Get some local data
				PIActionList actionList;

				// Pull the info
				sPSActionList->GetList(inputList, counter, &actionList);

				// change the indentation level for this object in a list
				// this makes it easier to read the output file
				// Recurse into this routine to pull apart the actionList
				tabLevel++;
				DumpInfoFromList(actionList, fileOut);
				tabLevel--;

				// Format the output
				TabOver(fileOut);
				fileOut << sal << "PutList(list" << inputList << ", list" 
					<< actionList << ");" << endl;

				break;

			case typeObjectSpecifier:
				// Get some local data
				PIActionReference refValue;

				// Pull the info
				sPSActionList->GetReference(inputList, counter, &refValue);

				// change the indentation level for this object in a list
				// this makes it easier to read the output file
				// Recurse into this routine to pull apart the refValue
				tabLevel++;
				DumpInfoFromReference(refValue, fileOut);
				tabLevel--;

				// Format the output
				TabOver(fileOut);
				fileOut << sal << "PutReference(list" << inputList << ", ref" 
					<< refValue << ");" << endl;

				break;

			case typeType:
			case typeGlobalClass:
				// Get some local data
				DescriptorClassID globClassID;
				char* globClassIDStr;
				globClassIDStr = new char[maxHashStringSize];
				if (globClassIDStr == NULL) return;

				// Pull the info
				sPSActionList->GetClass(inputList, counter, &globClassID);

				// Convert the 'Hash' to a "hashString"
				LongToStr(globClassID, "class", globClassIDStr);

				if (globClassID < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
							<< globClassIDStr << "\", &runtimeClassID);" << endl;
					TabOver(fileOut);
					fileOut << ecs;
			
					strcpy(globClassIDStr, "runtimeClassID");
				}
		
				// Format the output
				TabOver(fileOut);
				fileOut << sal << "PutClass(list" << inputList << ", " 
					<< globClassIDStr << ");" << endl;
				delete [] globClassIDStr;
				break;
				
			case typeRawData:
				// Get some local data
				int32	dataLength;

				// Pull the info
				sPSActionList->GetDataLength(inputList, counter, &dataLength);	

				// Format the output
				TabOver(fileOut);
				fileOut << sal << "PutData(list" << inputList << ", " 
						<< ", " << dataLength << ", voidPtrToData);"
						<< endl;
				break;

			default:
				// Get some local data
				char* typeIDStr;
				typeIDStr = new char[maxHashStringSize];
				if (typeIDStr == NULL) return;

				// Convert the 'Hash' to a "hashString"
				LongToStr(typeID, "type", typeIDStr);

				if (typeID < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
							<< typeIDStr << "\", &runtimeTypeID);" << endl;
					TabOver(fileOut);
					fileOut << ecs;
			
					strcpy(typeIDStr, "runtimeTypeID");
				}
		
				// Format the output
				TabOver(fileOut);
				fileOut << "ERROR: DumpInfoFromList type: " << typeIDStr 
					<< ", entry: " << counter << ", Total Entry: " << listCount 
					<< endl;
				delete [] typeIDStr;
				break;
		} // end switch on typeID

		counter++; // move to the next item in the list
	
		TabOver(fileOut);
		fileOut << ecs;

	} // end the while loop
	#else
		#ifdef __MWERKS__
			#pragma unused (inputList)
			#pragma unused (fileOut)
		#endif // I know we're not using these in the Mac version. Don't warn.
	#endif // _DEBUG
} // end DumpInfoFromList
	

	
//-------------------------------------------------------------------------------
//
//	DumpInfoFromDescriptor
//
//	Goes through each property in the result descriptor and dumps it and its
//	type. Has recursive functions that can get descriptors out of descriptors
//	and other combinations.
//
//-------------------------------------------------------------------------------
static void DumpInfoFromDescriptor(const PIActionDescriptor inputDesc,
								   ofstream & fileOut)
{

	// You probably don't want the overhead of this routine in your
	// non-debug code, so I'll define this and its strings only for
	// a debug build:
	#ifdef _DEBUG

	const char* sad = "error = sPSActionDescriptor->";
	
	// If there is no descriptor then don't bother.
	if (inputDesc == NULL)
		return;

	// counters for this descriptor
	uint32 descCount = 0;
	uint32 counter = 0;
	if (sPSActionDescriptor->GetCount(inputDesc, &descCount))
		return;
	
	// Format the output
	TabOver(fileOut);
	fileOut << "// Move this to the top of the routine!" << endl;

	TabOver(fileOut);
	fileOut << "PIActionDescriptor desc" << inputDesc << " = NULL;" << endl << endl;

	TabOver(fileOut);
	fileOut << sad << "Make(&desc" << inputDesc << ");" << endl;

	TabOver(fileOut);
	fileOut << ecs;

	freeZone->Add(inputDesc);

	// loop through all the items in this descriptor pulling apart
	// each one as it comes
	while (counter < descCount)
	{
		// get the key for this item
		DescriptorKeyID thisKeyID;
		sPSActionDescriptor->GetKey(inputDesc, counter, &thisKeyID);

		// get the type for this key
		DescriptorTypeID typeID;
		sPSActionDescriptor->GetType(inputDesc, thisKeyID, &typeID);

		// Convert the 'Hash' to a "hashString"
		char* keyIDStr;
		keyIDStr = new char[maxHashStringSize];
		if (keyIDStr == NULL) return;

		LongToStr(thisKeyID, "key", keyIDStr);		
		
		if (thisKeyID < SmallestHashValue)
		{
			if (typeID != typeObject && typeID != typeGlobalObject &&
				typeID != typeValueList && typeID != typeGlobalClass)
			{
				TabOver(fileOut);
				fileOut << "error = sPSActionControl->StringIDToTypeID(\""
						<< keyIDStr << "\", &runtimeKeyID);" << endl;
			
				TabOver(fileOut);
				fileOut << ecs;
			}

			strcpy(keyIDStr, "runtimeKeyID");
		}

		// pull the next bit of information based on the type
		switch (typeID)
		{
			case typeInteger:
				// Get some local data
				int32 intValue;

				// Pull the info
				sPSActionDescriptor->GetInteger(inputDesc, thisKeyID, &intValue);

				// Format the output
				TabOver(fileOut);
				fileOut << sad << "PutInteger(desc"
						<< inputDesc << ", " << keyIDStr << ", " 
						<< intValue << ");" << endl;
				break;

			case typeFloat:
				// Get some local data
				double doubleValue;

				// Pull the info
				sPSActionDescriptor->GetFloat(inputDesc, thisKeyID, &doubleValue);

				// Format the output
				TabOver(fileOut);
				fileOut << sad << "PutFloat(desc"
						<< inputDesc << ", " << keyIDStr << ", "
						<< doubleValue << ");" << endl;
				break;

			case typeUnitFloat:
				// Get some local data
				double unitDoubleValue;
				DescriptorUnitID unitID;
				char* unitIDStr;
				unitIDStr = new char[maxHashStringSize];
				if (unitIDStr == NULL) return;

				// Pull the info
				sPSActionDescriptor->GetUnitFloat(
					inputDesc, 
					thisKeyID, 
					&unitID, 
					&unitDoubleValue);

				// Convert the 'Hash' to a "hashString"
				LongToStr(unitID, "unit", unitIDStr);

				if (unitID < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
							<< unitIDStr << "\", &runtimeUnitID);" << endl;
					TabOver(fileOut);
					fileOut << ecs;
			
					strcpy(unitIDStr, "runtimeUnitID");
				}
		
				// Format the output
				TabOver(fileOut);
				fileOut << sad << "PutUnitFloat(desc"
						<< inputDesc << ", " << keyIDStr << ", "
						<< unitIDStr << ", " << unitDoubleValue
						<< ");" << endl;
				delete [] unitIDStr;
				break;

			case typeChar:
				// Get some local data
				uint32 charLen;
				size_t requestLen;
				char* charValue;

				// Pull the info
				sPSActionDescriptor->GetStringLength(inputDesc, thisKeyID, &charLen);
				requestLen = ++charLen; // make room for the null termination

				// Make some room for the data
				charValue = new char[requestLen];
				if (charValue == NULL) return;

				// Check for room availability
				if (requestLen == charLen && charValue)
				{
					sPSActionDescriptor->GetString(
						inputDesc, 
						thisKeyID, 
						charValue, 
						requestLen);

					// Format the output
					TabOver(fileOut);
					fileOut << sad << "PutString(desc"
							<< inputDesc << ", " << keyIDStr << ", \""
							<< charValue << "\");" << endl;
				}
				else
				{
					TabOver(fileOut);
					fileOut << "ERROR: " << sad << "PutString" << endl;
				}

				// Get rid of our local buffer
				delete [] charValue;
				break;

			case typeBoolean:
				// Get some local data
				Boolean boolValue;

				// Pull the info
				sPSActionDescriptor->GetBoolean(inputDesc, thisKeyID, &boolValue);

				// Format the output
				TabOver(fileOut);
				fileOut << sad << "PutBoolean(desc"
						<< inputDesc << ", " << keyIDStr << ", "
						<< (boolValue ? "true" : "false") << ");" << endl;
				break;

			case typeObject:
				// Get some local data
				PIActionDescriptor objDesc;
				objDesc = NULL;
				DescriptorClassID objClassID;
				char* objClassIDStr;
				objClassIDStr = new char[maxHashStringSize];
				if (objClassIDStr == NULL) return;

				// Pull the info
				sPSActionDescriptor->GetObject(
					inputDesc, 
					thisKeyID, 
					&objClassID, 
					&objDesc);

				// change the indentation level for this object in a list
				// this makes it easier to read the output file
				// Recurse into this routine to pull apart the objDesc
				tabLevel++;
				DumpInfoFromDescriptor(objDesc, fileOut);
				tabLevel--;

				LongToStr(objClassID, "class", objClassIDStr);				
				
				// Check to see if this is a 'Hash' type of event or a unique ID 
				// string. If it is a unique ID string then you have to get the 
				// runtime ID for that event and play.
				if (objClassID < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
						<< objClassIDStr << "\", &runtimeObjID);" << endl;

					// Update for the string
					strcpy(objClassIDStr, "runtimeObjID");

					TabOver(fileOut);
					fileOut << ecs;
				}

				// Dump the key out here so it is less confusing in the log file
				if (thisKeyID < SmallestHashValue)
				{
					LongToStr(thisKeyID, "key", keyIDStr);

					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\""
							<< keyIDStr << "\", &runtimeKeyID);" << endl;
			
					TabOver(fileOut);
					fileOut << ecs;
		
					strcpy(keyIDStr, "runtimeKeyID");
				}

				// Format the output
				TabOver(fileOut);
				fileOut << sad << "PutObject(desc"
						<< inputDesc << ", " << keyIDStr << ", "
						<< objClassIDStr << ", desc" << objDesc << ");" << endl;

				if (objDesc != NULL) sPSActionDescriptor->Free(objDesc);
				
				delete [] objClassIDStr;
				break;

			case typeGlobalObject:
				// Get some local data
				PIActionDescriptor globObjDesc;
				globObjDesc = NULL;
				DescriptorClassID globObjClassID;
				char* globObjClassIDStr;
				globObjClassIDStr = new char[maxHashStringSize];
				if (globObjClassIDStr == NULL) return;

				// Pull the info
				sPSActionDescriptor->GetGlobalObject(
					inputDesc, 
					thisKeyID, 
					&globObjClassID, 
					&globObjDesc);


				LongToStr(globObjClassID, "class", globObjClassIDStr);				
				
				// change the indentation level for this object in a list
				// this makes it easier to read the output file
				// Recurse into this routine to pull apart the globObjDesc
				tabLevel++;
				DumpInfoFromDescriptor(globObjDesc, fileOut);
				tabLevel--;

				// Check to see if this is a 'Hash' type of event or a unique ID 
				// string. If it is a unique ID string then you have to get the 
				// runtime ID for that event and play.
				if (globObjClassID < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
						<< globObjClassIDStr << "\", &runtimeObjID);" << endl;

					// Update for the string
					strcpy(globObjClassIDStr, "runtimeObjID");

					TabOver(fileOut);
					fileOut << ecs;
				}

				// Dump the key out here so it is less confusing in the log file
				if (thisKeyID < SmallestHashValue)
				{
					LongToStr(thisKeyID, "key", keyIDStr);

					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\""
							<< keyIDStr << "\", &runtimeKeyID);" << endl;
			
					TabOver(fileOut);
					fileOut << ecs;
		
					strcpy(keyIDStr, "runtimeKeyID");
				}

				// Format the output
				TabOver(fileOut);

				fileOut << sad << "PutGlobalObject(desc"
						<< inputDesc << ", " << keyIDStr << ", "
						<< globObjClassIDStr << ", desc" << globObjDesc << ");" 
						<< endl;

				if (globObjDesc != NULL) sPSActionDescriptor->Free(globObjDesc);

				delete [] globObjClassIDStr;
				break;

			case 'enum'://typeEnumerated:
				// Get some local data
				DescriptorEnumTypeID enumTypeID;
				DescriptorEnumID enumID;
				char* enumTypeIDStr;
				enumTypeIDStr = new char[maxHashStringSize];
				if (enumTypeIDStr == NULL) return;
				char* enumIDStr;
				enumIDStr = new char[maxHashStringSize];
				if (enumIDStr == NULL) return;

				// Pull the info
				sPSActionDescriptor->GetEnumerated(
					inputDesc, 
					thisKeyID, 
					&enumTypeID, 
					&enumID);

				LongToStr(enumID, "enum", enumIDStr);

				// Convert the 'Hash' to a "hashString"
				if (enumID < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
						<< enumIDStr << "\", &runtimeEnumID);" << endl;
					TabOver(fileOut);
					fileOut << ecs;

					// Update for the string
					strcpy(enumIDStr, "runtimeEnumID");

				}
				
				LongToStr(enumTypeID, "type", enumTypeIDStr);

				if (enumTypeID < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
						<< enumTypeIDStr << "\", &runtimeTypeID);" << endl;
					TabOver(fileOut);
					fileOut << ecs;

					// Update for the string
					strcpy(enumTypeIDStr, "runtimeTypeID");

				}

				// Format the output
				TabOver(fileOut);
				fileOut << sad << "PutEnumerated(desc"
						<< inputDesc << ", " << keyIDStr << ", " 
						<< enumTypeIDStr << ", " << enumIDStr << ");" << endl;

				delete [] enumTypeIDStr;
				delete [] enumIDStr;
				break;

			case typePath:
			case typeAlias:
				// Get some local data
				Handle aliasValue;
				char* fullPath;
				fullPath = new char[BigStrMaxLen*2];
				if (fullPath == NULL) return;

				// Pull the info
				sPSActionDescriptor->GetAlias(inputDesc, thisKeyID, &aliasValue);

				// Get the information out of the Handle
				// On Windows it's a char**, on Mac it's a mess
				if (fullPath != NULL)
					AliasToFullPath(aliasValue, fullPath);

				// Format the output
				TabOver(fileOut);
				fileOut << "// Move this to the top of the routine!" << endl;
				TabOver(fileOut);
				fileOut << "Handle aliasValue = NULL;" << endl;

				TabOver(fileOut);
				fileOut << "FullPathToAlias(\"" << fullPath << "\", aliasValue);" 
					    << endl;
				TabOver(fileOut);
				fileOut << sad << "PutAlias(desc"
						<< inputDesc << ", " << keyIDStr << ", aliasValue);"
						<< endl;

				freeZone->Add(aliasValue);

				delete [] fullPath;
				break;

			case typeValueList:
				// Get some local data
				PIActionList	listValue;

				// Pull the info
				sPSActionDescriptor->GetList(inputDesc, thisKeyID, &listValue);

				// change the indentation level for this object in a list
				// this makes it easier to read the output file
				// Recurse into this routine to pull apart the listValue
				tabLevel++;
				DumpInfoFromList(listValue, fileOut);
				tabLevel--;

				LongToStr(thisKeyID, "key", keyIDStr);

				if (thisKeyID < SmallestHashValue)
				{
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\""
							<< keyIDStr << "\", &runtimeKeyID);" << endl;
					strcpy(keyIDStr, "runtimeKeyID");

					TabOver(fileOut);
					fileOut << ecs;
				}

				// Format the output
				TabOver(fileOut);
				fileOut << sad << "PutList(desc" << inputDesc << ", " << keyIDStr 
					<< ", list" << listValue << ");" << endl;
				break;

			case typeObjectSpecifier:
				// Get some local data
				PIActionReference refValue;

				// Pull the info
				sPSActionDescriptor->GetReference(inputDesc, thisKeyID, &refValue);

				// change the indentation level for this object in a list
				// this makes it easier to read the output file
				// Recurse into this routine to pull apart the refValue
				tabLevel++;
				DumpInfoFromReference(refValue, fileOut);
				tabLevel--;

				// Format the output
				TabOver(fileOut);
				fileOut << sad << "PutReference(desc" << inputDesc << ", " 
					<< keyIDStr << ", ref" << refValue << ");" << endl;
				break;

			case typeType:
			case typeGlobalClass:
				// Get some local data
				DescriptorClassID globClassID;
				char* globClassIDStr;
				globClassIDStr = new char[maxHashStringSize];
				if (globClassIDStr == NULL) return;

				// Pull the info
				sPSActionDescriptor->GetClass(inputDesc, thisKeyID, &globClassID);

				LongToStr(globClassID, "class", globClassIDStr);
				
				// Convert the 'Hash' to a "hashString"
				if (globClassID < SmallestHashValue)
				{
					// Format the output
					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\"" 
						<< globClassIDStr << "\", &runtimeClassID);" << endl;

					// Update for the string
					strcpy(globClassIDStr, "runtimeClassID");

					TabOver(fileOut);
					fileOut << ecs;
				}

				// Dump the key out here so it is less confusing in the log file
				if (thisKeyID < SmallestHashValue)
				{
					LongToStr(thisKeyID, "key", keyIDStr);

					TabOver(fileOut);
					fileOut << "error = sPSActionControl->StringIDToTypeID(\""
							<< keyIDStr << "\", &runtimeKeyID);" << endl;
			
					TabOver(fileOut);
					fileOut << ecs;
		
					strcpy(keyIDStr, "runtimeKeyID");
				}

				// Format the output
				TabOver(fileOut);
				fileOut << sad << "PutClass(desc" << inputDesc << ", " 
					<< keyIDStr << ", " << globClassIDStr << ");" << endl;

				delete [] globClassIDStr;
				break;

			case typeRawData:
				// Get some local data
				int32	dataLength;

				// Pull the info
				sPSActionDescriptor->GetDataLength(inputDesc, thisKeyID, &dataLength);	

				// Format the output
				TabOver(fileOut);
				fileOut << sad << "PutData(desc" << inputDesc << ", " 
						<< keyIDStr << ", " << dataLength << ", voidPtrToData);"
						<< endl;
				break;

			default:
				// Get some local data
				char* typeIDStr;
				typeIDStr = new char[maxHashStringSize];
				if (typeIDStr == NULL) return;

				// Convert the 'Hash' to a "hashString"
				LongToStr(typeID, "xxxx", typeIDStr);

				// Format the output
				TabOver(fileOut);
				fileOut << "ERROR DumpInfoFromDescriptor type: " << typeIDStr 
					<< ", key: " << keyIDStr << ", entry: " << counter << endl;

				delete [] typeIDStr;
				break;
		} // end the switch

		counter++; // go to the next item in the list

		TabOver(fileOut);
		fileOut << ecs;

		delete [] keyIDStr;
	}// end the while loop
	#else
		#ifdef __MWERKS__
			#pragma unused (inputDesc)
			#pragma unused (fileOut)
		#endif // I know we're not using these in the Mac version. Don't warn.
	#endif // _DEBUG
}// end DumpInforFromDescriptor



//-------------------------------------------------------------------------------
//
//	TabOver
//
//	Utility function that makes the output file easier to read.
//
//-------------------------------------------------------------------------------
static void TabOver(ofstream & fileOut)
{
	for(int16 numberoftabs = 0; numberoftabs < tabLevel; numberoftabs++)
		fileOut << "     ";
}



//-------------------------------------------------------------------------------
//
//	PIUIDToChar
//
//	Utility function that converts longs to "Hash" strings
//
//-------------------------------------------------------------------------------
static void PIUIDToChar (const unsigned long inType, /* OUT */ char* outChars)
{
	int8 loopType, loopChar;
	
	// Figure out which byte we're dealing with and move it
	// to the highest character, then mask out everything but
	// the lowest byte and assign that as the character:
	for (loopType = 0, loopChar = 3; loopType < 4; loopType++, loopChar--)
		outChars[loopChar] = (char) ((inType >> (loopType<<3)) & 0xFF);
	
	outChars[loopType] = '\0';

} // end PIUIDToChar



//-------------------------------------------------------------------------------
//
//	PIUCharToID
//
//	Utility function that converts "Hash" strings to longs
//
//-------------------------------------------------------------------------------
unsigned long PIUCharToID (const char* inChars)
{
	unsigned short loop;
	ResType outType = 0;
	
	for (loop = 0; loop < 4; loop++)
	{
		outType <<= 8; // bits per char
		outType |= inChars[loop];
	}

	return outType;

} // end PIUCharToID



//-------------------------------------------------------------------------------
// You probably don't want the overhead of this routine in your
// non-debug code, so I'll define this and its strings only for
// a debug build:
#ifdef _DEBUG

struct PSConstantArray {
	int32	longVal;
	const char*	strStr;//[HashStrMaxLen];
};

static const struct PSConstantArray PSConstA[] = {	 
{ 0, "plugInDialogDontDisplay" },
{ 1, "plugInDialogDisplay" },
{ 2, "plugInDialogSilent" },
{ 1701737837, "typeEnumerated" },
{ 1685026146, "typeFloat" },
{ 1819242087, "typeInteger" },
{ 1651470188, "typeBoolean" },
{ 1634494835, "typeAlias" },
{ 1853189228, "typeNull" },
{ 1768842360, "formAbsolutePosition" },
{ 1886547824, "formPropertyID" },
{ 1919249509, "formRelativePosition" },
{ 1954115685, "typeType" },
{ 1413830740, "typeChar" },
{ 1349806112, "typePath" },
{ 1868720672, "typeObjectSpecifier" },
{ 1685026146, "typeDouble" },
{ 1433302086, "typeUnitDouble" },
{ 1198684531, "enumGrayscales" },
{ classAction, "classAction" },
{ classActionSet, "classActionSet" },
{ classAdjustment, "classAdjustment" },
{ classAdjustmentLayer, "classAdjustmentLayer" },
{ classAirbrushTool, "classAirbrushTool" },
{ classAlphaChannelOptions, "classAlphaChannelOptions" },
{ classAntiAliasedPICTAcquire, "classAntiAliasedPICTAcquire" },
{ classApplication, "classApplication" },
{ classArrowhead, "classArrowhead" },
{ classAssert, "classAssert" },
{ classAssumedProfile, "classAssumedProfile" },
{ classBMPFormat, "classBMPFormat" },
{ classBackgroundLayer, "classBackgroundLayer" },
{ classBevelEmboss, "classBevelEmboss" },
{ classBitmapMode, "classBitmapMode" },
{ classBlendRange, "classBlendRange" },
{ classBlurTool, "classBlurTool" },
{ classBookColor, "classBookColor" },
{ classBrightnessContrast, "classBrightnessContrast" },
{ classBrush, "classBrush" },
{ classBurnInTool, "classBurnInTool" },
{ classCachePrefs, "classCachePrefs" },
{ classCMYKColor, "classCMYKColor" },
{ classCMYKColorMode, "classCMYKColorMode" },
{ classCMYKSetup, "classCMYKSetup" },
{ classCalculation, "classCalculation" },
{ classChannel, "classChannel" },
{ classChannelMatrix, "classChannelMatrix" },
{ classChannelMixer, "classChannelMixer" },
{ classClippingInfo, "classClippingInfo" },
{ classClippingPath, "classClippingPath" },
{ classCloneStampTool, "classCloneStampTool" },
{ classColor, "classColor" },
{ classColorBalance, "classColorBalance" },
{ classColorCorrection, "classColorCorrection" },
{ classColorPickerPrefs, "classColorPickerPrefs" },
{ classColorSampler, "classColorSampler" },
{ classColorStop, "classColorStop" },
{ classCommand, "classCommand" },
{ classCurves, "classCurves" },
{ classCurvePoint, "classCurvePoint" },
{ classCustomPalette, "classCustomPalette" },
{ classCurvesAdjustment, "classCurvesAdjustment" },
{ classCustomPhosphors, "classCustomPhosphors" },
{ classCustomWhitePoint, "classCustomWhitePoint" },
{ classDisplayPrefs, "classDisplayPrefs" },
{ classDocument, "classDocument" },
{ classDodgeTool, "classDodgeTool" },
{ classDropShadow, "classDropShadow" },
{ classDuotoneInk, "classDuotoneInk" },
{ classDuotoneMode, "classDuotoneMode" },
{ classEPSGenericFormat, "classEPSGenericFormat" },
{ classEPSPICTPreview, "classEPSPICTPreview" },
{ classEPSTIFFPreview, "classEPSTIFFPreview" },
{ classElement, "classElement" },
{ classEllipse, "classEllipse" },
{ classEraserTool, "classEraserTool" },
{ classExport, "classExport" },
{ classFileInfo, "classFileInfo" },
{ classFileSavePrefs, "classFileSavePrefs" },
{ classFlashPixFormat, "classFlashPixFormat" },
{ classFontDesignAxes, "classFontDesignAxes" },
{ classFormat, "classFormat" },
{ classFrameFX, "classFrameFX" },
{ classContour, "classContour" },
{ classGeneralPrefs, "classGeneralPrefs" },
{ classGIF89aExport, "classGIF89aExport" },
{ classGIFFormat, "classGIFFormat" },
{ classGlobalAngle, "classGlobalAngle" },
{ classGradient, "classGradient" },
{ classGradientFill, "classGradientFill" },
{ classGradientMap, "classGradientMap" },
{ classGradientTool, "classGradientTool" },
{ classGraySetup, "classGraySetup" },
{ classGrayscale, "classGrayscale" },
{ classGrayscaleMode, "classGrayscaleMode" },
{ classGuide, "classGuide" },
{ classGuidesPrefs, "classGuidesPrefs" },
{ classHalftoneScreen, "classHalftoneScreen" },
{ classHalftoneSpec, "classHalftoneSpec" },
{ classHSBColor, "classHSBColor" },
{ classHSBColorMode, "classHSBColorMode" },
{ classHistoryBrushTool, "classHistoryBrushTool" },
{ classHistoryPrefs, "classHistoryPrefs" },
{ classHistoryState, "classHistoryState" },
{ classHueSatAdjustment, "classHueSatAdjustment" },
{ classHueSatAdjustmentV2, "classHueSatAdjustmentV2" },
{ classHueSaturation, "classHueSaturation" },
{ classIllustratorPathsExport, "classIllustratorPathsExport" },
{ classImagePoint, "classImagePoint" },
{ classImport, "classImport" },
{ classIndexedColorMode, "classIndexedColorMode" },
{ classInkTransfer, "classInkTransfer" },
{ classInnerGlow, "classInnerGlow" },
{ classInnerShadow, "classInnerShadow" },
{ classInterfaceColor, "classInterfaceColor" },
{ classInvert, "classInvert" },
{ classJPEGFormat, "classJPEGFormat" },
{ classLabColor, "classLabColor" },
{ classLabColorMode, "classLabColorMode" },
{ classLayer, "classLayer" },
{ classLayerEffects, "classLayerEffects" },
{ classLayerFXVisible, "classLayerFXVisible" },
{ classLevels, "classLevels" },
{ classLevelsAdjustment, "classLevelsAdjustment" },
{ classLightSource, "classLightSource" },
{ classLine, "classLine" },
{ classMacPaintFormat, "classMacPaintFormat" },
{ classMagicEraserTool, "classMagicEraserTool" },
{ classMagicPoint, "classMagicPoint" },
{ classMask, "classMask" },
{ classMenuItem, "classMenuItem" },
{ classMode, "classMode" },
{ classMultichannelMode, "classMultichannelMode" },
{ classObsoleteTextLayer, "classObsoleteTextLayer" },
{ classNull, "classNull" },
{ classOffset, "classOffset" },
{ classOpacity, "classOpacity" },
{ classOuterGlow, "classOuterGlow" },
{ classPDFGenericFormat, "classPDFGenericFormat" },
{ classPICTFileFormat, "classPICTFileFormat" },
{ classPICTResourceFormat, "classPICTResourceFormat" },
{ classPNGFormat, "classPNGFormat" },
{ classPageSetup, "classPageSetup" },
{ classPaintbrushTool, "classPaintbrushTool" },
{ classPath, "classPath" },
{ classPathComponent, "classPathComponent" },
{ classPathPoint, "classPathPoint" },
{ classPattern, "classPattern" },
{ classPatternStampTool, "classPatternStampTool" },
{ classPencilTool, "classPencilTool" },
{ classPhotoshop20Format, "classPhotoshop20Format" },
{ classPhotoshop35Format, "classPhotoshop35Format" },
{ classPhotoshopDCS2Format, "classPhotoshopDCS2Format" },
{ classPhotoshopDCSFormat, "classPhotoshopDCSFormat" },
{ classPhotoshopEPSFormat, "classPhotoshopEPSFormat" },
{ classPhotoshopPDFFormat, "classPhotoshopPDFFormat" },
{ classPixel, "classPixel" },
{ classPixelPaintFormat, "classPixelPaintFormat" },
{ classPluginPrefs, "classPluginPrefs" },
{ classPoint, "classPoint" },
{ classPoint16, "classPoint16" },
{ classPolygon, "classPolygon" },
{ classPosterize, "classPosterize" },
{ classPreferences, "classPreferences" },
{ classProfileSetup, "classProfileSetup" },
{ classProperty, "classProperty" },
{ classRange, "classRange" },
{ classRect16, "classRect16" },
{ classRGBColor, "classRGBColor" },
{ classRGBColorMode, "classRGBColorMode" },
{ classRGBSetup, "classRGBSetup" },
{ classRawFormat, "classRawFormat" },
{ classRectangle, "classRectangle" },
{ classSaturationTool, "classSaturationTool" },
{ classScitexCTFormat, "classScitexCTFormat" },
{ classSelection, "classSelection" },
{ classSelectiveColor, "classSelectiveColor" },
{ classShapingCurve, "classShapingCurve" },
{ classSharpenTool, "classSharpenTool" },
{ classSingleColumn, "classSingleColumn" },
{ classSingleRow, "classSingleRow" },
{ classBackgroundEraserTool, "classBackgroundEraserTool" },
{ classSolidFill, "classSolidFill" },
{ classArtHistoryBrushTool, "classArtHistoryBrushTool" },
{ classSmudgeTool, "classSmudgeTool" },
{ classSnapshot, "classSnapshot" },
{ classSpotColorChannel, "classSpotColorChannel" },
{ classStyle, "classStyle" },
{ classSubPath, "classSubPath" },
{ classTIFFFormat, "classTIFFFormat" },
{ classTargaFormat, "classTargaFormat" },
{ classTextLayer, "classTextLayer" },
{ classTextStyle, "classTextStyle" },
{ classTextStyleRange, "classTextStyleRange" },
{ classThreshold, "classThreshold" },
{ classTool, "classTool" },
{ classTransferSpec, "classTransferSpec" },
{ classTransferPoint, "classTransferPoint" },
{ classTransparencyPrefs, "classTransparencyPrefs" },
{ classTransparencyStop, "classTransparencyStop" },
{ classUnitsPrefs, "classUnitsPrefs" },
{ classUnspecifiedColor, "classUnspecifiedColor" },
{ classVersion, "classVersion" },
{ classXYYColor, "classXYYColor" },
{ classChromeFX, "classChromeFX" },
{ enumAdd, "enumAdd" },
{ enumAmountHigh, "enumAmountHigh" },
{ enumAmountLow, "enumAmountLow" },
{ enumAmountMedium, "enumAmountMedium" },
{ enumAntiAliasNone, "enumAntiAliasNone" },
{ enumAntiAliasLow, "enumAntiAliasLow" },
{ enumAntiAliasMedium, "enumAntiAliasMedium" },
{ enumAntiAliasHigh, "enumAntiAliasHigh" },
{ enumAntiAliasCrisp, "enumAntiAliasCrisp" },
{ enumAntiAliasStrong, "enumAntiAliasStrong" },
{ enumAntiAliasSmooth, "enumAntiAliasSmooth" },
{ enumAppleRGB, "enumAppleRGB" },
{ enumASCII, "enumASCII" },
{ enumAskWhenOpening, "enumAskWhenOpening" },
{ enumBicubic, "enumBicubic" },
{ enumBinary, "enumBinary" },
{ enumMonitorSetup, "enumMonitorSetup" },
{ enum16BitsPerPixel, "enum16BitsPerPixel" },
{ enum1BitPerPixel, "enum1BitPerPixel" },
{ enum2BitsPerPixel, "enum2BitsPerPixel" },
{ enum32BitsPerPixel, "enum32BitsPerPixel" },
{ enum4BitsPerPixel, "enum4BitsPerPixel" },
{ enum5000, "enum5000" },
{ enum5500, "enum5500" },
{ enum6500, "enum6500" },
{ enum72Color, "enum72Color" },
{ enum72Gray, "enum72Gray" },
{ enum7500, "enum7500" },
{ enum8BitsPerPixel, "enum8BitsPerPixel" },
{ enum9300, "enum9300" },
{ enumA, "enumA" },
{ enumAbsColorimetric, "enumAbsColorimetric" },
{ enumADSBottoms, "enumADSBottoms" },
{ enumADSCentersH, "enumADSCentersH" },
{ enumADSCentersV, "enumADSCentersV" },
{ enumADSHorizontal, "enumADSHorizontal" },
{ enumADSLefts, "enumADSLefts" },
{ enumADSRights, "enumADSRights" },
{ enumADSTops, "enumADSTops" },
{ enumADSVertical, "enumADSVertical" },
{ enumAboutApp, "enumAboutApp" },
{ enumAbsolute, "enumAbsolute" },
{ enumActualPixels, "enumActualPixels" },
{ enumAdaptive, "enumAdaptive" },
{ enumAdjustmentOptions, "enumAdjustmentOptions" },
{ enumAirbrushEraser, "enumAirbrushEraser" },
{ enumAll, "enumAll" },
{ enumAngle, "enumAngle" },
{ enumAny, "enumAny" },
{ enumApplyImage, "enumApplyImage" },
{ enumAroundCenter, "enumAroundCenter" },
{ enumArrange, "enumArrange" },
{ enumAsk, "enumAsk" },
{ enumB, "enumB" },
{ enumBack, "enumBack" },
{ enumBackground, "enumBackground" },
{ enumBackgroundColor, "enumBackgroundColor" },
{ enumBackward, "enumBackward" },
{ enumBehind, "enumBehind" },
{ enumBest, "enumBest" },
{ enumBetter, "enumBetter" },
{ enumBilinear, "enumBilinear" },
{ enumBitDepth1, "enumBitDepth1" },
{ enumBitDepth24, "enumBitDepth24" },
{ enumBitDepth4, "enumBitDepth4" },
{ enumBitDepth8, "enumBitDepth8" },
{ enumBitmap, "enumBitmap" },
{ enumBlack, "enumBlack" },
{ enumBlackAndWhite, "enumBlackAndWhite" },
{ enumBlackBody, "enumBlackBody" },
{ enumBlacks, "enumBlacks" },
{ enumBlockEraser, "enumBlockEraser" },
{ enumBlast, "enumBlast" },
{ enumBlocks, "enumBlocks" },
{ enumBlue, "enumBlue" },
{ enumBlues, "enumBlues" },
{ enumBottom, "enumBottom" },
{ enumBrushDarkRough, "enumBrushDarkRough" },
{ enumBrushesAppend, "enumBrushesAppend" },
{ enumBrushesDefine, "enumBrushesDefine" },
{ enumBrushesDelete, "enumBrushesDelete" },
{ enumBrushesLoad, "enumBrushesLoad" },
{ enumBrushesNew, "enumBrushesNew" },
{ enumBrushesOptions, "enumBrushesOptions" },
{ enumBrushesReset, "enumBrushesReset" },
{ enumBrushesSave, "enumBrushesSave" },
{ enumBrushLightRough, "enumBrushLightRough" },
{ enumBrushSimple, "enumBrushSimple" },
{ enumBrushSize, "enumBrushSize" },
{ enumBrushSparkle, "enumBrushSparkle" },
{ enumBrushWideBlurry, "enumBrushWideBlurry" },
{ enumBrushWideSharp, "enumBrushWideSharp" },
{ enumBuiltin, "enumBuiltin" },
{ enumBurnInH, "enumBurnInH" },
{ enumBurnInM, "enumBurnInM" },
{ enumBurnInS, "enumBurnInS" },
{ enumButtonMode, "enumButtonMode" },
{ enumCIERGB, "enumCIERGB" },
{ enumWidePhosphors, "enumWidePhosphors" },
{ enumWideGamutRGB, "enumWideGamutRGB" },
{ enumCMYK, "enumCMYK" },
{ enumCMYK64, "enumCMYK64" },
{ enumCMYKColor, "enumCMYKColor" },
{ enumCalculations, "enumCalculations" },
{ enumCascade, "enumCascade" },
{ enumCenter, "enumCenter" },
{ enumCenterGlow, "enumCenterGlow" },
{ enumCenteredFrame, "enumCenteredFrame" },
{ enumChannelOptions, "enumChannelOptions" },
{ enumChannelsPaletteOptions, "enumChannelsPaletteOptions" },
{ enumCheckerboardNone, "enumCheckerboardNone" },
{ enumCheckerboardSmall, "enumCheckerboardSmall" },
{ enumCheckerboardMedium, "enumCheckerboardMedium" },
{ enumCheckerboardLarge, "enumCheckerboardLarge" },
{ enumClear, "enumClear" },
{ enumClearGuides, "enumClearGuides" },
{ enumClipboard, "enumClipboard" },
{ enumClippingPath, "enumClippingPath" },
{ enumCloseAll, "enumCloseAll" },
{ enumCoarseDots, "enumCoarseDots" },
{ enumColor, "enumColor" },
{ enumColorBurn, "enumColorBurn" },
{ enumColorDodge, "enumColorDodge" },
{ enumColorMatch, "enumColorMatch" },
{ enumColorNoise, "enumColorNoise" },
{ enumColorimetric, "enumColorimetric" },
{ enumComposite, "enumComposite" },
{ enumConvertToCMYK, "enumConvertToCMYK" },
{ enumConvertToGray, "enumConvertToGray" },
{ enumConvertToLab, "enumConvertToLab" },
{ enumConvertToRGB, "enumConvertToRGB" },
{ enumCreateDuplicate, "enumCreateDuplicate" },
{ enumCreateInterpolation, "enumCreateInterpolation" },
{ enumCross, "enumCross" },
{ enumCurrentLayer, "enumCurrentLayer" },
{ enumCustom, "enumCustom" },
{ enumCustomPattern, "enumCustomPattern" },
{ enumCustomStops, "enumCustomStops" },
{ enumCyan, "enumCyan" },
{ enumCyans, "enumCyans" },
{ enumDark, "enumDark" },
{ enumDarken, "enumDarken" },
{ enumDarkenOnly, "enumDarkenOnly" },
{ enumDashedLines, "enumDashedLines" },
{ enumDesaturate, "enumDesaturate" },
{ enumDiamond, "enumDiamond" },
{ enumDifference, "enumDifference" },
{ enumDiffusion, "enumDiffusion" },
{ enumDiffusionDither, "enumDiffusionDither" },
{ enumDisplayCursorsPreferences, "enumDisplayCursorsPreferences" },
{ enumDissolve, "enumDissolve" },
{ enumDistort, "enumDistort" },
{ enumDodgeH, "enumDodgeH" },
{ enumDodgeM, "enumDodgeM" },
{ enumDodgeS, "enumDodgeS" },
{ enumDots, "enumDots" },
{ enumDraft, "enumDraft" },
{ enumDuotone, "enumDuotone" },
{ enumEBUITU, "enumEBUITU" },
{ enumEdgeGlow, "enumEdgeGlow" },
{ enumEliminateEvenFields, "enumEliminateEvenFields" },
{ enumEliminateOddFields, "enumEliminateOddFields" },
{ enumEllipse, "enumEllipse" },
{ enumEmboss, "enumEmboss" },
{ enumExact, "enumExact" },
{ enumExclusion, "enumExclusion" },
{ enumFPXCompressLossyJPEG, "enumFPXCompressLossyJPEG" },
{ enumFPXCompressNone, "enumFPXCompressNone" },
{ enumFaster, "enumFaster" },
{ enumFile, "enumFile" },
{ enumFileInfo, "enumFileInfo" },
{ enumFillBack, "enumFillBack" },
{ enumFillFore, "enumFillFore" },
{ enumFillInverse, "enumFillInverse" },
{ enumFillSame, "enumFillSame" },
{ enumFineDots, "enumFineDots" },
{ enumFirst, "enumFirst" },
{ enumFirstIdle, "enumFirstIdle" },
{ enumFitOnScreen, "enumFitOnScreen" },
{ enumForegroundColor, "enumForegroundColor" },
{ enumForward, "enumForward" },
{ enumFreeTransform, "enumFreeTransform" },
{ enumFront, "enumFront" },
{ enumFullDocument, "enumFullDocument" },
{ enumFullSize, "enumFullSize" },
{ enumGaussianDistribution, "enumGaussianDistribution" },
{ enumGIFColorFileColorTable, "enumGIFColorFileColorTable" },
{ enumGIFColorFileColors, "enumGIFColorFileColors" },
{ enumGIFColorFileMicrosoftPalette, "enumGIFColorFileMicrosoftPalette" },
{ enumGIFPaletteAdaptive, "enumGIFPaletteAdaptive" },
{ enumGIFPaletteExact, "enumGIFPaletteExact" },
{ enumGIFPaletteOther, "enumGIFPaletteOther" },
{ enumGIFPaletteSystem, "enumGIFPaletteSystem" },
{ enumGIFRequiredColorSpaceIndexed, "enumGIFRequiredColorSpaceIndexed" },
{ enumGIFRequiredColorSpaceRGB, "enumGIFRequiredColorSpaceRGB" },
{ enumGIFRowOrderInterlaced, "enumGIFRowOrderInterlaced" },
{ enumGIFRowOrderNormal, "enumGIFRowOrderNormal" },
{ enumGeneralPreferences, "enumGeneralPreferences" },
{ enumGood, "enumGood" },
{ enumGradientFill, "enumGradientFill" },
{ enumGrainClumped, "enumGrainClumped" },
{ enumGrainContrasty, "enumGrainContrasty" },
{ enumGrainEnlarged, "enumGrainEnlarged" },
{ enumGrainHorizontal, "enumGrainHorizontal" },
{ enumGrainRegular, "enumGrainRegular" },
{ enumGrainSoft, "enumGrainSoft" },
{ enumGrainSpeckle, "enumGrainSpeckle" },
{ enumGrainSprinkles, "enumGrainSprinkles" },
{ enumGrainStippled, "enumGrainStippled" },
{ enumGrainVertical, "enumGrainVertical" },
{ enumGrainyDots, "enumGrainyDots" },
{ enumGraphics, "enumGraphics" },
{ enumGray, "enumGray" },
{ enumGray16, "enumGray16" },
{ enumGray18, "enumGray18" },
{ enumGray22, "enumGray22" },
{ enumGray50, "enumGray50" },
{ enumGrayScale, "enumGrayScale" },
{ enumGreen, "enumGreen" },
{ enumGreens, "enumGreens" },
{ enumGuidesGridPreferences, "enumGuidesGridPreferences" },
{ enumHDTV, "enumHDTV" },
{ enumHSBColor, "enumHSBColor" },
{ enumHSLColor, "enumHSLColor" },
{ enumHalftoneFile, "enumHalftoneFile" },
{ enumHalftoneScreen, "enumHalftoneScreen" },
{ enumHardLight, "enumHardLight" },
{ enumHeavy, "enumHeavy" },
{ enumHideAll, "enumHideAll" },
{ enumHideSelection, "enumHideSelection" },
{ enumHigh, "enumHigh" },
{ enumHighQuality, "enumHighQuality" },
{ enumHighlights, "enumHighlights" },
{ enumHistogram, "enumHistogram" },
{ enumHistory, "enumHistory" },
{ enumHistoryPaletteOptions, "enumHistoryPaletteOptions" },
{ enumHistoryPreferences, "enumHistoryPreferences" },
{ enumHorizontal, "enumHorizontal" },
{ enumHorizontalOnly, "enumHorizontalOnly" },
{ enumHue, "enumHue" },
{ enumIBMPC, "enumIBMPC" },
{ enumICC, "enumICC" },
{ enumIcon, "enumIcon" },
{ enumIdleVM, "enumIdleVM" },
{ enumIgnore, "enumIgnore" },
{ enumImage, "enumImage" },
{ enumImageCachePreferences, "enumImageCachePreferences" },
{ enumIndexedColor, "enumIndexedColor" },
{ enumInfoPaletteOptions, "enumInfoPaletteOptions" },
{ enumInfoPaletteToggleSamplers, "enumInfoPaletteToggleSamplers" },
{ enumInnerBevel, "enumInnerBevel" },
{ enumInsetFrame, "enumInsetFrame" },
{ enumInside, "enumInside" },
{ enumJPEG, "enumJPEG" },
{ enumJustifyAll, "enumJustifyAll" },
{ enumJustifyFull, "enumJustifyFull" },
{ enumKeepProfile, "enumKeepProfile" },
{ enumKeyboardPreferences, "enumKeyboardPreferences" },
{ enumLab, "enumLab" },
{ enumLab48, "enumLab48" },
{ enumLabColor, "enumLabColor" },
{ enumLarge, "enumLarge" },
{ enumLast, "enumLast" },
{ enumLastFilter, "enumLastFilter" },
{ enumLayerOptions, "enumLayerOptions" },
{ enumLayersPaletteOptions, "enumLayersPaletteOptions" },
{ enumLeft, "enumLeft" },
{ enumLeft_PLUGIN, "enumLeft_PLUGIN" },
{ enumLevelBased, "enumLevelBased" },
{ enumLight, "enumLight" },
{ enumLightBlue, "enumLightBlue" },
{ enumLightDirBottom, "enumLightDirBottom" },
{ enumLightDirBottomLeft, "enumLightDirBottomLeft" },
{ enumLightDirBottomRight, "enumLightDirBottomRight" },
{ enumLightDirLeft, "enumLightDirLeft" },
{ enumLightDirRight, "enumLightDirRight" },
{ enumLightDirTop, "enumLightDirTop" },
{ enumLightDirTopLeft, "enumLightDirTopLeft" },
{ enumLightDirTopRight, "enumLightDirTopRight" },
{ enumLightGray, "enumLightGray" },
{ enumLightDirectional, "enumLightDirectional" },
{ enumLightenOnly, "enumLightenOnly" },
{ enumLightOmni, "enumLightOmni" },
{ enumLightPosBottom, "enumLightPosBottom" },
{ enumLightPosBottomLeft, "enumLightPosBottomLeft" },
{ enumLightPosBottomRight, "enumLightPosBottomRight" },
{ enumLightPosLeft, "enumLightPosLeft" },
{ enumLightPosRight, "enumLightPosRight" },
{ enumLightPosTop, "enumLightPosTop" },
{ enumLightPosTopLeft, "enumLightPosTopLeft" },
{ enumLightPosTopRight, "enumLightPosTopRight" },
{ enumLightRed, "enumLightRed" },
{ enumLightSpot, "enumLightSpot" },
{ enumLighten, "enumLighten" },
{ enumLightness, "enumLightness" },
{ enumLine, "enumLine" },
{ enumLines, "enumLines" },
{ enumLinear, "enumLinear" },
{ enumLinked, "enumLinked" },
{ enumLongLines, "enumLongLines" },
{ enumLongStrokes, "enumLongStrokes" },
{ enumLow, "enumLow" },
{ enumLower, "enumLower" },
{ enumLowQuality, "enumLowQuality" },
{ enumLuminosity, "enumLuminosity" },
{ enumMacThumbnail, "enumMacThumbnail" },
{ enumMacintosh, "enumMacintosh" },
{ enumMacintoshSystem, "enumMacintoshSystem" },
{ enumMagenta, "enumMagenta" },
{ enumMagentas, "enumMagentas" },
{ enumMask, "enumMask" },
{ enumMaskedAreas, "enumMaskedAreas" },
{ enumMasterAdaptive, "enumMasterAdaptive" },
{ enumMasterPerceptual, "enumMasterPerceptual" },
{ enumMasterSelective, "enumMasterSelective" },
{ enumMaximum, "enumMaximum" },
{ enumMaximumQuality, "enumMaximumQuality" },
{ enumMedium, "enumMedium" },
{ enumMediumBlue, "enumMediumBlue" },
{ enumMediumQuality, "enumMediumQuality" },
{ enumMediumDots, "enumMediumDots" },
{ enumMediumLines, "enumMediumLines" },
{ enumMediumStrokes, "enumMediumStrokes" },
{ enumMemoryPreferences, "enumMemoryPreferences" },
{ enumMergeChannels, "enumMergeChannels" },
{ enumMerged, "enumMerged" },
{ enumMergedLayers, "enumMergedLayers" },
{ enumMiddle, "enumMiddle" },
{ enumMidtones, "enumMidtones" },
{ enumModeGray, "enumModeGray" },
{ enumModeRGB, "enumModeRGB" },
{ enumMonitor, "enumMonitor" },
{ enumMonotone, "enumMonotone" },
{ enumMulti72Color, "enumMulti72Color" },
{ enumMulti72Gray, "enumMulti72Gray" },
{ enumMultichannel, "enumMultichannel" },
{ enumMultiNoCompositePS, "enumMultiNoCompositePS" },
{ enumMultiply, "enumMultiply" },
{ enumNavigatorPaletteOptions, "enumNavigatorPaletteOptions" },
{ enumNearestNeighbor, "enumNearestNeighbor" },
{ enumNetscapeGray, "enumNetscapeGray" },
{ enumNeutrals, "enumNeutrals" },
{ enumNewView, "enumNewView" },
{ enumNext, "enumNext" },
{ enumNikon, "enumNikon" },
{ enumNikon105, "enumNikon105" },
{ enumNo, "enumNo" },
{ enumNoCompositePS, "enumNoCompositePS" },
{ enumNone, "enumNone" },
{ enumNormal, "enumNormal" },
{ enumNormalPath, "enumNormalPath" },
{ enumNTSC, "enumNTSC" },
{ enumNull, "enumNull" },
{ enumOS2, "enumOS2" },
{ enumOff, "enumOff" },
{ enumOn, "enumOn" },
{ enumOpenAs, "enumOpenAs" },
{ enumOrange, "enumOrange" },
{ enumOutFromCenter, "enumOutFromCenter" },
{ enumOutOfGamut, "enumOutOfGamut" },
{ enumOuterBevel, "enumOuterBevel" },
{ enumOutside, "enumOutside" },
{ enumOutsetFrame, "enumOutsetFrame" },
{ enumOverlay, "enumOverlay" },
{ enumPaintbrushEraser, "enumPaintbrushEraser" },
{ enumPencilEraser, "enumPencilEraser" },
{ enumP22EBU, "enumP22EBU" },
{ enumPNGFilterAdaptive, "enumPNGFilterAdaptive" },
{ enumPNGFilterAverage, "enumPNGFilterAverage" },
{ enumPNGFilterNone, "enumPNGFilterNone" },
{ enumPNGFilterPaeth, "enumPNGFilterPaeth" },
{ enumPNGFilterSub, "enumPNGFilterSub" },
{ enumPNGFilterUp, "enumPNGFilterUp" },
{ enumPNGInterlaceAdam7, "enumPNGInterlaceAdam7" },
{ enumPNGInterlaceNone, "enumPNGInterlaceNone" },
{ enumPagePosCentered, "enumPagePosCentered" },
{ enumPagePosTopLeft, "enumPagePosTopLeft" },
{ enumPageSetup, "enumPageSetup" },
{ enumPalSecam, "enumPalSecam" },
{ enumPanaVision, "enumPanaVision" },
{ enumPathsPaletteOptions, "enumPathsPaletteOptions" },
{ enumPattern, "enumPattern" },
{ enumPatternDither, "enumPatternDither" },
{ enumPerceptual, "enumPerceptual" },
{ enumPerspective, "enumPerspective" },
{ enumPhotoshopPicker, "enumPhotoshopPicker" },
{ enumPickCMYK, "enumPickCMYK" },
{ enumPickGray, "enumPickGray" },
{ enumPickHSB, "enumPickHSB" },
{ enumPickLab, "enumPickLab" },
{ enumPickOptions, "enumPickOptions" },
{ enumPickRGB, "enumPickRGB" },
{ enumPillowEmboss, "enumPillowEmboss" },
{ enumPixelPaintSize1, "enumPixelPaintSize1" },
{ enumPixelPaintSize2, "enumPixelPaintSize2" },
{ enumPixelPaintSize3, "enumPixelPaintSize3" },
{ enumPixelPaintSize4, "enumPixelPaintSize4" },
{ enumPlace, "enumPlace" },
{ enumPlaybackOptions, "enumPlaybackOptions" },
{ enumPluginPicker, "enumPluginPicker" },
{ enumPluginsScratchDiskPreferences, "enumPluginsScratchDiskPreferences" },
{ enumPolarToRect, "enumPolarToRect" },
{ enumPondRipples, "enumPondRipples" },
{ enumPrecise, "enumPrecise" },
{ enumPreciseMatte, "enumPreciseMatte" },
{ enumPreviewOff, "enumPreviewOff" },
{ enumPreviewCMYK, "enumPreviewCMYK" },
{ enumPreviewCyan, "enumPreviewCyan" },
{ enumPreviewMagenta, "enumPreviewMagenta" },
{ enumPreviewYellow, "enumPreviewYellow" },
{ enumPreviewBlack, "enumPreviewBlack" },
{ enumPreviewCMY, "enumPreviewCMY" },
{ enumPrevious, "enumPrevious" },
{ enumPrimaries, "enumPrimaries" },
{ enumPrintSize, "enumPrintSize" },
{ enumPrintingInksSetup, "enumPrintingInksSetup" },
{ enumPurple, "enumPurple" },
{ enumPyramids, "enumPyramids" },
{ enumQCSAverage, "enumQCSAverage" },
{ enumQCSCorner0, "enumQCSCorner0" },
{ enumQCSCorner1, "enumQCSCorner1" },
{ enumQCSCorner2, "enumQCSCorner2" },
{ enumQCSCorner3, "enumQCSCorner3" },
{ enumQCSIndependent, "enumQCSIndependent" },
{ enumQCSSide0, "enumQCSSide0" },
{ enumQCSSide1, "enumQCSSide1" },
{ enumQCSSide2, "enumQCSSide2" },
{ enumQCSSide3, "enumQCSSide3" },
{ enumQuadtone, "enumQuadtone" },
{ enumQueryAlways, "enumQueryAlways" },
{ enumQueryAsk, "enumQueryAsk" },
{ enumQueryNever, "enumQueryNever" },
{ enumRepeat, "enumRepeat" },
{ enumRGB, "enumRGB" },
{ enumRGB48, "enumRGB48" },
{ enumRGBColor, "enumRGBColor" },
{ enumRadial, "enumRadial" },
{ enumRandom, "enumRandom" },
{ enumRectToPolar, "enumRectToPolar" },
{ enumRed, "enumRed" },
{ enumRedrawComplete, "enumRedrawComplete" },
{ enumReds, "enumReds" },
{ enumReflected, "enumReflected" },
{ enumRelative, "enumRelative" },
{ enumRepeatEdgePixels, "enumRepeatEdgePixels" },
{ enumRevealAll, "enumRevealAll" },
{ enumRevealSelection, "enumRevealSelection" },
{ enumRevert, "enumRevert" },
{ enumRight, "enumRight" },
{ enumRotate, "enumRotate" },
{ enumRotoscopingPreferences, "enumRotoscopingPreferences" },
{ enumRound, "enumRound" },
{ enumRulerCm, "enumRulerCm" },
{ enumRulerInches, "enumRulerInches" },
{ enumRulerPercent, "enumRulerPercent" },
{ enumRulerPicas, "enumRulerPicas" },
{ enumRulerPixels, "enumRulerPixels" },
{ enumRulerPoints, "enumRulerPoints" },
{ enumAdobeRGB1998, "enumAdobeRGB1998" },
{ enumSMPTEC, "enumSMPTEC" },
{ enumSRGB, "enumSRGB" },
{ enumSample3x3, "enumSample3x3" },
{ enumSample5x5, "enumSample5x5" },
{ enumSamplePoint, "enumSamplePoint" },
{ enumSaturate, "enumSaturate" },
{ enumSaturation, "enumSaturation" },
{ enumSaved, "enumSaved" },
{ enumSaveForWeb, "enumSaveForWeb" },
{ enumSavingFilesPreferences, "enumSavingFilesPreferences" },
{ enumScale, "enumScale" },
{ enumScreen, "enumScreen" },
{ enumScreenCircle, "enumScreenCircle" },
{ enumScreenDot, "enumScreenDot" },
{ enumScreenLine, "enumScreenLine" },
{ enumSelectedAreas, "enumSelectedAreas" },
{ enumSelection, "enumSelection" },
{ enumSelective, "enumSelective" },
{ enumSeparationSetup, "enumSeparationSetup" },
{ enumSeparationTables, "enumSeparationTables" },
{ enumShadows, "enumShadows" },
{ enumContourLinear, "enumContourLinear" },
{ enumContourGaussian, "enumContourGaussian" },
{ enumContourSingle, "enumContourSingle" },
{ enumContourDouble, "enumContourDouble" },
{ enumContourTriple, "enumContourTriple" },
{ enumContourCustom, "enumContourCustom" },
{ enumShortLines, "enumShortLines" },
{ enumShortStrokes, "enumShortStrokes" },
{ enumSingle72Color, "enumSingle72Color" },
{ enumSingle72Gray, "enumSingle72Gray" },
{ enumSingleNoCompositePS, "enumSingleNoCompositePS" },
{ enumSkew, "enumSkew" },
{ enumSlopeLimitMatte, "enumSlopeLimitMatte" },
{ enumSmall, "enumSmall" },
{ enumSmartBlurModeEdgeOnly, "enumSmartBlurModeEdgeOnly" },
{ enumSmartBlurModeNormal, "enumSmartBlurModeNormal" },
{ enumSmartBlurModeOverlayEdge, "enumSmartBlurModeOverlayEdge" },
{ enumSmartBlurQualityHigh, "enumSmartBlurQualityHigh" },
{ enumSmartBlurQualityLow, "enumSmartBlurQualityLow" },
{ enumSmartBlurQualityMedium, "enumSmartBlurQualityMedium" },
{ enumSnapshot, "enumSnapshot" },
{ enumSolidColor, "enumSolidColor" },
{ enumSoftLight, "enumSoftLight" },
{ enumSoftMatte, "enumSoftMatte" },
{ enumSpectrum, "enumSpectrum" },
{ enumSpin, "enumSpin" },
{ enumSpotColor, "enumSpotColor" },
{ enumSquare, "enumSquare" },
{ enumStagger, "enumStagger" },
{ enumStampIn, "enumStampIn" },
{ enumStampOut, "enumStampOut" },
{ enumStandard, "enumStandard" },
{ enumStdA, "enumStdA" },
{ enumStdB, "enumStdB" },
{ enumStdC, "enumStdC" },
{ enumStdE, "enumStdE" },
{ enumStretchToFit, "enumStretchToFit" },
{ enumStrokeDirHorizontal, "enumStrokeDirHorizontal" },
{ enumStrokeDirLeftDiag, "enumStrokeDirLeftDiag" },
{ enumStrokeDirRightDiag, "enumStrokeDirRightDiag" },
{ enumStrokeDirVertical, "enumStrokeDirVertical" },
{ enumStylesAppend, "enumStylesAppend" },
{ enumStylesDelete, "enumStylesDelete" },
{ enumStylesLoad, "enumStylesLoad" },
{ enumStylesNew, "enumStylesNew" },
{ enumStylesReset, "enumStylesReset" },
{ enumStylesSave, "enumStylesSave" },
{ enumSubtract, "enumSubtract" },
{ enumSwatchesAppend, "enumSwatchesAppend" },
{ enumSwatchesReplace, "enumSwatchesReplace" },
{ enumSwatchesReset, "enumSwatchesReset" },
{ enumSwatchesSave, "enumSwatchesSave" },
{ enumSystemPicker, "enumSystemPicker" },
{ enumTables, "enumTables" },
{ enumTarget, "enumTarget" },
{ enumTargetPath, "enumTargetPath" },
{ enumTexTypeBlocks, "enumTexTypeBlocks" },
{ enumTexTypeBrick, "enumTexTypeBrick" },
{ enumTexTypeBurlap, "enumTexTypeBurlap" },
{ enumTexTypeCanvas, "enumTexTypeCanvas" },
{ enumTexTypeFrosted, "enumTexTypeFrosted" },
{ enumTexTypeSandstone, "enumTexTypeSandstone" },
{ enumTexTypeTinyLens, "enumTexTypeTinyLens" },
{ enumThreshold, "enumThreshold" },
{ enumThumbnail, "enumThumbnail" },
{ enumTIFF, "enumTIFF" },
{ enumTile, "enumTile" },
{ enumTile_PLUGIN, "enumTile_PLUGIN" },
{ enumToggleActionsPalette, "enumToggleActionsPalette" },
{ enumToggleBlackPreview, "enumToggleBlackPreview" },
{ enumToggleBrushesPalette, "enumToggleBrushesPalette" },
{ enumToggleCMYKPreview, "enumToggleCMYKPreview" },
{ enumToggleCMYPreview, "enumToggleCMYPreview" },
{ enumToggleChannelsPalette, "enumToggleChannelsPalette" },
{ enumToggleColorPalette, "enumToggleColorPalette" },
{ enumToggleCyanPreview, "enumToggleCyanPreview" },
{ enumToggleEdges, "enumToggleEdges" },
{ enumToggleGamutWarning, "enumToggleGamutWarning" },
{ enumToggleGrid, "enumToggleGrid" },
{ enumToggleGuides, "enumToggleGuides" },
{ enumToggleHistoryPalette, "enumToggleHistoryPalette" },
{ enumToggleInfoPalette, "enumToggleInfoPalette" },
{ enumToggleLayerMask, "enumToggleLayerMask" },
{ enumToggleLayersPalette, "enumToggleLayersPalette" },
{ enumToggleLockGuides, "enumToggleLockGuides" },
{ enumToggleMagentaPreview, "enumToggleMagentaPreview" },
{ enumToggleNavigatorPalette, "enumToggleNavigatorPalette" },
{ enumToggleOptionsPalette, "enumToggleOptionsPalette" },
{ enumTogglePaths, "enumTogglePaths" },
{ enumTogglePathsPalette, "enumTogglePathsPalette" },
{ enumToggleRGBMacPreview, "enumToggleRGBMacPreview" },
{ enumToggleRGBWindowsPreview, "enumToggleRGBWindowsPreview" },
{ enumToggleRGBUncompensatedPreview, "enumToggleRGBUncompensatedPreview" },
{ enumToggleRulers, "enumToggleRulers" },
{ enumToggleSnapToGrid, "enumToggleSnapToGrid" },
{ enumToggleSnapToGuides, "enumToggleSnapToGuides" },
{ enumToggleStatusBar, "enumToggleStatusBar" },
{ enumToggleStylesPalette, "enumToggleStylesPalette" },
{ enumToggleSwatchesPalette, "enumToggleSwatchesPalette" },
{ enumToggleToolsPalette, "enumToggleToolsPalette" },
{ enumToggleYellowPreview, "enumToggleYellowPreview" },
{ enumTop, "enumTop" },
{ enumTransparency, "enumTransparency" },
{ enumTransparencyGamutPreferences, "enumTransparencyGamutPreferences" },
{ enumTransparent, "enumTransparent" },
{ enumTrinitron, "enumTrinitron" },
{ enumTritone, "enumTritone" },
{ enumUIBitmap, "enumUIBitmap" },
{ enumUICMYK, "enumUICMYK" },
{ enumUIDuotone, "enumUIDuotone" },
{ enumUIGrayscale, "enumUIGrayscale" },
{ enumUIIndexed, "enumUIIndexed" },
{ enumUILab, "enumUILab" },
{ enumUIMultichannel, "enumUIMultichannel" },
{ enumUIRGB, "enumUIRGB" },
{ enumUndo, "enumUndo" },
{ enumUniform, "enumUniform" },
{ enumUniformDistribution, "enumUniformDistribution" },
{ enumUnitsRulersPreferences, "enumUnitsRulersPreferences" },
{ enumUpper, "enumUpper" },
{ enumUserStop, "enumUserStop" },
{ enumVMPreferences, "enumVMPreferences" },
{ enumVertical, "enumVertical" },
{ enumVerticalOnly, "enumVerticalOnly" },
{ enumViolet, "enumViolet" },
{ enumWaveSine, "enumWaveSine" },
{ enumWaveSquare, "enumWaveSquare" },
{ enumWaveTriangle, "enumWaveTriangle" },
{ enumWeb, "enumWeb" },
{ enumWhite, "enumWhite" },
{ enumWhites, "enumWhites" },
{ enumWinThumbnail, "enumWinThumbnail" },
{ enumWind, "enumWind" },
{ enumWindows, "enumWindows" },
{ enumWindowsSystem, "enumWindowsSystem" },
{ enumWrap, "enumWrap" },
{ enumWrapAround, "enumWrapAround" },
{ enumWorkPath, "enumWorkPath" },
{ enumYellow, "enumYellow" },
{ enumYellowColor, "enumYellowColor" },
{ enumYellows, "enumYellows" },
{ enumYes, "enumYes" },
{ enumZip, "enumZip" },
{ enumZoom, "enumZoom" },
{ enumZoomIn, "enumZoomIn" },
{ enumZoomOut, "enumZoomOut" },
{ event3DTransform, "event3DTransform" },
{ eventApplyStyle, "eventApplyStyle" },
{ eventAssert, "eventAssert" },
{ eventAccentedEdges, "eventAccentedEdges" },
{ eventAdd, "eventAdd" },
{ eventAddNoise, "eventAddNoise" },
{ eventAddTo, "eventAddTo" },
{ eventAlign, "eventAlign" },
{ eventAll, "eventAll" },
{ eventAngledStrokes, "eventAngledStrokes" },
{ eventApplyImage, "eventApplyImage" },
{ eventBasRelief, "eventBasRelief" },
{ eventBatch, "eventBatch" },
{ eventBatchFromDroplet, "eventBatchFromDroplet" },
{ eventBlur, "eventBlur" },
{ eventBlurMore, "eventBlurMore" },
{ eventBorder, "eventBorder" },
{ eventBrightness, "eventBrightness" },
{ eventCanvasSize, "eventCanvasSize" },
{ eventChalkCharcoal, "eventChalkCharcoal" },
{ eventChannelMixer, "eventChannelMixer" },
{ eventCharcoal, "eventCharcoal" },
{ eventChrome, "eventChrome" },
{ eventClear, "eventClear" },
{ eventClose, "eventClose" },
{ eventClouds, "eventClouds" },
{ eventColorBalance, "eventColorBalance" },
{ eventColorHalftone, "eventColorHalftone" },
{ eventColorRange, "eventColorRange" },
{ eventColoredPencil, "eventColoredPencil" },
{ eventConteCrayon, "eventConteCrayon" },
{ eventContract, "eventContract" },
{ eventConvertMode, "eventConvertMode" },
{ eventCopy, "eventCopy" },
{ eventCopyEffects, "eventCopyEffects" },
{ eventCopyMerged, "eventCopyMerged" },
{ eventCopyToLayer, "eventCopyToLayer" },
{ eventCraquelure, "eventCraquelure" },
{ eventCreateDroplet, "eventCreateDroplet" },
{ eventCrop, "eventCrop" },
{ eventCrosshatch, "eventCrosshatch" },
{ eventCrystallize, "eventCrystallize" },
{ eventCurves, "eventCurves" },
{ eventCustom, "eventCustom" },
{ eventCut, "eventCut" },
{ eventCutToLayer, "eventCutToLayer" },
{ eventCutout, "eventCutout" },
{ eventDarkStrokes, "eventDarkStrokes" },
{ eventDeInterlace, "eventDeInterlace" },
{ eventDefinePattern, "eventDefinePattern" },
{ eventDefringe, "eventDefringe" },
{ eventDelete, "eventDelete" },
{ eventDesaturate, "eventDesaturate" },
{ eventDeselect, "eventDeselect" },
{ eventDespeckle, "eventDespeckle" },
{ eventDifferenceClouds, "eventDifferenceClouds" },
{ eventDiffuse, "eventDiffuse" },
{ eventDiffuseGlow, "eventDiffuseGlow" },
{ eventDisableLayerFX, "eventDisableLayerFX" },
{ eventDisplace, "eventDisplace" },
{ eventDistribute, "eventDistribute" },
{ eventDraw, "eventDraw" },
{ eventDryBrush, "eventDryBrush" },
{ eventDuplicate, "eventDuplicate" },
{ eventDustAndScratches, "eventDustAndScratches" },
{ eventEmboss, "eventEmboss" },
{ eventEqualize, "eventEqualize" },
{ eventExchange, "eventExchange" },
{ eventExpand, "eventExpand" },
{ eventExport, "eventExport" },
{ eventJumpto, "eventJumpto" },
{ eventExtrude, "eventExtrude" },
{ eventFacet, "eventFacet" },
{ eventFade, "eventFade" },
{ eventFeather, "eventFeather" },
{ eventFill, "eventFill" },
{ eventFilmGrain, "eventFilmGrain" },
{ eventFilter, "eventFilter" },
{ eventFindEdges, "eventFindEdges" },
{ eventFlattenImage, "eventFlattenImage" },
{ eventFlip, "eventFlip" },
{ eventFragment, "eventFragment" },
{ eventFresco, "eventFresco" },
{ eventGaussianBlur, "eventGaussianBlur" },
{ eventGet, "eventGet" },
{ eventGlass, "eventGlass" },
{ eventGlowingEdges, "eventGlowingEdges" },
{ eventGradient, "eventGradient" },
{ eventGradientMap, "eventGradientMap" },
{ eventGrain, "eventGrain" },
{ eventGraphicPen, "eventGraphicPen" },
{ eventGroup, "eventGroup" },
{ eventGrow, "eventGrow" },
{ eventHalftoneScreen, "eventHalftoneScreen" },
{ eventHide, "eventHide" },
{ eventHighPass, "eventHighPass" },
{ eventHueSaturation, "eventHueSaturation" },
{ eventImageSize, "eventImageSize" },
{ eventImport, "eventImport" },
{ eventInkOutlines, "eventInkOutlines" },
{ eventIntersect, "eventIntersect" },
{ eventIntersectWith, "eventIntersectWith" },
{ eventInverse, "eventInverse" },
{ eventInvert, "eventInvert" },
{ eventLensFlare, "eventLensFlare" },
{ eventLevels, "eventLevels" },
{ eventLightingEffects, "eventLightingEffects" },
{ eventLink, "eventLink" },
{ eventMake, "eventMake" },
{ eventMaximum, "eventMaximum" },
{ eventMedian, "eventMedian" },
{ eventMergeLayers, "eventMergeLayers" },
{ eventMergeSpotChannel, "eventMergeSpotChannel" },
{ eventMergeVisible, "eventMergeVisible" },
{ eventMezzotint, "eventMezzotint" },
{ eventMinimum, "eventMinimum" },
{ eventMosaic, "eventMosaic" },
{ eventMosaic_PLUGIN, "eventMosaic_PLUGIN" },
{ eventMotionBlur, "eventMotionBlur" },
{ eventMove, "eventMove" },
{ eventNTSCColors, "eventNTSCColors" },
{ eventNeonGlow, "eventNeonGlow" },
{ eventNext, "eventNext" },
{ eventNotePaper, "eventNotePaper" },
{ eventNotify, "eventNotify" },
{ eventNull, "eventNull" },
{ eventOceanRipple, "eventOceanRipple" },
{ eventOffset, "eventOffset" },
{ eventOpen, "eventOpen" },
{ eventPaintDaubs, "eventPaintDaubs" },
{ eventPaletteKnife, "eventPaletteKnife" },
{ eventPaste, "eventPaste" },
{ eventPasteEffects, "eventPasteEffects" },
{ eventPasteInto, "eventPasteInto" },
{ eventPasteOutside, "eventPasteOutside" },
{ eventPatchwork, "eventPatchwork" },
{ eventPhotocopy, "eventPhotocopy" },
{ eventPinch, "eventPinch" },
{ eventPlace, "eventPlace" },
{ eventPlaster, "eventPlaster" },
{ eventPlasticWrap, "eventPlasticWrap" },
{ eventPlay, "eventPlay" },
{ eventPointillize, "eventPointillize" },
{ eventPolar, "eventPolar" },
{ eventPosterEdges, "eventPosterEdges" },
{ eventPosterize, "eventPosterize" },
{ eventPrevious, "eventPrevious" },
{ eventPrint, "eventPrint" },
{ eventProfileToProfile, "eventProfileToProfile" },
{ eventPurge, "eventPurge" },
{ eventQuit, "eventQuit" },
{ eventRadialBlur, "eventRadialBlur" },
{ eventRasterize, "eventRasterize" },
{ eventRasterizeTypeSheet, "eventRasterizeTypeSheet" },
{ eventRemoveBlackMatte, "eventRemoveBlackMatte" },
{ eventRemoveLayerMask, "eventRemoveLayerMask" },
{ eventRemoveWhiteMatte, "eventRemoveWhiteMatte" },
{ eventRename, "eventRename" },
{ eventReplaceColor, "eventReplaceColor" },
{ eventReset, "eventReset" },
{ eventReticulation, "eventReticulation" },
{ eventRevert, "eventRevert" },
{ eventRipple, "eventRipple" },
{ eventRotate, "eventRotate" },
{ eventRoughPastels, "eventRoughPastels" },
{ eventSave, "eventSave" },
{ eventSelect, "eventSelect" },
{ eventSelectiveColor, "eventSelectiveColor" },
{ eventSet, "eventSet" },
{ eventSharpenEdges, "eventSharpenEdges" },
{ eventSharpen, "eventSharpen" },
{ eventSharpenMore, "eventSharpenMore" },
{ eventShear, "eventShear" },
{ eventShow, "eventShow" },
{ eventSimilar, "eventSimilar" },
{ eventSmartBlur, "eventSmartBlur" },
{ eventSmooth, "eventSmooth" },
{ eventSmudgeStick, "eventSmudgeStick" },
{ eventSolarize, "eventSolarize" },
{ eventSpatter, "eventSpatter" },
{ eventSpherize, "eventSpherize" },
{ eventSplitChannels, "eventSplitChannels" },
{ eventSponge, "eventSponge" },
{ eventSprayedStrokes, "eventSprayedStrokes" },
{ eventStainedGlass, "eventStainedGlass" },
{ eventStamp, "eventStamp" },
{ eventStop, "eventStop" },
{ eventStroke, "eventStroke" },
{ eventSubtract, "eventSubtract" },
{ eventSubtractFrom, "eventSubtractFrom" },
{ eventSumie, "eventSumie" },
{ eventTakeMergedSnapshot, "eventTakeMergedSnapshot" },
{ eventTakeSnapshot, "eventTakeSnapshot" },
{ eventTextureFill, "eventTextureFill" },
{ eventTexturizer, "eventTexturizer" },
{ eventThreshold, "eventThreshold" },
{ eventTiles, "eventTiles" },
{ eventTornEdges, "eventTornEdges" },
{ eventTraceContour, "eventTraceContour" },
{ eventTransform, "eventTransform" },
{ eventTrap, "eventTrap" },
{ eventTwirl, "eventTwirl" },
{ eventUnderpainting, "eventUnderpainting" },
{ eventUndo, "eventUndo" },
{ eventUngroup, "eventUngroup" },
{ eventUnlink, "eventUnlink" },
{ eventUnsharpMask, "eventUnsharpMask" },
{ eventVariations, "eventVariations" },
{ eventWait, "eventWait" },
{ eventWaterPaper, "eventWaterPaper" },
{ eventWatercolor, "eventWatercolor" },
{ eventWave, "eventWave" },
{ eventWind, "eventWind" },
{ eventZigZag, "eventZigZag" },
{ formClass, "formClass" },
{ formEnumerated, "formEnumerated" },
{ formIdentifier, "formIdentifier" },
{ formIndex, "formIndex" },
{ formOffset, "formOffset" },
{ formProperty, "formProperty" },
{ formName, "formName" },
{ key3DAntiAlias, "key3DAntiAlias" },
{ keyA, "keyA" },
{ keyAdjustment, "keyAdjustment" },
{ keyAligned, "keyAligned" },
{ keyAlignment, "keyAlignment" },
{ keyAll, "keyAll" },
{ keyAllExcept, "keyAllExcept" },
{ keyAllToolOptions, "keyAllToolOptions" },
{ keyAlphaChannelOptions, "keyAlphaChannelOptions" },
{ keyAlphaChannels, "keyAlphaChannels" },
{ keyAmbientBrightness, "keyAmbientBrightness" },
{ keyAmbientColor, "keyAmbientColor" },
{ keyAmount, "keyAmount" },
{ keyAmplitudeMax, "keyAmplitudeMax" },
{ keyAmplitudeMin, "keyAmplitudeMin" },
{ keyAnchor, "keyAnchor" },
{ keyAngle, "keyAngle" },
{ keyAngle1, "keyAngle1" },
{ keyAngle2, "keyAngle2" },
{ keyAngle3, "keyAngle3" },
{ keyAngle4, "keyAngle4" },
{ keyAntiAlias, "keyAntiAlias" },
{ keyAppend, "keyAppend" },
{ keyApply, "keyApply" },
{ keyArea, "keyArea" },
{ keyArrowhead, "keyArrowhead" },
{ keyAs, "keyAs" },
{ keyAssumedCMYK, "keyAssumedCMYK" },
{ keyAssumedGray, "keyAssumedGray" },
{ keyAssumedRGB, "keyAssumedRGB" },
{ keyAt, "keyAt" },
{ keyAuto, "keyAuto" },
{ keyAutoContrast, "keyAutoContrast" },
{ keyAutoErase, "keyAutoErase" },
{ keyAutoKern, "keyAutoKern" },
{ keyAutoUpdate, "keyAutoUpdate" },
{ keyAxis, "keyAxis" },
{ keyB, "keyB" },
{ keyBackground, "keyBackground" },
{ keyBackgroundColor, "keyBackgroundColor" },
{ keyBackgroundLevel, "keyBackgroundLevel" },
{ keyBackward, "keyBackward" },
{ keyBalance, "keyBalance" },
{ keyBaselineShift, "keyBaselineShift" },
{ keyBeepWhenDone, "keyBeepWhenDone" },
{ keyBeginRamp, "keyBeginRamp" },
{ keyBeginSustain, "keyBeginSustain" },
{ keyBevelDirection, "keyBevelDirection" },
{ keyBevelEmboss, "keyBevelEmboss" },
{ keyBevelStyle, "keyBevelStyle" },
{ keyBevelTechnique, "keyBevelTechnique" },
{ keyBigNudgeH, "keyBigNudgeH" },
{ keyBigNudgeV, "keyBigNudgeV" },
{ keyBitDepth, "keyBitDepth" },
{ keyBlack, "keyBlack" },
{ keyBlackClip, "keyBlackClip" },
{ keyBlackGeneration, "keyBlackGeneration" },
{ keyBlackGenerationCurve, "keyBlackGenerationCurve" },
{ keyBlackIntensity, "keyBlackIntensity" },
{ keyBlackLevel, "keyBlackLevel" },
{ keyBlackLimit, "keyBlackLimit" },
{ keyBleed, "keyBleed" },
{ keyBlendRange, "keyBlendRange" },
{ keyBlue, "keyBlue" },
{ keyBlueBlackPoint, "keyBlueBlackPoint" },
{ keyBlueGamma, "keyBlueGamma" },
{ keyBlueWhitePoint, "keyBlueWhitePoint" },
{ keyBlueX, "keyBlueX" },
{ keyBlueY, "keyBlueY" },
{ keyBlur, "keyBlur" },
{ keyBlurMethod, "keyBlurMethod" },
{ keyBlurQuality, "keyBlurQuality" },
{ keyBook, "keyBook" },
{ keyBorderThickness, "keyBorderThickness" },
{ keyBottom, "keyBottom" },
{ keyBrightness, "keyBrightness" },
{ keyBrushDetail, "keyBrushDetail" },
{ keyBrushes, "keyBrushes" },
{ keyBrushSize, "keyBrushSize" },
{ keyBrushType, "keyBrushType" },
{ keyBumpAmplitude, "keyBumpAmplitude" },
{ keyBumpChannel, "keyBumpChannel" },
{ keyBy, "keyBy" },
{ keyByline, "keyByline" },
{ keyBylineTitle, "keyBylineTitle" },
{ keyByteOrder, "keyByteOrder" },
{ keyCachePrefs, "keyCachePrefs" },
{ keyChokeMatte, "keyChokeMatte" },
{ keyCloneSource, "keyCloneSource" },
{ keyCMYKSetup, "keyCMYKSetup" },
{ keyCalculation, "keyCalculation" },
{ keyCalibrationBars, "keyCalibrationBars" },
{ keyCaption, "keyCaption" },
{ keyCaptionWriter, "keyCaptionWriter" },
{ keyCategory, "keyCategory" },
{ keyCellSize, "keyCellSize" },
{ keyCenter, "keyCenter" },
{ keyCenterCropMarks, "keyCenterCropMarks" },
{ keyChalkArea, "keyChalkArea" },
{ keyChannel, "keyChannel" },
{ keyChannelMatrix, "keyChannelMatrix" },
{ keyChannelName, "keyChannelName" },
{ keyChannels, "keyChannels" },
{ keyChannelsInterleaved, "keyChannelsInterleaved" },
{ keyCharcoalAmount, "keyCharcoalAmount" },
{ keyCharcoalArea, "keyCharcoalArea" },
{ keyChromeFX, "keyChromeFX" },
{ keyCity, "keyCity" },
{ keyClearAmount, "keyClearAmount" },
{ keyClippingPath, "keyClippingPath" },
{ keyClippingPathEPS, "keyClippingPathEPS" },
{ keyClippingPathFlatness, "keyClippingPathFlatness" },
{ keyClippingPathIndex, "keyClippingPathIndex" },
{ keyClippingPathInfo, "keyClippingPathInfo" },
{ keyClosedSubpath, "keyClosedSubpath" },
{ keyColor, "keyColor" },
{ keyColorChannels, "keyColorChannels" },
{ keyColorCorrection, "keyColorCorrection" },
{ keyColorIndicates, "keyColorIndicates" },
{ keyColorManagement, "keyColorManagement" },
{ keyColorPickerPrefs, "keyColorPickerPrefs" },
{ keyColorTable, "keyColorTable" },
{ keyColorize, "keyColorize" },
{ keyColors, "keyColors" },
{ keyColorsList, "keyColorsList" },
{ keyColorSpace, "keyColorSpace" },
{ keyColumnWidth, "keyColumnWidth" },
{ keyCommandKey, "keyCommandKey" },
{ keyCompensation, "keyCompensation" },
{ keyCompression, "keyCompression" },
{ keyConcavity, "keyConcavity" },
{ keyCondition, "keyCondition" },
{ keyConstant, "keyConstant" },
{ keyConstrain, "keyConstrain" },
{ keyConstrainProportions, "keyConstrainProportions" },
{ keyConstructionFOV, "keyConstructionFOV" },
{ keyContiguous, "keyContiguous" },
{ keyContinue, "keyContinue" },
{ keyContinuity, "keyContinuity" },
{ keyContrast, "keyContrast" },
{ keyConvert, "keyConvert" },
{ keyCopy, "keyCopy" },
{ keyCopyright, "keyCopyright" },
{ keyCopyrightNotice, "keyCopyrightNotice" },
{ keyCornerCropMarks, "keyCornerCropMarks" },
{ keyCount, "keyCount" },
{ keyCountryName, "keyCountryName" },
{ keyCrackBrightness, "keyCrackBrightness" },
{ keyCrackDepth, "keyCrackDepth" },
{ keyCrackSpacing, "keyCrackSpacing" },
{ keyCreateLayersFromLayerFX, "keyCreateLayersFromLayerFX" },
{ keyCredit, "keyCredit" },
{ keyCrossover, "keyCrossover" },
{ keyCurrent, "keyCurrent" },
{ keyCurrentHistoryState, "keyCurrentHistoryState" },
{ keyCurrentLight, "keyCurrentLight" },
{ keyCurrentToolOptions, "keyCurrentToolOptions" },
{ keyCurve, "keyCurve" },
{ keyCurveFile, "keyCurveFile" },
{ keyCustom, "keyCustom" },
{ keyCustomForced, "keyCustomForced" },
{ keyCustomMatte, "keyCustomMatte" },
{ keyCustomPalette, "keyCustomPalette" },
{ keyCyan, "keyCyan" },
{ keyDarkIntensity, "keyDarkIntensity" },
{ keyDarkness, "keyDarkness" },
{ keyDateCreated, "keyDateCreated" },
{ keyDatum, "keyDatum" },
{ keyDCS, "keyDCS" },
{ keyDefinition, "keyDefinition" },
{ keyDensity, "keyDensity" },
{ keyDepth, "keyDepth" },
{ keyDestBlackMax, "keyDestBlackMax" },
{ keyDestBlackMin, "keyDestBlackMin" },
{ keyDestinationMode, "keyDestinationMode" },
{ keyDestWhiteMax, "keyDestWhiteMax" },
{ keyDestWhiteMin, "keyDestWhiteMin" },
{ keyDetail, "keyDetail" },
{ keyDiameter, "keyDiameter" },
{ keyDiffusionDither, "keyDiffusionDither" },
{ keyDirection, "keyDirection" },
{ keyDirectionBalance, "keyDirectionBalance" },
{ keyDisplaceFile, "keyDisplaceFile" },
{ keyDisplacementMap, "keyDisplacementMap" },
{ keyDisplayPrefs, "keyDisplayPrefs" },
{ keyDistance, "keyDistance" },
{ keyDistortion, "keyDistortion" },
{ keyDistribution, "keyDistribution" },
{ keyDither, "keyDither" },
{ keyDitherAmount, "keyDitherAmount" },
{ keyDitherPreserve, "keyDitherPreserve" },
{ keyDitherQuality, "keyDitherQuality" },
{ keyDocumentID, "keyDocumentID" },
{ keyDotGain, "keyDotGain" },
{ keyDotGainCurves, "keyDotGainCurves" },
{ keyDropShadow, "keyDropShadow" },
{ keyDuplicate, "keyDuplicate" },
{ keyDynamicColorSliders, "keyDynamicColorSliders" },
{ keyEdge, "keyEdge" },
{ keyEdgeBrightness, "keyEdgeBrightness" },
{ keyEdgeFidelity, "keyEdgeFidelity" },
{ keyEdgeIntensity, "keyEdgeIntensity" },
{ keyEdgeSimplicity, "keyEdgeSimplicity" },
{ keyEdgeThickness, "keyEdgeThickness" },
{ keyEdgeWidth, "keyEdgeWidth" },
{ keyEffect, "keyEffect" },
{ keyEmbedProfiles, "keyEmbedProfiles" },
{ keyEmbedCMYK, "keyEmbedCMYK" },
{ keyEmbedGray, "keyEmbedGray" },
{ keyEmbedLab, "keyEmbedLab" },
{ keyEmbedRGB, "keyEmbedRGB" },
{ keyEmulsionDown, "keyEmulsionDown" },
{ keyEnabled, "keyEnabled" },
{ keyEncoding, "keyEncoding" },
{ keyEnd, "keyEnd" },
{ keyEndArrowhead, "keyEndArrowhead" },
{ keyEndRamp, "keyEndRamp" },
{ keyEndSustain, "keyEndSustain" },
{ keyEngine, "keyEngine" },
{ keyEraserKind, "keyEraserKind" },
{ keyEraseToHistory, "keyEraseToHistory" },
{ keyExactPoints, "keyExactPoints" },
{ keyExport, "keyExport" },
{ keyExportClipboard, "keyExportClipboard" },
{ keyExposure, "keyExposure" },
{ keyExtend, "keyExtend" },
{ keyExtension, "keyExtension" },
{ keyExtensionsQuery, "keyExtensionsQuery" },
{ keyExtrudeDepth, "keyExtrudeDepth" },
{ keyExtrudeMaskIncomplete, "keyExtrudeMaskIncomplete" },
{ keyExtrudeRandom, "keyExtrudeRandom" },
{ keyExtrudeSize, "keyExtrudeSize" },
{ keyExtrudeSolidFace, "keyExtrudeSolidFace" },
{ keyExtrudeType, "keyExtrudeType" },
{ keyEyeDropperSample, "keyEyeDropperSample" },
{ keyFadeoutSteps, "keyFadeoutSteps" },
{ keyFadeTo, "keyFadeTo" },
{ keyFalloff, "keyFalloff" },
{ keyFPXCompress, "keyFPXCompress" },
{ keyFPXQuality, "keyFPXQuality" },
{ keyFPXSize, "keyFPXSize" },
{ keyFPXView, "keyFPXView" },
{ keyFeather, "keyFeather" },
{ keyFiberLength, "keyFiberLength" },
{ keyFile, "keyFile" },
{ keyFileCreator, "keyFileCreator" },
{ keyFileInfo, "keyFileInfo" },
{ keyFileReference, "keyFileReference" },
{ keyFileSavePrefs, "keyFileSavePrefs" },
{ keyFileType, "keyFileType" },
{ keyFill, "keyFill" },
{ keyFillColor, "keyFillColor" },
{ keyFillNeutral, "keyFillNeutral" },
{ keyFingerpainting, "keyFingerpainting" },
{ keyFlareCenter, "keyFlareCenter" },
{ keyFlatness, "keyFlatness" },
{ keyFlatten, "keyFlatten" },
{ keyFocus, "keyFocus" },
{ keyFolders, "keyFolders" },
{ keyFontDesignAxes, "keyFontDesignAxes" },
{ keyFontDesignAxesVectors, "keyFontDesignAxesVectors" },
{ keyFontName, "keyFontName" },
{ keyFontScript, "keyFontScript" },
{ keyFontStyleName, "keyFontStyleName" },
{ keyFontTechnology, "keyFontTechnology" },
{ keyForcedColors, "keyForcedColors" },
{ keyForegroundColor, "keyForegroundColor" },
{ keyForegroundLevel, "keyForegroundLevel" },
{ keyFormat, "keyFormat" },
{ keyForward, "keyForward" },
{ keyFrameFX, "keyFrameFX" },
{ keyFrameWidth, "keyFrameWidth" },
{ keyFreeTransformCenterState, "keyFreeTransformCenterState" },
{ keyFrequency, "keyFrequency" },
{ keyFrom, "keyFrom" },
{ keyFromBuiltin, "keyFromBuiltin" },
{ keyFromMode, "keyFromMode" },
{ keyFunctionKey, "keyFunctionKey" },
{ keyFuzziness, "keyFuzziness" },
{ keyGamutWarning, "keyGamutWarning" },
{ keyGCR, "keyGCR" },
{ keyGeneralPrefs, "keyGeneralPrefs" },
{ keyGIFColorFileType, "keyGIFColorFileType" },
{ keyGIFColorLimit, "keyGIFColorLimit" },
{ keyGIFExportCaption, "keyGIFExportCaption" },
{ keyGIFMaskChannelIndex, "keyGIFMaskChannelIndex" },
{ keyGIFMaskChannelInverted, "keyGIFMaskChannelInverted" },
{ keyGIFPaletteFile, "keyGIFPaletteFile" },
{ keyGIFPaletteType, "keyGIFPaletteType" },
{ keyGIFRequiredColorSpaceType, "keyGIFRequiredColorSpaceType" },
{ keyGIFRowOrderType, "keyGIFRowOrderType" },
{ keyGIFTransparentColor, "keyGIFTransparentColor" },
{ keyGIFTransparentIndexBlue, "keyGIFTransparentIndexBlue" },
{ keyGIFTransparentIndexGreen, "keyGIFTransparentIndexGreen" },
{ keyGIFTransparentIndexRed, "keyGIFTransparentIndexRed" },
{ keyGIFUseBestMatch, "keyGIFUseBestMatch" },
{ keyGamma, "keyGamma" },
{ keyGlobalAngle, "keyGlobalAngle" },
{ keyGlobalLightingAngle, "keyGlobalLightingAngle" },
{ keyGloss, "keyGloss" },
{ keyGlowAmount, "keyGlowAmount" },
{ keyGlowTechnique, "keyGlowTechnique" },
{ keyGradient, "keyGradient" },
{ keyGradientFill, "keyGradientFill" },
{ keyGrain, "keyGrain" },
{ keyGrainType, "keyGrainType" },
{ keyGraininess, "keyGraininess" },
{ keyGray, "keyGray" },
{ keyGrayBehavior, "keyGrayBehavior" },
{ keyGraySetup, "keyGraySetup" },
{ keyGreen, "keyGreen" },
{ keyGreenBlackPoint, "keyGreenBlackPoint" },
{ keyGreenGamma, "keyGreenGamma" },
{ keyGreenWhitePoint, "keyGreenWhitePoint" },
{ keyGreenX, "keyGreenX" },
{ keyGreenY, "keyGreenY" },
{ keyGridColor, "keyGridColor" },
{ keyGridCustomColor, "keyGridCustomColor" },
{ keyGridMajor, "keyGridMajor" },
{ keyGridMinor, "keyGridMinor" },
{ keyGridStyle, "keyGridStyle" },
{ keyGridUnits, "keyGridUnits" },
{ keyGroup, "keyGroup" },
{ keyGroutWidth, "keyGroutWidth" },
{ keyGuides, "keyGuides" },
{ keyGuidesColor, "keyGuidesColor" },
{ keyGuidesCustomColor, "keyGuidesCustomColor" },
{ keyGuidesStyle, "keyGuidesStyle" },
{ keyGuidesPrefs, "keyGuidesPrefs" },
{ keyGutterWidth, "keyGutterWidth" },
{ keyHalftoneFile, "keyHalftoneFile" },
{ keyHalftoneScreen, "keyHalftoneScreen" },
{ keyHalftoneSpec, "keyHalftoneSpec" },
{ keyHalftoneSize, "keyHalftoneSize" },
{ keyHardness, "keyHardness" },
{ keyHeader, "keyHeader" },
{ keyHeadline, "keyHeadline" },
{ keyHeight, "keyHeight" },
{ keyHostName, "keyHostName" },
{ keyHighlightArea, "keyHighlightArea" },
{ keyHighlightColor, "keyHighlightColor" },
{ keyHighlightLevels, "keyHighlightLevels" },
{ keyHighlightMode, "keyHighlightMode" },
{ keyHighlightOpacity, "keyHighlightOpacity" },
{ keyHighlightStrength, "keyHighlightStrength" },
{ keyHistoryBrushSource, "keyHistoryBrushSource" },
{ keyHistoryPrefs, "keyHistoryPrefs" },
{ keyHistoryStateSource, "keyHistoryStateSource" },
{ keyHistoryStates, "keyHistoryStates" },
{ keyHorizontal, "keyHorizontal" },
{ keyHorizontalScale, "keyHorizontalScale" },
{ keyHostVersion, "keyHostVersion" },
{ keyHue, "keyHue" },
{ keyICCEngine, "keyICCEngine" },
{ keyICCSetupName, "keyICCSetupName" },
{ keyID, "keyID" },
{ keyIdle, "keyIdle" },
{ keyImageBalance, "keyImageBalance" },
{ keyImport, "keyImport" },
{ keyImpressionist, "keyImpressionist" },
{ keyIn, "keyIn" },
{ keyInherits, "keyInherits" },
{ keyInkColors, "keyInkColors" },
{ keyInks, "keyInks" },
{ keyInnerGlow, "keyInnerGlow" },
{ keyInnerGlowSource, "keyInnerGlowSource" },
{ keyInnerShadow, "keyInnerShadow" },
{ keyInput, "keyInput" },
{ keyInputMapRange, "keyInputMapRange" },
{ keyInputRange, "keyInputRange" },
{ keyIntensity, "keyIntensity" },
{ keyIntent, "keyIntent" },
{ keyInterfaceBevelHighlight, "keyInterfaceBevelHighlight" },
{ keyInterfaceBevelShadow, "keyInterfaceBevelShadow" },
{ keyInterfaceBlack, "keyInterfaceBlack" },
{ keyInterfaceBorder, "keyInterfaceBorder" },
{ keyInterfaceButtonDarkShadow, "keyInterfaceButtonDarkShadow" },
{ keyInterfaceButtonDownFill, "keyInterfaceButtonDownFill" },
{ keyInterfaceButtonUpFill, "keyInterfaceButtonUpFill" },
{ keyInterfaceColorBlue2, "keyInterfaceColorBlue2" },
{ keyInterfaceColorBlue32, "keyInterfaceColorBlue32" },
{ keyInterfaceColorGreen2, "keyInterfaceColorGreen2" },
{ keyInterfaceColorGreen32, "keyInterfaceColorGreen32" },
{ keyInterfaceColorRed2, "keyInterfaceColorRed2" },
{ keyInterfaceColorRed32, "keyInterfaceColorRed32" },
{ keyInterfaceIconFillActive, "keyInterfaceIconFillActive" },
{ keyInterfaceIconFillDimmed, "keyInterfaceIconFillDimmed" },
{ keyInterfaceIconFillSelected, "keyInterfaceIconFillSelected" },
{ keyInterfaceIconFrameActive, "keyInterfaceIconFrameActive" },
{ keyInterfaceIconFrameDimmed, "keyInterfaceIconFrameDimmed" },
{ keyInterfaceIconFrameSelected, "keyInterfaceIconFrameSelected" },
{ keyInterfacePaletteFill, "keyInterfacePaletteFill" },
{ keyInterfaceRed, "keyInterfaceRed" },
{ keyInterfaceWhite, "keyInterfaceWhite" },
{ keyInterfaceToolTipBackground, "keyInterfaceToolTipBackground" },
{ keyInterfaceToolTipText, "keyInterfaceToolTipText" },
{ keyInterfaceTransparencyForeground, "keyInterfaceTransparencyForeground" },
{ keyInterfaceTransparencyBackground, "keyInterfaceTransparencyBackground" },
{ keyInterlace, "keyInterlace" },
{ keyInterlaceCreateType, "keyInterlaceCreateType" },
{ keyInterlaceEliminateType, "keyInterlaceEliminateType" },
{ keyInterpolation, "keyInterpolation" },
{ keyInterpolationMethod, "keyInterpolationMethod" },
{ keyInvert, "keyInvert" },
{ keyInvertMask, "keyInvertMask" },
{ keyInvertSource2, "keyInvertSource2" },
{ keyInvertTexture, "keyInvertTexture" },
{ keyIsDirty, "keyIsDirty" },
{ keyItemIndex, "keyItemIndex" },
{ keyJPEGQuality, "keyJPEGQuality" },
{ keyKerning, "keyKerning" },
{ keyKeywords, "keyKeywords" },
{ keyKind, "keyKind" },
{ keyLZWCompression, "keyLZWCompression" },
{ keyLabels, "keyLabels" },
{ keyLandscape, "keyLandscape" },
{ keyLastTransform, "keyLastTransform" },
{ keyLayerEffects, "keyLayerEffects" },
{ keyLayerFXVisible, "keyLayerFXVisible" },
{ keyLayer, "keyLayer" },
{ keyLayerID, "keyLayerID" },
{ keyLayerName, "keyLayerName" },
{ keyLayers, "keyLayers" },
{ keyLeading, "keyLeading" },
{ keyLeft, "keyLeft" },
{ keyLength, "keyLength" },
{ keyLens, "keyLens" },
{ keyLevel, "keyLevel" },
{ keyLevels, "keyLevels" },
{ keyLightDark, "keyLightDark" },
{ keyLightDirection, "keyLightDirection" },
{ keyLightIntensity, "keyLightIntensity" },
{ keyLightPosition, "keyLightPosition" },
{ keyLightSource, "keyLightSource" },
{ keyLightType, "keyLightType" },
{ keyLightenGrout, "keyLightenGrout" },
{ keyLightness, "keyLightness" },
{ keyLine, "keyLine" },
{ keyLinkedLayerIDs, "keyLinkedLayerIDs" },
{ keyLocalLightingAngle, "keyLocalLightingAngle" },
{ keyLocalLightingAltitude, "keyLocalLightingAltitude" },
{ keyLocalRange, "keyLocalRange" },
{ keyLocation, "keyLocation" },
{ keyLog, "keyLog" },
{ keyLowerCase, "keyLowerCase" },
{ keyLuminance, "keyLuminance" },
{ keyLUTAnimation, "keyLUTAnimation" },
{ keyMagenta, "keyMagenta" },
{ keyMakeVisible, "keyMakeVisible" },
{ keyManipulationFOV, "keyManipulationFOV" },
{ keyMapBlack, "keyMapBlack" },
{ keyMapping, "keyMapping" },
{ keyMappingShape, "keyMappingShape" },
{ keyMaterial, "keyMaterial" },
{ keyMatrix, "keyMatrix" },
{ keyMatteColor, "keyMatteColor" },
{ keyMaximum, "keyMaximum" },
{ keyMaximumStates, "keyMaximumStates" },
{ keyMemoryUsagePercent, "keyMemoryUsagePercent" },
{ keyMerge, "keyMerge" },
{ keyMerged, "keyMerged" },
{ keyMessage, "keyMessage" },
{ keyMethod, "keyMethod" },
{ keyMezzotintType, "keyMezzotintType" },
{ keyMidpoint, "keyMidpoint" },
{ keyMidtoneLevels, "keyMidtoneLevels" },
{ keyMinimum, "keyMinimum" },
{ keyMismatchCMYK, "keyMismatchCMYK" },
{ keyMismatchGray, "keyMismatchGray" },
{ keyMismatchRGB, "keyMismatchRGB" },
{ keyMode, "keyMode" },
{ keyMonochromatic, "keyMonochromatic" },
{ keyMoveTo, "keyMoveTo" },
{ keyName, "keyName" },
{ keyNegative, "keyNegative" },
{ keyNew, "keyNew" },
{ keyNoise, "keyNoise" },
{ keyNonImageData, "keyNonImageData" },
{ keyNonLinear, "keyNonLinear" },
{ keyNull, "keyNull" },
{ keyNumLights, "keyNumLights" },
{ keyNumber, "keyNumber" },
{ keyNumberOfCacheLevels, "keyNumberOfCacheLevels" },
{ keyNumberOfChannels, "keyNumberOfChannels" },
{ keyNumberOfChildren, "keyNumberOfChildren" },
{ keyNumberOfDocuments, "keyNumberOfDocuments" },
{ keyNumberOfGenerators, "keyNumberOfGenerators" },
{ keyNumberOfLayers, "keyNumberOfLayers" },
{ keyNumberOfLevels, "keyNumberOfLevels" },
{ keyNumberOfPaths, "keyNumberOfPaths" },
{ keyNumberOfRipples, "keyNumberOfRipples" },
{ keyNumberOfSiblings, "keyNumberOfSiblings" },
{ keyObjectName, "keyObjectName" },
{ keyOffset, "keyOffset" },
{ keyOn, "keyOn" },
{ keyOpacity, "keyOpacity" },
{ keyOptimized, "keyOptimized" },
{ keyOrientation, "keyOrientation" },
{ keyOriginalHeader, "keyOriginalHeader" },
{ keyOriginalTransmissionReference, "keyOriginalTransmissionReference" },
{ keyOtherCursors, "keyOtherCursors" },
{ keyOuterGlow, "keyOuterGlow" },
{ keyOutput, "keyOutput" },
{ keyOverprintColors, "keyOverprintColors" },
{ keyOverrideOpen, "keyOverrideOpen" },
{ keyOverridePrinter, "keyOverridePrinter" },
{ keyOverrideSave, "keyOverrideSave" },
{ keyPaintCursorKind, "keyPaintCursorKind" },
{ keyParentIndex, "keyParentIndex" },
{ keyParentName, "keyParentName" },
{ keyPNGFilter, "keyPNGFilter" },
{ keyPNGInterlaceType, "keyPNGInterlaceType" },
{ keyPageFormat, "keyPageFormat" },
{ keyPageNumber, "keyPageNumber" },
{ keyPageSetup, "keyPageSetup" },
{ keyPagePosition, "keyPagePosition" },
{ keyPaintingCursors, "keyPaintingCursors" },
{ keyPaintType, "keyPaintType" },
{ keyPalette, "keyPalette" },
{ keyPaletteFile, "keyPaletteFile" },
{ keyPaperBrightness, "keyPaperBrightness" },
{ keyPath, "keyPath" },
{ keyPathContents, "keyPathContents" },
{ keyPathName, "keyPathName" },
{ keyPattern, "keyPattern" },
{ keyPencilWidth, "keyPencilWidth" },
{ keyPerspectiveIndex, "keyPerspectiveIndex" },
{ keyPhosphors, "keyPhosphors" },
{ keyPickerID, "keyPickerID" },
{ keyPickerKind, "keyPickerKind" },
{ keyPixelPaintSize, "keyPixelPaintSize" },
{ keyPlatform, "keyPlatform" },
{ keyPluginFolder, "keyPluginFolder" },
{ keyPluginPrefs, "keyPluginPrefs" },
{ keyPoints, "keyPoints" },
{ keyPosition, "keyPosition" },
{ keyPosterization, "keyPosterization" },
{ keyPostScriptColor, "keyPostScriptColor" },
{ keyPredefinedColors, "keyPredefinedColors" },
{ keyPreferBuiltin, "keyPreferBuiltin" },
{ keyPreserveAdditional, "keyPreserveAdditional" },
{ keyPreserveLuminosity, "keyPreserveLuminosity" },
{ keyPreserveTransparency, "keyPreserveTransparency" },
{ keyPressure, "keyPressure" },
{ keyPreferences, "keyPreferences" },
{ keyPreview, "keyPreview" },
{ keyPreviewCMYK, "keyPreviewCMYK" },
{ keyPreviewFullSize, "keyPreviewFullSize" },
{ keyPreviewIcon, "keyPreviewIcon" },
{ keyPreviewMacThumbnail, "keyPreviewMacThumbnail" },
{ keyPreviewWinThumbnail, "keyPreviewWinThumbnail" },
{ keyPreviewsQuery, "keyPreviewsQuery" },
{ keyPrintSettings, "keyPrintSettings" },
{ keyProfileSetup, "keyProfileSetup" },
{ keyProvinceState, "keyProvinceState" },
{ keyQuality, "keyQuality" },
{ keyExtendedQuality, "keyExtendedQuality" },
{ keyQuickMask, "keyQuickMask" },
{ keyRGBSetup, "keyRGBSetup" },
{ keyRadius, "keyRadius" },
{ keyRandomSeed, "keyRandomSeed" },
{ keyRatio, "keyRatio" },
{ keyRecentFiles, "keyRecentFiles" },
{ keyRed, "keyRed" },
{ keyRedBlackPoint, "keyRedBlackPoint" },
{ keyRedGamma, "keyRedGamma" },
{ keyRedWhitePoint, "keyRedWhitePoint" },
{ keyRedX, "keyRedX" },
{ keyRedY, "keyRedY" },
{ keyRegistrationMarks, "keyRegistrationMarks" },
{ keyRelative, "keyRelative" },
{ keyRelief, "keyRelief" },
{ keyRenderFidelity, "keyRenderFidelity" },
{ keyResample, "keyResample" },
{ keyResizeWindowsOnZoom, "keyResizeWindowsOnZoom" },
{ keyResolution, "keyResolution" },
{ keyResourceID, "keyResourceID" },
{ keyResponse, "keyResponse" },
{ keyRetainHeader, "keyRetainHeader" },
{ keyReverse, "keyReverse" },
{ keyRight, "keyRight" },
{ keyRippleMagnitude, "keyRippleMagnitude" },
{ keyRippleSize, "keyRippleSize" },
{ keyRotate, "keyRotate" },
{ keyRoundness, "keyRoundness" },
{ keyRulerOriginH, "keyRulerOriginH" },
{ keyRulerOriginV, "keyRulerOriginV" },
{ keyRulerUnits, "keyRulerUnits" },
{ keySaturation, "keySaturation" },
{ keySaveAndClose, "keySaveAndClose" },
{ keySaveComposite, "keySaveComposite" },
{ keySavePaletteLocations, "keySavePaletteLocations" },
{ keySavePaths, "keySavePaths" },
{ keySavePyramids, "keySavePyramids" },
{ keySaving, "keySaving" },
{ keyScale, "keyScale" },
{ keyScaleHorizontal, "keyScaleHorizontal" },
{ keyScaleVertical, "keyScaleVertical" },
{ keyScaling, "keyScaling" },
{ keyScans, "keyScans" },
{ keyScratchDisks, "keyScratchDisks" },
{ keyScreenFile, "keyScreenFile" },
{ keyScreenType, "keyScreenType" },
{ keyShadingIntensity, "keyShadingIntensity" },
{ keyShadingNoise, "keyShadingNoise" },
{ keyShadingShape, "keyShadingShape" },
{ keyContourType, "keyContourType" },
{ keySerialString, "keySerialString" },
{ keySeparations, "keySeparations" },
{ keyShadowColor, "keyShadowColor" },
{ keyShadowIntensity, "keyShadowIntensity" },
{ keyShadowLevels, "keyShadowLevels" },
{ keyShadowMode, "keyShadowMode" },
{ keyShadowOpacity, "keyShadowOpacity" },
{ keyShape, "keyShape" },
{ keySharpness, "keySharpness" },
{ keyShearEd, "keyShearEd" },
{ keyShearPoints, "keyShearPoints" },
{ keyShearSt, "keyShearSt" },
{ keyShiftKey, "keyShiftKey" },
{ keyShiftKeyToolSwitch, "keyShiftKeyToolSwitch" },
{ keyShortNames, "keyShortNames" },
{ keyShowEnglishFontNames, "keyShowEnglishFontNames" },
{ keyShowToolTips, "keyShowToolTips" },
{ keyShowTransparency, "keyShowTransparency" },
{ keySize, "keySize" },
{ keySkew, "keySkew" },
{ keySmartBlurMode, "keySmartBlurMode" },
{ keySmartBlurQuality, "keySmartBlurQuality" },
{ keySmooth, "keySmooth" },
{ keySmoothness, "keySmoothness" },
{ keySnapshotInitial, "keySnapshotInitial" },
{ keySoftness, "keySoftness" },
{ keySolidFill, "keySolidFill" },
{ keySource, "keySource" },
{ keySource2, "keySource2" },
{ keySourceMode, "keySourceMode" },
{ keySpacing, "keySpacing" },
{ keySpecialInstructions, "keySpecialInstructions" },
{ keySpherizeMode, "keySpherizeMode" },
{ keySpot, "keySpot" },
{ keySprayRadius, "keySprayRadius" },
{ keySquareSize, "keySquareSize" },
{ keySrcBlackMax, "keySrcBlackMax" },
{ keySrcBlackMin, "keySrcBlackMin" },
{ keySrcWhiteMax, "keySrcWhiteMax" },
{ keySrcWhiteMin, "keySrcWhiteMin" },
{ keyStart, "keyStart" },
{ keyStartArrowhead, "keyStartArrowhead" },
{ keyState, "keyState" },
{ keyStrength, "keyStrength" },
{ keyStrengthRatio, "keyStrengthRatio" },
{ keyStrength_PLUGIN, "keyStrength_PLUGIN" },
{ keyStrokeDetail, "keyStrokeDetail" },
{ keyStrokeDirection, "keyStrokeDirection" },
{ keyStrokeLength, "keyStrokeLength" },
{ keyStrokePressure, "keyStrokePressure" },
{ keyStrokeSize, "keyStrokeSize" },
{ keyStrokeWidth, "keyStrokeWidth" },
{ keyStyle, "keyStyle" },
{ keyStyles, "keyStyles" },
{ keyStylusIsPressure, "keyStylusIsPressure" },
{ keyStylusIsColor, "keyStylusIsColor" },
{ keyStylusIsOpacity, "keyStylusIsOpacity" },
{ keyStylusIsSize, "keyStylusIsSize" },
{ keySubPathList, "keySubPathList" },
{ keySupplementalCategories, "keySupplementalCategories" },
{ keySystemInfo, "keySystemInfo" },
{ keySystemPalette, "keySystemPalette" },
{ keyTarget, "keyTarget" },
{ keyTargetPath, "keyTargetPath" },
{ keyTargetPathIndex, "keyTargetPathIndex" },
{ keyText, "keyText" },
{ keyTextClickPoint, "keyTextClickPoint" },
{ keyTextData, "keyTextData" },
{ keyTextStyle, "keyTextStyle" },
{ keyTextStyleRange, "keyTextStyleRange" },
{ keyTexture, "keyTexture" },
{ keyTextureCoverage, "keyTextureCoverage" },
{ keyTextureFile, "keyTextureFile" },
{ keyTextureType, "keyTextureType" },
{ keyThreshold, "keyThreshold" },
{ keyTileNumber, "keyTileNumber" },
{ keyTileOffset, "keyTileOffset" },
{ keyTileSize, "keyTileSize" },
{ keyTitle, "keyTitle" },
{ keyTo, "keyTo" },
{ keyToBuiltin, "keyToBuiltin" },
{ keyToLinked, "keyToLinked" },
{ keyToMode, "keyToMode" },
{ keyToggleOthers, "keyToggleOthers" },
{ keyTolerance, "keyTolerance" },
{ keyTop, "keyTop" },
{ keyTotalLimit, "keyTotalLimit" },
{ keyTracking, "keyTracking" },
{ keyTransferSpec, "keyTransferSpec" },
{ keyTransparencyGrid, "keyTransparencyGrid" },
{ keyTransferFunction, "keyTransferFunction" },
{ keyTransparency, "keyTransparency" },
{ keyTransparencyGridColors, "keyTransparencyGridColors" },
{ keyTransparencyGridSize, "keyTransparencyGridSize" },
{ keyTransparencyPrefs, "keyTransparencyPrefs" },
{ keyTransparencyShape, "keyTransparencyShape" },
{ keyTransparentIndex, "keyTransparentIndex" },
{ keyTransparentWhites, "keyTransparentWhites" },
{ keyTwist, "keyTwist" },
{ keyType, "keyType" },
{ keyUCA, "keyUCA" },
{ keyUnitsPrefs, "keyUnitsPrefs" },
{ keyURL, "keyURL" },
{ keyUndefinedArea, "keyUndefinedArea" },
{ keyUnderline, "keyUnderline" },
{ keyUntitled, "keyUntitled" },
{ keyUpperY, "keyUpperY" },
{ keyUrgency, "keyUrgency" },
{ keyUseAccurateScreens, "keyUseAccurateScreens" },
{ keyUseAdditionalPlugins, "keyUseAdditionalPlugins" },
{ keyUseCacheForHistograms, "keyUseCacheForHistograms" },
{ keyUseCurves, "keyUseCurves" },
{ keyUseDefault, "keyUseDefault" },
{ keyUseGlobalAngle, "keyUseGlobalAngle" },
{ keyUseICCProfile, "keyUseICCProfile" },
{ keyUseMask, "keyUseMask" },
{ keyUserMaskEnabled, "keyUserMaskEnabled" },
{ keyUserMaskLinked, "keyUserMaskLinked" },
{ keyUsing, "keyUsing" },
{ keyValue, "keyValue" },
{ keyVector0, "keyVector0" },
{ keyVector1, "keyVector1" },
{ keyVectorColor, "keyVectorColor" },
{ keyVersionFix, "keyVersionFix" },
{ keyVersionMajor, "keyVersionMajor" },
{ keyVersionMinor, "keyVersionMinor" },
{ keyVertical, "keyVertical" },
{ keyVerticalScale, "keyVerticalScale" },
{ keyVideoAlpha, "keyVideoAlpha" },
{ keyVisible, "keyVisible" },
{ keyWatchSuspension, "keyWatchSuspension" },
{ keyWatermark, "keyWatermark" },
{ keyWaveType, "keyWaveType" },
{ keyWavelengthMax, "keyWavelengthMax" },
{ keyWavelengthMin, "keyWavelengthMin" },
{ keyWetEdges, "keyWetEdges" },
{ keyWhat, "keyWhat" },
{ keyWhiteClip, "keyWhiteClip" },
{ keyWhiteIntensity, "keyWhiteIntensity" },
{ keyWhiteIsHigh, "keyWhiteIsHigh" },
{ keyWhiteLevel, "keyWhiteLevel" },
{ keyWhitePoint, "keyWhitePoint" },
{ keyWholePath, "keyWholePath" },
{ keyWidth, "keyWidth" },
{ keyWindMethod, "keyWindMethod" },
{ keyWith, "keyWith" },
{ keyWorkPath, "keyWorkPath" },
{ keyWorkPathIndex, "keyWorkPathIndex" },
{ keyX, "keyX" },
{ keyY, "keyY" },
{ keyYellow, "keyYellow" },
{ keyZigZagType, "keyZigZagType" },
{ key_Source, "key_Source" },
{ pInherits, "pInherits" },
{ typeActionReference, "typeActionReference" },
{ typeActionData, "typeActionData" },
{ typeAlignDistributeSelector, "typeAlignDistributeSelector" },
{ typeAlignment, "typeAlignment" },
{ typeAmount, "typeAmount" },
{ typeAntiAlias, "typeAntiAlias" },
{ typeAreaSelector, "typeAreaSelector" },
{ typeAssumeOptions, "typeAssumeOptions" },
{ typeBevelEmbossStampStyle, "typeBevelEmbossStampStyle" },
{ typeBevelEmbossStyle, "typeBevelEmbossStyle" },
{ typeBitDepth, "typeBitDepth" },
{ typeBlackGeneration, "typeBlackGeneration" },
{ typeBlendMode, "typeBlendMode" },
{ typeBlurMethod, "typeBlurMethod" },
{ typeBlurQuality, "typeBlurQuality" },
{ typeBrushType, "typeBrushType" },
{ typeBuiltinProfile, "typeBuiltinProfile" },
{ typeBuiltInContour, "typeBuiltInContour" },
{ typeCMYKSetupEngine, "typeCMYKSetupEngine" },
{ typeCalculation, "typeCalculation" },
{ typeChannel, "typeChannel" },
{ typeChannelReference, "typeChannelReference" },
{ typeCheckerboardSize, "typeCheckerboardSize" },
{ typeClass, "typeClass" },
{ typeClassColor, "typeClassColor" },
{ typeClassElement, "typeClassElement" },
{ typeClassExport, "typeClassExport" },
{ typeClassFormat, "typeClassFormat" },
{ typeClassHueSatHueSatV2, "typeClassHueSatHueSatV2" },
{ typeClassImport, "typeClassImport" },
{ typeClassMode, "typeClassMode" },
{ typeClassStringFormat, "typeClassStringFormat" },
{ typeClassTextExport, "typeClassTextExport" },
{ typeClassTextImport, "typeClassTextImport" },
{ typeColor, "typeColor" },
{ typeColorChannel, "typeColorChannel" },
{ typeColorPalette, "typeColorPalette" },
{ typeColorSpace, "typeColorSpace" },
{ typeColorStopType, "typeColorStopType" },
{ typeColors, "typeColors" },
{ typeCompensation, "typeCompensation" },
{ typeContourEdge, "typeContourEdge" },
{ typeConvert, "typeConvert" },
{ typeCorrectionMethod, "typeCorrectionMethod" },
{ typeCursorKind, "typeCursorKind" },
{ typeDCS, "typeDCS" },
{ typeDeepDepth, "typeDeepDepth" },
{ typeDepth, "typeDepth" },
{ typeDiffuseMode, "typeDiffuseMode" },
{ typeDirection, "typeDirection" },
{ typeDisplacementMap, "typeDisplacementMap" },
{ typeDistribution, "typeDistribution" },
{ typeDither, "typeDither" },
{ typeDitherQuality, "typeDitherQuality" },
{ typeDocumentReference, "typeDocumentReference" },
{ typeEPSPreview, "typeEPSPreview" },
{ typeElementReference, "typeElementReference" },
{ typeEncoding, "typeEncoding" },
{ typeEraserKind, "typeEraserKind" },
{ typeExtrudeRandom, "typeExtrudeRandom" },
{ typeExtrudeType, "typeExtrudeType" },
{ typeEyeDropperSample, "typeEyeDropperSample" },
{ typeFPXCompress, "typeFPXCompress" },
{ typeFill, "typeFill" },
{ typeFillColor, "typeFillColor" },
{ typeFillContents, "typeFillContents" },
{ typeFillMode, "typeFillMode" },
{ typeForcedColors, "typeForcedColors" },
{ typeFrameFill, "typeFrameFill" },
{ typeFrameStyle, "typeFrameStyle" },
{ typeGIFColorFileType, "typeGIFColorFileType" },
{ typeGIFPaletteType, "typeGIFPaletteType" },
{ typeGIFRequiredColorSpaceType, "typeGIFRequiredColorSpaceType" },
{ typeGIFRowOrderType, "typeGIFRowOrderType" },
{ typeGlobalClass, "typeGlobalClass" },
{ typeGlobalObject, "typeGlobalObject" },
{ typeGradientType, "typeGradientType" },
{ typeGradientForm, "typeGradientForm" },
{ typeGrainType, "typeGrainType" },
{ typeGrayBehavior, "typeGrayBehavior" },
{ typeGuideGridColor, "typeGuideGridColor" },
{ typeGuideGridStyle, "typeGuideGridStyle" },
{ typeHistoryStateSource, "typeHistoryStateSource" },
{ typeHorizontalLocation, "typeHorizontalLocation" },
{ typeImageReference, "typeImageReference" },
{ typeInnerGlowSource, "typeInnerGlowSource" },
{ typeIntegerChannel, "typeIntegerChannel" },
{ typeIntent, "typeIntent" },
{ typeInterlaceCreateType, "typeInterlaceCreateType" },
{ typeInterlaceEliminateType, "typeInterlaceEliminateType" },
{ typeInterpolation, "typeInterpolation" },
{ typeKelvin, "typeKelvin" },
{ typeKelvinCustomWhitePoint, "typeKelvinCustomWhitePoint" },
{ typeLens, "typeLens" },
{ typeLightDirection, "typeLightDirection" },
{ typeLightPosition, "typeLightPosition" },
{ typeLightType, "typeLightType" },
{ typeLocationReference, "typeLocationReference" },
{ typeMaskIndicator, "typeMaskIndicator" },
{ typeMatteColor, "typeMatteColor" },
{ typeMatteTechnique, "typeMatteTechnique" },
{ typeMenuItem, "typeMenuItem" },
{ typeMethod, "typeMethod" },
{ typeMezzotintType, "typeMezzotintType" },
{ typeMode, "typeMode" },
{ typeNotify, "typeNotify" },
{ typeObject, "typeObject" },
{ typeObjectReference, "typeObjectReference" },
{ typeOnOff, "typeOnOff" },
{ typeOrdinal, "typeOrdinal" },
{ typeOrientation, "typeOrientation" },
{ typePNGFilter, "typePNGFilter" },
{ typePNGInterlaceType, "typePNGInterlaceType" },
{ typePagePosition, "typePagePosition" },
{ typePathKind, "typePathKind" },
{ typePathReference, "typePathReference" },
{ typePhosphors, "typePhosphors" },
{ typePhosphorsCustomPhosphors, "typePhosphorsCustomPhosphors" },
{ typePickerKind, "typePickerKind" },
{ typePixelPaintSize, "typePixelPaintSize" },
{ typePlatform, "typePlatform" },
{ typePreview, "typePreview" },
{ typePreviewCMYK, "typePreviewCMYK" },
{ typeProfileMismatch, "typeProfileMismatch" },
{ typePurgeItem, "typePurgeItem" },
{ typeQuadCenterState, "typeQuadCenterState" },
{ typeQuality, "typeQuality" },
{ typeQueryState, "typeQueryState" },
{ typeRGBSetupSource, "typeRGBSetupSource" },
{ typeRawData, "typeRawData" },
{ typeRippleSize, "typeRippleSize" },
{ typeRulerUnits, "typeRulerUnits" },
{ typeScreenType, "typeScreenType" },
{ typeShape, "typeShape" },
{ typeSmartBlurMode, "typeSmartBlurMode" },
{ typeSmartBlurQuality, "typeSmartBlurQuality" },
{ typeSourceMode, "typeSourceMode" },
{ typeSpherizeMode, "typeSpherizeMode" },
{ typeState, "typeState" },
{ typeStringClassFormat, "typeStringClassFormat" },
{ typeStringChannel, "typeStringChannel" },
{ typeStringCompensation, "typeStringCompensation" },
{ typeStringFSS, "typeStringFSS" },
{ typeStringInteger, "typeStringInteger" },
{ typeStrokeDirection, "typeStrokeDirection" },
{ typeStrokeLocation, "typeStrokeLocation" },
{ typeText, "typeText" },
{ typeTextureType, "typeTextureType" },
{ typeTransparencyGridColors, "typeTransparencyGridColors" },
{ typeTransparencyGridSize, "typeTransparencyGridSize" },
{ typeTypeClassModeOrClassMode, "typeTypeClassModeOrClassMode" },
{ typeUndefinedArea, "typeUndefinedArea" },
{ typeUnitFloat, "typeUnitFloat" },
{ typeUrgency, "typeUrgency" },
{ typeUserMaskOptions, "typeUserMaskOptions" },
{ typeValueList, "typeValueList" },
{ typeVerticalLocation, "typeVerticalLocation" },
{ typeWaveType, "typeWaveType" },
{ typeWindMethod, "typeWindMethod" },
{ typeYesNo, "typeYesNo" },
{ typeZigZagType, "typeZigZagType" },
{ unitAngle, "unitAngle" },
{ unitDensity, "unitDensity" },
{ unitDistance, "unitDistance" },
{ unitNone, "unitNone" },
{ unitPercent, "unitPercent" },
{ unitPixels, "unitPixels" } };



//-------------------------------------------------------------------------------
//
//	CalcMaxHashStringSize
//
//	Utility for the biggest string in the above array. 
//
//-------------------------------------------------------------------------------
static void CalcMaxHashStringSize(void)
{
	static const int32 ArraySize = sizeof(PSConstA) / sizeof(PSConstantArray);
	static doneThis = false;
	if (!doneThis)
	{
		doneThis = true;
	    for (int32 counter = 0; counter < ArraySize; counter++)
	    {
	    	int32 length = strlen(PSConstA[counter].strStr);
	    	length++; // for the termination
	    	if ( length > maxHashStringSize)
	    	{
	    		maxHashStringSize = length;
	    	}
	    }
	 }
}



//-------------------------------------------------------------------------------
//
//	LongToStr
//
//	Utility that uses the above structure to convert the int32 value from the
//	descriptors, lists, and references to output the string name. If it can't
//	find the constant then it outputs the 'Hash' code.
//-------------------------------------------------------------------------------
static void LongToStr(int32 inputLong, char* inputKeyType, char* returnString)
{
	// don't want to recalculate this all the time
	static const int32 ArraySize = sizeof(PSConstA) / sizeof(PSConstantArray);
	bool found = false;

	// blank it out
    *returnString = '\0';
    
    // if the input long is a small number then it's a runtime ID
    // use the control procs to get the string
    if (inputLong < SmallestHashValue)
    {
    	if (!(sPSActionControl->TypeIDToStringID(inputLong, 
    	                                   returnString,
    	                                   maxHashStringSize)))
    	{
    		found = true;
    	}
    }

	// loop through all the above constants looking for the one that matches
	// in an ideal world you wouldn't need the inputKeyType but there are constants
	// that break the hash code creation world so we want to make sure if you are
	// asking for a key you will get a key and not a class or something else
	if (!found)
	{
	    for (int32 counter = 0; counter < ArraySize; counter++)
    	    if (PSConstA[counter].longVal == inputLong)
				if (strstr(PSConstA[counter].strStr, inputKeyType))
				{
					short strLen = strlen(PSConstA[counter].strStr);
					strcpy(returnString, PSConstA[counter].strStr);
					returnString[strLen] = '\0'; // terminate this string
					counter = ArraySize;// and stop the for loop
					found = true;
				}
	}

	// didn't find a match so convert the number to its 'Hash' code
    if (*returnString == '\0' || !found)
	{
		*returnString++ = '\'';
		PIUIDToChar(inputLong,returnString);
		returnString[4] = '\'';
		returnString[5] = '\0';
	}
}



//-------------------------------------------------------------------------------
//
//	StrToLong
//
//	Utility that uses the above structure to convert the string value from the
//	descriptors, lists, and references to output the long value.
//-------------------------------------------------------------------------------
static unsigned long StrToLong(const char* inputStr)
{
	// don't want to recalculate this all the time
	static const int32 ArraySize = sizeof(PSConstA) / sizeof(PSConstantArray);

	unsigned long returnLong = 0;
	if (inputStr)
		for(int32 counter = 0; counter < ArraySize; counter++)
			if (strcmp(inputStr, PSConstA[counter].strStr) == 0)
			{
				returnLong = PSConstA[counter].longVal;
				break;
			}
	return (returnLong);
}



//-------------------------------------------------------------------------------
//
//	FreeZone::FreeZone
//
//	Constructor for the FreeZone. Doesn't do anything.
//
//-------------------------------------------------------------------------------
FreeZone::FreeZone() {}



//-------------------------------------------------------------------------------
//
//	FreeZone::~FreeZone
//
//	Destructor for the FreeZone class. Deletes all the char []'s in the vector.
//
//-------------------------------------------------------------------------------
FreeZone::~FreeZone()
{
	vector<char*>::iterator array_iter = v_array.begin();
	vector<char*>::iterator array_end = v_array.end();
	while(array_iter != array_end)
	{
		delete [] *array_iter;
		array_iter++;
	}
}



//-------------------------------------------------------------------------------
//
//	FreeZone::Add
//
//	Add a reference to the vector using the generic routine.
//
//-------------------------------------------------------------------------------
void FreeZone::Add(PIActionReference reference)
{
	Add("ref", (long)reference);
}



//-------------------------------------------------------------------------------
//
//	FreeZone::Add
//
//	Add a list to the vector using the generic routine.
//
//-------------------------------------------------------------------------------
void FreeZone::Add(PIActionList list)
{
	Add("list", (long)list);
}



//-------------------------------------------------------------------------------
//
//	FreeZone::Add
//
//	Add a descriptor to the vector using the generic routine.
//
//-------------------------------------------------------------------------------
void FreeZone::Add(PIActionDescriptor descriptor)
{
	Add("desc", (long)descriptor);
}



//-------------------------------------------------------------------------------
//
//	FreeZone::Add
//
//	Add a handle to the vector using a special routine.
//
//-------------------------------------------------------------------------------
void FreeZone::Add(Handle /*aliasValue*/)
{
	char* ptr = new char[strlen("aliasValue")];
	if (ptr == NULL) return;
	strcpy(ptr, "aliasValue");
	v_array.push_back(ptr);
}



//-------------------------------------------------------------------------------
//
//	FreeZone::Add
//
//	The generic add.
//
//-------------------------------------------------------------------------------
void FreeZone::Add(char* text, long value)
{
	char* ptr = new char[20];
	if (ptr == NULL) return;
	sprintf(ptr, "%s%p", text, value);
	v_array.push_back(ptr);
}



//-------------------------------------------------------------------------------
//
//	FreeZone::Output
//
//	Dump the vector to the stream.
//
//-------------------------------------------------------------------------------
void FreeZone::Output(ofstream& fileOut)
{
	vector<char*>::iterator array_iter = v_array.begin();
	vector<char*>::iterator array_end = v_array.end();
	while(array_iter != array_end)
	{
		char freeType = (*array_iter)[0];
		switch (freeType)
		{
			case 'r':
				TabOver(fileOut);
				fileOut << "if (" 
					   << *array_iter 
						<< " != NULL) sPSActionReference->Free(" 
						<< *array_iter << ");" 
						<< endl;
				break;
			case 'l':
				TabOver(fileOut);
				fileOut << "if (" 
					    << *array_iter 
						<< " != NULL) sPSActionList->Free(" 
						<< *array_iter << ");" 
						<< endl;
				break;
			case 'd':
				TabOver(fileOut);
				fileOut << "if (" 
					    << *array_iter 
						<< " != NULL) sPSActionDescriptor->Free(" 
						<< *array_iter << ");" 
						<< endl;
				break;
			case 'a':
				TabOver(fileOut);
				fileOut << "if (" 
					    << *array_iter 
						<< " != NULL) sPSHandle->Dispose(" 
						<< *array_iter << ");" 
						<< endl;
				break;
		}
		array_iter++;
	}
}

#endif // _DEBUG

// here all all the known dupes 11/4/98, I don't know of a good (easy) way to figure these out
// so if you see a constant that doesn't look like it belongs then check here and figure out
// what it should be.
//enumBlacks                   enumBlocks
//enumFileInfo                 enumFillInverse
//enumLightOmni                enumLightenOnly
//enumMagenta                  enumMagentas
//keyBlackLevel                keyBlackLimit
//keyCenter                    keyContrast
//keyConstant                  keyConstrain
//keyDistortion                keyDistribution
//keyGrain                     keyGreen
//keyInterfaceIconFrameDimmed  keyInterlace
//keyInterfaceIconFrameDimmed  keyInterpolation
//keyInterlace                 keyInterpolation
//keyNumberOfLayers            keyNumberOfLevels
//keySaturation                keyStart
//keyTextClickPoint            keyTextureCoverage

// end PIUActionUtils.cpp
