public static VirtualFile OpenAsFormat(Stream baseStream, string filename, int offset = 0, int length = -1, FileFormat format = FileFormat.None, CacheMethod m = CacheMethod.Default) {
if (length == -1) length = (int)baseStream.Length;
if (format == FileFormat.None) {
format = GuessFormat(filename);
logger.Debug("Guessed format: {0}", format);
}
switch (format) {
case FileFormat.Csf:
return new CsfFile(baseStream, filename, offset, length, m != CacheMethod.NoCache); // defaults to cache
case FileFormat.Hva:
return new HvaFile(baseStream, filename, offset, length, m != CacheMethod.NoCache); // defaults to not cache
case FileFormat.Ini:
return new IniFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Missions:
return new MissionsFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Mix:
return new MixFile(baseStream, filename, offset, length, m == CacheMethod.Cache);
case FileFormat.Pal:
return new PalFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Pkt:
return new PktFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Shp:
return new ShpFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Tmp:
return new TmpFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Vpl:
return new VplFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Vxl:
return new VxlFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Ukn:
default:
return new VirtualFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
}
}
public HfzFile loadFile(string fileName, FileFormat format)
{
HfzFile file = new HfzFile();
Stream fs = null;
EndianBinaryReader reader = null;
try
{
debugLine("File format: " + format + ", file name: " + fileName);
//create a file stream to work with during load
fs = Util.openStream(fileName, format, FileMode.Open);
reader = Util.createEndianBinaryReaderForStream(fs);
HfzHeader header = hfzReadHeader(reader);
file.header = header;
Dictionary<short, HfzTile> tiles = readTiles(header, reader);
file.mapData = tiles;
}
catch(Exception ex)
{
throw ex;
}
finally
{
reader.Close();
if (debug)
{
writeLog.Close();
}
}
return file;
}
public AmfFile loadFile(string fileName, FileFormat format)
{
Stream fs = null;
EndianBinaryReader reader = null;
try
{
debugLine("File format: " + format + ", file name: " + fileName);
fs = Util.openStream(fileName, format, FileMode.Open);
reader = Util.createEndianBinaryReaderForStream(fs);
AmfFile file = readAmfFile(reader);
return file;
}
catch(Exception ex)
{
throw ex;
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
public void saveFile(string fileName, FileFormat format, AmfFile file)
{
Stream fs = null;
EndianBinaryWriter writer = null;
try
{
debugLine("File format: " + format + ", file name: " + fileName);
fs = Util.openStream(fileName, format, FileMode.Create);
writer = Util.createEndianBinaryWriterForStream(fs);
writeAmfFile(writer, file);
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (writer != null)
{
writer.Close();
if (format == FileFormat.COMPRESSED)
{
Util.compressFile(fileName);
}
}
}
}
public Asset(SNOGroup group, Int32 snoId, string name)
{
this.Data = null;
this.Group = group;
this.SNOId = snoId;
this.Name = name;
this.FileName = group + "\\" + this.Name + FileExtensions.Extensions[(int)group];
}
public DdsSaveConfig(FileFormat fileFormat, int compressorType, int errorMetric, bool weightColorByAlpha, bool generateMipMaps) {
FileFormat = fileFormat;
CompressorType = compressorType;
ErrorMetric = errorMetric;
WeightColorByAlpha = weightColorByAlpha;
GenerateMipMaps = generateMipMaps;
}
public void UpdateFile(short webFileID, FileFormat fileFormat)
{
InvokeSafeSingleCall(() => {
var f = SiteFileStore.DataSource.GetByKey(webFileID);
f.DateupDatedutc = DateTime.UtcNow;
f.Fileformat = fileFormat;
f.Save();
return f.ID;
}, default(short));
}
private void Load()
{
if (!MPQStorage.CoreData.AssetFormats.ContainsKey(this.Group)) return;
var formatType = MPQStorage.CoreData.AssetFormats[this.Group];
var file = MPQStorage.CoreData.FileSystem.FindFile(this.FileName);
if (file == null || file.Size < 10) return;
this.Data = (FileFormat) Activator.CreateInstance(formatType, new object[] {file});
}
/// <summary>
/// Gets file format.
/// </summary>
/// <param name="fileFormat">Select <see cref="FileFormat"/>.</param>
/// <returns>Proper file format as <see cref="string"/>.</returns>
public static string Get(FileFormat fileFormat)
{
switch (fileFormat)
{
case FileFormat.Generic:
return "YYYYMMHH";
}
return string.Empty;
}
public void DownloadAudioAsync(AudioInformation audioInformation, FileFormat format, AudioBitrate bitrate, string destinationFileName)
{
if (!audioInformation.IsAvailableInFormatAndBitrate(format, bitrate))
throw new QualityNotAvailableException();
audioInProgress = audioInformation;
var downloadLink = audioInformation.GetDownloadURL(format, bitrate);
webClient.DownloadFileAsync(new Uri(downloadLink), destinationFileName);
}
/// <summary>
/// Occurs before an action is executed
/// </summary>
/// <param name="filterContext"></param>
public void OnActionExecuting(ActionExecutingContext filterContext)
{
FileFormat format = GetFileFormat(filterContext.HttpContext.Request.Path);
if (IsDisallowed(format))
{
throw new ArgumentException("Requested format has been disallowed");
}
RequestedFormat = format;
}
/// <summary>
/// 获取文件类型格式扩展名字符串
/// </summary>
/// <param name="fileFormat">格式枚举</param>
/// <returns>扩展名字符串</returns>
public static string GetFileFormat(FileFormat fileFormat)
{
switch (fileFormat) {
case FileFormat.JPG:
return ".jpg";
case FileFormat.PNG:
return ".png";
default:
return string.Empty;
}
}
public short GetNextFileID(FileFormat imageFormat)
{
return InvokeSafeSingleCall(() => {
var f = new SiteFileStore {
Accesscount = default(int),
Fileformat = imageFormat
};
f.Save();
return f.ID;
}, default(short));
}
/// <summary>
/// The get.
/// </summary>
/// <param name="fileFormat">
/// The file format.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public static string Get(FileFormat fileFormat)
{
switch (fileFormat)
{
case FileFormat.Generic:
// 20140101 000200;1.30111;1.309610;1.306350;1.306455;10
return @"^(?<date>\d{8}) (?<time>\d{6});(?<open>[0-9]*\.?[0-9]+);(?<high>[0-9]*\.?[0-9]+);(?<low>[0-9]*\.?[0-9]+);(?<close>[0-9]*\.?[0-9]+);(?<vol>[0-9]*\.?[0-9]+)";
}
return string.Empty;
}
public Asset(SNOGroup group, Int32 snoId, byte[] name)
{
this.Data = null;
this.Group = group;
this.SNOId = snoId;
int count = 0; while (count < 128 && name[count] != 0) count++;
this.Name = Encoding.UTF8.GetString(name.Take(count).ToArray());
this.FileName = group + "\\" + this.Name + FileFormats.FileExtensions.Extensions[(int)group];
this.Load();
}
// Constructor
public FileReader(string path)
{
// Init instance vars
reading = false;
clip = null;
this.path = path;
path = path.ToLower();
if (path.EndsWith(".wav")) this.format = FileFormat.WAV;
else if (path.EndsWith(".mp3")) this.format = FileFormat.MPEG;
else if (path.EndsWith(".ogg")) this.format = FileFormat.OGG;
else if (path.EndsWith(".ryt")) this.format = FileFormat.RYT;
else this.format = FileFormat.ERROR;
readDataPointer = 0;
}
private async Task<StorageFile> WriteableBitmapToStorageFile(WriteableBitmap wb, FileFormat fileFormat)
{
string FileName = "MyFile.";
Guid BitmapEncoderGuid = BitmapEncoder.JpegEncoderId;
switch (fileFormat)
{
case FileFormat.Jpeg:
FileName += "jpeg";
BitmapEncoderGuid = BitmapEncoder.JpegEncoderId;
break;
case FileFormat.Png:
FileName += "png";
BitmapEncoderGuid = BitmapEncoder.PngEncoderId;
break;
case FileFormat.Bmp:
FileName += "bmp";
BitmapEncoderGuid = BitmapEncoder.BmpEncoderId;
break;
case FileFormat.Tiff:
FileName += "tiff";
BitmapEncoderGuid = BitmapEncoder.TiffEncoderId;
break;
case FileFormat.Gif:
FileName += "gif";
BitmapEncoderGuid = BitmapEncoder.GifEncoderId;
break;
}
var file = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(FileName, CreationCollisionOption.ReplaceExisting);
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoderGuid, stream);
Stream pixelStream = wb.PixelBuffer.AsStream();
byte[] pixels = new byte[pixelStream.Length];
await pixelStream.ReadAsync(pixels, 0, pixels.Length);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore,
(uint)wb.PixelWidth,
(uint)wb.PixelHeight,
96.0,
96.0,
pixels);
await encoder.FlushAsync();
}
return file;
}
/// <summary>
/// Вернуть класс сохраняюший EPROM устройства в указанном формате
/// </summary>
/// <param name="format">Формат в котором неоходимо сохранить EPROM устройства</param>
/// <returns>Класс, выполняющий сохранение EPROM в файл</returns>
public static IEFSaver CreateSaver(FileFormat format)
{
switch (format)
{
case FileFormat.EF1TXT:
return new EF1TXTSaver();
case FileFormat.EF2XML:
return new EF2XMLSaver();
}
return null;
}
public void RunExport(List<Item> itemsToExport, List<ID> fieldsToExport, string fileName, FileFormat format)
{
if (itemsToExport.Count > 0 && fieldsToExport.Count > 0)
{
ImportExportManager.GenerateFile(itemsToExport, fieldsToExport, fileName, format);
JobStatus status = Sitecore.Context.Job.Status;
status.State = JobState.Finished;
}
else
{
}
}
/// <summary>
/// Возвращает загрузчик EPROM для указанного формата файла
/// </summary>
/// <param name="format">Формат в котором хранится EPROM устройства</param>
/// <returns>Загрузчик для указанного формата</returns>
public static IEFLoader CreateLoader(FileFormat format)
{
switch (format)
{
case FileFormat.EF1TXT:
return new EF1TXTLoader();
case FileFormat.EF2XML:
return new EF2XMLLoader();
case FileFormat.EF2XMLOLD:
return new EF2XMLOLDLoader();
}
return null;
}
/// <summary>
/// Archives a file, zipping it up and moving it or just moving it based on the passed in params. Also removes the un-zipped file from the file system
/// </summary>
/// <param name="sourcePath">Absolute path to the source file including file name</param>
/// <param name="destinationPath">Path to the directory that source file will be archived to</param>
/// <param name="zip">Set this to true if the file you are archiving needs to be zipped</param>
/// <param name="format">Enum based</param>
/// <param name="tempFolder"></param>
/// <returns>Bool</returns>
public static bool Archive(string sourcePath, string destinationPath, bool zip, FileFormat format, string tempFolder)
{
if (zip)
{
if (!S3FileExists(sourcePath))
throw new FileNotFoundException(String.Format("File {0} does not exist.", sourcePath));
// zip and if successful, delete the unzipped source file
var file = new FileInfo(sourcePath);
var tempFile = tempFolder + Guid.NewGuid().ToString() + ".zip";
var zipSuccess = zipFile(sourcePath, tempFile);
if (zipSuccess)
{
try
{
using (var zipStream = new FileStream(tempFile, FileMode.Open, FileAccess.Read))
{
CopyFileToS3Archive(destinationPath, zipStream, file.Name.Replace(file.Extension, ".zip"), tempFolder);
DeleteS3File(sourcePath);
return true;
}
}
finally
{
if (File.Exists(tempFile))
File.Delete(tempFile);
}
}
}
using (var fileStream = GetS3File(sourcePath))
if (fileStream != null)
{
var file = new FileInfo(sourcePath);
CopyFileToS3Archive(destinationPath, fileStream, file.Name, tempFolder);
DeleteS3File(sourcePath);
return true;
}
throw new FileNotFoundException(String.Format("File {0} does not exist.", sourcePath));
}
public void saveFile(string fileName, FileFormat format, HfzFile file)
{
HfzHeader fh = validateHeader(file);
// initiate the writing procedure
EndianBinaryWriter fileWriter = null;
try
{
// open file for writing
Stream stream = Util.openStream(fileName, format, FileMode.Create);
fileWriter = Util.createEndianBinaryWriterForStream(stream);
hfzWriteHeader(ref fileWriter, fh);
// writing tiles
List<short> keys = file.getTileKeys();
foreach (short key in keys)
{
hfzWriteTile(ref fileWriter, fh, file.getTileData(key));
}
fileWriter.Close();
}
catch(Exception ex)
{
throw new Exception("Error writing file " + fileName, ex);
}
finally
{
// close file
if (fileWriter != null)
{
fileWriter.Close();
if (format == FileFormat.COMPRESSED)
{
Util.compressFile(fileName);
}
}
}
}
public static bool LoadFromFile(FileFormat fileFormat, string path, int startingRow, int rowsLimit, out TimeSpan period, out List<BarData> datas)
{
datas = null;
period = TimeSpan.Zero;
if (fileFormat == FileFormat.CVSDefault)
{
LoadFromFileCSV(path, startingRow, rowsLimit, out datas);
}
else
{
return false;
}
// Find out what is the most oftenly occuring period - use it (for ex. consider weekends, holidays).
SortedDictionary<double, int> periodOccurences = new SortedDictionary<double, int>();
for (int i = 1; i < datas.Count; i++)
{
TimeSpan timeInterval = datas[i].DateTime - datas[i - 1].DateTime;
if (periodOccurences.ContainsKey(timeInterval.TotalMinutes) == false)
{
periodOccurences.Add(timeInterval.TotalMinutes, 1);
}
else
{
periodOccurences[timeInterval.TotalMinutes]++;
}
}
int totalOccurences = 0;
foreach (double periodMinutes in periodOccurences.Keys)
{// Keep going looking for the period with most occurences.
if (periodOccurences[periodMinutes] > totalOccurences)
{
period = TimeSpan.FromMinutes(periodMinutes);
totalOccurences = periodOccurences[periodMinutes];
}
}
return true;
}
/// <summary>
/// Prepares a text description which is compatible with 'rtpsend' among other 'rtp tools'.
/// </summary>
/// <param name="format">The <see cref="FileFormat"/> to output.</param>
/// <param name="packets">The <see cref="Rtcp.RtcpPacket"/>'s to describe</param>
/// <param name="time">Timeoffset from when recoding began, should be 0 for the first packet.</param>
/// <param name="source">The <see cref="System.Net.IPEndPoint"/> from which the packet was received.</param>
/// <returns>The text which describes the packet if the <paramref name="format"/> is a text format, otherwise an empty string</returns>
public static string ToTextualConvention(FileFormat format, IEnumerable<Rtcp.RtcpPacket> packets, TimeSpan time, System.Net.IPEndPoint source)
{
//Short form does not allow Rtcp, Binary Formats have no textual convention.
if (packets == null || format == FileFormat.Short || format <= FileFormat.Dump) return string.Empty;
//Store the hex payload in one builder
StringBuilder hexPayload = format == FileFormat.Hex ? new StringBuilder(64) : null;
//And the overall result in another
StringBuilder builder = new StringBuilder(64);
int totalLength = 0;
foreach (Rtcp.RtcpPacket packet in packets)
{
//Build the Expression of the packet given as an individual expression
//(T=>)
builder.Append(RtpSend.ToTextualConvention(format, packet));
//Increment for totalLength
totalLength += packet.Length;
if (format == FileFormat.Hex)
hexPayload.Append(BitConverter.ToString(packet.Payload.ToArray()).Replace("-", string.Empty));
}
//Insert the header
builder.Insert(0, string.Format(RtpSend.Format,
//0
time.TotalSeconds.ToString("0.000000"),
//1
string.Format(RtpSend.RtcpPacketFormat,
//0
totalLength,
//1
source.Address.ToString() + ':' + source.Port.ToString())));
//hex dump
if (format == FileFormat.Hex)
if (totalLength > 0) builder.Append(string.Format(HexFormat, "data", hexPayload, (char)Common.ASCII.LineFeed));
else builder.Append(string.Format(HexFormat, "data", NullSpecifier, (char)Common.ASCII.LineFeed));
//Return the allocated result
return builder.ToString();
}
/// <summary>
/// Save a Microsoft Word document as PDF
/// </summary>
/// <param name="filename"></param>
/// <param name="format"></param>
public void SaveWordDocumentAs(String filename, FileFormat format)
{
switch (format) {
case FileFormat.PDF:
SaveWordDocumentAsPdf(filename);
break;
case FileFormat.HTML:
break;
case FileFormat.TXT:
break;
case FileFormat.DOC:
break;
case FileFormat.DOCX:
break;
case FileFormat.RTF:
break;
}
}
public void Initialise()
{
Simulations basicFile = Utilities.GetRunnableSim();
IModel simulation = basicFile.FindInScope <Simulation>();
IModel paddock = basicFile.FindInScope <Zone>();
// Add a weather component.
Models.Climate.Weather weather = new Models.Climate.Weather();
weather.Name = "Weather";
weather.FileName = "asdf.met";
Structure.Add(weather, simulation);
// Add a second weather component.
Models.Climate.Weather weather2 = new Models.Climate.Weather();
weather2.FileName = "asdf.met";
weather2.Name = "Weather2";
Structure.Add(weather2, simulation);
// Add a third weather component.
Models.Climate.Weather weather3 = new Models.Climate.Weather();
weather3.FileName = "asdf.met";
weather3.Name = "Weather3";
Structure.Add(weather3, simulation);
// Add a third weather component.
Models.Climate.Weather weather4 = new Models.Climate.Weather();
weather4.FileName = "asdf.met";
weather4.Name = "Weather4";
Structure.Add(weather4, simulation);
// Add a report.
Models.Report report = new Models.Report();
report.Name = "Report";
Structure.Add(report, paddock);
// Add the wheat model.
string json = ReflectionUtilities.GetResourceAsString(typeof(IModel).Assembly, "Models.Resources.Wheat.json");
Plant wheat = FileFormat.ReadFromString <IModel>(json, out _).Children[0] as Plant;
wheat.ResourceName = "Wheat";
Structure.Add(wheat, paddock);
Manager manager = new Manager();
manager.Code = @"using Models.PMF;
using Models.Core;
using System;
namespace Models
{
[Serializable]
public class Script : Model
{
[Description(""an amount"")]
public double Amount { get; set; }
}
}";
Structure.Add(manager, paddock);
Physical physical = new Physical();
physical.BD = new double[5];
physical.AirDry = new double[5];
physical.LL15 = new double[5];
Structure.Add(physical, paddock);
basicFile.Write(basicFile.FileName);
fileName = basicFile.FileName;
// Create a new .apsimx file containing two weather nodes.
Simulations test = Utilities.GetRunnableSim();
IModel sim = test.FindInScope <Simulation>();
Models.Climate.Weather w1 = new Models.Climate.Weather();
w1.FileName = "w1.met";
w1.Name = "w1";
Structure.Add(w1, sim);
Models.Climate.Weather w2 = new Models.Climate.Weather();
w2.Name = "w2";
w2.FileName = "w2.met";
Structure.Add(w2, sim);
extFile = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".apsimx");
test.Write(extFile);
}
public void TestEditing()
{
string configFile = Path.GetTempFileName();
File.WriteAllLines(configFile, new[]
{
// Modify an array
"[Report].VariableNames = x,y,z",
// Modify a date - try a few different formats.
"[Clock].StartDate = 2000-01-01",
"[Clock].EndDate = 2000-01-10T00:00:00",
// Modify a string
"[Weather].FileName = fdsa.met",
@"[Weather2].FullFileName = .\jkl.met",
// Replace a model with a model from another file.
$"[Weather3] = {extFile}",
$"[Weather4] = {extFile};[w2]",
});
string models = typeof(IModel).Assembly.Location;
string args = $"{fileName} /Edit {configFile}";
var proc = new ProcessUtilities.ProcessWithRedirectedOutput();
proc.Start(models, args, Path.GetTempPath(), true, true);
proc.WaitForExit();
// Children of simulation are, in order:
// Clock, summary, zone, Weather, Weather2, w1, w2
Assert.AreEqual(null, proc.StdOut);
Assert.AreEqual(null, proc.StdErr);
Simulations file = FileFormat.ReadFromFile <Simulations>(fileName, out List <Exception> errors);
if (errors != null && errors.Count > 0)
{
throw errors[0];
}
var report = Apsim.Find(file, typeof(Models.Report)) as Models.Report;
string[] variableNames = new[] { "x", "y", "z" };
Assert.AreEqual(variableNames, report.VariableNames);
IModel sim = Apsim.Child(file, typeof(Simulation));
// Use an index-based lookup to locate child models.
// When we replace an entire model, we want to ensure
// that the replacement is inserted at the correct index.
Clock clock = sim.Children[0] as Clock;
Assert.AreEqual(new DateTime(2000, 1, 1), clock.StartDate);
Assert.AreEqual(new DateTime(2000, 1, 10), clock.EndDate);
var weather = sim.Children[3] as Models.Weather;
Assert.NotNull(weather);
Assert.AreEqual("Weather", weather.Name);
Assert.AreEqual("fdsa.met", weather.FileName);
var weather2 = sim.Children[4] as Models.Weather;
Assert.NotNull(weather2);
Assert.AreEqual("Weather2", weather2.Name);
Assert.AreEqual(@".\jkl.met", weather2.FileName);
// Weather3 and Weather4 should have been
// renamed to w1 and w2, respectively.
var weather3 = sim.Children[5] as Models.Weather;
Assert.NotNull(weather3);
Assert.AreEqual("w1", weather3.Name);
Assert.AreEqual("w1.met", weather3.FileName);
var weather4 = sim.Children[6] as Models.Weather;
Assert.NotNull(weather4);
Assert.AreEqual("w2", weather4.Name);
Assert.AreEqual("w2.met", weather4.FileName);
}
public void TestManagerParameterChanges()
{
Manager m = new Manager()
{
Name = "Manager",
Code = "using System; namespace Models { using Core; [Serializable] public class Script : Models.Core.Model { [Description(\"x\")] public string X { get; set; } } }"
};
Simulations sims = new Simulations()
{
Children = new List <IModel>()
{
new DataStore(),
new Experiment()
{
Name = "expt",
Children = new List <IModel>()
{
new Factors()
{
Children = new List <IModel>()
{
new Factor()
{
Name = "x",
Specification = "[Manager].Script.X = 1"
}
}
},
new Simulation()
{
Name = "sim",
Children = new List <IModel>()
{
new Clock()
{
StartDate = new DateTime(2020, 1, 1),
EndDate = new DateTime(2020, 1, 2),
Name = "Clock"
},
new Summary(),
m
}
}
}
}
}
};
sims.ParentAllDescendants();
m.OnCreated();
Runner runner = new Runner(sims);
string temp = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
try
{
IEnumerable <string> files = GenerateApsimXFiles.Generate(runner, 1, temp, _ => {});
Assert.AreEqual(1, files.Count());
string file = files.First();
sims = FileFormat.ReadFromFile <Simulations>(file, e => throw e, false);
Assert.AreEqual("1", sims.FindByPath("[Manager].Script.X").Value);
}
finally
{
if (Directory.Exists(temp))
{
Directory.Delete(temp, true);
}
}
}
/// <summary>
/// Export the
/// </summary>
/// <param name="ToFile"></param>
/// <param name="listSections"></param>
/// <param name="outputFormat"></param>
public static void Export(string toFile, UltraGrid grid, ExportSectionList listSections, FileFormat outputFormat)
{
// Create the report itself
Report report = new Report();
// ...then the sections for header, footer and body
ISection mainSection = report.AddSection();
mainSection.PageMargins = new Infragistics.Documents.Reports.Report.Margins(50);
ISectionHeader headerSection = mainSection.AddHeader();
headerSection.Height = 50;
headerSection.Repeat = true;
ISectionFooter footerSection = mainSection.AddFooter();
footerSection.Height = 50;
// Add the body of the report which is the contents of the grid
UltraGridDocumentExporter exporter = new UltraGridDocumentExporter();
exporter.Export(grid, mainSection);
// Setup the page numbering
PageNumbering pn = mainSection.PageNumbering;
// The Template property is the actual string that shows the page numbering. Use the [Page #] place-
// holder for the current page and the [TotalPages] place-holder for the total amount of pages in
// the entire document.
pn.Template = "Page [Page #] of [TotalPages]";
// Setting SkipFirst to true does not place page numbering on the first page of the section. This
// is useful if the first page is a Title page.
pn.SkipFirst = false;
// The page numbering will be aligned with the right side of the page. Valid values off the
// Alignment enum include Left, Center, and Right.
pn.Alignment.Horizontal = Alignment.Right;
// The page numbering will be located at the bottom of the page. Valid values off the
// Alignment enum include Top and Bottom.
pn.Alignment.Vertical = Alignment.Bottom;
// The page numbering is at the extreme bottom of the page, so we need to change the Y Offset
// in order to bring it in line with the rest of the page footer text.
pn.OffsetY = -18;
// Delete the old report if it exists
try
{
if (File.Exists(toFile))
{
File.Delete(toFile);
}
}
catch (Exception)
{
//Ignore any errors
}
// Generate the report
try
{
report.Generate();
report.Publish(toFile, outputFormat);
}
catch (Exception ex)
{
MessageBox.Show("Failed to write the export file " + toFile + ", the error was " + ex.Message);
}
}
public ObjectWriter (XmlDocument doc, FileFormat format)
{
this.doc = doc;
this.format = format;
}
// -------- вернуть загрузчика -------
public IEFLoader GetEFLoader(FileFormat format)
{
return(EFLoader.CreateLoader(format));
}
/// <summary>
/// 文档加载后的处理
/// </summary>
/// <param name="format">加载文档的格式</param>
public virtual void AfterLoad(FileFormat format)
{
}
internal void AddSubRecord(string name, string description, bool required, FileFormat format)
{
SubRecords.Add((this._name, $"{this._name}_{name}"));
var p = new Field($"{this._name}_{name}", name)
{
Modifiers = Modifiers.Public
};
if (required)
{
p.Modifiers |= Modifiers.ReadOnly;
p.Value = $"new {this._name}_{name}()";
}
this._genClass.Members.Add(p);
if (required)
{
this._constructorRead.Body.AppendLine(
$"this.{name} = this.Fields.First(x => x.Type == {this._name}_{name}.FieldType) as {this._name}_{name};");
this._getSubRecordsForWriting.Body.AppendLine($"ret.Add(this.{name});");
}
else
{
this._constructorRead.Body.AppendLine(
$"this.{name} = this.Fields.FirstOrDefault(x => x.Type == {this._name}_{name}.FieldType) as {this._name}_{name};");
this._getSubRecordsForWriting.Body.AppendLine($"if(this.{name} != null) ret.Add(this.{name});");
}
this.AddSubRecordNoField(name, description, required, format);
}
internal override Class259 vmethod_9(FileFormat fileFormat)
{
return((Class259) new DxfDimensionObjectContextData.Class313((DxfHandledObject)this));
}
public override TargetFrameworkMoniker GetDefaultTargetFrameworkForFormat(FileFormat format)
{
return(new TargetFrameworkMoniker("4.0"));
}
public override bool SupportsFormat(FileFormat format)
{
return(format.Id == "MSBuild10");
}
//Move to RtpSendExtensions?
/// <summary>
/// Parses the data contained in the given <see cref="System.IO.BinaryReader"/> for data which corresponds to a format compatible with <see href="http://www.cs.columbia.edu/irt/software/rtptools/#rtpsend">rtpsend</see>.
/// If a Binary format is encoutered (by the presence of the "#!rtpplay1.0" file header then <see cref="RtpTools.RtpDump.RtpDumpExtensions.ReadBinaryToolEntry"/> will be called implicitly with the reader given,
/// In such a case, unexpected will contain the data which matched the file header.
/// </summary>
/// <param name="reader">The <see cref="System.IO.BinaryReader"/> which should be created using <see cref="System.Text.Encoding.ASCII"/></param>
/// <param name="format">The format found while parsing the description.</param>
/// <param name="unexpected">Will only contain data if format was unknown, and contains the data encountered in the stream while attempting to parse.</param>
/// <returns>The item which was created as a result of reading from the stream.</returns>
internal static RtpToolEntry ParseText(System.IO.BinaryReader reader, System.Net.IPEndPoint source, ref FileFormat format, out byte[] unexpected)
{
unexpected = null;
double timeOffset = 0;
System.Net.IPEndPoint sourceInfo = source;
long position = reader.BaseStream.Position;
Common.IPacket builtPacket = null;
//Keep track of making a Rtp or Rtcp entry.
bool rtp = false;
Rtp.RtpPacket rtpP = null;
Rtcp.RtcpPacket rtcP = null;
///<summary>
/// each entry starts with a time value, in seconds, relative to the beginning of the trace.
/// The time value must appear at the beginning of a line, without white space. Within an RTP or RTCP packet description,
/// parameters may appear in any order, without white space around the equal sign.
/// Lines are continued with initial white space on the next line.
/// Comment lines start with #. Strings are enclosed in quotation marks.
/// <see cref="Tokens"/>
///</summary>
//The amount of tokens consumed from the reader, where a token is defined as above
int tokensParsed = -1,
//The amount of bytes read
lineBytesLength = 0,
//Used for token parsing, the index of the recognized token in 'Tokens'
tokenIndex = -1;
//Indicates if in a comment
bool parsingCommentOrWhitespace = false;
//Contains the data read from the stream until '\n' occurs.
byte[] lineBytes;
//Indicates if the parsing of the entry is complete
bool doneParsing = false, formatUnknown = format == FileFormat.Unknown, needAnyToken = true;
//A string instance which was used to compare to known `Tokens`
string token;
//No bytes have actually been consumed from the stream yet, while not done parsing and not at the end of the stream
while (!doneParsing && reader.BaseStream.Position < reader.BaseStream.Length)
{
//Determine the following character (ASCIIEncoding SHOULD have been specified in creation of the reader) [If not could possibly have also found out without consuming a byte here]
int peek = reader.PeekChar();
//If no data can be read
if (peek == -1)
{
//then indiate an unknown format and then return null
format = FileFormat.Unknown;
return null;
}
else if (peek == RtpDump.RtpDumpExtensions.Hash || peek == (char)Common.ASCII.Space)
{
//Comment lines start with # (Hash). Strings are enclosed in quotation marks.
parsingCommentOrWhitespace = true;
//Could be a binary format however....
}
else if (tokensParsed > 0 && peek == 'r' || peek == Common.ASCII.R) //Don't read any further a new entry follows (Could be a malformed entry with rXXX=YYY\n)
{
//doneParsing = true;
break;
}
//Read until '\n' occurs
RtpSendExtensions.ReadLineFeed(reader.BaseStream, out lineBytes);
//Keep track of the amount of bytes read
lineBytesLength = lineBytes.Length;
//If nothing was read return
if (lineBytesLength == 0) return null;
//If the format is unknown then
if (formatUnknown)
{
//check for the Binary format at the known ordinal, if found
if (lineBytesLength > 2 && lineBytes[0] == RtpDump.RtpDumpExtensions.Hash && lineBytes[1] == RtpDump.RtpDumpExtensions.Bang)
{
//Indicate a binary format so far
format = FileFormat.Binary;
//give the `unexpected` data back to the caller, which consisted of the header
unexpected = lineBytes;
//Remove the reference to the token now
token = null;
//Return the result of reading the binary entry.
return null;
}
//Check for the short form before parsing a token
//Search for '='
tokenIndex = Array.IndexOf<byte>(lineBytes, Common.ASCII.EqualsSign);
//If not found then this must be a Short entry.
if (tokenIndex == -1)
{
//No longer unknown because,
formatUnknown = false;
//This seems to be Short format
format = FileFormat.Short;
}
else //There was a '=' sign
{
//No longer still unknown because,
//This seems to be a Text format
format = FileFormat.Text;
//but we need to consume tokens until data in tokens as they occur to be sure
}
}
//If not found then this must be a Short entry.
if (format == FileFormat.Short) return RtpToolEntry.CreateShortEntry(DateTime.UtcNow.Subtract(TimeSpan.FromMilliseconds(timeOffset)), sourceInfo, lineBytes, 0, position);
else if (parsingCommentOrWhitespace)//If parsing a whitespace or a comment
{
//Not parsing the comment / whitespace any more
parsingCommentOrWhitespace = false;
//Perform another iteration
continue;
}
else if (needAnyToken) //If a token is needed
{
//Extract all tokens from the lineBytes
string[] tokens = Encoding.ASCII.GetString(lineBytes).Split((char)Common.ASCII.Space, (char)Common.ASCII.EqualsSign, '(', ')');
//Any hex data will need a length, and we start at offset 0.
int dataLen = 0, tokenOffset = 0;
//If nothing was tokenized then return the unexpected data.
if (tokens.Length == 0)
{
unexpected = lineBytes;
return null;
}
//The first token must be a timeOffset
if (timeOffset == 0) timeOffset = double.Parse(tokens[tokenOffset++]);
//For each token in the tokens after the timeOffset
for (int e = tokens.Length; tokenOffset < e; ++tokenOffset)
{
//Get the token at the index
token = tokens[tokenOffset];
//Determine what to do based on if there was a matching token in the Tokens array.
tokenIndex = Array.IndexOf<string>(Tokens, token);
//The entry must be finished.
if (-1 == tokenIndex)
{
unexpected = lineBytes;
break;
}
//Increment for a token parsed within the entry so far
++tokensParsed;
//Switch out logic based on token
switch (tokenIndex)
{
//RTP
case 1:
{
//The created structure will have a packetLength = 8 + dataLen
rtp = true;
rtpP = new Rtp.RtpPacket(0, false, false, Media.Common.MemorySegment.EmptyBytes);
builtPacket = rtpP;
//Do another iteration
continue;
}
//RTCP
case 17:
{
rtcP = new Rtcp.RtcpPacket(0, 0, 0, 0, 0, 0);
//The created structure will have packetLen = 0 to indicate Rtcp.
builtPacket = rtcP;
//Do another iteration
continue;
}
case 35: //from
{
string[] parts = tokens[++tokenOffset].Split((char)Common.ASCII.Colon);
System.Net.IPAddress ip = System.Net.IPAddress.Parse(parts[0]);
int port = int.Parse(parts[1]);
System.Diagnostics.Debug.WriteLine(ip + " " + port);
sourceInfo = new System.Net.IPEndPoint(ip, port);
continue;
}
case 2:
{
//version
int version = int.Parse(tokens[++tokenOffset]);
System.Diagnostics.Debug.WriteLine(version);
if (rtp) rtpP.Header.Version = version;
else rtcP.Header.Version = version;
continue;
}
case 3: //p
{
int paddingCount = int.Parse(tokens[++tokenOffset]);
System.Diagnostics.Debug.WriteLine(paddingCount);
break;
}
case 4: //x
{
if (rtp)
{
bool hasExtension = int.Parse(tokens[++tokenOffset]) == 1;
System.Diagnostics.Debug.WriteLine(hasExtension);
rtpP.Header.Extension = hasExtension;
}
break;
}
case 5: //m
{
if (rtp)
{
bool hasMarker = int.Parse(tokens[++tokenOffset]) == 1;
System.Diagnostics.Debug.WriteLine(hasMarker);
rtpP.Header.Marker = hasMarker;
}
break;
}
case 6: //pt
{
int payloadType = int.Parse(tokens[++tokenOffset]);
System.Diagnostics.Debug.WriteLine(payloadType);
if (rtp) rtpP.Header.PayloadType = payloadType;
else rtcP.Header.PayloadType = payloadType;
break;
}
case 7: //ts
{
if (rtp)
{
int ts = int.Parse(tokens[++tokenOffset]);
System.Diagnostics.Debug.WriteLine(ts);
rtpP.Header.Timestamp = ts;
}
break;
}
case 8: //seq
{
if (rtp)
{
int seq = int.Parse(tokens[++tokenOffset]);
System.Diagnostics.Debug.WriteLine(seq);
rtpP.Header.SequenceNumber = seq;
}
break;
}
case 9: //ssrc
{
token = tokens[++tokenOffset];
token = token.Remove(token.Length - 1).Replace(HexSpecifier, string.Empty);
int ssrc = 0;
if (!int.TryParse(token, out ssrc)) //plain int
ssrc = int.Parse(token, System.Globalization.NumberStyles.HexNumber);//hex
System.Diagnostics.Debug.WriteLine(ssrc);
if (rtp) rtpP.Header.SynchronizationSourceIdentifier = ssrc;
else rtcP.Header.SendersSynchronizationSourceIdentifier = ssrc;
break;
}
case 10: //cc
{
int cc = int.Parse(tokens[++tokenOffset]);
System.Diagnostics.Debug.WriteLine(cc);
if (rtp) rtpP.Header.ContributingSourceCount = cc;
else rtcP.Header.BlockCount = cc;
break;
}
case 11: //csrc
{
int csrc = int.Parse(tokens[++tokenOffset]);
System.Diagnostics.Debug.WriteLine(csrc);
//Add to a list.
break;
}
case 12://data
{
//Token based reading may not be required anymore
needAnyToken = false;
//Not unknown anymore because,
formatUnknown = false;
//Definitely hex format
format = FileFormat.Hex;
//The next token is the string in hex format of the payload.
++tokenIndex;
//If it begins with Hash then its NIL
//Done parsing the entry.
doneParsing = true;
continue;
}
case 13: //ext_type
{
int ext_type = int.Parse(tokens[++tokenOffset]);
System.Diagnostics.Debug.WriteLine(ext_type);
break;
}
case 14: //ext_len
{
int ext_len = int.Parse(tokens[++tokenOffset]);
System.Diagnostics.Debug.WriteLine(ext_len);
break;
}
case 15: //ext_data
{
//The next token is the string in hex format of the payload.
++tokenIndex;
//If it begins with Hash then its NIL
break;
}
case 16: //len
{
dataLen = int.Parse(tokens[++tokenOffset]);
System.Diagnostics.Debug.WriteLine(dataLen);
continue;
}
default:
{
//If the format was unknown
if (formatUnknown)
{
//It is no longer so because,
formatUnknown = false;
//it is no longer unknown, it is definitely a Text format
format = FileFormat.Text;
}
break;
}
}//Done determining what to do with a token
}//Done with tokens
}//Don't need to parse any tokens
}
//Create the resulting entry with the data contained in memory read from the reader by the writer
return new RtpToolEntry(DateTime.UtcNow.Subtract(TimeSpan.FromMilliseconds(timeOffset)), sourceInfo, builtPacket, (int)timeOffset, position);
}
public OperationRepairLayers(FileFormat slicerFile) : base(slicerFile)
{
}
protected override int GetSize(FileFormat fmt)
{
return((fmt.IsPS2) ? 0x80 : 0x88);
}
public static async Task <bool> HasFormat(this ILocalFileInfoRepository localFileInfoRepository, FilePath filePath, FileFormat fileFormat)
{
var itemfileFormat = await localFileInfoRepository.GetFileFormat(filePath);
var output = fileFormat == itemfileFormat;
return(output);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="toFile">Name of the file to export to</param>
/// <param name="headerText">Main Header text</param>
/// <param name="subheadingText">Sub-heading text</param>
/// <param name="footerText">footer text</param>
/// <param name="grid">Grid View to export</param>
/// <param name="outputFormat">Output format</param>
public static void Export(String toFile
, String headerText
, String subheadingText
, String footerText
, UltraGrid grid
, FileFormat outputFormat)
{
// Create the report itself
Report report = new Report();
// ...then the sections for header, footer and body
ISection mainSection = report.AddSection();
mainSection.PageMargins = new Infragistics.Documents.Reports.Report.Margins(50);
ISectionHeader headerSection = mainSection.AddHeader();
headerSection.Height = 50;
headerSection.Repeat = true;
// Add a footer for page numbering
ISectionFooter footerSection = mainSection.AddFooter();
// Create place-holder for header text
Infragistics.Documents.Reports.Report.Text.IText headerTextSection = headerSection.AddText(0, 0);
// ...and add the header in to this section, centralized
headerTextSection.AddContent(headerText);
headerTextSection.Alignment.Horizontal = Alignment.Center;
headerTextSection.Alignment.Vertical = Alignment.Middle;
// Set style for the header
Infragistics.Documents.Reports.Report.Text.Style HeaderStyle = new Infragistics.Documents.Reports.Report.Text.Style(new Infragistics.Documents.Reports.Graphics.Font("Verdana", 10, Infragistics.Documents.Reports.Graphics.FontStyle.Underline), Infragistics.Documents.Reports.Graphics.Brushes.DarkBlue);
headerTextSection.Style = HeaderStyle;
// Add in a sub-heading if required
if (subheadingText != null && subheadingText != "")
{
headerTextSection = headerSection.AddText(0, 20);
Infragistics.Documents.Reports.Report.Text.Style subHeaderStyle = new Infragistics.Documents.Reports.Report.Text.Style(new Infragistics.Documents.Reports.Graphics.Font("Verdana", 8, Infragistics.Documents.Reports.Graphics.FontStyle.Underline), Infragistics.Documents.Reports.Graphics.Brushes.DarkBlue);
headerTextSection.Style = subHeaderStyle;
headerTextSection.AddContent(subheadingText);
}
// Add the body of the report which is the contents of the grid
UltraGridDocumentExporter exporter = new UltraGridDocumentExporter();
exporter.Export(grid, mainSection);
//-------------------------
// Setup Footer content
//-------------------------
footerSection.Height = 50;
// Do we have a footer to display?
if (footerText != null && footerText != "")
{
// Create place-holder for footer text
Infragistics.Documents.Reports.Report.Text.IText footerTextSection = footerSection.AddText(0, 0);
// ...and add the footer text in to this section, left aligned
footerTextSection.Alignment.Horizontal = Alignment.Left;
footerTextSection.Alignment.Vertical = Alignment.Top;
// Set style for the text
Infragistics.Documents.Reports.Report.Text.Style footerStyle = new Infragistics.Documents.Reports.Report.Text.Style(new Infragistics.Documents.Reports.Graphics.Font("Verdana", 6, Infragistics.Documents.Reports.Graphics.FontStyle.Underline), Infragistics.Documents.Reports.Graphics.Brushes.DarkBlue);
footerTextSection.Style = footerStyle;
// ...and set the text itself
footerTextSection.AddContent(footerText);
}
PageNumbering pn = mainSection.PageNumbering;
// The Template property is the actual string that shows the page numbering. Use the [Page #] place-
// holder for the current page and the [TotalPages] place-holder for the total amount of pages in
// the entire document.
pn.Template = "Page [Page #] of [TotalPages]";
// Setting SkipFirst to true does not place page numbering on the first page of the section. This
// is useful if the first page is a Title page.
pn.SkipFirst = false;
// The page numbering will be aligned with the right side of the page. Valid values off the
// Alignment enum include Left, Center, and Right.
pn.Alignment.Horizontal = Alignment.Right;
// The page numbering will be located at the bottom of the page. Valid values off the
// Alignment enum include Top and Bottom.
pn.Alignment.Vertical = Alignment.Bottom;
// The page numbering is at the extreme bottom of the page, so we need to change the Y Offset
// in order to bring it in line with the rest of the page footer text.
pn.OffsetY = -18;
// Delete the old report if it exists
try
{
if (File.Exists(toFile))
{
File.Delete(toFile);
}
}
catch (Exception)
{
//Ignore any errors
}
// Generate the report
try
{
report.Generate();
report.Publish(toFile, outputFormat);
}
catch (Exception ex)
{
MessageBox.Show("Failed to write the export file " + toFile + ", the error was " + ex.Message);
}
}
public OutputDescriptor(TextWriter writer, FileFormat format, Type dataType)
{
Writer = writer;
Format = format;
DataType = dataType;
}
public void RunDirectoryOfFiles()
{
var simulations = new Simulations()
{
Name = "Simulations",
Version = Converter.LatestVersion,
Children = new List <IModel>()
{
new Simulation()
{
Name = "Sim1",
FileName = Path.GetTempFileName(),
Children = new List <IModel>()
{
new Clock()
{
StartDate = new DateTime(1980, 1, 1),
EndDate = new DateTime(1980, 1, 2)
},
new Summary()
}
},
new DataStore(),
}
};
// Create a temporary directory.
var path = Path.Combine(Path.GetTempPath(), "RunDirectoryOfFiles");
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
Directory.CreateDirectory(path);
File.WriteAllText(Path.Combine(path, "Sim1.apsimx"), FileFormat.WriteToString(simulations));
simulations.Children[0].Name = "Sim2";
File.WriteAllText(Path.Combine(path, "Sim2.apsimx"), FileFormat.WriteToString(simulations));
var runner = new Runner(Path.Combine(path, "*.apsimx"));
runner.Run();
// Check simulation 1 database
database = new SQLite();
database.OpenDatabase(Path.Combine(path, "Sim1.db"), readOnly: true);
Assert.IsTrue(
Utilities.CreateTable(new string[] { "Message" },
new List <object[]> {
new object[] { "Simulation terminated normally" }
})
.IsSame(database.ExecuteQuery("SELECT [Message] FROM _Messages")));
database.CloseDatabase();
// Check simulation 2 database
database = new SQLite();
database.OpenDatabase(Path.Combine(path, "Sim2.db"), readOnly: true);
Assert.IsTrue(
Utilities.CreateTable(new string[] { "Message" },
new List <object[]> {
new object[] { "Simulation terminated normally" }
})
.IsSame(database.ExecuteQuery("SELECT [Message] FROM _Messages")));
database.CloseDatabase();
}
private void OnGUI()
{
Camera camera = null;
renderCamera = EditorGUILayout.ObjectField("Render Camera", renderCamera, typeof(Camera), true) as Camera;
if (renderCamera == null)
{
if (SceneView.lastActiveSceneView != null)
{
camera = SceneView.lastActiveSceneView.camera;
EditorGUILayout.HelpBox("If you don't choose a render camera, the scene camera will be used. It is recommended to use a real camera", MessageType.Warning);
}
else
{
EditorGUILayout.HelpBox("No valid cameras found to render, please assign a camera or open a scene view", MessageType.Warning);
return;
}
}
else
{
camera = renderCamera;
}
var renderTexture = camera.targetTexture;
fileFileFormat = (FileFormat)EditorGUILayout.EnumPopup("Format", fileFileFormat);
if (fileFileFormat == FileFormat.JPEG)
{
RenderJPEGOptions();
}
textureFormat = (TextureFormat)EditorGUILayout.EnumPopup("Texture Format", textureFormat);
EditorGUILayout.BeginHorizontal();
width = EditorGUILayout.IntField("Width", width);
height = EditorGUILayout.IntField("Height", height);
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
nameRendersByDate = EditorGUILayout.ToggleLeft("Name Renders By Date", nameRendersByDate);
if (nameRendersByDate)
{
lastPath = EditorGUILayout.TextField("Output Directory", lastPath);
if (GUILayout.Button("Choose Path"))
{
lastPath = EditorUtility.OpenFolderPanel(
"Select Directory",
string.IsNullOrEmpty(lastPath) ? Application.dataPath : lastPath, "Screenshots");
}
}
EditorGUILayout.Space();
if (GUILayout.Button("Render"))
{
string path = "";
if (nameRendersByDate)
{
path = lastPath + "/Render_" + DateTime.Now.ToString("yyyy-MM-dd_hh-mm-ss");
path += fileFileFormat == FileFormat.PNG ? ".png" : ".jpeg";
}
else
{
var currentObj = Selection.activeObject;
var filename = currentObj == null ? "Render" : currentObj.name;
filename = filename.ToLower().Replace(' ', '_');
path = EditorUtility.SaveFilePanel(
"Save as",
string.IsNullOrEmpty(lastPath) ? Application.dataPath : lastPath,
filename,
fileFileFormat == FileFormat.PNG ? "png" : "jpeg");
lastPath = path;
}
Debug.Log("Outputting to: " + path);
Debug.Log("Last Path: " + lastPath);
if (string.IsNullOrEmpty(path))
{
return;
}
var texture = camera.RenderToTexture(width, height, textureFormat);
var imageData = fileFileFormat == FileFormat.PNG ? texture.EncodeToPNG() : texture.EncodeToJPG(jpegQuality);
File.WriteAllBytes(path, imageData);
DestroyImmediate(texture);
AssetDatabase.Refresh();
}
}
public void TestEditing()
{
string configFile = Path.GetTempFileName();
File.WriteAllLines(configFile, new[]
{
// Modify an array
"[Report].VariableNames = x,y,z",
// Modify a date - try a few different formats.
"[Clock].StartDate = 2000-01-01",
"[Clock].EndDate = 2000-01-10T00:00:00",
// Modify a string
"[Weather].FileName = fdsa.met",
@"[Weather2].FullFileName = jkl.met",
// Replace a model with a model from another file.
$"[Weather3] = {extFile}",
$"[Weather4] = {extFile};[w2]",
// Change a property of a resource model.
"[Wheat].Leaf.Photosynthesis.RUE.FixedValue = 0.4",
// Change a property of a manager script.
"[Manager].Script.Amount = 1234",
// Set an entire array.
"[Physical].BD = 1, 2, 3, 4, 5",
// Modify a single element of an array.
"[Physical].AirDry[2] = 6",
// Modify multiple elements of an array.
"[Physical].LL15[3:4] = 7",
});
string models = typeof(IModel).Assembly.Location;
string args = $"{fileName} /Edit {configFile}";
var proc = new ProcessUtilities.ProcessWithRedirectedOutput();
proc.Start(models, args, Path.GetTempPath(), true, writeToConsole: true);
proc.WaitForExit();
// Children of simulation are, in order:
// Clock, summary, zone, Weather, Weather2, w1, w2
Assert.AreEqual(null, proc.StdOut);
Assert.AreEqual(null, proc.StdErr);
Simulations file = FileFormat.ReadFromFile <Simulations>(fileName, out List <Exception> errors);
if (errors != null && errors.Count > 0)
{
throw errors[0];
}
var report = file.FindInScope <Models.Report>();
string[] variableNames = new[] { "x", "y", "z" };
Assert.AreEqual(variableNames, report.VariableNames);
IModel sim = file.FindChild <Simulation>();
// Use an index-based lookup to locate child models.
// When we replace an entire model, we want to ensure
// that the replacement is inserted at the correct index.
Clock clock = sim.Children[0] as Clock;
Assert.AreEqual(new DateTime(2000, 1, 1), clock.StartDate);
Assert.AreEqual(new DateTime(2000, 1, 10), clock.EndDate);
var weather = sim.Children[3] as Models.Climate.Weather;
Assert.NotNull(weather);
Assert.AreEqual("Weather", weather.Name);
Assert.AreEqual("fdsa.met", weather.FileName);
var weather2 = sim.Children[4] as Models.Climate.Weather;
Assert.NotNull(weather2);
Assert.AreEqual("Weather2", weather2.Name);
Assert.AreEqual(@"jkl.met", weather2.FileName);
// Weather3 and Weather4 should have been
// renamed to w1 and w2, respectively.
var weather3 = sim.Children[5] as Models.Climate.Weather;
Assert.NotNull(weather3);
Assert.AreEqual("w1", weather3.Name);
Assert.AreEqual("w1.met", weather3.FileName);
var weather4 = sim.Children[6] as Models.Climate.Weather;
Assert.NotNull(weather4);
Assert.AreEqual("w2", weather4.Name);
Assert.AreEqual("w2.met", weather4.FileName);
// The edit file operation should have changed RUE value to 0.4.
var wheat = sim.Children[2].Children[2] as Plant;
var rue = wheat.Children[6].Children[4].Children[0] as Constant;
Assert.AreEqual(0.4, rue.FixedValue);
double amount = (double)sim.FindByPath("[Manager].Script.Amount")?.Value;
Assert.AreEqual(1234, amount);
Physical physical = sim.Children[2].Children[4] as Physical;
Assert.AreEqual(new double[5] {
1, 2, 3, 4, 5
}, physical.BD);
Assert.AreEqual(new double[5] {
0, 6, 0, 0, 0
}, physical.AirDry);
Assert.AreEqual(new double[5] {
0, 0, 7, 7, 0
}, physical.LL15);
}
/// <summary>
/// Create the library.
/// </summary>
private void Run()
{
// Create the librarian and add the extension data.
Librarian librarian = new Librarian();
foreach (IExtensionData data in this.extensionData)
{
librarian.AddExtensionData(data);
}
// Add the sections to the librarian
List <Section> sections = new List <Section>();
foreach (string file in this.commandLine.Files)
{
string inputFile = Path.GetFullPath(file);
FileFormat format = FileStructure.GuessFileFormatFromExtension(Path.GetExtension(inputFile));
bool retry;
do
{
retry = false;
try
{
switch (format)
{
case FileFormat.Wixobj:
Intermediate intermediate = Intermediate.Load(inputFile, librarian.TableDefinitions, this.commandLine.SuppressVersionCheck);
sections.AddRange(intermediate.Sections);
break;
default:
Library loadedLibrary = Library.Load(inputFile, librarian.TableDefinitions, this.commandLine.SuppressVersionCheck);
sections.AddRange(loadedLibrary.Sections);
break;
}
}
catch (WixUnexpectedFileFormatException e)
{
format = e.FileFormat;
retry = (FileFormat.Wixobj == format || FileFormat.Wixlib == format); // .wixobj and .wixout are supported by lit.
if (!retry)
{
Messaging.Instance.OnMessage(e.Error);
}
}
} while (retry);
}
// Stop processing if any errors were found loading object files.
if (Messaging.Instance.EncounteredError)
{
return;
}
// and now for the fun part
Library library = librarian.Combine(sections);
// Add any localization files and save the library output if an error did not occur
if (null != library)
{
foreach (string localizationFile in this.commandLine.LocalizationFiles)
{
Localization localization = Localizer.ParseLocalizationFile(localizationFile, librarian.TableDefinitions);
if (null != localization)
{
library.AddLocalization(localization);
}
}
// If there was an error adding localization files, then bail.
if (Messaging.Instance.EncounteredError)
{
return;
}
LibraryBinaryFileResolver resolver = null;
if (this.commandLine.BindFiles)
{
resolver = new LibraryBinaryFileResolver();
resolver.FileManagers = this.fileManagers;
resolver.VariableResolver = new WixVariableResolver();
BinderFileManagerCore core = new BinderFileManagerCore();
core.AddBindPaths(this.commandLine.BindPaths, BindStage.Normal);
foreach (IBinderFileManager fileManager in resolver.FileManagers)
{
fileManager.Core = core;
}
}
library.Save(this.commandLine.OutputFile, resolver);
}
}
private async Task <StorageFile> WriteableBitmapToStorageFile(WriteableBitmap wb, FileFormat fileFormat)
{
string FileName = "MyFile.";
Guid BitmapEncoderGuid = BitmapEncoder.JpegEncoderId;
switch (fileFormat)
{
case FileFormat.Jpeg:
FileName += "jpeg";
BitmapEncoderGuid = BitmapEncoder.JpegEncoderId;
break;
case FileFormat.Png:
FileName += "png";
BitmapEncoderGuid = BitmapEncoder.PngEncoderId;
break;
case FileFormat.Bmp:
FileName += "bmp";
BitmapEncoderGuid = BitmapEncoder.BmpEncoderId;
break;
case FileFormat.Tiff:
FileName += "tiff";
BitmapEncoderGuid = BitmapEncoder.TiffEncoderId;
break;
case FileFormat.Gif:
FileName += "gif";
BitmapEncoderGuid = BitmapEncoder.GifEncoderId;
break;
}
var file = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(FileName, CreationCollisionOption.ReplaceExisting);
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoderGuid, stream);
Stream pixelStream = wb.PixelBuffer.AsStream();
byte[] pixels = new byte[pixelStream.Length];
await pixelStream.ReadAsync(pixels, 0, pixels.Length);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore,
(uint)wb.PixelWidth,
(uint)wb.PixelHeight,
96.0,
96.0,
pixels);
await encoder.FlushAsync();
}
return(file);
}
public async Task <ImageFileIdentity> AddImage(Stream imageFileStream, FileName imageFileName, FileFormat fileFormat)
{
var imageFileIdentity = ImageFileIdentity.New();
// Get unique file-name from image file identity.
var uniqueImageFileName = imageFileIdentity.GetUniqueFileName();
// Get the storage file path of the image file, using a single directory path and a globally-unique file name.
var uniqueImageFilePath = this.GetUniqueImageFilePath(uniqueImageFileName);
// Write the image file from its input stream to its unique local file path.
using (var file = File.Open(uniqueImageFilePath.Value, FileMode.CreateNew)) // Throw an exception if the file already exists by using create-new.
{
await imageFileStream.CopyToAsync(file);
}
// Add the file info to the repository.
var fileIdentity = imageFileIdentity.GetFileIdentity();
var fileInfo = new FileInfoAppType()
{
FileIdentity = fileIdentity,
FilePath = uniqueImageFilePath,
FileFormat = fileFormat,
};
await this.LocalFileInfoRepository.Add(fileInfo);
// Now add the unique file-name to original file-name mapping.
await this.OriginalFileNameMappingRepository.Add(uniqueImageFileName, imageFileName);
// Return the image file identity.
return(imageFileIdentity);
}
public async void OpenFile(string fileName)
{
FileFormat format = FileFormat.Detect(fileName);
if (format == null)
{
MessageBox.Show(this, "Unsupported file format", "Open file", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
//create load option and allow user to modify the load options
LoadOptions opt = format.CreateLoadOptions();
if (opt != null && opt.GetType() != typeof(LoadOptions))
{
if (OptionDialog.ShowDialog(this, "Import Settings", opt) == DialogResult.Cancel)
{
return;
}
}
currentFileName = fileName;
UpdateTitle();
long elapsed = 0;
try
{
lblStatus.Text = string.Format("Loading {0}", fileName);
fileListView1.Enabled = false;
propertyGrid1.SelectedObject = null;
Stopwatch st = Stopwatch.StartNew();
OnMovementChanged(btnStandardMovement, null);
Console.WriteLine("Loading file {0}", fileName);
//open the scene using user modified load option in background thread.
await Task.Run(() => scene.Open(fileName, opt));
elapsed = st.ElapsedMilliseconds;
Console.WriteLine("Loaded in {0}ms", elapsed);
renderView1.SceneUpdated(fileName);
sceneHierarchy.UpdateHierarchy(scene);
}
catch (Exception e)
{
MessageBox.Show(this, "Cannot open file " + fileName + "\n" + e.Message, "Open file",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
if (elapsed > 0)
{
lblStatus.Text = string.Format("Loaded in {0}ms, Ready.", elapsed);
}
else
{
lblStatus.Text = "Ready.";
}
fileListView1.Enabled = true;
}
}
protected override void ReadData(DataBuffer buf, FileFormat fmt)
{
buf.Skip(8); // unused
CurrentLevel = buf.ReadInt32();
CurrentArea = buf.ReadInt32();
Language = buf.ReadInt32();
MillisecondsPerGameMinute = buf.ReadInt32();
LastClockTick = buf.ReadUInt32();
GameClockHours = buf.ReadByte();
GameClockMinutes = buf.ReadByte();
GameClockSeconds = buf.ReadInt16();
TimeInMilliseconds = buf.ReadUInt32();
TimeScale = buf.ReadFloat();
TimeStep = buf.ReadFloat();
TimeStepNonClipped = buf.ReadFloat();
FramesPerUpdate = buf.ReadFloat();
FrameCounter = buf.ReadUInt32();
OldWeatherType = (WeatherType)buf.ReadInt16();
NewWeatherType = (WeatherType)buf.ReadInt16();
ForcedWeatherType = (WeatherType)buf.ReadInt16();
buf.Skip(2);
WeatherTypeInList = buf.ReadInt32();
WeatherInterpolationValue = buf.ReadFloat();
CameraPosition = buf.ReadStruct <Vector3>();
CameraModeInCar = buf.ReadFloat();
CameraModeOnFoot = buf.ReadFloat();
ExtraColor = buf.ReadInt32(); // for interiors, I think
IsExtraColorOn = buf.ReadBool(4);
ExtraColorInterpolation = buf.ReadFloat();
Brightness = buf.ReadInt32();
DisplayHud = buf.ReadBool();
ShowSubtitles = buf.ReadBool();
buf.Skip(2);
RadarMode = (RadarMode)buf.ReadInt32();
if (fmt.IsPS2)
{
BlurOn = buf.ReadBool(4);
Unknown78hPS2 = buf.ReadInt32(); // possibly unused setting
Unknown7ChPS2 = buf.ReadInt32(); // possibly unused setting
UseWideScreen = buf.ReadBool(4);
MusicVolume = buf.ReadInt32();
SfxVolume = buf.ReadInt32();
RadioStation = (RadioStation)buf.ReadByte();
StereoOutput = buf.ReadBool();
buf.Skip(2);
Unknown90hPS2 = buf.ReadInt32();
buf.Skip(9 * 4); // unused
PadMode = buf.ReadInt16();
buf.Skip(2);
InvertLook = !buf.ReadBool(4); // negated
UseVibration = buf.ReadBool();
buf.Skip(3);
HasPlayerCheated = buf.ReadBool(4);
AllTaxisHaveNitro = buf.ReadBool(4);
TargetIsOn = buf.ReadBool();
buf.Skip(3);
TargetPosition = buf.ReadStruct <Vector2>();
UnknownD8hPS2 = buf.ReadByte();
UnknownD9hPS2 = buf.ReadByte();
buf.Skip(2);
PlayerPosition = buf.ReadStruct <Vector3>();
TrailsOn = buf.ReadBool(4);
TimeStamp = buf.ReadStruct <Date>();
}
else if (fmt.IsPSP)
{
BlurOn = buf.ReadBool();
buf.Skip(3);
MusicVolume = buf.ReadInt32();
SfxVolume = buf.ReadInt32();
RadioStation = (RadioStation)buf.ReadByte();
StereoOutput = buf.ReadBool();
buf.Skip(2);
buf.Skip(9 * 4); // unused
PadMode = buf.ReadInt16();
InvertLook = !buf.ReadBool(); // negated
SwapNippleAndDPad = buf.ReadBool();
HasPlayerCheated = buf.ReadBool();
AllTaxisHaveNitro = buf.ReadBool();
TargetIsOn = buf.ReadBool();
buf.Skip(1);
TargetPosition = buf.ReadStruct <Vector2>();
UnknownB8hPSP = buf.ReadInt32();
PlayerPosition = buf.ReadStruct <Vector3>();
}
Debug.Assert(buf.Offset == GetSize(fmt));
}
/// <summary>
/// Prepares the text in the stream which corresponds to the RtcpData of a Rtcp.RtcpPacket.
/// </summary>
/// <param name="format">The <see cref="FileFormat"/> to output.</param>
/// <param name="packet">The <see cref="Rtcp.RtcpPacket"/> to describe</param>
/// <returns>The text describes the packet if the <paramref name="format"/> is a text format, otherwise an empty string</returns>
public static string ToTextualConvention(FileFormat format, Rtcp.RtcpPacket packet)
{
if (packet == null || packet.Payload.Count == 0 || format < FileFormat.Text || format == FileFormat.Short) return string.Empty;
if(format == FileFormat.Unknown) return UnknownSpecifier;
//Determine the format to use as well as the `Conventional Abbreviation`
switch (packet.PayloadType)
{
case Rtcp.SourceDescriptionReport.PayloadType:
//Use a SourceDescriptionReport to enumerate the SourceDescriptionChunk's and SourceDescriptionItem's contained in the packet.
using (var sdes = new Rtcp.SourceDescriptionReport(packet, false)) //Don't dispose the packet when done.
{
return string.Format(RtcpExpressionFormat,
"SDES",
packet.SynchronizationSourceIdentifier,
packet.Padding ? 1.ToString() : 0.ToString(),
packet.BlockCount,
packet.Header.LengthInWordsMinusOne, ToTextualConvention(sdes));
}
case Rtcp.SendersReport.PayloadType:
using (var sr = new Rtcp.SendersReport(packet, false))
{
return string.Format(RtcpExpressionFormat,
"SR",
packet.SynchronizationSourceIdentifier,
packet.Padding ? 1.ToString() : 0.ToString(),
packet.BlockCount,
packet.Header.LengthInWordsMinusOne,
(ToTextualConvention(sr) + (char)Common.ASCII.Space + string.Format(RtcpSendersInformationFormat,
//0
(DateTime.UtcNow - sr.NtpTime).TotalSeconds.ToString("0.000000"), //ts=
//1
sr.NtpTimestamp, //ntp=
//2
sr.SendersOctetCount, //osent=
//3
sr.SendersPacketCount))); //psent=
}
case Rtcp.ReceiversReport.PayloadType:
using (var rr = new Rtcp.ReceiversReport(packet, false))
{
return string.Format(RtcpExpressionFormat,
"RR",
packet.SynchronizationSourceIdentifier,
packet.Padding ? 1.ToString() : 0.ToString(),
packet.BlockCount,
packet.Header.LengthInWordsMinusOne,
ToTextualConvention(rr));
}
case Rtcp.GoodbyeReport.PayloadType:
using (var bye = new Rtcp.GoodbyeReport(packet, false))
{
return string.Format(RtcpExpressionFormat,
"BYE",
packet.SynchronizationSourceIdentifier, packet.Padding ? 1.ToString() : 0.ToString(),
packet.BlockCount,
packet.Header.LengthInWordsMinusOne, ToTextualConvention(bye));
}
case Rtcp.ApplicationSpecificReport.PayloadType:
return string.Format(RtcpExpressionFormat, "APP", packet.SynchronizationSourceIdentifier, packet.Padding ? 1.ToString() : 0.ToString(), packet.BlockCount, packet.Header.LengthInWordsMinusOne, string.Empty);
default:
//Unknown PayloadType use a Hex Representation of the PayloadType
return string.Format(RtcpExpressionFormat, packet.PayloadType.ToString("X"), packet.SynchronizationSourceIdentifier, packet.Padding ? 1.ToString() : 0.ToString(), packet.BlockCount, packet.Header.LengthInWordsMinusOne, string.Empty);
}
}
protected override void WriteData(DataBuffer buf, FileFormat fmt)
{
buf.Skip(4); // unused
buf.Write(3); // always 3
buf.Write(CurrentLevel);
buf.Write(CurrentArea);
buf.Write(Language);
buf.Write(MillisecondsPerGameMinute);
buf.Write(LastClockTick);
buf.Write(GameClockHours);
buf.Write(GameClockMinutes);
buf.Write(GameClockSeconds);
buf.Write(TimeInMilliseconds);
buf.Write(TimeScale);
buf.Write(TimeStep);
buf.Write(TimeStepNonClipped);
buf.Write(FramesPerUpdate);
buf.Write(FrameCounter);
buf.Write((short)OldWeatherType);
buf.Write((short)NewWeatherType);
buf.Write((short)ForcedWeatherType);
buf.Skip(2);
buf.Write(WeatherTypeInList);
buf.Write(WeatherInterpolationValue);
buf.Write(CameraPosition);
buf.Write(CameraModeInCar);
buf.Write(CameraModeOnFoot);
buf.Write(ExtraColor);
buf.Write(IsExtraColorOn, 4);
buf.Write(ExtraColorInterpolation);
buf.Write(Brightness);
buf.Write(DisplayHud);
buf.Write(ShowSubtitles);
buf.Skip(2);
buf.Write((int)RadarMode);
if (fmt.IsPS2)
{
buf.Write(BlurOn, 4);
buf.Write(Unknown78hPS2);
buf.Write(Unknown7ChPS2);
buf.Write(UseWideScreen, 4);
buf.Write(MusicVolume);
buf.Write(SfxVolume);
buf.Write((byte)RadioStation);
buf.Write(StereoOutput);
buf.Skip(2);
buf.Write(Unknown90hPS2);
buf.Skip(9 * 4); // unused
buf.Write(PadMode);
buf.Skip(2);
buf.Write(!InvertLook, 4); // negated
buf.Write(UseVibration);
buf.Skip(3);
buf.Write(HasPlayerCheated, 4);
buf.Write(AllTaxisHaveNitro, 4);
buf.Write(TargetIsOn);
buf.Skip(3);
buf.Write(TargetPosition);
buf.Write(UnknownD8hPS2);
buf.Write(UnknownD9hPS2);
buf.Skip(2);
buf.Write(PlayerPosition);
buf.Write(TrailsOn, 4);
buf.Write(TimeStamp);
}
else if (fmt.IsPSP)
{
buf.Write(BlurOn);
buf.Skip(3);
buf.Write(MusicVolume);
buf.Write(SfxVolume);
buf.Write((byte)RadioStation);
buf.Write(StereoOutput);
buf.Skip(2);
buf.Skip(9 * 4); // unused
buf.Write(PadMode);
buf.Write(!InvertLook); // negated
buf.Write(SwapNippleAndDPad);
buf.Write(HasPlayerCheated);
buf.Write(AllTaxisHaveNitro);
buf.Write(TargetIsOn);
buf.Skip(1);
buf.Write(TargetPosition);
buf.Write(UnknownB8hPSP);
buf.Write(PlayerPosition);
}
Debug.Assert(buf.Offset == GetSize(fmt));
}
/// <summary>
/// Prepares a text description which is compatible with 'rtpsend' among other 'rtp tools'.
/// </summary>
/// <param name="format">The <see cref="FileFormat"/> to output.</param>
/// <param name="packet">The <see cref="Rtp.RtpPacket"/> to describe</param>
/// <param name="time">Timeoffset from when recoding began, should be 0 for the first packet.</param>
/// <param name="source">The <see cref="System.Net.IPEndPoint"/> from which the packet was received.</param>
/// <returns>The text which describes the packet if the <paramref name="format"/> is a text format, otherwise an empty string</returns>
public static string ToTextualConvention(FileFormat format, Rtp.RtpPacket packet, TimeSpan time, System.Net.IPEndPoint source)
{
//StringBuilder?
//If the format is Short (Vat or Rtp Data in tablular form)
if (format == FileFormat.Short)
{
//Then return that format
return string.Format(RtpSend.ShortFormat,
//0
time.TotalSeconds.ToString("0.000000"),
//1
(packet.Marker ? (-packet.SequenceNumber) : packet.SequenceNumber).ToString(),
//2
source.Port.ToString());
}
StringBuilder builder = new StringBuilder(64);
//All Rtp are described with this format
builder.Append(string.Format(RtpSend.Format,
//0
time.TotalSeconds.ToString("0.000000"),
//1
string.Format(RtpSend.RtpPacketFormat,
//0
packet.Length, //Packet size in bytes including header
//1
source.Address.ToString() + ':' + source.Port.ToString(),
//2
packet.Version.ToString(),
//3
packet.Padding ? "1" : "0",
//4
packet.Extension ? "1" : "0",
//5
packet.ContributingSourceCount.ToString(),
//6
packet.Marker ? "1" : "0",
//7
packet.PayloadType,
//8 (Format description)
string.Format(RtpSend.PayloadDescriptionFormat, packet.PayloadType, RtpSendExtensions.PayloadDescription(packet)),
//9
packet.SequenceNumber,
//10
packet.SynchronizationSourceIdentifier,
//11
packet.Timestamp )));
//Write the textual representation of the items in the sourceList
if (packet.ContributingSourceCount > 0)
{
//Note
//http://www.cs.columbia.edu/irt/software/rtptools/ChangeLog.html
//States the format is not hex when in the format csrc[n]
//However -
//http://www.cs.columbia.edu/irt/software/rtptools/#rtpsend
//States that the format is :
//cc=<CSRC count>
//csrc=<CSRC>
//This is basically the same thing and a parsing semantic.
using (Media.RFC3550.SourceList sl = new Media.RFC3550.SourceList(packet))
{
if (sl == null)
{
builder.Append("#Incomplete Source List Not Included");
builder.Append((char)Common.ASCII.LineFeed);
}
else
{
//csrc=
while (sl.MoveNext())
{
builder.Append(string.Format(RtpSend.HexFormat, "csrc", HexSpecifier, sl.CurrentSource.ToString("X"), (char)Common.ASCII.LineFeed));
}
}
}
}
//Write the textual representation of the Extension
if (packet.Extension)
{
using (var rtpExtension = packet.GetExtension())
{
if (rtpExtension == null)
{
builder.Append("#Incomplete Extension Not Included");
builder.Append((char)Common.ASCII.LineFeed);
}
else
{
builder.Append(string.Format(RtpSend.HexFormat, "ext_type", HexSpecifier + rtpExtension.Flags.ToString("X"), (char)Common.ASCII.LineFeed));
builder.Append(string.Format(RtpSend.NonQuotedFormat, "ext_len", rtpExtension.LengthInWords));
builder.Append((char)Common.ASCII.LineFeed);
builder.Append(string.Format(RtpSend.HexFormat, "ext_data", BitConverter.ToString(rtpExtension.Data.ToArray()).Replace("-", string.Empty), (char)Common.ASCII.LineFeed));
}
}
}
//If the format is hex then add the payload dump
if (format == FileFormat.Hex)
{
var data = packet.PayloadData;
if (data.Any()) builder.Append(string.Format(RtpSend.HexFormat, "data", BitConverter.ToString(data.ToArray()).Replace("-", string.Empty), (char)Common.ASCII.LineFeed));
else builder.Append(string.Format(HexFormat, "data", NullSpecifier, (char)Common.ASCII.LineFeed));
}
//Return the result
return builder.ToString();
}
//[End]
private static async Task <AudioInformation> ParseVideoFromHTML(string html)
{
try
{
// Parse basic video information from the HTML
string url = new Regex(URL_PATTERN).Match(html).Groups[1].Value;
string title = new Regex(TITLE_PATTERN).Match(html).Groups[1].Value;
string description = new Regex(DESCRIPTION_PATTERN).Match(html).Groups[1].Value;
string thumbnailURL = new Regex(THUMBNAIL_PATTERN).Match(html).Groups[1].Value;
// Make sure that the title and description don't contain any HTML-escaped characters like &
title = WebUtility.HtmlDecode(title);
description = WebUtility.HtmlDecode(description);
if (url.Contains("&"))
{
url = url.Split('&')[0]; // If the URL contains more stuff in the query string, get rid of it
}
// Separate the JSON string, which is what we need for the download URLs and qualities
string jsonString = html.Split(new[] { "ytplayer.config = " }, StringSplitOptions.None)[1];
jsonString = jsonString.Split(new [] { "};" }, StringSplitOptions.None)[0] + "}";
// Parse video information from the JSON
dynamic json = new JavaScriptSerializer().Deserialize <object>(jsonString);
string[] keywords = json["args"]["keywords"].Split(',');
string[] adaptive_fmts = json["args"]["adaptive_fmts"].Split(new[] { "," }, StringSplitOptions.None);
// Create a dictionary with different qualities, formats and URL's
Dictionary <Tuple <FileFormat, AudioBitrate>, string> availableQualities = new Dictionary <Tuple <FileFormat, AudioBitrate>, string>();
foreach (string stream in adaptive_fmts)
{
if (!stream.Contains("url="))
{
continue;
}
if (!stream.Contains("itag="))
{
continue;
}
string formatString = Uri.UnescapeDataString(ParseFieldFromQueryString("type", stream));
if (!IsAudio(formatString))
{
continue;
}
string videoURL = Uri.UnescapeDataString(ParseFieldFromQueryString("url", stream));
string itag = Uri.UnescapeDataString(ParseFieldFromQueryString("itag", stream));
AudioBitrate bitrate = ParseBitrate(itag);
FileFormat format = ParseFormat(formatString);
Tuple <FileFormat, AudioBitrate> qualityTuple = Tuple.Create(format, bitrate);
if (!availableQualities.ContainsKey(qualityTuple))
{
availableQualities.Add(qualityTuple, videoURL);
}
}
// Download the thumbnail
Image thumbnail;
using (var http = new HttpClient())
{
thumbnail = Image.FromStream(new MemoryStream(await http.GetByteArrayAsync(thumbnailURL)));
}
// Create the video instance
AudioInformation audioInformation = new AudioInformation
{
URL = url,
Title = title,
Description = description,
Keywords = keywords,
Thumbnail = thumbnail,
AvailableQualities = availableQualities
};
foreach (Tuple <FileFormat, AudioBitrate> qualityTuple in availableQualities.Keys)
{
Console.WriteLine(qualityTuple.ToString());
}
// And return it :)
return(audioInformation);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
return(null);
}
}
public static IAssetLoader GetLoader(FileFormat type) => Loaders[type];
protected void InsertFileContent(object sender, WriterCommandEventArgs args)
{
if (args.Mode == WriterCommandEventMode.QueryState)
{
args.Enabled = args.DocumentControler != null &&
args.Document != null &&
args.DocumentControler.CanInsertElementAtCurrentPosition(
typeof(DomElement));
}
else if (args.Mode == WriterCommandEventMode.Invoke)
{
args.Result = false;
DomDocument document = null;
string fileName = null;
if (args.Parameter is string)
{
fileName = (string)args.Parameter;
}
else if (args.Parameter is DomDocument)
{
document = (DomDocument)args.Parameter;
}
if (document == null)
{
IFileSystem fs = args.Host.FileSystems.Docuemnt;
if (fs != null)
{
if (args.ShowUI)
{
// 浏览文件
fileName = fs.BrowseOpen(args.Host.Services, fileName);
}
if (string.IsNullOrEmpty(fileName))
{
return;
}
VFileInfo info = fs.GetFileInfo(args.Host.Services, fileName);
if (info.Exists == false)
{
// 文件不存在
return;
}
//打开文件
if (args.Host.Debuger != null)
{
args.Host.Debuger.DebugLoadingFile(fileName);
}
System.IO.Stream stream = fs.Open(args.Host.Services, fileName);
if (stream != null)
{
FileFormat format = WriterUtils.ParseFileFormat(info.Format);
using (stream)
{
// 读取文件，加载文档对象
document = new DomDocument();
document.Options = args.Document.Options;
document.ServerObject = args.Document.ServerObject;
document.Load(stream, format);
if (args.Host.Debuger != null)
{
args.Host.Debuger.DebugLoadFileComplete((int)stream.Length);
}
}
}
}
}
if (document != null &&
document.Body != null &&
document.Body.Elements.Count > 0)
{
// 导入文档内容
DomElementList list = document.Body.Elements;
args.Document.ImportElements(list);
args.DocumentControler.InsertElements(list);
args.Result = list;
}
}
}
private void AddSubRecordNoField(string name, string description, bool required, FileFormat format)
{
SubRecords.Add((this._name, $"{this._name}_{name}"));
var c = new Class($"{this._name}_{name}")
{
Modifiers = Modifiers.Public | Modifiers.Sealed
};
c.Extends.Add("SubRecord");
var s1 = new Field("Signature", "FieldType")
{
Value = $"Signature.FromString(\"{name}\")",
Modifiers = Modifiers.Static | Modifiers.Public | Modifiers.ReadOnly
};
c.Members.Add(s1);
var f = new Field(format.To, "Value")
{
Modifiers = Modifiers.Public
};
c.Members.Add(f);
var baseCon = new Method(null, c.Name)
{
Modifiers = Modifiers.Internal,
Parameters = "IReader headerReader, IReader dataReader, uint overrideDataSize = 0",
ConstructorInvocation = "base(headerReader, dataReader, overrideDataSize)",
Body = new Builder()
};
baseCon.Body.AppendLine($"this.Value = dataReader.{format.Read}(0);");
c.Members.Add(baseCon);
var emtpyCon = new Method(null, c.Name)
{
ConstructorInvocation = "base(FieldType)",
Modifiers = required ? Modifiers.Internal : Modifiers.Public
};
c.Members.Add(emtpyCon);
if (!required)
{
var valueConstructor = new Method(null, c.Name)
{
Modifiers = Modifiers.Public,
ConstructorInvocation = "base(FieldType)",
Parameters = $"{format.To} value",
Body = new Builder()
};
valueConstructor.Body.AppendLine("this.Value = value;");
c.Members.Add(valueConstructor);
}
var writer = new Method("void", "WriteData")
{
Modifiers = Modifiers.Override | Modifiers.Protected,
Parameters = "IWriter writer",
Body = new Builder()
};
writer.Body.AppendLine($"writer.{format.Write}(this.Value);");
c.Members.Add(writer);
var length = new Method("ushort", "DataLength")
{
Modifiers = Modifiers.Override | Modifiers.Protected, Body = new Builder()
};
length.Body.AppendLine($"return (ushort) ({GetLength(null, format)});");
c.Members.Add(length);
var bse = new Base
{
Comment =
"ReSharper disable RedundantUsingDirective\nReSharper disable InconsistentNaming\nReSharper disable UseObjectOrCollectionInitializer\nReSharper disable RedundantCast"
};
bse.Using.Add("System.Collections.Generic");
bse.Using.Add("System.Linq");
var ns = new Namespace("SkyrimLib");
bse.Namespaces.Add(ns);
ns.Types.Add(c);
File.WriteAllText($"../../../../SkyrimLib/Generated/{this._name}_{name}.cs", bse.BuildCode(true));
}
// ----- вернуть хранителя -------
public IEFSaver GetEFSaver(FileFormat format)
{
return(EFSaver.CreateSaver(format));
}
/// <summary>
/// Выполняет загрузку Eprom с файла
/// </summary>
/// <param name="filePath">Путь к файлу</param>
/// <param name="format">Формат в котором сохранен Eprom</param>
/// <returns></returns>
public Eprom LoadEpromFromFile(string filePath, FileFormat format)
{
IEFLoader ldr = null;
Eprom eprom = new Eprom();
switch (format)
{
case FileFormat.EF1TXT:
ldr = platform.GetEFLoader(FileFormat.EF1TXT);
break;
case FileFormat.EF2XMLOLD:
ldr = platform.GetEFLoader(FileFormat.EF2XMLOLD);
break;
case FileFormat.EF2XML:
ldr = platform.GetEFLoader(FileFormat.EF2XML);
break;
}
eprom = ldr.Load(filePath);
return eprom;
}
internal void AddSubRecordList(string name, string description, FileFormat format)
{
SubRecords.Add((this._name, $"{this._name}_{name}"));
/* Property */
var p = new Field($"{this._name}_{name}", name)
{
Modifiers = Modifiers.Public | Modifiers.ReadOnly, Value = $"new {this._name}_{name}()"
};
this._genClass.Members.Add(p);
this._constructorRead.Body.AppendLine(
$"this.{name} = this.Fields.First(x => x.Type == {this._name}_{name}.FieldType) as {this._name}_{name};");
this._getSubRecordsForWriting.Body.AppendLine(
$"if(this.{name}.Values.Count > 0) ret.Add(this.{name});");
/* Backing class */
var c = new Class($"{this._name}_{name}")
{
Modifiers = Modifiers.Public | Modifiers.Sealed
};
c.Extends.Add("SubRecord");
var s1 = new Field("Signature", "FieldType")
{
Value = $"Signature.FromString(\"{name}\")",
Modifiers = Modifiers.Static | Modifiers.Public | Modifiers.ReadOnly
};
c.Members.Add(s1);
var f = new Field($"List<{format.To}>", "Values")
{
Modifiers = Modifiers.Public | Modifiers.ReadOnly, Value = $"new List<{format.To}>()"
};
c.Members.Add(f);
var baseCon = new Method(null, c.Name)
{
Modifiers = Modifiers.Internal,
Parameters = "IReader headerReader, IReader dataReader, uint overrideDataSize = 0",
ConstructorInvocation = "base(headerReader, dataReader, overrideDataSize)",
Body = new Builder()
};
baseCon.Body.AppendLine("var idx = 0;");
baseCon.Body.AppendLine($"while (dataReader.Length > idx + {format.Size}){{");
baseCon.Body.EnterBlock();
baseCon.Body.AppendLine($"this.Values.Add(dataReader.{format.Read}(idx));");
baseCon.Body.AppendLine($"idx += {format.Size};");
baseCon.Body.LeaveBlock();
baseCon.Body.AppendLine("}");
c.Members.Add(baseCon);
var emtpyCon = new Method(null, c.Name)
{
ConstructorInvocation = "base(FieldType)", Modifiers = Modifiers.Internal
};
c.Members.Add(emtpyCon);
var writer = new Method("void", "WriteData")
{
Modifiers = Modifiers.Override | Modifiers.Protected,
Parameters = "IWriter writer",
Body = new Builder()
};
writer.Body.AppendLine($"foreach(var value in this.Values) writer.{format.Write}(value);");
c.Members.Add(writer);
var length = new Method("ushort", "DataLength")
{
Modifiers = Modifiers.Override | Modifiers.Protected, Body = new Builder()
};
length.Body.AppendLine($"return (ushort) (this.Values.Count * {format.Size});");
c.Members.Add(length);
var bse = new Base
{
Comment =
"ReSharper disable RedundantUsingDirective\nReSharper disable InconsistentNaming\nReSharper disable UseObjectOrCollectionInitializer\nReSharper disable RedundantCast"
};
bse.Using.Add("System.Collections.Generic");
bse.Using.Add("System.Linq");
var ns = new Namespace("SkyrimLib");
bse.Namespaces.Add(ns);
ns.Types.Add(c);
File.WriteAllText($"../../../../SkyrimLib/Generated/{this._name}_{name}.cs", bse.BuildCode(true));
}
