private static void WorkshopChecker(ref string fullPath, ExtractData Addon, string uid = "")
{
Workshop.AddonData addonData = Workshop.GetAddonData(uid);
if (addonData.Title != "None")
{
Console.WriteLine("***********************************************");
Console.WriteLine($"Addon Information:\n" +
$"Title - {addonData.Title}\n" +
$"Types - {string.Join(", ", addonData.Types.ToArray())}\n" +
$"Tags - {string.Join(", ", addonData.Tags.ToArray())}\n" +
$"Upload date - {addonData.UploadDate}\n" +
$"Last update - {addonData.UpdateDate}");
Console.WriteLine("***********************************************");
string addonName = addonData.Title.ToLower().Replace('-', '_');
addonName = addonName.Replace(' ', '_');
addonName = addonName.Replace("'", "_");
addonName = addonName.Replace(""", "_");
addonName = addonName.Replace("&", "_");
addonName = addonName.Replace("/", "_");
addonName = addonName.Replace("\\", "_");
addonName = addonName.Replace(":", "_");
addonName = addonName.Replace("?", "_");
addonName = addonName.Replace("*", "_");
addonName = addonName.Replace("\"", "_");
addonName = addonName.Replace("<", "_");
addonName = addonName.Replace(">", "_");
addonName = addonName.Replace("|", "_");
fullPath = Path.Combine(ExtractPath, addonName + "_" + Addon.AddonDirectoryName);
}
}
private void button5_Click(object sender, System.EventArgs e)
{
//textBox4.Text = Convertir.StringHexa("Convert", true);
string temp = ExtractData.AspireString("0D", "FFF", @"d:\cookies.txt");
textBox4.Text = Convertir.StringHexa(temp, true);
}
private void Import()
{
var dialog = new OpenFileDialog
{
DefaultExt = ".csv"
};
dialog.Filter = "CSV Files|*.csv";
bool?result = dialog.ShowDialog();
if (result != null && !(bool)result)
{
return;
}
var path = dialog.FileName;
if (string.IsNullOrEmpty(path))
{
return;
}
_rosterFileName = Path.GetFileName(path);
(var roster, var errors, var headers) = ExtractData.GetData <RosterData>(path);
_rosterData = new ObservableCollection <RosterData>(roster);
_errors = new ObservableCollection <string[]>(errors);
_headers = headers;
Navigate("Dashboard");
}
public bool InsertFileData(int cpeEntryId, int cpeDefinitionId, string filePath)
{
bool success;
if (File.Exists(filePath))
{
OCR ocr = new OCR();
var json = ocr.GetJSON(filePath);
string ocrText = ocr.GetProperty(json);
ExtractData extractData = new ExtractData();
extractData.OCRText = ocrText;
switch (cpeDefinitionId)
{
case 27:
success = extractData.Glue_Turret_Data(cpeEntryId, cpeDefinitionId);
break;
default:
success = false; //if wrong definitionId is given
break;
}
return(success);
}
else
{
success = false; //if file is not found
return(success);
}
}
static void ExtractNumber()
{
//DataDownload.DownPage(147);
//DataDownload.DownPage(167);
ExtractData.Extract(147);
//ExtractData.Extract(167);
}
public void PhoneRegExpWorldWidePhone()
{
var _phoneToValidate = new StringBuilder();
_phoneToValidate.Append("+55 (22) 4111-1211");
_phoneToValidate.Append("55 (48)3131-0800");
var _phoneValues = ExtractData.ExtractValidPhones(_phoneToValidate.ToString());
Assert.Equal(2, _phoneValues.Count);
}
public void PhoneRegExpPhoneWithPoint()
{
var _phoneToValidate = new StringBuilder();
_phoneToValidate.Append("(54) 4111.1211");
_phoneToValidate.Append("11 31310800");
var _phoneValues = ExtractData.ExtractValidPhones(_phoneToValidate.ToString());
Assert.Equal(2, _phoneValues.Count);
}
public void PhoneRegExpPhoneWithTraceValidate()
{
var _phoneToValidate = new StringBuilder();
_phoneToValidate.Append("(11) 4009-1211");
_phoneToValidate.Append("(54) 3333-1211");
_phoneToValidate.Append("(11)93333-1211");
var _phoneValues = ExtractData.ExtractValidPhones(_phoneToValidate.ToString());
Assert.Equal(3, _phoneValues.Count);
}
public static Process ExtractSingleFile(string filepath)
{
string gmadExePath = GetBinGmodFolder();
if (gmadExePath == null)
{
return(null);
}
string fileName = Path.GetFileNameWithoutExtension(filepath);
ExtractData Addon = GetDataByUid(fileName);
/*
* foreach (var contentValue in ContentData)
* Console.WriteLine($"{fileName} ({fileName.Length}) - {contentValue.AddonFileName} ({contentValue.AddonFileName.Length})");
*/
if (Addon == null)
{
Addon = GetDataByFilename(fileName);
}
if (Addon == null)
{
Addon = GetDataByPath(fileName);
}
if (Addon == null)
{
Console.WriteLine($"Failed to get addon information.");
return(null);
}
string FullExtractPath = Path.Combine(ExtractPath, Addon.AddonFileName + "_" + Addon.AddonDirectoryName);
WorkshopChecker(ref FullExtractPath, Addon, Addon.AddonUid);
ExtractData NewAddon = ExtractBinAndGetAddon(FullExtractPath, Addon);
if (NewAddon != null)
{
Addon = NewAddon;
}
if (!Directory.Exists(FullExtractPath))
{
Directory.CreateDirectory(FullExtractPath);
Console.WriteLine($"Addon directory created: " + FullExtractPath);
}
return(ExtractGma(gmadExePath, FullExtractPath, Addon));
}
protected override void ExecuteCommand(Action <string> output, params string[] args)
{
if (args == null || args.Length == 0)
{
output("Please input arguments.");
}
foreach (var arg in args)
{
DataDownload.DownKaiJiangData(int.Parse(arg));
ExtractData.Extract(int.Parse(arg));
}
}
static void Main(string[] args)
{
string path = @"C:\Users\T.I\Desktop\tt.txt";
ExtractData extractData = new ExtractData(path);
Enterprise enterprise = new Enterprise();
EnterpriseModel e = enterprise.Getdata(extractData.DataFromHeader());
Console.WriteLine($"CNPJ: {e.Cnpj}");
Console.WriteLine($"Código da SEFIP: {e.SefipCode}");
Console.WriteLine($"Mês de Competência: {e.CompetenceMonth}");
Console.WriteLine($"Ano de Competencia: {e.CompetenceYear}");
}
public override SensorDataVO ReadSensorData()
{
lock (this.dataQueue)
{
if (this.dataQueue.Count < 1)
{
return(new SensorDataVO(0, DateTime.Now, SensorType.None));
}
ExtractData data = this.dataQueue.Dequeue();
SensorDataVO vo = new SensorDataVO(
data.Data,
data.Time,
SensorType.Omap);
return(vo);
}
}
public static Process ExtractSingle(string filename)
{
string gmadExePath = GetBinGmodFolder();
if (gmadExePath == null)
{
return(null);
}
ExtractData Addon = GetDataByUid(filename);
if (Addon == null)
{
Addon = GetDataByFilename(filename);
}
if (Addon == null)
{
Addon = GetDataByPath(filename);
}
if (Addon == null)
{
Console.WriteLine($"Failed to get addon information.");
return(null);
}
string FullExtractPath = Path.Combine(ExtractPath, Addon.AddonFileName + "_" + Addon.AddonDirectoryName);
WorkshopChecker(ref FullExtractPath, Addon, filename);
ExtractData NewAddon = ExtractBinAndGetAddon(FullExtractPath, Addon);
if (NewAddon != null)
{
Addon = NewAddon;
}
if (!Directory.Exists(FullExtractPath))
{
Directory.CreateDirectory(FullExtractPath);
Console.WriteLine($"Addon directory created: " + FullExtractPath);
}
return(ExtractGma(gmadExePath, FullExtractPath, Addon));
}
private void DoExtract(int mode)
{
if (string.IsNullOrEmpty(textBoxOutput.Text))
{
buttonBrowse.PerformClick();
DoExtract(mode);
return;
}
List <ICharaCard> cards = new List <ICharaCard>();
if (mode == 1)
{
for (int i = 0; i < listView.CheckedItems.Count; i++)
{
var item = listView.CheckedItems[i];
if (item.Tag != null)
{
int index = (int)item.Tag;
if (index > -1)
{
cards.Add(extractor.Cards[index]);
}
}
}
}
else
{
cards = extractor.Cards;
}
if (cards.Count > 0)
{
var data = new ExtractData()
{
Cards = cards.ToArray(),
OutputPath = textBoxOutput.Text,
SaveOptions = saveOptions
};
EnableControls(false);
statusLabelStatus.Text = "Exporting ...";
backgroundWorkerExtract.RunWorkerAsync(data);
}
}
/// <summary>
/// Verifie que le fichier Rom est valide
/// </summary>
/// <param name="FileName">Chemin vers le fichier (path)</param>
/// <returns>Retourne true si le fichier rom est un fichier de type Super Nintendo</returns>
public static bool isValid(string FileName)
{
if (File.Exists(FileName))
{
//Variable de Verification pour determiner de quel type est la rom a charge
string CheckLow1 = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("81DC", "81DD", FileName, true));
string CheckLow2 = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("81DE", "81DF", FileName, true));
string CheckLow1b = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("7FDC", "7FDD", FileName, true));
string CheckLow2b = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("7FDE", "7FDF", FileName, true));
string CheckHigh1 = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("101DC", "101DD", FileName, true));
string CheckHigh2 = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("101DE", "101DF", FileName, true));
string CheckHigh1b = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("FFDC", "FFDD", FileName, true));
string CheckHigh2b = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("FFDE", "FFDF", FileName, true));
long ValCheckLowb = Convertir.HexaToDecimal(CheckLow1b) + Convertir.HexaToDecimal(CheckLow2b);
long ValCheckHigh = Convertir.HexaToDecimal(CheckHigh1) + Convertir.HexaToDecimal(CheckHigh2);
long ValCheckHighb = Convertir.HexaToDecimal(CheckHigh1b) + Convertir.HexaToDecimal(CheckHigh2b);
long ValCheckLow = Convertir.HexaToDecimal(CheckLow1) + Convertir.HexaToDecimal(CheckLow2);
//Fichier Valide ?
if (ValCheckLow == 65535)
{
return(true); //LowRom 1
}
if (ValCheckLowb == 65535)
{
return(true); //LowRom 2
}
if (ValCheckHigh == 65535)
{
return(true); //HighRom
}
if (ValCheckHighb == 65535)
{
return(true); //HighRom
}
return(false); //Fichier non valide
}
else
{
return(false); //Fichier non trouver donc pa valide
}
}
private static ExtractData ExtractBinAndGetAddon(string FullExtractPath, ExtractData Addon)
{
if (Addon.IsBin)
{
Console.WriteLine($"The file extension is \".bin\".");
if (!Directory.Exists(FullExtractPath))
{
Directory.CreateDirectory(FullExtractPath);
Console.WriteLine($"Addon directory created: " + FullExtractPath);
}
string TempPath = Path.Combine(FullExtractPath, "temp");
if (!Directory.Exists(TempPath))
{
DirectoryInfo di = Directory.CreateDirectory(TempPath);
di.Attributes = FileAttributes.Directory | FileAttributes.Hidden;
}
Console.WriteLine("Begin the process of unpacking.");
UnpackingBin(Addon.AddonPath, TempPath);
Console.WriteLine("Unpacking archive completed.");
string[] files = Directory.GetFiles(TempPath);
if (files.Length == 0)
{
return(null);
}
Addon.AddonPath = files[0] + ".gma";
File.Move(files[0], Addon.AddonPath);
return(Addon);
}
return(null);
}
/// <summary>
/// Decode l'entrée suivant les propriétés de l'objet
/// </summary>
public void Decode()
{
string DataBrut = ExtractData.AspireString(PositionHexa,
Convertir.DecimalToHexa(this._position + this._length - 1), this._file, true);
string[] Data = Convertir.StringHexa_LittleEndian(DataBrut, true).Trim().Split(new char[] { ' ' });
string DecodedDTE = "";
string Find = "";
for (int i = 0; i < Data.Length; i++)
{
Find = this._tbl.FindTBLMatch(Data[i], true);
if (Find == "#")
{
DecodedDTE += "<" + Data[i] + ">";
}
else
{
DecodedDTE += Find;
}
}
txtValue.Text = DecodedDTE.TrimEnd(' ');
}
/// <summary>
/// Chargé en mémoire le fichier Rom spécifier par this._FileName
/// </summary>
/// <returns>Return true si le fichier est bien chargé</returns>
public bool Load()
{
if (File.Exists(this._FileName))
{
if (SnesRom.isValid(this._FileName)) //Verifie si le fichier Rom valide
//Variable de Verification pour determiner de quel type est la rom a charg
{
string CheckLow1 = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("81DC", "81DD", this.FileName, true));
string CheckLow2 = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("81DE", "81DF", this.FileName, true));
string CheckLow1b = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("7FDC", "7FDD", this.FileName, true));
string CheckLow2b = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("7FDE", "7FDF", this.FileName, true));
string CheckHigh1 = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("101DC", "101DD", this.FileName, true));
string CheckHigh2 = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("101DE", "101DF", this.FileName, true));
string CheckHigh1b = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("FFDC", "FFDD", this.FileName, true));
string CheckHigh2b = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("FFDE", "FFDF", this.FileName, true));
long ValCheckLowb = Convertir.HexaToDecimal(CheckLow1b) + Convertir.HexaToDecimal(CheckLow2b);
long ValCheckHigh = Convertir.HexaToDecimal(CheckHigh1) + Convertir.HexaToDecimal(CheckHigh2);
long ValCheckHighb = Convertir.HexaToDecimal(CheckHigh1b) + Convertir.HexaToDecimal(CheckHigh2b);
long ValCheckLow = Convertir.HexaToDecimal(CheckLow1) + Convertir.HexaToDecimal(CheckLow2);
//Extraire les informations sur la rom dependant du type de rom
if (ValCheckLow == 65535) //LowRom 1
{
this._RomType = RomType.LowRom_School_1;
this._RomName = ExtractData.AspireString("81C0", "81D4", this.FileName).TrimEnd(new char[] { ' ' });
this._PostitionName = (int)Convertir.HexaToDecimal("81C0");
this._InfoCart = (InformationCartouche)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("81D6", "81D6", this.FileName, true)));
this._RomSizeMB = (ROMSize)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("81D7", "81D7", this.FileName, true)));
this._RamSizeKB = (RAMSize)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("81D8", "81D8", this.FileName, true)));
this._Country = (Country)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("81D9", "81D9", this.FileName, true)));
this._Compagnie = (Compagnie)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("81DA", "81DA", this.FileName, true)));
this._Version = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("81DB", "81DB", this.FileName, true));
this._CompChecksum = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("81DC", "81DD", this.FileName, true));
this._Checksum = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("81DE", "81DF", this.FileName, true));
this._NmiVblVector = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("81EA", "81EB", this.FileName, true));
this._ResetVector = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("81FC", "81FD", this.FileName, true));
}
else if (ValCheckLowb == 65535) //LowRom 2
{
this._RomType = RomType.LowRom_School_2;
this._RomName = ExtractData.AspireString("7FC0", "7FD4", this.FileName).TrimEnd(new char[] { ' ' });
this._PostitionName = (int)Convertir.HexaToDecimal("7FC0");
this._InfoCart = (InformationCartouche)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("7FD6", "7FD6", this.FileName, true)));
this._RomSizeMB = (ROMSize)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("7FD7", "7FD7", this.FileName, true)));
this._RamSizeKB = (RAMSize)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("7FD8", "7FD8", this.FileName, true)));
this._Country = (Country)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("7FD9", "7FD9", this.FileName, true)));
this._Compagnie = (Compagnie)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("7FDA", "7FDA", this.FileName, true)));
this._Version = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("7FDB", "7FDB", this.FileName, true));
this._CompChecksum = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("7FDC", "7FDD", this.FileName, true));
this._Checksum = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("7FDE", "7FDF", this.FileName, true));
this._NmiVblVector = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("7FEA", "7FEB", this.FileName, true));
this._ResetVector = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("7FFC", "7FFD", this.FileName, true));
}
else if (ValCheckHigh == 65535) // HighRom
{
this._RomType = RomType.HighRom;
this._RomName = ExtractData.AspireString("101C0", "101D4", this.FileName).TrimEnd(new char[] { ' ' });
this._PostitionName = (int)Convertir.HexaToDecimal("101C0");
this._InfoCart = (InformationCartouche)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("101D6", "101D6", this.FileName, true)));
this._RomSizeMB = (ROMSize)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("101D7", "101D7", this.FileName, true)));
this._RamSizeKB = (RAMSize)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("101D8", "101D8", this.FileName, true)));
this._Country = (Country)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("101D9", "101D9", this.FileName, true)));
this._Compagnie = (Compagnie)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("101DA", "101DA", this.FileName, true)));
this._Version = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("101DB", "101DB", this.FileName, true));
this._CompChecksum = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("101DC", "101DD", this.FileName, true));
this._Checksum = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("101DE", "101DF", this.FileName, true));
this._NmiVblVector = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("101EA", "101EB", this.FileName, true));
this._ResetVector = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("101FC", "101FD", this.FileName, true));
}
else if (ValCheckHighb == 65535) // HighRom
{
this._RomType = RomType.HighRom;
this._RomName = ExtractData.AspireString("FFC0", "FFD4", this.FileName).TrimEnd(new char[] { ' ' });
this._PostitionName = (int)Convertir.HexaToDecimal("FFC0");
this._InfoCart = (InformationCartouche)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("FFD6", "FFD6", this.FileName, true)));
this._RomSizeMB = (ROMSize)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("FFD7", "FFD7", this.FileName, true)));
this._RamSizeKB = (RAMSize)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("FFD8", "FFD8", this.FileName, true)));
this._Country = (Country)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("FFD9", "FFD9", this.FileName, true)));
this._Compagnie = (Compagnie)
Convertir.HexaToDecimal(
Convertir.StringHexa_LittleEndian(
ExtractData.AspireString("FFDA", "FFDA", this.FileName, true)));
this._Version = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("FFDB", "FFDB", this.FileName, true));
this._CompChecksum = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("FFDC", "FFDD", this.FileName, true));
this._Checksum = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("FFDE", "FFDF", this.FileName, true));
this._NmiVblVector = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("FFEA", "FFEB", this.FileName, true));
this._ResetVector = Convertir.StringHexa_LittleEndian(ExtractData.AspireString("FFFC", "FFFD", this.FileName, true));
}
//Format d'affichage
if (this._Country.ToString() == "Japon" ||
this._Country.ToString() == "USA")
{
this._FormatAffichage = FormatAffichage.NTSC;
}
else
{
this._FormatAffichage = FormatAffichage.PAL;
}
//MD5 hashing
this._MD5 = HashFile.GetMD5Hexa(this._FileName);
#region DEBUG INFOS : Informations sur la Rom
// #if DEBUG //Informations de debuggage
// Debug.WriteLine("DEBUG INFOS START : VRS.Library.Console.SuperNintendo.SnesRom.Load()");
// Debug.WriteLine("CheckLow1 :" + CheckLow1);
// Debug.WriteLine("CheckLow2 :" + CheckLow2);
// Debug.WriteLine("CheckLow1b :" + CheckLow1b);
// Debug.WriteLine("CheckLow2b :" + CheckLow2b);
// Debug.WriteLine("CheckHigh1 :" + CheckHigh1);
// Debug.WriteLine("CheckHigh2 :" + CheckHigh2);
// Debug.WriteLine("CheckHigh1b :" + CheckHigh1b);
// Debug.WriteLine("CheckHigh2b :" + CheckHigh2b);
// Debug.WriteLine("ValCheckLowb :" + ValCheckLowb);
// Debug.WriteLine("ValCheckHigh :" + ValCheckHigh);
// Debug.WriteLine("ValCheckHighb :" + ValCheckHighb);
// Debug.WriteLine("ValCheckLow :" + ValCheckLow);
// Debug.WriteLine("this._RomName :" + this._RomName);
// Debug.WriteLine("this._InfoCart :" + this._InfoCart.ToString());
// Debug.WriteLine("this._RomSizeMB :" + this._RomSizeMB.ToString());
// Debug.WriteLine("this._RamSizeKB :" + this._RamSizeKB.ToString());
// Debug.WriteLine("this._Country :" + this._Country.ToString());
// Debug.WriteLine("this._Compagnie :" + this._Compagnie.ToString());
// Debug.WriteLine("this._version : 1." + this._Version);
// Debug.WriteLine("this._CompChecksum :" + this._CompChecksum);
// Debug.WriteLine("this._Checksum :" + this._Checksum);
// Debug.WriteLine("this._ResetVector :" + this._ResetVector);
// Debug.WriteLine("this._NmiVblVector :" + this._NmiVblVector);
// Debug.WriteLine("this._FormatAffichage :" + this._FormatAffichage);
// Debug.WriteLine("this._MD5 :" + this._MD5);
// Debug.WriteLine("DEBUG INFOS END : VRS.Library.Console.SuperNintendo.SnesRom.Load()");
// #endif
#endregion
return(true);
}
else
{
return(false);
}
}
else
{
throw new FileNotFoundException();
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="extractsim">Method for getting a data point</param>
/// <param name="extractparam">Method for extracting the parameter from the data</param>
public DCMeasurement(ExtractData extractsim, ExtractParameter <DCMeasurement> extractparam)
{
this.extractsim = extractsim;
this.extractparam = extractparam;
}
public static ExtractData GetDataByPath(string filepath)
{
ExtractData data = ContentData.Find(x => x.AddonPath == filepath);
return((data != null) ? data : AllContentData.Find(x => x.AddonPath == filepath));
}
public static ExtractData GetDataByFilename(string filename)
{
ExtractData data = ContentData.Find(x => x.AddonFileName == filename);
return((data != null) ? data : AllContentData.Find(x => x.AddonFileName == filename));
}
public static ExtractData GetDataByUid(string uid)
{
ExtractData data = ContentData.Find(x => x.AddonUid == uid);
return((data != null) ? data : AllContentData.Find(x => x.AddonUid == uid));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="extract">The method for extracting our parameter</param>
public ACMeasurement(ExtractData extractsim, ExtractParameter <ACMeasurement> extractparam)
{
this.extractsim = extractsim ?? throw new ArgumentNullException(nameof(extractsim));
this.extractparam = extractparam ?? throw new ArgumentNullException(nameof(extractparam));
Analysis = new AC("ACMeasurement");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="extract">The extraction method</param>
public OPMeasurement(ExtractData extract)
{
this.extract = extract;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="node">The positive output node</param>
/// <param name="reference">The negative output node</param>
public OPMeasurement(string node, string reference = null)
{
extract = (SimulationData data) => data.GetVoltage(node, reference);
}
private void backgroundWorkerExtract_DoWork(object sender, DoWorkEventArgs e)
{
ExtractData data = e.Argument as ExtractData;
if (data != null)
{
try
{
var outDir = new DirectoryInfo(data.OutputPath);
if (!outDir.Exists)
{
outDir.Create();
}
for (int i = 0; i < data.Cards.Length; i++)
{
var card = data.Cards[i];
string fileName = card.GenerateFileName();
var charaFile = new FileInfo(Path.Combine(outDir.FullName, fileName));
int attempt = 0;
while (charaFile.Exists)
{
if (attempt > 0)
{
string newName = fileName.Replace(charaFile.Extension, $" ({attempt}){charaFile.Extension}");
charaFile = new FileInfo(Path.Combine(outDir.FullName, newName));
}
else
{
Thread.Sleep(100);
fileName = card.GenerateFileName();
charaFile = new FileInfo(Path.Combine(outDir.FullName, fileName));
}
attempt++;
}
Image image = null;
if (imagesCache.ContainsKey(card))
{
image = imagesCache[card];
}
else if (changeMap.ContainsKey(card))
{
image = GenerateImage(changeMap[card], card.Sex, drawCardBkg, drawCardFrame, drawSceneImage);
}
else
{
image = GenerateImage(card.SourceFileName, card.Sex, drawCardBkg, drawCardFrame, drawSceneImage);
}
if (image != null)
{
using (MemoryStream stream = new MemoryStream())
{
image.Save(stream, ImageFormat.Png);
card.PngData = stream.ToArray();
}
card.Save(charaFile.Create(), data.SaveOptions);
}
int progress = (int)(((float)i / (float)data.Cards.Length) * 100f);
backgroundWorkerExtract.ReportProgress(progress);
}
}
catch (Exception ex)
{
e.Result = ex;
}
}
backgroundWorkerExtract.ReportProgress(100);
}
public static void ParseDirectory()
{
if (ContentPath != null && Directory.Exists(ContentPath))
{
ContentData.Clear();
string[] ContentDirs = Directory.GetDirectories(ContentPath);
foreach (string dir in ContentDirs)
{
string[] ContentFiles = Directory.GetFiles(dir);
string uid = Path.GetFileName(dir);
if (ContentFiles.Length != 0)
{
bool isBin = false;
if (Path.GetExtension(ContentFiles[0]) == ".bin")
{
isBin = true;
}
if (!ContentData.Exists(x => x.AddonUid == uid))
{
var data = new ExtractData
{
AddonFileName = Path.GetFileNameWithoutExtension(ContentFiles[0]),
AddonDirectoryName = Path.GetFileName(dir),
AddonPath = ContentFiles[0],
AddonUid = uid,
IsBin = isBin
};
ContentData.Add(data);
AllContentData.Add(data);
}
}
}
}
string AddonsFolder = Path.Combine(GameFolderPath, "garrysmod", "addons");
if (AddonsFolder != null && Directory.Exists(AddonsFolder))
{
string[] ContentFiles = Directory.GetFiles(AddonsFolder);
if (ContentFiles.Length != 0)
{
foreach (var ContentFile in ContentFiles)
{
string[] SplitStr = Path.GetFileName(ContentFile).Split('_');
string NormalizeUid = SplitStr[SplitStr.Length - 1].Replace(".gma", string.Empty);
var data = new ExtractData
{
AddonFileName = Path.GetFileNameWithoutExtension(ContentFile),
AddonDirectoryName = Path.GetFileName(AddonsFolder),
AddonPath = ContentFile,
AddonUid = NormalizeUid,
IsBin = false
};
AllContentData.Add(data);
if (!ContentData.Exists(x => x.AddonUid == NormalizeUid))
{
ContentData.Add(data);
}
}
}
}
}
private static Process ExtractGma(string gmad_exe_path, string FullExtractPath, ExtractData Addon)
{
try
{
Process gmadProcess = new Process();
ProcessStartInfo startInfo = new ProcessStartInfo(gmad_exe_path, $"\"{Addon.AddonPath}\" -out \"{FullExtractPath}\"");
startInfo.WindowStyle = ProcessWindowStyle.Hidden;
startInfo.UseShellExecute = false;
startInfo.RedirectStandardOutput = false;
startInfo.CreateNoWindow = true;
gmadProcess.StartInfo = startInfo;
Console.WriteLine("Begin the process of GMA unpacking.");
gmadProcess.Start();
gmadProcess.WaitForExit();
gmadProcess.Close();
Console.WriteLine("Unpacking GMA completed.");
if (Addon.IsBin)
{
Directory.Delete(Path.Combine(FullExtractPath, "temp"), true);
}
return(gmadProcess);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(null);
}
static void ExtractNumber(int categoryId)
{
DataDownload.DownPage(categoryId);
ExtractData.Extract(categoryId);
}
public void SelectAllLines()
{
var doc = Application.DocumentManager.MdiActiveDocument;
if (doc == null)
{
return;
}
var ed = doc.Editor;
//CLEAR DATA
mDBTextCollection.Clear();
mLayerCollection.Clear();
mPolylineCollection.Clear();
mLineCollection.Clear();
ExtractData.getInstance().mListLayer.Clear();
PromptSelectionOptions pso = new PromptSelectionOptions();
//Message to user for selction
pso.MessageForAdding = "\nSelect area contains objects: ";
//Remove duplicated selection
pso.AllowDuplicates = false;
// Perform our restricted selection
PromptSelectionResult psr = ed.GetSelection(pso);
if (psr.Status != PromptStatus.OK)
{
return;
}
//[[---------------------------------------------------------
//Get Zero point
PromptPointResult pPtRes;
PromptPointOptions pPtOpts = new PromptPointOptions("");
// Prompt for the start point
pPtOpts.Message = "\nPick Zero point : ";
pPtRes = doc.Editor.GetPoint(pPtOpts);
Point3d ptZero = pPtRes.Value;
ExtractData.getInstance().getZeroPoint().setXY(ptZero.X, ptZero.Y);
// Exit if the user presses ESC or cancels the command
if (pPtRes.Status != PromptStatus.OK)
{
return;
}
//---------------------------------------------------------]]
//[[----------------------------------------------------------
//Get comparison level in double
PromptDoubleOptions pMssOpts = new PromptDoubleOptions("");
pMssOpts.Message = "\nEnter MSS : ";
// Restrict input to positive and non-negative values
pMssOpts.AllowZero = false;
pMssOpts.AllowNegative = false;
// Define the valid keywords and allow Enter
pMssOpts.Keywords.Add("Big");
pMssOpts.Keywords.Add("Small");
pMssOpts.Keywords.Add("Regular");
pMssOpts.Keywords.Default = "Regular";
pMssOpts.AllowNone = true;
// Get the MSS value entered by the user
PromptDoubleResult pMssRes = doc.Editor.GetDouble(pMssOpts);
ExtractData.getInstance().setMss(pMssRes.Value);
//if (pMssRes.Status != PromptStatus.OK)
// return;
//----------------------------------------------------------]]
//Dump debug information to txt file
var sb = new StringBuilder();
//Open a transaction
Transaction tr = doc.TransactionManager.StartTransaction();
foreach (ObjectId acSSObj in psr.Value.GetObjectIds())
{
//get properties
Entity ent = (Entity)tr.GetObject(acSSObj, OpenMode.ForRead);
//CHECKING OBJECT TYPE
switch (ent.GetType().ToString())
{
case "Autodesk.AutoCAD.DatabaseServices.Line":
Line ln = tr.GetObject(acSSObj, OpenMode.ForRead) as Line;
mLineCollection.Add(ln);
break;
case "Autodesk.AutoCAD.DatabaseServices.Polyline":
Polyline pln = tr.GetObject(acSSObj, OpenMode.ForRead) as Polyline;
mPolylineCollection.Add(pln);
break;
case "Autodesk.AutoCAD.DatabaseServices.DBText":
DBText dbt = tr.GetObject(acSSObj, OpenMode.ForRead) as DBText;
mDBTextCollection.Add(dbt);
break;
default:
ed.WriteMessage("\nNo handle");
ed.WriteMessage("\nType: " + ent.GetType().ToString());
break;
}
ent.Dispose();
}
//Apply changes and close transaction
tr.Commit();
mLineCollection.AddRange(mLineUtilObject.convertPolyLineToLine(mPolylineCollection, ed));
List <Line> lines = mLineUtilObject.cuttingLineIfCrossed(mLineCollection);
int numberOfPoint;
//ExtractData extractData = new ExtractData();
double[] arrayX = ExtractData.getInstance().getArrayX();
double[] arrayY = ExtractData.getInstance().getArrayY();
bool[,] isLineMatrix = ExtractData.getInstance().getIsLineMatrix();
//numberOfPoint = mLineUtilObject.convertListLineToArray(lines, arrayX, arrayY, isLineMatrix);
numberOfPoint = mLineUtilObject.convertListLineToArray(mLineCollection, arrayX, arrayY, isLineMatrix);
ed.WriteMessage("number of Point: {0}", numberOfPoint);
extractDataObject.setNumberOfPoint(numberOfPoint);
mLineUtilObject.sortLTRandUTB(extractDataObject.getIndexs(), arrayX, arrayY, numberOfPoint);
sb.Append("Number of line : " + mLineCollection.Count + "\n");
for (int i = 0; i < mLineCollection.Count; i++)
{
sb.Append("\nLine " + (i + 1) + " : " + mLineCollection[i].StartPoint.X + " " + mLineCollection[i].StartPoint.Y);
sb.Append(" " + mLineCollection[i].EndPoint.X + " " + mLineCollection[i].EndPoint.Y + "\n");
}
string fileName = "D:/linedata.txt";
mLineUtilObject.dump(sb.ToString(), ed, fileName);
sb = new StringBuilder();
sb.Append("Number of line : " + lines.Count + "\n");
for (int i = 0; i < lines.Count; i++)
{
sb.Append("\nLine " + (i + 1) + " : " + lines[i].StartPoint.X + " " + lines[i].StartPoint.Y);
sb.Append(" " + lines[i].EndPoint.X + " " + lines[i].EndPoint.Y + "\n");
}
fileName = "D:/lines.txt";
mLineUtilObject.dump(sb.ToString(), ed, fileName);
sb = new StringBuilder();
sb.Append("Number of line : " + lines.Count + "\n");
for (int i = 0; i < numberOfPoint; i++)
{
sb.Append("\nPoint " + (i + 1) + " : " + arrayX[i] + " " + arrayY[i]);
}
fileName = "D:/point.txt";
mLineUtilObject.dump(sb.ToString(), ed, fileName);
fileName = "D:/extractInput.txt";
mLineUtilObject.dump(extractDataObject.getStringInput(), ed, fileName);
extractDataObject.processExtractData();
fileName = "D:/extractOutput.txt";
mLineUtilObject.dump(extractDataObject.getStringResult(), ed, fileName);
}
private void Analyze()
{
try
{
var iDoc = (mshtml.IHTMLDocument2) XuWeBrowser.Document.DomDocument;
if (iDoc != null)
{
var ed = new ExtractData {OuterHtmlSource = iDoc.body.outerHTML};
if (ed.TryParse())
{
if (ed.TryAnalyzeXml())
{
if (ed.IsValid())
{
Measurements.Add(ed);
if (Measurements.Count >= 2)
{
if (!(Measurements[0].Equals(Measurements[1])))
{
// Measurement changed
var current = Measurements[1];
var fp = new CultureInfo("da");
BoosterLog.InfoFormat(
fp
,"{0};{1,6:F};{2,6:F};{3,6:F1};{4,6:F};{5,6:F};{6,6:F1};{7,6:F1};{8,6:F1};{9,6:F1};{10,6};"
, current.TimeStamp
, current.BoosterSpeed
, (current.PressureOut - current.PressureIn)*10
, current.CrossFlow/10f
, current.PressureIn
, current.PressureOut
, current.TempBrineIn
, current.TempBrineOut
, current.TempAirIndoor
, current.TempAirOutdoor
, current.CrossFlow
);
}
// strip off older measurements
while (Measurements.Count > 1)
{
Measurements.RemoveAt(0);
}
}
}
else
{
// ranges outside limits
Logger.WarnFormat("Measuremen outside limits: {0}", ed);
}
}
else
{
// unable to analyze Xml
// aleady logged by exception.
}
}
else
{
// unable to parse
Logger.WarnFormat("Unable to parse Xml: \r\n{0}\r\n", iDoc.body.outerHTML);
}
}
}
catch (Exception ex)
{
Logger.Error("",ex);
}
}
