public void Pin(IArchivable archivable)
{
if (Contains(archivable) && !IsPinned(archivable))
{
pinnedArchivables.Add(archivable);
}
}
public void Unpin(IArchivable archivable)
{
if (Contains(archivable) && IsPinned(archivable))
{
pinnedArchivables.Remove(archivable);
}
}
public static bool Contains(Archive __instance, ref bool __result, IArchivable archivable)
{
lock (__instance) //changed
{
__result = __instance.archivables.Contains(archivable);
return(false);
}
}
public IArchivable ReadObject()
{
uint tag = ReadUInt16();
if (tag == BigObjectTag)
{
tag = ReadUInt32(); // stored as 4-bytes instead
}
else
{
if (tag != NewClassTag && (tag & ClassTag) > 0)
{
tag = (tag - ClassTag) | BigClassTag;
}
}
if (tag != NewClassTag && (tag & BigClassTag) == 0)
{
// specifies an already stored object
uint objectTag = tag - BigClassTag;
if (objectTag >= m_LoadArray.Count)
{
throw new InvalidOperationException("Object tag too large: " + objectTag);
}
return((IArchivable)m_LoadArray[(int)objectTag]);
}
// specifies a new class
ArchiveClass objClass;
if (tag == NewClassTag)
{
// new class followed by object
int schemaNum = ReadInt16();
int nameLength = ReadInt16();
var className = ReadStringTerm(nameLength);
if (!m_HashClasses.ContainsKey(className))
{
throw new InvalidOperationException("Unknown class type deserialising archive: " + className);
}
objClass = m_HashClasses[className];
m_LoadArray.Add(objClass);
}
else
{ // is existing class followed by object
uint classIndex = tag - BigClassTag;
if (classIndex == 0 || classIndex >= m_LoadArray.Count)
{
throw new InvalidOperationException("Invalid existing class index " + classIndex);
}
objClass = (ArchiveClass)m_LoadArray[(int)classIndex];
Debug.Assert(objClass != null);
}
IArchivable create = (IArchivable)objClass.TypeObject.GetConstructor(new Type[] { }).Invoke(new object[] { });
m_LoadArray.Add(create);
create.Read(this);
return(create);
}
public bool Remove(IArchivable archivable)
{
if (!Contains(archivable))
{
return(false);
}
archivables.Remove(archivable);
pinnedArchivables.Remove(archivable);
return(true);
}
public void Unpin(IArchivable archivable)
{
if (this.Contains(archivable))
{
if (this.IsPinned(archivable))
{
this.pinnedArchivables.Remove(archivable);
}
}
}
public bool Remove(IArchivable archivable)
{
if (!this.Contains(archivable))
{
return(false);
}
this.archivables.Remove(archivable);
this.pinnedArchivables.Remove(archivable);
return(true);
}
public void Pin(IArchivable archivable)
{
if (this.Contains(archivable))
{
if (!this.IsPinned(archivable))
{
this.pinnedArchivables.Add(archivable);
}
}
}
public void Unpin(IArchivable archivable)
{
if (!this.Contains(archivable))
{
return;
}
if (!this.IsPinned(archivable))
{
return;
}
this.pinnedArchivables.Remove(archivable);
}
public static bool Remove(Archive __instance, ref bool __result, IArchivable archivable)
{
lock (__instance) //changed
{
if (!__instance.Contains(archivable))
{
__result = false;
return(false);
}
__instance.archivables.Remove(archivable);
__instance.pinnedArchivables.Remove(archivable);
__result = true;
return(false);
}
}
static void Postfix(IArchivable x, ref int __result)
{
if (x is ArchivedDialog dialog)
{
__result = dialog.ID;
}
else if (x is Letter letter)
{
__result = letter.ID;
}
else if (x is Message msg)
{
__result = msg.ID;
}
}
public override void Delete(T entity)
{
IArchivable archivable = entity as IArchivable;
if (archivable != null)
{
archivable.DeletedBy = Thread.CurrentPrincipal.Identity.Name;
archivable.Deleted = DateTime.Now;
_surrogate.Update(entity);
}
else
{
_surrogate.Delete(entity);
}
}
public bool Add(IArchivable archivable)
{
if (archivable == null)
{
Log.Error("Tried to add null archivable.", false);
return(false);
}
if (this.Contains(archivable))
{
return(false);
}
this.archivables.Add(archivable);
this.archivables.SortBy((IArchivable x) => x.CreatedTicksGame);
this.CheckCullArchivables();
return(true);
}
public bool Remove(IArchivable archivable)
{
bool result;
if (!this.Contains(archivable))
{
result = false;
}
else
{
this.archivables.Remove(archivable);
this.pinnedArchivables.Remove(archivable);
result = true;
}
return(result);
}
public static bool Add(Archive __instance, ref bool __result, IArchivable archivable)
{
lock (__instance) //changed
{
if (archivable == null)
{
Log.Error("Tried to add null archivable.");
__result = false;
return(false);
}
if (__instance.Contains(archivable))
{
__result = false;
return(false);
}
__instance.archivables.Add(archivable);
__instance.archivables.SortBy <IArchivable, int>((Func <IArchivable, int>)(x => x.CreatedTicksGame));
__instance.CheckCullArchivables();
__result = true;
return(false);
}
}
public bool Add(IArchivable archivable)
{
bool result;
if (archivable == null)
{
Log.Error("Tried to add null archivable.", false);
result = false;
}
else if (this.Contains(archivable))
{
result = false;
}
else
{
this.archivables.Add(archivable);
this.archivables.SortBy((IArchivable x) => x.CreatedTicksGame);
this.CheckCullArchivables();
result = true;
}
return(result);
}
public void Write(IArchivable o)
{
int existingIndex = m_WrittenObjects.IndexOf(o);
if (existingIndex >= 0)
{
WriteTag((uint)existingIndex, false);
}
else
{
// object not get written - check if class name has been written
if (!m_HashClasses.ContainsKey(o.GetType()))
{
throw new InvalidOperationException("Unexpected class type in ArchiveWriter" + o.GetType().ToString());
}
ArchiveClass archiveClass = (ArchiveClass)m_HashClasses[o.GetType()];
if (archiveClass.Schema == -1)
{
// not yet written this class
WriteTag(NewClassTag, true);
WriteTag(0, false);
//WriteTag(_nNextSchema, false);
archiveClass.Schema = (int)m_NextIndex;
m_NextIndex++;
// for some reason name is not written as a length+string - instead it is always a 16-bit length followed by string data
// (whereas normal StringL is 8-byte length unless that 8-bits indicates longer)
base.Write(Convert.ToUInt16(archiveClass.Name.Length));
WriteStringBytes(archiveClass.Name);
}
else
{
WriteTag((uint)archiveClass.Schema, true);
}
m_NextIndex++; // object itself also counted in index
m_WrittenObjects.Add(o);
o.Write(this);
}
}
public bool Contains(IArchivable archivable)
{
return(this.archivables.Contains(archivable));
}
public static void Archive(this IArchivable obj)
{
obj.DateArchived = DateTimeService.UtcNow;
}
public static bool IsArchived(this IArchivable obj)
{
return(obj.DateArchived.HasValue);
}
private void DoArchivableRow(Rect rect, IArchivable archivable, int index)
{
if (index % 2 == 1)
{
Widgets.DrawLightHighlight(rect);
}
Widgets.DrawHighlightIfMouseover(rect);
Text.Font = GameFont.Small;
Text.Anchor = TextAnchor.MiddleLeft;
Text.WordWrap = false;
Rect rect2 = rect;
Rect rect3 = rect2;
rect3.width = 30f;
rect2.xMin += 40f;
float num;
if (Find.Archive.IsPinned(archivable))
{
num = 1f;
}
else if (Mouse.IsOver(rect3))
{
num = 0.25f;
}
else
{
num = 0f;
}
if (num > 0f)
{
GUI.color = new Color(1f, 1f, 1f, num);
GUI.DrawTexture(new Rect(rect3.x + (rect3.width - 22f) / 2f, rect3.y + (rect3.height - 22f) / 2f, 22f, 22f).Rounded(), MainTabWindow_History.PinTex);
GUI.color = Color.white;
}
Rect rect4 = rect2;
Rect outerRect = rect2;
outerRect.width = 30f;
rect2.xMin += 40f;
Texture archivedIcon = archivable.ArchivedIcon;
if (archivedIcon != null)
{
GUI.color = archivable.ArchivedIconColor;
Widgets.DrawTextureFitted(outerRect, archivedIcon, 0.8f);
GUI.color = Color.white;
}
Rect rect5 = rect2;
rect5.width = 200f;
rect2.xMin += 210f;
Vector2 location = (Find.CurrentMap == null) ? default(Vector2) : Find.WorldGrid.LongLatOf(Find.CurrentMap.Tile);
GUI.color = new Color(0.75f, 0.75f, 0.75f);
int num2 = GenDate.TickGameToAbs(archivable.CreatedTicksGame);
string str = string.Concat(new object[]
{
GenDate.DateFullStringAt((long)num2, location),
", ",
GenDate.HourInteger((long)num2, location.x),
"LetterHour".Translate()
});
Widgets.Label(rect5, str.Truncate(rect5.width, null));
GUI.color = Color.white;
Rect rect6 = rect2;
Widgets.Label(rect6, archivable.ArchivedLabel.Truncate(rect6.width, null));
GenUI.ResetLabelAlign();
Text.WordWrap = true;
TooltipHandler.TipRegion(rect3, "PinArchivableTip".Translate(200));
if (Mouse.IsOver(rect4))
{
TooltipHandler.TipRegion(rect4, archivable.ArchivedTooltip);
}
if (Widgets.ButtonInvisible(rect3, false))
{
if (Find.Archive.IsPinned(archivable))
{
Find.Archive.Unpin(archivable);
SoundDefOf.Checkbox_TurnedOff.PlayOneShotOnCamera(null);
}
else
{
Find.Archive.Pin(archivable);
SoundDefOf.Checkbox_TurnedOn.PlayOneShotOnCamera(null);
}
}
if (Widgets.ButtonInvisible(rect4, false))
{
if (Event.current.button == 1)
{
LookTargets lookTargets = archivable.LookTargets;
if (CameraJumper.CanJump(lookTargets.TryGetPrimaryTarget()))
{
CameraJumper.TryJumpAndSelect(lookTargets.TryGetPrimaryTarget());
Find.MainTabsRoot.EscapeCurrentTab(true);
}
}
else
{
archivable.OpenArchived();
}
}
}
private void DoArchivableRow(Rect rect, IArchivable archivable, int index)
{
if (index % 2 == 1)
{
Widgets.DrawLightHighlight(rect);
}
Widgets.DrawHighlightIfMouseover(rect);
Text.Font = GameFont.Small;
Text.Anchor = TextAnchor.MiddleLeft;
Text.WordWrap = false;
Rect rect2 = rect;
Rect rect3 = rect2;
rect3.width = 30f;
rect2.xMin += 35f;
float num = Find.Archive.IsPinned(archivable) ? 1f : ((!Mouse.IsOver(rect3)) ? 0f : 0.25f);
Rect position = new Rect(rect3.x + (rect3.width - 22f) / 2f, rect3.y + (rect3.height - 22f) / 2f, 22f, 22f).Rounded();
if (num > 0f)
{
GUI.color = new Color(1f, 1f, 1f, num);
GUI.DrawTexture(position, PinTex);
}
else
{
GUI.color = PinOutlineColor;
GUI.DrawTexture(position, PinOutlineTex);
}
GUI.color = Color.white;
Rect rect4 = rect2;
Rect outerRect = rect2;
outerRect.width = 30f;
rect2.xMin += 35f;
Texture archivedIcon = archivable.ArchivedIcon;
if (archivedIcon != null)
{
GUI.color = archivable.ArchivedIconColor;
Widgets.DrawTextureFitted(outerRect, archivedIcon, 0.8f);
GUI.color = Color.white;
}
Rect rect5 = rect2;
rect5.width = 80f;
rect2.xMin += 85f;
Vector2 location = (Find.CurrentMap != null) ? Find.WorldGrid.LongLatOf(Find.CurrentMap.Tile) : default(Vector2);
GUI.color = new Color(0.75f, 0.75f, 0.75f);
Widgets.Label(label: GenDate.DateShortStringAt(GenDate.TickGameToAbs(archivable.CreatedTicksGame), location).Truncate(rect5.width), rect: rect5);
GUI.color = Color.white;
Rect rect6 = rect2;
Widgets.Label(rect6, archivable.ArchivedLabel.Truncate(rect6.width));
GenUI.ResetLabelAlign();
Text.WordWrap = true;
TooltipHandler.TipRegionByKey(rect3, "PinArchivableTip", 200);
if (Mouse.IsOver(rect4))
{
displayedMessageIndex = index;
}
if (Widgets.ButtonInvisible(rect3))
{
if (Find.Archive.IsPinned(archivable))
{
Find.Archive.Unpin(archivable);
SoundDefOf.Checkbox_TurnedOff.PlayOneShotOnCamera();
}
else
{
Find.Archive.Pin(archivable);
SoundDefOf.Checkbox_TurnedOn.PlayOneShotOnCamera();
}
}
if (!Widgets.ButtonInvisible(rect4))
{
return;
}
if (Event.current.button == 1)
{
LookTargets lookTargets = archivable.LookTargets;
if (CameraJumper.CanJump(lookTargets.TryGetPrimaryTarget()))
{
CameraJumper.TryJumpAndSelect(lookTargets.TryGetPrimaryTarget());
Find.MainTabsRoot.EscapeCurrentTab();
}
}
else
{
archivable.OpenArchived();
}
}
private static bool <ExposeData> m__1(IArchivable x)
{
return(x == null);
}
private static int <Add> m__2(IArchivable x)
{
return(x.CreatedTicksGame);
}
public static IEnumerable <ListItem> SetDropDown(IEnumerable <IArchivable> baseSet, IArchivable Current)
{
return(from c in baseSet
where (c.IsActive && !c.IsArchived) || (Current != null && c.ID == Current.ID)
select c.ListItem);
}
public virtual void Restore(IArchivable archivable) => archivable.Archived = false;
public static bool ShouldShow(IArchivable archivable)
{
return(archivable.ArchivedLabel.ToLower().Contains(searchText.ToLower()));
}
public bool IsPinned(IArchivable archivable)
{
return(this.pinnedArchivables.Contains(archivable));
}
public static void Archive(this IArchivable obj)
{
obj.IsArchived = true;
}
