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

// Decompiled with JetBrains decompiler
// Type: Microsoft.Iris.Render.Internal.Display
// 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 System;
using System.Collections.Generic;

namespace Microsoft.Iris.Render.Internal
{
  internal class Display : IDisplay
  {
    private string m_stDeviceName;
    private Rectangle m_rcMonitor;
    private Rectangle m_rcWork;
    private bool m_fPrimaryMonitor;
    private DisplayManager m_owner;
    private RenderEngine m_engine;
    private uint m_nDisplayId;
    private TvFormat m_nTvFormat;
    private string m_stMonitorPnP;
    private DisplayMode m_modeDesktop;
    private DisplayMode m_modeCurrent;
    private DisplayModeFlags m_nCurrentValid;
    private DisplayMode[] m_arSupportedModes;
    private DisplayMode[] m_arExtraModes;
    private DisplayMode[] m_arAllModes;

    internal Display(
      DisplayManager owner,
      RenderEngine engine,
      string stDeviceName,
      uint nDisplayID)
    {
      this.m_stDeviceName = stDeviceName;
      this.m_owner = owner;
      this.m_engine = engine;
      this.m_nDisplayId = nDisplayID;
      this.m_arSupportedModes = DisplayMode.EmptyModes;
      this.m_arExtraModes = DisplayMode.EmptyModes;
      this.m_arAllModes = DisplayMode.EmptyModes;
      this.m_modeCurrent = new DisplayMode();
      this.m_nCurrentValid = (DisplayModeFlags) 0;
    }

    public string DeviceName => this.m_stDeviceName;

    public Rectangle ScreenArea => this.m_rcMonitor;

    public Rectangle WorkArea => this.m_rcWork;

    public bool IsPrimary => this.m_fPrimaryMonitor;

    public TvFormat TvFormat => this.m_nTvFormat;

    public bool TvMode => this.m_modeCurrent.fTvMode;

    public Size LogicalFullScreenResolution => this.m_modeCurrent.sizeLogicalPxl.IsZero ? (this.m_modeCurrent.sizePhysicalPxl.IsZero ? this.m_rcMonitor.Size : this.m_modeCurrent.sizePhysicalPxl) : this.m_modeCurrent.sizeLogicalPxl;

    internal uint UniqueId => this.m_nDisplayId;

    public DisplayMode[] SupportedModes => this.m_arSupportedModes;

    public DisplayMode[] ExtraModes => this.m_arExtraModes;

    public DisplayMode[] AllModes => this.m_arAllModes;

    public DisplayMode CurrentMode => this.m_modeCurrent;

    public DisplayMode DesktopMode => this.m_modeDesktop;

    public string MonitorPnP => this.m_stMonitorPnP;

    public bool ValidateDisplayMode(
      DisplayMode modeDesired,
      DisplayModeFlags nCheck,
      bool fAllowAllModes,
      out DisplayMode modeComplete,
      out DisplayModeFlags nCompleteCheck)
    {
      if (fAllowAllModes)
      {
        if (this.m_arAllModes == null || this.m_arAllModes.Length == 0)
        {
          modeComplete = modeDesired;
          nCompleteCheck = nCheck;
          return false;
        }
      }
      else if (this.m_arSupportedModes == null || this.m_arSupportedModes.Length == 0)
      {
        modeComplete = modeDesired;
        nCompleteCheck = nCheck;
        return false;
      }
      this.CompleteDisplayMode(ref modeDesired, ref nCheck);
      modeComplete = this.m_modeCurrent;
      nCompleteCheck = this.m_nCurrentValid;
      DisplayMode[] array = fAllowAllModes ? this.m_arAllModes : this.m_arExtraModes;
      DisplayMode.RenderModeComparer renderModeComparer = new DisplayMode.RenderModeComparer();
      if (Array.BinarySearch<DisplayMode>(array, modeDesired, (IComparer<DisplayMode>) renderModeComparer) >= 0)
      {
        modeComplete = modeDesired;
        nCompleteCheck = DisplayModeFlags.Size | DisplayModeFlags.Format | DisplayModeFlags.RefreshRate;
      }
      else
      {
        modeComplete = this.m_modeDesktop;
        int num = Display.ComputeRank(this.m_modeDesktop, modeDesired, nCheck);
        nCompleteCheck = DisplayModeFlags.Size | DisplayModeFlags.Format | DisplayModeFlags.RefreshRate;
        foreach (DisplayMode arSupportedMode in this.m_arSupportedModes)
        {
          int rank = Display.ComputeRank(arSupportedMode, modeDesired, nCheck);
          if (rank >= num)
          {
            modeComplete = arSupportedMode;
            num = rank;
            nCompleteCheck = DisplayModeFlags.Size | DisplayModeFlags.Format | DisplayModeFlags.RefreshRate;
          }
        }
        if (modeDesired.sizeLogicalPxl.Width > 0 && modeDesired.sizeLogicalPxl.Height > 0)
        {
          modeComplete.sizeLogicalPxl.Width = modeComplete.sizePhysicalPxl.Width;
          modeComplete.sizeLogicalPxl.Height = modeComplete.sizePhysicalPxl.Width * modeDesired.sizeLogicalPxl.Height / modeDesired.sizeLogicalPxl.Width;
        }
        else
          modeComplete.sizeLogicalPxl = modeComplete.sizePhysicalPxl;
      }
      if (Bits.TestFlag((int) nCheck, 8))
      {
        modeComplete.fTvMode = modeDesired.fTvMode;
        nCompleteCheck |= DisplayModeFlags.TvMode;
      }
      return true;
    }

    public bool ChangeFullScreenResolution(DisplayMode modeChanges, DisplayModeFlags nValid)
    {
      bool flag = false;
      Debug2.Validate(modeChanges.sizePhysicalPxl.Width == 0 && modeChanges.sizePhysicalPxl.Height == 0 || modeChanges.sizePhysicalPxl.Width > 0 && modeChanges.sizePhysicalPxl.Height > 0, typeof (ArgumentException), (object) "Must specify physical 0 x 0 or a positive size", (object) typeof (ArgumentOutOfRangeException));
      Debug2.Validate(modeChanges.sizeLogicalPxl.Width == 0 && modeChanges.sizeLogicalPxl.Height == 0 || modeChanges.sizeLogicalPxl.Width > 0 && modeChanges.sizeLogicalPxl.Height > 0, typeof (ArgumentException), (object) "Must specify logical 0 x 0 or a positive size", (object) typeof (ArgumentOutOfRangeException));
      Debug2.Validate(modeChanges.nRefreshRate >= 0 && modeChanges.nRefreshRate < 1000, typeof (ArgumentException), "Must have valid refresh rate");
      DisplayMode modeCurrent = this.m_modeCurrent;
      this.m_modeCurrent.ChangeFrom(modeChanges, nValid);
      this.m_nCurrentValid |= nValid;
      if (this.m_modeCurrent != modeCurrent)
      {
        this.m_owner.RemoteStub.SendChangeFullScreenMode(this.m_nDisplayId, new RenderDisplayMode()
        {
          sizePhysicalPxl = this.m_modeCurrent.sizePhysicalPxl,
          sizeLogicalPxl = this.m_modeCurrent.sizeLogicalPxl,
          nFormat = this.m_modeCurrent.nFormat,
          nRefreshRate = this.m_modeCurrent.nRefreshRate,
          Interlaced = this.m_modeCurrent.fInterlaced
        }, this.m_modeCurrent.fTvMode);
        flag = true;
        this.m_engine.Window.NotifyDisplayReconfigured();
      }
      return flag;
    }

    private static int ComputeRank(
      DisplayMode modeValid,
      DisplayMode modeDesired,
      DisplayModeFlags nCheck)
    {
      int num1 = 0;
      if (Bits.TestFlag((int) nCheck, 2))
      {
        if (modeValid.nFormat == modeDesired.nFormat)
        {
          num1 += 4000;
        }
        else
        {
          int num2 = SurfaceFormatInfo.GetBitsPerPixel(modeValid.nFormat);
          int num3 = SurfaceFormatInfo.GetBitsPerPixel(modeDesired.nFormat);
          if (num2 == 24)
            num2 = 32;
          if (num3 == 24)
            num3 = 32;
          if (num2 == num3)
            num1 += 3500;
        }
      }
      if (Bits.TestFlag((int) nCheck, 1) && !modeValid.sizePhysicalPxl.IsZero)
      {
        Size size = new Size(modeDesired.sizePhysicalPxl.Width - modeValid.sizePhysicalPxl.Width, modeDesired.sizePhysicalPxl.Height - modeValid.sizePhysicalPxl.Height);
        if (modeValid.sizePhysicalPxl.Width < 640 && modeValid.sizePhysicalPxl.Height < 480 || size.Width >= 0 && size.Height >= 0)
        {
          float flValue1 = Math.Abs((float) size.Width / (float) modeValid.sizePhysicalPxl.Width);
          float flValue2 = Math.Abs((float) size.Height / (float) modeValid.sizePhysicalPxl.Height);
          int num2 = 2000 - (int) (1000.0 * (double) Math2.Clamp(flValue1, 0.0f, 1f) + 1000.0 * (double) Math2.Clamp(flValue2, 0.0f, 1f));
          if (num2 < 0)
            num2 = 0;
          num1 += num2;
        }
      }
      if (Bits.TestFlag((int) nCheck, 4) && modeValid.fInterlaced == modeDesired.fInterlaced)
      {
        int num2 = Math.Abs(modeDesired.nRefreshRate - modeValid.nRefreshRate);
        if (num2 >= 15)
          return -1;
        int num3 = 1000 * (15 - num2) / 15;
        num1 += num3;
      }
      return num1;
    }

    private void CompleteDisplayMode(ref DisplayMode modeDesired, ref DisplayModeFlags nCheck)
    {
      if (!Bits.TestFlag((int) nCheck, 1))
      {
        if (Bits.TestFlag((int) this.m_nCurrentValid, 1) && !this.m_modeCurrent.sizePhysicalPxl.IsZero)
        {
          modeDesired.sizePhysicalPxl = this.m_modeCurrent.sizePhysicalPxl;
          modeDesired.sizeLogicalPxl = this.m_modeCurrent.sizeLogicalPxl;
          nCheck |= DisplayModeFlags.Size;
        }
        else
        {
          modeDesired.sizePhysicalPxl.Width = this.m_rcMonitor.Width;
          modeDesired.sizePhysicalPxl.Height = this.m_rcMonitor.Height;
          modeDesired.sizeLogicalPxl.Width = this.m_rcMonitor.Width;
          modeDesired.sizeLogicalPxl.Height = this.m_rcMonitor.Height;
          nCheck |= DisplayModeFlags.Size;
        }
      }
      if (!Bits.TestFlag((int) nCheck, 2) && Bits.TestFlag((int) this.m_nCurrentValid, 2))
      {
        modeDesired.nFormat = this.m_modeCurrent.nFormat;
        nCheck |= DisplayModeFlags.Format;
      }
      if (!Bits.TestFlag((int) nCheck, 4))
      {
        if (Bits.TestFlag((int) this.m_nCurrentValid, 4) && this.m_modeCurrent.nRefreshRate > 0)
        {
          modeDesired.nRefreshRate = this.m_modeCurrent.nRefreshRate;
          modeDesired.fInterlaced = this.m_modeCurrent.fInterlaced;
          nCheck |= DisplayModeFlags.RefreshRate;
        }
        else
        {
          modeDesired.nRefreshRate = 60;
          modeDesired.fInterlaced = false;
          nCheck |= DisplayModeFlags.RefreshRate;
        }
      }
      if (Bits.TestFlag((int) nCheck, 8) || !Bits.TestFlag((int) this.m_nCurrentValid, 8))
        return;
      modeDesired.fTvMode = this.m_modeCurrent.fTvMode;
      nCheck |= DisplayModeFlags.TvMode;
    }

    internal void UpdateMonitorInfo(
      Rectangle rcMonitor,
      Rectangle rcWork,
      bool fPrimary,
      TvFormat nTvFormat,
      string stMonitorPnP,
      DisplayMode modeDesktop)
    {
      this.m_rcMonitor = rcMonitor;
      this.m_rcWork = rcWork;
      this.m_fPrimaryMonitor = fPrimary;
      this.m_nTvFormat = nTvFormat;
      this.m_modeDesktop = modeDesktop;
      this.m_stMonitorPnP = stMonitorPnP;
    }

    internal void UpdateDisplayModes(
      DisplayMode[] arNewSupportedModes,
      DisplayMode[] arNewExtraModes,
      DisplayMode[] arNewAllModes)
    {
      this.m_arSupportedModes = arNewSupportedModes;
      if (this.m_arSupportedModes == null)
        this.m_arSupportedModes = DisplayMode.EmptyModes;
      this.m_arExtraModes = arNewExtraModes;
      if (this.m_arExtraModes == null)
        this.m_arExtraModes = DisplayMode.EmptyModes;
      this.m_arAllModes = arNewAllModes;
      if (this.m_arAllModes != null)
        return;
      this.m_arAllModes = DisplayMode.EmptyModes;
    }
  }
}