private string DetermineOutfileBody(string outputFilenameTemplate)
{
var outputDir = PathSafe.GetDirectoryName(outputFilenameTemplate) ?? "";
var filenameBase = PathSafe.GetFileNameWithoutExtension(outputFilenameTemplate) ?? "output";
return(PathSafe.Combine(outputDir, filenameBase));
}
public string GetFontFilename(Font font)
{
RegistryKey[] registryKeys =
{
Microsoft.Win32.Registry.LocalMachine.OpenSubKey(@"Software\Microsoft\Windows NT\CurrentVersion\Fonts", false),
Microsoft.Win32.Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Windows NT\CurrentVersion\Fonts", false),
Microsoft.Win32.Registry.LocalMachine.OpenSubKey(@"Software\Microsoft\Windows\CurrentVersion\Fonts", false)
};
try
{
foreach (RegistryKey fonts in registryKeys)
{
if (fonts != null)
{
var name = MatchRegistryFontKey(font, fonts);
if (!string.IsNullOrEmpty(name))
{
return(PathSafe.GetFileName(fonts.GetValue(name).ToString()));
}
}
}
_logger.Warn($"Incompatible Font: {font.Name} {font.Style.ToString()}");
return(null);
}
finally
{
foreach (RegistryKey key in registryKeys)
{
key?.Dispose();
}
}
}
public string GetAssemblyDirectory()
{
var assemblyPath = GetAssemblyPath(_assembly);
var dir = Path.GetDirectoryName(assemblyPath);
return(PathSafe.GetDirectoryName(assemblyPath));
}
/// <summary>
/// Creates a directory that does not exist yet. It takes a path and appends a counting number (_2, _3, etc) to ensure
/// this in a readable way.
/// </summary>
/// <returns>The uniqified directory path</returns>
public string MakeUniqueDirectory(string path)
{
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
if (string.IsNullOrEmpty(path))
{
throw new ArgumentException("Argument may not be empty string", nameof(path));
}
var directory = PathSafe.GetDirectoryName(path) ?? "";
var fileBody = PathSafe.GetFileName(path);
var i = 2;
while (_directoryWrap.Exists(path) || _fileWrap.Exists(path))
{
path = PathSafe.Combine(directory, fileBody + "_" + i);
i++;
}
return(path);
}
public async Task SaveCommand_Execute_ProfileIsValid_UserCanceledSaveFileDialog_FileExist_NotifysUserWithCorrectInteraction()
{
var vm = BuildViewModel(saveDialogResult: false); //User cancels SaveFileDialog
var job = BuildJob(_pdfProfile);
var task = vm.ExecuteWorkflowStep(job);
_interactiveProfileChecker.CheckWithErrorResultInOverlay(job).Returns(true);
await vm.BrowseFileCommandAsync.ExecuteAsync(null);
_file.Exists(Arg.Any <string>()).Returns(true);
vm.OutputFilename = _filenameFromSaveDialog;
vm.OutputFolder = _folderFromSaveDialog;
var expectedDir = PathSafe.Combine(vm.OutputFolder, vm.OutputFilename);
vm.SaveCommand.Execute(null);
var interaction = _interactionRequest.AssertWasRaised <MessageInteraction>();
Assert.AreEqual(_translation.ConfirmSaveAs.ToUpper(), interaction.Title, "Title");
Assert.AreEqual(_translation.GetFileAlreadyExists(expectedDir), interaction.Text, "Message");
Assert.AreEqual(MessageIcon.Exclamation, interaction.Icon, "Icon");
Assert.AreEqual(MessageOptions.YesNo, interaction.Buttons, "Buttons");
Assert.IsFalse(task.IsCompleted);
await AbortStep(vm, task);
}
public OutputFormat GetOutputFormatByPath(string path)
{
var ext = PathSafe.GetExtension(path);
if (ext != null)
{
switch (ext.ToLower())
{
case ".jpg":
case ".jpeg":
return(OutputFormat.Jpeg);
case ".png":
return(OutputFormat.Png);
case ".tif":
case ".tiff":
return(OutputFormat.Tif);
case ".txt":
return(OutputFormat.Txt);
case ".pdf":
return(OutputFormat.Pdf);
}
}
throw new NotImplementedException($"OutputFormat '{ext}' is not known to {nameof(OutputFormatHelper)}!");
}
public void UpdateLanguage()
{
var language = GetLanguage();
var applicationDir = _assemblyHelper.GetAssemblyDirectory();
var applicationUserGuideDir = PathSafe.Combine(applicationDir, "UserGuide");
var candidates = new[]
{
PathSafe.Combine(applicationDir, $"PDFCreator_{language.CommonName}.chm"),
PathSafe.Combine(applicationUserGuideDir, $"PDFCreator_{language.CommonName}.chm"),
PathSafe.Combine(applicationDir, "PDFCreator_english.chm"),
PathSafe.Combine(applicationUserGuideDir, "PDFCreator_english.chm")
};
foreach (var candidate in candidates)
{
if (!_fileWrap.Exists(candidate))
{
continue;
}
_userGuideLauncher.SetUserGuide(candidate);
break;
}
}
public string GetDir()
{
var pdfforgeProgramData = @"%ProgramData%\pdfforge\";
var applicationProgramData = PathSafe.Combine(pdfforgeProgramData, _applicationName);
return(Environment.ExpandEnvironmentVariables(applicationProgramData));
}
public GpoReader(string applicationRegKey)
{
var policyPath = PathSafe.Combine(@"Software\Policies\", applicationRegKey);
_hklmStorage = new RegistryStorage(RegistryHive.LocalMachine, policyPath);
_hkcuStorage = new RegistryStorage(RegistryHive.CurrentUser, policyPath);
}
private void SetPdfXParameters(IList <string> parameters)
{
var shortenedTempPath = PathHelper.GetShortPathName(Job.JobTempFolder);
parameters.Add("-dPDFX");
Logger.Debug("Shortened Temppath from\r\n\"" + Job.JobTempFolder + "\"\r\nto\r\n\"" + shortenedTempPath + "\"");
//Add ICC profile
var iccFile = PathSafe.Combine(shortenedTempPath, "profile.icc");
switch (Job.Profile.PdfSettings.ColorModel)
{
case ColorModel.Cmyk:
FileWrap.WriteAllBytes(iccFile, GhostscriptResources.WebCoatedFOGRA28);
break;
case ColorModel.Gray:
FileWrap.WriteAllBytes(iccFile, GhostscriptResources.ISOcoated_v2_grey1c_bas);
break;
}
parameters.Add("-sOutputICCProfile=\"" + iccFile + "\"");
//Set in pdf-X example, but is not documented in the distiller parameters
var defFile = PathSafe.Combine(shortenedTempPath, "pdfx_def.ps");
var sb = new StringBuilder(GhostscriptResources.PdfxDefinition);
sb.Replace("%/ICCProfile (ISO Coated sb.icc)", "/ICCProfile (" + EncodeGhostscriptParametersOctal(iccFile.Replace('\\', '/')) + ")");
FileWrap.WriteAllText(defFile, sb.ToString());
parameters.Add(defFile);
}
public JobInfo Duplicate(JobInfo jobInfo, string profileGuid = null)
{
var jobInfoDuplicate = new JobInfo();
jobInfoDuplicate.Metadata = jobInfo.Metadata.Copy();
jobInfoDuplicate.JobType = jobInfo.JobType;
jobInfoDuplicate.PrintDateTime = jobInfo.PrintDateTime;
jobInfoDuplicate.PrinterName = jobInfo.PrinterName;
jobInfoDuplicate.PrinterParameter = profileGuid == null ? jobInfo.PrinterParameter : "";
jobInfoDuplicate.ProfileParameter = profileGuid ?? jobInfo.ProfileParameter;
jobInfoDuplicate.OutputFileParameter = jobInfo.OutputFileParameter;
jobInfoDuplicate.OriginalFilePath = jobInfo.OriginalFilePath;
jobInfoDuplicate.InfFile = "DuplicateInfFileDummy_" + Guid.NewGuid();
var sfiFilename = PathSafe.GetFileName(jobInfo.SourceFiles[0].Filename);
var duplicateJobFolder = _jobFolderBuilder.CreateJobFolderInSpool(sfiFilename);
foreach (var sfi in jobInfo.SourceFiles)
{
var sfiDuplicate = _sourceFileInfoDuplicator.Duplicate(sfi, duplicateJobFolder, profileGuid);
jobInfoDuplicate.SourceFiles.Add(sfiDuplicate);
}
return(jobInfoDuplicate);
}
private string CreateInfFile(IList <JobFolderFile> jobFolderFiles, string jobFolder, AppStartParameters appStartParameters)
{
var firstDirectConversionFile = jobFolderFiles[0].OriginalFilePath;
var fileName = PathSafe.GetFileName(firstDirectConversionFile);
var shortFileName = fileName;
if (fileName.Length > 12)
{
shortFileName = fileName.Substring(0, 12);
}
var infFile = PathSafe.Combine(jobFolder, shortFileName + ".inf");
var jobInfo = new JobInfo();
foreach (var jobFolderFile in jobFolderFiles)
{
var sfi = CreateSourceFileInfo(jobFolderFile, appStartParameters);
jobInfo.SourceFiles.Add(sfi);
}
_jobInfoManager.SaveToInfFile(jobInfo, infFile);
Logger.Debug("Created inf-file for ps-file: " + infFile);
return(infFile);
}
public UIElement LoadBanner(BannerDefinition banner)
{
var baseName = PathSafe.Combine(_fileCache.CacheDirectory, $"{banner.BundleId}-v{banner.Version}");
var filename = baseName + ".zip";
var directory = baseName + "-extracted";
if (!DirectoryContainsBanner(directory, banner))
{
ExtractZipFile(filename, directory);
}
FrameworkElement bannerControl;
switch (banner.BundleType)
{
case BundleType.Xaml:
bannerControl = LoadXamlBanner(banner, directory);
break;
case BundleType.Image:
bannerControl = LoadImageBanner(banner, directory);
break;
default: throw new Exception("Unknown banner type!");
}
WpfHelper.RegisterOpen(bannerControl, url => HandleClick(banner, url));
var loadOnce = new LoadOnceHandler();
bannerControl.Loaded += (sender, args) => HandleLoaded(banner, loadOnce);
return(bannerControl);
}
public SourceFileInfo Duplicate(SourceFileInfo sfi, string duplicateFolder, string profileGuid)
{
var duplicate = new SourceFileInfo();
duplicate.SessionId = sfi.SessionId;
duplicate.WinStation = sfi.WinStation;
duplicate.Author = sfi.Author;
duplicate.ClientComputer = sfi.ClientComputer;
duplicate.PrinterName = sfi.PrinterName;
duplicate.JobCounter = sfi.JobCounter;
duplicate.JobId = sfi.JobId;
duplicate.DocumentTitle = sfi.DocumentTitle;
duplicate.OriginalFilePath = sfi.OriginalFilePath;
duplicate.Type = sfi.Type;
duplicate.TotalPages = sfi.TotalPages;
duplicate.Copies = sfi.Copies;
duplicate.UserTokenEvaluated = sfi.UserTokenEvaluated;
duplicate.UserToken = sfi.UserToken;
duplicate.OutputFileParameter = sfi.OutputFileParameter;
duplicate.PrinterParameter = profileGuid == null ? sfi.PrinterParameter : "";
duplicate.ProfileParameter = profileGuid ?? sfi.ProfileParameter;
var duplicateFilename = PathSafe.GetFileNameWithoutExtension(sfi.Filename);
var duplicateFilePath = PathSafe.Combine(duplicateFolder, duplicateFilename);
duplicateFilePath = _uniqueFilePathBuilder.Build(duplicateFilePath).Unique;
_file.Copy(sfi.Filename, duplicateFilePath);
duplicate.Filename = duplicateFilePath;
return(duplicate);
}
/// <summary>
/// Create a new GhostscriptJob instance
/// </summary>
/// <param name="jobInfo">JobInfo of the job to convert</param>
/// <param name="profile">Profile that determines the conversion process</param>
/// <param name="tempFolder">
/// TempFolderProvider that gives the full Temp path, i.e. C:\Users\Admin\Local
/// Settings\Temp\clawPDF
/// </param>
/// <param name="jobTranslations">Translations needed for the job</param>
/// <param name="fileWrap">Only for testing</param>
/// <param name="directoryWrap">Only for testing</param>
public GhostscriptJob(IJobInfo jobInfo, ConversionProfile profile, JobTranslations jobTranslations,
ITempFolderProvider tempFolder, IFile fileWrap, IDirectory directoryWrap)
: base(jobInfo, profile, jobTranslations, fileWrap, directoryWrap)
{
var gsVersion = new GhostscriptDiscovery().GetBestGhostscriptInstance();
if (gsVersion == null)
{
Logger.Error("No valid Ghostscript version found.");
throw new InvalidOperationException("No valid Ghostscript version found.");
}
Logger.Debug("Ghostscript Version: " + gsVersion.Version + " loaded from " + gsVersion.DllPath);
_ghostScript = new GhostScript(gsVersion);
JobTempFolder = PathSafe.Combine(tempFolder.TempFolder,
"Job_" + PathSafe.GetFileNameWithoutExtension(PathSafe.GetRandomFileName()));
JobTempOutputFolder = PathSafe.Combine(JobTempFolder, "tempoutput");
DirectoryWrap.CreateDirectory(JobTempFolder);
DirectoryWrap.CreateDirectory(JobTempOutputFolder);
// Shorten the temp folder for GS compatibility
//缩短临时文件夹以实现GS兼容性
JobTempFolder = JobTempFolder;
}
public ActionResult <string> GetFontPath(ConversionProfile profile)
{
var globalFontFolder = Environment.GetFolderPath(Environment.SpecialFolder.Fonts);
_logger.Trace("Global font folder: " + globalFontFolder);
var fontPath = PathSafe.Combine(globalFontFolder, profile.Stamping.FontFile);
if (!_file.Exists(fontPath))
{
var userFontFolder = Environment.ExpandEnvironmentVariables(@"%LocalAppData%\Microsoft\Windows\Fonts");
_logger.Trace("User font folder: " + userFontFolder);
fontPath = PathSafe.Combine(userFontFolder, profile.Stamping.FontFile);
if (!_file.Exists(fontPath))
{
_logger.Error($"Font file not found: {profile.Stamping.FontFile}");
return(new ActionResult <string>(ErrorCode.Stamp_FontNotFound));
}
}
_logger.Debug("Font path: " + fontPath);
return(new ActionResult <string>(fontPath));
}
private string RemoveExtension(string filePath)
{
var directory = PathSafe.GetDirectoryName(filePath);
var fileWithoutExtension = PathSafe.GetFileNameWithoutExtension(filePath);
return(Path.Combine(directory, fileWithoutExtension));
}
public string ComposeTargetFilePath(Job job)
{
//Consider OutputFileParameter
if (!string.IsNullOrWhiteSpace(job.JobInfo.OutputFileParameter))
{
if (_pathUtil.IsValidRootedPath(job.JobInfo.OutputFileParameter))
{
return(job.JobInfo.OutputFileParameter);
}
}
var outputFolder = ComposeOutputFolder(job);
var outputFileName = ComposeOutputFilename(job);
var filePath = PathSafe.Combine(outputFolder, outputFileName);
//Keep long filename for interactive
if (!job.Profile.AutoSave.Enabled)
{
return(filePath);
}
try
{
filePath = _pathUtil.EllipsisForTooLongPath(filePath);
_logger.Debug("FilePath after ellipsis: " + filePath);
}
catch (ArgumentException)
{
throw new WorkflowException("Filepath is only a directory or the directory itself is already too long to append a useful filename under the limits of Windows (max " + _pathUtil.MAX_PATH + " characters):\n"
+ filePath);
}
return(filePath);
}
/// <summary>
/// Get the list of Ghostscript Parameters. This List contains of a basic set of parameters together with some
/// device-specific
/// parameters that will be added by the device implementation
/// </summary>
/// <param name="ghostscriptVersion"></param>
/// <returns>A list of parameters that will be passed to Ghostscript</returns>
public IList <string> GetGhostScriptParameters(GhostscriptVersion ghostscriptVersion)
{
IList <string> parameters = new List <string>();
var outputFormatHelper = new OutputFormatHelper();
parameters.Add("gs");
parameters.Add("--permit-file-all=\"" + Job.JobTempFolder + "\\\"");
parameters.Add("-I" + ghostscriptVersion.LibPaths);
parameters.Add("-sFONTPATH=" + _osHelper.WindowsFontsFolder);
parameters.Add("-dNOPAUSE");
parameters.Add("-dBATCH");
if (!outputFormatHelper.HasValidExtension(Job.OutputFileTemplate, Job.Profile.OutputFormat))
{
outputFormatHelper.EnsureValidExtension(Job.OutputFileTemplate, Job.Profile.OutputFormat);
}
AddOutputfileParameter(parameters);
AddDeviceSpecificParameters(parameters);
// Add user-defined parameters
if (!string.IsNullOrEmpty(Job.Profile.Ghostscript.AdditionalGsParameters))
{
var args = _commandLineUtil.CommandLineToArgs(Job.Profile.Ghostscript.AdditionalGsParameters);
foreach (var s in args)
{
parameters.Add(s);
}
}
//Dictonary-Parameters must be the last Parameters
if (DistillerDictonaries.Count > 0)
{
parameters.Add("-c");
foreach (var parameter in DistillerDictonaries)
{
parameters.Add(parameter);
}
}
//Don't add further paramters here, since the distiller-parameters should be the last!
parameters.Add("-f");
SetSourceFiles(parameters, Job);
// Compose name of the pdfmark file based on the location and name of the inf file
var pdfMarkFileName = PathSafe.Combine(Job.JobTempFolder, "metadata.mtd");
CreatePdfMarksFile(pdfMarkFileName);
// Add pdfmark file as input file to set metadata
parameters.Add(pdfMarkFileName);
return(parameters);
}
private void EnableSaveToDesktop(Job job)
{
job.Profile.SaveFileTemporary = false;
var filename = PathSafe.GetFileName(job.OutputFileTemplate);
var desktopFolder = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
job.OutputFileTemplate = PathSafe.Combine(desktopFolder, filename);
}
private string GetDefaultLogFilePath(string applicationName)
{
var localAppDataFolderBase = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
var logFileDir = PathSafe.Combine(localAppDataFolderBase, "pdfforge", "PDFCreator");
var fileName = PathSafe.Combine(logFileDir, applicationName + ".log");
return(fileName);
}
public override void MoveOutputFiles()
{
string outputDir = PathSafe.GetDirectoryName(Job.OutputFilenameTemplate) ?? "";
string filenameBase = PathSafe.GetFileNameWithoutExtension(Job.OutputFilenameTemplate) ?? "output";
string outfilebody = PathSafe.Combine(outputDir, filenameBase);
Job.OutputFiles = new string[TempOutputFiles.Count]; //reserve space
foreach (string tempoutputfile in TempOutputFiles)
{
string extension = PathSafe.GetExtension(TempOutputFiles[0]);
string tempFileBase = PathSafe.GetFileNameWithoutExtension(tempoutputfile) ?? "output";
string num = tempFileBase.Replace(Job.JobTempFileName, "");
int numValue;
if (int.TryParse(num, out numValue))
{
int numDigits = (int)Math.Floor(Math.Log10(TempOutputFiles.Count) + 1);
num = numValue.ToString("D" + numDigits);
}
string outputfile;
if (num == "1")
{
outputfile = outfilebody + extension;
}
else
{
outputfile = outfilebody + num + extension;
}
lock (_lockObject)
{
var uniqueFilename = new UniqueFilename(outputfile, DirectoryWrap, FileWrap);
if (Job.Profile.AutoSave.Enabled && Job.Profile.AutoSave.EnsureUniqueFilenames)
{
outputfile = EnsureUniqueFilename(uniqueFilename);
}
if (!CopyFile(tempoutputfile, outputfile))
{
outputfile = EnsureUniqueFilename(uniqueFilename);
if (!CopyFile(tempoutputfile, outputfile))
{
//Throw exception after second attempt to copy failes.
throw new DeviceException("Error while copying to target file in second attempt. Process gets canceled.", 2);
}
}
}
DeleteFile(tempoutputfile);
Job.OutputFiles[Convert.ToInt32(num) - 1] = outputfile;
}
}
public JobHistoryJsonFileStorage(IEnvironment environment, IFile file, IAppDataProvider appDataProvider)
{
_environment = environment;
_file = file;
_appDataProvider = appDataProvider;
var historyDir = _appDataProvider.LocalAppDataFolder;
_savePath = PathSafe.Combine(historyDir, "PDFCreatorHistory.json");
}
public string GetDownloadPath(string downloadUrl)
{
var downloadLocation = _tempFolderProvider.TempFolder;
_directory.CreateDirectory(downloadLocation);
var uri = new Uri(downloadUrl);
var filename = PathSafe.GetFileName(uri.LocalPath);
return(PathSafe.Combine(downloadLocation, filename));
}
public void OutputFormat_WhenSet_UpdatesFilename()
{
var vm = BuildViewModel();
vm.SetJob(BuildJob(_pdfProfile));
var oldOutputFileName = vm.OutputFilename;
vm.OutputFormat = OutputFormat.Txt;
Assert.AreEqual(PathSafe.ChangeExtension(oldOutputFileName, ".txt"), vm.OutputFilename);
}
private string CopyFileToJobFolder(string jobFolder, string file)
{
var shortUniqueFilename = _path.GetRandomFileName();
var extension = PathSafe.GetExtension(file);
var psFileInJobFolder = PathSafe.Combine(jobFolder, shortUniqueFilename + extension);
_file.Copy(file, psFileInJobFolder);
Logger.Debug("Copied direct conversion file to spool folder: " + psFileInJobFolder);
return(psFileInJobFolder);
}
private void SetPdfAParameters(IList <string> parameters)
{
var shortenedTempPath = PathHelper.GetShortPathName(Job.JobTempFolder);
switch (Job.Profile.OutputFormat)
{
case OutputFormat.PdfA1B:
parameters.Add("-dPDFA=1");
break;
case OutputFormat.PdfA2B:
parameters.Add("-dPDFA=2");
break;
case OutputFormat.PdfA3B:
parameters.Add("-dPDFA=3");
break;
}
//parameters.Add("-dNOOUTERSAVE"); //Set in pdf-A example, but is not documented in the distiller parameters
Logger.Debug("Shortened Temppath from\r\n\"" + Job.JobTempFolder + "\"\r\nto\r\n\"" + shortenedTempPath + "\"");
//Add ICC profile
var iccFile = PathSafe.Combine(shortenedTempPath, "profile.icc");
//Set ICC Profile according to the color model
switch (Job.Profile.PdfSettings.ColorModel)
{
case ColorModel.Cmyk:
FileWrap.WriteAllBytes(iccFile, Resources.WebCoatedFOGRA28);
break;
case ColorModel.Gray:
FileWrap.WriteAllBytes(iccFile, Resources.ISOcoated_v2_grey1c_bas);
break;
default:
case ColorModel.Rgb:
FileWrap.WriteAllBytes(iccFile, Resources.eciRGB_v2);
break;
}
parameters.Add("-sPDFACompatibilityPolicy=1");
parameters.Add("-sOutputICCProfile=\"" + iccFile + "\"");
var defFile = PathSafe.Combine(Job.JobTempFolder, "pdfa_def.ps");
var sb = new StringBuilder(Resources.PdfaDefinition);
sb.Replace("[ICC_PROFILE]", "(" + EncodeGhostscriptParametersOctal(iccFile.Replace('\\', '/')) + ")");
FileWrap.WriteAllText(defFile, sb.ToString());
parameters.Add(defFile);
}
public string CreateFile(string filename, string extension)
{
filename = PathSafe.ChangeExtension(filename, extension);
var dir = _directoryHelper.CreateTestFileDirectory();
var testFile = PathSafe.Combine(dir, filename);
if (!_file.Exists(testFile))
{
_file.WriteAllText(testFile, @"PDFCreator Test", Encoding.UTF8);
}
return(testFile);
}
public PrinterPort ReadPrinterPort(string portName)
{
var subKey = PathSafe.Combine(RegistryBaseKey, portName);
var key = _registry.LocalMachine.OpenSubKey(subKey);
if (key == null)
{
return(null);
}
var printerPort = new PrinterPort();
try
{
printerPort.Name = portName;
printerPort.Description = key.GetValue("Description").ToString();
printerPort.Program = key.GetValue("Program").ToString();
var portTypeString = key.GetValue("Type", "PS").ToString();
if (portTypeString.Equals("XPS", StringComparison.OrdinalIgnoreCase))
{
printerPort.Type = PortType.Xps;
}
printerPort.TempFolderName = key.GetValue("TempFolderName", DefaultTempFolderName).ToString();
var serverValue = (int?)key.GetValue("Server");
if (serverValue == 1)
{
printerPort.IsServerPort = true;
}
if (string.IsNullOrWhiteSpace(printerPort.TempFolderName))
{
printerPort.TempFolderName = DefaultTempFolderName;
}
var jobCounter = (int)key.GetValue("JobCounter", 0);
printerPort.JobCounter = jobCounter;
}
catch (NullReferenceException)
{
printerPort = null;
}
key.Close();
return(printerPort);
}
public bool HasValidExtension(string file, OutputFormat outputFormat)
{
var extension = PathSafe.GetExtension(file);
if (extension == null)
{
return(false);
}
var validExtensions = GetValidExtensions(outputFormat);
return(validExtensions.Contains(extension.ToLower()));
}
