public static string ConvertDateToString(this DateTime date, ConvertFormat format)
{
switch (format)
{
case ConvertFormat.YYYY_MM_DD:
return(date.ToString("yyyy-MM-dd"));
case ConvertFormat.YYYYMMDD:
return(date.ToString("yyyyMMdd"));
case ConvertFormat.HHMMSS:
return(date.ToString("HHmmss"));
case ConvertFormat.YYYY_S_MM_S_DD:
return(date.ToString("yyyy/MM/dd"));
case ConvertFormat.YYYYMMDDHHMMSS:
return(date.ToString("yyyyMMddHHmmss"));
case ConvertFormat.YYYY_DOT_MM_DOT_DD:
return(date.ToString("yyy.MM.dd"));
default:
return(date.ToLongDateString());
}
}
public void ConvertWithType()
{
using var format = new StringFormatTest("3");
Assert.That(
ConvertFormat.With(typeof(FormatTestDuplicatedConverter2), format),
Is.EqualTo(3));
}
public static void TranslatePOwithAnotherPO(string BasePO, string TargetPo)
{
Po BPo = null, TPo = null;
using (DataStream name = DataStreamFactory.FromFile(BasePO, FileOpenMode.Read))
using (BinaryFormat binaryname = new BinaryFormat(name))
{
BPo = (Po)ConvertFormat.With <Po2Binary>(binaryname);
}
using (DataStream name = DataStreamFactory.FromFile(TargetPo, FileOpenMode.Read))
using (BinaryFormat binaryname = new BinaryFormat(name))
{
TPo = (Po)ConvertFormat.With <Po2Binary>(binaryname);
}
foreach (PoEntry entryBPo in BPo.Entries)
{
foreach (PoEntry entryTPo in TPo.Entries)
{
if (entryBPo.Original == entryTPo.Original && (entryBPo.Translated != null && entryBPo.Translated != ""))
{
entryTPo.Translated = entryBPo.Translated;
if (entryBPo.TranslatorComment != string.Empty && entryBPo.TranslatorComment != null && entryBPo.TranslatorComment.Trim() != "")
{
entryTPo.TranslatorComment = entryBPo.TranslatorComment;
}
}
}
}
ConvertFormat.To <BinaryFormat>(TPo).Stream.WriteTo(TargetPo);
}
/// <summary>
/// Transforms a Yarhl node using a chain of converters.
/// </summary>
/// <param name="node">The original node.</param>
/// <param name="converters">Converters list.</param>
/// <param name="parameters">Allowed parameters list.</param>
public static void Transform(this Node node, List <ConverterInfo> converters, List <ParameterInfo> parameters)
{
var yarhlConverters = PluginManager.Instance.GetConverters().Select(x => x.Metadata).ToList();
foreach (ConverterInfo converterInfo in converters)
{
ConverterMetadata metadata = yarhlConverters.Find(x => x.Name == converterInfo.TypeName);
if (metadata == null)
{
throw new UnknownConverterException($"Unknown converter: {converterInfo.TypeName}");
}
IConverter converter = (IConverter)Activator.CreateInstance(metadata.Type);
System.Reflection.MethodInfo initializer = metadata.Type.GetMethod("Initialize");
ParameterInfo parameter = parameters.Find(x => x.Id == converterInfo.ParameterId);
if (initializer != null && parameter != null)
{
_ = initializer.Invoke(converter, new object[] { parameter.Value });
}
node.ChangeFormat((IFormat)ConvertFormat.With(converter, node.Format));
}
}
private static void CompressFiles(IEnumerable <Node> files, int compressorVersion)
{
var compressorParameters = new CompressorParameters
{
Endianness = 0x00,
Version = (byte)compressorVersion,
};
Parallel.ForEach(files, node =>
{
var parFile = node.GetFormatAs <ParFile>();
if (parFile == null || !parFile.CanBeCompressed || compressorVersion == 0x00 ||
parFile.Stream.Length == 0)
{
return;
}
FileCompressing?.Invoke(node);
var compressed =
(ParFile)ConvertFormat.With <Compressor, CompressorParameters>(compressorParameters, parFile);
long diff = parFile.Stream.Length - compressed.Stream.Length;
if (diff >= 0 && (parFile.Stream.Length < 2048 || diff >= 2048))
{
node.ChangeFormat(compressed);
}
FileCompressed?.Invoke(node);
});
}
public void ConvertWithInit()
{
using var format = new StringFormatTest("3");
Assert.That(
ConvertFormat.With <HiddenConverter, int>(4, format),
Is.EqualTo(7));
}
public NodeContainerFormat Convert(BinaryFormat source)
{
var container = new NodeContainerFormat();
var po = new Po {
Header = new PoHeader("Jump Ultimate Stars", "TranScene", "es")
{
LanguageTeam = "TranScene",
}
};
var reader = new DataReader(source.Stream)
{
DefaultEncoding = Encoding.GetEncoding("shift_jis"),
};
JusData.reader = reader;
reader.Stream.Position = 0x00;
BinaryFormat poBin;
var mangaIndex = MangaIndex.getInstance();
int numQuestions = reader.ReadInt32();
string currentManga = mangaIndex.getMangaName(0xFF);
int mangaCount = 0;
for (int i = 0; i < numQuestions; i++)
{
var q = JquizData.readData();
if (q.manga != currentManga)
{
poBin = ConvertFormat.With <Po2Binary>(po) as BinaryFormat;
container.Root.Add(new Node($"jquiz-{mangaCount}-{currentManga}.po", poBin));
po = new Po {
Header = new PoHeader("Jump Ultimate Stars", "TranScene", "es")
{
LanguageTeam = "TranScene",
}
};
mangaCount++;
currentManga = q.manga;
}
po.Add(new PoEntry(q.question)
{
Context = $"{i} - Question",
ExtractedComments = $"{q.photo}-{q.mangaCode}-{q.unknown}-{q.num}"
});
for (int j = 0; j < q.answers.Length; j++)
{
po.Add(new PoEntry(q.answers[j])
{
Context = $"{i} - Answer {j}"
});
}
}
poBin = ConvertFormat.With <Po2Binary>(po) as BinaryFormat;
container.Root.Add(new Node($"jquiz-{mangaCount}-{currentManga}.po", poBin));
return(container);
}
public void ConvertWithGeneric()
{
using var format = new StringFormatTest("3");
Assert.That(
ConvertFormat.With <FormatTestDuplicatedConverter1>(format),
Is.EqualTo(3));
}
public void ConvertBasicHeaderNoEntries()
{
var po = new Po(new PoHeader("myId", "yo", "es")
{
CreationDate = "today"
});
string text = @"msgid """"
msgstr """"
""Project-Id-Version: myId\n""
""Report-Msgid-Bugs-To: yo\n""
""POT-Creation-Date: today\n""
""PO-Revision-Date: \n""
""Last-Translator: \n""
""Language-Team: \n""
""Language: es\n""
""MIME-Version: 1.0\n""
""Content-Type: text/plain; charset=UTF-8\n""
""Content-Transfer-Encoding: 8bit\n""
";
text = text.Replace("\r\n", "\n");
var newPo = ConvertStringToPo(text);
CompareText(ConvertFormat.To <BinaryFormat>(po), text);
Assert.AreEqual(po.Header.ProjectIdVersion, newPo.Header.ProjectIdVersion);
Assert.AreEqual(po.Header.ReportMsgidBugsTo, newPo.Header.ReportMsgidBugsTo);
Assert.AreEqual(po.Header.CreationDate, newPo.Header.CreationDate);
Assert.AreEqual(po.Header.Language, newPo.Header.Language);
Assert.IsEmpty(newPo.Header.LastTranslator);
Assert.IsEmpty(newPo.Entries);
}
public void ConvertNoHeaderEntries()
{
var testPo = new Po();
testPo.Add(new PoEntry {
Original = "original"
});
testPo.Add(new PoEntry {
Original = "totranslate", Translated = "translated"
});
string text = @"
msgid ""original""
msgstr """"
msgid ""totranslate""
msgstr ""translated""
";
text = text.Replace("\r\n", "\n");
var newPo = ConvertStringToPo(text);
CompareText(ConvertFormat.To <BinaryFormat>(testPo), text);
Assert.IsNull(newPo.Header);
Assert.AreEqual(2, newPo.Entries.Count);
}
public void ConvertWithTypeThrowsIfNoImplementIConverter()
{
using var format = new StringFormatTest("3");
Assert.That(
() => ConvertFormat.With(typeof(DateTime), format),
Throws.InvalidOperationException.With.Message.EqualTo(
$"Cannot find converter {typeof(DateTime).FullName}"));
}
public void ConvertWithTypeThrowsIfConverterNotFound()
{
using var format = new StringFormatTest("3");
Assert.That(
() => ConvertFormat.With(typeof(HiddenConverter), format),
Throws.InvalidOperationException.With.Message.EqualTo(
$"Cannot find converter {typeof(HiddenConverter).FullName}"));
}
static Po ConvertStringToPo(string binary)
{
using BinaryFormat textFormat = new BinaryFormat();
new TextWriter(textFormat.Stream).Write(binary);
textFormat.Stream.Position = 0;
return(ConvertFormat.To <Po>(textFormat));
}
public void ConvertToWithTypeThrowsIfTypeIsNull()
{
Type dstType = null;
Assert.That(
() => ConvertFormat.To(dstType, "3"),
Throws.ArgumentNullException);
}
public void ConvertToThrowsIfSrcIsNull()
{
Assert.That(
() => ConvertFormat.To <int>(null),
Throws.ArgumentNullException);
Assert.That(
() => ConvertFormat.To(typeof(int), null),
Throws.ArgumentNullException);
}
public void ConvertWithInstanceThrowsIfConverterIsNull()
{
var format = new StringFormatTest("3");
HiddenConverter converter = null;
Assert.That(
() => ConvertFormat.With(converter, format),
Throws.ArgumentNullException);
}
public void ConvertWithInstance()
{
var format = new StringFormatTest("3");
var converter = new HiddenConverter();
Assert.That(
ConvertFormat.With(converter, format),
Is.EqualTo(3));
}
public void ConvertWithTypeThrowsIfTypeIsNull()
{
var format = new StringFormatTest("3");
Type type = null;
Assert.That(
() => ConvertFormat.With(type, format),
Throws.ArgumentNullException);
}
public void ConvertFromBaseWithDerivedConverterThrows()
{
// We cannot do the inverse, from base type use the derived converter
Base val = new Base {
X = 3
};
Assert.Throws <InvalidOperationException>(
() => ConvertFormat.To <ushort>(val));
}
public void ConvertFromDerivedWithBaseConverter()
{
var format = new Derived {
Y = 11, X = 10
};
int conv = 0;
Assert.DoesNotThrow(() => conv = ConvertFormat.To <int>(format));
Assert.AreEqual(15, conv);
}
public void ConvertToThrowsIfNoConverter()
{
var ex = Assert.Throws <InvalidOperationException>(() =>
ConvertFormat.To(typeof(short), (short)3));
Assert.AreEqual(
"Cannot find converter for: " +
$"{typeof(short).FullName} -> {typeof(short).FullName}",
ex.Message);
}
public void ConvertToThrowsIfThereAreTwoEqualConverters()
{
var test = new StringFormatTest("3");
var ex = Assert.Throws <InvalidOperationException>(() =>
ConvertFormat.To(typeof(short), test));
Assert.AreEqual(
"Multiple converters for: " +
$"{typeof(StringFormatTest).FullName} -> {typeof(short).FullName}",
ex.Message);
}
public void ConvertFromImplementationWithInterfaceConverter()
{
var format = new InterfaceImpl {
Z = 14
};
int conv = 0;
Assert.DoesNotThrow(() => conv = (int)ConvertFormat.With <ConverterInterface>(format));
Assert.AreEqual(14, conv);
Assert.DoesNotThrow(() => conv = ConvertFormat.To <int>(format));
Assert.AreEqual(14, conv);
}
/// <summary>
/// Create a SLLZ compressed BinaryFormat.
/// </summary>
/// <param name="source">original format.</param>
/// <returns>The compressed binary.</returns>
public ParFile Convert(BinaryFormat source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
return(_compressorParameters.CompressionType switch
{
CompressionType.Standard => (ParFile)ConvertFormat.With <CompressStandard, CompressorParameters>(_compressorParameters, source),
CompressionType.Zlib => (ParFile)ConvertFormat.With <CompressZlib, CompressorParameters>(_compressorParameters, source),
_ => throw new FormatException($"SLLZ: Bad Compression Type ({_compressorParameters.CompressionType})")
});
/// <summary>
/// Reads a format from this stream.
/// </summary>
/// <returns>The format read.</returns>
/// <typeparam name="T">The type of the format to read.</typeparam>
public T ReadFormat <T>()
{
if (Disposed)
{
throw new ObjectDisposedException(nameof(DataStream));
}
T format;
using (var binary = new BinaryFormat(this))
format = ConvertFormat.To <T>(binary);
return(format);
}
public void ConvertToDerivedWithDerivedConverter()
{
// Just to validate converter, derived with derived converter
Derived derived = null;
Assert.DoesNotThrow(() => derived = ConvertFormat.To <Derived>((ushort)4));
Assert.AreEqual(5, derived.Y);
Assert.AreEqual(4, derived.X);
ushort conv = 0;
Assert.DoesNotThrow(() => conv = ConvertFormat.To <ushort>(derived));
Assert.AreEqual(5, conv);
}
public void ConvertFullHeaderNoEntries()
{
var header = new PoHeader("myId", "yo", "SC")
{
CreationDate = "today",
RevisionDate = "tomorrow",
LastTranslator = "she",
LanguageTeam = "bestteam",
PluralForms = "pl",
};
header.Extensions["Generator"] = "yarhl";
header.Extensions["Hey"] = "hoy";
var testPo = new Po(header);
string text = @"msgid """"
msgstr """"
""Project-Id-Version: myId\n""
""Report-Msgid-Bugs-To: yo\n""
""POT-Creation-Date: today\n""
""PO-Revision-Date: tomorrow\n""
""Last-Translator: she\n""
""Language-Team: bestteam\n""
""Language: SC\n""
""MIME-Version: 1.0\n""
""Content-Type: text/plain; charset=UTF-8\n""
""Content-Transfer-Encoding: 8bit\n""
""Plural-Forms: pl\n""
""X-Generator: yarhl\n""
""X-Hey: hoy\n""
";
text = text.Replace("\r\n", "\n");
var newPo = ConvertStringToPo(text);
var newHeader = newPo.Header;
CompareText(ConvertFormat.To <BinaryFormat>(testPo), text);
Assert.AreEqual(header.ProjectIdVersion, newHeader.ProjectIdVersion);
Assert.AreEqual(header.ReportMsgidBugsTo, newHeader.ReportMsgidBugsTo);
Assert.AreEqual(header.CreationDate, newHeader.CreationDate);
Assert.AreEqual(header.RevisionDate, newHeader.RevisionDate);
Assert.AreEqual(header.LastTranslator, newHeader.LastTranslator);
Assert.AreEqual(header.LanguageTeam, newHeader.LanguageTeam);
Assert.AreEqual(header.Language, newHeader.Language);
Assert.AreEqual(header.PluralForms, newHeader.PluralForms);
Assert.That(header.Extensions["Generator"], Is.EqualTo(newHeader.Extensions["Generator"]));
Assert.That(header.Extensions["Hey"], Is.EqualTo(newHeader.Extensions["Hey"]));
Assert.IsEmpty(newPo.Entries);
}
public void ConvertToBaseWithDerivedConverter()
{
// It should use the converter: ushort -> Derived
// The converter will generate a derived type and will cast-down
// to base.
Base val = null;
Assert.DoesNotThrow(() => val = ConvertFormat.To <Base>((ushort)3));
Assert.IsInstanceOf <Derived>(val);
Assert.AreEqual(3, val.X);
Assert.DoesNotThrow(() => val = ConvertFormat.To <Base>((int)3));
Assert.IsInstanceOf <Base>(val);
Assert.AreEqual(5, val.X);
}
private static void ImportDig(Node nDIG, Node nATM, Node nPNG, string outputPath)
{
log.Info("Importing " + nDIG.Name + ", " + nATM.Name + " and " + nPNG.Name);
DIG originalDig = nDIG.TransformWith <Binary2DIG>().GetFormatAs <DIG>();
ALMT originalAtm = nATM.TransformWith <Binary2ALMT>().GetFormatAs <ALMT>();
// New stream
var stream = new MemoryStream();
var dataStream = DataStreamFactory.FromStreamKeepingOwnership(stream, 0, 0);
// Copy the png to the bitmap stream
nPNG.Stream.WriteTo(dataStream);
// Import the new PNG file
Bitmap newImage = (Bitmap)Image.FromStream(stream);
var quantization = new FixedPaletteQuantization(originalDig.Palette.GetPalette(0));
ColorFormat format;
if (originalDig.PaletteType == 16)
{
format = ColorFormat.Indexed_4bpp;
}
else
{
format = ColorFormat.Indexed_8bpp;
}
Texim.ImageMapConverter importer = new Texim.ImageMapConverter
{
Format = format,
PixelEncoding = PixelEncoding.HorizontalTiles,
Quantization = quantization,
//Mapable = new MatchMapping(originalDig.Pixels.GetPixels())
};
(Palette _, PixelArray pixelInfo, MapInfo[] mapInfos) = importer.Convert(newImage);
originalDig.Pixels = pixelInfo;
originalAtm.Info = mapInfos;
BinaryFormat bDig = (BinaryFormat)ConvertFormat.With <Binary2DIG>(originalDig);
BinaryFormat bAtm = (BinaryFormat)ConvertFormat.With <Binary2ALMT>(originalAtm);
Utils.Lzss(bDig, "-evn").Stream.WriteTo(Path.Combine(outputPath, nDIG.Name + ".evn.dig"));
bAtm.Stream.WriteTo(Path.Combine(outputPath, nATM.Name + ".atm"));
}
public void ConvertWithThrowsIfFormatIsNull()
{
StringFormatTest format = null;
Assert.That(
() => ConvertFormat.With <HiddenConverter>(format),
Throws.ArgumentNullException);
Assert.That(
() => ConvertFormat.With <HiddenConverter, int>(4, format),
Throws.ArgumentNullException);
var converter = new HiddenConverter();
Assert.That(
() => ConvertFormat.With(converter, format),
Throws.ArgumentNullException);
}
/// <summary>
/// Convert The current Image to the specified format
/// </summary>
/// <param name="format">The destination format of the new image</param>
/// <returns></returns>
public FreeImage ConvertTo(ConvertFormat format)
{
switch (format)
{
case ConvertFormat.Bits4:
return new FreeImage(FreeImageApi.ConvertTo4Bits(this.m_Handle));
case ConvertFormat.Bits8:
return new FreeImage(FreeImageApi.ConvertTo8Bits(this.m_Handle));
case ConvertFormat.Bits16_565:
return new FreeImage(FreeImageApi.ConvertTo16Bits565(this.m_Handle));
case ConvertFormat.Bits16_555:
return new FreeImage(FreeImageApi.ConvertTo16Bits555(this.m_Handle));
case ConvertFormat.Bits24:
return new FreeImage(FreeImageApi.ConvertTo24Bits(this.m_Handle));
case ConvertFormat.Bits32:
return new FreeImage(FreeImageApi.ConvertTo32Bits(this.m_Handle));
}
return null;
}