using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
using MyNes.Properties;

namespace MLV;

public class ManagedListViewPanel : Control
{
	private enum ManagedListViewMoveType
	{
		None,
		ColumnVLine,
		Column
	}

	private StringFormat _StringFormat;

	private Point DownPoint;

	private Point UpPoint;

	private Point DownPointAsViewPort;

	private Point CurrentMousePosition;

	public ManagedListViewViewMode viewMode;

	public ManagedListViewColumnsCollection columns;

	public ManagedListViewItemsCollection items;

	public ImageList ImagesList = new ImageList();

	public int HscrollOffset;

	public int VscrollOffset;

	public bool AllowItemsDragAndDrop = true;

	public bool AllowColumnsReorder = true;

	public bool ChangeColumnSortModeWhenClick = true;

	public int ThumbnailsHeight = 36;

	public int ThumbnailsWidth = 36;

	public int itemTextHeight = 28;

	public bool DrawHighlight = true;

	public int itemHeight = 15;

	public bool ThumbnailsKeepImageSize;

	private ManagedListViewMoveType moveType;

	private int selectedColumnIndex = -1;

	private bool highlightSelectedColumn;

	private bool highlightItemAsOver;

	private int overItemSelectedIndex;

	private int OldoverItemSelectedIndex;

	private int LatestOverItemSelectedIndex;

	private int originalcolumnWidth;

	private int downX;

	private bool isMouseDown;

	private int SelectRectanglex;

	private int SelectRectangley;

	private int SelectRectanglex1;

	private int SelectRectangley1;

	private bool DrawSelectRectangle;

	private bool isSecectingItems;

	private bool isMovingColumn;

	private int currentColumnMovedIndex;

	private int columnHeight = 24;

	private int columnh = 8;

	private int itemh = 6;

	private int highlightSensitive = 6;

	private int spaceBetweenItemsThunmbailsView = 5;

	private string currentSearchChar = "";

	private int previousShift = -1;

	public int buffered_columnsSize;

	public int buffered_itemsSize;

	private Image backgroundThumbnail;

	private int backgroundDrawX;

	private int backgroundDrawY;

	private int backgroundDrawH;

	private int backgroundDrawW;

	public bool ShowItemInfoOnThumbnailMode;

	private ManagedListViewShowThumbnailTooltipArgs thumb_tooltip;

	public Color ItemHighlightColor = Color.LightSkyBlue;

	public Color ItemSpecialColor = Color.YellowGreen;

	public Color ItemMouseOverColor = Color.LightGray;

	public Color ColumnColor = Color.Silver;

	public Color ColumnHighlightColor = Color.LightSkyBlue;

	public Color ColumnClickColor = Color.PaleVioletRed;

	private IContainer components;

	public List<ManagedListViewItem> SelectedItems
	{
		get
		{
			List<ManagedListViewItem> list = new List<ManagedListViewItem>();
			foreach (ManagedListViewItem item in items)
			{
				if (item.Selected)
				{
					list.Add(item);
				}
			}
			return list;
		}
	}

	public override Font Font
	{
		get
		{
			return base.Font;
		}
		set
		{
			base.Font = value;
			if (this.RefreshScrollBars != null)
			{
				this.RefreshScrollBars(this, null);
			}
			Invalidate();
		}
	}

	public override Image BackgroundImage
	{
		get
		{
			return base.BackgroundImage;
		}
		set
		{
			base.BackgroundImage = value;
			CalculateBackgroundBounds();
		}
	}

	public ManagedListViewBackgroundRenderMode BackgroundRenderMode { get; set; }

	public event EventHandler AdvanceVScrollRequest;

	public event EventHandler ReverseVScrollRequest;

	public event EventHandler AdvanceHScrollRequest;

	public event EventHandler ReverseHScrollRequest;

	public event EventHandler RefreshScrollBars;

	public event EventHandler SelectedIndexChanged;

	public event EventHandler<ManagedListViewColumnDrawArgs> DrawColumn;

	public event EventHandler<ManagedListViewItemDrawArgs> DrawItem;

	public event EventHandler<ManagedListViewSubItemDrawArgs> DrawSubItem;

	public event EventHandler<ManagedListViewMouseOverSubItemArgs> MouseOverSubItem;

	public event EventHandler<ManagedListViewColumnClickArgs> ColumnClicked;

	public event EventHandler<ManagedListViewItemDoubleClickArgs> ItemDoubleClick;

	public event EventHandler EnterPressedOverItem;

	public event EventHandler SwitchToColumnsContextMenu;

	public event EventHandler SwitchToNormalContextMenu;

	public event EventHandler AfterColumnResize;

	public event EventHandler AfterColumnReorder;

	public event EventHandler ItemsDrag;

	public event EventHandler<ManagedListViewItemSelectArgs> ScrollToSelectedItemRequest;

	public event EventHandler<ManagedListViewItemSelectArgs> FillSubitemsRequest;

	public event EventHandler RefreshValues;

	public event EventHandler<ManagedListViewShowThumbnailTooltipArgs> ShowThumbnailTooltipRequest;

	public event EventHandler<ManagedListViewShowThumbnailTooltipArgs> ShowThumbnailInfoRequest;

	public event EventHandler HideThumbnailTooltipRequest;

	public ManagedListViewPanel()
	{
		InitializeComponent();
		ControlStyles flag = ControlStyles.OptimizedDoubleBuffer;
		SetStyle(flag, value: true);
		AllowDrop = true;
		ShowItemInfoOnThumbnailMode = true;
		_StringFormat = new StringFormat();
		_StringFormat = new StringFormat(StringFormatFlags.NoWrap);
		_StringFormat.Trimming = StringTrimming.EllipsisCharacter;
	}

	public int GetItemIndexAtCursorPoint()
	{
		return GetItemIndexAtPoint(CurrentMousePosition);
	}

	public int GetItemIndexAtPoint(Point location)
	{
		int result = -1;
		if (viewMode == ManagedListViewViewMode.Details)
		{
			int num = location.Y;
			num -= columnHeight;
			if (num > 0 && num < buffered_itemsSize)
			{
				result = (VscrollOffset + num) / itemHeight;
			}
		}
		else
		{
			int num2 = VscrollOffset % (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
			_ = base.Height / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
			int num3 = base.Width / (spaceBetweenItemsThunmbailsView + ThumbnailsWidth);
			int num4 = VscrollOffset / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight) * num3;
			int num5 = (location.Y + num2) / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
			int num6 = location.X / (spaceBetweenItemsThunmbailsView + ThumbnailsWidth);
			int num7 = num5 * num3 + num6;
			if (num7 + num4 < items.Count && location.X < num3 * (spaceBetweenItemsThunmbailsView + ThumbnailsWidth))
			{
				result = num7 + num4;
			}
		}
		return result;
	}

	public int CalculateColumnsSize()
	{
		int num = 0;
		foreach (ManagedListViewColumn column in columns)
		{
			num += column.Width;
		}
		return num;
	}

	public int CalculateItemsSize()
	{
		itemHeight = TextRenderer.MeasureText("TEST", Font).Height + itemh;
		return itemHeight * items.Count;
	}

	public int GetItemHeight()
	{
		return TextRenderer.MeasureText("TEST", Font).Height + itemh;
	}

	public int GetVisibleItemsHeight()
	{
		int num = TextRenderer.MeasureText("TEST", Font).Height + itemh;
		return base.Height / num + 2;
	}

	public int GetVscrollValueForItem(int itemIndex)
	{
		if (viewMode == ManagedListViewViewMode.Details)
		{
			return itemIndex * itemHeight;
		}
		int num = base.Width / (spaceBetweenItemsThunmbailsView + ThumbnailsWidth);
		int num2 = itemIndex * (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight) / num;
		return num2 - num2 % (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
	}

	public Size CalculateSizeOfItemsAsThumbnails()
	{
		if (items.Count == 0)
		{
			return Size.Empty;
		}
		int num = 0;
		int num2 = 0;
		_ = base.Height / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
		int num3 = base.Width / (spaceBetweenItemsThunmbailsView + ThumbnailsWidth);
		if (num3 == 0)
		{
			num3 = 1;
		}
		num2 = (int)(Math.Ceiling((double)items.Count / (double)num3) * (double)(spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight));
		if (spaceBetweenItemsThunmbailsView + ThumbnailsWidth > base.Width)
		{
			num = ThumbnailsWidth;
		}
		return new Size(num, num2);
	}

	public void OnKeyDownRaised(KeyEventArgs e)
	{
		if (items.Count > 0)
		{
			if (e.KeyCode == Keys.Prior)
			{
				foreach (ManagedListViewItem item in items)
				{
					item.Selected = false;
				}
				items[0].Selected = true;
				if (this.ScrollToSelectedItemRequest != null)
				{
					this.ScrollToSelectedItemRequest(this, new ManagedListViewItemSelectArgs(0));
				}
				return;
			}
			if (e.KeyCode == Keys.Next)
			{
				foreach (ManagedListViewItem item2 in items)
				{
					item2.Selected = false;
				}
				items[items.Count - 1].Selected = true;
				if (this.ScrollToSelectedItemRequest != null)
				{
					this.ScrollToSelectedItemRequest(this, new ManagedListViewItemSelectArgs(items.Count - 1));
				}
				return;
			}
		}
		if (viewMode == ManagedListViewViewMode.Details)
		{
			if (SelectedItems.Count == 1)
			{
				int num = items.IndexOf(SelectedItems[0]);
				if (e.KeyCode == Keys.Down)
				{
					if (num + 1 < items.Count)
					{
						items[num].Selected = false;
						items[num + 1].Selected = true;
						int num2 = base.Height / itemHeight - 2;
						int num3 = VscrollOffset / itemHeight + num2;
						if (num + 1 > num3 && this.AdvanceVScrollRequest != null)
						{
							this.AdvanceVScrollRequest(this, null);
						}
						if (this.SelectedIndexChanged != null)
						{
							this.SelectedIndexChanged(this, new EventArgs());
						}
					}
				}
				else if (e.KeyCode == Keys.Up)
				{
					if (num - 1 >= 0)
					{
						items[num].Selected = false;
						items[num - 1].Selected = true;
						int num4 = VscrollOffset / itemHeight + 1;
						if (num - 1 < num4 && this.ReverseVScrollRequest != null)
						{
							this.ReverseVScrollRequest(this, null);
						}
						if (this.SelectedIndexChanged != null)
						{
							this.SelectedIndexChanged(this, new EventArgs());
						}
					}
				}
				else if (e.KeyCode == Keys.Return)
				{
					if (this.EnterPressedOverItem != null)
					{
						this.EnterPressedOverItem(this, new EventArgs());
					}
				}
				else
				{
					KeysConverter keysConverter = new KeysConverter();
					if (keysConverter.ConvertToString(e.KeyCode) != currentSearchChar)
					{
						items[num].Selected = false;
						num = 0;
					}
					currentSearchChar = keysConverter.ConvertToString(e.KeyCode);
					for (int i = num + 1; i < items.Count; i++)
					{
						ManagedListViewSubItem subItemByID = items[i].GetSubItemByID(columns[0].ID);
						if (subItemByID != null && subItemByID.Text.Length > 0 && subItemByID.Text.Substring(0, 1) == keysConverter.ConvertToString(e.KeyCode))
						{
							items[num].Selected = false;
							items[i].Selected = true;
							if (this.ScrollToSelectedItemRequest != null)
							{
								this.ScrollToSelectedItemRequest(this, new ManagedListViewItemSelectArgs(i));
							}
							Invalidate();
							break;
						}
					}
				}
			}
			else if (SelectedItems.Count > 1)
			{
				int num5 = items.IndexOf(SelectedItems[0]);
				KeysConverter keysConverter2 = new KeysConverter();
				for (int j = num5 + 1; j < items.Count; j++)
				{
					ManagedListViewSubItem subItemByID2 = items[j].GetSubItemByID(columns[0].ID);
					if (subItemByID2 != null && subItemByID2.Text.Length > 0 && subItemByID2.Text.Substring(0, 1) == keysConverter2.ConvertToString(e.KeyCode))
					{
						items[num5].Selected = false;
						items[j].Selected = true;
						if (this.ScrollToSelectedItemRequest != null)
						{
							this.ScrollToSelectedItemRequest(this, new ManagedListViewItemSelectArgs(j));
						}
						break;
					}
				}
			}
			else
			{
				KeysConverter keysConverter3 = new KeysConverter();
				for (int k = 0; k < items.Count; k++)
				{
					ManagedListViewSubItem subItemByID3 = items[k].GetSubItemByID(columns[0].ID);
					if (subItemByID3 != null && subItemByID3.Text.Length > 0 && subItemByID3.Text.Substring(0, 1) == keysConverter3.ConvertToString(e.KeyCode))
					{
						items[k].Selected = true;
						if (this.ScrollToSelectedItemRequest != null)
						{
							this.ScrollToSelectedItemRequest(this, new ManagedListViewItemSelectArgs(k));
						}
						break;
					}
				}
			}
		}
		else if (SelectedItems.Count == 1)
		{
			int num6 = items.IndexOf(SelectedItems[0]);
			if (e.KeyCode == Keys.Right)
			{
				if (num6 + 1 < items.Count)
				{
					items[num6].Selected = false;
					items[num6 + 1].Selected = true;
					int vscrollValueForItem = GetVscrollValueForItem(num6 + 1);
					if (base.Height - vscrollValueForItem < ThumbnailsHeight + itemTextHeight && this.ScrollToSelectedItemRequest != null)
					{
						this.ScrollToSelectedItemRequest(this, new ManagedListViewItemSelectArgs(num6 + 1));
					}
					if (this.SelectedIndexChanged != null)
					{
						this.SelectedIndexChanged(this, new EventArgs());
					}
				}
			}
			else if (e.KeyCode == Keys.Left)
			{
				if (num6 - 1 >= 0)
				{
					items[num6].Selected = false;
					items[num6 - 1].Selected = true;
					if (GetVscrollValueForItem(num6 - 1) < VscrollOffset && this.ScrollToSelectedItemRequest != null)
					{
						this.ScrollToSelectedItemRequest(this, new ManagedListViewItemSelectArgs(num6 - 1));
					}
					if (this.SelectedIndexChanged != null)
					{
						this.SelectedIndexChanged(this, new EventArgs());
					}
				}
			}
			else if (e.KeyCode == Keys.Down)
			{
				_ = base.Height / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
				int num7 = base.Width / (spaceBetweenItemsThunmbailsView + ThumbnailsWidth);
				int num8 = VscrollOffset / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight) * num7;
				int num9 = num6 - num8;
				int num10 = num8 + num7 + num9;
				if (num10 < items.Count)
				{
					items[num6].Selected = false;
					items[num10].Selected = true;
					int vscrollValueForItem2 = GetVscrollValueForItem(num10);
					if (base.Height - vscrollValueForItem2 < ThumbnailsHeight + itemTextHeight && this.ScrollToSelectedItemRequest != null)
					{
						this.ScrollToSelectedItemRequest(this, new ManagedListViewItemSelectArgs(num10));
					}
					if (this.SelectedIndexChanged != null)
					{
						this.SelectedIndexChanged(this, new EventArgs());
					}
				}
			}
			else if (e.KeyCode == Keys.Up)
			{
				_ = base.Height / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
				int num11 = base.Width / (spaceBetweenItemsThunmbailsView + ThumbnailsWidth);
				int num12 = VscrollOffset / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight) * num11;
				int num13 = num6 - num12;
				int num14 = num12 - num11 + num13;
				if (num14 >= 0)
				{
					items[num6].Selected = false;
					items[num14].Selected = true;
					if (GetVscrollValueForItem(num14) < VscrollOffset && this.ScrollToSelectedItemRequest != null)
					{
						this.ScrollToSelectedItemRequest(this, new ManagedListViewItemSelectArgs(num14));
					}
					if (this.SelectedIndexChanged != null)
					{
						this.SelectedIndexChanged(this, new EventArgs());
					}
				}
			}
			else if (e.KeyCode == Keys.Return)
			{
				if (this.EnterPressedOverItem != null)
				{
					this.EnterPressedOverItem(this, new EventArgs());
				}
			}
			else
			{
				KeysConverter keysConverter4 = new KeysConverter();
				for (int l = num6 + 1; l < items.Count; l++)
				{
					if (items[l].Text.Length > 0 && items[l].Text.Substring(0, 1) == keysConverter4.ConvertToString(e.KeyCode))
					{
						items[num6].Selected = false;
						items[l].Selected = true;
						if (this.ScrollToSelectedItemRequest != null)
						{
							this.ScrollToSelectedItemRequest(this, new ManagedListViewItemSelectArgs(l));
						}
						break;
					}
				}
			}
		}
		else if (SelectedItems.Count > 1)
		{
			int num15 = items.IndexOf(SelectedItems[0]);
			KeysConverter keysConverter5 = new KeysConverter();
			for (int m = num15 + 1; m < items.Count; m++)
			{
				if (items[m].GetSubItemByID(columns[0].ID).Text.Length > 0 && items[m].GetSubItemByID(columns[0].ID).Text.Substring(0, 1) == keysConverter5.ConvertToString(e.KeyCode))
				{
					items[num15].Selected = false;
					items[m].Selected = true;
					if (this.ScrollToSelectedItemRequest != null)
					{
						this.ScrollToSelectedItemRequest(this, new ManagedListViewItemSelectArgs(m));
					}
					break;
				}
			}
		}
		else
		{
			KeysConverter keysConverter6 = new KeysConverter();
			for (int n = 0; n < items.Count; n++)
			{
				if (items[n].Text.Length > 0 && items[n].Text.Substring(0, 1) == keysConverter6.ConvertToString(e.KeyCode))
				{
					items[n].Selected = true;
					if (this.ScrollToSelectedItemRequest != null)
					{
						this.ScrollToSelectedItemRequest(this, new ManagedListViewItemSelectArgs(n));
					}
					break;
				}
			}
		}
		Invalidate();
	}

	public void OnRefreshScrollBars()
	{
		if (this.RefreshScrollBars != null)
		{
			this.RefreshScrollBars(this, null);
		}
	}

	public void OnMouseLeaveRise()
	{
		OnMouseLeave(new EventArgs());
	}

	public void OnColumnsCollectionClear()
	{
		highlightSelectedColumn = false;
		highlightItemAsOver = false;
		overItemSelectedIndex = -1;
		OldoverItemSelectedIndex = -1;
		LatestOverItemSelectedIndex = -1;
		HscrollOffset = 0;
		VscrollOffset = 0;
	}

	protected override void OnPaint(PaintEventArgs pe)
	{
		base.OnPaint(pe);
		pe.Graphics.FillRectangle(new SolidBrush(BackColor), 0, 0, base.Width, base.Height);
		if (backgroundThumbnail != null)
		{
			pe.Graphics.DrawImage(backgroundThumbnail, backgroundDrawX, backgroundDrawY, backgroundDrawW, backgroundDrawH);
		}
		if (viewMode == ManagedListViewViewMode.Details)
		{
			DrawDetailsView(pe);
		}
		else
		{
			DrawThumbailsView(pe);
		}
		if (DrawSelectRectangle)
		{
			pe.Graphics.DrawRectangle(new Pen(new SolidBrush(Color.Gray)), SelectRectanglex, SelectRectangley, SelectRectanglex1 - SelectRectanglex, SelectRectangley1 - SelectRectangley);
		}
	}

	protected override void OnPaintBackground(PaintEventArgs pevent)
	{
	}

	protected override void OnMouseDown(MouseEventArgs e)
	{
		base.OnMouseDown(e);
		DownPoint = e.Location;
		DownPointAsViewPort = new Point(e.X + HscrollOffset, e.Y + VscrollOffset);
		isMouseDown = true;
		if (viewMode == ManagedListViewViewMode.Details)
		{
			if (e.Button == MouseButtons.Left)
			{
				if (e.Y > columnHeight)
				{
					if (e.X > buffered_columnsSize - HscrollOffset)
					{
						DrawSelectRectangle = true;
					}
					else if (e.Y > buffered_itemsSize - VscrollOffset)
					{
						DrawSelectRectangle = true;
					}
					else
					{
						DrawSelectRectangle = false;
					}
				}
				else
				{
					DrawSelectRectangle = false;
				}
			}
			else
			{
				DrawSelectRectangle = false;
			}
		}
		else if (e.Button == MouseButtons.Left)
		{
			if (!highlightItemAsOver && overItemSelectedIndex < 0)
			{
				DrawSelectRectangle = true;
			}
			else
			{
				DrawSelectRectangle = false;
			}
		}
		Invalidate();
	}

	protected override void OnMouseUp(MouseEventArgs e)
	{
		UpPoint = e.Location;
		base.OnMouseUp(e);
		if (e.Button == MouseButtons.Left)
		{
			if (moveType == ManagedListViewMoveType.ColumnVLine && selectedColumnIndex >= 0 && this.AfterColumnResize != null)
			{
				this.AfterColumnResize(this, new EventArgs());
			}
			if (moveType == ManagedListViewMoveType.Column && selectedColumnIndex >= 0 && isMovingColumn)
			{
				int num = 0;
				int num2 = 0;
				int num3 = 0;
				foreach (ManagedListViewColumn column in columns)
				{
					num += column.Width;
					if (num >= HscrollOffset && e.X >= num2 - HscrollOffset && e.X <= num - HscrollOffset + 3)
					{
						selectedColumnIndex = num3;
					}
					num3++;
					num2 += column.Width;
					if (num2 - HscrollOffset > base.Width)
					{
						break;
					}
				}
				ManagedListViewColumn item = columns[currentColumnMovedIndex];
				columns.Remove(columns[currentColumnMovedIndex]);
				columns.Insert(selectedColumnIndex, item);
				if (this.AfterColumnReorder != null)
				{
					this.AfterColumnReorder(this, null);
				}
			}
		}
		isMovingColumn = false;
		DrawSelectRectangle = false;
		SelectRectanglex = 0;
		SelectRectangley = 0;
		SelectRectanglex1 = 0;
		SelectRectangley1 = 0;
		previousShift = -1;
		isMouseDown = false;
		Invalidate();
	}

	protected override void OnMouseMove(MouseEventArgs e)
	{
		base.OnMouseMove(e);
		CurrentMousePosition = e.Location;
		bool flag = true;
		if (viewMode == ManagedListViewViewMode.Details)
		{
			if (e.Button == MouseButtons.Left && moveType == ManagedListViewMoveType.ColumnVLine && selectedColumnIndex >= 0)
			{
				int num = e.X - downX;
				if ((previousShift != num) & (originalcolumnWidth + num > 5))
				{
					Cursor = Cursors.VSplit;
					columns[selectedColumnIndex].Width = originalcolumnWidth + num;
					buffered_columnsSize = CalculateColumnsSize();
					if (this.RefreshValues != null)
					{
						this.RefreshValues(this, null);
					}
					previousShift = num;
					Invalidate();
				}
				return;
			}
			if (e.Y <= columnHeight)
			{
				if (this.SwitchToColumnsContextMenu != null)
				{
					this.SwitchToColumnsContextMenu(this, new EventArgs());
				}
				highlightSelectedColumn = true;
				if (e.Button == MouseButtons.Left)
				{
					if (moveType == ManagedListViewMoveType.ColumnVLine && selectedColumnIndex >= 0)
					{
						int num2 = e.X - downX;
						if ((previousShift != num2) & (originalcolumnWidth + num2 > 5))
						{
							Cursor = Cursors.VSplit;
							columns[selectedColumnIndex].Width = originalcolumnWidth + num2;
							buffered_columnsSize = CalculateColumnsSize();
							if (this.RefreshValues != null)
							{
								this.RefreshValues(this, null);
							}
							previousShift = num2;
						}
					}
					if (AllowColumnsReorder && moveType == ManagedListViewMoveType.Column && selectedColumnIndex >= 0)
					{
						Cursor = Cursors.SizeAll;
						currentColumnMovedIndex = selectedColumnIndex;
						if (e.X > DownPoint.X + 3 || e.X < DownPoint.X - 3)
						{
							isMovingColumn = true;
						}
						if (isMovingColumn)
						{
							if (e.X < 10)
							{
								OnReverseHScrollRequest();
							}
							else if (e.X > base.Width - 10)
							{
								OnAdvanceHScrollRequest();
							}
						}
						buffered_columnsSize = CalculateColumnsSize();
					}
				}
				else
				{
					moveType = ManagedListViewMoveType.None;
					int num3 = 0;
					int num4 = 0;
					int num5 = 0;
					bool flag2 = false;
					foreach (ManagedListViewColumn column in columns)
					{
						num3 += column.Width;
						if (num3 >= HscrollOffset)
						{
							if (e.X >= num4 - HscrollOffset && e.X <= num3 - HscrollOffset + 3)
							{
								selectedColumnIndex = num5;
								moveType = ManagedListViewMoveType.Column;
							}
							int num6 = num3 - HscrollOffset - 3;
							int num7 = num3 - HscrollOffset + 3;
							if (e.X >= num6 && e.X <= num7)
							{
								downX = e.X;
								originalcolumnWidth = column.Width;
								moveType = ManagedListViewMoveType.ColumnVLine;
								Cursor = Cursors.VSplit;
								flag2 = true;
								break;
							}
						}
						num5++;
						num4 += column.Width;
						if (num4 - HscrollOffset > base.Width)
						{
							break;
						}
					}
					if (!flag2)
					{
						Cursor = Cursors.Default;
					}
				}
			}
			else
			{
				if (this.SwitchToNormalContextMenu != null)
				{
					this.SwitchToNormalContextMenu(this, new EventArgs());
				}
				if (e.Button == MouseButtons.Left)
				{
					if (moveType == ManagedListViewMoveType.ColumnVLine && selectedColumnIndex >= 0)
					{
						int num8 = e.X - downX;
						if ((previousShift != num8) & (originalcolumnWidth + num8 > 5))
						{
							Cursor = Cursors.VSplit;
							columns[selectedColumnIndex].Width = originalcolumnWidth + num8;
							buffered_columnsSize = CalculateColumnsSize();
							if (this.RefreshValues != null)
							{
								this.RefreshValues(this, null);
							}
							previousShift = num8;
						}
					}
					if (AllowColumnsReorder && moveType == ManagedListViewMoveType.Column && selectedColumnIndex >= 0)
					{
						currentColumnMovedIndex = selectedColumnIndex;
						if (e.X > DownPoint.X + 3 || e.X < DownPoint.X - 3)
						{
							isMovingColumn = true;
						}
						buffered_columnsSize = CalculateColumnsSize();
						if (isMovingColumn)
						{
							if (e.X < 10)
							{
								OnReverseHScrollRequest();
							}
							else if (e.X > base.Width - 10)
							{
								OnAdvanceHScrollRequest();
							}
						}
					}
				}
				else
				{
					moveType = ManagedListViewMoveType.None;
					selectedColumnIndex = -1;
					highlightSelectedColumn = false;
					isMovingColumn = false;
				}
			}
			if (e.Y > columnHeight)
			{
				if (e.Button == MouseButtons.Left)
				{
					Cursor = Cursors.Default;
					if (DrawSelectRectangle)
					{
						SelectRectanglex = DownPointAsViewPort.X - HscrollOffset;
						SelectRectangley = DownPointAsViewPort.Y - VscrollOffset;
						SelectRectanglex1 = e.X;
						SelectRectangley1 = e.Y;
						if (SelectRectanglex1 < SelectRectanglex)
						{
							SelectRectanglex = e.X;
							SelectRectanglex1 = DownPointAsViewPort.X - HscrollOffset;
						}
						if (SelectRectangley1 < SelectRectangley)
						{
							SelectRectangley = e.Y;
							SelectRectangley1 = DownPointAsViewPort.Y - VscrollOffset;
						}
						if (e.Y > base.Height)
						{
							for (int i = 0; i < 10; i++)
							{
								if (this.AdvanceVScrollRequest != null)
								{
									this.AdvanceVScrollRequest(this, null);
								}
							}
						}
						if (Control.ModifierKeys != Keys.Control)
						{
							foreach (ManagedListViewItem item in items)
							{
								item.Selected = false;
							}
						}
						if (SelectRectanglex + HscrollOffset < buffered_columnsSize)
						{
							TextRenderer.MeasureText("TEST", Font);
							isSecectingItems = true;
							bool flag3 = false;
							for (int j = VscrollOffset + SelectRectangley; j < VscrollOffset + SelectRectangley1; j++)
							{
								int num9 = (j - columnHeight) / itemHeight;
								if (num9 < items.Count)
								{
									items[num9].Selected = true;
									flag3 = true;
								}
							}
							if (flag3 && this.SelectedIndexChanged != null)
							{
								this.SelectedIndexChanged(this, new EventArgs());
							}
						}
					}
					if (AllowItemsDragAndDrop && (e.X > DownPoint.X + 3 || e.X < DownPoint.X - 3 || ((e.Y > DownPoint.Y + 3) | (e.Y < DownPoint.Y - 3))) && highlightItemAsOver && overItemSelectedIndex >= 0 && items[overItemSelectedIndex].Selected && this.ItemsDrag != null)
					{
						this.ItemsDrag(this, new EventArgs());
					}
				}
				else
				{
					Cursor = Cursors.Default;
					if (e.X < buffered_columnsSize - HscrollOffset)
					{
						Size charFontSize = TextRenderer.MeasureText("TEST", Font);
						int num10 = (e.Y + (VscrollOffset - columnHeight) - itemHeight / highlightSensitive) / itemHeight;
						if (num10 < items.Count)
						{
							highlightItemAsOver = true;
							overItemSelectedIndex = num10;
							if (OldoverItemSelectedIndex != num10 && OldoverItemSelectedIndex >= 0 && OldoverItemSelectedIndex < items.Count)
							{
								items[OldoverItemSelectedIndex].OnMouseLeave();
							}
							int num11 = 0;
							int num12 = 0;
							int num13 = 0;
							foreach (ManagedListViewColumn column2 in columns)
							{
								num11 += column2.Width;
								if (num11 >= HscrollOffset && num11 > e.X + HscrollOffset)
								{
									if (num13 >= items[num10].SubItems.Count)
									{
										break;
									}
									ManagedListViewSubItem subItemByID = items[num10].GetSubItemByID(column2.ID);
									if (subItemByID != null)
									{
										subItemByID.OnMouseOver(new Point(e.X - (num12 - HscrollOffset), 0), charFontSize);
										if (subItemByID.GetType() == typeof(ManagedListViewRatingSubItem))
										{
											((ManagedListViewRatingSubItem)subItemByID).DrawOverImage = true;
										}
									}
									if (this.MouseOverSubItem == null)
									{
										break;
									}
									Font font = (subItemByID.CustomFontEnabled ? subItemByID.CustomFont : Font);
									int num14 = TextRenderer.MeasureText(subItemByID.Text, font).Width;
									num14 += 2;
									switch (subItemByID.DrawMode)
									{
									case ManagedListViewItemDrawMode.TextAndImage:
										if (subItemByID.ImageIndex < ImagesList.Images.Count)
										{
											num14 += itemHeight;
										}
										break;
									case ManagedListViewItemDrawMode.UserDraw:
										num14 += itemHeight;
										break;
									}
									bool isTextFullyVisible = num14 < num11 - num12 - HscrollOffset;
									int num15 = num10 * itemHeight - VscrollOffset + columnHeight;
									Rectangle subitemRectangle = new Rectangle(num12 - HscrollOffset, num15, num11 - num12 - HscrollOffset, itemHeight);
									this.MouseOverSubItem(this, new ManagedListViewMouseOverSubItemArgs(num10, columns[num13].ID, e.X - HscrollOffset, subitemRectangle, subItemByID.Text, isTextFullyVisible));
									break;
								}
								num12 += column2.Width;
								num13++;
								if (num12 - HscrollOffset > base.Width)
								{
									break;
								}
							}
							OldoverItemSelectedIndex = num10;
						}
						else
						{
							highlightItemAsOver = false;
							if (overItemSelectedIndex < items.Count && overItemSelectedIndex >= 0)
							{
								items[OldoverItemSelectedIndex].OnMouseLeave();
							}
							OldoverItemSelectedIndex = (overItemSelectedIndex = -1);
						}
					}
					else
					{
						highlightItemAsOver = false;
						if (overItemSelectedIndex < items.Count && overItemSelectedIndex >= 0)
						{
							items[OldoverItemSelectedIndex].OnMouseLeave();
						}
						OldoverItemSelectedIndex = (overItemSelectedIndex = -1);
					}
				}
			}
			if (DrawSelectRectangle && e.Y < columnHeight)
			{
				for (int k = 0; k < 10; k++)
				{
					if (this.ReverseVScrollRequest != null)
					{
						this.ReverseVScrollRequest(this, null);
					}
				}
			}
		}
		else if (e.Button == MouseButtons.Left)
		{
			if (DrawSelectRectangle)
			{
				SelectRectanglex = DownPointAsViewPort.X - HscrollOffset;
				SelectRectangley = DownPointAsViewPort.Y - VscrollOffset;
				SelectRectanglex1 = e.X;
				SelectRectangley1 = e.Y;
				if (SelectRectanglex1 < SelectRectanglex)
				{
					SelectRectanglex = e.X;
					SelectRectanglex1 = DownPointAsViewPort.X - HscrollOffset;
				}
				if (SelectRectangley1 < SelectRectangley)
				{
					SelectRectangley = e.Y;
					SelectRectangley1 = DownPointAsViewPort.Y - VscrollOffset;
				}
				if (e.Y > base.Height)
				{
					for (int l = 0; l < 10; l++)
					{
						if (this.AdvanceVScrollRequest != null)
						{
							this.AdvanceVScrollRequest(this, null);
						}
					}
				}
				if (e.Y < 0)
				{
					for (int m = 0; m < 10; m++)
					{
						if (this.ReverseVScrollRequest != null)
						{
							this.ReverseVScrollRequest(this, null);
						}
					}
				}
				if (Control.ModifierKeys != Keys.Control)
				{
					foreach (ManagedListViewItem item2 in items)
					{
						item2.Selected = false;
					}
				}
				bool flag4 = false;
				isSecectingItems = true;
				int num16 = VscrollOffset % (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
				_ = base.Height / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
				int num17 = base.Width / (spaceBetweenItemsThunmbailsView + ThumbnailsWidth);
				_ = VscrollOffset / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
				int num18;
				for (num18 = VscrollOffset + SelectRectangley; num18 < VscrollOffset + SelectRectangley1; num18++)
				{
					int num19;
					for (num19 = HscrollOffset + SelectRectanglex; num19 < HscrollOffset + SelectRectanglex1; num19++)
					{
						int num20 = (num18 + num16) / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
						int num21 = num19 / (spaceBetweenItemsThunmbailsView + ThumbnailsWidth);
						if (num21 < num17)
						{
							int num22 = num20 * num17 + num21;
							if (num22 < items.Count)
							{
								items[num22].Selected = true;
								flag4 = true;
							}
						}
						num19 += spaceBetweenItemsThunmbailsView + ThumbnailsWidth;
					}
					num18 += spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight;
				}
				if (flag4 && this.SelectedIndexChanged != null)
				{
					this.SelectedIndexChanged(this, new EventArgs());
				}
			}
			if (AllowItemsDragAndDrop && (e.X > DownPoint.X + 3 || e.X < DownPoint.X - 3 || ((e.Y > DownPoint.Y + 3) | (e.Y < DownPoint.Y - 3))) && highlightItemAsOver && overItemSelectedIndex >= 0 && items[overItemSelectedIndex].Selected && this.ItemsDrag != null)
			{
				this.ItemsDrag(this, new EventArgs());
			}
		}
		else
		{
			int num23 = VscrollOffset % (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
			_ = base.Height / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
			int num24 = base.Width / (spaceBetweenItemsThunmbailsView + ThumbnailsWidth);
			int num25 = VscrollOffset / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight) * num24;
			int num26 = (e.Y + num23) / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
			int num27 = e.X / (spaceBetweenItemsThunmbailsView + ThumbnailsWidth);
			int num28 = num26 * num24 + num27;
			if (num28 + num25 < items.Count)
			{
				if (e.X < num24 * (spaceBetweenItemsThunmbailsView + ThumbnailsWidth))
				{
					highlightItemAsOver = true;
					overItemSelectedIndex = num28 + num25;
				}
				else
				{
					highlightItemAsOver = false;
					OldoverItemSelectedIndex = (overItemSelectedIndex = -1);
				}
			}
			else
			{
				highlightItemAsOver = false;
				OldoverItemSelectedIndex = (overItemSelectedIndex = -1);
			}
		}
		if (flag)
		{
			Invalidate();
		}
	}

	protected override void OnMouseClick(MouseEventArgs e)
	{
		base.OnMouseClick(e);
		if (viewMode == ManagedListViewViewMode.Details)
		{
			if (e.Y > columnHeight)
			{
				if (e.X < buffered_columnsSize - HscrollOffset)
				{
					if (e.Button == MouseButtons.Left && !isSecectingItems && overItemSelectedIndex >= 0)
					{
						bool selected = items[overItemSelectedIndex].Selected;
						bool flag = false;
						if (Control.ModifierKeys == Keys.Shift)
						{
							flag = true;
							if (LatestOverItemSelectedIndex == -1)
							{
								flag = false;
							}
						}
						else if (Control.ModifierKeys != Keys.Control)
						{
							LatestOverItemSelectedIndex = -1;
							foreach (ManagedListViewItem item in items)
							{
								item.Selected = false;
							}
						}
						if (highlightItemAsOver && overItemSelectedIndex >= 0)
						{
							if (!flag)
							{
								items[overItemSelectedIndex].Selected = true;
								LatestOverItemSelectedIndex = overItemSelectedIndex;
								if (this.SelectedIndexChanged != null && !selected)
								{
									this.SelectedIndexChanged(this, new EventArgs());
								}
								int num = 0;
								int num2 = 0;
								int num3 = 0;
								foreach (ManagedListViewColumn column in columns)
								{
									num += column.Width;
									if (num >= HscrollOffset && num > e.X + HscrollOffset)
									{
										items[overItemSelectedIndex].GetSubItemByID(column.ID)?.OnMouseClick(new Point(e.X - (num2 - HscrollOffset), 0), TextRenderer.MeasureText("TEST", Font), overItemSelectedIndex);
										break;
									}
									num2 += column.Width;
									num3++;
									if (num2 - HscrollOffset > base.Width)
									{
										break;
									}
								}
							}
							else
							{
								foreach (ManagedListViewItem item2 in items)
								{
									item2.Selected = false;
								}
								if (overItemSelectedIndex > LatestOverItemSelectedIndex)
								{
									for (int i = LatestOverItemSelectedIndex; i < overItemSelectedIndex + 1; i++)
									{
										items[i].Selected = true;
									}
									if (this.SelectedIndexChanged != null)
									{
										this.SelectedIndexChanged(this, new EventArgs());
									}
								}
								else if (overItemSelectedIndex < LatestOverItemSelectedIndex)
								{
									for (int j = overItemSelectedIndex; j < LatestOverItemSelectedIndex + 1; j++)
									{
										items[j].Selected = true;
									}
									if (this.SelectedIndexChanged != null)
									{
										this.SelectedIndexChanged(this, new EventArgs());
									}
								}
							}
						}
					}
					if (e.Button == MouseButtons.Left && !isSecectingItems && overItemSelectedIndex == -1)
					{
						LatestOverItemSelectedIndex = -1;
						bool flag2 = false;
						foreach (ManagedListViewItem item3 in items)
						{
							if (item3.Selected && !flag2)
							{
								flag2 = true;
							}
							item3.Selected = false;
						}
						if (flag2 && this.SelectedIndexChanged != null)
						{
							this.SelectedIndexChanged(this, new EventArgs());
						}
					}
				}
				else if (!isSecectingItems)
				{
					bool flag3 = false;
					foreach (ManagedListViewItem item4 in items)
					{
						if (item4.Selected && !flag3)
						{
							flag3 = true;
						}
						item4.Selected = false;
					}
					if (flag3 && this.SelectedIndexChanged != null)
					{
						this.SelectedIndexChanged(this, new EventArgs());
					}
				}
			}
			if (e.Y < columnHeight && e.Button == MouseButtons.Left && moveType == ManagedListViewMoveType.Column && selectedColumnIndex >= 0 && !isMovingColumn)
			{
				if (ChangeColumnSortModeWhenClick)
				{
					switch (columns[selectedColumnIndex].SortMode)
					{
					case ManagedListViewSortMode.None:
						columns[selectedColumnIndex].SortMode = ManagedListViewSortMode.AtoZ;
						break;
					case ManagedListViewSortMode.AtoZ:
						columns[selectedColumnIndex].SortMode = ManagedListViewSortMode.ZtoA;
						break;
					case ManagedListViewSortMode.ZtoA:
						columns[selectedColumnIndex].SortMode = ManagedListViewSortMode.None;
						break;
					}
				}
				if (this.ColumnClicked != null)
				{
					this.ColumnClicked(this, new ManagedListViewColumnClickArgs(columns[selectedColumnIndex].ID));
				}
			}
		}
		else
		{
			if (e.Button == MouseButtons.Left && !isSecectingItems && overItemSelectedIndex >= 0 && items.Count > 0)
			{
				bool selected2 = items[overItemSelectedIndex].Selected;
				bool flag4 = false;
				if (Control.ModifierKeys == Keys.Shift)
				{
					flag4 = true;
					if (LatestOverItemSelectedIndex == -1)
					{
						flag4 = false;
					}
				}
				else if (Control.ModifierKeys != Keys.Control)
				{
					LatestOverItemSelectedIndex = -1;
					foreach (ManagedListViewItem item5 in items)
					{
						item5.Selected = false;
					}
				}
				if (highlightItemAsOver && overItemSelectedIndex >= 0)
				{
					if (!flag4)
					{
						items[overItemSelectedIndex].Selected = true;
						LatestOverItemSelectedIndex = overItemSelectedIndex;
						if (this.SelectedIndexChanged != null && !selected2)
						{
							this.SelectedIndexChanged(this, new EventArgs());
						}
					}
					else
					{
						foreach (ManagedListViewItem item6 in items)
						{
							item6.Selected = false;
						}
						if (overItemSelectedIndex > LatestOverItemSelectedIndex)
						{
							for (int k = LatestOverItemSelectedIndex; k < overItemSelectedIndex + 1; k++)
							{
								items[k].Selected = true;
							}
							if (this.SelectedIndexChanged != null)
							{
								this.SelectedIndexChanged(this, new EventArgs());
							}
						}
						else if (overItemSelectedIndex < LatestOverItemSelectedIndex)
						{
							for (int l = overItemSelectedIndex; l < LatestOverItemSelectedIndex + 1; l++)
							{
								items[l].Selected = true;
							}
							if (this.SelectedIndexChanged != null)
							{
								this.SelectedIndexChanged(this, new EventArgs());
							}
						}
					}
				}
			}
			if (e.Button == MouseButtons.Left && !isSecectingItems && overItemSelectedIndex == -1 && items.Count > 0)
			{
				LatestOverItemSelectedIndex = -1;
				bool flag5 = false;
				foreach (ManagedListViewItem item7 in items)
				{
					if (item7.Selected && !flag5)
					{
						flag5 = true;
					}
					item7.Selected = false;
				}
				if (flag5 && this.SelectedIndexChanged != null)
				{
					this.SelectedIndexChanged(this, new EventArgs());
				}
			}
		}
		if (!Focused)
		{
			Focus();
		}
		isSecectingItems = false;
		Invalidate();
	}

	protected override void OnMouseWheel(MouseEventArgs e)
	{
		if (e.Delta > 0 && this.ReverseVScrollRequest != null)
		{
			this.ReverseVScrollRequest(this, null);
		}
		if (e.Delta < 0 && this.AdvanceVScrollRequest != null)
		{
			this.AdvanceVScrollRequest(this, null);
		}
		base.OnMouseWheel(e);
		Invalidate();
	}

	protected override void OnMouseDoubleClick(MouseEventArgs e)
	{
		base.OnMouseDoubleClick(e);
		if (e.Y > columnHeight && this.ItemDoubleClick != null)
		{
			this.ItemDoubleClick(this, new ManagedListViewItemDoubleClickArgs(overItemSelectedIndex));
		}
	}

	protected override void OnMouseLeave(EventArgs e)
	{
		base.OnMouseLeave(e);
		if (highlightItemAsOver)
		{
			highlightItemAsOver = false;
			if (overItemSelectedIndex < items.Count && overItemSelectedIndex >= 0 && OldoverItemSelectedIndex >= 0 && OldoverItemSelectedIndex < items.Count && items[OldoverItemSelectedIndex] != null)
			{
				items[OldoverItemSelectedIndex].OnMouseLeave();
			}
			OldoverItemSelectedIndex = (overItemSelectedIndex = -1);
			Invalidate();
		}
	}

	protected override void OnEnter(EventArgs e)
	{
		base.OnEnter(e);
		OnRefreshScrollBars();
	}

	public void CalculateBackgroundBounds()
	{
		if (BackgroundImage != null)
		{
			switch (BackgroundRenderMode)
			{
			case ManagedListViewBackgroundRenderMode.NormalStretchNoAspectRatio:
				backgroundDrawX = (backgroundDrawY = 0);
				backgroundDrawH = base.Height;
				backgroundDrawW = base.Width;
				break;
			case ManagedListViewBackgroundRenderMode.StretchWithAspectRatioIfLarger:
				CalculateBKGStretchedImageValues();
				CenterBKGImage();
				break;
			case ManagedListViewBackgroundRenderMode.StretchWithAspectRatioToFit:
				CalculateBKGStretchToFitImageValues();
				CenterBKGImage();
				break;
			}
			backgroundThumbnail = BackgroundImage.GetThumbnailImage(backgroundDrawW, backgroundDrawH, null, IntPtr.Zero);
		}
		else
		{
			backgroundThumbnail = null;
		}
	}

	protected override void OnResize(EventArgs e)
	{
		base.OnResize(e);
		CalculateBackgroundBounds();
	}

	private void DrawDetailsView(PaintEventArgs pe)
	{
		if (columns == null)
		{
			return;
		}
		int num = 0;
		int num2 = 0;
		int num3 = 0;
		Size size = TextRenderer.MeasureText("TEST", Font);
		columnHeight = size.Height + columnh;
		int num4 = columnh / 2;
		itemHeight = size.Height + itemh;
		int num5 = itemh / 2;
		int num6 = base.Height / itemHeight + 2;
		bool flag = false;
		int num7 = VscrollOffset % itemHeight;
		foreach (ManagedListViewColumn column in columns)
		{
			num += column.Width;
			if (num >= HscrollOffset)
			{
				if (items != null)
				{
					int num8 = VscrollOffset / itemHeight;
					for (int i = 0; i < num6; i++)
					{
						if (num8 < items.Count)
						{
							if (flag)
							{
								flag = false;
								num2 = 0;
							}
							if (num2 == 0 && items[num8].IsChildItem)
							{
								num2 = 15;
								flag = true;
							}
							if (backgroundThumbnail == null)
							{
								pe.Graphics.FillRectangle(new SolidBrush(base.BackColor), new Rectangle(num2 - HscrollOffset + 1, i * itemHeight - num7 + columnHeight + 1, column.Width - 1, itemHeight));
							}
							if (items[num8].IsSpecialItem)
							{
								pe.Graphics.FillRectangle(new SolidBrush(ItemSpecialColor), new Rectangle(num2 - HscrollOffset + 1, i * itemHeight - num7 + columnHeight + 1, column.Width - 1, itemHeight));
							}
							if (items[num8].Selected)
							{
								pe.Graphics.FillRectangle(new SolidBrush(ItemHighlightColor), new Rectangle(num2 - HscrollOffset + 1, i * itemHeight - num7 + columnHeight + 1, column.Width - 1, itemHeight));
							}
							else if (highlightItemAsOver && num8 == overItemSelectedIndex && DrawHighlight)
							{
								pe.Graphics.FillRectangle(new SolidBrush(ItemMouseOverColor), new Rectangle(num2 - HscrollOffset + 1, i * itemHeight - num7 + columnHeight + 1, column.Width - 1, itemHeight));
							}
							if (items[num8].UseSubitemsReady)
							{
								if (!items[num8].IsSubitemsReady && this.FillSubitemsRequest != null)
								{
									this.FillSubitemsRequest(this, new ManagedListViewItemSelectArgs(num8));
								}
								if (!items[num8].IsSubitemsReady)
								{
									continue;
								}
							}
							ManagedListViewSubItem subItemByID = items[num8].GetSubItemByID(column.ID);
							if (subItemByID != null)
							{
								Color color = subItemByID.Color;
								Font font = (subItemByID.CustomFontEnabled ? subItemByID.CustomFont : Font);
								if (subItemByID.GetType() == typeof(ManagedListViewRatingSubItem))
								{
									((ManagedListViewRatingSubItem)subItemByID).OnRefreshRating(num8, itemHeight);
									Image image = Resources.noneRating;
									if (!((ManagedListViewRatingSubItem)subItemByID).DrawOverImage)
									{
										switch (((ManagedListViewRatingSubItem)subItemByID).Rating)
										{
										case 1:
											image = Resources.star_1;
											break;
										case 2:
											image = Resources.star_2;
											break;
										case 3:
											image = Resources.star_3;
											break;
										case 4:
											image = Resources.star_4;
											break;
										case 5:
											image = Resources.star_5;
											break;
										}
									}
									else
									{
										switch (((ManagedListViewRatingSubItem)subItemByID).OverRating)
										{
										case 1:
											image = Resources.star_1;
											break;
										case 2:
											image = Resources.star_2;
											break;
										case 3:
											image = Resources.star_3;
											break;
										case 4:
											image = Resources.star_4;
											break;
										case 5:
											image = Resources.star_5;
											break;
										}
									}
									image = image.GetThumbnailImage(itemHeight * 4, itemHeight - 1, null, IntPtr.Zero);
									int num9 = itemHeight * 4;
									if (num9 > column.Width)
									{
										num9 = column.Width;
									}
									pe.Graphics.DrawImageUnscaledAndClipped(image, new Rectangle(num2 - HscrollOffset + 2, i * itemHeight - num7 + columnHeight + 1, num9, itemHeight - 1));
									((ManagedListViewRatingSubItem)subItemByID).DrawOverImage = false;
								}
								else
								{
									switch (subItemByID.DrawMode)
									{
									case ManagedListViewItemDrawMode.Text:
										pe.Graphics.DrawString(subItemByID.Text, font, new SolidBrush(color), new Rectangle(num2 - HscrollOffset + 2, i * itemHeight - num7 + columnHeight + num5, column.Width, size.Height), _StringFormat);
										break;
									case ManagedListViewItemDrawMode.Image:
										if (subItemByID.ImageIndex < ImagesList.Images.Count)
										{
											pe.Graphics.DrawImage(ImagesList.Images[subItemByID.ImageIndex], new Rectangle(num2 - HscrollOffset + 2, i * itemHeight - num7 + columnHeight + 1, itemHeight - 1, itemHeight - 1));
										}
										break;
									case ManagedListViewItemDrawMode.TextAndImage:
									{
										int num11 = 2;
										if (subItemByID.ImageIndex < ImagesList.Images.Count)
										{
											pe.Graphics.DrawImage(ImagesList.Images[subItemByID.ImageIndex], new Rectangle(num2 - HscrollOffset + 2, i * itemHeight - num7 + columnHeight + 1, itemHeight - 1, itemHeight - 1));
											num11 += itemHeight;
										}
										pe.Graphics.DrawString(subItemByID.Text, font, new SolidBrush(color), new Rectangle(num2 - HscrollOffset + 2 + num11, i * itemHeight - num7 + columnHeight + num5, column.Width - num11, size.Height), _StringFormat);
										break;
									}
									case ManagedListViewItemDrawMode.UserDraw:
										if (this.DrawSubItem != null)
										{
											ManagedListViewSubItemDrawArgs managedListViewSubItemDrawArgs = new ManagedListViewSubItemDrawArgs(column.ID, num8, items[num8]);
											this.DrawSubItem(this, managedListViewSubItemDrawArgs);
											int num10 = 2;
											if (managedListViewSubItemDrawArgs.ImageToDraw != null)
											{
												pe.Graphics.DrawImage(managedListViewSubItemDrawArgs.ImageToDraw, new Rectangle(num2 - HscrollOffset + 2, i * itemHeight - num7 + columnHeight + 1, itemHeight - 1, itemHeight - 1));
												num10 += itemHeight;
											}
											pe.Graphics.DrawString(managedListViewSubItemDrawArgs.TextToDraw, font, new SolidBrush(color), new Rectangle(num2 - HscrollOffset + 2 + num10, i * itemHeight - num7 + columnHeight + num5, column.Width - num10, size.Height), _StringFormat);
										}
										break;
									}
								}
							}
						}
						num8++;
					}
					if (flag)
					{
						flag = false;
						num2 = 0;
					}
				}
				Color color2 = ColumnColor;
				if (highlightSelectedColumn && selectedColumnIndex == num3)
				{
					color2 = ((!isMouseDown) ? ColumnHighlightColor : ((moveType == ManagedListViewMoveType.ColumnVLine) ? ColumnHighlightColor : ColumnClickColor));
				}
				pe.Graphics.FillRectangle(new LinearGradientBrush(default(Point), new Point(0, columnHeight), color2, Color.White), new Rectangle(num2 - HscrollOffset + 1, 1, column.Width, columnHeight));
				pe.Graphics.DrawLine(new Pen(Brushes.LightGray), new Point(num - HscrollOffset, 1), new Point(num - HscrollOffset, base.Height - 1));
				pe.Graphics.DrawString(column.HeaderText, Font, new SolidBrush(column.HeaderTextColor), new Rectangle(num2 - HscrollOffset + 2, num4, column.Width, columnHeight), _StringFormat);
				if (this.DrawColumn != null)
				{
					this.DrawColumn(this, new ManagedListViewColumnDrawArgs(column.ID, pe.Graphics, new Rectangle(num2 - HscrollOffset, 2, column.Width, columnHeight)));
				}
				switch (column.SortMode)
				{
				case ManagedListViewSortMode.AtoZ:
					pe.Graphics.DrawImage(Resources.SortAlpha.ToBitmap(), new Rectangle(num2 - HscrollOffset + column.Width - 14, 2, 12, 16));
					break;
				case ManagedListViewSortMode.ZtoA:
					pe.Graphics.DrawImage(Resources.SortZ.ToBitmap(), new Rectangle(num2 - HscrollOffset + column.Width - 14, 2, 12, 16));
					break;
				}
			}
			num2 += column.Width;
			num3++;
			if (num2 - HscrollOffset > base.Width)
			{
				break;
			}
		}
		if (columns.Count > 0)
		{
			pe.Graphics.DrawLine(new Pen(new SolidBrush(Color.Gray)), new Point(0, columnHeight), new Point(base.Width, columnHeight));
		}
		if (isMovingColumn)
		{
			pe.Graphics.FillRectangle(new LinearGradientBrush(default(Point), new Point(0, columnHeight), Color.White, Color.Silver), new Rectangle(CurrentMousePosition.X, 1, columns[selectedColumnIndex].Width, columnHeight));
			pe.Graphics.DrawLine(new Pen(Brushes.LightGray), new Point(num - HscrollOffset, 1), new Point(num - HscrollOffset, base.Height - 1));
			pe.Graphics.DrawString(columns[selectedColumnIndex].HeaderText, Font, new SolidBrush(columns[selectedColumnIndex].HeaderTextColor), new Rectangle(CurrentMousePosition.X, 2, columns[selectedColumnIndex].Width, columnHeight), _StringFormat);
		}
	}

	private void DrawThumbailsView(PaintEventArgs pe)
	{
		thumb_tooltip = null;
		itemTextHeight = TextRenderer.MeasureText("TEST", Font).Height * 2;
		string text = "";
		StringFormat stringFormat = new StringFormat();
		stringFormat.Alignment = StringAlignment.Center;
		stringFormat.Trimming = StringTrimming.EllipsisCharacter;
		int num = base.Height / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
		int num2 = base.Width / (spaceBetweenItemsThunmbailsView + ThumbnailsWidth);
		if (num2 == 0)
		{
			num2 = 1;
		}
		int num3 = VscrollOffset / (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight) * num2;
		if (num3 >= items.Count)
		{
			return;
		}
		int num4 = 2;
		for (int i = 0; i < num + 2; i++)
		{
			int num5 = spaceBetweenItemsThunmbailsView;
			for (int j = 0; j < num2; j++)
			{
				int num6 = VscrollOffset % (spaceBetweenItemsThunmbailsView + ThumbnailsHeight + itemTextHeight);
				if (highlightItemAsOver && num3 == overItemSelectedIndex)
				{
					pe.Graphics.FillRectangle(new SolidBrush(ItemMouseOverColor), new Rectangle(num5 - 2, num4 - num6 - 2, ThumbnailsWidth + 4, ThumbnailsHeight + itemTextHeight + 4));
				}
				if (items[num3].Selected)
				{
					pe.Graphics.FillRectangle(new SolidBrush(ItemHighlightColor), new Rectangle(num5 - 2, num4 - num6 - 2, ThumbnailsWidth + 4, ThumbnailsHeight + itemTextHeight + 4));
				}
				string text2 = "";
				Image image = null;
				switch (items[num3].DrawMode)
				{
				case ManagedListViewItemDrawMode.Text:
				case ManagedListViewItemDrawMode.Image:
				case ManagedListViewItemDrawMode.TextAndImage:
					if (items[num3].ImageIndex < ImagesList.Images.Count)
					{
						image = ImagesList.Images[items[num3].ImageIndex];
					}
					text2 = items[num3].Text;
					break;
				case ManagedListViewItemDrawMode.UserDraw:
				{
					ManagedListViewItemDrawArgs managedListViewItemDrawArgs = new ManagedListViewItemDrawArgs(num3);
					if (this.DrawItem != null)
					{
						this.DrawItem(this, managedListViewItemDrawArgs);
					}
					image = managedListViewItemDrawArgs.ImageToDraw;
					text2 = managedListViewItemDrawArgs.TextToDraw;
					break;
				}
				}
				text = text2;
				if (image != null)
				{
					Size size = (ThumbnailsKeepImageSize ? CalculateStretchImageValuesStretch(image.Width, image.Height) : CalculateStretchImageValues(image.Width, image.Height));
					int num7 = num5 + ThumbnailsWidth / 2 - size.Width / 2;
					int num8 = num4 - num6 + ThumbnailsHeight / 2 - size.Height / 2;
					pe.Graphics.DrawImage(image, new Rectangle(num7, num8, size.Width, size.Height));
				}
				pe.Graphics.DrawString(text2, Font, new SolidBrush(items[num3].Color), new Rectangle(num5, num4 + ThumbnailsHeight + 1 - num6, ThumbnailsWidth, itemTextHeight), stringFormat);
				if (num3 == overItemSelectedIndex)
				{
					Size size2 = TextRenderer.MeasureText(text, Font);
					int num9 = size2.Width + 8;
					if (num9 >= base.Width)
					{
						num9 = base.Width - 1;
					}
					if (ShowItemInfoOnThumbnailMode)
					{
						thumb_tooltip = new ManagedListViewShowThumbnailTooltipArgs(num3, text, new Rectangle(num5, num4 + ThumbnailsHeight + 1 - num6, num9, size2.Height + 1));
						if (this.ShowThumbnailInfoRequest != null)
						{
							this.ShowThumbnailInfoRequest(this, thumb_tooltip);
							text = thumb_tooltip.TextToShow;
							int rating = thumb_tooltip.Rating;
							size2 = TextRenderer.MeasureText(text, Font);
							num9 = size2.Width + 8;
							if (num9 >= base.Width)
							{
								num9 = base.Width - 1;
							}
							thumb_tooltip = new ManagedListViewShowThumbnailTooltipArgs(num3, text, rating, new Rectangle(num5, num4 + ThumbnailsHeight + 1 - num6, num9, size2.Height + 1));
						}
					}
					if (this.ShowThumbnailTooltipRequest != null)
					{
						this.ShowThumbnailTooltipRequest(this, new ManagedListViewShowThumbnailTooltipArgs(num3, text, new Rectangle(num5, num4 + ThumbnailsHeight + 1 - num6, size2.Width, itemTextHeight)));
					}
				}
				num5 += ThumbnailsWidth + spaceBetweenItemsThunmbailsView;
				num3++;
				if (num3 == items.Count)
				{
					break;
				}
			}
			num4 += ThumbnailsHeight + itemTextHeight + spaceBetweenItemsThunmbailsView;
			if (num3 == items.Count)
			{
				break;
			}
		}
		if (thumb_tooltip != null)
		{
			if (!ShowItemInfoOnThumbnailMode)
			{
				return;
			}
			int num10 = thumb_tooltip.TextThumbnailRectangle.Width;
			int num11 = thumb_tooltip.TextThumbnailRectangle.Height;
			if (thumb_tooltip.Rating != -1)
			{
				num11 += 20;
			}
			int num12 = 1;
			int num13 = base.Height - num11 + 1;
			pe.Graphics.FillRectangle(new SolidBrush(ItemMouseOverColor), num12, num13, num10, num11);
			pe.Graphics.DrawRectangle(Pens.Gray, num12, num13, num10, num11 - 2);
			stringFormat.Alignment = StringAlignment.Near;
			pe.Graphics.DrawString(thumb_tooltip.TextToShow, Font, new SolidBrush(Color.Black), new Rectangle(num12 + 1, num13, num10, (thumb_tooltip.Rating != -1) ? (num11 - 20) : num11), stringFormat);
			if (thumb_tooltip.Rating != -1)
			{
				switch (thumb_tooltip.Rating)
				{
				case 0:
					pe.Graphics.DrawImage(Resources.noneRating, num12 + 1, base.Height - 20, 58, 18);
					break;
				case 1:
					pe.Graphics.DrawImage(Resources.star_1, num12 + 1, base.Height - 20, 58, 18);
					break;
				case 2:
					pe.Graphics.DrawImage(Resources.star_2, num12 + 1, base.Height - 20, 58, 18);
					break;
				case 3:
					pe.Graphics.DrawImage(Resources.star_3, num12 + 1, base.Height - 20, 58, 18);
					break;
				case 4:
					pe.Graphics.DrawImage(Resources.star_4, num12 + 1, base.Height - 20, 58, 18);
					break;
				case 5:
					pe.Graphics.DrawImage(Resources.star_5, num12 + 1, base.Height - 20, 58, 18);
					break;
				}
			}
		}
		else if (this.HideThumbnailTooltipRequest != null)
		{
			this.HideThumbnailTooltipRequest(this, new EventArgs());
		}
	}

	private Size CalculateStretchImageValues(int imgW, int imgH)
	{
		float num = (float)ThumbnailsWidth / (float)ThumbnailsHeight;
		float num2 = (float)imgW / (float)imgH;
		int num3 = 0;
		int num4 = 0;
		if (ThumbnailsWidth >= imgW && ThumbnailsHeight >= imgH)
		{
			num3 = imgW;
			num4 = imgH;
		}
		else if (ThumbnailsWidth > imgW && ThumbnailsHeight < imgH)
		{
			num4 = ThumbnailsHeight;
			num3 = (int)((float)ThumbnailsHeight * num2);
		}
		else if (ThumbnailsWidth < imgW && ThumbnailsHeight > imgH)
		{
			num3 = ThumbnailsWidth;
			num4 = (int)((float)ThumbnailsWidth / num2);
		}
		else if (ThumbnailsWidth < imgW && ThumbnailsHeight < imgH)
		{
			if (ThumbnailsWidth >= ThumbnailsHeight)
			{
				if (imgW >= imgH && num2 >= num)
				{
					num3 = ThumbnailsWidth;
					num4 = (int)((float)ThumbnailsWidth / num2);
				}
				else
				{
					num4 = ThumbnailsHeight;
					num3 = (int)((float)ThumbnailsHeight * num2);
				}
			}
			else if (imgW < imgH && num2 < num)
			{
				num4 = ThumbnailsHeight;
				num3 = (int)((float)ThumbnailsHeight * num2);
			}
			else
			{
				num3 = ThumbnailsWidth;
				num4 = (int)((float)ThumbnailsWidth / num2);
			}
		}
		return new Size(num3, num4);
	}

	private Size CalculateStretchImageValuesStretch(int imgW, int imgH)
	{
		float num = (float)ThumbnailsWidth / (float)ThumbnailsHeight;
		float num2 = (float)imgW / (float)imgH;
		int num3 = 0;
		int num4 = 0;
		if (ThumbnailsWidth >= imgW && ThumbnailsHeight >= imgH)
		{
			if (ThumbnailsWidth >= ThumbnailsHeight)
			{
				if (imgW >= imgH && num2 >= num)
				{
					num3 = ThumbnailsWidth;
					num4 = (int)((float)ThumbnailsWidth / num2);
				}
				else
				{
					num4 = ThumbnailsHeight;
					num3 = (int)((float)ThumbnailsWidth * num2);
				}
			}
			else if (imgW < imgH && num2 < num)
			{
				num4 = ThumbnailsHeight;
				num3 = (int)((float)ThumbnailsHeight * num2);
			}
			else
			{
				num3 = ThumbnailsWidth;
				num4 = (int)((float)base.Width / num2);
			}
		}
		else if (ThumbnailsWidth > imgW && ThumbnailsHeight < imgH)
		{
			num4 = ThumbnailsHeight;
			num3 = (int)((float)ThumbnailsHeight * num2);
		}
		else if (ThumbnailsWidth < imgW && ThumbnailsHeight > imgH)
		{
			num3 = ThumbnailsWidth;
			num4 = (int)((float)ThumbnailsWidth / num2);
		}
		else if (ThumbnailsWidth < imgW && ThumbnailsHeight < imgH)
		{
			if (ThumbnailsWidth >= ThumbnailsHeight)
			{
				if (imgW >= imgH && num2 >= num)
				{
					num3 = ThumbnailsWidth;
					num4 = (int)((float)ThumbnailsWidth / num2);
				}
				else
				{
					num4 = ThumbnailsHeight;
					num3 = (int)((float)ThumbnailsHeight * num2);
				}
			}
			else if (imgW < imgH && num2 < num)
			{
				num4 = ThumbnailsHeight;
				num3 = (int)((float)ThumbnailsHeight * num2);
			}
			else
			{
				num3 = ThumbnailsWidth;
				num4 = (int)((float)ThumbnailsWidth / num2);
			}
		}
		return new Size(num3, num4);
	}

	private void CalculateBKGStretchedImageValues()
	{
		float num = (float)base.Width / (float)base.Height;
		float num2 = (float)BackgroundImage.Width / (float)BackgroundImage.Height;
		if (base.Width >= BackgroundImage.Width && base.Height >= BackgroundImage.Height)
		{
			backgroundDrawW = BackgroundImage.Width;
			backgroundDrawH = BackgroundImage.Height;
		}
		else if (base.Width > BackgroundImage.Width && base.Height < BackgroundImage.Height)
		{
			backgroundDrawH = base.Height;
			backgroundDrawW = (int)((float)base.Height * num2);
		}
		else if (base.Width < BackgroundImage.Width && base.Height > BackgroundImage.Height)
		{
			backgroundDrawW = base.Width;
			backgroundDrawH = (int)((float)base.Width / num2);
		}
		else
		{
			if (base.Width >= BackgroundImage.Width || base.Height >= BackgroundImage.Height)
			{
				return;
			}
			if (base.Width >= base.Height)
			{
				if (BackgroundImage.Width >= BackgroundImage.Height && num2 >= num)
				{
					backgroundDrawW = base.Width;
					backgroundDrawH = (int)((float)base.Width / num2);
				}
				else
				{
					backgroundDrawH = base.Height;
					backgroundDrawW = (int)((float)base.Height * num2);
				}
			}
			else if (BackgroundImage.Width < BackgroundImage.Height && num2 < num)
			{
				backgroundDrawH = base.Height;
				backgroundDrawW = (int)((float)base.Height * num2);
			}
			else
			{
				backgroundDrawW = base.Width;
				backgroundDrawH = (int)((float)base.Width / num2);
			}
		}
	}

	private void CalculateBKGStretchToFitImageValues()
	{
		float num = (float)base.Width / (float)base.Height;
		float num2 = (float)BackgroundImage.Width / (float)BackgroundImage.Height;
		if (base.Width >= BackgroundImage.Width && base.Height >= BackgroundImage.Height)
		{
			if (base.Width >= base.Height)
			{
				if (BackgroundImage.Width >= BackgroundImage.Height && num2 >= num)
				{
					backgroundDrawW = base.Width;
					backgroundDrawH = (int)((float)base.Width / num2);
				}
				else
				{
					backgroundDrawH = base.Height;
					backgroundDrawW = (int)((float)base.Height * num2);
				}
			}
			else if (BackgroundImage.Width < BackgroundImage.Height && num2 < num)
			{
				backgroundDrawH = base.Height;
				backgroundDrawW = (int)((float)base.Height * num2);
			}
			else
			{
				backgroundDrawW = base.Width;
				backgroundDrawH = (int)((float)base.Width / num2);
			}
		}
		else if (base.Width > BackgroundImage.Width && base.Height < BackgroundImage.Height)
		{
			backgroundDrawH = base.Height;
			backgroundDrawW = (int)((float)base.Height * num2);
		}
		else if (base.Width < BackgroundImage.Width && base.Height > BackgroundImage.Height)
		{
			backgroundDrawW = base.Width;
			backgroundDrawH = (int)((float)base.Width / num2);
		}
		else
		{
			if (base.Width >= BackgroundImage.Width || base.Height >= BackgroundImage.Height)
			{
				return;
			}
			if (base.Width >= base.Height)
			{
				if (BackgroundImage.Width >= BackgroundImage.Height && num2 >= num)
				{
					backgroundDrawW = base.Width;
					backgroundDrawH = (int)((float)base.Width / num2);
				}
				else
				{
					backgroundDrawH = base.Height;
					backgroundDrawW = (int)((float)base.Height * num2);
				}
			}
			else if (BackgroundImage.Width < BackgroundImage.Height && num2 < num)
			{
				backgroundDrawH = base.Height;
				backgroundDrawW = (int)((float)base.Height * num2);
			}
			else
			{
				backgroundDrawW = base.Width;
				backgroundDrawH = (int)((float)base.Width / num2);
			}
		}
	}

	private void CenterBKGImage()
	{
		backgroundDrawY = (int)((double)(base.Height - backgroundDrawH) / 2.0);
		backgroundDrawX = (int)((double)(base.Width - backgroundDrawW) / 2.0);
	}

	private void OnReverseHScrollRequest()
	{
		if (this.ReverseHScrollRequest != null)
		{
			this.ReverseHScrollRequest(this, new EventArgs());
		}
	}

	private void OnAdvanceHScrollRequest()
	{
		if (this.AdvanceHScrollRequest != null)
		{
			this.AdvanceHScrollRequest(this, new EventArgs());
		}
	}

	protected override void WndProc(ref Message m)
	{
		base.WndProc(ref m);
		if (m.Msg == 257)
		{
			OnKeyDownRaised(new KeyEventArgs((Keys)(int)m.WParam));
		}
	}

	protected override void Dispose(bool disposing)
	{
		if (disposing && components != null)
		{
			components.Dispose();
		}
		base.Dispose(disposing);
	}

	private void InitializeComponent()
	{
		this.components = new System.ComponentModel.Container();
	}
}