public void Handle(WallPostAddedOrEdited message)
{
if (!message.Edited)
{
return;
}
using (IEnumerator <IVirtualizable> enumerator = ((Collection <IVirtualizable>) this.PostsVM.Collection).GetEnumerator())
{
while (enumerator.MoveNext())
{
IVirtualizable current = enumerator.Current;
WallPostItem wallPostItem = current as WallPostItem;
if (wallPostItem != null && wallPostItem.WallPost.to_id == message.NewlyAddedWallPost.to_id && wallPostItem.WallPost.id == message.NewlyAddedWallPost.id)
{
List <WallPost> wallPosts = new List <WallPost>();
wallPosts.Add(message.NewlyAddedWallPost);
List <User> users = message.Users;
List <Group> groups = message.Groups;
// ISSUE: variable of the null type
double itemsWidth = 0.0;
this.PostsVM.Insert((IVirtualizable)Enumerable.First <IVirtualizable>(WallPostItemsGenerator.Generate(wallPosts, users, groups, null, itemsWidth)), ((Collection <IVirtualizable>) this.PostsVM.Collection).IndexOf(current));
this.PostsVM.Delete(current);
break;
}
}
}
}
public void RemoveItem(IVirtualizable itemToBeRemoved)
{
itemToBeRemoved.ChangeState(VirtualizableState.Unloaded);
this.SetResetParent(false, itemToBeRemoved);
this._virtualizableItems.Remove(itemToBeRemoved);
this._loadedSegment = new Segment();
this.RearrangeAllItems();
this.PerformLoadUnload(this._isScrolling ? VirtualizableState.LoadedPartially : VirtualizableState.LoadedFully);
}
private void LoadItemsInSegment(Segment segment, VirtualizableState desiredState)
{
for (int lowerBound = segment.LowerBound; lowerBound <= segment.UpperBound; ++lowerBound)
{
IVirtualizable virtualizableItem = this._virtualizableItems[lowerBound];
virtualizableItem.ChangeState(desiredState);
this.AddToChildren((UIElement)virtualizableItem.View);
}
}
private void UnloadItemsInSegment(Segment segment)
{
for (int lowerBound = segment.LowerBound; lowerBound <= segment.UpperBound; ++lowerBound)
{
IVirtualizable virtualizableItem = this._virtualizableItems[lowerBound];
this.RemoveFromChildren((UIElement)virtualizableItem.View);
virtualizableItem.ChangeState(VirtualizableState.Unloaded);
}
}
private int GetIndexOfFirstLoadedComment()
{
IVirtualizable virtualizable = this._virtPanel.VirtualizableItems.FirstOrDefault <IVirtualizable>((Func <IVirtualizable, bool>)(i => i is CommentItem));
if (virtualizable == null)
{
return(0);
}
return(this._virtPanel.VirtualizableItems.IndexOf(virtualizable));
}
private static VoiceMessageItem GetLoadedVoiceMessageItem(IVirtualizable item)
{
VoiceMessageItem voiceMessageItem = ConversationItems.GetVoiceMessageItem(item);
if (voiceMessageItem != null && voiceMessageItem.CurrentState != VirtualizableState.Unloaded)
{
return(voiceMessageItem);
}
return((VoiceMessageItem)null);
}
private int GetIndexToInsertItems()
{
IVirtualizable virtualizable = this._panel.VirtualizableItems.FirstOrDefault <IVirtualizable>((Func <IVirtualizable, bool>)(vi => vi is CommentItem));
if (virtualizable == null)
{
return(this._panel.VirtualizableItems.Count);
}
return(this._panel.VirtualizableItems.IndexOf(virtualizable));
}
private void SetResetParent(bool set, IVirtualizable item)
{
if (set)
{
item.Parent = (IMyVirtualizingPanel)this;
}
else
{
item.Parent = null;
}
}
private double HeightOfItemIncludingMargin(IVirtualizable virtualizableItem)
{
double fixedHeight = virtualizableItem.FixedHeight;
Thickness margin1 = virtualizableItem.Margin;
// ISSUE: explicit reference operation
double top = margin1.Top;
double num = fixedHeight + top;
Thickness margin2 = virtualizableItem.Margin;
// ISSUE: explicit reference operation
double bottom = ((Thickness)@margin2).Bottom;
return(num + bottom);
}
public void Substitute(IVirtualizable item, IVirtualizable updatedItem)
{
int num1 = this.VirtualizableItems.IndexOf(item);
if (num1 < 0)
{
return;
}
this.RemoveItem(item);
int index = num1;
List <IVirtualizable> itemsToInsert = new List <IVirtualizable>();
itemsToInsert.Add(updatedItem);
this.InsertRemoveItems(index, itemsToInsert, false, null);
}
private void MoreCommentsAreLoaded(bool result)
{
if (!result)
{
return;
}
Execute.ExecuteOnUIThread((Action)(() =>
{
UCItem moreCommentsItem = this._loadMoreCommentsItem;
IVirtualizable virtualizable = (IVirtualizable)Enumerable.FirstOrDefault <IVirtualizable>(this.virtPanel.VirtualizableItems, (Func <IVirtualizable, bool>)(i => i is CommentItem));
if (virtualizable == null)
{
return;
}
this.virtPanel.InsertRemoveItems(this.virtPanel.VirtualizableItems.IndexOf(virtualizable), this.GenereateVirtualizableItemsToAdd(), true, (IVirtualizable)moreCommentsItem);
}));
}
public void Substitute(IVirtualizable item, IVirtualizable updatedItem)
{
int num1 = this.VirtualizableItems.IndexOf(item);
if (num1 < 0)
{
return;
}
this.RemoveItem(item);
int index = num1;
List <IVirtualizable> itemsToInsert = new List <IVirtualizable>();
itemsToInsert.Add(updatedItem);
int num2 = 0;
// ISSUE: variable of the null type
this.InsertRemoveItems(index, itemsToInsert, num2 != 0, null);
}
private static VoiceMessageItem GetVoiceMessageItem(IVirtualizable item)
{
MessageItem messageItem = item as MessageItem;
MessageContentItem messageContentItem = messageItem == null ? item as MessageContentItem : messageItem.VirtualizableChildren.FirstOrDefault <IVirtualizable>((Func <IVirtualizable, bool>)(i => i is MessageContentItem)) as MessageContentItem;
if (messageContentItem != null)
{
if (messageContentItem.ForwardedList != null && messageContentItem.ForwardedList.Count > 0)
{
return((VoiceMessageItem)null);
}
AttachmentsItem attachmentsItem = messageContentItem.VirtualizableChildren.FirstOrDefault <IVirtualizable>((Func <IVirtualizable, bool>)(i => i is AttachmentsItem)) as AttachmentsItem;
VoiceMessageItem voiceMessageItem = (attachmentsItem != null ? attachmentsItem.VirtualizableChildren.FirstOrDefault <IVirtualizable>((Func <IVirtualizable, bool>)(i => i is VoiceMessageItem)) : (IVirtualizable)null) as VoiceMessageItem;
if (voiceMessageItem != null)
{
return(voiceMessageItem);
}
}
return((VoiceMessageItem)null);
}
public void RearrangeAllItems()
{
double num1 = 0.0;
this._thresholdPointIndexes.Clear();
int num2 = 0;
foreach (IVirtualizable virtualizableItem in this._virtualizableItems)
{
if (virtualizableItem == null)
{
throw new Exception("Can only add virtualizable items.");
}
IVirtualizable virtualizable = virtualizableItem;
Thickness margin = virtualizableItem.Margin;
double left = margin.Left;
margin = virtualizableItem.Margin;
double top1 = margin.Top + num1;
margin = virtualizableItem.Margin;
double right = margin.Right;
margin = virtualizableItem.Margin;
double bottom1 = margin.Bottom;
Thickness thickness = new Thickness(left, top1, right, bottom1);
virtualizable.ViewMargin = thickness;
double fixedHeight = virtualizableItem.FixedHeight;
margin = virtualizableItem.Margin;
double top2 = margin.Top;
double num3 = fixedHeight + top2;
margin = virtualizableItem.Margin;
double bottom2 = margin.Bottom;
double num4 = num3 + bottom2;
foreach (int coveredPoint in this.GetCoveredPoints(num1, num1 + num4))
{
this._thresholdPointIndexes[coveredPoint] = num2;
}
num1 += num4;
++num2;
}
this.ChangeHeight(num1);
this._listScrollViewer.UpdateLayout();
}
public void AddItems(IEnumerable <IVirtualizable> _itemsToBeAdded)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
double num1 = 0.0;
if (this._virtualizableItems.Count > 0)
{
num1 = this._virtualizableItems.Sum <IVirtualizable>((Func <IVirtualizable, double>)(vi => vi.FixedHeight + vi.Margin.Top + vi.Margin.Bottom));
}
foreach (IVirtualizable virtualizable1 in _itemsToBeAdded)
{
if (virtualizable1 == null)
{
throw new Exception("Can only add virtualizable items.");
}
IVirtualizable virtualizable2 = virtualizable1;
double left = virtualizable1.Margin.Left;
double top = virtualizable1.Margin.Top + num1;
Thickness margin = virtualizable1.Margin;
double right = margin.Right;
margin = virtualizable1.Margin;
double bottom = margin.Bottom;
Thickness thickness = new Thickness(left, top, right, bottom);
virtualizable2.ViewMargin = thickness;
this.SetResetParent(true, virtualizable1);
this._virtualizableItems.Add(virtualizable1);
double num2 = virtualizable1.FixedHeight + virtualizable1.Margin.Top + virtualizable1.Margin.Bottom;
foreach (int coveredPoint in this.GetCoveredPoints(num1, num1 + num2))
{
this._thresholdPointIndexes[coveredPoint] = this._virtualizableItems.Count - 1;
}
num1 += num2;
}
this.PerformLoadUnload(this._isScrolling ? VirtualizableState.LoadedPartially : VirtualizableState.LoadedFully);
this.ChangeHeight(num1);
stopwatch.Stop();
this.Log(string.Format("MyVirtualizingPanel.AddItems {0}", (object)stopwatch.ElapsedMilliseconds));
}
private void ProcessInputParameters()
{
Group parameterForIdAndReset = ParametersRepository.GetParameterForIdAndReset("PickedGroupForRepost") as Group;
if (parameterForIdAndReset == null)
{
return;
}
IEnumerator <IVirtualizable> enumerator = ((Collection <IVirtualizable>)NewsViewModel.Instance.NewsFeedVM.Collection).GetEnumerator();
try
{
while (enumerator.MoveNext())
{
IVirtualizable current = enumerator.Current;
WallPostItem wallPostItem = current as WallPostItem;
if (wallPostItem == null && current is NewsFeedAdsItem)
{
wallPostItem = (current as NewsFeedAdsItem).WallPostItem;
}
if ((wallPostItem != null ? wallPostItem.LikesAndCommentsItem : null) != null && wallPostItem.LikesAndCommentsItem.ShareInGroupIfApplicable(parameterForIdAndReset.id, parameterForIdAndReset.name))
{
break;
}
VideosNewsItem videosNewsItem = current as VideosNewsItem;
if (videosNewsItem != null)
{
videosNewsItem.LikesAndCommentsItem.ShareInGroupIfApplicable(parameterForIdAndReset.id, parameterForIdAndReset.name);
}
}
}
finally
{
if (enumerator != null)
{
enumerator.Dispose();
}
}
}
public int GetIndexOfItemOnScreen()
{
double verticalOffset = this.ScrollViewer.VerticalOffset;
double num1 = 0.0;
int num2 = 0;
List <IVirtualizable> .Enumerator enumerator = this.VirtualizableItems.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
IVirtualizable current = enumerator.Current;
double num3 = num1;
double fixedHeight = current.FixedHeight;
Thickness margin = current.Margin;
// ISSUE: explicit reference operation
double top = ((Thickness)@margin).Top;
double num4 = fixedHeight + top;
margin = current.Margin;
// ISSUE: explicit reference operation
double bottom = ((Thickness)@margin).Bottom;
double num5 = num4 + bottom;
num1 = num3 + num5;
if (num1 <= verticalOffset)
{
++num2;
}
else
{
break;
}
}
}
finally
{
enumerator.Dispose();
}
return(num2);
}
public void RespondToChildHeightChange(IVirtualizable child)
{
this.GenerateLayoutForWallPost();
this.RegenerateChildren();
this.NotifyHeightChanged();
}
public void InsertRemoveItems(int index, List <IVirtualizable> itemsToInsert, bool keepItemsBelowIndexFixed = false, IVirtualizable itemToRemove = null)
{
try
{
bool flag = false;
if (keepItemsBelowIndexFixed)
{
double num = 0.0;
for (int index1 = 0; index1 < index; ++index1)
{
num += this.VirtualizableItems[index1].FixedHeight + this.VirtualizableItems[index1].Margin.Top + this.VirtualizableItems[index1].Margin.Bottom;
}
if (num < this._listScrollViewer.VerticalOffset + this._listScrollViewer.ViewportHeight)
{
flag = true;
}
}
this._loadedSegment = new Segment();
double num1 = itemsToInsert.Sum <IVirtualizable>((Func <IVirtualizable, double>)(i => i.FixedHeight + i.Margin.Top + i.Margin.Bottom));
this.SetResetParent(true, (IEnumerable <IVirtualizable>)itemsToInsert);
this._virtualizableItems.InsertRange(index, (IEnumerable <IVirtualizable>)itemsToInsert);
if (itemToRemove != null)
{
itemToRemove.ChangeState(VirtualizableState.Unloaded);
double num2 = num1;
double fixedHeight = itemToRemove.FixedHeight;
Thickness margin = itemToRemove.Margin;
double top = margin.Top;
double num3 = fixedHeight + top;
margin = itemToRemove.Margin;
double bottom = margin.Bottom;
double num4 = num3 + bottom;
num1 = num2 - num4;
this.SetResetParent(false, itemToRemove);
this._virtualizableItems.Remove(itemToRemove);
}
this.RearrangeAllItems();
if (flag)
{
this._changingVerticalOffset = true;
this.Log("SCROLLING TO " + (object)this._listScrollViewer.VerticalOffset + (object)num1 + " scroll height : " + (object)this._listScrollViewer.ExtentHeight);
this._listScrollViewer.ScrollToVerticalOffset(this._listScrollViewer.VerticalOffset + num1);
this._changingVerticalOffset = false;
}
this.PerformLoadUnload(this._isScrolling ? VirtualizableState.LoadedPartially : VirtualizableState.LoadedFully);
}
catch
{
}
}
private double HeightOfItemIncludingMargin(IVirtualizable virtualizableItem)
{
return(virtualizableItem.FixedHeight + virtualizableItem.Margin.Top + virtualizableItem.Margin.Bottom);
}
private void collection_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
MyVirtualizingPanel2 virtualizingPanel2 = this;
List <IVirtualizable> itemsToInsert = new List <IVirtualizable>();
if (e.NewItems != null)
{
foreach (object newItem in (IEnumerable)e.NewItems)
{
if (newItem is IVirtualizable)
{
itemsToInsert.Add(newItem as IVirtualizable);
}
else if (this.CreateVirtItemFunc != null)
{
itemsToInsert.Add(this.CreateVirtItemFunc(newItem));
}
}
}
List <IVirtualizable> virtualizableList1 = new List <IVirtualizable>();
if (e.OldItems != null)
{
foreach (object oldItem in (IEnumerable)e.OldItems)
{
if (oldItem is IVirtualizable)
{
virtualizableList1.Add(oldItem as IVirtualizable);
}
else if (e.OldStartingIndex >= 0 && e.OldStartingIndex < virtualizingPanel2.VirtualizableItems.Count)
{
IVirtualizable itemToBeRemoved = virtualizingPanel2.VirtualizableItems[e.OldStartingIndex];
virtualizingPanel2.RemoveItem(itemToBeRemoved);
}
}
}
if (this._isEditing)
{
this._addedWhileEdited.AddRange((IEnumerable <IVirtualizable>)itemsToInsert);
}
else if (e.Action == NotifyCollectionChangedAction.Add)
{
if (e.NewStartingIndex >= virtualizingPanel2.VirtualizableItems.Count)
{
virtualizingPanel2.AddItems((IEnumerable <IVirtualizable>)itemsToInsert);
}
else
{
virtualizingPanel2.InsertRemoveItems(e.NewStartingIndex, itemsToInsert, virtualizingPanel2.KeepScrollPositionWhenAddingItems, (IVirtualizable)null);
}
}
else if (e.Action == NotifyCollectionChangedAction.Reset)
{
virtualizingPanel2.ClearItems();
List <IVirtualizable> virtualizableList2 = new List <IVirtualizable>();
foreach (object obj in (IEnumerable)virtualizingPanel2.ItemsSource)
{
virtualizableList2.Add(obj is IVirtualizable ? obj as IVirtualizable : this.CreateVirtItemFunc(obj));
}
virtualizingPanel2.AddItems((IEnumerable <IVirtualizable>)virtualizableList2);
}
else
{
if (e.Action != NotifyCollectionChangedAction.Remove || virtualizableList1.Count <= 0)
{
return;
}
virtualizingPanel2.RemoveItem(virtualizableList1[0]);
}
}
