2200 lines
63 KiB
C#
2200 lines
63 KiB
C#
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();
|
|
}
|
|
}
|