/// <summary>
/// Save a LoggerRoot object to the filesystem
/// </summary>
/// <param name="filePath">The path where the LoggerRoot object should be stored</param>
/// <param name="root">The LoggerRoot object that should be saved</param>
/// <param name="saveFormat">The format in which the LoggerRoot object should be stored</param>
internal static void SaveLoggerRoot(string filePath, LoggerRoot root, SaveFormats saveFormat)
{
if (string.IsNullOrEmpty(filePath))
{
throw new ArgumentException(nameof(filePath));
}
if (root == null)
{
throw new ArgumentNullException(nameof(root));
}
switch (saveFormat)
{
case SaveFormats.Xml:
SaveLoggerRootXml(filePath, root);
break;
case SaveFormats.Json:
SaveLoggerRootJson(filePath, root);
break;
default:
throw new ArgumentOutOfRangeException(nameof(saveFormat), saveFormat, null);
}
}
/// <summary>
/// Save Logger objects to a configuration file asynchronously
/// </summary>
/// <param name="filePath">The path where the configuration file should be stored</param>
/// <param name="saveFormat">The format in which the configuration data should be stored</param>
/// <returns>The Task object that is associated with this asynchronous method</returns>
public static async Task SaveConfigurationAsync(string filePath, SaveFormats saveFormat)
{
LoggerRoot root = new LoggerRoot {
Loggers = Loggers
};
await ConfigurationManager.SaveLoggerRootAsync(filePath, root, saveFormat);
}
/// <summary>
/// Save Logger objects to a configuration file
/// </summary>
/// <param name="filePath">The path where the configuration file should be stored</param>
/// <param name="saveFormat">The format in which the configuration data should be stored</param>
public static void SaveConfiguration(string filePath, SaveFormats saveFormat)
{
LoggerRoot root = new LoggerRoot {
Loggers = Loggers
};
ConfigurationManager.SaveLoggerRoot(filePath, root, saveFormat);
}
private void SaveModel(IModelSaver modelSaver, SaveFormats format)
{
if (SavingInProgress)
{
return;
}
SavingInProgress = true;
NotifyPropertyChanged("SavingInProgress");
BackgroundWorker SaveWorker = new BackgroundWorker();
SaveWorker.DoWork += SaveWorker_DoWork;
SaveWorker.RunWorkerCompleted += SaveWorker_RunWorkerCompleted;
SaveWorker.RunWorkerAsync(new SaveTask(modelSaver, GenerateFilename(), format));
ShowStatus(GreenResources.StatusSaveInProgress, true);
}
public void SaveTo(string fileName, SaveFormats format, Sheet sheet)
{
using (System.IO.StreamWriter wr = new System.IO.StreamWriter(new System.IO.FileStream(fileName, System.IO.FileMode.Create)))
{
switch (format)
{
case SaveFormats.ExcelXml:
wr.Write(this.ToExcelXml(sheet));
break;
case SaveFormats.Html:
wr.Write(this.ToHtml(sheet));
break;
}
wr.Close();
}
}
public void SaveTo(string fileName, SaveFormats format, Sheet sheet)
{
using (var wr = new System.IO.StreamWriter(new System.IO.FileStream(fileName, System.IO.FileMode.Create)))
{
switch (format)
{
case SaveFormats.Excel:
this.ToExcel(wr, sheet);
break;
case SaveFormats.Html:
this.ToHtml(wr, sheet);
break;
}
wr.Close();
}
}
protected virtual string SaveFile(string file)
{
if (this.p != null)
{
string text = Directory.GetCurrentDirectory() + @"\FileName.txt";
var fileStream = new FileStream(text, FileMode.Open, FileAccess.Read);
using (var streamReader = new StreamReader(fileStream, Encoding.UTF8))
{
text = streamReader.ReadToEnd();
}
tempDirectory = Path.Combine(Path.GetTempPath(), "~Njit");
try
{
if (!System.IO.Directory.Exists(tempDirectory))
{
System.IO.Directory.CreateDirectory(tempDirectory);
}
}
catch (Exception ex)
{
MessageBox.Show(this, "خطا در دسترسی به مسیر ذخیره فایل ها" + "\r\n\r\n" + ex.Message);
}
this.SelectedFolderForSaveFiles = text + "\\" + this.p;
SelectedSaveFormat = SaveFormats.JPEG;
string fileExtension = Path.GetExtension(file).ToLower();
if (imageExtensions.Contains(fileExtension))
{
switch (SelectedSaveFormat)
{
case SaveFormats.None:
break;
case SaveFormats.JPEG:
if (fileExtension != ".jpg" && fileExtension != ".jpeg")
{
fileExtension = ".jpg";
string newfile = GetUniqFileName(fileExtension);
Image image = Image.FromFile(file);
ImageHelper.ConvertImage(image, System.Drawing.Imaging.ImageFormat.Jpeg, 0, newfile);
image.Dispose();
file = newfile;
}
break;
case SaveFormats.PNG:
if (fileExtension != ".png")
{
fileExtension = ".png";
string newfile = GetUniqFileName(fileExtension);
Image image = Image.FromFile(file);
ImageHelper.ConvertImage(image, System.Drawing.Imaging.ImageFormat.Png, 0, newfile);
image.Dispose();
file = newfile;
}
break;
case SaveFormats.BMP:
if (fileExtension != ".bmp")
{
fileExtension = ".bmp";
string newfile = GetUniqFileName(fileExtension);
Image image = Image.FromFile(file);
ImageHelper.ConvertImage(image, System.Drawing.Imaging.ImageFormat.Bmp, 0, newfile);
image.Dispose();
file = newfile;
}
break;
default:
throw new Exception();
}
}
string fileName = System.IO.Path.GetFileNameWithoutExtension(file) + fileExtension; //Njit.Common.PersianCalendar.GetDate(DateTime.Now, "-") + " " + Njit.Common.PersianCalendar.GetTime(DateTime.Now, "-", true, true) + fileExtension;
string destinationFile = null;
destinationFile = Path.Combine(this.SelectedFolderForSaveFiles, fileName);
int i = 1;
while (System.IO.File.Exists(destinationFile))
{
fileName = System.IO.Path.GetFileNameWithoutExtension(file) + " (" + i.ToString() + ")" + fileExtension;//Njit.Common.PersianCalendar.GetDate(DateTime.Now, "-") + " " + Njit.Common.PersianCalendar.GetTime(DateTime.Now, "-", true, true) + fileExtension;
destinationFile = Path.Combine(this.SelectedFolderForSaveFiles, fileName);
i++;
}
FileStream serverFileStream = null;
FileStream clientFileStream = null;
try
{
if (!System.IO.Directory.Exists(this.SelectedFolderForSaveFiles))
{
System.IO.Directory.CreateDirectory(this.SelectedFolderForSaveFiles);
}
serverFileStream = System.IO.File.Create(destinationFile);
clientFileStream = System.IO.File.OpenRead(file);
byte[] buffre = new byte[1 * 1024 * 1024];
int readCount = 0;
do
{
readCount = clientFileStream.Read(buffre, 0, buffre.Length);
serverFileStream.Write(buffre, 0, readCount);
}while (readCount > 0);
clientFileStream.Close();
serverFileStream.Close();
clientFileStream.Dispose();
serverFileStream.Dispose();
return(destinationFile);
}
catch (Exception ex)
{
if (clientFileStream != null)
{
clientFileStream.Dispose();
}
if (serverFileStream != null)
{
serverFileStream.Dispose();
}
throw new Exception("خطا در ذخیره فایل" + "\r\n" + file + "\r\n\r\n" + ex.Message);
}
}
else
{
MessageBox.Show("پرونده ای که می خواهید سند به آن اضافه کنید را مشخص کنید");
return("");
}
}
public SaveTask(IModelSaver modelSaver, string filename, SaveFormats format)
{
ModelSaver = modelSaver;
Filename = filename;
Format = format;
}
public void SaveTo(string fileName, SaveFormats format)
{
SaveTo(fileName, format, null);
}
private static ColorBgra LinearColorToBgra(SaveFormats.LinearColor linearColor)
{
return LinearColorToBgra(
linearColor.R,
linearColor.G,
linearColor.B,
linearColor.A);
}
private static void ApplyAppearancePreset(SaveFormats.MorphHead morphHead,
AppearancePreset preset)
{
if (morphHead == null)
{
throw new ArgumentNullException("morphHead");
}
if (preset == null)
{
throw new ArgumentNullException("preset");
}
if (string.IsNullOrEmpty(preset.HairMesh) == false)
{
morphHead.HairMesh = preset.HairMesh;
}
if (preset.Scalars != null)
{
if (preset.Scalars.Clear == true)
{
morphHead.ScalarParameters.Clear();
}
if (preset.Scalars.Remove != null)
{
foreach (var scalar in preset.Scalars.Remove)
{
morphHead.ScalarParameters.RemoveAll(
p => string.Compare(p.Name, scalar, StringComparison.InvariantCultureIgnoreCase) == 0);
}
}
if (preset.Scalars.Add != null)
{
foreach (var scalar in preset.Scalars.Add)
{
morphHead.ScalarParameters.Add(
new SaveFormats.MorphHead.ScalarParameter()
{
Name = scalar.Key,
Value = scalar.Value,
});
}
}
if (preset.Scalars.Set != null)
{
foreach (var scalar in preset.Scalars.Set)
{
morphHead.ScalarParameters.RemoveAll(
p => string.Compare(p.Name, scalar.Key, StringComparison.InvariantCultureIgnoreCase) == 0);
morphHead.ScalarParameters.Add(
new SaveFormats.MorphHead.ScalarParameter()
{
Name = scalar.Key,
Value = scalar.Value,
});
}
}
}
if (preset.Textures != null)
{
if (preset.Textures.Clear == true)
{
morphHead.TextureParameters.Clear();
}
if (preset.Textures.Remove != null)
{
foreach (var texture in preset.Textures.Remove)
{
morphHead.TextureParameters.RemoveAll(
p => string.Compare(p.Name, texture, StringComparison.InvariantCultureIgnoreCase) == 0);
}
}
if (preset.Textures.Add != null)
{
foreach (var texture in preset.Textures.Add)
{
morphHead.TextureParameters.Add(
new SaveFormats.MorphHead.TextureParameter()
{
Name = texture.Key,
Value = texture.Value,
});
}
}
if (preset.Textures.Set != null)
{
foreach (var texture in preset.Textures.Set)
{
morphHead.TextureParameters.RemoveAll(
p => string.Compare(p.Name, texture.Key, StringComparison.InvariantCultureIgnoreCase) == 0);
morphHead.TextureParameters.Add(
new SaveFormats.MorphHead.TextureParameter()
{
Name = texture.Key,
Value = texture.Value,
});
}
}
}
if (preset.Vectors != null)
{
if (preset.Vectors.Clear == true)
{
morphHead.VectorParameters.Clear();
}
if (preset.Vectors.Remove != null)
{
foreach (var vector in preset.Vectors.Remove)
{
string temp = vector;
morphHead.VectorParameters.RemoveAll(
p => string.Compare(p.Name, temp, StringComparison.InvariantCultureIgnoreCase) == 0);
}
}
if (preset.Vectors.Add != null)
{
foreach (var vector in preset.Vectors.Add)
{
morphHead.VectorParameters.Add(
new SaveFormats.MorphHead.VectorParameter()
{
Name = vector.Key,
Value = new SaveFormats.LinearColor()
{
R = vector.Value.R,
G = vector.Value.G,
B = vector.Value.B,
A = vector.Value.A,
},
});
}
}
if (preset.Vectors.Set != null)
{
foreach (var vector in preset.Vectors.Set)
{
var temp = vector;
morphHead.VectorParameters.RemoveAll(
p => string.Compare(p.Name, temp.Key, StringComparison.InvariantCultureIgnoreCase) == 0);
morphHead.VectorParameters.Add(
new SaveFormats.MorphHead.VectorParameter()
{
Name = vector.Key,
Value = new SaveFormats.LinearColor()
{
R = vector.Value.R,
G = vector.Value.G,
B = vector.Value.B,
A = vector.Value.A,
},
});
}
}
}
}
public void SaveTo(string fileName, SaveFormats format)
{
SaveTo(fileName, format, null);
}
public PlayerNotoriety(SaveFormats.NotorietyType type, string name)
{
this.Type = type;
this.Name = name;
}
// ReSharper restore UnusedMember.Local
private static bool ParseCareerName(
string input,
out string name,
out SaveFormats.OriginType originType,
out SaveFormats.NotorietyType reputationType,
out string className,
out DateTime date)
{
name = null;
className = null;
originType = SaveFormats.OriginType.None;
reputationType = SaveFormats.NotorietyType.None;
date = DateTime.Now;
var parts = input.Split('_');
if (parts.Length != 5)
{
return false;
}
name = parts[0];
if (parts[1] == null ||
parts[1].Length != 2)
{
return false;
}
switch (parts[1][0])
{
case '0':
{
originType = SaveFormats.OriginType.None;
break;
}
case '1':
{
originType = SaveFormats.OriginType.Spacer;
break;
}
case '2':
{
originType = SaveFormats.OriginType.Colony;
break;
}
case '3':
{
originType = SaveFormats.OriginType.Earthborn;
break;
}
default:
{
return false;
}
}
switch (parts[1][1])
{
case '0':
{
reputationType = SaveFormats.NotorietyType.None;
break;
}
case '1':
{
reputationType = SaveFormats.NotorietyType.Survivor;
break;
}
case '2':
{
reputationType = SaveFormats.NotorietyType.Warhero;
break;
}
case '3':
{
reputationType = SaveFormats.NotorietyType.Ruthless;
break;
}
default:
{
return false;
}
}
if (parts[2] == null)
{
return false;
}
className = parts[2];
if (parts[3] == null ||
parts[3].Length != 6)
{
return false;
}
if (parts[4] == null ||
parts[4].Length != 7)
{
return false;
}
int day;
if (int.TryParse(parts[3].Substring(0, 2), out day) == false)
{
return false;
}
int month;
if (int.TryParse(parts[3].Substring(2, 2), out month) == false)
{
return false;
}
int year;
if (int.TryParse(parts[3].Substring(4, 2), out year) == false)
{
return false;
}
date = new DateTime(2000 + year, month, day);
return true;
}
