public static CustomPersonality LoadPersonality(ppParser pp)
{
if (!pp.Subfiles.Select(x => x.Name).Any(n => n.EndsWith(".icf")) || //check if it's a valid personality .pp which contains everything we need
!pp.Subfiles.Select(x => x.Name).Any(n => n.EndsWith(".lst") && n.StartsWith("jg2p")))
{
return(null);
}
string filename = pp.FilePath.Remove(0, pp.FilePath.LastIndexOf('\\') + 1);
IWriteFile iw = pp.Subfiles.First(x => x.Name.EndsWith(".lst") && x.Name.StartsWith("jg2p")); //you can thank a certain person for making this difficult (http://pastebin.com/3zkjpM7e)
var lst = LSTFactory.LoadLST(iw, LSTMode.Custom);
byte slot = (byte)lst.Slot;
Gender gender = lst.Gender; //not sure if more accurate than grabbing ID letter, this column is set to 1 for female and 0 for male
string ID = lst.ID;
string Name = lst.Name;
Name = AppendTranslation.GetValueOrDefault(Name, Name);
return(new CustomPersonality(gender, filename, ID, filename + "/" + iw.Name, Name, slot));
}
private void Preview(String parserVar, ListViewItem item)
{
ppParser parser = (ppParser)Gui.Scripting.Variables[parserVar];
IWriteFile subfile = (IWriteFile)item.Tag;
String clothPreviewPath = Path.GetDirectoryName(parser.FilePath) + @"\" + subfile.Name + ".preview";
Plugins.ExportSubfile(parser, subfile.Name, clothPreviewPath);
lastBasePath = Path.GetDirectoryName(parser.FilePath) + @"\base.pp";
ppParser basePP = (ppParser)Plugins.OpenPP(lastBasePath);
ppEditor baseEditor = new ppEditor(basePP);
String sampleBodyPath = Path.GetDirectoryName(parser.FilePath) + @"\sample_body.xx.$org$";
if (!File.Exists(sampleBodyPath))
{
Plugins.ExportSubfile(basePP, "sample_body.xx", sampleBodyPath);
}
baseEditor.RemoveSubfile("sample_body.xx");
baseEditor.AddSubfile(clothPreviewPath);
baseEditor.RenameSubfile(Path.GetFileName(clothPreviewPath), "sample_body.xx");
baseEditor.SavePP(false, (string)Gui.Config["BackupExtensionPP"], false);
File.Delete(clothPreviewPath);
lastPreviewed = item;
buttonPrepare.Text = "Prepare " + item.Text;
buttonRestoreDefault.Enabled = true;
}
public MetaIWriteFile(IWriteFile WriteFile, uint Hash, uint Size, object Metadata)
{
this.WriteFile = WriteFile;
this.Hash = Hash;
this.Size = Size;
this.Metadata = Metadata;
}
public WriteTime_EntriesInCSVFile(
IConvertListToCSV convertListToCSV,
IWriteFile writeFile)
{
_convertListToCSV = convertListToCSV;
_writeFile = writeFile;
}
public static void WriteRLEHeader(Stream stream, MetaIWriteList data)
{
byte[] headerBuf = new byte[HeaderSize(data.Count)];
BinaryWriter writer = new BinaryWriter(new MemoryStream(headerBuf));
writer.Write(ppVersionBytes);
writer.Write(DecryptHeaderBytes(BitConverter.GetBytes(Version)));
writer.Write(DecryptHeaderBytes(new byte[] { FirstByte }));
writer.Write(DecryptHeaderBytes(BitConverter.GetBytes(data.Count)));
List <uint> offsets = new List <uint>();
byte[] fileHeaderBuf = new byte[288 * data.Count];
uint fileOffset = (uint)headerBuf.Length;
for (int i = 0; i < data.Count; i++)
{
IWriteFile subfile = data[i].WriteFile;
uint hash = data[i].Hash;
uint size = data[i].Size;
object metadata = data[i].Metadata;
bool collision = data.GetRange(0, i)
.Any(x => x.Hash == hash);
uint currentOffset = fileOffset;
if (collision)
{
int index = data.IndexOf(data.GetRange(0, i)
.First(x => x.Hash == hash));
size = data[index].Size;
currentOffset = offsets[index];
}
offsets.Add(currentOffset);
int idx = i * 288;
Utility.EncodingShiftJIS.GetBytes(subfile.Name).CopyTo(fileHeaderBuf, idx);
BitConverter.GetBytes(size).CopyTo(fileHeaderBuf, idx + 260);
BitConverter.GetBytes(currentOffset).CopyTo(fileHeaderBuf, idx + 264);
Metadata wakeariMetadata = (Metadata)metadata;
System.Array.Copy(wakeariMetadata.LastBytes, 0, fileHeaderBuf, idx + 268, 20);
BitConverter.GetBytes(size).CopyTo(fileHeaderBuf, idx + 284);
if (!collision)
{
fileOffset += size;
}
}
writer.Write(DecryptHeaderBytes(fileHeaderBuf));
writer.Write(DecryptHeaderBytes(BitConverter.GetBytes(headerBuf.Length)));
writer.Flush();
stream.Write(headerBuf, 0, headerBuf.Length);
}
public static ToolOutputParser OpenToolOutput([DefaultVar] ppParser parser, string name)
{
for (int i = 0; i < parser.Subfiles.Count; i++)
{
if (parser.Subfiles[i].Name == name)
{
IReadFile subfile = parser.Subfiles[i] as IReadFile;
if (subfile != null)
{
return(new ToolOutputParser(subfile.CreateReadStream(), subfile.Name));
}
IWriteFile writeFile = parser.Subfiles[i] as IWriteFile;
if (writeFile != null)
{
using (MemoryStream memStream = new MemoryStream())
{
writeFile.WriteTo(memStream);
memStream.Position = 0;
ToolOutputParser outParser = new ToolOutputParser(memStream, writeFile.Name);
outParser.readFromOtherParser = true;
return(outParser);
}
}
break;
}
}
return(null);
}
public static void ExportSubfile([DefaultVar] ppParser parser, string name, string path)
{
for (int i = 0; i < parser.Subfiles.Count; i++)
{
if (parser.Subfiles[i].Name == name)
{
FileInfo file = new FileInfo(path);
DirectoryInfo dir = file.Directory;
if (!dir.Exists)
{
dir.Create();
}
using (FileStream fs = file.Create())
{
IWriteFile subfile = parser.Subfiles[i];
ppSubfile ppSubfile = subfile as ppSubfile;
if (ppSubfile != null)
{
ppSubfile.SourceStream = ppSubfile.CreateReadStream();
}
subfile.WriteTo(fs);
if (ppSubfile != null)
{
ppSubfile.SourceStream = null;
}
}
break;
}
}
}
public static MemoryStream ToStream(this IWriteFile iw)
{
MemoryStream mem = new MemoryStream();
iw.WriteTo(mem);
mem.Position = 0;
return(mem);
}
public void Setup()
{
_fileOpener = A.Fake <IOpenFile>();
_fileReader = A.Fake <IReadFile>();
_fileWriter = A.Fake <IWriteFile>();
_csvReaderWriter = new CSVReaderWriter(_fileOpener, _fileReader, _fileWriter);
}
public ViewModelOperation()
{
//CancelToken();
_getFilePath = new GetPathAllFiles();
_readFile = new BinaryReadFile();
_writeFile = new WriteXmlFile();
_filesSize = new BindingList <ReadFileResult>();
}
public WriteAllDataFromAllUserCSVFile(
IConvertListToCSV convertListToCSV,
IWriteFile writeFile,
IWriteConsol writeConsol)
{
_convertListToCSV = convertListToCSV;
_writeFile = writeFile;
_writeConsol = writeConsol;
}
/// <summary>
/// Creates a new instance of <see cref="DefaultBlobstoreController"/>
/// </summary>
/// <param name="fileEnlister">Dependency injection for <see cref="IEnlistFiles"/></param>
/// <param name="fileReader">Dependency injection for <see cref="IReadFile"/></param>
/// <param name="fileWriter">Dependency injection for <see cref="IWriteFile"/></param>
public DefaultBlobstoreController(
IEnlistFiles fileEnlister,
IReadFile fileReader,
IWriteFile fileWriter)
{
this.fileEnlister = fileEnlister;
this.fileReader = fileReader;
this.fileWriter = fileWriter;
}
public long AnalyzePP(ppParser pp)
{
long total = 0;
for (int i = 0; i < pp.Subfiles.Count; i++)
{
IWriteFile iw = pp.Subfiles[i];
if (!iw.Name.EndsWith(".wav"))
{
continue;
}
Stream str = Tools.GetReadStream(iw);
if (!str.CanSeek || str.Length == 0)
{
str.Close();
continue;
}
using (str)
{
WaveFileChunkReader wv = new WaveFileChunkReader();
WaveFormat f;
try
{
f = wv.ReadWaveHeader(str);
}
catch (FormatException)
{
str.Close();
continue;
}
long length = str.Length;
long remaining = length;
if (f.Channels > 1) // || wv.WaveFormat.Encoding != WaveFormatEncoding.Adpcm
{
total += (length / 2);
remaining /= 2;
}
if (f.SampleRate > SampleRate)
{
total += remaining - (long)(((float)SampleRate / f.SampleRate) * remaining);
}
}
if (ProgressUpdated != null)
{
ProgressUpdated((int)Math.Floor((double)(100 * i) / pp.Subfiles.Count));
}
}
return(total);
}
private void InitSubfileLists()
{
remSubfilesList.Items.Clear();
reaSubfilesList.Items.Clear();
imageSubfilesList.Items.Clear();
soundSubfilesList.Items.Clear();
otherSubfilesList.Items.Clear();
adjustSubfileListsEnabled(false);
List <ListViewItem> remFiles = new List <ListViewItem>(Editor.Parser.Subfiles.Count);
List <ListViewItem> reaFiles = new List <ListViewItem>(Editor.Parser.Subfiles.Count);
List <ListViewItem> imageFiles = new List <ListViewItem>(Editor.Parser.Subfiles.Count);
List <ListViewItem> soundFiles = new List <ListViewItem>(Editor.Parser.Subfiles.Count);
List <ListViewItem> otherFiles = new List <ListViewItem>(Editor.Parser.Subfiles.Count);
for (int i = 0; i < Editor.Parser.Subfiles.Count; i++)
{
IWriteFile subfile = Editor.Parser.Subfiles[i];
ListViewItem item = new ListViewItem(subfile.Name);
item.Tag = subfile;
string ext = Path.GetExtension(subfile.Name).ToUpper();
if (ext.Equals(".REM"))
{
remFiles.Add(item);
}
else if (ext.Equals(".REA"))
{
reaFiles.Add(item);
}
else if (Utility.ImageSupported(ext))
{
imageFiles.Add(item);
}
else if (ext.Equals(".WAV") || ext.Equals(".OGG"))
{
soundFiles.Add(item);
}
else
{
otherFiles.Add(item);
}
}
remSubfilesList.Items.AddRange(remFiles.ToArray());
reaSubfilesList.Items.AddRange(reaFiles.ToArray());
OptionalTab(imageSubfilesList, imageFiles, tabPageImageSubfiles, 2);
OptionalTab(soundSubfilesList, soundFiles, tabPageSoundSubfiles, 3);
otherSubfilesList.Items.AddRange(otherFiles.ToArray());
adjustSubfileLists();
adjustSubfileListsEnabled(true);
if (soundSubfilesList.Items.Count > 0 && soundLib == null)
{
soundLib = new Utility.SoundLib();
}
}
private void InitSubfileLists()
{
xxSubfilesList.Items.Clear();
xaSubfilesList.Items.Clear();
imageSubfilesList.Items.Clear();
soundSubfilesList.Items.Clear();
otherSubfilesList.Items.Clear();
adjustSubfileListsEnabled(false);
List <ListViewItem> xxFiles = new List <ListViewItem>(Editor.Parser.Subfiles.Count);
List <ListViewItem> xaFiles = new List <ListViewItem>(Editor.Parser.Subfiles.Count);
List <ListViewItem> imageFiles = new List <ListViewItem>(Editor.Parser.Subfiles.Count);
List <ListViewItem> soundFiles = new List <ListViewItem>(Editor.Parser.Subfiles.Count);
List <ListViewItem> otherFiles = new List <ListViewItem>(Editor.Parser.Subfiles.Count);
for (int i = 0; i < Editor.Parser.Subfiles.Count; i++)
{
IWriteFile subfile = Editor.Parser.Subfiles[i];
ListViewItem item = new ListViewItem(subfile.Name);
item.Tag = subfile;
string ext = Path.GetExtension(subfile.Name).ToLower();
if (ext.Equals(".xx"))
{
xxFiles.Add(item);
}
else if (ext.Equals(".xa"))
{
xaFiles.Add(item);
}
else if (ext.Equals(".ema") || Utility.ImageSupported(ext))
{
imageFiles.Add(item);
}
else if (ext.Equals(".ogg") || ext.Equals(".wav"))
{
soundFiles.Add(item);
}
else
{
otherFiles.Add(item);
}
}
xxSubfilesList.Items.AddRange(xxFiles.ToArray());
xaSubfilesList.Items.AddRange(xaFiles.ToArray());
imageSubfilesList.Items.AddRange(imageFiles.ToArray());
soundSubfilesList.Items.AddRange(soundFiles.ToArray());
otherSubfilesList.Items.AddRange(otherFiles.ToArray());
adjustSubfileLists();
adjustSubfileListsEnabled(true);
if (soundSubfilesList.Items.Count > 0 && soundLib == null)
{
soundLib = new Utility.SoundLib();
}
}
public DefaultBlobstoreControllerTest()
{
this.fileEnlister = A.Fake<IEnlistFiles>();
this.fileReader = A.Fake<IReadFile>();
this.fileWriter = A.Fake<IWriteFile>();
this.testee = new DefaultBlobstoreController(
this.fileEnlister,
this.fileReader,
this.fileWriter);
}
public static PersonalityLST LoadLST(this IWriteFile iw, LSTMode mode)
{
if (mode == LSTMode.Custom)
{
return(new CustomPersonalityLST(iw.ToStream().ToArray()));
}
else
{
return(new PersonalityLST(iw.ToStream().ToArray()));
}
}
public void ReplaceSubfile(IWriteFile file)
{
int index = FindSubfile(file.Name);
if (index < 0)
{
throw new Exception("Couldn't find the subfile " + file.Name);
}
Parser.Subfiles.RemoveAt(index);
Parser.Subfiles.Insert(index, file);
}
public void ProcessPP(ppParser pp)
{
for (int i = 0; i < pp.Subfiles.Count; i++)
{
IWriteFile iw = pp.Subfiles[i];
if (!iw.Name.EndsWith(".wav"))
{
continue;
}
Stream str = Tools.GetReadStream(iw);
if (!str.CanSeek || str.Length == 0)
{
str.Close();
continue;
}
using (str)
using (WaveFileReader wv = new WaveFileReader(str))
{
if (wv.WaveFormat.Channels > 1 || wv.WaveFormat.SampleRate > SampleRate) // || wv.WaveFormat.Encoding != WaveFormatEncoding.Adpcm
{
WaveFormat f = new WaveFormat(SampleRate, 16, 1); //new AdpcmWaveFormat(wv.WaveFormat.SampleRate, 1);
using (MediaFoundationResampler resampledAudio = new MediaFoundationResampler(wv, f))
{
resampledAudio.ResamplerQuality = 60;
MemoryStream o = new MemoryStream();
using (WaveFileWriter wr = new WaveFileWriter(o, f))
{
int count = 0;
byte[] buffer = new byte[2048];
while ((count = resampledAudio.Read(buffer, 0, 2048)) > 0)
{
wr.Write(buffer, 0, count);
}
wr.Flush();
pp.Subfiles[i] = new MemSubfile(ToByteArray(o), iw.Name);
}
}
}
}
if (ProgressUpdated != null)
{
ProgressUpdated((int)Math.Floor((double)(100 * i) / pp.Subfiles.Count));
}
}
}
public List <FormXX> OpenXXSubfilesList()
{
List <FormXX> list = new List <FormXX>(xxSubfilesList.SelectedItems.Count);
foreach (ListViewItem item in xxSubfilesList.SelectedItems)
{
IWriteFile writeFile = (IWriteFile)item.Tag;
FormXX formXX = (FormXX)Gui.Scripting.RunScript(FormVariable + ".OpenXXSubfile(name=\"" + writeFile.Name + "\")", false);
formXX.Activate();
list.Add(formXX);
}
return(list);
}
public GetSchemas(
IEnsureAuthenticated ensureAuthenticated,
ISimVersionCache simVersionCache,
ISimVersionClient simVersionClient,
IWriteFile writeFile,
IGetCreatedOutputFolder getCreatedOutputFolder,
ILogger <GetSchemas> logger)
{
this.ensureAuthenticated = ensureAuthenticated;
this.simVersionCache = simVersionCache;
this.simVersionClient = simVersionClient;
this.writeFile = writeFile;
this.getCreatedOutputFolder = getCreatedOutputFolder;
this.logger = logger;
}
public static void Save(Frames frames, string path, IWriteFile fileSystem)
{
try
{
fileSystem.Open(path);
foreach (int pin in frames.GetPins())
{
fileSystem.Write(pin.ToString() + ",");
}
}
finally
{
fileSystem.Close();
}
}
public void ReplaceSubfile(IWriteFile file)
{
throw new NotImplementedException();
/*
* int index = FindSubfile(file.Name);
* if (index < 0)
* {
* throw new Exception("Couldn't find the subfile " + file.Name);
* }
*
* Parser.Subfiles.RemoveAt(index);
* Parser.Subfiles.Insert(index, file);
*/
}
public List <FormXA> OpenXASubfilesList()
{
List <FormXA> list = new List <FormXA>(xaSubfilesList.SelectedItems.Count);
foreach (ListViewItem item in xaSubfilesList.SelectedItems)
{
IWriteFile writeFile = (IWriteFile)item.Tag;
FormXA formXA = (FormXA)Gui.Scripting.RunScript(FormVariable + ".OpenXASubfile(name=\"" + writeFile.Name + "\")", false);
formXA.Activate();
list.Add(formXA);
item.Font = new Font(item.Font, FontStyle.Bold);
xaSubfilesList.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
}
return(list);
}
public List <FormREA> OpenREASubfilesList()
{
List <FormREA> list = new List <FormREA>(remSubfilesList.SelectedItems.Count);
foreach (ListViewItem item in reaSubfilesList.SelectedItems)
{
IWriteFile writeFile = (IWriteFile)item.Tag;
FormREA formREA = (FormREA)Gui.Scripting.RunScript(FormVariable + ".OpenREASubfile(name=\"" + writeFile.Name + "\")", false);
if (formREA != null)
{
formREA.Activate();
list.Add(formREA);
}
}
return(list);
}
public GetConfigs(
IEnsureAuthenticated ensureAuthenticated,
ISimVersionCache simVersionCache,
IGetUserIdFromUsername getUserIdFromUsername,
IConfigClient configClient,
IWriteFile writeFile,
IGetCreatedOutputFolder getCreatedOutputFolder,
ILogger <GetConfigs> logger)
{
this.ensureAuthenticated = ensureAuthenticated;
this.simVersionCache = simVersionCache;
this.getUserIdFromUsername = getUserIdFromUsername;
this.configClient = configClient;
this.writeFile = writeFile;
this.getCreatedOutputFolder = getCreatedOutputFolder;
this.logger = logger;
}
public long AnalyzePP(ppParser pp)
{
long savings = 0;
for (int i = 0; i < pp.Subfiles.Count; i++)
{
IWriteFile iw = pp.Subfiles[i];
if (!iw.Name.EndsWith(".tga"))
{
continue;
}
Stream str = Tools.GetReadStream(iw);
if (!str.CanSeek || str.Length == 0)
{
str.Close();
continue;
}
using (str)
{
try
{
MagickImage m = new MagickImage(str);
m.CompressionMethod = CompressionMethod.RLE;
using (MemoryStream rle = new MemoryStream())
{
m.Write(rle, MagickFormat.Tga);
savings += str.Length - rle.Length;
}
}
catch (MagickException) { }
}
if (ProgressUpdated != null)
{
ProgressUpdated((int)Math.Floor((double)(100 * i) / pp.Subfiles.Count));
}
}
return(savings);
}
private void exportSubfilesToolStripMenuItem_Click(object sender, EventArgs e)
{
try
{
folderBrowserDialog1.SelectedPath = Path.GetDirectoryName(this.Editor.Parser.FilePath);
folderBrowserDialog1.RootFolder = Environment.SpecialFolder.MyComputer;
if (folderBrowserDialog1.ShowDialog() == DialogResult.OK)
{
ListView subfilesList = null;
if (tabControlSubfiles.SelectedTab == tabPageXXSubfiles)
{
subfilesList = xxSubfilesList;
}
else if (tabControlSubfiles.SelectedTab == tabPageXASubfiles)
{
subfilesList = xaSubfilesList;
}
else if (tabControlSubfiles.SelectedTab == tabPageImageSubfiles)
{
subfilesList = imageSubfilesList;
}
else if (tabControlSubfiles.SelectedTab == tabPageSoundSubfiles)
{
subfilesList = soundSubfilesList;
}
else if (tabControlSubfiles.SelectedTab == tabPageOtherSubfiles)
{
subfilesList = otherSubfilesList;
}
if (subfilesList != null)
{
foreach (ListViewItem item in subfilesList.SelectedItems)
{
IWriteFile subfile = (IWriteFile)item.Tag;
Gui.Scripting.RunScript("ExportSubfile(parser=" + ParserVar + ", name=\"" + subfile.Name + "\", path=\"" + folderBrowserDialog1.SelectedPath + @"\" + subfile.Name + "\")");
}
}
}
}
catch (Exception ex)
{
Utility.ReportException(ex);
}
}
public ppSwapfile(string ppPath, IWriteFile source)
{
this.Name = source.Name;
this.swapFilePath = tmpFolder + @"\" + ppPath.Replace('\\', '#').Replace(':', '~') + "#" + source.Name;
if (!Directory.Exists(tmpFolder))
{
Directory.CreateDirectory(tmpFolder);
}
else
{
string rnd = string.Empty;
Random rand = new Random();
while (File.Exists(swapFilePath + rnd))
{
rnd = "-" + rand.Next();
}
swapFilePath += rnd;
}
using (FileStream stream = File.OpenWrite(swapFilePath))
{
source.WriteTo(stream);
}
}
public ppSwapfile(string ppPath, IWriteFile source)
{
this.Name = source.Name;
this.swapFilePath = tmpFolder + @"\" + ppPath.Replace('\\', '#').Replace(':', '~') + "#" + source.Name;
if (!Directory.Exists(tmpFolder))
{
Directory.CreateDirectory(tmpFolder);
}
else
{
string rnd = string.Empty;
Random rand = new Random();
while (File.Exists(swapFilePath + rnd))
{
rnd = "-" + rand.Next();
}
swapFilePath += rnd;
}
using (FileStream stream = File.OpenWrite(swapFilePath))
{
source.WriteTo(stream);
}
}
public static Stream GetReadStream(IWriteFile iw)
{
Stream str;
if (iw is MemSubfile)
{
MemSubfile m = iw as MemSubfile;
str = m.CreateReadStream();
}
else if (iw is IReadFile)
{
IReadFile p = iw as IReadFile;
str = p.CreateReadStream();
}
else
{
str = new MemoryStream();
iw.WriteTo(str);
str.Position = 0;
}
return(str);
}
public static Stream GetReadStream(IWriteFile iw)
{
Stream str;
if (iw is MemSubfile)
{
MemSubfile m = iw as MemSubfile;
str = m.CreateReadStream();
}
else if (iw is IReadFile)
{
IReadFile p = iw as IReadFile;
str = p.CreateReadStream();
}
else
{
str = new MemoryStream();
iw.WriteTo(str);
str.Position = 0;
}
return str;
}
public void ReplaceSubfile(IWriteFile file)
{
int index = FindSubfile(file.Name);
if (index < 0)
{
throw new Exception("Couldn't find the subfile " + file.Name);
}
Parser.Subfiles.RemoveAt(index);
Parser.Subfiles.Insert(index, file);
}
public static ppSwapfile OpenSwapfile([DefaultVar]ppParser ppParser, IWriteFile parserToSwap)
{
ppSwapfile swap = new ppSwapfile(ppParser.FilePath, parserToSwap);
return swap;
}
public void AddNew(IWriteFile WriteFile, uint Hash, uint Size, object Metadata)
{
this.Add(new MetaIWriteFile(WriteFile, Hash, Size, Metadata));
}
public void Setup()
{
RefreshTestFileContents();
_writer = new WriteToHostsFile();
}
public CallBack(Game game, IWriteFile writeFile, IReadFile readFile)
{
this._game = game;
this._writeFile = writeFile;
this._readFile = readFile;
}
public Game(IUserInterface userInterface, IWriteFile writeFile, IReadFile readFile)
{
this._userInterface = userInterface;
this._writeFile = writeFile;
this._readFile = readFile;
}
public HomeController(IClawer clawer, IWriteFile writeFile, IHostingEnvironment hostingEnvironment)
{
_clawer = clawer;
_writeFile = writeFile;
_hostingEnvironment = hostingEnvironment;
}
/// <summary>
/// ファイル作成
/// </summary>
/// <param name="writter"></param>
private void CreateFile(IWriteFile writter)
{
try
{
// ダイアログ表示
var dialog = new SaveFileDialog();
dialog.Filter = "(*.txt)|*.txt";
//dialog.DefaultExt = "txt";
dialog.FileName = "Dto1.txt";
dialog.RestoreDirectory = true;
if (dialog.ShowDialog() != DialogResult.OK)
{
return;
}
// 保存
Stream stream = null;
using (stream = dialog.OpenFile())
{
if (stream != null)
{
using (var sw = new StreamWriter(stream, Encoding.GetEncoding("UTF-8")))
{
for (int i = 0; i < this.dtoView.Rows.Count; i++)
{
var strType = (string)this.dtoView.Rows[i].Cells[0].Value;
var strDec = (string)(this.dtoView.Rows[i].Cells[1].Value ?? "");
var strPhygNm = (string)this.dtoView.Rows[i].Cells[2].Value;
var strLgNm = (string)this.dtoView.Rows[i].Cells[3].Value;
if (string.IsNullOrWhiteSpace(strType))
{
break;
}
// 値型のセット
if (strType == "NUMERIC" || strType == "DECIMAL")
{
var intDec = this.Get_intValue(strDec);
strType = intDec == 0 ? "int" : "double";
}
else
{
strType = "string";
}
var item = new WriteItem()
{
TYPE = strType,
PHYGIC_NM = strPhygNm,
LOGIC_NM = strLgNm
};
// 生成
writter.Write(sw, item);
}
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.GetBaseException().ToString(), "例外", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
