winamp/Src/Plugins/General/gen_ml/HeaderIconList.cpp

#include "main.h"

#include "../gen_ml/ml.h"
#include "../gen_ml/ml_ipc_0313.h"
#include "../Winamp/gen.h"

#define WM_EX_GETREALLIST		(WM_USER + 0x01)
#define WM_EX_UNLOCKREDRAW		(WM_USER + 0x02)
#define WM_EX_UPDATESCROLLINFO	(WM_USER + 0x03)
#define WM_EX_GETCOUNTPERPAGE	(WM_USER + 0x04)

#define LVN_EX_SIZECHANGED		(LVN_LAST)

#define IWF_NO				0x0000
#define IWF_ALL				0x00FF
#define IWF_CONTAINER		0x0001
#define IWF_LISTVIEW			0x0002
#define IWF_HEADER			0x0004
#define IWF_UPDATENOW		0x1000

BOOL
CopyListColumnToHeaderItem(const LVCOLUMNW *column, HDITEMW *item)
{
	if (NULL == column || NULL == item)
		return FALSE;

	item->mask = 0;
	if (0 != (LVCF_FMT & column->mask))
	{
		item->mask |= HDI_FORMAT;
		item->fmt = 0;

		switch((LVCFMT_JUSTIFYMASK & column->fmt))
		{
			case LVCFMT_RIGHT:
				item->fmt |= HDF_RIGHT;
				break;
			case LVCFMT_CENTER:
				item->fmt |= HDF_CENTER;
				break;
			default:
				item->fmt |= HDF_LEFT;
				break;
		}

		if (0 != (LVCFMT_IMAGE & column->fmt))
			item->fmt |= HDF_IMAGE;

		if (0 != (LVCFMT_BITMAP_ON_RIGHT & column->fmt))
			item->fmt |= HDF_BITMAP_ON_RIGHT;
	}
				
	if (0 != (LVCF_WIDTH & column->mask))
	{
		item->mask |= HDI_WIDTH;
		item->cxy = column->cx;
	}

	if (0 != (LVCF_TEXT & column->mask))
	{
		item->mask |= HDI_TEXT;
		item->pszText = column->pszText;
		item->cchTextMax = column->cchTextMax;
	}

	if (0 != (LVCF_IMAGE & column->mask))
	{
		item->mask |= HDI_IMAGE;
		item->iImage = column->iImage;
	}

	if (0 != (LVCF_ORDER & column->mask))
	{
		item->mask |= HDI_ORDER;
		item->iOrder = column->iOrder;
	}

	return TRUE;
}

BOOL
CopyHeaderItemToListColumn(const HDITEMW *item, LVCOLUMNW *column)
{
	if (NULL == column || NULL == item)
		return FALSE;

	column->mask = 0;
	if (0 != (HDI_FORMAT& item->mask))
	{
		column->mask |= LVCF_FMT ;
		column->fmt = 0;

		switch((HDF_JUSTIFYMASK & item->fmt))
		{
			case HDF_RIGHT:
				column->fmt |= LVCFMT_RIGHT;
				break;
			case HDF_CENTER:
				column->fmt |= LVCFMT_CENTER;
				break;
			default:
				column->fmt |= LVCFMT_LEFT;
				break;
		}

		if (0 != (HDF_IMAGE & item->fmt))
			column->fmt |= LVCFMT_IMAGE;

		if (0 != (HDF_BITMAP_ON_RIGHT & item->fmt))
			column->fmt |= LVCFMT_BITMAP_ON_RIGHT;
	}
				
	if (0 != (HDI_WIDTH & item->mask))
	{
		column->mask |= LVCF_WIDTH;
		column->cx = item->cxy;
	}

	if (0 != (HDI_TEXT & item->mask))
	{
		column->mask |= LVCF_TEXT;
		column->pszText = item->pszText;
		column->cchTextMax = item->cchTextMax;
	}

	if (0 != (HDI_IMAGE & item->mask))
	{
		column->mask |= LVCF_IMAGE;
		column->iImage = item->iImage;
	}

	if (0 != (HDI_ORDER & item->mask))
	{
		column->mask |= LVCF_ORDER;
		column->iOrder = item->iOrder;
	}

	return TRUE;
}

static BOOL UpdateScrollInfo(HWND hwnd, UINT fMask, BOOL bRedraw) 
{
	HWND hwndList;
	SCROLLINFO si;
	BOOL bUpdateBars(FALSE);

	hwndList = GetDlgItem(hwnd,2);

	si.cbSize= sizeof(SCROLLINFO);
	si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;

	if (!hwndList || !GetScrollInfo(hwnd, SB_VERT, &si)) 
		return FALSE;

	if (SIF_RANGE & fMask)
	{
		RECT rc, rv;
	
		UINT nPage;
		INT nMax;
		BOOL bScrollVisible;
		HDLAYOUT headerLayout;
		WINDOWPOS headerPos;

		HWND hwndHeader = GetDlgItem(hwnd, 3);
		if (!hwndHeader) 
			return FALSE;

		GetClientRect(hwnd, &rc);
		ListView_GetViewRect(hwndList,&rv);
	
		headerLayout.prc = &rc;
		headerLayout.pwpos = &headerPos;
					
		SendMessageW(hwndHeader, HDM_LAYOUT, 0, (LPARAM)&headerLayout);
		
		bScrollVisible = (si.nMax > 0 && si.nPage > 0 && (INT)si.nPage < si.nMax);
        
		nMax = rv.bottom - rv.top;
		nPage = (rc.bottom - rc.top);

		if (si.nMax != nMax || si.nPage != nPage)
		{
			si.nMin = 0;
			si.nMax = nMax;
			si.nPage = nPage;
			SetScrollInfo(hwnd, SB_VERT, &si, FALSE);
			bUpdateBars = TRUE;
			if (bScrollVisible != (si.nMax > 0 && si.nPage > 0 && (INT)si.nPage < si.nMax))
			{
				MLSkinnedScrollWnd_UpdateBars(hwnd, bRedraw);
				GetClientRect(hwnd, &rc);

				headerLayout.prc = &rc;
				headerLayout.pwpos = &headerPos;
					
				SendMessageW(hwndHeader, HDM_LAYOUT, 0, (LPARAM)&headerLayout);

				headerPos.flags |= SWP_NOREDRAW;
				SetWindowPos(hwndHeader, headerPos.hwndInsertAfter, headerPos.x, headerPos.y, 
						headerPos.cx, headerPos.cy, headerPos.flags);
				
				SetWindowPos(hwndList, NULL, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, 
						SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE | SWP_NOREDRAW);

				if (FALSE != bRedraw)
					RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN);

				bUpdateBars = FALSE;
			}
		}
		
	}

	if (SIF_POS & fMask)
	{
		POINT p;
		if (FALSE != SendMessageW(hwndList, LVM_GETORIGIN, (WPARAM)0, (LPARAM)&p))
		{
			if (p.y < si.nMin)
				p.y = si.nMin;
			
			if (p.y > (si.nMax - (int)si.nPage))
				p.y = si.nMax - si.nPage;
			
			if (p.y != si.nPos)
			{
				si.nPos = p.y;
				si.fMask = SIF_POS;
				SetScrollInfo(hwnd, SB_VERT, &si, TRUE);
				bUpdateBars = TRUE;
			}
		}
	}
	if (bUpdateBars) 
		MLSkinnedScrollWnd_UpdateBars(hwnd, bRedraw);

	return TRUE;
}

static void
UpdateFontMetrics(HWND hwnd, BOOL redraw)
{
	HWND controlWindow;
	RECT headerRect;
	unsigned int windowStyle;


	windowStyle = GetWindowLongPtr(hwnd, GWL_STYLE);
	if(0 != (WS_VISIBLE & windowStyle))
		SetWindowLongPtrW(hwnd, GWL_STYLE, windowStyle & ~WS_VISIBLE);

	
	controlWindow = GetDlgItem(hwnd, 3);
	if (NULL != controlWindow)
	{	
		MLSkinnedHeader_SetHeight(controlWindow, -1);
		if (FALSE == GetWindowRect(controlWindow, &headerRect))
			SetRectEmpty(&headerRect);
	}
	else
		SetRectEmpty(&headerRect);


	controlWindow = GetDlgItem(hwnd, 2);
	if (NULL != controlWindow)
	{
		
		RECT rect;
		if (FALSE != GetClientRect(hwnd, &rect))
		{
			SetWindowPos(controlWindow, NULL, 
						 rect.left, rect.top + headerRect.bottom - headerRect.top, 
 						 rect.right - rect.left, (rect.bottom - rect.top) - (headerRect.bottom - headerRect.top), 
						 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW | SWP_NOCOPYBITS);  
		}
	}

	
	if (0 != (WS_VISIBLE & windowStyle))
	{
		windowStyle = GetWindowLongPtr(hwnd, GWL_STYLE);
		if (0 == (WS_VISIBLE & windowStyle))
		{
			windowStyle |= WS_VISIBLE;
			SetWindowLongPtrW(hwnd, GWL_STYLE, windowStyle);
		}

		if (FALSE != redraw)
			RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN);
	}
}

static HHOOK hook = NULL;
static HWND hwndToMonitor = NULL;

typedef struct UpdateSelection
{
	BOOL active;
	int iFrom;
	int iTo;
}UpdateSelection;


typedef struct ListViewData
{
	WNDPROC prevWindowProc;
	UpdateSelection updateSelection;
} ListViewData;

#define LVCWP_NORMAL			0
#define LVCWP_UPDATESCROLLINFO	(1 << 0)

static LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam)
{
	MSG *pMsg = (MSG*)lParam;
	if (pMsg->hwnd == hwndToMonitor)
	{
		switch(pMsg->message)
		{
			case WM_LBUTTONUP:
			case WM_RBUTTONUP:
				{
					LRESULT result = CallNextHookEx(hook, nCode, wParam, lParam);
					UnhookWindowsHookEx(hook);
					hwndToMonitor = NULL;
					hook = NULL;
					return result;
				}
			case WM_MOUSEMOVE:
				if ((MK_LBUTTON | MK_RBUTTON) & pMsg->wParam)
				{
					RECT rw;
					POINTS pts(MAKEPOINTS(pMsg->lParam));
					POINT pt; 
					POINTSTOPOINT(pt, pts);
					MapWindowPoints(pMsg->hwnd, HWND_DESKTOP, &pt, 1);
					GetWindowRect(pMsg->hwnd, &rw);
					if (pt.y < rw.top || pt.y > rw.bottom)
					{
						HWND hwndParent = GetParent(pMsg->hwnd);
						if (hwndParent)
						{
							SCROLLINFO si;
							si.cbSize = sizeof(SCROLLINFO);
							si.fMask = SIF_RANGE | SIF_POS | SIF_PAGE;
							if (GetScrollInfo(hwndParent, SB_VERT, &si))
							{
								if ((si.nPos > si.nMin && pt.y < rw.top) || (si.nPos < (si.nMax - (INT)si.nPage) && pt.y > rw.bottom))
								{
									SendMessageW(hwndParent, WM_SETREDRAW, FALSE, 0L);
									LRESULT result = CallNextHookEx(hook, nCode, wParam, lParam);
									PostMessageW(hwndParent, WM_EX_UPDATESCROLLINFO, SIF_POS, FALSE);
									PostMessageW(hwndParent, WM_EX_UNLOCKREDRAW, IWF_CONTAINER | IWF_LISTVIEW | IWF_UPDATENOW, 0L);
									return result;
								}
							}
						}
					}
					SleepEx(1, TRUE);
				}
				break;
		}
	}
	return CallNextHookEx(hook, nCode, wParam, lParam);
}
static void
ListView_ScheduleSelectionUpdate(HWND hwnd, int iFrom, int iTo)
{
	ListViewData *listView;
	listView = (ListViewData*)(LONG_PTR)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
	if (NULL == listView)
		return;

	listView->updateSelection.iFrom = iFrom;
	listView->updateSelection.iTo = iTo;
	listView->updateSelection.active = TRUE;
}

static void
ListView_UpdateSelection(HWND hwnd, int iFrom, int iTo)
{
	HWND parentWindow;
	LVITEM item;
	int start, stop, i, lim;
	
	start = (int)SendMessageW(hwnd, LVM_GETSELECTIONMARK, 0, 0L);
	stop = (int)SendMessageW(hwnd, LVM_GETNEXTITEM, iFrom - 1, LVNI_FOCUSED);
	if (stop < start)
	{
		int tmp = start;
		start = stop;
		stop = tmp;
	}
					
	item.state = 0;
	item.stateMask = LVIS_SELECTED;

	if (start != iFrom)
	{
		if (start < iFrom) 
		{
			i = start; 
			lim = iFrom;
		}
		else 
		{
			i = iFrom; 
			lim = start; 
		}

		i--;
		for(;;)
		{
			i = (int)SendMessageW(hwnd, LVM_GETNEXTITEM, (WPARAM)i, 
								 (LPARAM)(LVNI_ALL | LVNI_SELECTED));
			if (-1 == i || i >= lim)
				break;
			
			SendMessageW(hwnd, LVM_SETITEMSTATE, i, (LPARAM)&item);
		}
	}
	if (stop < iTo)  
	{
		i = stop + 1; 
		lim = iTo; 

		i--;
		for(;;)
		{
			i = (int)SendMessageW(hwnd, LVM_GETNEXTITEM, (WPARAM)i, 
								 (LPARAM)(LVNI_ALL | LVNI_SELECTED));
			if (-1 == i || i > lim)
				break;
			
			SendMessageW(hwnd, LVM_SETITEMSTATE, i, (LPARAM)&item);
		}
	}

	parentWindow = GetAncestor(hwnd, GA_PARENT);
	if (NULL != parentWindow)
	{
		HWND notifyWindow;
		
		SendMessageW(parentWindow, WM_SETREDRAW, TRUE, 0L);
		RedrawWindow(parentWindow, NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN);
		
		notifyWindow =  GetAncestor(parentWindow, GA_PARENT);
		if (NULL != notifyWindow)
		{
			NMLVODSTATECHANGE stateChange;
			stateChange.hdr.idFrom = GetWindowLongPtrW(parentWindow, GWLP_ID);
			stateChange.hdr.hwndFrom = parentWindow;
			stateChange.hdr.code = LVN_ODSTATECHANGED;
			stateChange.iFrom = start;
			stateChange.iTo = stop;
			stateChange.uNewState = LVIS_SELECTED;
			stateChange.uOldState = 0;
			SendMessageW(notifyWindow, WM_NOTIFY, stateChange.hdr.idFrom, (LPARAM)&stateChange);
		}
	}
}
static LRESULT
ListView_CallWindowProc(ListViewData *listView, HWND hwnd, unsigned int uMsg, WPARAM wParam, LPARAM lParam,
						unsigned int flags)
{
	LRESULT result;
	
	result = CallWindowProcW(listView->prevWindowProc, hwnd, uMsg, wParam, lParam);
	
	if (FALSE != listView->updateSelection.active)
	{
		listView->updateSelection.active = FALSE;
		ListView_UpdateSelection(hwnd, listView->updateSelection.iFrom, listView->updateSelection.iTo);
	}

	if (0 != (LVCWP_UPDATESCROLLINFO & flags))
	{
		HWND hwndParent;
		hwndParent = GetAncestor(hwnd, GA_PARENT);
		if (NULL != hwndParent)
			UpdateScrollInfo(hwndParent, SIF_POS, TRUE);
	}
	
	return result;	
}

static LRESULT WINAPI 
ListView_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	ListViewData *listView;
	listView = (ListViewData*)(LONG_PTR)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
	
	if (NULL == listView || 
		NULL == listView->prevWindowProc)
	{
		return DefWindowProcW(hwnd, uMsg, wParam, lParam);
	}
	
	switch(uMsg)
	{
		case WM_DESTROY:
			SetWindowLongPtrW(hwnd, GWLP_USERDATA, NULL);
			CallWindowProcW(listView->prevWindowProc, hwnd, uMsg, wParam, lParam);
			free(listView);
			return 0;
		case WM_KEYDOWN:
			switch(wParam)
			{
				case VK_PRIOR:
				case VK_UP:
				case VK_HOME:
				case VK_NEXT:
				case VK_END:
				case VK_DOWN:
				case VK_LEFT:
				case VK_RIGHT:
					return ListView_CallWindowProc(listView, hwnd, uMsg, wParam, lParam, LVCWP_UPDATESCROLLINFO);
			}
			break;
		case WM_TIMER:
			if (43 == wParam) 
				return ListView_CallWindowProc(listView, hwnd, uMsg, wParam, lParam, LVCWP_UPDATESCROLLINFO);
			break;
		case WM_HSCROLL:
		case WM_VSCROLL:
		case WM_MOUSEWHEEL: 
		case LVM_ENSUREVISIBLE:
			return ListView_CallWindowProc(listView, hwnd, uMsg, wParam, lParam, LVCWP_UPDATESCROLLINFO);
		case WM_LBUTTONDOWN:
		case WM_RBUTTONDOWN:
			{
				LVHITTESTINFO ht;
				ht.pt.x = GET_X_LPARAM(lParam);
				ht.pt.y = GET_Y_LPARAM(lParam);
				if (-1 == SendMessageW(hwnd, LVM_HITTEST, 0, (LPARAM)&ht) || 0 == (LVHT_ONITEM  & ht.flags))
				{
					hwndToMonitor = hwnd;
					hook = SetWindowsHookEx(WH_MSGFILTER, HookProc, NULL, GetCurrentThreadId()); 
				}
			}
			break;
	}

	return ListView_CallWindowProc(listView, hwnd, uMsg, wParam, lParam, LVCWP_NORMAL);
}


static LRESULT
HeaderIconList_OnCreate(HWND hwnd, CREATESTRUCT *createStruct)
{
	HWND hwndList, hwndHeader;
	MLSKINWINDOW m;
	RECT rc;
	DWORD style;

	m.skinType = SKINNEDWND_TYPE_SCROLLWND;
	m.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS;
	m.hwndToSkin = hwnd;
	MLSkinWindow(g_hwnd, &m);
	
	SetScrollRange(hwnd, SB_VERT, 0, 0, FALSE);
	MLSkinnedScrollWnd_UpdateBars(hwnd, FALSE);

	GetClientRect(hwnd, &rc);

	style = WS_CLIPSIBLINGS | WS_CHILD | WS_VISIBLE | HDS_BUTTONS | HDS_FULLDRAG;
	hwndHeader = CreateWindowExW(WS_EX_NOPARENTNOTIFY, WC_HEADERW, L"", style, 0, 0, rc.right - rc.left, 20, hwnd, (HMENU)3,0,0);
	if (NULL != hwndHeader)
	{
		m.hwndToSkin = hwndHeader;
		m.skinType = SKINNEDWND_TYPE_HEADER;
		m.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS;
		MLSkinWindow(g_hwnd, &m);
	}
	
	style = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_CHILD | WS_TABSTOP | WS_VISIBLE |
					 LVS_ICON | LVS_SHOWSELALWAYS | LVS_OWNERDATA | LVS_NOLABELWRAP;
	
	hwndList = CreateWindowExW(WS_EX_NOPARENTNOTIFY, WC_LISTVIEWW,L"",style,0, 20, rc.right - rc.left, rc.bottom - rc.top - 20, hwnd,(HMENU)2,0,0);
	if (NULL != hwndList)
	{
		ListViewData *listView;
		listView = (ListViewData*)calloc(1, sizeof(ListViewData));
		if (NULL != listView)
		{
			listView->prevWindowProc = (WNDPROC)(LONG_PTR)SetWindowLongPtrW(hwndList, GWLP_WNDPROC, (LONGX86)(LONG_PTR)ListView_WindowProc);
			SetWindowLongPtrW(hwndList,GWLP_USERDATA, (LONGX86)(LONG_PTR)listView);
		}
		
		SendMessageW(hwndList, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_INFOTIP, LVS_EX_INFOTIP);

		if (NULL != hwndHeader)
			SetWindowPos(hwndHeader, hwndList, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
		
		m.skinType = SKINNEDWND_TYPE_LISTVIEW;
		m.hwndToSkin = hwndList;
		m.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS | SWLVS_FULLROWSELECT | SWLVS_DOUBLEBUFFER;
		MLSkinWindow(g_hwnd, &m);
		MLSkinnedScrollWnd_SetMode(hwndList, SCROLLMODE_STANDARD);
		MLSkinnedScrollWnd_ShowHorzBar(hwndList, FALSE);
		MLSkinnedScrollWnd_ShowVertBar(hwndList, FALSE);
	}

	UpdateFontMetrics(hwnd, FALSE);

	return 0;
}

static void
HeaderIconList_OnDestroy(HWND hwnd)
{
}

// TODO need to finish off the butting up to edge handling
static void
HeaderIconList_OnWindowPosChanged(HWND hwnd, WINDOWPOS *windowPos)
{
	RECT rc;
	HWND hwndHeader, hwndList;
	hwndHeader = GetDlgItem(hwnd, 3);
	hwndList = GetDlgItem(hwnd, 2);
	BOOL bRedraw;

	bRedraw = (0 == (SWP_NOREDRAW & windowPos->flags));

	if ((SWP_NOSIZE | SWP_NOMOVE) == ((SWP_NOSIZE | SWP_NOMOVE | SWP_FRAMECHANGED) & windowPos->flags))
		return;

	hwndHeader = GetDlgItem(hwnd, 3);
	hwndList = GetDlgItem(hwnd, 2);
	if (hwndHeader &&  hwndList)
	{
		HDLAYOUT headerLayout;
		WINDOWPOS headerPos;
		
		GetClientRect(hwnd, &rc);

		/*SCROLLINFO si;
		si.cbSize= sizeof(SCROLLINFO);
		si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
		BOOL got = GetScrollInfo(hwnd, SB_VERT, &si);
		BOOL bScrollVisible = (si.nMax > 0 && si.nPage > 0 && (INT)si.nPage <= si.nMax);*/

		headerLayout.prc = &rc;
		headerLayout.pwpos = &headerPos;
					
		if (FALSE != SendMessageW(hwndHeader, HDM_LAYOUT, 0, (LPARAM)&headerLayout))
		{
			headerPos.flags |= ((SWP_NOREDRAW | SWP_NOCOPYBITS) & windowPos->flags);
			SetWindowPos(hwndHeader, headerPos.hwndInsertAfter, headerPos.x, headerPos.y, 
						headerPos.cx, headerPos.cy, headerPos.flags);
		}

		SetWindowPos(hwndList, NULL, rc.left, rc.top, rc.right - rc.left/* + (bScrollVisible ? 16 : 0)*/, rc.bottom - rc.top,
					SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOCOPYBITS);

		UpdateScrollInfo(hwnd, SIF_RANGE | SIF_POS, bRedraw);
	}
	
	NMHDR hdr; 
	hdr.code = LVN_EX_SIZECHANGED;
	hdr.hwndFrom = hwnd;
	hdr.idFrom = GetWindowLongPtrW(hwnd,GWLP_ID);
	SendMessageW(GetParent(hwnd), WM_NOTIFY, hdr.idFrom, (LPARAM)&hdr);
}

static void
HeaderIconList_OnVertScroll(HWND hwnd, INT actionLayout, INT trackPosition, HWND scrollBar)
{
	SCROLLINFO si={sizeof(si),SIF_TRACKPOS | SIF_POS | SIF_RANGE | SIF_PAGE,0};
	if (GetScrollInfo(hwnd,SB_VERT,&si))
	{
		int pos(0), itemHeight;
		BOOL bRedraw(TRUE);
		HWND hwndList;
		
		hwndList = GetDlgItem(hwnd, 2);
		if (!hwndList) 
			return;

		itemHeight = HIWORD(SendMessageW(hwndList, LVM_GETITEMSPACING, 0, 0L));
		
		if (si.nPos > (si.nMax - (INT)si.nPage)) 
			si.nPos = si.nMax - si.nPage;

		switch(actionLayout)
		{
			case SB_TOP:			pos = si.nMin; break;
			case SB_BOTTOM:			pos = si.nMax; break;
			case SB_LINEDOWN:		pos = si.nPos + itemHeight/2; break;
			case SB_LINEUP:			pos = si.nPos - itemHeight/2; break;
			case SB_PAGEDOWN:		pos = si.nPos + si.nPage - (((INT)si.nPage > itemHeight && 0 == ((INT)si.nPage%itemHeight)) ? itemHeight : 0);break;
			case SB_PAGEUP:			pos = si.nPos - si.nPage - (((INT)si.nPage > itemHeight && 0 == ((INT)si.nPage%itemHeight)) ? itemHeight : 0);break;
			case SB_THUMBPOSITION:	
			case SB_THUMBTRACK:		
				{
					POINT pt;
					if (!SendMessageW(hwndList, LVM_GETORIGIN, 0, (LPARAM)&pt)) 
						return;
					si.nPos = pt.y;
					pos = si.nTrackPos;
					bRedraw = FALSE;
				}
				break; 
			case SB_ENDSCROLL:		MLSkinnedScrollWnd_UpdateBars(hwnd, TRUE); return;
			default:				pos = si.nPos;
		}
	
		if (pos < si.nMin) pos = si.nMin;
		if (pos > (si.nMax - (INT)si.nPage)) pos = si.nMax - si.nPage;
		if (pos != si.nPos)
		{
			BOOL br;
			if (!bRedraw)
			{
				UpdateWindow(GetDlgItem(hwnd, 3));
				UpdateWindow(hwnd);
				SendMessageW(hwnd, WM_SETREDRAW, FALSE, 0L);
			}
			br = (BOOL)SendMessageW(hwndList, LVM_SCROLL, 0, pos - si.nPos);
			if (!bRedraw) SendMessageW(hwnd, WM_SETREDRAW, TRUE, 0L);
			if (br)
			{
				si.fMask = SIF_POS;
				si.nPos = pos;
				SetScrollInfo(hwnd, SB_VERT, &si, FALSE);

				if (!bRedraw) 
					InvalidateRect(hwndList, NULL, TRUE);
			}
		}
	}
}

static void
HeaderIconList_OnSetFont(HWND hwnd, HFONT font, BOOL redraw)
{
	if (0 == (SWS_USESKINFONT & MLSkinnedWnd_GetStyle(hwnd)))
	{
		HWND controlWindow;
				
		controlWindow = GetDlgItem(hwnd,3);
		if (NULL != controlWindow)
			SendMessageW(controlWindow, WM_SETFONT, (WPARAM)font, MAKELPARAM(0, 0L));

		controlWindow = GetDlgItem(hwnd,2);
		if (NULL != controlWindow)
			SendMessageW(controlWindow, WM_SETFONT, (WPARAM)font, MAKELPARAM(0, 0L));
	
		UpdateFontMetrics(hwnd, redraw);
	}
}

static LRESULT
HeaderIconList_OnGetFont(HWND hwnd)
{
	HWND listWindow;

	listWindow = GetDlgItem(hwnd, 2);
	if (NULL != listWindow) 
		return SendMessageW(listWindow, WM_GETFONT, 0, 0L);
			
	return DefWindowProcW(hwnd, WM_GETFONT, 0, 0L);
}

static void
HeaderIconList_OnSetRedraw(HWND hwnd, BOOL enableRedraw)
{
	HWND childWindow;

	DefWindowProcW(hwnd, WM_SETREDRAW, enableRedraw, 0L);
	
	childWindow = GetDlgItem(hwnd, 3);
	if (NULL != childWindow)
	{
		SendMessage(childWindow, WM_SETREDRAW, enableRedraw, 0L);
		if (FALSE != enableRedraw)
			InvalidateRect(childWindow, NULL, TRUE);
	}

	childWindow = GetDlgItem(hwnd, 2);
	if (NULL != childWindow)
	{
		SendMessage(childWindow, WM_SETREDRAW, enableRedraw, 0L);
		if (FALSE != enableRedraw)
			InvalidateRect(childWindow, NULL, TRUE);
	}
}

static void 
HeaderIconList_OnSkinUpdated(HWND hwnd, BOOL notifyChildren, BOOL redraw)
{
	UpdateFontMetrics(hwnd, redraw);
}

static LRESULT
HeaderIconList_OnDisplaySort(HWND hwnd, int sortIndex, BOOL ascendingOrder)
{
	HWND headerWindow;

	headerWindow = GetDlgItem(hwnd, 3);
	if (NULL == headerWindow)
		return 0;

	return SENDMLIPC(headerWindow, ML_IPC_SKINNEDHEADER_DISPLAYSORT, MAKEWPARAM(sortIndex, ascendingOrder));
}

static LRESULT
HeaderIconList_OnGetSort(HWND hwnd)
{
	HWND headerWindow;

	headerWindow = GetDlgItem(hwnd, 3);
	if (NULL == headerWindow)
		return 0;

	return SENDMLIPC(headerWindow, ML_IPC_SKINNEDHEADER_GETSORT, 0);
}


static LRESULT
HeaderIconList_OnMediaLibraryIPC(HWND hwnd, INT msg, INT_PTR param)
{
	switch(msg)
	{
		case ML_IPC_SKINNEDWND_SKINUPDATED:			HeaderIconList_OnSkinUpdated(hwnd, LOWORD(param), HIWORD(param)); break;
		case ML_IPC_SKINNEDLISTVIEW_DISPLAYSORT: 	return HeaderIconList_OnDisplaySort(hwnd, LOWORD(param), HIWORD(param));
		case ML_IPC_SKINNEDLISTVIEW_GETSORT:		return HeaderIconList_OnGetSort(hwnd); 
	}
	return 0;
}

static LRESULT CALLBACK HeaderIconList(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
	switch(uMsg) 
	{
		case WM_CREATE:				return HeaderIconList_OnCreate(hwnd, (CREATESTRUCT*)lParam);
		case WM_DESTROY:			HeaderIconList_OnDestroy(hwnd); return 0;
		case WM_WINDOWPOSCHANGED:	HeaderIconList_OnWindowPosChanged(hwnd, (WINDOWPOS*)lParam); return 0;
		case WM_VSCROLL:			HeaderIconList_OnVertScroll(hwnd, LOWORD(wParam), (short)HIWORD(wParam), (HWND)lParam); return 0;
		case WM_ERASEBKGND: 		return 1;
		case WM_SETFONT:			HeaderIconList_OnSetFont(hwnd, (HFONT)wParam, LOWORD(lParam)); return 0; 
		case WM_GETFONT:			return HeaderIconList_OnGetFont(hwnd);
		case WM_SETREDRAW:			HeaderIconList_OnSetRedraw(hwnd, (BOOL)wParam); return 0;
		case WM_TIMER:
			if (43 == wParam)
			{
				KillTimer(hwnd, 43);
				PostMessageW(hwnd, WM_EX_UPDATESCROLLINFO, SIF_POS, FALSE);
				PostMessageW(hwnd, WM_EX_UNLOCKREDRAW, IWF_CONTAINER | IWF_LISTVIEW | IWF_UPDATENOW, 0L);
			}
			break;

		case WM_EX_UPDATESCROLLINFO:
			return UpdateScrollInfo(hwnd, (UINT)wParam, (BOOL)lParam);

		case WM_EX_UNLOCKREDRAW:
			
			SendMessageW(hwnd, WM_SETREDRAW, TRUE, 0L);
			if (IWF_CONTAINER & wParam) { InvalidateRect(hwnd, NULL, FALSE); if (IWF_UPDATENOW & wParam) UpdateWindow(hwnd); }
			if (IWF_LISTVIEW & wParam) 
			{
				HWND hwndList = GetDlgItem(hwnd, 2);
				if(hwndList) { InvalidateRect(hwndList, NULL, TRUE);  if (IWF_UPDATENOW & wParam) UpdateWindow(hwndList); }
			}
			if (IWF_HEADER & wParam) 
			{
				HWND hwndHeader = GetDlgItem(hwnd, 3);
				if(hwndHeader) { InvalidateRect(hwndHeader, NULL, TRUE);  if (IWF_UPDATENOW & wParam) UpdateWindow(hwndHeader); }
			}
			break;
		case LVM_GETHEADER:
			return (LRESULT)GetDlgItem(hwnd,3);
		case LVM_DELETECOLUMN:
			{
				HWND headerWindow;
				headerWindow = GetDlgItem(hwnd,3);
				if (NULL != headerWindow)
					return SendMessageW(headerWindow, HDM_DELETEITEM, wParam, 0L);
			}
			return FALSE;
		case LVM_GETCOLUMNWIDTH:
			{
				HWND headerWindow;
				headerWindow = GetDlgItem(hwnd,3);
				if (NULL != headerWindow)
				{
					HDITEMW headerItem;
					headerItem.mask = HDI_WIDTH;
					if (FALSE != SendMessageW(headerWindow, HDM_GETITEM, wParam, (LPARAM)&headerItem))
						return headerItem.cxy;
				}
			}
			return 0;
		case LVM_INSERTCOLUMNA:
		case LVM_INSERTCOLUMNW:
			{
				LVCOLUMNW *listColumn = (LVCOLUMNW*)lParam;
				HDITEMW headerItem;
				HWND headerWindow;
				headerWindow = GetDlgItem(hwnd,3);
				if (NULL == headerWindow)
					return -1;

				if (FALSE == CopyListColumnToHeaderItem(listColumn, &headerItem))
					return -1;

				if (0 == (HDI_FORMAT & headerItem.mask))
				{
					headerItem.mask |= HDI_FORMAT;
					headerItem.fmt = HDF_LEFT;
				}

				return SendMessageW(headerWindow, 
							(LVM_INSERTCOLUMNW == uMsg) ? HDM_INSERTITEMW : HDM_INSERTITEMA,
							wParam,	(LPARAM)&headerItem);
			}
			break;
		case LVM_SETITEMCOUNT:
			{
				HWND hwndList = GetDlgItem(hwnd, 2);
				if (hwndList) 
				{
					LRESULT lr = ListView_WindowProc(hwndList, uMsg, wParam, lParam);
					UpdateScrollInfo(hwnd, SIF_RANGE | SIF_POS, TRUE);
					return lr;
				}
			}
			break;
		case LVM_GETCOLUMNW:
		case LVM_GETCOLUMNA:
			{
				LVCOLUMNW *l = (LVCOLUMNW *)lParam;
				HDITEMW h;
				HWND headerWindow;
				
				headerWindow = GetDlgItem(hwnd, 3);
				if (NULL == headerWindow)
					return FALSE;

				if (FALSE == CopyListColumnToHeaderItem(l, &h))
					return FALSE;

				if(!SendMessageW(headerWindow, 
								(LVM_GETCOLUMNW == uMsg) ? HDM_GETITEMW : HDM_GETITEMA, 
								wParam, 
								(LPARAM)&h))
				{
					return FALSE;
				}
				
				if (FALSE == CopyHeaderItemToListColumn(&h, l))
					return FALSE;
			}
			return TRUE;

		case LVM_SETCOLUMNW:
		case LVM_SETCOLUMNA:
			{
				LVCOLUMNW *l = (LVCOLUMNW *)lParam;
				HDITEMW h;
				HWND headerWindow;
				
				headerWindow = GetDlgItem(hwnd, 3);
				if (NULL == headerWindow)
					return FALSE;

				if (FALSE == CopyListColumnToHeaderItem(l, &h))
					return FALSE;

				if(!SendMessageW(headerWindow, 
								(LVM_SETCOLUMNW == uMsg) ? HDM_SETITEMW : HDM_SETITEMA, 
								wParam, (LPARAM)&h))
				{
					return FALSE;
				}
				
				if (FALSE == CopyHeaderItemToListColumn(&h, l))
					return FALSE;
			}
			return TRUE;
		case LVM_SETCOLUMNWIDTH:
			{
				HWND headerWindow;
				HDITEMW headerItem;

				headerWindow = GetDlgItem(hwnd, 3);
				if (NULL == headerWindow)
					return FALSE;

				if (LVSCW_AUTOSIZE == lParam)
					return FALSE;

				if (LVSCW_AUTOSIZE_USEHEADER == lParam)
					return FALSE;

				headerItem.mask = HDI_WIDTH;
				headerItem.cxy = (int)lParam;

				return SendMessageW(headerWindow, HDM_SETITEMW, (WPARAM)wParam, (LPARAM)&headerItem);
			}
			break;
		case WM_NOTIFY:
			{
				BOOL bPost(FALSE);
				LPNMHDR l=(LPNMHDR)lParam;
				if(l->idFrom == 2) 
				{
					switch(l->code)
					{
						case LVN_ODFINDITEMA:
						case LVN_ODFINDITEMW:
							bPost = TRUE;
							break;
						case LVN_ODSTATECHANGED:
							{
								NMLVODSTATECHANGE *stateChange;
								stateChange = (NMLVODSTATECHANGE*)lParam;
								
								if (0 != (LVIS_SELECTED & (stateChange->uNewState ^ stateChange->uOldState)))
								{
									
									SendMessageW(hwnd, WM_SETREDRAW, FALSE, 0L);
									ListView_ScheduleSelectionUpdate(l->hwndFrom, stateChange->iFrom,stateChange->iTo); 
								}

								return 0;
							}
							break;
					}
					l->idFrom = GetWindowLong(hwnd,GWL_ID);
					l->hwndFrom = hwnd;
					LRESULT lr = SendMessageW(GetParent(hwnd),uMsg,l->idFrom,lParam);
					if (bPost)
					{
						UpdateWindow(GetDlgItem(hwnd, 3));
						SendMessageW(hwnd, WM_SETREDRAW, FALSE, 0L);
						PostMessageW(hwnd, WM_EX_UPDATESCROLLINFO, SIF_POS, TRUE);
						PostMessageW(hwnd, WM_EX_UNLOCKREDRAW, IWF_CONTAINER | IWF_LISTVIEW, 0L);
					}
					return lr;
				}
				else if(l->idFrom == 3) {
					switch(l->code) {
						case HDN_ITEMCLICKA:
						case HDN_ITEMCLICKW:
							{
								NMHEADER *nm = (NMHEADER*)lParam;
								HWND hwndParent;
								hwndParent = GetParent(hwnd);
								if (hwndParent)
								{
									wParam = GetWindowLongPtrW(hwnd,GWLP_ID);
									if(nm->iButton == 0) { // left click
										NMLISTVIEW p = {{hwnd, wParam, LVN_COLUMNCLICK},-1,nm->iItem,0};
										return SendMessageW(hwndParent,WM_NOTIFY,wParam,(LPARAM)&p);
									} else if(nm->iButton == 1) { // right click
										NMHDR p = {nm->hdr.hwndFrom,wParam,NM_RCLICK};
										return SendMessageW(hwndParent,WM_NOTIFY,wParam,(LPARAM)&p);
									}
								}
								
							}
							break;
					}
					return SendMessageW(GetParent(hwnd),uMsg, wParam,lParam);
				}
			}
			break;
		case WM_EX_GETREALLIST: 
			return (LRESULT)GetDlgItem(hwnd, 2);
		case WM_EX_GETCOUNTPERPAGE: 
			{
				HWND hwndList;
				RECT rc;
				hwndList = GetDlgItem(hwnd, 2);
				if (hwndList)
				{
					GetClientRect(hwndList, &rc);
					OffsetRect(&rc, -rc.left, -rc.top);
					DWORD spacing = (DWORD)SendMessageW(hwndList, LVM_GETITEMSPACING, 0, 0L);
					if (LOWORD(spacing) && HIWORD(spacing))
					{					
						return (rc.right/LOWORD(spacing)) * (rc.bottom /HIWORD(spacing) + ((rc.bottom%HIWORD(spacing)) ? 1 : 0));
					}
					
				}
			}
			return 0;

		case WM_ML_IPC:
			return HeaderIconList_OnMediaLibraryIPC(hwnd, (INT)lParam, (INT_PTR)wParam);

		default:
			if(uMsg >= LVM_FIRST && uMsg < LVM_FIRST + 0x100) 
			{
				HWND hwndList = GetDlgItem(hwnd,2);
				if (hwndList) return ListView_WindowProc(hwndList, uMsg, wParam, lParam);
			}
			break;
	}
	return DefWindowProcW(hwnd,uMsg,wParam,lParam);
}


void InitHeaderIconList() {
	WNDCLASSW wc = {0, };

	if (GetClassInfoW(plugin.hDllInstance, L"HeaderIconList", &wc)) return;
	wc.style = CS_DBLCLKS;
	wc.lpfnWndProc = HeaderIconList;
	wc.hInstance = plugin.hDllInstance;
	wc.lpszClassName = L"HeaderIconList";
	RegisterClassW(&wc);
}