Xune/UIX.RenderApi.Skia/Microsoft/Iris/Render/Graphics/DynamicBucket.cs

// Decompiled with JetBrains decompiler
// Type: Microsoft.Iris.Render.Graphics.DynamicBucket
// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll

using System.Collections;

namespace Microsoft.Iris.Render.Graphics
{
  internal sealed class DynamicBucket
  {
    private DynamicPool m_poolOwner;
    private int m_nHeightPxl;
    private ArrayList m_alRows;
    private bool m_fCompacting;

    public DynamicBucket(DynamicPool poolOwner, int nHeightPxl)
    {
      this.m_poolOwner = poolOwner;
      this.m_nHeightPxl = nHeightPxl;
      this.m_alRows = new ArrayList();
    }

    public int RowHeight => this.m_nHeightPxl;

    internal DynamicPool DynamicPool => this.m_poolOwner;

    public Surface CreateSurface(
      ISurfaceContentOwner surfaceOwner,
      Size sizeRequestPxl,
      Size sizeContentPxl,
      Size sizeGutter,
      bool fRotated,
      PoolAllocMethod allocMethod)
    {
      ArrayList alReloadContent = (ArrayList) null;
      DynamicRow dynamicRow = (DynamicRow) null;
      switch (allocMethod)
      {
        case PoolAllocMethod.Available:
          dynamicRow = this.FindTrivialFreeSpaceRow(sizeRequestPxl.Width);
          break;
        case PoolAllocMethod.New:
        case PoolAllocMethod.CompactDead:
        case PoolAllocMethod.CompactAll:
          alReloadContent = new ArrayList();
          dynamicRow = this.m_poolOwner.CreateRow(alReloadContent, this, surfaceOwner, sizeRequestPxl, allocMethod);
          if (dynamicRow != null)
          {
            this.m_alRows.Add((object) dynamicRow);
            break;
          }
          break;
        case PoolAllocMethod.ScavengeDead:
          alReloadContent = new ArrayList();
          dynamicRow = this.ScavengeForAvailableSpace(alReloadContent, sizeRequestPxl);
          break;
      }
      if (alReloadContent != null)
        this.m_poolOwner.ProcessDeferredContent(alReloadContent);
      return dynamicRow?.CreateSurface(surfaceOwner, sizeRequestPxl, sizeContentPxl, sizeGutter, fRotated);
    }

    public void NotifyEmpty(DynamicRow rowEmpty)
    {
      if (this.m_fCompacting)
        return;
      this.NotifyEmptyWorker(this.m_alRows.IndexOf((object) rowEmpty));
    }

    private void NotifyEmptyWorker(int idxRow)
    {
      DynamicRow alRow = (DynamicRow) this.m_alRows[idxRow];
      this.m_alRows.RemoveAt(idxRow);
      this.m_poolOwner.NotifyEmpty(alRow);
      if (this.m_alRows.Count != 0)
        return;
      this.m_poolOwner.NotifyEmpty(this);
    }

    private DynamicRow FindTrivialFreeSpaceRow(int nRequestedWidth)
    {
      for (int index = 0; index < this.m_alRows.Count; ++index)
      {
        DynamicRow alRow = (DynamicRow) this.m_alRows[index];
        if (nRequestedWidth <= alRow.LargestFree)
          return alRow;
      }
      return (DynamicRow) null;
    }

    private DynamicRow ScavengeForAvailableSpace(
      ArrayList alReloadContent,
      Size sizeRequested)
    {
      uint uAvgTimestampsNoCompact;
      uint uAvgTimestampsWithCompact;
      object objResultOfSpeculation = this.m_poolOwner.SpeculateScavengeRows(this.RowHeight, this, out uAvgTimestampsNoCompact, out uAvgTimestampsWithCompact);
      DynamicRow dynamicRow = (DynamicRow) null;
      if (uAvgTimestampsNoCompact == uint.MaxValue)
        dynamicRow = this.ScavengeLocalRows(alReloadContent, sizeRequested.Width);
      if (uAvgTimestampsNoCompact != uint.MaxValue || uAvgTimestampsWithCompact != uint.MaxValue)
      {
        int nRequestedHeight = 0;
        if (dynamicRow == null)
          nRequestedHeight = this.RowHeight;
        this.m_poolOwner.FinishScavengeRows(alReloadContent, nRequestedHeight, objResultOfSpeculation);
      }
      return dynamicRow;
    }

    private DynamicRow ScavengeLocalRows(ArrayList alReloadContent, int nRequestedWidth)
    {
      DynamicRow dynamicRow1 = (DynamicRow) null;
      object obj1 = (object) null;
      uint num1 = uint.MaxValue;
      DynamicRow dynamicRow2 = (DynamicRow) null;
      object obj2 = (object) null;
      uint num2 = uint.MaxValue;
      for (int index = 0; index < this.m_alRows.Count; ++index)
      {
        DynamicRow alRow = (DynamicRow) this.m_alRows[index];
        uint uAvgTimestampsNoCompact;
        uint uAvgTimestampsWithCompact;
        object obj3 = alRow.SpeculateScavengeBlocks(nRequestedWidth, out uAvgTimestampsNoCompact, out uAvgTimestampsWithCompact);
        if (num1 > uAvgTimestampsNoCompact)
        {
          num1 = uAvgTimestampsNoCompact;
          obj1 = obj3;
          dynamicRow1 = alRow;
        }
        if (num2 > uAvgTimestampsWithCompact)
        {
          num2 = uAvgTimestampsWithCompact;
          obj2 = obj3;
          dynamicRow2 = alRow;
        }
      }
      DynamicRow dynamicRow3 = dynamicRow1;
      object objResultOfPotentialCalculation = obj1;
      if (dynamicRow3 == null)
      {
        dynamicRow3 = dynamicRow2;
        objResultOfPotentialCalculation = obj2;
      }
      if (dynamicRow3 != null && !dynamicRow3.FinishScavengeBlocks(alReloadContent, nRequestedWidth, objResultOfPotentialCalculation))
        dynamicRow3 = (DynamicRow) null;
      if (dynamicRow3 != null && !this.m_alRows.Contains((object) dynamicRow3))
        dynamicRow3 = (DynamicRow) null;
      return dynamicRow3;
    }

    internal void CollectDeadBlocks()
    {
      if (this.m_alRows.Count <= 0)
        return;
      this.m_fCompacting = true;
      try
      {
        for (int index = 0; index < this.m_alRows.Count; ++index)
          ((DynamicRow) this.m_alRows[index]).CollectDeadBlocks();
        this.RemoveEmptyRows();
      }
      finally
      {
        this.m_fCompacting = false;
      }
    }

    internal void CompactBlocks(ArrayList alReloadContent, bool fCompactToRight)
    {
      if (this.m_alRows.Count <= 0)
        return;
      this.m_fCompacting = true;
      try
      {
        int index = 0;
        for (; index < this.m_alRows.Count; ++index)
        {
          DynamicRow alRow1 = (DynamicRow) this.m_alRows[index];
          alRow1.CompactBlocks(alReloadContent, fCompactToRight);
          int num = index + 1;
          while (num < this.m_alRows.Count)
          {
            DynamicRow alRow2 = (DynamicRow) this.m_alRows[num++];
            if (!DynamicRow.MoveBlocksToEnd(alReloadContent, alRow1, alRow2, fCompactToRight))
              break;
          }
        }
        this.RemoveEmptyRows();
      }
      finally
      {
        this.m_fCompacting = false;
      }
    }

    internal void RemoveEmptyRows()
    {
      int num = 0;
      while (num < this.m_alRows.Count)
      {
        if (((DynamicRow) this.m_alRows[num]).IsEmpty)
          this.NotifyEmptyWorker(num);
        else
          ++num;
      }
    }

    public int ID => 0;

    internal void AssertOwningThread() => this.m_poolOwner.AssertOwningThread();
  }
}