private static void SetExpandedRecurse(RvDir pTree, bool expanded) { for (int i = 0; i < pTree.ChildCount; i++) { RvBase b = pTree.Child(i); if (b is RvDir) { RvDir d = (RvDir)b; if (d.Tree != null) { d.Tree.TreeExpanded = expanded; SetExpandedRecurse(d, expanded); } } } }
private static void SetChecked(RvDir pTree, RvTreeRow.TreeSelect nSelection) { pTree.Tree.Checked = nSelection; for (int i = 0; i < pTree.ChildCount; i++) { RvBase b = pTree.Child(i); if (b is RvDir) { RvDir d = (RvDir)b; if (d.Tree != null) { SetChecked(d, nSelection); } } } }
public static bool ReadDat(ref RvDir tDat, string strFilename) { RvDir tNow = tDat; FileType thisFileType = FileType.Unknown; int errorCode = DatFileLoader.LoadDat(strFilename); if (errorCode != 0) { DatUpdate.ShowDat(new Win32Exception(errorCode).Message, strFilename); return(false); } DatFileLoader.Gn(); while (!DatFileLoader.EndOfStream()) { switch (DatFileLoader.Next.ToLower()) { case "doscenter": _cleanFileNames = true; DatFileLoader.Gn(); if (!LoadHeaderFromDat(ref tNow, ref thisFileType)) { return(false); } DatFileLoader.Gn(); break; case "game": DatFileLoader.Gn(); if (!LoadGameFromDat(ref tNow, thisFileType)) { return(false); } DatFileLoader.Gn(); break; default: DatUpdate.SendAndShowDat(Resources.DatCmpReader_ReadDat_Error_keyword + DatFileLoader.Next + Resources.DatCmpReader_ReadDat_not_known, DatFileLoader.Filename); DatFileLoader.Gn(); break; } } DatFileLoader.Close(); return(true); }
private static EFile RemoveOldDatsCleanUpFiles(RvBase dbDir) { if (dbDir.Dat != null) { if (dbDir.Dat.Status == DatUpdateStatus.Correct) { return(EFile.Keep); } if (dbDir.Dat.Status == DatUpdateStatus.Delete) { if (dbDir.DatRemove() == EFile.Delete) { return(EFile.Delete); //delete } } } FileType ft = dbDir.FileType; // if we are checking a dir or zip recurse into it. if (ft != FileType.Zip && ft != FileType.Dir) { return(EFile.Keep); } RvDir tDir = dbDir as RvDir; // remove all DATStatus's here they will get set back correctly when adding dats back in below. dbDir.DatStatus = DatStatus.NotInDat; for (int i = 0; i < tDir.ChildCount; i++) { if (RemoveOldDatsCleanUpFiles(tDir.Child(i)) == EFile.Keep) { continue; } tDir.ChildRemove(i); i--; } if (ft == FileType.Zip && dbDir.GotStatus == GotStatus.Corrupt) { return(EFile.Keep); } // if this directory is now empty it should be deleted return(tDir.ChildCount == 0 ? EFile.Delete : EFile.Keep); }
public static bool ReadMameDat(ref RvDir tDat, XmlDocument doc) { FileType thisFileType = FileType.Unknown; if (!LoadMameHeaderFromDat(ref tDat, ref doc, ref thisFileType)) { return(false); } if (doc.DocumentElement == null) { return(false); } XmlNodeList dirNodeList = doc.DocumentElement.SelectNodes("dir"); if (dirNodeList != null) { foreach (XmlNode dirNode in dirNodeList) { LoadDirFromDat(ref tDat, dirNode, thisFileType); } } XmlNodeList gameNodeList = doc.DocumentElement.SelectNodes("game"); if (gameNodeList != null) { foreach (XmlNode gameNode in gameNodeList) { LoadGameFromDat(ref tDat, gameNode, thisFileType); } } XmlNodeList machineNodeList = doc.DocumentElement.SelectNodes("machine"); if (machineNodeList != null) { foreach (XmlNode machineNode in machineNodeList) { LoadGameFromDat(ref tDat, machineNode, thisFileType); } } return(true); }
private static void MatchFound(RvBase dbChild, RvBase fileChild) { // only check a zip if the filestamp has changed, we asume it is the same if the filestamp has not changed. switch (dbChild.FileType) { case FileType.Zip: if (dbChild.TimeStamp != fileChild.TimeStamp || EScanLevel == eScanLevel.Level3 || (EScanLevel == eScanLevel.Level2 && !IsDeepScanned((RvDir)dbChild))) { // this is done first as the CheckADir could change this value if the zip turns out to be corrupt dbChild.FileAdd(fileChild); CheckADir((RvDir)dbChild, false); } else { // this is still needed incase the filenames case (upper/lower characters) have changed, but nothing else dbChild.FileCheckName(fileChild); } break; case FileType.Dir: RvDir tDir = (RvDir)dbChild; if (tDir.Tree == null) // do not recurse into directories that are in the tree, as they are processed by the top level code. { CheckADir(tDir, true); } if (_fileErrorAbort) { return; } dbChild.FileAdd(fileChild); break; case FileType.File: case FileType.ZipFile: if (dbChild.TimeStamp == fileChild.TimeStamp && dbChild.GotStatus == GotStatus.Corrupt) { fileChild.GotStatus = GotStatus.Corrupt; } dbChild.FileAdd(fileChild); break; default: throw new Exception("Unsuported file type " + dbChild.FileType); } }
// returns number of CHD files in a RvDir // will be confused if there are any RvDirs as well as CHD files in 'dir' // does not check sub-dirs of 'dir' private static int numDisks(RvDir dir) { int retVal = 0; if (dir != null) { for (int i = 0; i < dir.ChildCount; i++) { RvFile chd = dir.Child(i) as RvFile; if ((chd != null) && (chd.FileType == FileType.File) && chd.Name.EndsWith(".chd")) { retVal++; } } } return(retVal); }
private static bool LoadHeaderFromDat(ref RvDir tDir, ref XmlDocument doc) { XmlNodeList head = doc.SelectNodes("softwarelist"); if (head == null) { return(false); } if (head.Count == 0) { return(false); } if (head[0].Attributes == null) { return(false); } RvDat tDat = new RvDat(); tDat.AddData(RvDat.DatData.DatName, VarFix.CleanFileName(head[0].Attributes.GetNamedItem("name"))); tDat.AddData(RvDat.DatData.Description, VarFix.String(head[0].Attributes.GetNamedItem("description"))); string val = VarFix.String(head[0].Attributes.GetNamedItem("forcemerging")).ToLower(); switch (val.ToLower()) { case "split": tDat.AddData(RvDat.DatData.MergeType, "split"); break; case "full": tDat.AddData(RvDat.DatData.MergeType, "full"); break; default: tDat.AddData(RvDat.DatData.MergeType, "split"); break; } tDir.Dat = tDat; return(true); }
public static void ReportStatusReset(RvBase tBase) { tBase.RepStatusReset(); FileType ftBase = tBase.FileType; if ((ftBase != FileType.Zip) && (ftBase != FileType.SevenZip) && (ftBase != FileType.Dir)) { return; } RvDir tDir = (RvDir)tBase; for (int i = 0; i < tDir.ChildCount; i++) { ReportStatusReset(tDir.Child(i)); } }
private static void LoadRomFromDat(ref RvDir tGame, XmlNode romNode, FileType thisFileType) { if (romNode.Attributes == null) { return; } XmlNode name = romNode.Attributes.GetNamedItem("name"); string loadflag = VarFix.String(romNode.Attributes.GetNamedItem("loadflag")); if (name != null) { RvFile tRom = new RvFile(thisFileType) // changed { Name = VarFix.CleanFullFileName(name), Size = VarFix.ULong(romNode.Attributes.GetNamedItem("size")), CRC = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("crc"), 8), SHA1 = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("sha1"), 40), Status = VarFix.ToLower(romNode.Attributes.GetNamedItem("status")), Dat = tGame.Dat }; if (tRom.Size != null) { tRom.FileStatusSet(FileStatus.SizeFromDAT); } if (tRom.CRC != null) { tRom.FileStatusSet(FileStatus.CRCFromDAT); } if (tRom.SHA1 != null) { tRom.FileStatusSet(FileStatus.SHA1FromDAT); } _indexContinue = tGame.ChildAdd(tRom); } else if (loadflag.ToLower() == "continue") { RvFile tZippedFile = (RvFile)tGame.Child(_indexContinue); tZippedFile.Size += VarFix.ULong(romNode.Attributes.GetNamedItem("size")); } }
private static void ReportMissingFindSizes(RvDir dir, RvDat dat, ReportType rt) { for (int i = 0; i < dir.ChildCount; i++) { RvBase b = dir.Child(i); if (b.Dat != null && b.Dat != dat) { continue; } RvFile f = b as RvFile; if (f != null) { if ( (rt == ReportType.PartialMissing && Partial.Contains(f.RepStatus)) || (rt == ReportType.Fixing && Fixing.Contains(f.RepStatus)) ) { int fileNameLength = f.FileNameInsideGame().Length; int fileSizeLength = f.Size.ToString().Length; int repStatusLength = f.RepStatus.ToString().Length; if (fileNameLength > _fileNameLength) { _fileNameLength = fileNameLength; } if (fileSizeLength > _fileSizeLength) { _fileSizeLength = fileSizeLength; } if (repStatusLength > _repStatusLength) { _repStatusLength = repStatusLength; } } } RvDir d = b as RvDir; if (d != null) { ReportMissingFindSizes(d, dat, rt); } } }
private static void RemoveOldTree(RvBase dbBase) { RvDir dbDir = dbBase as RvDir; if (dbDir == null) { return; } if (dbDir.DatStatus == DatStatus.NotInDat && dbDir.Tree != null) { dbDir.Tree = null; } for (int i = 0; i < dbDir.ChildCount; i++) { RemoveOldTree(dbDir.Child(i)); } }
private static void DatSetRemoveUnneededDirs(RvDir tDat) { for (int g = 0; g < tDat.ChildCount; g++) { RvDir tGame = (RvDir)tDat.Child(g); if (tGame.Game == null) { DatSetRemoveUnneededDirs(tGame); } else { for (int r = 0; r < tGame.ChildCount - 1; r++) { // first find any directories, zero length with filename ending in a '/' // there are RvFiles that are really directories (probably inside a zip file) RvFile f0 = (RvFile)tGame.Child(r); if (f0.Name.Length == 0) { continue; } if (f0.Name.Substring(f0.Name.Length - 1, 1) != "/") { continue; } // if the next file contains that found directory, then the directory file can be deleted RvFile f1 = (RvFile)tGame.Child(r + 1); if (f1.Name.Length <= f0.Name.Length) { continue; } if (f0.Name != f1.Name.Substring(0, f0.Name.Length)) { continue; } tGame.ChildRemove(r); r--; } } } }
private static void WriteDatFile(RvDir dir, bool CHDsAreDisk) { WriteLine("<?xml version=\"1.0\"?>"); WriteLine(""); WriteLine("<datafile>"); WriteHeader(CHDsAreDisk ? "CHDs as disk - if you see lots of status=nodump, try the other way" : "CHD as rom - if you see lots of empty double-quotes, try the other way"); /* write Games/Dirs */ if (CHDsAreDisk) { ProcessDir(dir); } else { PlainProcessDir(dir); } WriteLine("</datafile>"); }
private static void SetMissingStatus(RvBase dbChild) { if (dbChild.FileRemove() == EFile.Delete) { ReportError.SendAndShow("Error is Set Mssing Status in DatUpdate"); return; } FileType ft = dbChild.FileType; if (ft == FileType.Zip || ft == FileType.Dir) { RvDir dbDir = (RvDir)dbChild; for (int i = 0; i < dbDir.ChildCount; i++) { SetMissingStatus(dbDir.Child(i)); } } }
// CHDs as rom private static void PlainProcessDir(RvDir dir, int depth = 1) { string indent = new string('\t', depth); for (int i = 0; i < dir.ChildCount; i++) { RvDir item = dir.Child(i) as RvDir; if ((item != null) && ((item.FileType == FileType.Zip) || (item.FileType == FileType.Dir))) { WriteLine(indent + "<game name=\"" + clean(item.Name) + "\">"); WriteLine(indent + "\t<description>" + clean(item.Game == null ? item.Name : item.Game.GetData(RvGame.GameData.Description)) + "</description>"); for (int j = 0; j < item.ChildCount; j++) { RvFile file = item.Child(j) as RvFile; if (file != null) { WriteLine(indent + "\t<rom name=\"" + clean(file.Name) + "\" size=\"" + file.Size + "\" crc=\"" + ArrByte.ToString(file.CRC) + "\" md5=\"" + ArrByte.ToString(file.MD5) + "\" sha1=\"" + ArrByte.ToString(file.SHA1) + "\"/>"); } RvDir aDir = item.Child(j) as RvDir; if (aDir != null) { string dName = aDir.Name; for (int k = 0; k < aDir.ChildCount; k++) { RvFile subFile = aDir.Child(k) as RvFile; WriteLine(indent + "\t<rom name=\"" + dName + "\\" + clean(subFile.Name) + "\" size=\"" + subFile.Size + "\" crc=\"" + ArrByte.ToString(subFile.CRC) + "\" md5=\"" + ArrByte.ToString(subFile.MD5) + "\" sha1=\"" + ArrByte.ToString(subFile.SHA1) + "\"/>"); } } } WriteLine(indent + "</game>"); } // only recurse when grandchildren are not CHDs if ((item != null) && (item.FileType == FileType.Dir) && !hasChdGrandChildren(item)) { WriteLine(indent + "<dir name=\"" + clean(item.Name) + "\">"); PlainProcessDir(item, depth + 1); WriteLine(indent + "</dir>"); } } }
private static void DatSetRenameAndRemoveDups(RvDir tDat) { for (int g = 0; g < tDat.ChildCount; g++) { RvDir tDir = (RvDir)tDat.Child(g); if (tDir.Game == null) { DatSetRenameAndRemoveDups(tDir); } else { for (int r = 0; r < tDir.ChildCount - 1; r++) { RvFile f0 = (RvFile)tDir.Child(r); RvFile f1 = (RvFile)tDir.Child(r + 1); if (f0.Name != f1.Name) { continue; } if (f0.Size != f1.Size || !ArrByte.bCompare(f0.CRC, f1.CRC)) { tDir.ChildRemove(r + 1); // remove F1 f1.Name = f1.Name + "_" + ArrByte.ToString(f1.CRC); // rename F1; int pos = tDir.ChildAdd(f1); if (pos < r) { r = pos; } // if this rename moved the File back up the list, start checking again from that file. } else { tDir.ChildRemove(r + 1); } r--; } } } }
private static bool LoadMameHeaderFromDat(ref RvDir tDir, ref XmlDocument doc, ref FileType thisFileType) { if (doc.DocumentElement == null) { return(false); } XmlNode head = doc.SelectSingleNode("mame"); if (head == null || head.Attributes == null) { return(false); } RvDat tDat = new RvDat(); tDat.AddData(RvDat.DatData.DatName, VarFix.CleanFileName(head.Attributes.GetNamedItem("build"))); tDat.AddData(RvDat.DatData.Description, VarFix.String(head.Attributes.GetNamedItem("build"))); thisFileType = FileType.ZipFile; tDir.Dat = tDat; return(true); }
private static void LoadRomFromDat(ref RvDir tGame, XmlNode romNode, FileType thisFileType) { if (romNode.Attributes == null) { return; } RvFile tRom = new RvFile(thisFileType) { Dat = tGame.Dat, Size = VarFix.ULong(romNode.Attributes.GetNamedItem("size")), Name = VarFix.CleanFullFileName(romNode.Attributes.GetNamedItem("name")), CRC = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("crc"), 8), SHA1 = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("sha1"), 40), MD5 = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("md5"), 32), Merge = VarFix.CleanFullFileName(romNode.Attributes.GetNamedItem("merge")), Status = VarFix.ToLower(romNode.Attributes.GetNamedItem("status")) }; if (tRom.Size != null) { tRom.FileStatusSet(FileStatus.SizeFromDAT); } if (tRom.CRC != null) { tRom.FileStatusSet(FileStatus.CRCFromDAT); } if (tRom.SHA1 != null) { tRom.FileStatusSet(FileStatus.SHA1FromDAT); } if (tRom.MD5 != null) { tRom.FileStatusSet(FileStatus.MD5FromDAT); } tGame.ChildAdd(tRom); }
private static bool hasChdGrandChildren(RvDir aDir) { if (aDir == null) { return(false); } for (int i = 0; i < aDir.ChildCount; i++) { RvDir item = aDir.Child(i) as RvDir; if (item == null) { continue; } for (int j = 0; j < item.ChildCount; j++) { if (item.Child(j).Name.ToLower().EndsWith(".chd")) { return(true); } } } return(false); }
private static void LoadDiskFromDat(ref RvDir tGame, XmlNode romNode) { if (romNode.Attributes == null) { return; } XmlNode name = romNode.Attributes.GetNamedItem("name"); RvFile tRom = new RvFile(FileType.File) { Name = VarFix.CleanFullFileName(name) + ".chd", SHA1CHD = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("sha1"), 40), Status = VarFix.ToLower(romNode.Attributes.GetNamedItem("status")), Dat = tGame.Dat }; if (tRom.SHA1CHD != null) { tRom.FileStatusSet(FileStatus.SHA1CHDFromDAT); } tGame.ChildAdd(tRom); }
private static void ScanDirs(uint dirId, string datRoot, string subPath) { DirectoryInfo di = new DirectoryInfo(Path.Combine(datRoot, subPath)); DirectoryInfo[] dis = di.GetDirectories(); foreach (DirectoryInfo d in dis) { uint nextDirId = RvDir.FindOrInsertIntoDir(dirId, d.Name, Path.Combine(subPath, d.Name) + "\\"); ScanDirs(nextDirId, datRoot, Path.Combine(subPath, d.Name)); if (_bgw.CancellationPending) { return; } } FileInfo[] fisDat = di.GetFiles("*.DAT"); FileInfo[] fisXml = di.GetFiles("*.XML"); int datCount = fisDat.Length + fisXml.Length; ReadDat(fisDat, subPath, dirId, datCount > 1); ReadDat(fisXml, subPath, dirId, datCount > 1); }
private static void SetExpanded(RvDir pTree, bool rightClick) { if (!rightClick) { pTree.Tree.TreeExpanded = !pTree.Tree.TreeExpanded; return; } // Find the value of the first child node. for (int i = 0; i < pTree.ChildCount; i++) { RvBase b = pTree.Child(i); if (b is RvDir) { RvDir d = (RvDir)b; if (d.Tree != null) { //Recusivly Set All Child Nodes to this value SetExpandedRecurse(pTree, !d.Tree.TreeExpanded); break; } } } }
public static bool ReadMameDat(ref RvDir tDat, XmlDocument doc) { FileType thisFileType = FileType.Unknown; if (!LoadMameHeaderFromDat(ref tDat, ref doc, ref thisFileType)) { return(false); } if (doc.DocumentElement == null) { return(false); } XmlNodeList dirNodeList = doc.DocumentElement.SelectNodes("dir"); if (dirNodeList != null) { for (int i = 0; i < dirNodeList.Count; i++) { LoadDirFromDat(ref tDat, dirNodeList[i], thisFileType); } } XmlNodeList gameNodeList = doc.DocumentElement.SelectNodes("game"); if (gameNodeList != null) { for (int i = 0; i < gameNodeList.Count; i++) { LoadGameFromDat(ref tDat, gameNodeList[i], thisFileType); } } return(true); }
public void SetSelected(RvDir selected) { bool found = false; RvDir t = selected; while (t != null) { if (t.Tree != null) { if (!found) { _lSelected = t; found = true; } else { t.Tree.TreeExpanded = true; } } t = t.Parent; } SetupInt(); }
public static bool ReadDat(ref RvDir tDat, XmlDocument doc) { if (!LoadHeaderFromDat(ref tDat, ref doc)) { return(false); } if (doc.DocumentElement == null) { return(false); } XmlNodeList gameNodeList = doc.DocumentElement.SelectNodes("software"); if (gameNodeList == null) { return(false); } for (int i = 0; i < gameNodeList.Count; i++) { LoadGameFromDat(ref tDat, gameNodeList[i]); } return(true); }
private static bool LoadGameFromDat(ref RvDir tDat, FileType thisFileType) { if (DatFileLoader.Next != "(") { DatUpdate.SendAndShowDat(Resources.DatCmpReader_LoadGameFromDat_not_found_after_game, DatFileLoader.Filename); return(false); } DatFileLoader.Gn(); string snext = DatFileLoader.Next.ToLower(); if (snext != "name") { DatUpdate.SendAndShowDat(Resources.DatCmpReader_LoadGameFromDat_Name_not_found_as_first_object_in, DatFileLoader.Filename); return(false); } RvDir parent = tDat; string fullname = VarFix.CleanFullFileName(DatFileLoader.GnRest()); if (_cleanFileNames) { fullname = fullname.Replace("/", "-"); } while (fullname.Contains("/")) { int firstSlash = fullname.IndexOf("/", StringComparison.Ordinal); string dir = fullname.Substring(0, firstSlash); fullname = fullname.Substring(firstSlash + 1); int index; if (parent.ChildNameSearch(new RvDir(FileType.Dir) { Name = dir }, out index) == 0) { parent = (RvDir)parent.Child(index); } else { RvDir tpDir = new RvDir(FileType.Dir) { Name = dir, DatStatus = DatStatus.InDatCollect, Dat = tDat.Dat, Tree = new RvTreeRow() }; parent.ChildAdd(tpDir, index); parent = tpDir; } } if (fullname.Length > 4 && fullname.ToLower().Substring(fullname.Length - 4, 4) == ".zip") { fullname = fullname.Substring(0, fullname.Length - 4); } RvDir tDir = new RvDir(thisFileType == FileType.File ? FileType.Dir : FileType.Zip) { Name = fullname }; DatFileLoader.Gn(); tDir.Game = new RvGame(); tDir.DatStatus = DatStatus.InDatCollect; tDir.Dat = tDat.Dat; int index1; string testName = tDir.Name; int nameCount = 0; while (parent.ChildNameSearch(tDir, out index1) == 0) { tDir.Name = testName + "_" + nameCount; nameCount++; } parent.ChildAdd(tDir, index1); while (DatFileLoader.Next != ")") { switch (DatFileLoader.Next.ToLower()) { case "file": DatFileLoader.Gn(); if (!LoadRomFromDat(ref tDir, thisFileType)) { return(false); } DatFileLoader.Gn(); break; default: DatUpdate.SendAndShowDat(Resources.DatCmpReader_ReadDat_Error_keyword + DatFileLoader.Next + Resources.DatCmpReader_LoadGameFromDat_not_known_in_game, DatFileLoader.Filename); DatFileLoader.Gn(); break; } } return(true); }
private static void UpdateDirs(RvDir dbDir, RvDir fileDir) { int dbIndex = 0; int scanIndex = 0; dbDir.DatStatus = DatStatus.InDatCollect; if (dbDir.Tree == null) { Debug.WriteLine("Adding Tree View to " + dbDir.Name); dbDir.Tree = new RvTreeRow(); } Debug.WriteLine(""); Debug.WriteLine("Now scanning dirs"); while (dbIndex < dbDir.ChildCount || scanIndex < fileDir.ChildCount) { RvBase dbChild = null; RvBase fileChild = null; int res = 0; if (dbIndex < dbDir.ChildCount && scanIndex < fileDir.ChildCount) { dbChild = dbDir.Child(dbIndex); fileChild = fileDir.Child(scanIndex); res = DBHelper.CompareName(dbChild, fileChild); Debug.WriteLine("Checking " + dbChild.Name + " : and " + fileChild.Name + " : " + res); } else if (scanIndex < fileDir.ChildCount) { fileChild = fileDir.Child(scanIndex); res = 1; Debug.WriteLine("Checking : and " + fileChild.Name + " : " + res); } else if (dbIndex < dbDir.ChildCount) { dbChild = dbDir.Child(dbIndex); res = -1; } switch (res) { case 0: // found a matching directory in DatRoot So recurse back into it if (dbChild.GotStatus == GotStatus.Got) { if (dbChild.Name != fileChild.Name) // check if the case of the Item in the DB is different from the Dat Root Actual filename { if (!string.IsNullOrEmpty(dbChild.FileName)) // if we do not already have a different case name stored { dbChild.FileName = dbChild.Name; // copy the DB filename to the FileName } else // We already have a different case filename found in RomRoot { if (dbChild.FileName == fileChild.Name) // check if the Datroot name does now match the name in the DB Filename { dbChild.FileName = null; // if it does undo the BadCase Flag } } dbChild.Name = fileChild.Name; // Set the db Name to match the Datroot Name. } } else { dbChild.Name = fileChild.Name; } UpdateDatList((RvDir)dbChild, (RvDir)fileChild); dbIndex++; scanIndex++; break; case 1: // found a new directory in Dat RvDir tDir = new RvDir(FileType.Dir) { Name = fileChild.Name, Tree = new RvTreeRow(), DatStatus = DatStatus.InDatCollect, }; dbDir.ChildAdd(tDir, dbIndex); Debug.WriteLine("Adding new Dir and Calling back in to check this DIR " + tDir.Name); UpdateDatList(tDir, (RvDir)fileChild); dbIndex++; scanIndex++; break; case -1: // all files dbIndex++; break; } } }
/* * private static void SetInDat(RvDir tDir) * { * tDir.DatStatus = DatStatus.InDatCollect; * if (tDir.Parent != null) * SetInDat(tDir.Parent); * } */ private static Boolean MergeInDat(RvDir dbDat, RvDir newDat, out RvDat conflict, bool checkOnly) { conflict = null; int dbIndex = 0; int newIndex = 0; while (dbIndex < dbDat.ChildCount || newIndex < newDat.ChildCount) { RvBase dbChild = null; RvBase newDatChild = null; int res = 0; if (dbIndex < dbDat.ChildCount && newIndex < newDat.ChildCount) { dbChild = dbDat.Child(dbIndex); // are files newDatChild = newDat.Child(newIndex); // is from a dat item res = DBHelper.CompareName(dbChild, newDatChild); } else if (newIndex < newDat.ChildCount) { newDatChild = newDat.Child(newIndex); res = 1; } else if (dbIndex < dbDat.ChildCount) { dbChild = dbDat.Child(dbIndex); res = -1; } if (res == 0) { if (dbChild == null || newDatChild == null) { SendAndShowDat(Resources.DatUpdate_MergeInDat_Error_in_Logic, dbDat.FullName); break; } List <RvBase> dbDats = new List <RvBase>(); List <RvBase> newDats = new List <RvBase>(); int dbDatsCount = 1; int newDatsCount = 1; dbDats.Add(dbChild); newDats.Add(newDatChild); while (dbIndex + dbDatsCount < dbDat.ChildCount && DBHelper.CompareName(dbChild, dbDat.Child(dbIndex + dbDatsCount)) == 0) { dbDats.Add(dbDat.Child(dbIndex + dbDatsCount)); dbDatsCount += 1; } while (newIndex + newDatsCount < newDat.ChildCount && DBHelper.CompareName(newDatChild, newDat.Child(newIndex + newDatsCount)) == 0) { newDats.Add(newDat.Child(newIndex + newDatsCount)); newDatsCount += 1; } if (dbDatsCount > 1 || newDatsCount > 1) { ReportError.SendAndShow("Double Name Found"); } for (int indexdb = 0; indexdb < dbDatsCount; indexdb++) { if (dbDats[indexdb].DatStatus == DatStatus.NotInDat) { continue; } if (checkOnly) { conflict = dbChild.Dat; return(true); } SendAndShowDat(Resources.DatUpdate_MergeInDat_Unkown_Update_Dat_Status + dbChild.DatStatus, dbDat.FullName); break; } if (!checkOnly) { for (int indexNewDats = 0; indexNewDats < newDatsCount; indexNewDats++) { if (newDats[indexNewDats].SearchFound) { continue; } for (int indexDbDats = 0; indexDbDats < dbDatsCount; indexDbDats++) { if (dbDats[indexDbDats].SearchFound) { continue; } bool matched = FullCompare(dbDats[indexDbDats], newDats[indexNewDats]); if (!matched) { continue; } dbDats[indexDbDats].DatAdd(newDats[indexNewDats]); FileType ft = dbChild.FileType; if (ft == FileType.Zip || ft == FileType.Dir) { RvDir dChild = (RvDir)dbChild; RvDir dNewChild = (RvDir)newDatChild; MergeInDat(dChild, dNewChild, out conflict, checkOnly); } dbDats[indexDbDats].SearchFound = true; newDats[indexNewDats].SearchFound = true; } } for (int indexNewDats = 0; indexNewDats < newDatsCount; indexNewDats++) { if (newDats[indexNewDats].SearchFound) { continue; } dbDat.ChildAdd(newDats[indexNewDats], dbIndex); dbChild = dbDat.Child(dbIndex); SetMissingStatus(dbChild); dbIndex++; } } dbIndex += dbDatsCount; newIndex += newDatsCount; } if (res == 1) { if (!checkOnly) { dbDat.ChildAdd(newDatChild, dbIndex); dbChild = dbDat.Child(dbIndex); SetMissingStatus(dbChild); dbIndex++; } newIndex++; } if (res == -1) { dbIndex++; } } return(false); }
// CHDs as disk private static void ProcessDir(RvDir dir, int depth = 1) { string indent = new string('\t', depth); // recursive indent List <string> disks = new List <string> { string.Empty }; for (int i = 0; i < dir.ChildCount; i++) { RvDir item = dir.Child(i) as RvDir; if ((item != null) && (item.FileType == FileType.Dir)) { if ((disks.Count > 2) && (item.Name != disks[0])) // flush the last one if there were only CHDs in it { justCHDs(indent, disks); disks.Clear(); } // tabulate next disk list, if any disks = new List <string> { item.Name, item.Game == null ? item.Name : item.Game.GetData(RvGame.GameData.Description) }; for (int j = 0; j < item.ChildCount; j++) { RvFile chd = item.Child(j) as RvFile; if ((chd != null) && (chd.FileType == FileType.File) && chd.Name.EndsWith(".chd")) { if (!string.IsNullOrEmpty(ArrByte.ToString(chd.SHA1CHD))) { disks.Add(indent + "\t<disk name=\"" + clean(chd.Name).Replace(".chd", "") + "\" sha1=\"" + ArrByte.ToString(chd.SHA1CHD) + "\"/>"); } else { disks.Add(indent + "\t<disk name=\"" + clean(chd.Name).Replace(".chd", "") + "\" status=\"nodump\"/>"); } } } } if ((item != null) && (item.FileType == FileType.Zip)) { WriteLine(indent + "<game name=\"" + clean(item.Name) + "\">"); string desc = item.Game == null ? item.Name : item.Game.GetData(RvGame.GameData.Description); WriteLine(indent + "\t<description>" + clean(desc) + "</description>"); for (int j = 0; j < item.ChildCount; j++) { RvFile file = item.Child(j) as RvFile; if (file != null) { WriteLine(indent + "\t<rom name=\"" + clean(file.Name) + "\" size=\"" + file.Size + "\" crc=\"" + ArrByte.ToString(file.CRC) + "\" md5=\"" + ArrByte.ToString(file.MD5) + "\" sha1=\"" + ArrByte.ToString(file.SHA1) + "\"/>"); } } if (disks.Count > 2) // take care of previous list of CHDs now { for (int j = 2; j < disks.Count; j++) { WriteLine(disks[j]); } disks.Clear(); } WriteLine(indent + "</game>"); } if ((item != null) && (item.FileType == FileType.Dir)) { if (numDisks(item) == 0) // only recurse when children are not CHDs { WriteLine(indent + "<dir name=\"" + clean(item.Name) + "\">"); ProcessDir(item, depth + 1); WriteLine(indent + "</dir>"); } } } // check for one last CHDs-only game if (disks.Count > 2) { justCHDs(indent, disks); } }