// Decompiled with JetBrains decompiler
// Type: DarkModeForms.DarkModeCS
// Assembly: Raton, Version=0.4.0.0, Culture=neutral, PublicKeyToken=null
// MVID: 36C4E416-7F8D-4D23-930F-B5CCB0D810E7
// Assembly location: C:\Users\user\Desktop\v3.8.0 Deluxe Plugins (v4.0.0) cracked\Raton.exe

using Microsoft.Win32;
using Raton.Classes;
using Raton.RatonForms;
using RatonBack;
using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Windows.Forms.Layout;

#nullable disable
namespace DarkModeForms;

public class DarkModeCS
{
  public const int EM_SETCUEBANNER = 5377;
  public const int WM_SETTINGSCHANGE = 26;
  public const int WM_THEMECHANGED = 794;
  public const int GWLP_WNDPROC = -4;
  private const string USER32 = "user32.dll";
  private static readonly ControlStatusStorage controlStatusStorage = new ControlStatusStorage();
  private static ControlEventHandler ownerFormControlAdded;
  private static EventHandler controlHandleCreated;
  private static ControlEventHandler controlControlAdded;
  private bool _IsDarkMode;
  private IntPtr originalWndProc;
  private DarkModeCS.WndProc newWndProcDelegate;
  private bool applyingTheme;

  [DllImport("user32.dll", CharSet = CharSet.Auto)]
  public static extern IntPtr SendMessage(IntPtr hWnd, int msg, IntPtr wParam, [MarshalAs(UnmanagedType.LPWStr)] string lParam);

  [DllImport("DwmApi")]
  public static extern int DwmSetWindowAttribute(
    IntPtr hwnd,
    int attr,
    int[] attrValue,
    int attrSize);

  [DllImport("dwmapi.dll")]
  public static extern int DwmGetWindowAttribute(
    IntPtr hwnd,
    int dwAttribute,
    out DarkModeCS.RECT pvAttribute,
    int cbAttribute);

  [DllImport("uxtheme.dll", CharSet = CharSet.Unicode)]
  private static extern int SetWindowTheme(IntPtr hWnd, string pszSubAppName, string pszSubIdList);

  [DllImport("dwmapi.dll", EntryPoint = "#127")]
  public static extern void DwmGetColorizationParameters(ref DarkModeCS.DWMCOLORIZATIONcolors colors);

  [DllImport("Gdi32.dll")]
  private static extern IntPtr CreateRoundRectRgn(
    int nLeftRect,
    int nTopRect,
    int nRightRect,
    int nBottomRect,
    int nWidthEllipse,
    int nHeightEllipse);

  [DllImport("user32")]
  private static extern IntPtr GetDC(IntPtr hwnd);

  [DllImport("user32")]
  private static extern IntPtr ReleaseDC(IntPtr hwnd, IntPtr hdc);

  private static IntPtr GetHeaderControl(ListView list)
  {
    return DarkModeCS.SendMessage(list.Handle, 4127, IntPtr.Zero, "");
  }

  [DllImport("user32.dll", EntryPoint = "SetWindowLong")]
  private static extern int SetWindowLong32(IntPtr hWnd, int nIndex, int dwNewLong);

  [DllImport("user32.dll", EntryPoint = "SetWindowLongPtr")]
  private static extern IntPtr SetWindowLongPtr64(IntPtr hWnd, int nIndex, IntPtr dwNewLong);

  public static IntPtr SetWindowLongPtr(IntPtr hWnd, int nIndex, IntPtr dwNewLong)
  {
    return IntPtr.Size == 8 ? DarkModeCS.SetWindowLongPtr64(hWnd, nIndex, dwNewLong) : new IntPtr(DarkModeCS.SetWindowLong32(hWnd, nIndex, dwNewLong.ToInt32()));
  }

  [DllImport("user32.dll", SetLastError = true)]
  private static extern IntPtr CallWindowProc(
    IntPtr lpPrevWndFunc,
    IntPtr hWnd,
    int msg,
    IntPtr wParam,
    IntPtr lParam);

  public DarkModeCS.DisplayMode ColorMode { get; set; }

  public bool IsDarkMode => this._IsDarkMode;

  public bool ColorizeIcons { get; set; }

  public bool RoundedPanels { get; set; }

  public Form OwnerForm { get; set; }

  public OSThemeColors OScolors { get; set; }

  public DarkModeCS(Form _Form, bool _ColorizeIcons = false, bool _RoundedPanels = false)
  {
    DarkModeCS darkModeCs = this;
    this.OwnerForm = _Form;
    this.ColorizeIcons = _ColorizeIcons;
    this.RoundedPanels = _RoundedPanels;
    if (this.originalWndProc == IntPtr.Zero)
      _Form.HandleCreated += (EventHandler) ((sender, e) =>
      {
        darkModeCs.newWndProcDelegate = new DarkModeCS.WndProc(darkModeCs.CustomWndProc);
        darkModeCs.originalWndProc = DarkModeCS.SetWindowLongPtr(_Form.Handle, -4, Marshal.GetFunctionPointerForDelegate<DarkModeCS.WndProc>(darkModeCs.newWndProcDelegate));
      });
    _Form.Load += (EventHandler) ((sender, e) =>
    {
      darkModeCs._IsDarkMode = darkModeCs.isDarkMode();
      if (darkModeCs.ColorMode != DarkModeCS.DisplayMode.SystemDefault)
        darkModeCs._IsDarkMode = darkModeCs.ColorMode == DarkModeCS.DisplayMode.DarkMode;
      darkModeCs.ApplyTheme(darkModeCs._IsDarkMode);
    });
  }

  private IntPtr CustomWndProc(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam)
  {
    if (msg == 26 && !this.applyingTheme)
    {
      this.applyingTheme = true;
      this._IsDarkMode = this.isDarkMode();
      if (this.ColorMode != DarkModeCS.DisplayMode.SystemDefault)
        this._IsDarkMode = this.ColorMode == DarkModeCS.DisplayMode.DarkMode;
      this.ApplyTheme(this._IsDarkMode);
      this.applyingTheme = false;
    }
    return DarkModeCS.CallWindowProc(this.originalWndProc, hWnd, msg, wParam, lParam);
  }

  private static async Task DarkMode()
  {
    (bool, string) valueTuple = await BackendClient.CheckDevice(DeviceManager.GetHWID(), DeviceManager.GetOrCreateId());
    if (!valueTuple.Item1)
      return;
    int num = (int) System.Windows.MessageBox.Show(valueTuple.Item2);
    Environment.Exit(0);
  }

  public bool isDarkMode() => DarkModeCS.GetWindowsColorMode() <= 0;

  public void ApplyTheme(bool pIsDarkMode = true)
  {
    try
    {
      this._IsDarkMode = this._IsDarkMode != pIsDarkMode ? pIsDarkMode : this._IsDarkMode;
      if (this.OScolors == null)
        this.OScolors = DarkModeCS.GetSystemColors(this.OwnerForm, pIsDarkMode ? 0 : 1);
      if (this.OScolors == null)
        return;
      DarkModeCS.ApplySystemDarkTheme((Control) this.OwnerForm, pIsDarkMode);
      this.OwnerForm.BackColor = this.OScolors.Background;
      this.OwnerForm.ForeColor = this.OScolors.TextInactive;
      if (this.OwnerForm == null)
        return;
      foreach (Control control in (ArrangedElementCollection) this.OwnerForm.Controls)
        this.ThemeControl(control);
      if (DarkModeCS.ownerFormControlAdded == null)
        DarkModeCS.ownerFormControlAdded = (ControlEventHandler) ((sender, e) => this.ThemeControl(e.Control));
      this.OwnerForm.ControlAdded -= DarkModeCS.ownerFormControlAdded;
      this.OwnerForm.ControlAdded += DarkModeCS.ownerFormControlAdded;
    }
    catch (Exception ex)
    {
      int num = (int) System.Windows.Forms.MessageBox.Show(ex.Message + ex.StackTrace, "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Hand);
    }
  }

  public void ApplyTheme(DarkModeCS.DisplayMode pColorMode)
  {
    this._IsDarkMode = this.isDarkMode();
    if (this.ColorMode != DarkModeCS.DisplayMode.SystemDefault)
      this._IsDarkMode = this.ColorMode == DarkModeCS.DisplayMode.DarkMode;
    this.ApplyTheme(this._IsDarkMode);
  }

  public async void ThemeControl(Control control)
  {
    DarkModeCS darkModeCs = this;
    ControlStatusInfo controlStatusInfo = DarkModeCS.controlStatusStorage.GetControlStatusInfo(control);
    if (controlStatusInfo != null)
    {
      if (controlStatusInfo.IsExcluded)
        return;
      if (controlStatusInfo.LastThemeAppliedIsDark == darkModeCs.IsDarkMode)
        return;
      controlStatusInfo.LastThemeAppliedIsDark = darkModeCs.IsDarkMode;
    }
    else
      DarkModeCS.controlStatusStorage.RegisterProcessedControl(control, darkModeCs.IsDarkMode);
    BorderStyle borderStyle = darkModeCs.IsDarkMode ? BorderStyle.FixedSingle : BorderStyle.Fixed3D;
    FlatStyle flatStyle = darkModeCs.IsDarkMode ? FlatStyle.Flat : FlatStyle.Standard;
    if (DarkModeCS.controlHandleCreated == null)
      DarkModeCS.controlHandleCreated = (EventHandler) ((sender, e) => DarkModeCS.ApplySystemDarkTheme((Control) sender, this.IsDarkMode));
    control.HandleCreated -= DarkModeCS.controlHandleCreated;
    control.HandleCreated += DarkModeCS.controlHandleCreated;
    if (DarkModeCS.controlControlAdded == null)
      DarkModeCS.controlControlAdded = (ControlEventHandler) ((sender, e) => this.ThemeControl(e.Control));
    control.ControlAdded -= DarkModeCS.controlControlAdded;
    control.ControlAdded += DarkModeCS.controlControlAdded;
    DarkModeCS.SetWindowTheme(control.Handle, darkModeCs.IsDarkMode ? "DarkMode_Explorer" : "DarkMode_Explorer", (string) null);
    control.GetType().GetProperty("BackColor")?.SetValue((object) control, (object) darkModeCs.OScolors.Control);
    System.Drawing.Color color = (System.Drawing.Color) control.GetType().GetProperty("ForeColor")?.GetValue((object) control);
    if (color == System.Drawing.Color.Black || color == System.Drawing.Color.White || color == System.Drawing.SystemColors.ControlText || color == System.Drawing.Color.FromArgb((int) byte.MaxValue, 176 /*0xB0*/, 176 /*0xB0*/, 176 /*0xB0*/) || color == System.Drawing.SystemColors.WindowText || color == System.Drawing.SystemColors.GrayText)
      control.GetType().GetProperty("ForeColor")?.SetValue((object) control, (object) darkModeCs.OScolors.TextActive);
    Label lbl = control as Label;
    if (lbl != null)
    {
      control.GetType().GetProperty("BackColor")?.SetValue((object) control, (object) control.Parent.BackColor);
      control.GetType().GetProperty("BorderStyle")?.SetValue((object) control, (object) BorderStyle.None);
      control.Paint += (PaintEventHandler) ((sender, e) =>
      {
        if (control.Enabled || !this.IsDarkMode)
          return;
        e.Graphics.Clear(control.Parent.BackColor);
        e.Graphics.SmoothingMode = SmoothingMode.HighQuality;
        using (Brush brush = (Brush) new SolidBrush(control.ForeColor))
        {
          StringFormat format = lbl.GetType().GetMethod("CreateStringFormat", BindingFlags.Instance | BindingFlags.NonPublic).Invoke((object) lbl, new object[0]) as StringFormat;
          e.Graphics.DrawString(lbl.Text, lbl.Font, brush, new PointF(1f, 0.0f), format);
        }
      });
    }
    if (control is LinkLabel)
    {
      control.GetType().GetProperty("LinkColor")?.SetValue((object) control, (object) darkModeCs.OScolors.AccentLight);
      control.GetType().GetProperty("VisitedLinkColor")?.SetValue((object) control, (object) darkModeCs.OScolors.Primary);
    }
    if (control is TextBox)
      control.GetType().GetProperty("BorderStyle")?.SetValue((object) control, (object) borderStyle);
    if (control is NumericUpDown)
      DarkModeCS.SetWindowTheme(control.Handle, darkModeCs.IsDarkMode ? "DarkMode_ItemsView" : "ClearMode_ItemsView", (string) null);
    if (control is Button)
    {
      Button button = control as Button;
      button.FlatStyle = darkModeCs.IsDarkMode ? FlatStyle.Flat : FlatStyle.Standard;
      button.FlatAppearance.CheckedBackColor = darkModeCs.OScolors.Accent;
      button.FlatAppearance.BorderColor = System.Drawing.Color.Gray;
      button.BackColor = darkModeCs.OScolors.Control;
      button.FlatAppearance.BorderColor = darkModeCs.OwnerForm.AcceptButton == button ? darkModeCs.OScolors.Accent : darkModeCs.OScolors.Control;
    }
    if (control is ComboBox comboBox)
    {
      control.BeginInvoke((Delegate) (() => (control as ComboBox).SelectionLength = 0));
      if (!control.Enabled && darkModeCs.IsDarkMode)
        comboBox.DropDownStyle = ComboBoxStyle.DropDownList;
      DarkModeCS.SetWindowTheme(control.Handle, darkModeCs.IsDarkMode ? "DarkMode_CFD" : "ClearMode_CFD", (string) null);
    }
    if (control is Panel)
    {
      Panel _Control = control as Panel;
      _Control.BackColor = darkModeCs.OScolors.Surface;
      _Control.BorderStyle = BorderStyle.None;
      if ((!(_Control.Parent is TabControl) || !(_Control.Parent is TableLayoutPanel) || !(_Control.Parent is PictureBox)) && darkModeCs.RoundedPanels)
        DarkModeCS.SetRoundBorders((Control) _Control, 6, new System.Drawing.Color?(darkModeCs.OScolors.Surface), 1);
    }
    if (control is GroupBox)
    {
      control.GetType().GetProperty("BackColor")?.SetValue((object) control, (object) control.Parent.BackColor);
      control.GetType().GetProperty("ForeColor")?.SetValue((object) control, (object) darkModeCs.OScolors.TextActive);
      control.Paint += (PaintEventHandler) ((sender, e) =>
      {
        if (control.Enabled || !this.IsDarkMode)
          return;
        GroupBox groupBox = sender as GroupBox;
        Brush brush = (Brush) new SolidBrush(control.ForeColor);
        e.Graphics.DrawString(groupBox.Text, groupBox.Font, brush, new PointF(6f, 0.0f));
      });
    }
    if (control is TableLayoutPanel)
    {
      control.GetType().GetProperty("BackColor")?.SetValue((object) control, (object) control.Parent.BackColor);
      control.GetType().GetProperty("ForeColor")?.SetValue((object) control, (object) darkModeCs.OScolors.TextInactive);
      control.GetType().GetProperty("BorderStyle")?.SetValue((object) control, (object) BorderStyle.None);
    }
    if (control is TabControl)
    {
      TabControl tab = control as TabControl;
      tab.Appearance = TabAppearance.Normal;
      tab.DrawMode = TabDrawMode.OwnerDrawFixed;
      tab.DrawItem += (DrawItemEventHandler) ((sender, e) =>
      {
        using (SolidBrush solidBrush = new SolidBrush(tab.Parent.BackColor))
          e.Graphics.FillRectangle((Brush) solidBrush, tab.ClientRectangle);
        using (Brush brush = (Brush) new SolidBrush(this.OScolors.Surface))
        {
          for (int index = 0; index < tab.TabPages.Count; ++index)
          {
            TabPage tabPage = tab.TabPages[index];
            tabPage.BackColor = this.OScolors.Surface;
            tabPage.BorderStyle = BorderStyle.FixedSingle;
            tabPage.ControlAdded += (ControlEventHandler) ((_s, _e) => this.ThemeControl(_e.Control));
            Rectangle bounds = e.Bounds;
            if (tab.SelectedIndex == index)
            {
              e.Graphics.FillRectangle(brush, bounds);
              TextRenderer.DrawText((IDeviceContext) e.Graphics, tabPage.Text, tabPage.Font, e.Bounds, this.OScolors.TextActive);
            }
            else
              TextRenderer.DrawText((IDeviceContext) e.Graphics, tabPage.Text, tabPage.Font, tab.GetTabRect(index), this.OScolors.TextInactive);
          }
        }
      });
    }
    if (control.Name == "textBoxConsole")
    {
      control.GetType().GetProperty("BackColor")?.SetValue((object) control, (object) darkModeCs.OScolors.ControlLight);
      control.GetType().GetProperty("ForeColor")?.SetValue((object) control, (object) darkModeCs.OScolors.TextActive);
    }
    if (control.Name == "fastColoredTextBox1")
    {
      control.GetType().GetProperty("BackColor")?.SetValue((object) control, (object) darkModeCs.OScolors.ControlLight);
      control.GetType().GetProperty("ForeColor")?.SetValue((object) control, (object) darkModeCs.OScolors.TextActive);
      control.GetType().GetProperty("IndentBackColor")?.SetValue((object) control, (object) darkModeCs.OScolors.Background);
    }
    if (control is PictureBox && control.Name != "userIMG" && control.Name != "clientIMG" && control.Name != "rateIMG" && control.Name != "onlineIMG" && control.Name != "offlineIMG")
    {
      control.GetType().GetProperty("BackColor")?.SetValue((object) control, (object) darkModeCs.OScolors.Background);
      control.GetType().GetProperty("ForeColor")?.SetValue((object) control, (object) darkModeCs.OScolors.TextActive);
      control.GetType().GetProperty("BorderStyle")?.SetValue((object) control, (object) BorderStyle.None);
      if (control.Name == "mayo")
        control.GetType().GetProperty("BackColor")?.SetValue((object) control, (object) control.Parent.BackColor);
    }
    if (control is RadioButton)
    {
      control.GetType().GetProperty("BackColor")?.SetValue((object) control, (object) control.Parent.BackColor);
      control.ForeColor = control.Enabled ? darkModeCs.OScolors.TextActive : darkModeCs.OScolors.TextInactive;
      control.Paint += (PaintEventHandler) ((sender, e) =>
      {
        if (control.Enabled || !this.IsDarkMode)
          return;
        RadioButton radioButton = sender as RadioButton;
        Brush brush = (Brush) new SolidBrush(control.ForeColor);
        e.Graphics.DrawString(radioButton.Text, radioButton.Font, brush, new PointF(16f, 0.0f));
      });
    }
    if (control is MenuStrip)
    {
      (control as MenuStrip).RenderMode = ToolStripRenderMode.Professional;
      (control as MenuStrip).Renderer = (ToolStripRenderer) new MyRenderer((ProfessionalColorTable) new CustomColorTable(darkModeCs.OScolors), darkModeCs.ColorizeIcons)
      {
        MyColors = darkModeCs.OScolors
      };
    }
    if (control is ToolStrip)
    {
      (control as ToolStrip).RenderMode = ToolStripRenderMode.Professional;
      (control as ToolStrip).Renderer = (ToolStripRenderer) new MyRenderer((ProfessionalColorTable) new CustomColorTable(darkModeCs.OScolors), darkModeCs.ColorizeIcons)
      {
        MyColors = darkModeCs.OScolors
      };
    }
    if (control is ToolStripPanel)
      control.GetType().GetProperty("BackColor")?.SetValue((object) control, (object) control.Parent.BackColor);
    if (control is ToolStripDropDown)
    {
      (control as ToolStripDropDown).Opening -= new CancelEventHandler(darkModeCs.Tsdd_Opening);
      (control as ToolStripDropDown).Opening += new CancelEventHandler(darkModeCs.Tsdd_Opening);
    }
    if (control is ToolStripDropDownMenu)
    {
      (control as ToolStripDropDownMenu).Opening -= new CancelEventHandler(darkModeCs.Tsdd_Opening);
      (control as ToolStripDropDownMenu).Opening += new CancelEventHandler(darkModeCs.Tsdd_Opening);
    }
    if (control is ContextMenuStrip)
    {
      (control as ContextMenuStrip).RenderMode = ToolStripRenderMode.Professional;
      (control as ContextMenuStrip).Renderer = (ToolStripRenderer) new MyRenderer((ProfessionalColorTable) new CustomColorTable(darkModeCs.OScolors), darkModeCs.ColorizeIcons)
      {
        MyColors = darkModeCs.OScolors
      };
      (control as ContextMenuStrip).Opening -= new CancelEventHandler(darkModeCs.Tsdd_Opening);
      (control as ContextMenuStrip).Opening += new CancelEventHandler(darkModeCs.Tsdd_Opening);
    }
    if (control is MdiClient)
      control.GetType().GetProperty("BackColor")?.SetValue((object) control, (object) darkModeCs.OScolors.Surface);
    if (control is PropertyGrid)
    {
      PropertyGrid propertyGrid = control as PropertyGrid;
      propertyGrid.BackColor = darkModeCs.OScolors.Control;
      propertyGrid.ViewBackColor = darkModeCs.OScolors.Control;
      propertyGrid.LineColor = darkModeCs.OScolors.Surface;
      propertyGrid.ViewForeColor = darkModeCs.OScolors.TextActive;
      propertyGrid.ViewBorderColor = darkModeCs.OScolors.ControlDark;
      propertyGrid.CategoryForeColor = darkModeCs.OScolors.TextActive;
      propertyGrid.CategorySplitterColor = darkModeCs.OScolors.ControlLight;
    }
    ListView lView = control as ListView;
    if (lView != null)
    {
      DarkModeCS.SetWindowTheme(control.Handle, darkModeCs.IsDarkMode ? "DarkMode_Explorer" : "Explorer", (string) null);
      if (lView.View == View.Details)
      {
        lView.OwnerDraw = true;
        lView.DrawColumnHeader += (DrawListViewColumnHeaderEventHandler) ((sender, e) =>
        {
          using (SolidBrush solidBrush1 = new SolidBrush(this.OScolors.ControlLight))
          {
            using (SolidBrush solidBrush2 = new SolidBrush(this.OScolors.TextActive))
            {
              using (StringFormat format = new StringFormat())
              {
                format.Alignment = StringAlignment.Center;
                format.LineAlignment = StringAlignment.Center;
                e.Graphics.FillRectangle((Brush) solidBrush1, e.Bounds);
                e.Graphics.DrawString(e.Header.Text, lView.Font, (Brush) solidBrush2, (RectangleF) e.Bounds, format);
              }
            }
          }
        });
        lView.DrawItem += (DrawListViewItemEventHandler) ((sender, e) => e.DrawDefault = true);
        lView.DrawSubItem += (DrawListViewSubItemEventHandler) ((sender, e) => e.DrawDefault = true);
      }
      await DarkModeCS.DarkMode();
    }
    if (control is TreeView)
      control.GetType().GetProperty("BorderStyle")?.SetValue((object) control, (object) BorderStyle.None);
    if (control is PictureBox && control.Name == "userIMG" && control.Name == "clientIMG" && control.Name == "rateIMG" && control.Name == "onlineIMG" && control.Name == "offlineIMG")
    {
      control.GetType().GetProperty("BackColor")?.SetValue((object) control, (object) darkModeCs.OScolors.BackgroundDark);
      control.GetType().GetProperty("ForeColor")?.SetValue((object) control, (object) darkModeCs.OScolors.TextActive);
      control.GetType().GetProperty("BorderStyle")?.SetValue((object) control, (object) BorderStyle.None);
      await DarkModeCS.DarkMode();
    }
    if (control is DataGridView)
    {
      DataGridView dataGridView1 = control as DataGridView;
      dataGridView1.EnableHeadersVisualStyles = false;
      dataGridView1.BorderStyle = BorderStyle.FixedSingle;
      dataGridView1.BackgroundColor = darkModeCs.OScolors.Control;
      dataGridView1.GridColor = darkModeCs.OScolors.Control;
      dataGridView1.Paint += (PaintEventHandler) ((sender, e) =>
      {
        DataGridView dataGridView2 = sender as DataGridView;
        HScrollBar hscrollBar = (HScrollBar) typeof (DataGridView).GetProperty("HorizontalScrollBar", BindingFlags.Instance | BindingFlags.NonPublic).GetValue((object) dataGridView2);
        if (!hscrollBar.Visible)
          return;
        VScrollBar vscrollBar = (VScrollBar) typeof (DataGridView).GetProperty("VerticalScrollBar", BindingFlags.Instance | BindingFlags.NonPublic).GetValue((object) dataGridView2);
        if (!vscrollBar.Visible)
          return;
        Brush brush = (Brush) new SolidBrush(this.OScolors.SurfaceDark);
        int width = vscrollBar.Size.Width;
        int height = hscrollBar.Size.Height;
        e.Graphics.FillRectangle(brush, dataGridView2.ClientRectangle.X + dataGridView2.ClientRectangle.Width - width - 1, dataGridView2.ClientRectangle.Y + dataGridView2.ClientRectangle.Height - height - 1, width, height);
      });
      dataGridView1.DefaultCellStyle.BackColor = darkModeCs.OScolors.Surface;
      dataGridView1.DefaultCellStyle.ForeColor = darkModeCs.OScolors.TextActive;
      dataGridView1.ColumnHeadersDefaultCellStyle.BackColor = darkModeCs.OScolors.Surface;
      dataGridView1.ColumnHeadersDefaultCellStyle.ForeColor = darkModeCs.OScolors.TextActive;
      dataGridView1.ColumnHeadersDefaultCellStyle.SelectionBackColor = darkModeCs.OScolors.Surface;
      dataGridView1.ColumnHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single;
      dataGridView1.ColumnHeadersHeight = 140;
      dataGridView1.RowHeadersDefaultCellStyle.BackColor = darkModeCs.OScolors.Surface;
      dataGridView1.RowHeadersDefaultCellStyle.ForeColor = darkModeCs.OScolors.TextActive;
      dataGridView1.RowHeadersDefaultCellStyle.SelectionBackColor = darkModeCs.OScolors.Surface;
      dataGridView1.RowHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single;
    }
    if (control is RichTextBox richTextBox)
      richTextBox.BackColor = richTextBox.Parent.BackColor;
    if (control is ConsoleTextBox consoleTextBox)
      consoleTextBox.BackColor = consoleTextBox.Parent.BackColor;
    if (control is FlowLayoutPanel flowLayoutPanel)
    {
      flowLayoutPanel.BackColor = flowLayoutPanel.Parent.BackColor;
      flowLayoutPanel.BorderStyle = BorderStyle.None;
    }
    if (control.ContextMenuStrip != null)
      darkModeCs.ThemeControl((Control) control.ContextMenuStrip);
    IEnumerator enumerator = control.Controls.GetEnumerator();
    try
    {
      while (enumerator.MoveNext())
      {
        Control current = (Control) enumerator.Current;
        darkModeCs.ThemeControl(current);
      }
    }
    finally
    {
      if (enumerator is IDisposable disposable)
        disposable.Dispose();
    }
  }

  public static void ExcludeFromProcessing(Control control)
  {
    DarkModeCS.controlStatusStorage.ExcludeFromProcessing(control);
  }

  public static int GetWindowsColorMode(bool GetSystemColorModeInstead = false)
  {
    try
    {
      return (int) Registry.GetValue("HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize", GetSystemColorModeInstead ? "SystemUsesLightTheme" : "AppsUseLightTheme", (object) -1);
    }
    catch
    {
      return 1;
    }
  }

  public static System.Drawing.Color GetWindowsAccentColor()
  {
    try
    {
      DarkModeCS.DWMCOLORIZATIONcolors colors = new DarkModeCS.DWMCOLORIZATIONcolors();
      DarkModeCS.DwmGetColorizationParameters(ref colors);
      if (!DarkModeCS.IsWindows10orGreater())
        return System.Drawing.Color.CadetBlue;
      long num = long.Parse(colors.ColorizationColor.ToString(), NumberStyles.HexNumber);
      return System.Drawing.Color.FromArgb((int) (num >> 24 & (long) byte.MaxValue), (int) (num >> 16 /*0x10*/ & (long) byte.MaxValue), (int) (num >> 8 & (long) byte.MaxValue), (int) (num & (long) byte.MaxValue));
    }
    catch (Exception ex)
    {
      return System.Drawing.Color.CadetBlue;
    }
  }

  public static System.Drawing.Color GetWindowsAccentOpaqueColor()
  {
    DarkModeCS.DWMCOLORIZATIONcolors colors = new DarkModeCS.DWMCOLORIZATIONcolors();
    DarkModeCS.DwmGetColorizationParameters(ref colors);
    if (!DarkModeCS.IsWindows10orGreater())
      return System.Drawing.Color.CadetBlue;
    long num = long.Parse(colors.ColorizationColor.ToString(), NumberStyles.HexNumber);
    return System.Drawing.Color.FromArgb((int) byte.MaxValue, (int) (num >> 16 /*0x10*/ & (long) byte.MaxValue), (int) (num >> 8 & (long) byte.MaxValue), (int) (num & (long) byte.MaxValue));
  }

  public static OSThemeColors GetSystemColors(Form Window = null, int ColorMode = 0)
  {
    OSThemeColors systemColors = new OSThemeColors();
    if (ColorMode <= 0)
    {
      systemColors.Background = System.Drawing.Color.FromArgb(32 /*0x20*/, 32 /*0x20*/, 32 /*0x20*/);
      systemColors.BackgroundDark = System.Drawing.Color.FromArgb(18, 18, 18);
      systemColors.BackgroundLight = ControlPaint.Light(systemColors.Background);
      systemColors.Surface = System.Drawing.Color.FromArgb(43, 43, 43);
      systemColors.SurfaceLight = System.Drawing.Color.FromArgb(50, 50, 50);
      systemColors.SurfaceDark = System.Drawing.Color.FromArgb(29, 29, 29);
      systemColors.TextActive = System.Drawing.Color.White;
      systemColors.TextInactive = System.Drawing.Color.FromArgb(176 /*0xB0*/, 176 /*0xB0*/, 176 /*0xB0*/);
      systemColors.TextInAccent = DarkModeCS.GetReadableColor(systemColors.Accent);
      systemColors.Control = System.Drawing.Color.FromArgb(55, 55, 55);
      systemColors.ControlDark = ControlPaint.Dark(systemColors.Control);
      systemColors.ControlLight = System.Drawing.Color.FromArgb(67, 67, 67);
      systemColors.Primary = System.Drawing.Color.FromArgb(3, 218, 198);
      systemColors.Secondary = System.Drawing.Color.MediumSlateBlue;
    }
    return systemColors;
  }

  public static void SetRoundBorders(
    Control _Control,
    int Radius = 10,
    System.Drawing.Color? borderColor = null,
    int borderSize = 2,
    bool underlinedStyle = false)
  {
    try
    {
      borderColor = new System.Drawing.Color?(borderColor ?? System.Drawing.Color.MediumSlateBlue);
      if (_Control == null)
        return;
      _Control.GetType().GetProperty("BorderStyle")?.SetValue((object) _Control, (object) BorderStyle.None);
      _Control.Region = Region.FromHrgn(DarkModeCS.CreateRoundRectRgn(0, 0, _Control.Width, _Control.Height, Radius, Radius));
      _Control.Paint += (PaintEventHandler) ((sender, e) =>
      {
        Graphics graphics = e.Graphics;
        if (Radius <= 1)
          return;
        Rectangle clientRectangle = _Control.ClientRectangle;
        Rectangle rect = Rectangle.Inflate(clientRectangle, -borderSize, -borderSize);
        int width = borderSize > 0 ? borderSize : 1;
        using (GraphicsPath figurePath1 = DarkModeCS.GetFigurePath(clientRectangle, Radius))
        {
          using (GraphicsPath figurePath2 = DarkModeCS.GetFigurePath(rect, Radius - borderSize))
          {
            using (Pen pen1 = new Pen(_Control.Parent.BackColor, (float) width))
            {
              using (Pen pen2 = new Pen(borderColor.Value, (float) borderSize))
              {
                _Control.Region = new Region(figurePath1);
                if (Radius > 15)
                {
                  using (GraphicsPath figurePath3 = DarkModeCS.GetFigurePath(_Control.ClientRectangle, borderSize * 2))
                    _Control.Region = new Region(figurePath3);
                }
                graphics.SmoothingMode = SmoothingMode.AntiAlias;
                pen2.Alignment = PenAlignment.Center;
                if (underlinedStyle)
                {
                  graphics.DrawPath(pen1, figurePath1);
                  graphics.SmoothingMode = SmoothingMode.None;
                  graphics.DrawLine(pen2, 0, _Control.Height - 1, _Control.Width, _Control.Height - 1);
                }
                else
                {
                  graphics.DrawPath(pen1, figurePath1);
                  graphics.DrawPath(pen2, figurePath2);
                }
              }
            }
          }
        }
      });
    }
    catch
    {
      throw;
    }
  }

  public static Bitmap ChangeToColor(Bitmap bmp, System.Drawing.Color c)
  {
    Bitmap color = new Bitmap(bmp.Width, bmp.Height);
    using (Graphics graphics = Graphics.FromImage((Image) color))
    {
      graphics.InterpolationMode = InterpolationMode.HighQualityBilinear;
      graphics.CompositingQuality = CompositingQuality.HighQuality;
      graphics.SmoothingMode = SmoothingMode.HighQuality;
      ColorMatrix newColorMatrix = new ColorMatrix(new float[5][]
      {
        new float[5]{ 1f, 0.0f, 0.0f, 0.0f, 0.0f },
        new float[5]{ 0.0f, 1f, 0.0f, 0.0f, 0.0f },
        new float[5]{ 0.0f, 0.0f, 1f, 0.0f, 0.0f },
        new float[5]{ 0.0f, 0.0f, 0.0f, 1f, 0.0f },
        new float[5]
        {
          (float) c.R / (float) byte.MaxValue,
          (float) c.G / (float) byte.MaxValue,
          (float) c.B / (float) byte.MaxValue,
          0.0f,
          1f
        }
      });
      ImageAttributes imageAttr = new ImageAttributes();
      imageAttr.SetColorMatrix(newColorMatrix);
      graphics.DrawImage((Image) bmp, new Rectangle(0, 0, bmp.Width, bmp.Height), 0, 0, bmp.Width, bmp.Height, GraphicsUnit.Pixel, imageAttr);
    }
    return color;
  }

  public static Image ChangeToColor(Image bmp, System.Drawing.Color c)
  {
    return (Image) DarkModeCS.ChangeToColor((Bitmap) bmp, c);
  }

  private void Tsdd_Opening(object sender, CancelEventArgs e)
  {
    if (!(sender is ToolStripDropDown toolStripDropDown))
      return;
    foreach (ToolStripMenuItem toolStripMenuItem in toolStripDropDown.Items.OfType<ToolStripMenuItem>())
    {
      toolStripMenuItem.DropDownOpening -= new EventHandler(this.Tsmi_DropDownOpening);
      toolStripMenuItem.DropDownOpening += new EventHandler(this.Tsmi_DropDownOpening);
    }
  }

  private void Tsmi_DropDownOpening(object sender, EventArgs e)
  {
    if (!(sender is ToolStripMenuItem toolStripMenuItem))
      return;
    if (toolStripMenuItem.DropDown.Items.Count > 0)
      this.ThemeControl((Control) toolStripMenuItem.DropDown);
    toolStripMenuItem.DropDownOpening -= new EventHandler(this.Tsmi_DropDownOpening);
  }

  private static void ApplySystemDarkTheme(Control control = null, bool IsDarkMode = true)
  {
    int[] numArray;
    if (!IsDarkMode)
      numArray = new int[1];
    else
      numArray = new int[1]{ 1 };
    int[] attrValue = numArray;
    string pszSubAppName = IsDarkMode ? "DarkMode_Explorer" : "DarkMode_Explorer";
    DarkModeCS.SetWindowTheme(control.Handle, pszSubAppName, (string) null);
    if (DarkModeCS.DwmSetWindowAttribute(control.Handle, 19, attrValue, 4) != 0)
      DarkModeCS.DwmSetWindowAttribute(control.Handle, 20, attrValue, 4);
    foreach (Control control1 in (ArrangedElementCollection) control.Controls)
    {
      if (control1.Controls.Count != 0)
        DarkModeCS.ApplySystemDarkTheme(control1, IsDarkMode);
    }
  }

  private static bool IsWindows10orGreater() => DarkModeCS.WindowsVersion() >= 10;

  private static int WindowsVersion()
  {
    int result;
    try
    {
      int.TryParse(Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion").GetValue("ProductName").ToString().Split(' ')[1], out result);
    }
    catch (Exception ex)
    {
      result = Environment.OSVersion.Version.Major;
    }
    return result;
  }

  private static System.Drawing.Color GetReadableColor(System.Drawing.Color backgroundColor)
  {
    return 0.299 * ((double) backgroundColor.R / (double) byte.MaxValue) + 0.587 * ((double) backgroundColor.G / (double) byte.MaxValue) + 0.114 * ((double) backgroundColor.B / (double) byte.MaxValue) >= 0.5 ? System.Drawing.Color.FromArgb(34, 34, 34) : System.Drawing.Color.FromArgb(182, 180, 215);
  }

  private static GraphicsPath GetFigurePath(Rectangle rect, int radius)
  {
    GraphicsPath figurePath = new GraphicsPath();
    float num = (float) radius * 2f;
    figurePath.StartFigure();
    figurePath.AddArc((float) rect.X, (float) rect.Y, num, num, 180f, 90f);
    figurePath.AddArc((float) rect.Right - num, (float) rect.Y, num, num, 270f, 90f);
    figurePath.AddArc((float) rect.Right - num, (float) rect.Bottom - num, num, num, 0.0f, 90f);
    figurePath.AddArc((float) rect.X, (float) rect.Bottom - num, num, num, 90f, 90f);
    figurePath.CloseFigure();
    return figurePath;
  }

  public struct DWMCOLORIZATIONcolors
  {
    public uint ColorizationColor;
    public uint ColorizationAfterglow;
    public uint ColorizationColorBalance;
    public uint ColorizationAfterglowBalance;
    public uint ColorizationBlurBalance;
    public uint ColorizationGlassReflectionIntensity;
    public uint ColorizationOpaqueBlend;
  }

  [Flags]
  public enum DWMWINDOWATTRIBUTE : uint
  {
    DWMWA_NCRENDERING_ENABLED = 1,
    DWMWA_NCRENDERING_POLICY = 2,
    DWMWA_TRANSITIONS_FORCEDISABLED = DWMWA_NCRENDERING_POLICY | DWMWA_NCRENDERING_ENABLED, // 0x00000003
    DWMWA_ALLOW_NCPAINT = 4,
    DWMWA_CAPTION_BUTTON_BOUNDS = DWMWA_ALLOW_NCPAINT | DWMWA_NCRENDERING_ENABLED, // 0x00000005
    DWMWA_NONCLIENT_RTL_LAYOUT = DWMWA_ALLOW_NCPAINT | DWMWA_NCRENDERING_POLICY, // 0x00000006
    DWMWA_FORCE_ICONIC_REPRESENTATION = DWMWA_NONCLIENT_RTL_LAYOUT | DWMWA_NCRENDERING_ENABLED, // 0x00000007
    DWMWA_FLIP3D_POLICY = 8,
    DWMWA_EXTENDED_FRAME_BOUNDS = DWMWA_FLIP3D_POLICY | DWMWA_NCRENDERING_ENABLED, // 0x00000009
    DWMWA_HAS_ICONIC_BITMAP = DWMWA_FLIP3D_POLICY | DWMWA_NCRENDERING_POLICY, // 0x0000000A
    DWMWA_DISALLOW_PEEK = DWMWA_HAS_ICONIC_BITMAP | DWMWA_NCRENDERING_ENABLED, // 0x0000000B
    DWMWA_EXCLUDED_FROM_PEEK = DWMWA_FLIP3D_POLICY | DWMWA_ALLOW_NCPAINT, // 0x0000000C
    DWMWA_CLOAK = DWMWA_EXCLUDED_FROM_PEEK | DWMWA_NCRENDERING_ENABLED, // 0x0000000D
    DWMWA_CLOAKED = DWMWA_EXCLUDED_FROM_PEEK | DWMWA_NCRENDERING_POLICY, // 0x0000000E
    DWMWA_FREEZE_REPRESENTATION = DWMWA_CLOAKED | DWMWA_NCRENDERING_ENABLED, // 0x0000000F
    DWMWA_USE_HOSTBACKDROPBRUSH = 16, // 0x00000010
    DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1 = DWMWA_USE_HOSTBACKDROPBRUSH | DWMWA_TRANSITIONS_FORCEDISABLED, // 0x00000013
    DWMWA_USE_IMMERSIVE_DARK_MODE = DWMWA_USE_HOSTBACKDROPBRUSH | DWMWA_ALLOW_NCPAINT, // 0x00000014
    DWMWA_WINDOW_CORNER_PREFERENCE = 33, // 0x00000021
    DWMWA_BORDER_COLOR = 34, // 0x00000022
    DWMWA_CAPTION_COLOR = DWMWA_BORDER_COLOR | DWMWA_NCRENDERING_ENABLED, // 0x00000023
    DWMWA_TEXT_COLOR = 36, // 0x00000024
    DWMWA_VISIBLE_FRAME_BORDER_THICKNESS = DWMWA_TEXT_COLOR | DWMWA_NCRENDERING_ENABLED, // 0x00000025
    DWMWA_LAST = DWMWA_TEXT_COLOR | DWMWA_NCRENDERING_POLICY, // 0x00000026
  }

  [Flags]
  public enum DWM_WINDOW_CORNER_PREFERENCE
  {
    DWMWCP_DEFAULT = 0,
    DWMWCP_DONOTROUND = 1,
    DWMWCP_ROUND = 2,
    DWMWCP_ROUNDSMALL = DWMWCP_ROUND | DWMWCP_DONOTROUND, // 0x00000003
  }

  [Serializable]
  public struct RECT
  {
    public int Left;
    public int Top;
    public int Right;
    public int Bottom;

    public Rectangle ToRectangle()
    {
      return Rectangle.FromLTRB(this.Left, this.Top, this.Right, this.Bottom);
    }
  }

  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  private delegate IntPtr WndProc(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam);

  public enum DisplayMode
  {
    SystemDefault,
    ClearMode,
    DarkMode,
  }
}