public DefineFontNameTag(FlashReader reader, TagRecord header) :
base(reader, header)
{
FontId = reader.ReadUInt16();
FontName = reader.ReadNullTerminatedString();
FontCopyright = reader.ReadNullTerminatedString();
}
private static TagEntry CreateTagEntry(TagRecord tagRecord)
{
return(new TagEntry {
Tag = tagRecord,
IsChecked = false,
});
}
public override void Read(
TagRecord _Tag
, BinaryReader _GAFFileReader
, ref GAFAnimationData _SharedData
, ref GAFTimelineData _CurrentTimeline)
{
uint count = _GAFFileReader.ReadUInt32();
for (uint i = 0; i < count; ++i)
{
string id = GAFReader.ReadString(_GAFFileReader);
ushort start = _GAFFileReader.ReadUInt16();
ushort end = _GAFFileReader.ReadUInt16();
var data = new GAFSequenceData(id, (uint)start, (uint)end);
if (_CurrentTimeline == null)
{
_SharedData.rootTimeline.sequences.Add(data);
}
else
{
_CurrentTimeline.sequences.Add(data);
}
}
}
// ---------------------------------------------------------------------------
public bool ReadFromFile(String FileName)
{
TagRecord TagData = new TagRecord();
// Reset and load tag data from file to variable
ResetData();
bool result = ReadTag(FileName, ref TagData);
// Process data if loaded and tag header OK
if ((result) && Utils.StringEqualsArr("TAG", TagData.Header))
{
FExists = true;
FVersionID = GetTagVersion(TagData);
// Fill properties with tag data
FTitle = Utils.BuildStringCStyle(TagData.Title);
FArtist = Utils.BuildStringCStyle(TagData.Artist).TrimEnd();
FAlbum = Utils.BuildStringCStyle(TagData.Album).TrimEnd();
FYear = Utils.BuildStringCStyle(TagData.Year).TrimEnd();
if (TAG_VERSION_1_0 == FVersionID)
{
FComment = Utils.BuildStringCStyle(TagData.Comment).TrimEnd();
}
else
{
char[] newComment = new char[28];
Array.Copy(TagData.Comment, 0, newComment, 0, 28);
FComment = Utils.BuildStringCStyle(newComment).TrimEnd();
FTrack = (byte)TagData.Comment[29];
}
FGenreID = TagData.Genre;
}
return(result);
}
private static void SetWatchlistValues(Video originai, Video updated = null)
{
DateTime runTime = DateTime.Now;
var watchListTag = TagRecord.Create(originai.Id.HasValue ? originai.Id.Value : -1, TagType.WatchList);
if (updated == null)
{
originai.Created = originai.Updated = runTime;
originai.AddTag(watchListTag);
}
else
{
originai.Updated = runTime;
originai.AddTag(watchListTag);
if (updated.Tags != null)
{
foreach (var t in updated.Tags.Values)
{
originai.AddTag(t);
}
}
}
}
// ---------------------------------------------------------------------------
public bool SaveToFile(String FileName)
{
TagRecord TagData = new TagRecord();
// Prepare tag record
TagData.Reset();
TagData.Header[0] = 'T';
TagData.Header[1] = 'A';
TagData.Header[2] = 'G';
Array.Copy(FTitle.ToCharArray(), TagData.Title, 30);
Array.Copy(FArtist.ToCharArray(), TagData.Artist, 30);
Array.Copy(FAlbum.ToCharArray(), TagData.Album, 30);
Array.Copy(FYear.ToCharArray(), TagData.Year, 4);
Array.Copy(FComment.ToCharArray(), TagData.Comment, 30);
if (FTrack > 0)
{
TagData.Comment[28] = '\0';
TagData.Comment[29] = (char)FTrack;
}
TagData.Genre = FGenreID;
// Delete old tag and write new tag
return((RemoveFromFile(FileName)) && (SaveTag(FileName, TagData)));
}
public override void Read(
TagRecord _Tag
, BinaryReader _GAFFileReader
, ref GAFAnimationData _SharedData
, ref GAFTimelineData _CurrentTimeline)
{
}
// ---------------------------------------------------------------------------
bool SaveTag(String FileName, TagRecord TagData)
{
bool result = true;
try
{
// Allow write-access and open file
FileStream fs = new FileStream(FileName, FileMode.Open, FileAccess.Write);
BinaryWriter TargetFile = new BinaryWriter(fs);
// Write tag
fs.Seek(fs.Length, SeekOrigin.Begin);
TargetFile.Write(TagData.Header);
TargetFile.Write(TagData.Title);
TargetFile.Write(TagData.Artist);
TargetFile.Write(TagData.Album);
TargetFile.Write(TagData.Year);
TargetFile.Write(TagData.Comment);
TargetFile.Write(TagData.Genre);
TargetFile.Close();
fs.Close();
}
catch (Exception e)
{
System.Console.WriteLine(e.StackTrace);
result = false;
}
return(result);
}
protected virtual FlashTag ReadTag(FlashReader reader, TagRecord header)
{
FlashTag tag = null;
switch (header.TagType)
{
default:
tag = new UnknownTag(Reader, header);
break;
case FlashTagType.DoABC:
tag = new DoABCTag(Reader, header);
_abcFiles.Add(((DoABCTag)tag).ABC);
break;
case FlashTagType.DefineBitsLossless2:
tag = new DefineBitsLossless2Tag(Reader, header);
break;
case FlashTagType.DefineBinaryData:
tag = new DefineBinaryDataTag(Reader, header);
break;
}
var character = (tag as ICharacter);
if (character != null)
{
// Add ICharacter tag to the global dictionary.
Dictionary.Characters[
character.CharacterId] = character;
}
return(tag);
}
public static CourseTagRecordEditor AddTag(this CourseRecord course, TagRecord record)
{
if (record.Category.ToUpper() != TagCategory.Course.ToString().ToUpper())
{
throw new ArgumentException("");
}
return(new CourseTagRecordEditor(course, record));
}
public static StudentTagRecordEditor AddTag(this StudentRecord student, TagRecord record)
{
if (record.Category.ToUpper() != TagCategory.Student.ToString().ToUpper())
{
throw new ArgumentException("");
}
return(new StudentTagRecordEditor(student, record));
}
private void loadItems()
{
foreach (int addr in RecordAddresses())
{
var r = new TagRecord(M, addr);
records.Add(r.Key, r);
}
}
public static TeacherTagRecordEditor AddTag(this TeacherRecord teacher, TagRecord record)
{
if (record.Category.ToUpper() != TagCategory.Teacher.ToString().ToUpper())
{
throw new ArgumentException("");
}
return(new TeacherTagRecordEditor(teacher, record));
}
private SitemapEntry ToSitemapEntry(TagRecord tag)
{
var url = _urlHelper.Action("Search", "Home", new { Area = "Orchard.Tags", TagName = tag.TagName });
var entry = CreateEntry(tag, url, changeFrequency: ChangeFrequency.Daily);
entry.Context = tag.Id.ToString();
return(entry);
}
private void loadItems()
{
foreach (int addr in RecordAddresses())
{
var r = new TagRecord(M, addr);
records.Add(r.Key, r);
}
}
public static ClassTagRecordEditor AddTag(this ClassRecord cla, TagRecord record)
{
if (record.Category.ToUpper() != TagCategory.Class.ToString().ToUpper())
{
throw new ArgumentException("");
}
return(new ClassTagRecordEditor(cla, record));
}
private void loadItems()
{
foreach (var addr in RecordAdresses())
{
TagRecord r = new TagRecord(m, addr);
records.Add(r.Key, r);
}
}
private void loadItems()
{
foreach (var addr in RecordAdresses())
{
TagRecord r = new TagRecord(m, addr);
records.Add(r.Key, r);
}
}
public DefineBinaryDataTag(FlashReader reader, TagRecord header)
: base(reader, header)
{
CharacterId = reader.ReadUInt16();
reader.ReadUInt32();
BinaryData = reader.ReadBytes(header.Body.Length - 6);
}
/// <summary>
/// Initializes a new instance of the <see cref="PdbType"/> class.
/// </summary>
/// <param name="pdb">The PDB file reader.</param>
/// <param name="typeIndex">Type index.</param>
/// <param name="tagRecord">The tag record.</param>
/// <param name="modifierOptions">The modifier options.</param>
/// <param name="size">The type size in bytes.</param>
internal PdbUserDefinedType(PdbFileReader pdb, TypeIndex typeIndex, TagRecord tagRecord, ModifierOptions modifierOptions, ulong size)
: base(pdb, typeIndex, modifierOptions, tagRecord.Name.String, size)
{
TagRecord = tagRecord;
fieldsCache = SimpleCache.CreateWithContext(this, CallEnumerateFields);
staticFieldsCache = SimpleCache.CreateWithContext(this, CallEnumerateStaticFields);
baseClassesCache = SimpleCache.CreateWithContext(this, CallEnumerateBaseClasses);
virtualBaseClassesCache = SimpleCache.CreateWithContext(this, CallEnumerateVirtualBaseClasses);
}
public override void Read(
TagRecord _Tag
, BinaryReader _GAFFileReader
, ref GAFAnimationData _SharedData
, ref GAFTimelineData _RootTimeline)
{
uint id = _GAFFileReader.ReadUInt32();
uint framesCount = _GAFFileReader.ReadUInt32();
Rect frameSize = GAFReader.ReadRect(_GAFFileReader);
Vector2 pivot = GAFReader.ReadVector2(_GAFFileReader);
byte hasLinkage = _GAFFileReader.ReadByte();
string linkageName = string.Empty;
if (hasLinkage == 1)
{
linkageName = GAFReader.ReadString(_GAFFileReader);
}
var timeline = new GAFTimelineData(id, linkageName, framesCount, frameSize, pivot);
_SharedData.timelines.Add((int)id, timeline);
var tagReaders = GetTagsDictionary();
while (_GAFFileReader.BaseStream.Position < _Tag.expectedStreamPosition)
{
TagRecord record;
try
{
record = GAFReader.OpenTag(_GAFFileReader);
}
catch (System.Exception _exception)
{
throw new GAFException("GAF! GAFReader::Read - Failed to open tag! Stream position - " + _GAFFileReader.BaseStream.Position.ToString() + "\nException - " + _exception);
}
if (record.type != TagBase.TagType.TagInvalid &&
tagReaders.ContainsKey(record.type))
{
try
{
tagReaders[record.type].Read(record, _GAFFileReader, ref _SharedData, ref timeline);
}
catch (System.Exception _exception)
{
throw new GAFException("GAF! GAFReader::Read - Failed to read tag - " + record.type.ToString() + "\n Exception - " + _exception.ToString(), record);
}
GAFReader.CheckTag(record, _GAFFileReader);
}
else
{
GAFReader.CloseTag(record, _GAFFileReader);
}
}
}
public SetBackgroundColorTag(FlashReader reader, TagRecord header) :
base(reader, header)
{
byte red = reader.ReadByte();
byte green = reader.ReadByte();
byte blue = reader.ReadByte();
BackgroundColor =
Color.FromArgb(red, green, blue);
}
internal TagRecordEditor(TagRecord record)
{
Tag = record;
Remove = false;
ID = record.ID;
Prefix = record.Prefix;
Name = record.Name;
Category = record.Category;
Color = record.Color;
}
private static IEnumerable <TypeRecord> GetFields(PdbFile pdb, TagRecord record)
{
foreach (TypeRecord field in EnumerateFieldList(pdb, record.FieldList))
{
if (field is DataMemberRecord || field is StaticDataMemberRecord staticDataMember)
{
yield return(field);
}
}
}
private void loadItems()
{
foreach (var addr in RecordAddresses())
{
var r = new TagRecord(M, addr);
if (!Records.ContainsKey(r.Key))
{
Records.Add(r.Key, r);
}
}
}
public static void CheckTag(TagRecord _Record, BinaryReader _Reader)
{
if (_Reader.BaseStream.Position != _Record.expectedStreamPosition)
{
GAFUtils.Error(
"GAFReader::CloseTag - " +
"Tag " + _Record.type.ToString() + " " +
"hasn't been correctly read, tag length is not respected. " +
"Expected " + _Record.expectedStreamPosition + " " +
"but actually " + _Reader.BaseStream.Position + " !");
}
}
public DoABCTag(FlashReader reader, TagRecord header)
: base(reader, header)
{
Flags = reader.ReadUInt32();
Name = reader.ReadNullTerminatedString();
int nameLength = (Encoding.UTF8.GetByteCount(Name) + 1);
byte[] abcData = reader.ReadBytes(header.Body.Length - (nameLength + 4));
ABC = new ABCFile(abcData);
}
/// <summary>
/// This method groups the results into batches and send
/// </summary>
/// <param name="documents"></param>
private void GroupDocumentsAndSend(List <BulkDocumentInfoBEO> documents)
{
documents = GatherFamiliesAndDuplicates(documents);
// Construct the record object for the successive worker, with the boot param
var bulkTagRecord = new BulkTagRecord
{
BinderId = _mBootObject.BinderId,
CollectionId = _mBootObject.TagDetails.CollectionId,
MatterId = _mBootObject.TagDetails.MatterId,
DatasetId = _mBootObject.TagDetails.DatasetId,
ReviewSetId = _mBootObject.DocumentListDetails.SearchContext.ReviewSetId,
NumberOfOriginalDocuments = _mTotalDocumentCount,
CreatedByUserGuid = _mBootObject.JobScheduleCreatedBy
};
// Fill the tag details in record object
var tagRecord = new TagRecord
{
Id = _mBootObject.TagDetails.Id,
ParentId = _mBootObject.TagDetails.ParentTagId,
Name = _mBootObject.TagDetails.Name,
TagDisplayName = _mBootObject.TagDetails.TagDisplayName,
IsOperationTagging = _mBootObject.IsOperationTagging,
IsTagAllDuplicates = _mBootObject.IsTagAllDuplicates,
IsTagAllFamily = _mBootObject.IsTagAllFamily
};
tagRecord.TagBehaviors.AddRange(_mBootObject.TagDetails.TagBehaviors);
bulkTagRecord.SearchContext = _mSearchContext;
bulkTagRecord.TagDetails = tagRecord;
// Determine # of batches for documents to be sent
var documentsCopy = new List <BulkDocumentInfoBEO>(documents);
var noOfBatches = (documentsCopy.Count % _mWindowSize == 0)
? (documents.Count / _mWindowSize)
: (documents.Count / _mWindowSize) + 1;
bulkTagRecord.NumberOfBatches = noOfBatches;
Tracer.Info(string.Format("Total batch of document(s) determined : {0}", noOfBatches));
var processedDocCount = 0;
for (var i = 0; i < noOfBatches; i++)
{
// Group documents and send it to next worker
bulkTagRecord.Documents = documentsCopy.Skip(processedDocCount).Take(_mWindowSize).ToList();
processedDocCount += _mWindowSize;
Send(bulkTagRecord);
}
}
// ---------------------------------------------------------------------------
byte GetTagVersion(TagRecord TagData)
{
byte result = TAG_VERSION_1_0;
// Terms for ID3v1.1
if ((('\0' == TagData.Comment[28]) && ('\0' != TagData.Comment[29])) ||
((32 == (byte)TagData.Comment[28]) && (32 != (byte)TagData.Comment[29])))
{
result = TAG_VERSION_1_1;
}
return(result);
}
public TagRecord CreateTag(string tagName)
{
var result = _tagRepository.Get(x => x.TagName == tagName);
if (result == null)
{
result = new TagRecord {
TagName = tagName
};
_tagRepository.Create(result);
}
return(result);
}
// ---------------------------------------------------------------------------
public bool RemoveFromFile(String FileName)
{
TagRecord TagData = new TagRecord();
bool result;
// Find tag
result = ReadTag(FileName, ref TagData);
// Delete tag if loaded and tag header OK
if ((result) && Utils.StringEqualsArr("TAG", TagData.Header))
{
result = RemoveTag(FileName);
}
return(result);
}
private RefreshResults RefreshRecentlyAdded()
{
var list = Browser.GetRecentlyAddedVideos();
List <Video> added = new List <Video>();
List <Video> duplicates = new List <Video>();
List <Video> failedIds = new List <Video>();
DateTime runTime = DateTime.Now;
foreach (Video v in list)
{
var existing = DataStore.GetExistingVideo(v.Type, v.AmazonId, v.Title);
if (existing == null)
{
v.Created = v.Updated = runTime;
v.AddTag(TagRecord.Create(-1, TagType.New));
if ((from i in added
where i.AmazonId == v.AmazonId || i.Title == v.Title
select i).FirstOrDefault() == null)
{
try
{
DataStore.InsertVideo(v);
added.Add(v);
}
catch (Exception e)
{
failedIds.Add(v);
}
}
else
{
duplicates.Add(v);
}
}
else
{
existing.Updated = runTime;
DataStore.UpdateVideo(existing);
}
}
RefreshResults result = new RefreshResults(added, failedIds);
return(result);
}
// ********************* Auxiliary functions & voids ********************
bool ReadTag(String FileName, ref TagRecord TagData)
{
bool result;
FileStream fs = null;
BinaryReader SourceFile = null;
try
{
result = true;
// Set read-access and open file
fs = new FileStream(FileName, FileMode.Open, FileAccess.Read);
SourceFile = new BinaryReader(fs);
// Read tag
fs.Seek(-128, SeekOrigin.End);
// ID3v1 tags are C-String(null-terminated)-based tags
// they are not unicode-encoded, hence the use of ReadTrueChars
TagData.Header = Utils.ReadTrueChars(SourceFile,3);
TagData.Title = Utils.ReadTrueChars(SourceFile,30);
TagData.Artist = Utils.ReadTrueChars(SourceFile,30);
TagData.Album = Utils.ReadTrueChars(SourceFile,30);
TagData.Year = Utils.ReadTrueChars(SourceFile,4);
TagData.Comment = Utils.ReadTrueChars(SourceFile,30);
TagData.Genre = SourceFile.ReadByte();
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
System.Console.WriteLine(e.StackTrace);
result = false;
}
if (SourceFile != null) SourceFile.Close();
if (fs != null) fs.Close();
return result;
}
// ---------------------------------------------------------------------------
bool SaveTag(String FileName, TagRecord TagData)
{
bool result = true;
try
{
// Allow write-access and open file
FileStream fs = new FileStream(FileName, FileMode.Open, FileAccess.Write);
BinaryWriter TargetFile = new BinaryWriter(fs);
// Write tag
fs.Seek(fs.Length, SeekOrigin.Begin);
TargetFile.Write(TagData.Header);
TargetFile.Write(TagData.Title);
TargetFile.Write(TagData.Artist);
TargetFile.Write(TagData.Album);
TargetFile.Write(TagData.Year);
TargetFile.Write(TagData.Comment);
TargetFile.Write(TagData.Genre);
TargetFile.Close();
fs.Close();
}
catch (Exception e)
{
System.Console.WriteLine(e.StackTrace);
result = false;
}
return result;
}
// ---------------------------------------------------------------------------
byte GetTagVersion(TagRecord TagData)
{
byte result = TAG_VERSION_1_0;
// Terms for ID3v1.1
if ( (('\0' == TagData.Comment[28]) && ('\0' != TagData.Comment[29])) ||
((32 == (byte)TagData.Comment[28]) && (32 != (byte)TagData.Comment[29])) )
result = TAG_VERSION_1_1;
return result;
}
// ---------------------------------------------------------------------------
public bool ReadFromFile(String FileName)
{
TagRecord TagData = new TagRecord();
// Reset and load tag data from file to variable
ResetData();
bool result = ReadTag(FileName, ref TagData);
// Process data if loaded and tag header OK
if ((result) && Utils.StringEqualsArr("TAG",TagData.Header))
{
FExists = true;
FVersionID = GetTagVersion(TagData);
// Fill properties with tag data
FTitle = Utils.BuildStringCStyle(TagData.Title);
FArtist = Utils.BuildStringCStyle(TagData.Artist).TrimEnd();
FAlbum = Utils.BuildStringCStyle(TagData.Album).TrimEnd();
FYear = Utils.BuildStringCStyle(TagData.Year).TrimEnd();
if (TAG_VERSION_1_0 == FVersionID)
{
FComment = Utils.BuildStringCStyle(TagData.Comment).TrimEnd();
}
else
{
char[] newComment = new char[28];
Array.Copy(TagData.Comment,0,newComment,0,28);
FComment = Utils.BuildStringCStyle(newComment).TrimEnd();
FTrack = (byte)TagData.Comment[29];
}
FGenreID = TagData.Genre;
}
return result;
}
// ---------------------------------------------------------------------------
public bool RemoveFromFile(String FileName)
{
TagRecord TagData = new TagRecord();
bool result;
// Find tag
result = ReadTag(FileName, ref TagData);
// Delete tag if loaded and tag header OK
if ( (result) && Utils.StringEqualsArr("TAG",TagData.Header) ) result = RemoveTag(FileName);
return result;
}
// ---------------------------------------------------------------------------
public bool SaveToFile(String FileName)
{
TagRecord TagData = new TagRecord();
// Prepare tag record
TagData.Reset();
TagData.Header[0] = 'T';
TagData.Header[1] = 'A';
TagData.Header[2] = 'G';
Array.Copy(FTitle.ToCharArray(), TagData.Title, 30);
Array.Copy(FArtist.ToCharArray(), TagData.Artist, 30);
Array.Copy(FAlbum.ToCharArray(), TagData.Album, 30);
Array.Copy(FYear.ToCharArray(), TagData.Year, 4);
Array.Copy(FComment.ToCharArray(), TagData.Comment, 30);
if (FTrack > 0)
{
TagData.Comment[28] = '\0';
TagData.Comment[29] = (char)FTrack;
}
TagData.Genre = FGenreID;
// Delete old tag and write new tag
return ( (RemoveFromFile(FileName)) && (SaveTag(FileName, TagData)) );
}
