예제 #1
0
void sys_DirectoryExists(PA_PluginParameters params){
	char *directory = NULL;
	LONG_PTR length;
	WIN32_FIND_DATA FindFileData;
	HANDLE hFindFile;
	LONG ret = 0; // assume directory doesn't exist // WJF 6/30/16 Win-21 LONG_PTR -> LONG

	// retrieve the directory manual
	length = PA_GetTextParameter(params, 1, 0L);

	if (length > 0) {
		directory = malloc(length + 1); // WJF 7/13/16 Win-21 Removed typecasting on malloc to follow C best practices

		if (directory != NULL) {
			memset(directory, 0, length + 1);
			PA_GetTextParameter(params, 1, directory);
		}
	}

	// if the directory ends with a backslash it will fail and needs to be removed
	// if the directory is a disk root it will fail handle here in special case
	if (NULL != directory){
		if ((':' == directory[1]) && (length <= 3)) { // REB 8/2/10 #24474 Changed ( 3 == length) to (length <= 3)
			// drive since has only 3 chars, handle here
			ret = GetFileAttributes(directory);
			if (ret != INVALID_FILE_ATTRIBUTES){ // REB 8/2/10 #24474 Added check for invalid attributes.
				ret = (0 != (GetFileAttributes(directory) & FILE_ATTRIBUTE_DIRECTORY)); // set exists
				free(directory);
				directory = NULL; // we have a result so avoid to normal handler
			}
		}
		else if ('\\' == directory[length - 1]){
			directory[length - 1] = '\0';
		}
	}

	if (NULL != directory){
		hFindFile = FindFirstFile(directory, &FindFileData);

		// if a valid handle we should test whether it's a directory
		if (INVALID_HANDLE_VALUE != hFindFile){
			ret = (0 != (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)); // set exists
			FindClose(hFindFile);	// close handle
		}
		freeTextParameter(directory);
	}

	PA_ReturnLong(params, ret);
}
예제 #2
0
void sys_FileExists(PA_PluginParameters params){
	char *file = NULL;
	WIN32_FIND_DATA FindFileData;
	HANDLE hFindFile;
	BOOL ret = FALSE; // assume file doesn't exist  // WJF 6/30/16 Win-21 LONG_PTR -> BOOL

	file = getTextParameter(params, 1);

	if (NULL != file){
		hFindFile = FindFirstFile(file, &FindFileData);

		// if a valid handle we should test whether it's not a directory
		if (INVALID_HANDLE_VALUE != hFindFile){
			ret = (0 == (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)); // set exists
			FindClose(hFindFile);	// close handle
		}

		freeTextParameter(file);
	}

	PA_ReturnLong(params, ret);
}
예제 #3
0
// ------------------------------------------------
//
//  FUNCTION: sys_GetDocumentList( PA_PluginParameters params )
//
//  PURPOSE:  Return a list of files in a directory.
//
//	DATE:	  MJG 6/4/04 (3.6)
//
//  UPDATES:  MJG 7/5/05 (3.6.2)  Updated to set the 4D variable, Error,
//								  when an error occurs.
//
//			  AMS 9/16/14 #40405 (6.4)  Updated to return the oldest entries first
//		   								 and take in a starting index for specifying
//										 where the list of returned files begins.
//
//
// ------------------------------------------------
void sys_GetDocumentList(PA_PluginParameters params)
{
	LONG lReturnValue = 0; // WJF 6/30/16 Win-21 LONG_PTR -> LONG
	LONG lFileCount = 0; // WJF 6/30/16 Win-21 LONG_PTR -> LONG
	LONG lArraySize = 0; // WJF 6/30/16 Win-21 LONG_PTR -> LONG
	LONG lEndIndex = 0; // WJF 6/30/16 Win-21 LONG_PTR -> LONG
	LONG lCount = 0; // WJF 6/30/16 Win-21 LONG_PTR -> LONG
	const LONG lFileLimit = 1000;
	char fullPath[MAXBUF];
	WIN32_FIND_DATA fFindData;
	DWORD ret = 0;
	DWORD lastError = 0;
	HANDLE NextFind = 0;
	BOOL bGetAllFiles = FALSE;
	WIN32_FIND_DATA fileList[1000];

	// parameter variables
	char *patPathName = NULL;
	char *patFilePattern = NULL;
	LONG palMaxFilesToReturn = 0; // WJF 6/30/16 Win-21 LONG_PTR -> LONG
	LONG palFileSort = 0; // WJF 6/30/16 Win-21 LONG_PTR -> LONG
	LONG palStartIndex = 0; // WJF 6/30/16 Win-21 LONG_PTR -> LONG
	PA_Variable paReturnFileList;

	// Get the function parameters.
	patPathName = getTextParameter(params, 1);
	patFilePattern = getTextParameter(params, 2);
	paReturnFileList = PA_GetVariableParameter(params, 3);
	palMaxFilesToReturn = PA_GetLongParameter(params, 4);
	palFileSort = PA_GetLongParameter(params, 5);  // AMS2 9/30/14 #40405  Moved the sort parameter to be before start index
	palStartIndex = PA_GetLongParameter(params, 6);  // AMS2 9/16/14 #40405

	// Clear out the return array.
	PA_ResizeArray(&paReturnFileList, 0);

	// AMS2 9/19/14 #40405 Passing in the start index is optional, if a value is passed in then it is assumed that the user put in a number relative to a starting index of 1 instead of 0 for c/c++ arrays
	if ((palStartIndex != 0) || (palStartIndex > 0)) // WJF 6/24/16 Win-21 NULL -> 0
	{
		palStartIndex--;
	}
	else{
		palStartIndex = 0;
	}

	// WJF 4/7/15 #41624 If they haven't chosen a valid sort option, set to default
	if ((palFileSort != 1) && (palFileSort != 2))
	{
		palFileSort = 0;
	}

	if (patPathName != NULL && patFilePattern != NULL)
	{
		// Check if the path is valid.
		ret = GetFileAttributes(patPathName);

		if ((ret & FILE_ATTRIBUTE_DIRECTORY) != 0 && ret != INVALID_DIRECTORY)
		{
			// Build the full path name.
			if (patFilePattern[0] == '\0')
			{
				snprintf(fullPath, MAXBUF, "%s%s*.*", patPathName, patPathName[strlen(patPathName) - 1] == PATHCHAR ? "" : PATHSTR);
			}
			else
			{
				snprintf(fullPath, MAXBUF, "%s%s%s", patPathName, patPathName[strlen(patPathName) - 1] == PATHCHAR ? "" : PATHSTR, patFilePattern);
			}

			// Get the first file.
			NextFind = FindFirstFile(fullPath, &fFindData);

			if (NextFind != INVALID_HANDLE_VALUE)
			{
				// AMS2 9/18/14 #40405  Loop through the files in the directory and build a list to sort. Currently the max files that can be stored from a directory is 1000.
				lastError = ERROR_NO_MORE_FILES;
				bGetAllFiles = (palMaxFilesToReturn <= 0);

				while ((NextFind != INVALID_HANDLE_VALUE) && (lFileCount < lFileLimit))
				{
					if ((fFindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
					{
						// AMS2 9/19/14 #40405 When a file match is found, insert it into the file list array.
						fileList[lFileCount] = fFindData;
						lFileCount++;   // Count the number of files that match the pattern.
					}
					if (!FindNextFile(NextFind, &fFindData))
					{
						lastError = GetLastError();
						break;
					}
				} // end while

				// AMS2 9/18/14 #40405 Sort the array using compareFileTimeCreation which takes in two win32 find data variables and compares their creation dates.
				if (palFileSort == 1)
				{
					qsort(fileList, lFileCount, sizeof(WIN32_FIND_DATA), (int(*)(const void*, const void*))compareFileTimeCreation);
				}
				else if (palFileSort == 2) // WJF 4/7/15 #41624 Sorty by alphabetical order
				{
					qsort(fileList, lFileCount, sizeof(WIN32_FIND_DATA), (int(*)(const void*, const void*))compareAlphabetical);
				}

				// AMS2 9/18/14 #40405 Get all of the files if 0 is passed for the max files parameter.
				if (palMaxFilesToReturn == 0)
				{
					palMaxFilesToReturn = lFileCount;
				}

				// AMS2 9/18/14 #40405 If the start index or end index is out of range, then set them to the file count.
				if (palStartIndex > lFileCount)
				{
					palStartIndex = lFileCount;
				}

				lEndIndex = palMaxFilesToReturn + palStartIndex;

				if (lEndIndex > lFileCount)
				{
					lEndIndex = lFileCount;
				}

				// AMS2 9/22/14 #40405 As long as the end index is within the file limit, insert the requested file names into the return array
				// starting at the specified start index  and end at the start index + the max number of files to return.
				if (lEndIndex <= lFileLimit)
				{
					for (int i = palStartIndex; i < lEndIndex; i++)
					{
						lCount++;
						if (lCount > lArraySize)
						{
							// Increase the size of the array.
							lArraySize = lCount + ARRAY_LOAD_VALUE;
							PA_ResizeArray(&paReturnFileList, lArraySize);
						}

						PA_SetTextInArray(paReturnFileList, lCount, fileList[i].cFileName, strlen(fileList[i].cFileName));
					}
				}
			}
			else
			{
				lastError = GetLastError();
			}

			FindClose(NextFind);
		}
		else
		{
			lastError = GetLastError();
		}
	}

	if (lastError == ERROR_NO_MORE_FILES || lastError == ERROR_FILE_NOT_FOUND)
	{
		setError(0);
		PA_ResizeArray(&paReturnFileList, lCount);  // AMS2 9/22/14 #40405 When the file selection has finished with no more files in the dir or a file has not been found, resize the return array to the number of files inserted into the array.
		lReturnValue = 1;
	}
	else
	{
		setError(lastError);
		PA_ResizeArray(&paReturnFileList, 0);
	}

	PA_SetVariableParameter(params, 3, paReturnFileList, 0);

	freeTextParameter(patPathName);
	freeTextParameter(patFilePattern);

	PA_ReturnLong(params, lReturnValue);
}