/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the string mapped to the type for the converter.
/// </summary>
/// <param name="type">The type of the encoder, e.g. CC table.</param>
/// <returns>string for the combobox, or string.empty if type not found</returns>
/// ------------------------------------------------------------------------------------
private string GetConverterStringForType(ConverterType type)
{
for (int iConverter = 0; iConverter < cboConverter.Items.Count; iConverter++)
{
if (((CnvtrTypeComboItem)cboConverter.Items[iConverter]).Type == type)
return ((CnvtrTypeComboItem)cboConverter.Items[iConverter]).ImplementType;
}
return string.Empty;
}
public void SetConverter(Type type, ConverterType converter)
{
if (converter == null)
{
if (_converters.ContainsKey(type))
_converters.Remove(type);
}
else
{
_converters[type] = converter;
switch (type.GetTypeCodeEx())
{
case TypeCode.Boolean : _booleanConverter = converter; return;
case TypeCode.Char : _charConverter = converter; return;
case TypeCode.SByte : _sByteConverter = converter; return;
case TypeCode.Byte : _byteConverter = converter; return;
case TypeCode.Int16 : _int16Converter = converter; return;
case TypeCode.UInt16 : _uInt16Converter = converter; return;
case TypeCode.Int32 : _int32Converter = converter; return;
case TypeCode.UInt32 : _uInt32Converter = converter; return;
case TypeCode.Int64 : _int64Converter = converter; return;
case TypeCode.UInt64 : _uInt64Converter = converter; return;
case TypeCode.Single : _singleConverter = converter; return;
case TypeCode.Double : _doubleConverter = converter; return;
case TypeCode.Decimal : _decimalConverter = converter; return;
case TypeCode.DateTime : _dateTimeConverter = converter; return;
case TypeCode.String : _stringConverter = converter; return;
}
}
}
public IntPtr src_new(ConverterType converter_type, int channels, out int error)
{
return(Interop64.src_new(converter_type, channels, out error));
}
private void button1_Click(object sender, EventArgs e)
{
err.Clear();
bool valid = true;
if (string.IsNullOrWhiteSpace(txtSource.Text))
{
err.SetError(txtSource, "不可空白");
valid = false;
}
if (string.IsNullOrWhiteSpace(cboTarget.Text))
{
err.SetError(cboTarget, "不可空白");
valid = false;
}
if (cboSourceType.Text == SourceType.Variable.ToString())
{
bool contains = false;
foreach (IVariable v in _service.Variables)
{
if (v.Name == txtSource.Text)
{
contains = true;
break;
}
}
if (!contains)
{
foreach (Preprocess p in _service.Preprocesses)
{
if (p.Type == PreprocessType.Variable && p.Name == txtSource.Text)
{
contains = true;
break;
}
}
}
if (!contains)
{
err.SetError(txtSource, "InternalVariable 中不包含此變數");
valid = false;
}
}
if (!valid)
{
return;
}
if (Completed == null)
{
this.Close();
return;
}
Field field = new Field();
field.Alias = txtAlias.Text;
field.AutoNumber = chkAutoNumber.Checked;
field.InputConverter = ConverterType.Parse(cboInputConverter.Text);
field.OutputConverter = ConverterType.Parse(cboOutputConverter.Text);
field.Mandatory = chkMandatory.Checked;
field.Quote = chkQuote.Checked;
field.Required = chkRequired.Checked;
field.Source = txtSource.Text;
field.Target = cboTarget.Text;
IOType itype = IOType.Element;
if (!Enum.TryParse <IOType>(cboInputType.Text, true, out itype))
{
itype = IOType.Element;
}
field.InputType = itype;
IOType otype = IOType.Element;
if (!Enum.TryParse <IOType>(cboOutputType.Text, true, out otype))
{
otype = IOType.Element;
}
field.OutputType = otype;
SourceType stype = SourceType.Request;
if (!Enum.TryParse <SourceType>(cboSourceType.Text, true, out stype))
{
stype = SourceType.Request;
}
field.SourceType = stype;
Completed.Invoke(this, new FieldEventArgs(field));
this.Close();
}
/// <summary></summary>
public CnvtrTypeComboItem(string name, ConverterType type, string implementType)
{
m_itemName = name;
m_type = type;
m_implementType = implementType;
}
/// <summary></summary>
public CnvtrTypeComboItem(string name, ConverterType type, string implementType)
{
m_itemName = name;
m_type = type;
m_implementType = implementType;
}
public bool TryConvert(StringBuilder stringBuilder, ISqlDataType dataType, object value)
{
if (value == null)
{
stringBuilder.Append("NULL");
return(true);
}
var type = value.GetType();
ConverterType converter = null;
if (_converters.Count > 0 && !type.IsEnumEx())
{
switch (type.GetTypeCodeEx())
{
case TypeCode.DBNull:
stringBuilder.Append("NULL");
return(true);
case TypeCode.Boolean:
converter = _booleanConverter;
break;
case TypeCode.Char:
converter = _charConverter;
break;
case TypeCode.SByte:
converter = _sByteConverter;
break;
case TypeCode.Byte:
converter = _byteConverter;
break;
case TypeCode.Int16:
converter = _int16Converter;
break;
case TypeCode.UInt16:
converter = _uInt16Converter;
break;
case TypeCode.Int32:
converter = _int32Converter;
break;
case TypeCode.UInt32:
converter = _uInt32Converter;
break;
case TypeCode.Int64:
converter = _int64Converter;
break;
case TypeCode.UInt64:
converter = _uInt64Converter;
break;
case TypeCode.Single:
converter = _singleConverter;
break;
case TypeCode.Double:
converter = _doubleConverter;
break;
case TypeCode.Decimal:
converter = _decimalConverter;
break;
case TypeCode.DateTime:
converter = _dateTimeConverter;
break;
case TypeCode.String:
converter = _stringConverter;
break;
default:
_converters.TryGetValue(type, out converter);
break;
}
}
if (converter != null)
{
converter(stringBuilder, dataType, value);
return(true);
}
if (_baseConverters.Length > 0)
{
foreach (var valueConverter in _baseConverters)
{
if (valueConverter.TryConvert(stringBuilder, dataType, value))
{
return(true);
}
}
}
return(false);
}
/// --------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="T:EncoderInfo"/> class.
/// </summary>
/// <param name="name">The name of the encoding converter.</param>
/// <param name="method">The method, e.g. CC table, TecKit, etc.</param>
/// <param name="fileName">Name of the file containing the conversion table, etc.</param>
/// <param name="fromToType">Type of conversion, e.g. from legacy to Unicode.</param>
/// --------------------------------------------------------------------------------
public EncoderInfo(string name, ConverterType method, string fileName, ConvType fromToType)
{
m_name = name;
m_method = method;
m_fileName = fileName;
m_fromToType = fromToType;
}
static void Main()
{
Console.WriteLine(@"Создайте папку D:\\Pictures, сохраните в ней тестовое изображение.
В этой же папке будут сохранены изображения, соответствующие множествам уровня");
Console.WriteLine("\nВведите имя файла, например, 1.jpg");
Console.WriteLine(@"Если вы хотите использовать другой путь, введите его целиком в формате
C:\test\image1.jpg");
Console.WriteLine();
string input = Console.ReadLine();
if (input.Contains(":"))
{
imagePath = Path.GetDirectoryName(input);
}
string path = Path.Combine(imagePath, input);
Console.WriteLine("Введите номер желаемого алгоритма обработки изображения:");
Console.WriteLine("1) монохромное изображение");
Console.WriteLine("2) красная компонента RGB");
Console.WriteLine("3) зелёная компонента RGB");
Console.WriteLine("4) синяя компонента RGB");
Console.WriteLine("5) компонента Hue палитры HSV");
Console.WriteLine();
int converterNumber;
int.TryParse(Console.ReadLine(), out converterNumber);
ConverterType converterType = (ConverterType)(converterNumber - 1);
int directoryNumber = GetDirectoryNumber(imagePath);
LayersDirectoryPath = Path.Combine(imagePath, "Layers ") + directoryNumber.ToString();
Directory.CreateDirectory(LayersDirectoryPath);
var spectrumBuilder = new SpectrumBuilder();
var layersBuilder = new LayersBuilder();
//Вычисление показателей сингулярности
DateTime before = DateTime.Now;
var image_before = (Bitmap)Image.FromFile(path);
var image = ImageConverter.ConvertBitmap(image_before, converterType);
Console.WriteLine("\nВычисляются показатели сингулярности...");
var singularityBounds = layersBuilder.GetSingularityBounds(image, converterType);
DateTime after = DateTime.Now;
TimeSpan firstPeriod = after - before;
Console.WriteLine($"Время вычисления показателей {firstPeriod.ToString()}");
Console.WriteLine("Minimal singularity: {0:0.00}", singularityBounds.Begin);
Console.WriteLine("Maximal singularity: {0:0.00}", singularityBounds.End);
Console.WriteLine("\nВведите шаг между уровнями, например, 0,2");
double singulatityStep = double.Parse(Console.ReadLine());
//Вычисление множеств уровня
Console.WriteLine("\nВычисляются множества уровня...");
before = DateTime.Now;
var layers = layersBuilder.SplitByLayers(singularityBounds, singulatityStep);
after = DateTime.Now;
TimeSpan secondPeriod = after - before;
Console.WriteLine($"Время определения уровней {secondPeriod.ToString()}");
//Вычисление спектра
Console.WriteLine("\nВычисляется мультифрактальный спектр...");
before = DateTime.Now;
var spectrum = spectrumBuilder.CalculateSpectrum(image, layers, singularityBounds, singulatityStep);
after = DateTime.Now;
TimeSpan thirdPeriod = after - before;
Console.WriteLine($"Время вычисления спектра {thirdPeriod.ToString()}");
Console.WriteLine("\nМножества уровня построены");
Console.WriteLine("Номер папки с множествами уровня : {0}", directoryNumber);
Console.WriteLine("Мультифрактальный спектр вычислен и находится в файле spectrum.txt");
//Сохранение спектра в текстовый файл
string actualSpectrumPath = Path.Combine(LayersDirectoryPath, spectrumFileName);
using (StreamWriter sw = new StreamWriter(actualSpectrumPath, true))
{
sw.WriteLine("*********************");
var outputInfo = new StringBuilder();
foreach (var layerInfo in spectrum)
{
outputInfo.Append(string.Format("{0:0.00 }", layerInfo.Key));
outputInfo.Append(string.Format("{0:0.00}\r\n", layerInfo.Value));
}
sw.WriteLine(outputInfo);
sw.Close();
}
Console.WriteLine($"Общее время работы программы {firstPeriod.Add(secondPeriod).Add(thirdPeriod).ToString()}");
Console.WriteLine("\nЖелаем вам всего доброго!");
Console.ReadKey();
}
bool TryConvertImpl(StringBuilder stringBuilder, SqlDataType dataType, object value, bool tryBase)
{
if (value == null
#if !SILVERLIGHT && !NETFX_CORE
|| (value is INullable && ((INullable)value).IsNull)
#endif
)
{
stringBuilder.Append("NULL");
return(true);
}
var type = value.GetType();
ConverterType converter = null;
if (_converters.Count > 0 && !type.IsEnumEx())
{
switch (type.GetTypeCodeEx())
{
#if NETSTANDARD
case (TypeCode)2: stringBuilder.Append("NULL"); return(true);
#else
case TypeCode.DBNull: stringBuilder.Append("NULL"); return(true);
#endif
case TypeCode.Boolean: converter = _booleanConverter; break;
case TypeCode.Char: converter = _charConverter; break;
case TypeCode.SByte: converter = _sByteConverter; break;
case TypeCode.Byte: converter = _byteConverter; break;
case TypeCode.Int16: converter = _int16Converter; break;
case TypeCode.UInt16: converter = _uInt16Converter; break;
case TypeCode.Int32: converter = _int32Converter; break;
case TypeCode.UInt32: converter = _uInt32Converter; break;
case TypeCode.Int64: converter = _int64Converter; break;
case TypeCode.UInt64: converter = _uInt64Converter; break;
case TypeCode.Single: converter = _singleConverter; break;
case TypeCode.Double: converter = _doubleConverter; break;
case TypeCode.Decimal: converter = _decimalConverter; break;
case TypeCode.DateTime: converter = _dateTimeConverter; break;
case TypeCode.String: converter = _stringConverter; break;
default: _converters.TryGetValue(type, out converter); break;
}
}
if (converter != null)
{
converter(stringBuilder, dataType, value);
return(true);
}
if (tryBase && BaseConverters.Length > 0)
{
foreach (var valueConverter in BaseConverters)
{
if (valueConverter.TryConvertImpl(stringBuilder, dataType, value, false))
{
return(true);
}
}
}
/*
* var ar = new AttributeReader();
* var udtAttr = ar.GetAttributes<Microsoft.SqlServer.Server.SqlUserDefinedTypeAttribute>(type);
*
* if (udtAttr.Length > 0 && udtAttr[0].Format == Microsoft.SqlServer.Server.Format.UserDefined)
* {
* SetConverter(type, (sb,dt,v) => BuildString(sb, v.ToString()));
* return TryConvertImpl(stringBuilder, dataType, value, tryBase);
* }
*/
return(false);
}
public FileBuilder(ConverterType conversionType)
{
this.Path = SetNewFilePath(conversionType);
SetFileConverter(conversionType);
}
public static IConverter Get(ConverterType converterType)
{
return(ConverterFactory.TypeMapping[converterType]);
}
private void Converter(TextBox control, ConverterType converterType)
{
InputAudioFiles = null;
txtOgg2FixHdr.Text = String.Empty;
txtWwiseConvert.Text = String.Empty;
txtWwise2Ogg.Text = String.Empty;
txtAudio2Wem.Text = String.Empty;
using (var fd = new OpenFileDialog())
{
fd.Multiselect = true;
fd.Filter = "Wwise 2010.3.3 OGG files (*.ogg)|*.ogg";
if (converterType == ConverterType.Revorb || converterType == ConverterType.WEM)
{
fd.Filter += "|Wwise 2013 WEM files (*.wem)|*.wem";
}
else if (converterType == ConverterType.Ogg2Wem)
{
fd.Filter = "Vorbis Ogg or Wave files (*.ogg, *.wav)|*.ogg; *.wav";
}
fd.ShowDialog();
if (!fd.FileNames.Any())
{
return;
}
InputAudioFiles = fd.FileNames;
Dictionary <string, string> errorFiles = new Dictionary <string, string>();
List <string> successFiles = new List <string>();
foreach (var file in InputAudioFiles)
{
try
{
var extension = Path.GetExtension(file);
var outputFileName = Path.Combine(Path.GetDirectoryName(file), String.Format("{0}_fixed{1}", Path.GetFileNameWithoutExtension(file), ".ogg"));
switch (converterType)
{
case ConverterType.HeaderFix:
txtOgg2FixHdr.Text = file;
using (FileStream fl = File.Create(outputFileName))
OggFile.ConvertOgg(file).CopyTo(fl);
break;
case ConverterType.Revorb:
txtWwise2Ogg.Text = file;
OggFile.Revorb(file, outputFileName, Path.GetDirectoryName(Application.ExecutablePath), (extension == ".ogg") ? OggFile.WwiseVersion.Wwise2010 : OggFile.WwiseVersion.Wwise2013);
break;
case ConverterType.WEM:
txtWwiseConvert.Text = file;
outputFileName = Path.ChangeExtension(outputFileName, Path.GetExtension(file));
OggFile.ConvertAudioPlatform(file, outputFileName);
break;
case ConverterType.Ogg2Wem:
txtAudio2Wem.Text = file;
OggFile.Convert2Wem(file, (int)audioQualityBox.Value, (long)Convert.ToDouble(lblChorusTime.Text) * 1000);
break;
}
successFiles.Add(file);
}
catch (Exception ex)
{
errorFiles.Add(file, ex.Message);
}
}
if (errorFiles.Count <= 0 && successFiles.Count > 0)
{
MessageBox.Show("Conversion complete!", MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else if (errorFiles.Count > 0 && successFiles.Count > 0)
{
StringBuilder alertMessage = new StringBuilder(
"Conversion complete with errors." + Environment.NewLine + Environment.NewLine);
alertMessage.AppendLine(
"Files converted with success:" + Environment.NewLine);
foreach (var sFile in successFiles)
{
alertMessage.AppendLine(String.Format("File: {0}", sFile));
}
alertMessage.AppendLine("Files converted with error:" + Environment.NewLine);
foreach (var eFile in errorFiles)
{
alertMessage.AppendLine(String.Format("File: {0}; error: {1}", eFile.Key, eFile.Value));
}
MessageBox.Show(alertMessage.ToString(), MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
StringBuilder alertMessage = new StringBuilder(
"Conversion complete with errors." + Environment.NewLine);
alertMessage.AppendLine(
"Files converted with error: " + Environment.NewLine);
foreach (var eFile in errorFiles)
{
alertMessage.AppendLine(String.Format("File: {0}, error: {1}", eFile.Key, eFile.Value));
}
MessageBox.Show(alertMessage.ToString(), MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Helper method to enable us to set cboConverter for testing purposes
/// </summary>
/// <param name="setTo">Type that we are setting the Converter Type combo to</param>
/// ------------------------------------------------------------------------------------
public void setCboConverter(ConverterType setTo)
{
for (int i = 0; i < cboConverter.Items.Count; i++)
{
if (((CnvtrTypeComboItem)cboConverter.Items[i]).Type == setTo)
{
cboConverter.SelectedIndex = i;
break;
}
else
cboConverter.SelectedIndex = 0;
}
}
public void SetConverter(Type type, ConverterType converter)
{
if (converter == null)
{
if (_converters.ContainsKey(type))
{
_converters.Remove(type);
}
}
else
{
_converters[type] = converter;
switch (type.GetTypeCodeEx())
{
case TypeCode.Boolean:
_booleanConverter = converter;
return;
case TypeCode.Char:
_charConverter = converter;
return;
case TypeCode.SByte:
_sByteConverter = converter;
return;
case TypeCode.Byte:
_byteConverter = converter;
return;
case TypeCode.Int16:
_int16Converter = converter;
return;
case TypeCode.UInt16:
_uInt16Converter = converter;
return;
case TypeCode.Int32:
_int32Converter = converter;
return;
case TypeCode.UInt32:
_uInt32Converter = converter;
return;
case TypeCode.Int64:
_int64Converter = converter;
return;
case TypeCode.UInt64:
_uInt64Converter = converter;
return;
case TypeCode.Single:
_singleConverter = converter;
return;
case TypeCode.Double:
_doubleConverter = converter;
return;
case TypeCode.Decimal:
_decimalConverter = converter;
return;
case TypeCode.DateTime:
_dateTimeConverter = converter;
return;
case TypeCode.String:
_stringConverter = converter;
return;
}
}
}
private void Converter(TextBox control, ConverterType converterType)
{
InputOggFiles = null;
using (var fd = new OpenFileDialog()) {
fd.Filter = "Wwise 2010.3.3 OGG files|*.ogg";
fd.Multiselect = true;
fd.ShowDialog();
if (fd.FileNames.Count() <= 0) {
MessageBox.Show("The selected directory has no .ogg file inside!", MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
string path = Path.GetDirectoryName(fd.FileName);
switch (converterType) {
case ConverterType.HeaderFix:
inputOggTextBox.Text = path;
break;
case ConverterType.Revorb:
inputOggRocksmithTextBox.Text = path;
break;
}
InputOggFiles = fd.FileNames;
Dictionary<string, string> errorFiles = new Dictionary<string, string>();
List<string> successFiles = new List<string>();
foreach (var file in InputOggFiles) {
try {
var outputFileName = Path.Combine(Path.GetDirectoryName(file), String.Format("{0}_fixed{1}", Path.GetFileNameWithoutExtension(file), Path.GetExtension(file)));
switch (converterType) {
case ConverterType.HeaderFix:
OggFile.ConvertOgg(file, outputFileName);
break;
case ConverterType.Revorb:
OggFile.Revorb(file, outputFileName, Path.GetDirectoryName(Application.ExecutablePath));
break;
}
successFiles.Add(file);
} catch (Exception ex) {
errorFiles.Add(file, ex.Message);
}
}
if (errorFiles.Count <= 0 && successFiles.Count > 0)
MessageBox.Show("Conversion complete!", MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Information);
else if (errorFiles.Count > 0 && successFiles.Count > 0) {
StringBuilder alertMessage = new StringBuilder("Conversion complete with errors." + Environment.NewLine + Environment.NewLine);
alertMessage.AppendLine("Files converted with success:" + Environment.NewLine);
foreach (var sFile in successFiles)
alertMessage.AppendLine(String.Format("File: {0}", sFile));
alertMessage.AppendLine("Files converted with error:" + Environment.NewLine);
foreach (var eFile in errorFiles)
alertMessage.AppendLine(String.Format("File: {0}; error: {1}", eFile.Key, eFile.Value));
MessageBox.Show(alertMessage.ToString(), MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Warning);
} else {
StringBuilder alertMessage = new StringBuilder("Conversion complete with errors." + Environment.NewLine);
alertMessage.AppendLine("Files converted with error: " + Environment.NewLine);
foreach (var eFile in errorFiles)
alertMessage.AppendLine(String.Format("File: {0}, error: {1}", eFile.Key, eFile.Value));
MessageBox.Show(alertMessage.ToString(), MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="converterType">specific convert type </param>
/// <returns>return the specific converter factory </returns>
public CurrencyManager Export(ConverterType converterType)
{
_exporter = new ConverterFactory().GetConverterInstance(converterType);
_exportableString = _exporter.Export(Data.ToList());
return(this);
}
private void Converter(TextBox control, ConverterType converterType)
{
InputAudioFiles = null;
txtOgg2FixHdr.Text = String.Empty;
txtWwiseConvert.Text = String.Empty;
txtWwise2Ogg.Text = String.Empty;
txtAudio2Wem.Text = String.Empty;
using (var fd = new OpenFileDialog())
{
fd.Multiselect = true;
fd.Filter = "Wwise 2010.3.3 OGG files (*.ogg)|*.ogg";
if (converterType == ConverterType.Revorb || converterType == ConverterType.WEM)
fd.Filter += "|Wwise 2013 WEM files (*.wem)|*.wem";
else if (converterType == ConverterType.Ogg2Wem)
fd.Filter = "Vorbis Ogg or Wave files (*.ogg, *.wav)|*.ogg; *.wav";
fd.ShowDialog();
if (!fd.FileNames.Any())
return;
InputAudioFiles = fd.FileNames;
Dictionary<string, string> errorFiles = new Dictionary<string, string>();
List<string> successFiles = new List<string>();
foreach (var file in InputAudioFiles)
{
try
{
var extension = Path.GetExtension(file);
var outputFileName = Path.Combine(Path.GetDirectoryName(file), String.Format("{0}_fixed{1}", Path.GetFileNameWithoutExtension(file), ".ogg"));
switch (converterType)
{
case ConverterType.HeaderFix:
txtOgg2FixHdr.Text = file;
using (FileStream fl = File.Create(outputFileName))
OggFile.ConvertOgg(file).CopyTo(fl);
break;
case ConverterType.Revorb:
txtWwise2Ogg.Text = file;
OggFile.Revorb(file, outputFileName, Path.GetDirectoryName(Application.ExecutablePath), (extension == ".ogg") ? OggFile.WwiseVersion.Wwise2010 : OggFile.WwiseVersion.Wwise2013);
break;
case ConverterType.WEM:
txtWwiseConvert.Text = file;
outputFileName = Path.ChangeExtension(outputFileName, Path.GetExtension(file));
OggFile.ConvertAudioPlatform(file, outputFileName);
break;
case ConverterType.Ogg2Wem:
txtAudio2Wem.Text = file;
OggFile.Convert2Wem(file, (int)audioQualityBox.Value, (long)Convert.ToDouble(lblChorusTime.Text) * 1000);
break;
}
successFiles.Add(file);
}
catch (Exception ex)
{
errorFiles.Add(file, ex.Message);
}
}
if (errorFiles.Count <= 0 && successFiles.Count > 0)
MessageBox.Show("Conversion complete!", MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Information);
else if (errorFiles.Count > 0 && successFiles.Count > 0)
{
StringBuilder alertMessage = new StringBuilder(
"Conversion complete with errors." + Environment.NewLine + Environment.NewLine);
alertMessage.AppendLine(
"Files converted with success:" + Environment.NewLine);
foreach (var sFile in successFiles)
alertMessage.AppendLine(String.Format("File: {0}", sFile));
alertMessage.AppendLine("Files converted with error:" + Environment.NewLine);
foreach (var eFile in errorFiles)
alertMessage.AppendLine(String.Format("File: {0}; error: {1}", eFile.Key, eFile.Value));
MessageBox.Show(alertMessage.ToString(), MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
StringBuilder alertMessage = new StringBuilder(
"Conversion complete with errors." + Environment.NewLine);
alertMessage.AppendLine(
"Files converted with error: " + Environment.NewLine);
foreach (var eFile in errorFiles)
alertMessage.AppendLine(String.Format("File: {0}, error: {1}", eFile.Key, eFile.Value));
MessageBox.Show(alertMessage.ToString(), MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
public static extern IntPtr src_new(ConverterType converter_type, int channels, out int error);
// This is a positional argument
public PositionAttribute()
{
DescResourceName = string.Empty;
DesiredIndex = 0;
Desc = string.Empty;
PutToRight = false;
ControlType = typeof(TextBox);
ColSpan = 1;
_convType = Model.ConverterType.String;
_checkBoxValues = "Y|N";
CreateConverter();
ListerName = string.Empty;
OnlyFromList = false;
}
public static IEnumerable <MultipartFormParameter> ApiParameter(ConverterType from, ConverterType to, string template, string csl)
{
if (from != ConverterType.Undefined)
{
yield return(CreateField("from", from.ToString().ToLower()));
yield return(CreateField("ext", from.GetExtension()));
}
if (to != ConverterType.Undefined)
{
yield return(CreateField("to", to.ToString().ToLower()));
}
if (!string.IsNullOrWhiteSpace(template))
{
yield return(CreateField("template", template));
}
if (!string.IsNullOrWhiteSpace(csl))
{
yield return(CreateField("csl", csl));
}
}
