/// <summary>Parses dedup value from input parameter.</summary>
/// <param name="dedup">Dedup value string.</param>
private static void ParseDedupValue(string dedup)
{
var dedupValue = false;
// If value is provided then parse it
if (!string.IsNullOrEmpty(dedup))
{
// Try parsing the value passed
// If contains invalid value then throw an exception
if (bool.TryParse(dedup.Trim(), out dedupValue))
{
ArgumentValueData[Dedup] = dedupValue.ToString(CultureInfo.InvariantCulture);
}
else
{
ArgumentValueData.Remove(Dedup);
throw new ImageAssembleException(string.Format(CultureInfo.CurrentUICulture, ImageAssembleStrings.InvalidInputParameterValueMessage, Dedup));
}
}
else
{
ArgumentValueData.Remove(Dedup);
throw new ImageAssembleException(string.Format(CultureInfo.CurrentUICulture, ImageAssembleStrings.ValueMissingForInputParameterMessage, Dedup));
}
}
/// <summary>Parses padding value from input parameter.</summary>
/// <param name="padding">Padding value string.</param>
private static void ParsePaddingValue(string padding)
{
var padValue = 0;
// If value is provided then parse it
// else throw an exception
if (!string.IsNullOrEmpty(padding))
{
// Try parsing the value passed
// If contains invalid value then throw an exception
if (int.TryParse(padding.Trim(), out padValue))
{
// Check if the padding is outside valid limits (0 to 1024)
// If it is, throw an exception
if (padValue < ArgumentParser.MinPadding || padValue > ArgumentParser.MaxPadding)
{
throw new ImageAssembleException(string.Format(CultureInfo.CurrentCulture, ImageAssembleStrings.InvalidPaddingValueMessage, padding, ArgumentParser.MinPadding.ToString(CultureInfo.CurrentCulture), ArgumentParser.MaxPadding.ToString(CultureInfo.CurrentCulture)));
}
ArgumentValueData[Padding] = padValue.ToString(CultureInfo.InvariantCulture);
}
else
{
ArgumentValueData.Remove(Padding);
throw new ImageAssembleException(string.Format(CultureInfo.CurrentCulture, ImageAssembleStrings.InvalidInputParameterValueMessage, Padding));
}
}
else
{
ArgumentValueData.Remove(Padding);
throw new ImageAssembleException(string.Format(CultureInfo.CurrentCulture, ImageAssembleStrings.ValueMissingForInputParameterMessage, Padding));
}
}
/// <summary>Performs static members initialization / clean-up.</summary>
private static void PreParsingLogic()
{
// If ArgumentValueData is not initialized then initialize it
// else clear it.
if (ArgumentValueData == null)
{
ArgumentValueData = new Dictionary <string, string>();
}
else
{
ArgumentValueData.Clear();
}
// Add default packing type value as Vertical
ArgumentValueData.Add(PackingScheme, Vertical);
// Add default sprite name
ArgumentValueData.Add(SpriteName, DefaultSpriteName);
// Add default dedup as False
ArgumentValueData.Add(Dedup, "False");
// Add default value for Padding
ArgumentValueData.Add(Padding, DefaultPadding.ToString(CultureInfo.InvariantCulture));
// Clear InputImageList if it is not null
if (inputImageList != null && inputImageList.Count > 0)
{
inputImageList.Clear();
}
// Arraylist that will hold the missing parameters. First all mandatory parameters
// are added to it and as they are parsed removed from the list so the remaining
// members in arraylist at the end of parsing are missing.
if (MissingParams == null)
{
MissingParams = new ArrayList();
}
else
{
MissingParams.Clear();
}
MissingParams.Add(DirectoryOrFileName);
MissingParams.Add(OutputDirectory);
MissingParams.Add(XmlMapName);
MissingParams.Add(ArgumentParser.Padding);
}
/// <summary>Parses log file name from input value</summary>
/// <param name="mapFileName">Log file name.</param>
private static void ParseLogFile(string mapFileName)
{
if (string.IsNullOrEmpty(mapFileName))
{
throw new ImageAssembleException(string.Format(CultureInfo.CurrentUICulture, ImageAssembleStrings.ValueMissingForInputParameterMessage, XmlMapName));
}
else
{
var directory = Path.GetDirectoryName(mapFileName);
if (!string.IsNullOrEmpty(directory))
{
// Create all directories
Directory.CreateDirectory(directory);
}
ArgumentValueData.Add(XmlMapName, mapFileName);
}
}
/// <summary>Parses directory value from input parameter.</summary>
/// <param name="dirName">Directory value string.</param>
/// <param name="paramName">Input parameter name.</param>
private static void ParseDirectoryValue(string dirName, string paramName)
{
var formatMessageDoesnotExist = string.Format(CultureInfo.CurrentUICulture, ImageAssembleStrings.DirectoryDoesNotExistMessage, dirName, paramName);
var formatMessageNotSpecified = string.Format(CultureInfo.CurrentUICulture, ImageAssembleStrings.ValueMissingForInputParameterMessage, paramName);
var flagInputDirectory = true;
if (paramName.Equals(OutputDirectory, StringComparison.OrdinalIgnoreCase))
{
flagInputDirectory = false;
formatMessageDoesnotExist = string.Format(CultureInfo.CurrentUICulture, ImageAssembleStrings.DirectoryDoesNotExistMessage, dirName, paramName);
formatMessageNotSpecified = string.Format(CultureInfo.CurrentUICulture, ImageAssembleStrings.ValueMissingForInputParameterMessage, paramName);
}
if (!string.IsNullOrEmpty(dirName))
{
if (Directory.Exists(dirName))
{
if (flagInputDirectory)
{
inputImageList = ConvertToInputImageList(Directory.GetFiles(dirName));
// Fix for Bug# 956100
// If there are not images present then thrown an exception
if (InputImageList.Count == 0)
{
throw new ImageAssembleException(string.Format(CultureInfo.CurrentUICulture, ImageAssembleStrings.NoInputFilesMessage, dirName));
}
}
else
{
ArgumentValueData.Add(OutputDirectory, dirName);
}
}
else
{
throw new ImageAssembleException(formatMessageDoesnotExist);
}
}
else
{
throw new ImageAssembleException(formatMessageNotSpecified);
}
}
/// <summary>Parses command line parameters and generates a list of image paths from it.</summary>
/// <remarks>/inputdirectory and /inputfilepaths overrides inputImages parameter.
/// i.e. When inputImages parameters is provided, its value will be used only when
/// /inputdirectory and /inputfilepaths are not present in input parameters.</remarks>
/// <param name="input">string array of input parameters.</param>
/// <param name="inputImages">InputImage List that will be passed by ImageAssembleTask. For all other callers (Console App), this value will be NULL.</param>
internal static void ParseArguments(string[] input, IList <InputImage_Accessor> inputImages)
{
var usage = string.Format(CultureInfo.CurrentCulture, ImageAssembleStrings.ToolUsageMessage, ArgumentParser.DefaultPadding.ToString(CultureInfo.CurrentCulture), ArgumentParser.MinPadding.ToString(CultureInfo.CurrentCulture), ArgumentParser.MaxPadding.ToString(CultureInfo.CurrentCulture));
// Check if arguments are provided
if (input == null || input.Length == 0)
{
throw new ImageAssembleException(string.Format(CultureInfo.CurrentCulture, ImageAssembleStrings.NoInputParametersMessage, usage));
}
else
{
// Check if duplicate input image parameters are present
CheckImageFilesDuplicateParameter(input);
// Perform some clean-up and/or initialization
PreParsingLogic();
// Set InputImageList if it is passed as parameter to this method
if (inputImages != null)
{
inputImageList = inputImages;
}
foreach (var ar in input)
{
if (ar.StartsWith(DirectoryName, StringComparison.OrdinalIgnoreCase) || ar.StartsWith(ShorthandInputDirectory, StringComparison.OrdinalIgnoreCase))
{
// Directory name parsing
var dirName = ParseParameterValueFromArg(ar, DirectoryName, ShorthandInputDirectory);
ParseDirectoryValue(dirName, DirectoryName);
MissingParams.Remove(DirectoryOrFileName);
}
else if (ar.StartsWith(Paths, StringComparison.OrdinalIgnoreCase) || ar.StartsWith(ShorthandInputFilePaths, StringComparison.OrdinalIgnoreCase))
{
// Input string is semicolon separated file paths
// e.g. /i:C:\Users\v-niravd\Documents\Test\Images\Input\pic_karate.gif;C:\Users\v-niravd\Documents\Test\Images\Input\vaio.gif
var filePaths = ParseParameterValueFromArg(ar, Paths, ShorthandInputFilePaths);
ParseInputFilePaths(filePaths);
MissingParams.Remove(DirectoryOrFileName);
}
else if (ar.StartsWith(OutputDirectory, StringComparison.OrdinalIgnoreCase))
{
// Directory name parsing
var outputDir = string.Empty;
outputDir = ar.Substring(OutputDirectory.Length).Trim();
ParseDirectoryValue(outputDir, OutputDirectory);
MissingParams.Remove(OutputDirectory);
}
else if (ar.StartsWith(PackingScheme, StringComparison.OrdinalIgnoreCase) || ar.StartsWith(ShorthandPackingScheme, StringComparison.OrdinalIgnoreCase))
{
// Packing type parsing
var packing = ParseParameterValueFromArg(ar, PackingScheme, ShorthandPackingScheme);
if (!string.IsNullOrEmpty(packing))
{
if (packing.Equals(Horizontal, StringComparison.OrdinalIgnoreCase) || packing.Equals(Vertical, StringComparison.OrdinalIgnoreCase))
{
ArgumentValueData[PackingScheme] = packing;
}
else
{
ArgumentValueData.Remove(PackingScheme);
throw new ImageAssembleException(string.Format(CultureInfo.CurrentUICulture, ImageAssembleStrings.InvalidInputParameterValueMessage, PackingScheme));
}
}
else
{
ArgumentValueData.Remove(PackingScheme);
throw new ImageAssembleException(string.Format(CultureInfo.CurrentUICulture, ImageAssembleStrings.ValueMissingForInputParameterMessage, PackingScheme));
}
}
else if (ar.StartsWith(SpriteName, StringComparison.OrdinalIgnoreCase) || ar.StartsWith(ShorthandSpriteImage, StringComparison.OrdinalIgnoreCase))
{
// Sprite name parsing
var spriteName = ParseParameterValueFromArg(ar, SpriteName, ShorthandSpriteImage);
if (!string.IsNullOrEmpty(spriteName))
{
ArgumentValueData[SpriteName] = spriteName;
}
else
{
ArgumentValueData.Remove(SpriteName);
throw new ImageAssembleException(string.Format(CultureInfo.CurrentUICulture, ImageAssembleStrings.ValueMissingForInputParameterMessage, SpriteName));
}
}
else if (ar.StartsWith(XmlMapName, StringComparison.OrdinalIgnoreCase) || ar.StartsWith(ShorthandLogFile, StringComparison.OrdinalIgnoreCase))
{
// Xml map file name parsing
var mapFileName = ParseParameterValueFromArg(ar, XmlMapName, ShorthandLogFile);
MissingParams.Remove(XmlMapName);
ParseLogFile(mapFileName);
}
else if (ar.StartsWith(ArgumentParser.Padding, StringComparison.OrdinalIgnoreCase) || ar.StartsWith(ShorthandPadding, StringComparison.OrdinalIgnoreCase))
{
// Padding parsing
var padding = ParseParameterValueFromArg(ar, ArgumentParser.Padding, ShorthandPadding);
MissingParams.Remove(ArgumentParser.Padding);
ParsePaddingValue(padding);
}
else if (ar.StartsWith(Dedup, StringComparison.OrdinalIgnoreCase) || ar.StartsWith(ShorthandDedup, StringComparison.OrdinalIgnoreCase))
{
// Dedup parsing
var dedup = ParseParameterValueFromArg(ar, ArgumentParser.Dedup, ShorthandDedup);
MissingParams.Remove(ArgumentParser.Dedup);
ParseDedupValue(dedup);
}
else if (ar.StartsWith(Question, StringComparison.OrdinalIgnoreCase) || ar.StartsWith(Help, StringComparison.OrdinalIgnoreCase))
{
continue;
}
else
{
// unknown input parameter
var paramName = ar.Substring(0, ar.IndexOf(":", StringComparison.OrdinalIgnoreCase) + 1);
throw new ImageAssembleException(string.Format(CultureInfo.CurrentUICulture, ImageAssembleStrings.InvalidInputParameterMessage, paramName));
}
}
// Check missing parameters
CheckMissingParameters(usage);
}
}
