private static bool isFile(DatRule datRule, DatHeader dh)
{
FileType ft = datRule.Compression;
if (!datRule.CompressionOverrideDAT)
{
switch (dh.Compression?.ToLower())
{
case "unzip":
case "file":
ft = FileType.Dir;
break;
case "7zip":
case "7z":
ft = FileType.SevenZip;
break;
case "zip":
ft = FileType.Zip;
break;
}
}
if (Settings.rvSettings.FilesOnly)
{
ft = FileType.Dir;
}
return(ft == FileType.Dir);
}
private void BtnResetAllClick(object sender, EventArgs e)
{
ChangesMade = true;
for (int i = 0; i < Settings.rvSettings.DatRules.Count; i++)
{
DatRule _rule = Settings.rvSettings.DatRules[i];
if (_rule.Compression != FileType.Zip ||
_rule.CompressionOverrideDAT ||
_rule.Merge != MergeType.Split ||
_rule.MergeOverrideDAT ||
_rule.SubDirType != RemoveSubType.KeepAllSubDirs ||
_rule.SingleArchive ||
_rule.MultiDATDirOverride ||
_rule.UseDescriptionAsDirName)
{
DatUpdate.CheckAllDats(DB.DirRoot.Child(0), _rule.DirKey);
}
}
Settings.rvSettings.ResetDatRules();
Settings.WriteConfig(Settings.rvSettings);
_rule = Settings.rvSettings.DatRules[0];
UpdateGrid();
SetDisplay();
}
private void DataGridGamesDoubleClick(object sender, EventArgs e)
{
if (DataGridGames.SelectedRows.Count <= 0)
{
return;
}
Text = "Edit Existing Directory / DATs Mapping";
_rule = (DatRule)DataGridGames.SelectedRows[0].Tag;
UpdateGrid();
SetDisplay();
}
private static void SetMergeType(DatRule datRule, DatHeader dh)
{
bool hasRom = DatHasRomOf.HasRomOf(dh.BaseDir);
if (hasRom)
{
MergeType mt = datRule.Merge;
if (!datRule.MergeOverrideDAT)
{
switch (dh.MergeType?.ToLower())
{
case "full":
mt = MergeType.Merge;
break;
case "nonmerge":
mt = MergeType.NonMerged;
break;
case "split":
mt = MergeType.Split;
break;
}
}
switch (mt)
{
case MergeType.Merge:
DatClean.DatSetMakeMergeSet(dh.BaseDir, dh.MameXML);
break;
case MergeType.NonMerged:
DatClean.DatSetMakeNonMergeSet(dh.BaseDir);
break;
case MergeType.Split:
DatClean.DatSetMakeSplitSet(dh.BaseDir);
//DatClean.RemoveNotCollected(dh.BaseDir);
break;
case MergeType.CHDsMerge:
DatClean.DatSetMakeMergeSet(dh.BaseDir, false);
break;
}
DatClean.RemoveDupes(dh.BaseDir, !dh.MameXML);
DatClean.RemoveEmptySets(dh.BaseDir);
}
}
public static DatRule FindDatRule(string datName)
{
ReportError.LogOut($"FindDatRule: Dat Name is {datName}");
DatRule use = null;
int longest = -1;
int datNameLength = datName.Length;
foreach (DatRule s in Settings.rvSettings.DatRules)
{
if (s.DirKey.Length < 8 || s.DirKey.Substring(0, 8) != "RomVault")
{
continue;
}
string DirKey = "DatRoot" + s.DirKey.Substring(8) + System.IO.Path.DirectorySeparatorChar;
int dirKeyLen = DirKey.Length;
if (dirKeyLen > datNameLength)
{
continue;
}
if (datName.Substring(0, dirKeyLen) != DirKey)
{
continue;
}
if (dirKeyLen < longest)
{
continue;
}
longest = dirKeyLen;
use = s;
}
if (use == null)
{
ReportError.LogOut("Use is Null");
}
else
{
ReportError.LogOut($"Using Rule for Dir {use.DirKey} {use.DirPath}");
}
return(use);
}
private static void SetCompressionMethod(DatRule datRule, DatHeader dh)
{
FileType ft = datRule.Compression;
if (!datRule.CompressionOverrideDAT)
{
switch (dh.Compression?.ToLower())
{
case "unzip":
case "file":
ft = FileType.Dir;
break;
case "7zip":
case "7z":
ft = FileType.SevenZip;
break;
case "zip":
ft = FileType.Zip;
break;
}
}
if (Settings.rvSettings.FilesOnly)
{
ft = FileType.Dir;
}
switch (ft)
{
case FileType.Dir:
DatSetCompressionType.SetFile(dh.BaseDir);
return;
case FileType.SevenZip:
DatSetCompressionType.SetZip(dh.BaseDir, true);
return;
default:
DatSetCompressionType.SetZip(dh.BaseDir);
return;
}
}
public static DatRule FindDatRule(string datName)
{
Debug.WriteLine($"Dat Name in {datName}");
DatRule use = null;
int longest = -1;
int datNameLength = datName.Length;
foreach (DatRule s in Settings.rvSettings.DatRules)
{
if (s.DirKey.Length < 8 || s.DirKey.Substring(0, 8) != "RomVault")
{
continue;
}
string DirKey = "DatRoot" + s.DirKey.Substring(8) + System.IO.Path.DirectorySeparatorChar;
int dirKeyLen = DirKey.Length;
if (dirKeyLen > datNameLength)
{
continue;
}
if (datName.Substring(0, dirKeyLen) != DirKey)
{
continue;
}
if (dirKeyLen < longest)
{
continue;
}
longest = dirKeyLen;
use = s;
}
Debug.WriteLine($"Using Rule for Dir {use.DirKey} {use.DirPath}");
return(use);
}
private static bool RecursiveDatTree(RvFile tDir, out int datCount)
{
datCount = 0;
string strPath = RvFile.GetDatPhysicalPath(tDir.DatTreeFullName);
if (!Directory.Exists(strPath))
{
ReportError.Show("Path: " + strPath + " Not Found.");
return(false);
}
DirectoryInfo oDir = new DirectoryInfo(strPath);
List <FileInfo> lFilesIn = new List <FileInfo>();
FileInfo[] oFilesIn = oDir.GetFiles("*.dat");
lFilesIn.AddRange(oFilesIn);
oFilesIn = oDir.GetFiles("*.xml");
lFilesIn.AddRange(oFilesIn);
datCount += lFilesIn.Count;
foreach (FileInfo file in lFilesIn)
{
RvDat tDat = new RvDat();
tDat.AddData(RvDat.DatData.DatRootFullName, Path.Combine(tDir.DatTreeFullName, file.Name));
tDat.TimeStamp = file.LastWriteTime;
string datRootFullName = tDat.GetData(RvDat.DatData.DatRootFullName);
DatRule datRule = DatReader.FindDatRule(datRootFullName);
tDat.MultiDatOverride = datRule.MultiDATDirOverride;
tDat.UseDescriptionAsDirName = datRule.UseDescriptionAsDirName;
tDat.SingleArchive = datRule.SingleArchive;
tDat.RemoveSubDir = datRule.RemoveSubDir;
tDir.DirDatAdd(tDat);
}
if (tDir.DirDatCount > 1)
{
for (int i = 0; i < tDir.DirDatCount; i++)
{
tDir.DirDat(i).MultiDatsInDirectory = true;
}
}
DirectoryInfo[] oSubDir = oDir.GetDirectories();
foreach (DirectoryInfo t in oSubDir)
{
RvFile cDir = new RvFile(FileType.Dir)
{
Name = t.Name, DatStatus = DatStatus.InDatCollect
};
int index = tDir.ChildAdd(cDir);
RecursiveDatTree(cDir, out int retDatCount);
datCount += retDatCount;
if (retDatCount == 0)
{
tDir.ChildRemove(index);
}
}
return(true);
}
private static bool RecursiveDatTree(RvFile tDir, out int datCount)
{
datCount = 0;
string strPath = RvFile.GetDatPhysicalPath(tDir.DatTreeFullName);
if (!Directory.Exists(strPath))
{
ReportError.Show($"Path: {strPath} Not Found.");
return(false);
}
DirectoryInfo oDir = new DirectoryInfo(strPath);
List <FileInfo> lFilesIn = new List <FileInfo>();
FileInfo[] oFilesIn = oDir.GetFiles("*.dat");
lFilesIn.AddRange(oFilesIn);
oFilesIn = oDir.GetFiles("*.xml");
lFilesIn.AddRange(oFilesIn);
datCount += lFilesIn.Count;
foreach (FileInfo file in lFilesIn)
{
RvDat tDat = new RvDat();
tDat.SetData(RvDat.DatData.DatRootFullName, Path.Combine(tDir.DatTreeFullName, file.Name));
tDat.TimeStamp = file.LastWriteTime;
// this works passing in the full DirectoryName of the Dat, because the rules
// has a directory separator character added to the end of them,
// so they match up to the directory name in this full Directory Name.
string datRootFullName = tDat.GetData(RvDat.DatData.DatRootFullName);
DatRule datRule = DatReader.FindDatRule(datRootFullName);
tDat.MultiDatOverride = datRule.MultiDATDirOverride;
tDat.UseDescriptionAsDirName = datRule.UseDescriptionAsDirName;
tDat.SingleArchive = datRule.SingleArchive;
tDat.SubDirType = datRule.SubDirType;
tDir.DirDatAdd(tDat);
}
if (tDir.DirDatCount > 1)
{
for (int i = 0; i < tDir.DirDatCount; i++)
{
tDir.DirDat(i).MultiDatsInDirectory = true;
}
}
DirectoryInfo[] oSubDir = oDir.GetDirectories();
foreach (DirectoryInfo t in oSubDir)
{
RvFile cDir = new RvFile(FileType.Dir)
{
Name = t.Name, DatStatus = DatStatus.InDatCollect
};
int index = tDir.ChildAdd(cDir);
RecursiveDatTree(cDir, out int retDatCount);
datCount += retDatCount;
if (retDatCount == 0)
{
tDir.ChildRemove(index);
}
}
return(true);
}
public void SetLocation(string dLocation)
{
_rule = FindRule(dLocation);
SetDisplay();
UpdateGrid();
}
public static RvFile ReadInDatFile(RvDat datFile, ThreadWorker thWrk, out string extraDirName)
{
try
{
_thWrk = thWrk;
extraDirName = null;
string datRootFullName = datFile.GetData(RvDat.DatData.DatRootFullName);
string fullPath = RvFile.GetDatPhysicalPath(datRootFullName);
Debug.WriteLine("Reading Dat " + fullPath);
DatRead.ReadDat(fullPath, ReadError, out DatHeader dh);
if (dh == null)
{
return(null);
}
string dirNameRule = Path.GetDirectoryName(datRootFullName) + Path.DirSeparatorChar;
if (
!datFile.MultiDatOverride && dh.Dir != "noautodir" &&
(datFile.MultiDatsInDirectory || !string.IsNullOrEmpty(dh.RootDir))
)
{
// if we are auto adding extra directories then create a new directory.
extraDirName = "";
if (string.IsNullOrEmpty(extraDirName) && datFile.UseDescriptionAsDirName && !string.IsNullOrWhiteSpace(dh.Description))
{
extraDirName = dh.Description;
}
if (string.IsNullOrEmpty(extraDirName))
{
extraDirName = dh.RootDir;
}
if (string.IsNullOrEmpty(extraDirName))
{
extraDirName = dh.Name;
}
if (string.IsNullOrEmpty(extraDirName))
{
extraDirName = Path.GetFileNameWithoutExtension(fullPath);
}
dirNameRule += VarFix.CleanFileName(extraDirName) + Path.DirSeparatorChar;
}
ReportError.LogOut($"DatRule {dirNameRule}");
DatRule datRule = FindDatRule(dirNameRule);
DatClean.CleanFilenames(dh.BaseDir);
switch (datRule.Filter)
{
case FilterType.CHDsOnly:
DatClean.RemoveNonCHD(dh.BaseDir);
break;
case FilterType.RomsOnly:
DatClean.RemoveCHD(dh.BaseDir);
break;
}
DatClean.RemoveNoDumps(dh.BaseDir);
SetMergeType(datRule, dh);
if (datRule.SingleArchive)
{
DatClean.MakeDatSingleLevel(dh, datRule.UseDescriptionAsDirName, datRule.SubDirType, isFile(datRule, dh));
}
DatClean.RemoveUnNeededDirectories(dh.BaseDir);
SetCompressionMethod(datRule, dh); // This sorts the files into the required dir order for the set compression type. (And also sets '\' characters to '/' in zip files.)
DatClean.DirectoryExpand(dh.BaseDir); // this works because we only expand files, so the order inside the zip / 7z does not matter.
DatClean.RemoveEmptyDirectories(dh.BaseDir);
DatClean.CleanFilenamesFixDupes(dh.BaseDir); // you may get repeat filenames inside Zip's / 7Z's and they may not be sorted to find them by now.
RvFile newDir = ExternalDatConverter.ConvertFromExternalDat(dh, datFile);
return(newDir);
}
catch (Exception e)
{
string datRootFullName = datFile?.GetData(RvDat.DatData.DatRootFullName);
Console.WriteLine(e);
throw new Exception("Error is DAT " + datRootFullName + " " + e.Message);
}
}
public static RvFile ReadInDatFile(RvDat datFile, ThreadWorker thWrk)
{
try
{
_thWrk = thWrk;
string datRootFullName = datFile.GetData(RvDat.DatData.DatRootFullName);
DatRead dr = new DatRead
{
ErrorReport = ReadError
};
string fullPath = RvFile.GetDatPhysicalPath(datRootFullName);
Debug.WriteLine("Reading Dat " + fullPath);
dr.ReadDat(fullPath, out DatHeader dh);
if (dh == null)
{
return(null);
}
string extraPath = !string.IsNullOrEmpty(dh.RootDir) ?
dh.RootDir : dh.Name;
string dirName = Path.GetDirectoryName(datRootFullName) + System.IO.Path.DirectorySeparatorChar + extraPath + System.IO.Path.DirectorySeparatorChar;
DatRule datRule = FindDatRule(dirName);
DatClean.CleanFilenames(dh.BaseDir);
switch (datRule.Filter)
{
case FilterType.CHDsOnly:
DatClean.RemoveNonCHD(dh.BaseDir);
break;
case FilterType.RomsOnly:
DatClean.RemoveCHD(dh.BaseDir);
break;
}
DatClean.RemoveNoDumps(dh.BaseDir);
SetMergeType(datRule, dh);
if (datRule.SingleArchive)
{
DatClean.MakeDatSingleLevel(dh);
}
DatClean.RemoveUnNeededDirectories(dh.BaseDir);
SetCompressionMethod(datRule, dh); // This sorts the files into the required dir order for the set compression type.
DatClean.DirectoryExpand(dh.BaseDir); // this works because we only expand files, so the order inside the zip / 7z does not matter.
DatClean.RemoveEmptyDirectories(dh.BaseDir);
DatClean.CleanFilenamesFixDupes(dh.BaseDir); // you may get repeat filenames inside Zip's / 7Z's and they may not be sorted to find them by now.
RvFile newDir = ExternalDatConverter.ConvertFromExternalDat(dh, datRootFullName, datFile.TimeStamp);
return(newDir);
}
catch (Exception e)
{
string datRootFullName = datFile?.GetData(RvDat.DatData.DatRootFullName);
Console.WriteLine(e);
throw new Exception("Error is DAT " + datRootFullName + " " + e.Message);
}
}
