public override void Run(FlagParse fp)
{
if (fp.Args.Length == 1)
{
QCol.Green("Displays a HEX output of a JCR entry");
return;
}
QCol.Doing("Reading", fp.Args[1]);
var jcr = JCR6.Dir(fp.Args[1]);
if (jcr == null)
{
QCol.QuickError(JCR6.JERROR); return;
}
if (fp.Args.Length == 2)
{
foreach (TJCREntry file in jcr.Entries.Values)
{
Show(jcr, file.Entry);
}
}
else
{
for (int i = 2; i < fp.Args.Length; ++i)
{
Show(jcr, fp.Args[i]);
}
}
}
private void Listbox_Favs_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (Listbox_Favs.SelectedItem == null)
{
return;
}
var rf = (string)Listbox_Favs.SelectedItem;
var rc = JCR6.Recognize(rf);
Debug.WriteLine($"Analysing {rf} => {rc}");
if (rc == "NONE")
{
Confirm.Annoy($"{rf} was not recognized");
return;
}
Core.IN_Resource = true;
Core.Resource = rf;
Core.CDirectory = "";
//Core.Config.ListAddNew(Platform, "Used", rf);
//RenewUsed();
UpdateDirBox();
ResTableSTG.Content = Core.JCR.FATstorage;
ResType.Content = rc;
return;
}
void GetJCR()
{
var f = new List <TJCREntry>();
JCR = JCR6.Dir(Dirry.AD(args[1]));
Assert(JCR, JCR6.JERROR);
foreach (TJCREntry e in JCR.Entries.Values)
{
var ok = qstr.Suffixed(e.Entry.ToLower(), ".png");
var p = false;
for (int i = 2; i < args.Length; i++)
{
p = p || qstr.Prefixed(e.Entry.ToLower(), args[i].ToLower());
}
ok = (args.Length == 2 || p);
if (ok)
{
f.Add(e);
}
}
Files = f.ToArray();
TQMG.Init(graphics, GraphicsDevice, spriteBatch, JCR);
JCRC = new TJCRCreate($"{qstr.StripExt(args[1])}.Negative.JCR");
}
public override void Run(FlagParse fp)
{
if (fp.Args.Length < 2)
{
QCol.Green("This feature allows you to show the content of a certain file.\n");
QCol.Green("In order to do this, some additional configuration will be needed, as well as knowledge of the file system you are using.\n");
QCol.Green("Don't worry about having to set up this file, manually. You will be prompted whenever NJCR requires more information.\n");
QCol.Green($"The configuration can lateron be edited with your favority text editor (as long as it supports Unix LF line ends), as it will be saved as {ShowConfig}");
return;
}
QCol.Doing("Reading JCR", fp.Args[1].Replace("\\", "/"));
var jcr = JCR6.Dir(fp.Args[1]);
if (jcr == null)
{
QCol.QuickError(JCR6.JERROR); return;
}
if (!File.Exists(ShowConfig))
{
QuickStream.SaveString(ShowConfig, "[rem]\nNothint to see here yet\n");
}
Config = GINI.ReadFromFile(ShowConfig);
Ask("Temp.Dir", "I am in need of a temp-directory.\nYou can pick any directory you want for this, and the system will try to create the desired directory if it doesn't yet exist.\nThe files to show will be temporarily stored here, and IT'S VERY IMPORTANT THAT THIS DIRECTORY IS ONLY USED FOR THIS PURPOSE!!!", "Temp Folder");
QCol.Doing("Temp dir", TempFolder);
Directory.CreateDirectory(TempFolder);
for (int i = 2; i < fp.Args.Length; i++)
{
Show(jcr, fp.Args[i]);
}
}
static void Load_JCR6()
{
Assets = JCR6.Dir(Dirry.C("$AppDir$/jcr/Kobud.jcr"));
if (Assets == null)
{
QuickGTK.Error(JCR6.JERROR);
throw new Exception(JCR6.JERROR);
}
}
public override void Run(FlagParse fp)
{
if (fp.Args.Length == 1)
{
QCol.Green("Show content of an entry as text on the console:\n\n");
QCol.Yellow("-b "); QCol.Cyan("When not set the ^Z character will be seen as EOF (DOS setting still working in Windows). When -b is set, everything will always be shown\n");
QCol.Yellow("-nsh "); QCol.Cyan("When set JCR6 will NOT try to syntax highlight");
QCol.Yellow("-nln "); QCol.Cyan("When set line numbers will not be displayed");
return;
}
KittyHigh.Init();
new KittyHighCS();
new KittyHighNIL();
new KittyHighLua();
new KittyHighGINI();
new KittyBlitzMax();
new KittyHighC();
new KittyHighPascal();
new KittyHighBrainFuck();
new KittyHighGo();
new KittyHighBlitzBasic();
new KittyHighSASKIA();
new KittyHighPython();
new KittyHighHtml();
new KittyHighCobra();
new KittyHighJava();
new KittyHighJavaScript();
new KittyHighNeil();
new KittyHighVB();
new KittyHighWhiteSpace();
new KittyHighXml();
var jcr = JCR6.Dir(fp.Args[1]);
if (jcr == null)
{
QCol.QuickError(JCR6.JERROR);
return;
}
if (fp.Args.Length == 2)
{
foreach (TJCREntry ent in jcr.Entries.Values)
{
Show(jcr, ent.Entry, fp);
}
}
else
{
for (int i = 2; i < fp.Args.Length; i++)
{
Show(jcr, fp.Args[i], fp);
}
}
}
void KthuraCheck(string map)
{
var mapfile = $"{Old["Maps"]}/{map}";
var modified = false;
Print($"Checking Kthura map: {map}");
Print($"= File: {mapfile}");
var jd = JCR6.Dir(mapfile);
foreach (var e in jd.Entries.Values)
{
if (e.Storage == "lzma")
{
modified = true;
Print($" = Entry {e.Entry} was packed with lzma, which is not (yet) supported in the new Kthura. So a repack is in order");
}
}
if (modified)
{
//if (true) {
Print("= Repacking in zlib");
var ed = new SortedDictionary <string, byte[]>();
foreach (var e in jd.Entries.Values)
{
Print($" = Reading: {e.Entry}");
ed[e.Entry] = jd.JCR_B(e.Entry);
}
var st = $"[IGNORECASE]\nLABELS=NO\nTAGS=NO\n\n[Save]\nStorage=zlib\n";
ed["Options"] = new byte[st.Length];
for (int i = 0; i < st.Length; ++i)
{
ed["Options"][i] = (byte)st[i];
}
Print("= Saving new map");
var jc = new TJCRCreate(mapfile, "zlib");
foreach (var e in ed)
{
Print($" = Writing: {e.Key}");
jc.AddBytes(e.Value, e.Key, "zlib");
}
Print("= Finalizing");
jc.Close();
}
else
{
Print("= Map appears to be in order. No changes needed!");
}
}
public Void()
{
graphics = new GraphicsDeviceManager(this);
graphics.PreferredBackBufferWidth = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width - 5;
graphics.PreferredBackBufferHeight = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height - 100;
try {
new JCR6_lzma();
JCR = JCR6.Dir($"{qstr.StripExt(MKL.MyExe)}.jcr"); Assert(JCR, "Void.jcr has not been properly loaded!");
} catch (Exception QuelleCatastrophe) {
#if DEBUG
FatalError($"Exception Thrown:\n{QuelleCatastrophe.Message}\n\n{QuelleCatastrophe.StackTrace}");
#else
FatalError($"Exception Thrown:\n{QuelleCatastrophe.Message}");
#endif
}
Content.RootDirectory = "Content";
}
private void DirBox_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
if (DirBox.SelectedItem == null)
{
return;
}
var item = (string)DirBox.SelectedItem;
//var d = item.Content.ToString();
Debug.WriteLine($"Double-clicked {item}");
if (!qstr.Suffixed(item, "/"))
{
if (Core.IN_Resource)
{
return;
}
var rf = $"{Core.CDirectory}/{item}";
var rc = JCR6.Recognize(rf);
Debug.WriteLine($"Analysing {rf} => {rc}");
if (rc == "NONE")
{
return;
}
Core.IN_Resource = true;
Core.Resource = rf;
Core.CDirectory = "";
Core.Config.ListAddNew(Platform, "Used", rf);
RenewUsed();
UpdateDirBox();
ResTableSTG.Content = Core.JCR.FATstorage;
ResType.Content = rc;
return;
}
if (Core.IN_Resource)
{
if (item == "../")
{
if (Core.CDirectory == "")
{
Directory.SetCurrentDirectory(qstr.ExtractDir(Core.Resource));
Core.IN_Resource = false;
Core.CDirectory = Directory.GetCurrentDirectory().Replace('\\', '/');
UpdateDirBox();
return;
}
Core.CDirectory = qstr.ExtractDir(Core.CDirectory);
UpdateDirBox();
return;
}
else
{
if (Core.CDirectory == "")
{
Core.CDirectory = item.Substring(0, item.Length - 1);
}
else
{
Core.CDirectory += $"/{item.Substring(0, item.Length - 1)}";
}
UpdateDirBox();
return;
}
}
else
{
Directory.SetCurrentDirectory(item);
Core.CDirectory = Directory.GetCurrentDirectory().Replace('\\', '/');
UpdateDirBox();
}
}
private void DirBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
Entry_Alias.Items.Clear();
Entry_Ratio.Content = "N/A";
Entry_Main.Content = "--";
if (DirBox.SelectedItem == null)
{
foreach (string EL in EntryLink.Keys)
{
EntryLink[EL].Content = "--";
}
UpdateBlockView(false);
return;
}
var item = (string)DirBox.SelectedItem;
if (Core.IN_Resource)
{
var ename = $"{Core.CDirectory}/{item}";
while (ename != "" && ename[0] == '/')
{
ename = ename.Substring(1);
}
if (qstr.Suffixed(ename, "/"))
{
foreach (string EL in EntryLink.Keys)
{
EntryLink[EL].Content = "N/A";
}
Entry_Entry.Content = ename;
Entry_Type.Content = "Directory";
UpdateBlockView(false);
}
else
{
var E = Core.JCR.Entries[ename.ToUpper()];
UpdateBlockView(E.Block != 0);
foreach (TJCREntry ECHK in Core.JCR.Entries.Values)
{
if (ECHK != E && ECHK.MainFile == E.MainFile && ECHK.Offset == E.Offset && ECHK.Block == E.Block)
{
Entry_Alias.Items.Add(ECHK.Entry);
}
}
foreach (string k in E.databool.Keys)
{
if (EntryLink.ContainsKey(k))
{
if (E.databool[k])
{
EntryLink[k].Content = "Yes";
}
else
{
EntryLink[k].Content = "No";
}
}
}
foreach (string k in E.dataint.Keys)
{
if (EntryLink.ContainsKey(k))
{
EntryLink[k].Content = $"{E.dataint[k]}";
}
}
foreach (string k in E.datastring.Keys)
{
if (EntryLink.ContainsKey(k))
{
EntryLink[k].Content = $"{E.datastring[k]}";
}
}
Entry_Main.Content = E.MainFile;
Entry_Ratio.Content = E.Ratio;
if (E.Block != 0)
{
Entry_Ratio.Content = "Unavailable (block)";
Entry_Offset.Content = "Unavailable (block)";
var B = Core.JCR.Blocks[$"{E.Block}:{E.MainFile}"];
Entry_Entry_Block.Content = E.Entry;
Entry_Block.Content = $"{E.Block}";
Block_Entries.Items.Clear();
foreach (var BE in Core.JCR.Entries.Values)
{
if (BE.Block == E.Block)
{
Block_Entries.Items.Add(BE.Entry);
}
}
Block_EntryOffset.Content = $"{E.Offset}";
Block_Offset.Content = $"{B.Offset}";
Block_Size.Content = $"{B.Size}";
Block_CSize.Content = $"{B.CompressedSize}";
Block_Ratio.Content = $"{B.Ratio}%";
}
if (Core.Config[Core.Platform, "ViewSwap"] == "")
{
Viewer.Navigate($"file://{Core.MyExeDir}/NoViewSwap.html");
}
else
{
switch (qstr.ExtractExt(E.Entry).ToLower())
{
case "jpg":
case "jpeg":
case "gif":
case "bmp":
case "png":
ImgViewer.ViewImg(Core.JCR.JCR_B(E.Entry), $"{E.MainFile}/{E.Entry}");
Viewer.Refresh();
break;
default:
KittyViewer.View($"{E.MainFile}/{E.Entry}", Core.JCR.LoadString(E.Entry));
break;
}
Viewer.Navigate($"file://{Core.Config[Core.Platform, "VIEWSWAP"]}/ViewFile.html");
}
}
}
else
{
var ename = $"{Core.CDirectory}/{item}";
if (!qstr.Suffixed(ename, "/"))
{
if (Core.Config[Core.Platform, "ViewSwap"] == "")
{
Viewer.Navigate($"file://{Core.MyExeDir}/NoViewSwap.html");
}
else if (JCR6.Recognize(ename).ToUpper() != "NONE")
{
var odir = Core.Config[Core.Platform, "VIEWSWAP"];
var KV = new KittyViewer();
KV.ForegroundColor = ConsoleColor.Yellow;
KV.WriteLine("JCR6 resource");
KV.ForegroundColor = ConsoleColor.White;
KV.WriteLine($"File {qstr.StripDir(ename)} has been recognized as: {JCR6.Recognize(ename)}");
KV.WriteLine($"JCR6 understands this format, so why don't you open it to see its contents?");
Directory.CreateDirectory(odir);
QuickStream.SaveString($"{odir}/ViewJCRFile.html", KV.ToString());
Viewer.Navigate($"{odir}/ViewJCRFile.html");
}
else
{
switch (qstr.ExtractExt(ename).ToLower())
{
case "jpg":
case "jpeg":
case "gif":
case "bmp":
case "png":
ImgViewer.ViewImg(QuickStream.GetFile(ename), ename);
break;
default:
KittyViewer.View($"{ename}", QuickStream.LoadString(ename));
break;
}
Viewer.Navigate($"file://{Core.Config[Core.Platform, "VIEWSWAP"]}/ViewFile.html");
}
}
}
}
public override void Run(FlagParse fp)
{
if (fp.Args.Length == 1 || fp.GetBool("h"))
{
QCol.Green("Extract files from a JCR file! Available switches are:\n\n");
QCol.Yellow("-nx "); QCol.Cyan("No eXternals. This means that any file imported from external JCR files will be ignored\n");
QCol.Yellow("-ow "); QCol.Cyan("Overwrite existing files\n");
QCol.Yellow("-nodir "); QCol.Cyan("Remove paths from file names\n");
QCol.Yellow("-nac "); QCol.Cyan("No auto-creation of new directories if needed\n");
QCol.Yellow("-output <path> "); QCol.Cyan("Define output path\n");
QCol.Magenta("\n\nWhat is important to note is that JCR6 was never set up as a real archiver like ZIP, RAR and 7z.\nIt has therefore features that ZIP, RAR, 7z nor any other archiver has.\n\nIt also lacks features the others have.\n\nExtracting was never a full feature of JCR6, but was rather added for completeness sake.\nExtracting files from it can therefore have some funny results.\n\n");
return;
}
var nx = fp.GetBool("nx");
var ow = fp.GetBool("ow");
var nodir = fp.GetBool("nodir");
var autocreate = fp.GetBool("nac");
var outdir = fp.GetString("output");
if (outdir != "")
{
outdir = outdir.Replace("\\", "/");
if (!qstr.Suffixed(outdir, "/"))
{
outdir += "/";
}
}
QCol.Doing("Reading", fp.Args[1]);
var jcr = JCR6.Dir(fp.Args[1]);
if (JCR6.JERROR != "")
{
QCol.QuickError($"JCR6 Error: {JCR6.JERROR}");
return;
}
try {
var skipreason = "";
var allow = true;
var offsets = new Dictionary <string, List <TJCREntry> >();
var alias = aliashanding.Ignore;
void skip(string reason)
{
if (skipreason != "")
{
skipreason += "; ";
}
skipreason += reason;
allow = false;
}
var shared = false;
foreach (TJCREntry Ent in jcr.Entries.Values)
{
var tag = $"{Ent.MainFile}:{Ent.Offset}";
if (!offsets.ContainsKey(tag))
{
offsets[tag] = new List <TJCREntry>();
}
else
{
shared = true;
}
offsets[tag].Add(Ent);
}
if (shared)
{
Console.Beep();
QCol.Red("\n\nWARNING!\n");
QCol.Yellow("This resource has some shared-references or aliases as they are properly called in JCR6.\n");
QCol.Yellow("Extracting from this file can therefore create tons of duplicate files, as JCR6 cannot tell which entry is more relevant than others.\n");
QCol.Yellow("It's strongly recommended to extract files from this resource unless you are sure about what you are doing and what the consequences are and how to deal with them\n");
QCol.Cyan("1 = Continue, but ask about any files that has aliases, what to do with them\n");
QCol.Cyan("2 = Continue, but skip all files with aliases\n");
QCol.Cyan("3 = Continue, and just let the duplicate files come, I don't fear them!\n");
QCol.Cyan("Q = Cancel this operation\n");
QCol.Magenta("What do you want to do? "); QCol.Green("");
{
var loop = true;
do
{
var ch = Console.ReadKey();
switch (ch.KeyChar)
{
case '1': alias = aliashanding.Ask; loop = false; break;
case '2': alias = aliashanding.Skip; loop = false; break;
case '3': alias = aliashanding.Ignore; loop = false; break;
case 'q':
case 'Q': return;
}
} while (loop);
Console.WriteLine($" -- {alias}");
}
}
foreach (TJCREntry Ent in jcr.Entries.Values)
{
allow = true;
skipreason = "";
// can we do this?
var source = Ent.Entry;
var target = Ent.Entry;
var tag = $"{Ent.MainFile}:{Ent.Offset}";
if (!JCR6.CompDrivers.ContainsKey(Ent.Storage))
{
skip($"Unknown compression method ({Ent.Storage})");
}
if (offsets[tag].Count > 1)
{
switch (alias)
{
case aliashanding.Skip: skip($"Offset reference as {offsets[tag].Count} entries, and system has been set to skip those"); break;
case aliashanding.Ask: {
Console.Beep();
QCol.Red($"Entry {Ent.Entry} has been aliased.\n");
foreach (TJCREntry aliasentry in offsets[tag])
{
QCol.Magenta("= "); QCol.Cyan($"{aliasentry.Entry}\n");
}
QCol.Green("Extract ? <Y/N> ");
do
{
var d = Console.ReadKey().KeyChar;
if (d == 'Y' || d == 'y')
{
break;
}
if (d == 'N' || d == 'n')
{
skip("User decided not to extract"); break;
}
} while (true);
Console.Write("\r");
break;
}
}
}
if (Ent.MainFile != fp.Args[1] && nx)
{
skip("No Externals");
}
if (nodir)
{
target = qstr.StripDir(target);
}
target = $"{outdir}{target}";
if (!Directory.Exists(qstr.ExtractDir(target)) && !autocreate)
{
Console.Beep();
QCol.Red($"{target}! ");
QCol.Yellow($"Create directory {qstr.ExtractDir(target)} ? <Y/N> ");
do
{
var d = Console.ReadKey().KeyChar;
if (d == 'Y' || d == 'y')
{
break;
}
if (d == 'N' || d == 'n')
{
skip("User decided not to extract"); break;
}
} while (true);
Console.Write("\n");
}
if (File.Exists(target) && (!ow))
{
Console.Beep();
QCol.Red($"{target} exists! ");
QCol.Yellow($"Overwrite ? <Y/N> ");
do
{
var d = Console.ReadKey().KeyChar;
if (d == 'Y' || d == 'y')
{
break;
}
if (d == 'N' || d == 'n')
{
skip("User decided not to extract"); break;
}
} while (true);
Console.Write("\n");
}
if (allow)
{
QCol.Doing("Extracting", target, "\r");
Directory.CreateDirectory(qstr.ExtractDir(target));
var b = jcr.JCR_B(source);
QuickStream.SaveBytes(target, b);
QCol.Doing(" Extracted", target);
}
else
{
QCol.Doing(" Skipped", target, "\t"); QCol.Red($"{skipreason}\n");
}
}
} catch (Exception e) {
QCol.QuickError($".NET Error: {e.Message}");
#if DEBUG
QCol.Magenta(e.StackTrace);
#endif
}
}
public override void Run(FlagParse fp)
{
var ShowXStuff = fp.GetBool("x");
var ShowAlias = fp.GetBool("a");
var ShowAllDat = fp.GetBool("xd");
if (fp.Args.Length == 1)
{
QCol.Green("Verboses the files in a JCR resource:\n\n");
QCol.Yellow("-x "); QCol.Cyan("Show notes and author (if available)\n");
QCol.Yellow("-a "); QCol.Cyan("List out all aliases");
QCol.Yellow("-xd "); QCol.Cyan("Show all entry variable settings");
return;
}
if (fp.Args.Length > 2)
{
QCol.QuickError("Only ONE file please!");
return;
}
var jcr = JCR6.Dir(fp.Args[1]);
if (jcr == null)
{
QCol.QuickError(JCR6.JERROR); return;
}
{ // Resources
var ResCount = new TMap <string, int>();
var CmpCount = new TMap <string, int>();
foreach (TJCREntry ent in jcr.Entries.Values)
{
ResCount[ent.MainFile]++;
CmpCount[ent.Storage]++;
}
XPrint(15, ConsoleColor.White, "Type");
XPrint(9, ConsoleColor.White, "Entries", Just.Right);
XPrint(10, ConsoleColor.White, " Resource:"); Console.WriteLine();
XPrint(15, ConsoleColor.White, "====");
XPrint(9, ConsoleColor.White, " =======", Just.Right);
XPrint(10, ConsoleColor.White, " ========="); Console.WriteLine();
foreach (string k in ResCount.Keys)
{
var rec = JCR6.Recognize(k);
if (rec != "NONE")
{
XPrint(15, ConsoleColor.Blue, JCR6.FileDrivers[rec].name);
XPrint(9, ConsoleColor.Cyan, ResCount[k]);
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine($" {k}");
}
}
Console.WriteLine();
XPrint(20, ConsoleColor.White, "Storage Method");
XPrint(10, ConsoleColor.White, "Used", Just.Right); Console.WriteLine();
XPrint(20, ConsoleColor.White, "==============");
XPrint(10, ConsoleColor.White, "====", Just.Right); Console.WriteLine();
foreach (string k in CmpCount.Keys)
{
XPrint(20, ConsoleColor.Blue, k);
XPrint(10, ConsoleColor.Cyan, CmpCount[k], Just.Right);
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine();
}
}
Console.WriteLine();
// Comments
foreach (string name in jcr.Comments.Keys)
{
QCol.White($"{name}\n");
for (int i = 0; i < name.Length; i++)
{
QCol.White("=");
}
QCol.Yellow($"\n{jcr.Comments[name]}\n\n");
}
// Blocks (if any)
//if (jcr.Blocks.Count>0) {
bool bfirst = true;
foreach (var B in jcr.Blocks.Values)
{
if (bfirst)
{
bfirst = false;
Console.WriteLine();
XPrint(5, ConsoleColor.White, "Block", Just.Right); WhiteSpace(2);
XPrint(10, ConsoleColor.White, "Compressed", Just.Right); WhiteSpace(2);
XPrint(10, ConsoleColor.White, "Size", Just.Right); WhiteSpace(2);
XPrint(5, ConsoleColor.White, "Ratio", Just.Right); WhiteSpace(2);
XPrint(7, ConsoleColor.White, "Storage"); Console.WriteLine();
XPrint(5, ConsoleColor.White, "=====", Just.Right); WhiteSpace(2);
XPrint(10, ConsoleColor.White, "==========", Just.Right); WhiteSpace(2);
XPrint(10, ConsoleColor.White, "====", Just.Right); WhiteSpace(2);
XPrint(5, ConsoleColor.White, "=====", Just.Right); WhiteSpace(2);
XPrint(7, ConsoleColor.White, "======="); Console.WriteLine();
}
XPrint(5, ConsoleColor.Blue, B.ID); WhiteSpace(2);
XPrint(10, ConsoleColor.Green, B.CompressedSize); WhiteSpace(2);
XPrint(10, ConsoleColor.Red, B.Size); WhiteSpace(2);
XPrint(5, ConsoleColor.Magenta, $"{B.Ratio}%", Just.Right); WhiteSpace(2);
XPrint(7, ConsoleColor.Yellow, B.Storage); Console.WriteLine();
}
//foreach (var BK in jcr.Blocks.Keys) Console.WriteLine(BK);
//}
// Entries
Console.WriteLine();
XPrint(15, ConsoleColor.White, "Kind"); WhiteSpace(2);
XPrint(10, ConsoleColor.White, "Compressed", Just.Right); WhiteSpace(2);
XPrint(10, ConsoleColor.White, "Size", Just.Right); WhiteSpace(2);
XPrint(5, ConsoleColor.White, "Ratio", Just.Right); WhiteSpace(2);
XPrint(7, ConsoleColor.White, "Storage"); WhiteSpace(2);
Console.WriteLine("Entry");
XPrint(15, ConsoleColor.White, "===="); WhiteSpace(2);
XPrint(10, ConsoleColor.White, "==========", Just.Right); WhiteSpace(2);
XPrint(10, ConsoleColor.White, "====", Just.Right); WhiteSpace(2);
XPrint(5, ConsoleColor.White, "=====", Just.Right); WhiteSpace(2);
XPrint(7, ConsoleColor.White, "======="); WhiteSpace(2);
Console.WriteLine("=====");
foreach (TJCREntry ent in jcr.Entries.Values)
{
Console.BackgroundColor = ConsoleColor.Black;
if (ent.MainFile != fp.Args [1].Replace("\\", "/"))
{
Console.BackgroundColor = ConsoleColor.DarkBlue;
}
XPrint(15, ConsoleColor.Blue, FTypes[qstr.ExtractExt(ent.Entry).ToLower()]); WhiteSpace(2);
if (ent.Block == 0)
{
XPrint(10, ConsoleColor.Green, ent.CompressedSize);
}
else
{
XPrint(10, ConsoleColor.DarkGreen, $"Block: {ent.Block}");
}
WhiteSpace(2);
XPrint(10, ConsoleColor.Red, ent.Size); WhiteSpace(2);
if (ent.Block == 0)
{
XPrint(5, ConsoleColor.Magenta, ent.Ratio, Just.Right);
}
else
{
XPrint(5, ConsoleColor.Magenta, "");
} WhiteSpace(2);
XPrint(7, ConsoleColor.Yellow, ent.Storage); WhiteSpace(2);
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(ent.Entry);
if (ShowXStuff)
{
if (ent.Author != "")
{
QCol.Doing("\tAuthor", ent.Author);
}
if (ent.Notes != "")
{
QCol.Green($"{ent.Notes}\n");
}
}
if (ShowAlias)
{
foreach (string AlFile in jcr.Aliases(ent))
{
QCol.Doing("\tAlias", AlFile);
}
}
if (ShowAllDat)
{
foreach (string k in ent.databool.Keys)
{
QCol.Magenta("\tbool "); QCol.Yellow(k); QCol.White(" = "); if (ent.databool[k])
{
QCol.Green("True\n");
}
else
{
QCol.Red("False\n");
}
}
foreach (string k in ent.datastring.Keys)
{
QCol.Magenta("\tstring "); QCol.Yellow(k); QCol.White(" = "); QCol.Green($"\"{ent.datastring[k]}\"\n");
}
foreach (string k in ent.dataint.Keys)
{
QCol.Magenta("\tint "); QCol.Yellow(k); QCol.White(" = "); QCol.Cyan($"{ent.dataint[k]}\n");
}
}
}
}
public void Go()
{
// Create or update?
TJCRCreate jout;
var temp = $"{qstr.ExtractDir(jcrfile)}/{qstr.md5($"{jcrfile}.{DateTime.Now.ToString()}")}.$jcr";
TJCRDIR jtmp = null;
if (updating)
{
jout = new TJCRCreate(temp, filetablecompression, sig);
}
else
{
jout = new TJCRCreate(jcrfile, filetablecompression, sig);
}
if (jout == null || jout.mystream == null)
{
QCol.QuickError($"Error creating JCR file >> {JCR6.JERROR}");
return;
}
// Add Comments
foreach (string n in Comments.Keys)
{
QCol.Doing("Comment", n);
jout.AddComment(n, Comments[n]);
}
// Add Dependencies
foreach (var d in Imports)
{
QCol.Doing("Import", d);
jout.Import(d);
}
foreach (var d in Requires)
{
QCol.Doing("Require", d);
jout.Require(d);
}
// Add files
foreach (Fil2Add aFile in Jiffy)
{
try {
if (nomerge || JCR6.Recognize(aFile.source) == "NONE")
{
QCol.Doing("Adding", aFile.source, "\r");
jout.AddFile(aFile.source, aFile.target, aFile.storage, aFile.author, aFile.notes);
//Console.WriteLine("\nBefore AfterAdd\n");
#if DEBUG
QCol.Doing("TARGET:", $"{aFile.target}=>{aFile.TARGET}");
#endif
var E = jout.Entries[aFile.TARGET];
AfterAdd(E, aFile);
//Console.WriteLine("\nAfter AfterAdd\n");
}
else
{
QCol.Doing("Merging", aFile.source);
var merge = JCR6.Dir(aFile.source);
foreach (TJCREntry ent in merge.Entries.Values)
{
QCol.Doing("Adding", "", "");
QCol.Magenta($"{aFile.source}/");
QCol.Cyan($"{ent.Entry}\r");
var tar = $"{aFile.target}/{ent.Entry}";
if (puremerge)
{
jout.JCRCopy(merge, ent.Entry, tar);
}
else
{
var buf = merge.JCR_B(ent.Entry);
jout.AddBytes(buf, tar, aFile.storage, ent.Author, ent.Notes);
}
//var E = jout.Entries[tar.ToUpper()];
var E = jout.LastAddedEntry;
AfterAdd(E, aFile);
}
}
} catch (Exception crap) {
QCol.Red(" Failed:\n");
if (JCR6.JERROR != "")
{
QCol.QuickError($"JCR6: {JCR6.JERROR}");
}
QCol.QuickError($".NET: {crap.Message}");
#if DEBUG
QCol.Magenta($"{crap.StackTrace}\n\n");
#endif
}
}
// Process aliases
//foreach(string ori in AliasList.Keys) {
foreach (SAlias SAL in AliasList)
{
QCol.Yellow("Alias: ");
QCol.Red(SAL.ori);
QCol.White(" => ");
QCol.Green(SAL.tar);
jout.Alias(SAL.ori, SAL.tar);
QCol.White("\n");
}
// Reorganize Files
if (updating)
{
try {
QCol.Doing("Reorganizing", "Data");
jtmp = JCR6.Dir(jcrfile);
if (jtmp == null)
{
throw new Exception($"JCR failed to analyse the old archive: {JCR6.JERROR}");
}
var indicator = 0;
foreach (TJCREntry entry in jtmp.Entries.Values)
{
indicator++;
if (indicator % 5 == 0)
{
QCol.Blue("\r \r.\b");
}
else
{
QCol.Blue(".\b");
}
if (!jout.Entries.ContainsKey(entry.Entry.ToUpper()))
{
QCol.Green("O");
jout.JCRCopy(jtmp, entry.Entry);
}
else
{
QCol.Red("X");
}
}
Console.WriteLine();
} catch (Exception well) {
QCol.QuickError(well.Message);
}
}
// Add dependency requests
// TODO: Dependency requests
// Closure and overwrite old JCR file if applicable.
QCol.Doing("Finalizing", jcrfile);
jout.Close();
if (updating)
{
try {
File.Delete(jcrfile);
File.Move(temp, jcrfile);
} catch (Exception E) {
QCol.QuickError(E.Message);
}
}
}
