Xune/UIX.RenderApi.Skia/Microsoft/Iris/Render/Internal/DisplayManager.cs

// Decompiled with JetBrains decompiler
// Type: Microsoft.Iris.Render.Internal.DisplayManager
// 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 Microsoft.Iris.Render.Common;
using Microsoft.Iris.Render.Protocol;
using Microsoft.Iris.Render.Protocols.Splash.Desktop.Nt;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;

namespace Microsoft.Iris.Render.Internal
{
  internal class DisplayManager : 
    RenderObject,
    IDisplayManager,
    IDesktopManagerCallback,
    IRenderHandleOwner,
    IEnumerable
  {
    private const uint MONITORINFOF_PRIMARY = 1;
    private static ushort[] s_ByteOrder_MonitorInfoCallbackMsg;
    private RenderSession m_session;
    private RenderEngine m_engine;
    private RemoteDesktopManager m_remoteManager;
    private DisplayMode[] m_arExtraModes;
    private DisplayManager.DisplayInfo m_info;
    private DisplayManager.DisplayInfo m_infoRebuilding;
    private Display m_dispRebuildLastAdded;
    private ArrayList m_alRebuildSupportedModes;
    private ArrayList m_alRebuildAllModes;
    private bool m_fPendingChangeNotification;

    private DisplayManager(RenderSession session, RenderEngine engine, bool fEnumDisplayModes)
    {
      this.m_session = session;
      this.m_engine = engine;
      this.m_info = new DisplayManager.DisplayInfo();
      this.m_arExtraModes = DisplayMode.EmptyModes;
      this.m_remoteManager = this.m_session.BuildRemoteDesktopManager(this, fEnumDisplayModes);
      this.m_remoteManager.SendRebuildMonitorCache();
    }

    internal static DisplayManager CreateDisplayManager(
      RenderSession session,
      RenderEngine engine,
      bool fEnumDisplayModes)
    {
      return new DisplayManager(session, engine, fEnumDisplayModes);
    }

    protected override void Dispose(bool fInDispose)
    {
      if (fInDispose && this.m_remoteManager != null)
        this.m_remoteManager.Dispose();
      this.m_remoteManager = (RemoteDesktopManager) null;
      base.Dispose(fInDispose);
    }

    public IDisplay PrimaryDisplay => (IDisplay) this.m_info.primaryDisplay;

    public DisplayMode[] ExtraModes
    {
      get => this.m_arExtraModes;
      set
      {
        if (value == null)
          value = DisplayMode.EmptyModes;
        this.m_arExtraModes = value;
      }
    }

    internal RemoteDesktopManager RemoteStub => this.m_remoteManager;

    public IDisplay DisplayFromDeviceName(string stDeviceName) => (IDisplay) this.DisplayFromName(stDeviceName);

    private Display DisplayFromName(string stDeviceName)
    {
      Display display1 = (Display) null;
      if (!string.IsNullOrEmpty(stDeviceName))
      {
        foreach (Display display2 in this.m_info.displays)
        {
          if (string.Compare(display2.DeviceName, stDeviceName, StringComparison.OrdinalIgnoreCase) == 0)
          {
            display1 = display2;
            break;
          }
        }
      }
      return display1;
    }

    internal Display DisplayFromUniqueId(uint idDisplay)
    {
      foreach (Display display in this.m_info.displays)
      {
        if ((int) idDisplay == (int) display.UniqueId)
          return display;
      }
      return (Display) null;
    }

    RENDERHANDLE IRenderHandleOwner.RenderHandle => this.m_remoteManager.RenderHandle;

    void IRenderHandleOwner.OnDisconnect() => this.m_remoteManager = (RemoteDesktopManager) null;

    void IDesktopManagerCallback.OnBeginEnumMonitorInfo(RENDERHANDLE target)
    {
      this.m_infoRebuilding = new DisplayManager.DisplayInfo();
      this.m_dispRebuildLastAdded = (Display) null;
      this.m_alRebuildSupportedModes = new ArrayList();
      this.m_alRebuildAllModes = new ArrayList();
    }

    void IDesktopManagerCallback.OnEndEnumMonitorInfo(RENDERHANDLE target)
    {
      foreach (Display display in this.m_infoRebuilding.displays)
      {
        if (display.IsPrimary)
          this.m_infoRebuilding.primaryDisplay = display;
      }
      this.m_info = this.m_infoRebuilding;
      this.m_infoRebuilding = (DisplayManager.DisplayInfo) null;
      this.m_dispRebuildLastAdded = (Display) null;
      this.m_alRebuildSupportedModes = (ArrayList) null;
      this.m_alRebuildAllModes = (ArrayList) null;
      if (this.DisplayChange == null || this.m_fPendingChangeNotification)
        return;
      this.m_session.DeferredInvoke((Delegate) new DeferredHandler(this.DeliverDisplayChangeNotification), (object) null, DeferredInvokePriority.Normal);
      this.m_fPendingChangeNotification = true;
    }

    unsafe void IDesktopManagerCallback.OnMonitorInfo(
      RENDERHANDLE target,
      Message* pmsgRaw)
    {
      if (this.m_session.IsForeignByteOrderOnWindowing)
        MarshalHelper.SwapByteOrder((byte*) pmsgRaw, ref DisplayManager.s_ByteOrder_MonitorInfoCallbackMsg, typeof (DisplayManager.MonitorInfoCallbackMsg), 0, 0);
      Display display = this.ConvertMonitorInfo((DisplayManager.MonitorInfoCallbackMsg*) pmsgRaw);
      this.m_dispRebuildLastAdded = display;
      this.m_alRebuildSupportedModes.Clear();
      this.m_alRebuildAllModes.Clear();
      this.m_infoRebuilding.displays.Add((object) display);
    }

    void IDesktopManagerCallback.OnBeginDisplayModes(RENDERHANDLE target)
    {
    }

    void IDesktopManagerCallback.OnDisplayMode(
      RENDERHANDLE target,
      RenderDisplayMode rmodeAdd,
      bool fSupported)
    {
      DisplayMode displayMode = new DisplayMode();
      displayMode.sizePhysicalPxl = rmodeAdd.sizePhysicalPxl;
      displayMode.sizeLogicalPxl = rmodeAdd.sizeLogicalPxl;
      displayMode.nFormat = rmodeAdd.nFormat;
      displayMode.nRefreshRate = rmodeAdd.nRefreshRate;
      displayMode.fInterlaced = rmodeAdd.Interlaced;
      displayMode.fTvMode = false;
      if (fSupported)
        this.m_alRebuildSupportedModes.Add((object) displayMode);
      else
        this.m_alRebuildAllModes.Add((object) displayMode);
    }

    void IDesktopManagerCallback.OnEndDisplayModes(RENDERHANDLE target)
    {
      DisplayMode[] arSupportedModes;
      DisplayMode[] arExtraModes;
      DisplayMode[] arAllModes;
      this.BuildModeLists(out arSupportedModes, out arExtraModes, out arAllModes);
      if (arSupportedModes.Length <= 0)
        return;
      this.m_dispRebuildLastAdded.UpdateDisplayModes(arSupportedModes, arExtraModes, arAllModes);
    }

    public IEnumerator GetEnumerator() => this.m_info != null ? this.m_info.displays.GetEnumerator() : new Display[0].GetEnumerator();

    public event EventHandler DisplayChange;

    private void DeliverDisplayChangeNotification(object param)
    {
      if (!this.m_fPendingChangeNotification)
        return;
      this.m_fPendingChangeNotification = false;
      if (this.DisplayChange == null)
        return;
      this.DisplayChange((object) this, EventArgs.Empty);
    }

    private unsafe Display ConvertMonitorInfo(DisplayManager.MonitorInfoCallbackMsg* pmsg)
    {
      string stringUni1 = Marshal.PtrToStringUni(new IntPtr((void*) &pmsg->pad_szDevice1));
      Display display = (Display) null;
      if (this.m_info != null)
        display = this.DisplayFromName(stringUni1);
      if (display == null)
        display = new Display(this, this.m_engine, stringUni1, pmsg->idDisplay);
      Rectangle rcMonitor = new Rectangle(pmsg->rcMonLeft, pmsg->rcMonTop, pmsg->rcMonRight - pmsg->rcMonLeft, pmsg->rcMonBottom - pmsg->rcMonTop);
      Rectangle rcWork = new Rectangle(pmsg->rcWrkLeft, pmsg->rcWrkTop, pmsg->rcWrkRight - pmsg->rcWrkLeft, pmsg->rcWrkBottom - pmsg->rcWrkTop);
      bool fPrimary = ((int) pmsg->dwFlags & 1) != 0;
      TvFormat nTvFormat = (TvFormat) pmsg->nTvFormat;
      DisplayMode modeDesktop = new DisplayMode();
      modeDesktop.sizePhysicalPxl.Width = pmsg->sizeScreenWidth;
      modeDesktop.sizePhysicalPxl.Height = pmsg->sizeScreenHeight;
      modeDesktop.sizeLogicalPxl.Width = pmsg->sizeScreenWidth;
      modeDesktop.sizeLogicalPxl.Height = pmsg->sizeScreenHeight;
      modeDesktop.nFormat = (SurfaceFormat) pmsg->nFormat;
      modeDesktop.nRefreshRate = pmsg->nRefreshRate;
      modeDesktop.fInterlaced = pmsg->fInterlaced != 0U;
      modeDesktop.fTvMode = false;
      string stringUni2 = Marshal.PtrToStringUni(new IntPtr((void*) &pmsg->pad_szMonitorPnP1));
      display.UpdateMonitorInfo(rcMonitor, rcWork, fPrimary, nTvFormat, stringUni2, modeDesktop);
      return display;
    }

    private void BuildModeLists(
      out DisplayMode[] arSupportedModes,
      out DisplayMode[] arExtraModes,
      out DisplayMode[] arAllModes)
    {
      DisplayMode.RenderModeComparer renderModeComparer = new DisplayMode.RenderModeComparer();
      arSupportedModes = (DisplayMode[]) this.m_alRebuildSupportedModes.ToArray(typeof (DisplayMode));
      Array.Sort<DisplayMode>(arSupportedModes, (IComparer<DisplayMode>) renderModeComparer);
      arAllModes = (DisplayMode[]) this.m_alRebuildAllModes.ToArray(typeof (DisplayMode));
      Array.Sort<DisplayMode>(arAllModes, (IComparer<DisplayMode>) renderModeComparer);
      Vector<DisplayMode> vector = new Vector<DisplayMode>();
      int length = this.m_arExtraModes.Length;
      List<int>[] intListArray = new List<int>[length];
      for (int index = 0; index < length; ++index)
        intListArray[index] = new List<int>();
      for (int index1 = 0; index1 < this.m_alRebuildAllModes.Count; ++index1)
      {
        DisplayMode alRebuildAllMode = (DisplayMode) this.m_alRebuildAllModes[index1];
        if (Array.BinarySearch<DisplayMode>(arSupportedModes, alRebuildAllMode, (IComparer<DisplayMode>) renderModeComparer) < 0)
        {
          for (int index2 = 0; index2 < this.m_arExtraModes.Length; ++index2)
          {
            DisplayMode arExtraMode = this.m_arExtraModes[index2];
            if (DisplayMode.CompareRenderModes(alRebuildAllMode, arExtraMode) == 0)
            {
              vector.Add(alRebuildAllMode);
              intListArray[index2] = (List<int>) null;
            }
            else if (DisplayMode.CompareSimilarModes(alRebuildAllMode, arExtraMode) == 0)
              intListArray[index2]?.Add(index1);
          }
        }
      }
      foreach (List<int> intList in intListArray)
      {
        if (intList != null)
        {
          foreach (int index in intList)
            vector.Add((DisplayMode) this.m_alRebuildAllModes[index]);
        }
      }
      arExtraModes = vector.ToArray();
      Array.Sort<DisplayMode>(arExtraModes, (IComparer<DisplayMode>) renderModeComparer);
    }

    private class DisplayInfo
    {
      public Display primaryDisplay;
      public ArrayList displays = new ArrayList();
    }

    [ComVisible(false)]
    private struct MonitorInfoCallbackMsg
    {
      public uint cbSize;
      public int nMsg;
      public RENDERHANDLE idObjectSubject;
      public uint idDisplay;
      public uint nTvFormat;
      public int sizeScreenWidth;
      public int sizeScreenHeight;
      public uint nFormat;
      public int nRefreshRate;
      public uint fInterlaced;
      public uint cbMiSize;
      public int rcMonLeft;
      public int rcMonTop;
      public int rcMonRight;
      public int rcMonBottom;
      public int rcWrkLeft;
      public int rcWrkTop;
      public int rcWrkRight;
      public int rcWrkBottom;
      public uint dwFlags;
      public long pad_szDevice1;
      public long pad_szDevice2;
      public long pad_szDevice3;
      public long pad_szDevice4;
      public long pad_szDevice5;
      public long pad_szDevice6;
      public long pad_szDevice7;
      public long pad_szDevice8;
      public long pad_szMonitorPnP1;
      public long pad_szMonitorPnP2;
      public long pad_szMonitorPnP3;
      public long pad_szMonitorPnP4;
      public long pad_szMonitorPnP5;
      public long pad_szMonitorPnP6;
      public long pad_szMonitorPnP7;
      public long pad_szMonitorPnP8;
      public long pad_szMonitorPnP9;
      public long pad_szMonitorPnP10;
      public long pad_szMonitorPnP11;
      public long pad_szMonitorPnP12;
      public long pad_szMonitorPnP13;
      public long pad_szMonitorPnP14;
      public long pad_szMonitorPnP15;
      public long pad_szMonitorPnP16;
      public long pad_szMonitorPnP17;
      public long pad_szMonitorPnP18;
      public long pad_szMonitorPnP19;
      public long pad_szMonitorPnP20;
      public long pad_szMonitorPnP21;
      public long pad_szMonitorPnP22;
      public long pad_szMonitorPnP23;
      public long pad_szMonitorPnP24;
      public long pad_szMonitorPnP25;
      public long pad_szMonitorPnP26;
      public long pad_szMonitorPnP27;
      public long pad_szMonitorPnP28;
      public long pad_szMonitorPnP29;
      public long pad_szMonitorPnP30;
      public long pad_szMonitorPnP31;
      public long pad_szMonitorPnP32;
    }
  }
}