📄 pflprefs.c

📁 PGP8.0源码请认真阅读您的文件包然后写出其具体功能
💻 C
📖 第 1 页 / 共 5 页
字号:
				if (IsNull(newPrefData->data.a->templateStruct))
				{
					err = kPGPError_OutOfMemory;
					break;
				}
			
				err = sCopyStructDataToPref(*prefRef, TRUE,
						prefArray->templateStruct,
						newPrefData->data.a->templateStruct);
			
				if (IsPGPError(err))
					break;
			}
			
			for (arrayIndex=0; arrayIndex<prefArray->numElements; arrayIndex++)
			{
				copyElement = &(prefArray->elements[arrayIndex]);
				newElement = &(newPrefData->data.a->elements[arrayIndex]);

				newElement->size = copyElement->size;

				switch (prefArray->type)
				{
				case kPGPPrefType_Boolean:
				case kPGPPrefType_Number:
					newElement->data = copyElement->data; 
					break;

				case kPGPPrefType_String:
					if (IsntNull(copyElement->data))
						newElement->size = strlen(copyElement->data) + 1;
					else
						newElement->size = 0;

				case kPGPPrefType_Byte:
					if (IsntNull(copyElement->data))
					{
						newElement->data = PGPNewData(memoryMgr,
												newElement->size,
												kPGPMemoryMgrFlags_Clear);
					
						if (IsNull(newElement->data))
						{
							err = kPGPError_OutOfMemory;
							break;
						}

						pgpCopyMemory(copyElement->data, newElement->data,
							newElement->size);
					}
					else
						newElement->data = NULL; 
					
					break;

				case kPGPPrefType_Struct:
					newElement->size = sizeof(PGPPrefStruct);
					newElement->data = PGPNewData(memoryMgr,
											sizeof(PGPPrefStruct),
											kPGPMemoryMgrFlags_Clear);
					
					if (IsNull(newElement->data))
					{
						err = kPGPError_OutOfMemory;
						break;
					}

					err = sCopyStructDataToPref(*prefRef, TRUE,
							(PGPPrefStruct *) copyElement->data,
							(PGPPrefStruct *) newElement->data);
					break;
					
				default:
					break;
				}
			}
			break;
					
		default:
			break;
		}
	
		if (IsntPGPError(err))
			sAddPrefData(*prefRef, newPrefData);
		else
		{
			sFreePrefData(newPrefData, TRUE);
			PGPFreeData(newPrefData);
			break;
		}
	}

	if (IsntNull(*prefRef))
		(*prefRef)->dirty = FALSE;

	return err;
}


PGPError PGPAddPrefs(PGPPrefRef prefsToAdd, PGPPrefRef prefRef)
{
	PGPPrefData *addData = NULL;
	PGPError err = kPGPError_NoErr;

	PGPValidatePref(prefsToAdd);
	PGPValidatePref(prefRef);

	addData = prefsToAdd->prefList;
	while (IsntNull(addData) && IsntPGPError(err))
	{
		switch (addData->prefType)
		{
		case kPGPPrefType_Boolean:
			err = PGPSetPrefData(prefRef, addData->prefIndex, 
					addData->dataLength, &(addData->data.b));
			break;

		case kPGPPrefType_Number:
			err = PGPSetPrefData(prefRef, addData->prefIndex, 
					addData->dataLength, &(addData->data.i));
			break;

		case kPGPPrefType_String:
			err = PGPSetPrefData(prefRef, addData->prefIndex, 
					addData->dataLength, addData->data.str);
			break;

		case kPGPPrefType_Byte:
			err = PGPSetPrefData(prefRef, addData->prefIndex, 
					addData->dataLength, addData->data.p);
			break;

		case kPGPPrefType_Struct:
			err = PGPSetPrefData(prefRef, addData->prefIndex, 
					addData->dataLength, addData->data.strct);
			break;

		case kPGPPrefType_Array:
			err = PGPSetPrefData(prefRef, addData->prefIndex, 
					addData->dataLength, addData->data.a);
			break;

		default:
			break;
		}

		if (IsntPGPError(err))
			err = sCopyPrefFlags(prefRef, addData->prefIndex, 
					addData->flags);

		if (err == kPGPError_PrefNotFound)
			err = kPGPError_NoErr;

		if (IsntPGPError(err))
			err = sGetNextPrefData(addData, &addData);
	}

	return err;
}


PGPError PGPFreePrefs(PGPPrefRef prefRef)
{
	PGPValidatePref(prefRef);

	sFreePref(prefRef);
	return kPGPError_NoErr;
}


PGPError PGPPeekPrefMemoryMgr(PGPPrefRef prefRef,
								PGPMemoryMgrRef *memoryMgr)
{
	if (IsntNull(memoryMgr))
		*memoryMgr = NULL;

	PGPValidatePref(prefRef);
	PGPValidatePtr(memoryMgr);

	*memoryMgr = prefRef->memoryMgr;
	return kPGPError_NoErr;
}

 
PGPError PGPGetPrefData(PGPPrefRef prefRef, 
							PGPPrefIndex prefIndex, 
							PGPSize *dataLength, 
							void **inBuffer)
{
	PGPPrefData *			currentPrefData;
	PGPPrefArray *			prefArray;
	PGPPrefArrayElement *	copyElement;
	PGPPrefArrayElement *	newElement;
	PGPUInt32				index;
	PGPError				err;

	if (IsntNull(dataLength))
		*dataLength = 0;
	if (IsntNull(inBuffer))
		*inBuffer = NULL;

	PGPValidatePtr(inBuffer);
	PGPValidatePtr(dataLength);
	PGPValidatePref(prefRef);

	err = sFindPrefDataByIndex(prefRef, prefIndex, &currentPrefData);
	pgpAssertNoErr(err);
	if (IsPGPError(err))
		return err;

	if (IsNull(currentPrefData))
		return kPGPError_PrefNotFound;

	if (currentPrefData->dataLength > 0)
	{
		*inBuffer	= PGPNewData(prefRef->memoryMgr,
						currentPrefData->dataLength,
						kPGPMemoryMgrFlags_Clear);

		if (IsNull(*inBuffer))
			return kPGPError_OutOfMemory;
		else
			*dataLength	= currentPrefData->dataLength;
	}
	else
		return kPGPError_PrefNotFound;

	switch (currentPrefData->prefType)
	{
	case kPGPPrefType_Boolean:
		pgpCopyMemory(&(currentPrefData->data.b), *inBuffer, 
			sizeof(PGPBoolean));
		break;

	case kPGPPrefType_Number:
		pgpCopyMemory(&(currentPrefData->data.i), *inBuffer, 
			sizeof(PGPUInt32));
		break;

	case kPGPPrefType_String:
		if (IsntNull(currentPrefData->data.str))
			pgpCopyMemory(currentPrefData->data.str, *inBuffer, 
				currentPrefData->dataLength);
		break;

	case kPGPPrefType_Byte:
		if (IsntNull(currentPrefData->data.p))
			pgpCopyMemory(currentPrefData->data.p, *inBuffer, 
				currentPrefData->dataLength);
		break;

	case kPGPPrefType_Struct:
		if (IsntNull(currentPrefData->data.strct))
			err = sCopyStructDataToPref(prefRef, TRUE, 
					currentPrefData->data.strct, (PGPPrefStruct *) *inBuffer);
		break;

	case kPGPPrefType_Array:
		if (IsNull(currentPrefData->data.a))
			break;

		prefArray = (PGPPrefArray *) *inBuffer;
		prefArray->numElements = currentPrefData->data.a->numElements;
		prefArray->type = currentPrefData->data.a->type;

		if (prefArray->numElements > 0)
		{
			prefArray->elements = (PGPPrefArrayElement *) 
										PGPNewData(prefRef->memoryMgr,
											sizeof(PGPPrefArrayElement) *
											prefArray->numElements,
											kPGPMemoryMgrFlags_Clear);

			if (IsNull(prefArray->elements))
			{
				err = kPGPError_OutOfMemory;
				PGPFreeData(*inBuffer);
				*inBuffer = NULL;
				break;
			}
		}

		if (prefArray->type == kPGPPrefType_Struct)
		{
			prefArray->templateStruct = (PGPPrefStruct *) 
										PGPNewData(prefRef->memoryMgr,
											sizeof(PGPPrefStruct),
											kPGPMemoryMgrFlags_Clear);

			if (IsNull(prefArray->templateStruct))
			{
				err = kPGPError_OutOfMemory;

				if (IsntNull(prefArray->elements))
					PGPFreeData(prefArray->elements);

				PGPFreeData(*inBuffer);
				*inBuffer = NULL;
				break;
			}

			err = sCopyStructDataToPref(prefRef, TRUE,
					currentPrefData->data.a->templateStruct,
					prefArray->templateStruct);

			if (IsPGPError(err))
			{
				PGPFreeData(prefArray->templateStruct);

				if (IsntNull(prefArray->elements))
					PGPFreeData(prefArray->elements);

				PGPFreeData(*inBuffer);
				*inBuffer = NULL;
				break;
			}
		}

		for (index=0; index<currentPrefData->data.a->numElements; index++)
		{
			copyElement = &(currentPrefData->data.a->elements[index]);
			newElement = &(prefArray->elements[index]);

			newElement->size = copyElement->size;

			switch (prefArray->type)
			{
			case kPGPPrefType_Boolean:
			case kPGPPrefType_Number:
				newElement->data = copyElement->data; 
				break;
				
			case kPGPPrefType_String:
				if (IsntNull(copyElement->data))
					newElement->size = strlen(copyElement->data) + 1;
				else
					newElement->size = 0;
				
			case kPGPPrefType_Byte:
				if (IsntNull(copyElement->data))
				{
					newElement->data = PGPNewData(prefRef->memoryMgr,
											newElement->size,
											kPGPMemoryMgrFlags_Clear);
					
					if (IsNull(newElement->data))
					{
						err = kPGPError_OutOfMemory;
						break;
					}
					
					pgpCopyMemory(copyElement->data, newElement->data,
						newElement->size);
				}
				else
					newElement->data = NULL; 
				
				break;
				
			case kPGPPrefType_Struct:
				newElement->size = sizeof(PGPPrefStruct);
				newElement->data = PGPNewData(prefRef->memoryMgr,
									sizeof(PGPPrefStruct),
									kPGPMemoryMgrFlags_Clear);
				
				if (IsNull(newElement->data))
				{
					err = kPGPError_OutOfMemory;
					break;
				}
				
				err = sCopyStructDataToPref(prefRef, TRUE,
						(PGPPrefStruct *) copyElement->data,
						(PGPPrefStruct *) newElement->data);
				break;

			default:
				break;
			}
		}
		break;

	default:
		break;
	}

	return err;
}


PGPError PGPSetPrefData(PGPPrefRef prefRef, 
							PGPPrefIndex prefIndex, 
							PGPSize dataLength, 
							const void *outBuffer)
{
	PGPPrefData *			currentPrefData;
	PGPPrefArray *			prefArray;
	PGPPrefArrayElement *	copyElement;
	PGPPrefArrayElement *	newElement;
	PGPUInt32				index;
	PGPError				err;
	
	PGPValidatePref(prefRef);

	err = sFindPrefDataByIndex(prefRef, prefIndex, &currentPrefData);
	pgpAssertNoErr(err);
	if (IsPGPError(err))
		return err;

	if (IsNull(currentPrefData))
		return kPGPError_PrefNotFound;

	if (currentPrefData->prefType != kPGPPrefType_Byte)
	{
		PGPValidatePtr(outBuffer);
		PGPValidateParam(dataLength > 0);
	}

	switch (currentPrefData->prefType)
	{
	case kPGPPrefType_Boolean:
		if (!prefRef->dirty)
		{
			if (!pgpMemoryEqual(outBuffer, &(currentPrefData->data.b), 
				dataLength))
				prefRef->dirty = TRUE;
		}

		if (prefRef->dirty)
			pgpCopyMemory(outBuffer, &(currentPrefData->data.b), dataLength);
		break;

	case kPGPPrefType_Number:
		if (!prefRef->dirty)
		{
			if (!pgpMemoryEqual(outBuffer, &(currentPrefData->data.i), 
				dataLength))
				prefRef->dirty = TRUE;
		}

		if (prefRef->dirty)
			pgpCopyMemory(outBuffer, &(currentPrefData->data.i), dataLength);
		break;

	case kPGPPrefType_String:
		if (currentPrefData->dataLength != dataLength)
			prefRef->dirty = TRUE;

		if (IsntNull(currentPrefData->data.str))
		{
			if (!prefRef->dirty)
			{
				if (!pgpMemoryEqual(outBuffer, currentPrefData->data.str,
					dataLength))
					prefRef->dirty = TRUE;
			}
		}

		if (prefRef->dirty)
		{
			if (IsntNull(currentPrefData->data.str))
				PGPFreeData(currentPrefData->data.str);
		
			currentPrefData->data.str = PGPNewData(prefRef->memoryMgr,
											dataLength,
											kPGPMemoryMgrFlags_Clear);
			
			if (IsNull(currentPrefData->data.str))
			{
				sRemovePrefData(prefRef, currentPrefData);
				return kPGPError_OutOfMemory;
			}
			
			pgpCopyMemory(outBuffer, currentPrefData->data.str, dataLength);
			sStripQuotes(dataLength, currentPrefData->data.str);
			dataLength = strlen(currentPrefData->data.str) + 1;
		}
		break;

	case kPGPPrefType_Byte:
		if (currentPrefData->dataLength != dataLength)
			prefRef->dirty = TRUE;

		if (IsntNull(currentPrefData->data.p) && IsntNull(outBuffer) &&
			!prefRef->dirty)
		{
			if (!pgpMemoryEqual(outBuffer, currentPrefData->data.p, dataLength))
				prefRef->dirty = TRUE;
		}

		if (prefRef->dirty)
		{
			if (IsntNull(currentPrefData->data.p))
			{
				PGPFreeData(currentPrefData->data.p);
				currentPrefData->data.p = NULL;
			}
			
			if (IsntNull(outBuffer))
			{
				currentPrefData->data.p = PGPNewData(prefRef->memoryMgr,
											dataLength,
											kPGPMemoryMgrFlags_Clear);
				
				if (IsNull(currentPrefData->data.p))
				{
					sRemovePrefData(prefRef, currentPrefData);
					return kPGPError_OutOfMemory;
				}
				
				pgpCopyMemory(outBuffer, currentPrefData->data.p, dataLength);
			}
		}
		break;

	case kPGPPrefType_Struct:
		err = sCopyStructDataToPref(prefRef, FALSE,
				(PGPPrefStruct *) outBuffer, currentPrefData->data.strct);
		break;

	case kPGPPrefType_Array:
		prefArray = (PGPPrefArray *) outBuffer;
		if (prefArray->type != currentPrefData->data.a->type)
		{
			err = kPGPError_BadParams;
			break;
		}

		if (prefArray->numElements != currentPrefData->data.a->numElements)
		{
			prefRef->dirty = TRUE;
			PGPFreePrefArray(currentPrefData->data.a);

			err = PGPCreatePrefArray(prefRef, prefArray->type, 
					prefArray->numElements, prefArray->templateStruct,
					&(currentPrefData->data.a));

			if (IsPGPError(err))
				break;
		}

		for (index=0; index<prefArray->numElements; index++)
		{
			copyElement = &(prefArray->elements[index]);
			newElement = &(currentPrefData->data.a->elements[index]);
			
			if ((newElement->size != copyElement->size) && 
				((prefArray->type == kPGPPrefType_String) || 
				(prefArray->type == kPGPPrefType_Byte)))
			{
				prefRef->dirty = TRUE;
			}
			
			newElement->size = copyElement->size;

			switch (prefArray->type)
			{
			case kPGPPrefType_Boolean:
			case kPGPPrefType_Number:
				if (newElement->data != copyElement->data)
				{
					prefRef->dirty = TRUE;
					newElement->data = copyElement->data;
				}
				break;
				
			case kPGPPrefType_String:
				if (IsntNull(copyElement->data))
					newElement->size = strlen(copyElement->data) + 1;
				else
					newElement->size = 0;
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -