/*=========================================================================
* 
* CPAdList.cpp :  Lists - Implementation file
* 
*
* Version			1.0
* Creation date		
* Revision date
*
* Shaitan
*=======================================================================*/
#include "stdafx.h"
#ifdef ACTIVE_EDITOR
#include "acp_base.h"

#include "ITF/CPAdLbox.hpp"
#include "ITF/CPAdList.hpp"
#include "ITF/CPABaseO.hpp"
#include "ITF/CPAEditB.hpp"
#include "IncTUT.h"

#define C_uiHeaderEntry		 0
#define C_uiAutoAdjustEntry	 1

#define C_uiDrawStateEntry	 2
#define C_uiDrawIconEntry	 3
#define C_uiDrawTypeEntry	 4
#define C_uiDrawOwnerEntry	 5
#define C_uiDrawInfoEntry	 6

#define C_uiSortAlphaEntry   7
#define C_uiSortCommonEntry  8
#define C_uiSortEditedEntry  9

#define C_uiDisplayAllEntry 10

#define C_uiCustomEntryStart 20

BOOL g_bIsAdjusting = FALSE;
BOOL g_bIsBuildingList = FALSE;

//#################################################################################
// Sorted ListBox
//#################################################################################
BEGIN_MESSAGE_MAP(CPA_SortedListBox, CListCtrl)
	ON_NOTIFY_REFLECT(LVN_BEGINDRAG, OnBeginDrag)
	ON_NOTIFY_REFLECT(LVN_COLUMNCLICK, OnColumnClicked)
	ON_WM_LBUTTONUP()
	ON_WM_MOUSEMOVE()
	ON_WM_LBUTTONDBLCLK()
	ON_WM_RBUTTONDOWN()
	ON_WM_KEYDOWN()
	ON_WM_KEYUP()
	ON_WM_DRAWITEM()
	ON_WM_SIZE()
END_MESSAGE_MAP()

/*----------------------------------------
	Constructor
----------------------------------------*/
CPA_SortedListBox::CPA_SortedListBox (void)
{
	// init parameters
	m_pOwnerEditor = NULL;
	m_pParentDialog = NULL;
	m_pSortedList = NULL;
	m_pIconList = NULL;
	m_pStateList = NULL;
	// init styles
	m_eCurrentOrder = E_lo_Alpha;
	m_bDisplayGray = TRUE;
	m_lDrawStyle = C_lDrawNothing;
	m_lNbColumns = 0;
	m_bHeaders = TRUE;
	m_bAdjustSize = TRUE;
	// init permissions
	m_bCanChangeOrder = TRUE;
	m_bCanChangeDisplay = TRUE;
	m_bCanChangeDrawStyle = TRUE;
	m_bCanChangeHeaders = TRUE;
	m_bCanDragDrop = TRUE;
	// init state
	m_bIsSelecting = FALSE;
	m_iDraggedItem = -1;
	m_iTargetItem = -1;
}


/*----------------------------------------
	Set list
----------------------------------------*/
void CPA_SortedListBox::SetSortedList (CPA_BaseObjectList *pSortedList)
{
	m_pSortedList = pSortedList;
	fn_vReinitListObjects();
}

/*----------------------------------------
	Set icons
----------------------------------------*/
void CPA_SortedListBox::SetIconList (CImageList *pIconList, BOOL bUpdate)
{
	// user icon list
	m_pIconList = pIconList;
	SetImageList(pIconList, LVSIL_SMALL);

	if (bUpdate)
		fn_vReinitListObjects();
}

/*----------------------------------------
	Set icons
----------------------------------------*/
void CPA_SortedListBox::SetStateList (CImageList *pStateList, BOOL bUpdate)
{
	// user icon list
	m_pStateList = pStateList;
	SetImageList(pStateList, LVSIL_STATE);

	if (bUpdate)
		fn_vReinitListObjects();
}

/*----------------------------------------
	Set order
----------------------------------------*/
void CPA_SortedListBox::SetOrder (tdeListOrder eNewOrder, BOOL bCanChange, BOOL bUpdateList)
{
	// update order
	m_bCanChangeOrder = bCanChange;
	m_eCurrentOrder = eNewOrder;

	if (!bUpdateList)
		return;
	
	// update list
	if (m_pParentDialog)
	{
		m_pParentDialog->GetCurrentList()->SetOrder(eNewOrder);
		m_pParentDialog->fn_vInitListObjects();
	}
	else
		fn_vReinitListObjects();
}

/*----------------------------------------
	Set column headers
----------------------------------------*/
void CPA_SortedListBox::SetColumnHeaders (BOOL bHeaders, BOOL bCanChange, BOOL bUpdateList)
{
	if (bHeaders)
		ModifyStyle(LVS_NOCOLUMNHEADER, 0);
	else
		ModifyStyle(0, LVS_NOCOLUMNHEADER);

	m_bHeaders = bHeaders;
}

/*----------------------------------------
	Set draw style
----------------------------------------*/
void CPA_SortedListBox::SetDrawStyle (long lNewStyle, BOOL bCanChange, BOOL bUpdateList)
{
	int			iInd;
	
	// update flag
	m_bCanChangeDrawStyle = bCanChange;
	// update style
	if (lNewStyle != m_lDrawStyle)
	{
		// delete old colums
		for (iInd = 0; iInd < m_lNbColumns; iInd++)
			DeleteColumn(m_lNbColumns - iInd - 1);
		// update draw style
		m_lDrawStyle = lNewStyle;
		// init new columns
		iInd = 0;
		// state icon
		if ((m_lDrawStyle & C_lDrawState)&&(m_pStateList))
			InsertColumn(iInd++, "v", LVCFMT_LEFT, -1, -1);
		// item icon
		if ((m_lDrawStyle & C_lDrawIcon)&&(m_pIconList))
			InsertColumn(iInd++, "v", LVCFMT_LEFT, -1, -1);
		// name
		if (m_lDrawStyle & C_lDrawName)
			InsertColumn(iInd++, "v Name", LVCFMT_LEFT, -1, -1);
		// type
		if (m_lDrawStyle & C_lDrawType)
			InsertColumn(iInd++, "v Type", LVCFMT_LEFT, -1, 0);
		// owner
		if (m_lDrawStyle & C_lDrawOwner)
			InsertColumn(iInd++, "v Owner", LVCFMT_LEFT, -1, 1);
		// info
		if (m_lDrawStyle & C_lDrawInfo)
			InsertColumn(iInd++, "Info", LVCFMT_LEFT, -1, 2);
		// init nb of columns
		m_lNbColumns = iInd;
		// init columns size
		fn_vReinitColumnWidth();
	}

	// update list
	if (m_pParentDialog)
		m_pParentDialog->GetCurrentList()->SetStyle(lNewStyle);

	if (!bUpdateList)
		return;

	// update list
	if (m_pParentDialog)
		m_pParentDialog->fn_vInitListObjects();
	else
		fn_vReinitListObjects();
}

/*----------------------------------------
	Set draw style
----------------------------------------*/
void CPA_SortedListBox::SetDisplayGray (BOOL bNewDisplay, BOOL bCanChange, BOOL bUpdateList)
{
	// update style
	m_bCanChangeDisplay = bCanChange;
	m_bDisplayGray = bNewDisplay;

	if (!bUpdateList)
		return;

	// update list
	if (m_pParentDialog)
		m_pParentDialog->fn_vInitListObjects();
	else
		fn_vReinitListObjects();
}

/*----------------------------------------
	Columns 
----------------------------------------*/
void CPA_SortedListBox::fn_vReinitColumnWidth (void)
{
	RECT		rWindow;
	long		lSize, lWidth;
	long		lNbColumns = m_lNbColumns;
	long		lIconSize = 0;
	int			iInd = 0;

	// state column
	if ((m_lDrawStyle & C_lDrawState)&&(m_pStateList))
	{
		lIconSize += 20;
		SetColumnWidth(iInd++, 20);
	}
	// icon column
	if ((m_lDrawStyle & C_lDrawIcon)&&(m_pIconList))
	{
		lIconSize += 20;
		SetColumnWidth(iInd++, 20);
	}
	// init columns size
	GetWindowRect(&rWindow);
	lNbColumns = m_lNbColumns - iInd;
	// get minimal width
	lWidth = rWindow.right - rWindow.left - lIconSize - 2*lNbColumns - 5;
	if (GetCountPerPage() < GetItemCount())
		lWidth = lWidth - 15;
	// adust colums size
	lSize = (m_lNbColumns > 0) ? lWidth / lNbColumns : 0;
	while (iInd < m_lNbColumns)
		SetColumnWidth(iInd++, lSize);
}

/*----------------------------------------
	List 
----------------------------------------*/
void CPA_SortedListBox::fn_vReinitListObjects (void)
{
	CPA_BaseObject *pElem;
	BOOL			bRes;
	long			lIndex, lRealIndex;
	int				iPos = 0;

	// RAZ
	DeleteAllItems();
	if (!m_pSortedList)
		return;

	// update list in case of changes
//	m_pSortedList->fn_vUpdateSortedList();
	// for size
	g_bIsBuildingList = TRUE;

	// look for instances of selected descriptor
	for (lIndex = 0, lRealIndex = 0; lIndex < m_pSortedList->GetCount(); lIndex++)
	{
		pElem = m_pSortedList->GetObjectWithIndex(lRealIndex, GetOrder());
		// test function
		if (m_pParentDialog)
			bRes = m_pParentDialog->fn_bCanInsertElement(pElem);
		else
			bRes = ((pElem->fn_bIsAvailable())||(m_bDisplayGray));

		if ((bRes)&&(pElem->fn_bIsValid()))
		{
			// insert item
			iPos = InsertNewItem(iPos, pElem) + 1;
			lRealIndex++;
		}
		else if (GetOrder() == E_lo_Common)
			m_pSortedList->fn_bChangeObjectOrder(pElem, m_pSortedList->GetCount() - 1, E_lo_Common);
		else
			lRealIndex++;
	}
	// for size
	g_bIsBuildingList = FALSE;
}

/*----------------------------------------
	Insertion
----------------------------------------*/
int CPA_SortedListBox::InsertNewItem (int iNumItem, CPA_BaseObject *pElem)
{
	int			iNumIcon, iPos;

	// get icon
	iNumIcon = GetCorrespondingIcon(pElem);
	
	// insert item and set data
	iPos = InsertItem(iNumItem, pElem->GetNameToDraw(), iNumIcon);
	SetItemData(iPos, (DWORD) pElem);

	return iPos;
}

/*----------------------------------------
	Selection
----------------------------------------*/
void CPA_SortedListBox::SetSelectedItem (int iNumItem)
{
	int iInd;
	
	// set flag
	m_bIsSelecting = TRUE;
	
	// select item
	if (iNumItem != -1)
	{
		SetItemState(iNumItem, LVIS_SELECTED, LVIS_SELECTED);
		EnsureVisible(iNumItem, TRUE);
	}
	// unselect item
	else
	{
		iInd = GetNextItem(-1, LVNI_SELECTED);
		if (iInd != -1)
			SetItemState(iInd, 0, LVIS_SELECTED);
	}

	m_iSelectedItem = iNumItem;

	// update flag
	m_bIsSelecting = FALSE;
}
	
/*----------------------------------------
	Selection
----------------------------------------*/
int	CPA_SortedListBox::GetSelectedItem (void)
{
	return GetNextItem(-1, LVNI_SELECTED);
}


/*----------------------------------------
	Popup Menu
----------------------------------------*/
void CPA_SortedListBox::OnRButtonDown(UINT nFlags, CPoint point) 
{
	BOOL bEntry		= FALSE;
	BOOL bCustom	= FALSE;
	
	ClientToScreen( &point );
	// create popup menu	
	CMenu oMenu;
	oMenu.CreatePopupMenu();

	// Headers 
	if (m_bCanChangeHeaders)
	{
		oMenu.AppendMenu( MF_STRING | ((m_bHeaders)?MF_CHECKED:MF_UNCHECKED), C_uiHeaderEntry, "Headers");
		bEntry = TRUE;
	}
	// Auto Size
	if ((m_lNbColumns != 2) || (m_bCanChangeDrawStyle))
	{
		oMenu.AppendMenu( MF_STRING | ((m_bAdjustSize)?MF_CHECKED:MF_UNCHECKED), C_uiAutoAdjustEntry, "Adjust Size");
		bEntry = TRUE;
	}

	// Draw Style
	if (m_bCanChangeDrawStyle)
	{
		// separator
		if (bEntry)
			oMenu.AppendMenu(MF_SEPARATOR);
		// entries to change draw style
		if (m_pStateList)
			oMenu.AppendMenu( MF_STRING | ((m_lDrawStyle & C_lDrawState)?MF_CHECKED:MF_UNCHECKED), C_uiDrawStateEntry, "State");
		if (m_pIconList)
			oMenu.AppendMenu( MF_STRING | ((m_lDrawStyle & C_lDrawIcon)?MF_CHECKED:MF_UNCHECKED), C_uiDrawIconEntry, "Icon");
		oMenu.AppendMenu( MF_STRING | ((m_lDrawStyle & C_lDrawType)?MF_CHECKED:MF_UNCHECKED), C_uiDrawTypeEntry, "Type");
		oMenu.AppendMenu( MF_STRING | ((m_lDrawStyle & C_lDrawOwner)?MF_CHECKED:MF_UNCHECKED), C_uiDrawOwnerEntry, "Owner");
		oMenu.AppendMenu( MF_STRING | ((m_lDrawStyle & C_lDrawInfo)?MF_CHECKED:MF_UNCHECKED), C_uiDrawInfoEntry, "Info");
		bEntry = TRUE;
	}

	// Order
	if (m_bCanChangeOrder)
	{
		// separator
		if (bEntry)
			oMenu.AppendMenu(MF_SEPARATOR);
		// entries to change display order
		oMenu.AppendMenu( MF_STRING | ((m_eCurrentOrder == E_lo_Alpha)?MF_CHECKED:MF_UNCHECKED), C_uiSortAlphaEntry, "Alphabetic");
		oMenu.AppendMenu( MF_STRING | ((m_eCurrentOrder == E_lo_Common)?MF_CHECKED:MF_UNCHECKED), C_uiSortCommonEntry, "Common");
		oMenu.AppendMenu( MF_STRING | ((m_eCurrentOrder == E_lo_Edited)?MF_CHECKED:MF_UNCHECKED), C_uiSortEditedEntry, "Edited");
		bEntry = TRUE;
	}

	// Invalid Objects
	if (m_bCanChangeDisplay)
	{
		// separator
		if (bEntry)
			oMenu.AppendMenu(MF_SEPARATOR);
		// entry to change display mode
		oMenu.AppendMenu( MF_STRING | ((m_bDisplayGray)?MF_CHECKED:MF_UNCHECKED), C_uiDisplayAllEntry, "Display All");
	}

	// separator
	if (bEntry)
		oMenu.AppendMenu(MF_SEPARATOR);
	// Custom Entries
	if (m_pParentDialog)
		bCustom = m_pOwnerEditor->fn_bAddEntriesToListPopup(m_pParentDialog, m_pParentDialog->GetCurrentType(), &oMenu, C_uiCustomEntryStart);
	else
		bCustom = m_pOwnerEditor->fn_bAddEntriesToListPopup(this, m_pSortedList, &oMenu, C_uiCustomEntryStart);
	// no custom entries => remove separator
	if (!bCustom)
		oMenu.DeleteMenu(oMenu.GetMenuItemCount() - 1, MF_BYPOSITION); 
	
	// display & track popup menu
	if ((bEntry)||(bCustom))
    {
        TUT_M_vGetTutDll    ();
        TUT_M_vRegisterMenu (this -> m_hWnd , oMenu . m_hMenu , point . x , point . y);
		oMenu.TrackPopupMenu( TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, this);
    }
	// destroy menus
	oMenu.DestroyMenu();
}

/*----------------------------------------
	Answer to Popup
----------------------------------------*/
BOOL CPA_SortedListBox::OnCommand( WPARAM wParam, LPARAM lParam )
{
	// command from a menu ?
	if (HIWORD(wParam) == 0) 
	{
		// ID of menu item ?
		switch (LOWORD(wParam)) 
		{
			// column headers
			case C_uiHeaderEntry:
				if (m_bHeaders)
					SetColumnHeaders(FALSE);
				else
					SetColumnHeaders(TRUE);
				break;

			case C_uiAutoAdjustEntry:
				SetAdjustSize(!m_bAdjustSize);
				break;

			// draw style
			case C_uiDrawStateEntry:
				if (m_lDrawStyle & C_lDrawState)
					SetDrawStyle(m_lDrawStyle - C_lDrawState);
				else
					SetDrawStyle(m_lDrawStyle + C_lDrawState);
				break;
			case C_uiDrawIconEntry:
				if (m_lDrawStyle & C_lDrawIcon)
					SetDrawStyle(m_lDrawStyle - C_lDrawIcon);
				else
					SetDrawStyle(m_lDrawStyle + C_lDrawIcon);
				break;
			case C_uiDrawTypeEntry:
				if (m_lDrawStyle & C_lDrawType)
					SetDrawStyle(m_lDrawStyle - C_lDrawType);
				else
					SetDrawStyle(m_lDrawStyle + C_lDrawType);
				break;
			case C_uiDrawOwnerEntry:
				if (m_lDrawStyle & C_lDrawOwner)
					SetDrawStyle(m_lDrawStyle - C_lDrawOwner);
				else
					SetDrawStyle(m_lDrawStyle + C_lDrawOwner);
				break;
			case C_uiDrawInfoEntry:
				if (m_lDrawStyle & C_lDrawInfo)
					SetDrawStyle(m_lDrawStyle - C_lDrawInfo);
				else
					SetDrawStyle(m_lDrawStyle + C_lDrawInfo);
				break;

			// list order
			case C_uiSortAlphaEntry:
				SetOrder(E_lo_Alpha);
				break;
			case C_uiSortCommonEntry:
				SetOrder(E_lo_Common);
				break;
			case C_uiSortEditedEntry:
				SetOrder(E_lo_Edited);
				break;

			// list order
			case C_uiDisplayAllEntry:
				SetDisplayGray(!m_bDisplayGray);
				break;
		}
		// custom entries
		if (LOWORD(wParam) >= C_uiCustomEntryStart) 
		{
			if (m_pParentDialog)
				m_pOwnerEditor->fn_vOnCommandInListPopup(m_pParentDialog, m_pParentDialog->GetCurrentType(), LOWORD(wParam) - C_uiCustomEntryStart);
			else
				m_pOwnerEditor->fn_vOnCommandInListPopup(this, m_pSortedList, LOWORD(wParam) - C_uiCustomEntryStart);
		}
	}
	return CListCtrl::OnCommand(wParam, lParam);
}

/*----------------------------------------
	Load
----------------------------------------*/
void CPA_SortedListBox::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	CPA_BaseObject	*pElem = NULL;
	BOOL			bRedraw;
	BOOL			bRes = FALSE;
	UINT			pFlag;
	int				iSelect;
	
	// get selected element
	iSelect = HitTest(point, &pFlag);
	if (iSelect != -1)
		pElem = (CPA_BaseObject *) GetItemData(iSelect);

	if (m_pParentDialog)
		bRes = m_pOwnerEditor->fn_bOnDblClkListObjects(m_pParentDialog, m_pParentDialog->GetCurrentType(), pElem);

	if ((bRes)||(!m_bDisplayGray))
	{
		CListCtrl::OnLButtonDblClk(nFlags, point);
		return;
	}

	// non available object => load
	if ((pElem)&&(!pElem->fn_bIsAvailable()))
	{
		bRedraw = pElem->GetEditor()->fn_bLoadBaseObject(pElem);
		if (bRedraw)
			SetSelectedItem(iSelect);		
	}
	else
		CListCtrl::OnLButtonDblClk(nFlags, point);
}

/*----------------------------------------
	Init Drag&Drop
----------------------------------------*/
void CPA_SortedListBox::OnBeginDrag (NMHDR* pNMHDR, LRESULT* pResult)
{
	LPNM_LISTVIEW	pNMListView = (LPNM_LISTVIEW)pNMHDR;
		
	if ((m_eCurrentOrder != E_lo_Edited)||(!m_bCanDragDrop))
		m_iDraggedItem = -1;
	else
		m_iDraggedItem = pNMListView->iItem;
}


/*----------------------------------------
	End Drag&Drop
----------------------------------------*/
void CPA_SortedListBox::OnLButtonUp (UINT nFlags, CPoint point)
{
	CPA_BaseObject	*pObjectToDrag;
	CPA_BaseObject	*pTarget;
	int				iOldIndex, iNewIndex;

	// no dragged item => no action
	if (m_iDraggedItem == -1)
	{
		CListCtrl::OnLButtonUp (nFlags, point);
		return;
	}

	// find target
	if ((m_iTargetItem > -1)&&(m_iTargetItem < GetItemCount()))
	{
		// find object current index
		pObjectToDrag = (CPA_BaseObject *) GetItemData(m_iDraggedItem);
		iOldIndex = m_pSortedList->GetIndexOfObject(pObjectToDrag, E_lo_Edited);
		// find target index
		pTarget = (CPA_BaseObject *) GetItemData(m_iTargetItem);
		iNewIndex = m_pSortedList->GetIndexOfObject(pTarget, E_lo_Edited);
		// update order
		m_pSortedList->fn_vChangeObjectOrder(iOldIndex, iNewIndex, E_lo_Edited);
	}

	// update state
	SetItemState(m_iTargetItem, 0, TVIS_DROPHILITED);
	m_iDraggedItem = -1;
	m_iTargetItem = -1;

	// update list
	if (m_pParentDialog)
		m_pParentDialog->fn_vInitListObjects();
	else
		fn_vReinitListObjects();
}



/*----------------------------------------
	Drag&Drop
----------------------------------------*/
void CPA_SortedListBox::OnMouseMove (UINT nFlags, CPoint point)
{
	int		iTarget;
	UINT	pFlag;

	if (m_iDraggedItem == -1)
	{
		CListCtrl::OnMouseMove (nFlags, point);
		return;
	}

	// find target
	iTarget = HitTest(point, &pFlag);
	if (iTarget != m_iTargetItem)
	{
		// update old target
		if (m_iTargetItem)
			SetItemState(m_iTargetItem, 0, TVIS_DROPHILITED);
		// update new target
		m_iTargetItem = iTarget;
		if (m_iTargetItem)
			SetItemState(m_iTargetItem, TVIS_DROPHILITED, TVIS_DROPHILITED);
	}
}

/*----------------------------------------
	KeyDown
----------------------------------------*/
void CPA_SortedListBox::OnKeyDown (UINT nChar, UINT nRepCnt, UINT nFlags)
{
	if (m_pParentDialog && !m_pParentDialog->fn_bOnKeyDownInControl(nChar, nRepCnt, nFlags))
		CListCtrl::OnKeyDown(nChar, nRepCnt, nFlags);
	else
		fn_vOnKeyDown(nChar, nRepCnt, nFlags);
}

/*----------------------------------------
	KeyUp
----------------------------------------*/
void CPA_SortedListBox::OnKeyUp (UINT nChar, UINT nRepCnt, UINT nFlags)
{
	if (m_pParentDialog && !m_pParentDialog->fn_bOnKeyUpInControl(nChar, nRepCnt, nFlags))
		CListCtrl::OnKeyUp(nChar, nRepCnt, nFlags);
}

/*----------------------------------------
	GetIndex
----------------------------------------*/
int CPA_SortedListBox::GetCorrespondingIndex (DWORD pElem)
{
	DWORD	pData;
	int		iIndex;

	for (iIndex = 0; iIndex < GetItemCount(); iIndex++)
	{
		pData = GetItemData(iIndex);
		if (pData == pElem)
			return iIndex;
	}
	return -1;
}


/*----------------------------------------
	Get Icon
----------------------------------------*/
int CPA_SortedListBox::GetCorrespondingIcon	(CPA_BaseObject *pObject)
{
	if (m_pParentDialog)
		return m_pOwnerEditor->GetIconForListItem(m_pParentDialog, m_pParentDialog->GetCurrentType(), pObject);
	else
		return m_pOwnerEditor->GetIconForListItem(this, m_pSortedList, pObject);
}

/*----------------------------------------
	Get State
----------------------------------------*/
int CPA_SortedListBox::GetCorrespondingState (CPA_BaseObject *pObject)
{
	if (m_pParentDialog)
		return m_pOwnerEditor->GetStateForListItem(m_pParentDialog, m_pParentDialog->GetCurrentType(), pObject);
	else
		return m_pOwnerEditor->GetStateForListItem(this, m_pSortedList, pObject);
}

/*----------------------------------------
	Get Colors
----------------------------------------*/
BOOL CPA_SortedListBox::GetCorrespondingColors (CPA_BaseObject *pObject, COLORREF *pRectColor, COLORREF *pTextColor) 
{
	if (m_pParentDialog)
		return m_pOwnerEditor->GetColorsForListItem(m_pParentDialog, m_pParentDialog->GetCurrentType(), 
													pObject, pRectColor, pTextColor);
	else
		return m_pOwnerEditor->GetColorsForListItem(this, m_pSortedList, pObject, pRectColor, pTextColor);
}

/*----------------------------------------
	Get Info
----------------------------------------*/
CString CPA_SortedListBox::GetCorrespondingInfo (CPA_BaseObject *pObject)
{
	if (m_pParentDialog)
		return m_pOwnerEditor->GetInfoForListItem(m_pParentDialog, m_pParentDialog->GetCurrentType(), pObject);
	else
		return m_pOwnerEditor->GetInfoForListItem(this, m_pSortedList, pObject);
}

/*----------------------------------------
	Owner Draw List
----------------------------------------*/
void CPA_SortedListBox::SetOwnerDrawStyle (BOOL bOwnerDraw)
{
	if (bOwnerDraw)
		ModifyStyle(0, LVS_OWNERDRAWFIXED);
	else
		ModifyStyle(LVS_OWNERDRAWFIXED, 0);
}


/*----------------------------------------
	Adjust colums width 
----------------------------------------*/
void CPA_SortedListBox::SetAdjustSize (BOOL bAdjust)
{
	m_bAdjustSize = bAdjust;

	if (m_bAdjustSize)
	{
		fn_vReinitColumnWidth();
		fn_vReinitListObjects();
		SetSelectedItem(m_iSelectedItem);
	}
}

/*----------------------------------------
	Adjust colums width when size changes
----------------------------------------*/
void CPA_SortedListBox::OnSize (UINT nType, int cx, int cy)
{
	if (!g_bIsBuildingList)
	{
		if ((m_bAdjustSize)&&(!g_bIsAdjusting))
		{
			g_bIsAdjusting = TRUE;
			fn_vReinitColumnWidth();
			fn_vReinitListObjects();
			SetSelectedItem(m_iSelectedItem);
			g_bIsAdjusting = FALSE;
		}
		else
			CListCtrl::OnSize(nType, cx, cy);
	}
}


/*----------------------------------------
	Disable Icon
----------------------------------------*/
void CPA_SortedListBox::fn_vDisableIcon (CDC *pDC, POINT pt, COLORREF cRectColor)
{
	int i, j;

	for (i = 0; i < 17; i+=2)
	{
		for (j = 0; j < 17 ; j+=2)
		{
			pDC->SetPixelV(pt.x + i, pt.y + j, cRectColor);
		}
	}
}

/*----------------------------------------
	Draw Item
----------------------------------------*/
void CPA_SortedListBox::DrawItem (LPDRAWITEMSTRUCT lpDIS)
{
	CPA_BaseObject	*pElem;
 	COLORREF		cTextColor;
	COLORREF		cRectColor;
	CString			csInfo;
	POINT			pt;
	RECT			rcItem;
	BOOL			bRes;
	CDC				*pDC;
	int				iNumIcon, iState, iInd = 0;

	// get element
	pElem = (CPA_BaseObject *) GetItemData(lpDIS->itemID);
	if (!pElem)
		return;

	// get icon
	if ((m_pIconList)&&(m_lDrawStyle & C_lDrawIcon))
		iNumIcon = GetCorrespondingIcon(pElem);
	// get state
	if ((m_pStateList)&&(m_lDrawStyle & C_lDrawState))
		iState = GetCorrespondingState(pElem);

	// get colors
	bRes = GetCorrespondingColors(pElem, &cRectColor, &cTextColor);
	if (!bRes)
	{
		if (lpDIS->itemState & ODS_SELECTED)
		{
			cRectColor = RGB (0, 0, 254);
			cTextColor = (pElem->fn_bIsAvailable()) ? RGB(254, 254, 254) : RGB(126, 126, 126);
		}
		else if ((int)lpDIS->itemID == m_iTargetItem)
		{
			cRectColor = RGB (0, 0, 0);
			cTextColor = (pElem->fn_bIsAvailable()) ? RGB(254, 254, 254) : RGB(126, 126, 126);
		}
		else
		{
			cRectColor = RGB (254, 254, 254);
			cTextColor = (pElem->fn_bIsAvailable()) ? RGB(0, 0, 0) : RGB(126, 126, 126);
		}
	}

    // drawing parameters
	pDC = CDC::FromHandle(lpDIS->hDC);
	pt.x = lpDIS->rcItem.left;
	pt.y = lpDIS->rcItem.top;
	// draw background
	pDC->FillSolidRect(&lpDIS->rcItem, cRectColor);
    pDC->SetBkMode(TRANSPARENT);
	pDC->SetTextColor(cTextColor);

	// if necessary, draw state icon
	if ((m_pStateList)&&(m_lDrawStyle & C_lDrawState))
	{
		m_pStateList->SetBkColor(cRectColor);
		m_pStateList->Draw(pDC, iState, pt, ILD_NORMAL);
		if (!pElem->fn_bIsAvailable())
			fn_vDisableIcon(pDC, pt, cRectColor);
		pt.x += 20;
		iInd++;
	}
	// draw icon
	if ((m_pIconList)&&(m_lDrawStyle & C_lDrawIcon))
	{
		m_pIconList->SetBkColor(cRectColor);
		m_pIconList->Draw(pDC, iNumIcon, pt, ILD_NORMAL);
		if (!pElem->fn_bIsAvailable())
			fn_vDisableIcon(pDC, pt, cRectColor);
		pt.x += 20;
		iInd++;
	}

	// draw name
	rcItem = lpDIS->rcItem;
	rcItem.left = pt.x;
	rcItem.right = rcItem.left + GetColumnWidth(iInd++) - 5;
	pDC->DrawText(pElem->GetNameToDraw(), &rcItem, DT_SINGLELINE | DT_LEFT | DT_VCENTER);

	// draw type
	if (m_lDrawStyle & C_lDrawType)
	{
		rcItem.left = rcItem.right + 5;
		rcItem.right = rcItem.left + GetColumnWidth(iInd++) - 5;
		pDC->DrawText(pElem->GetTypeToDraw(), &rcItem, DT_SINGLELINE | DT_LEFT | DT_VCENTER);
	}
	// owner
	if (m_lDrawStyle & C_lDrawOwner)
	{
		rcItem.left = rcItem.right + 5;
		rcItem.right = rcItem.left + GetColumnWidth(iInd++) - 5;
		pDC->DrawText(pElem->GetOwnerToDraw(), &rcItem, DT_SINGLELINE | DT_LEFT | DT_VCENTER);
	}
	// info
	if (m_lDrawStyle & C_lDrawInfo)
	{
		rcItem.left = rcItem.right + 5;
		rcItem.right = rcItem.left + GetColumnWidth(iInd++) - 5;
		csInfo = GetCorrespondingInfo(pElem);
		pDC->DrawText(csInfo, &rcItem, DT_SINGLELINE | DT_LEFT | DT_VCENTER);
	}
}


/*----------------------------------------
	Update order when column is clicked
----------------------------------------*/
void CPA_SortedListBox::OnColumnClicked (NMHDR* pNMHDR, LRESULT* pResult)
{
	LPNM_LISTVIEW	pNMListView = (LPNM_LISTVIEW)pNMHDR;
	tdeSortCriteria	eCriteria;
	int				iNumColumn;
		
	if (!m_bCanChangeOrder)
		return;
	
	if (pNMListView->iItem != -1)
		return;
	
	// get corresponding column
	iNumColumn = pNMListView->iSubItem;
	eCriteria = GetColumnType(iNumColumn);
	if (eCriteria == E_sc_None)
		return;

	// update list order
	fn_vSortListByCriteria(eCriteria);
	SetOrder(E_lo_Edited);
}

/*----------------------------------------
	Get Column Type from number
----------------------------------------*/
tdeSortCriteria CPA_SortedListBox::GetColumnType (int iNumColumn)
{
	int iInd = 0;

	// state ?
	if ((m_lDrawStyle & C_lDrawState)&&(m_pStateList))
	{
		if (iInd++ == iNumColumn)
			return E_sc_State;
	}
	// icon ?
	if ((m_lDrawStyle & C_lDrawIcon)&&(m_pIconList))
	{
		if (iInd++ == iNumColumn)
			return E_sc_Icon;
	}
	// name
	if (iInd++ == iNumColumn)
		return E_sc_Name;

	if (m_lDrawStyle & C_lDrawType)
	{
		if (iInd++ == iNumColumn)
			return E_sc_Type;
	}

	if (m_lDrawStyle & C_lDrawOwner)
	{
		if (iInd++ == iNumColumn)
			return E_sc_Owner;
	}

	return E_sc_None;
}

/*----------------------------------------
	Index By State To Draw
----------------------------------------*/
int CPA_SortedListBox::GetIndexByStateToDraw (CPA_BaseObject *pObject)
{
	CPA_BaseObject		*pElem;
	CString				csName, csNameRef;
	int					iState, iStateRef;
	int					iInd;

	iStateRef = GetCorrespondingState(pObject);
	csNameRef = pObject->GetNameToDraw();

	for (iInd = 0; iInd < m_pSortedList->GetCount(); iInd++)
	{
		pElem = m_pSortedList->GetObjectWithIndex(iInd, E_lo_Edited);
		// get icon
		csName = pElem->GetNameToDraw();
		iState = GetCorrespondingState(pElem);
	
		if (iState > iStateRef)
			return iInd;
		if ((iState == iStateRef)&&(csName >= csNameRef))
			return iInd;
	}

	return (m_pSortedList->GetCount() - 1);
}

/*----------------------------------------
	Index By Icon To Draw
----------------------------------------*/
int CPA_SortedListBox::GetIndexByIconToDraw (CPA_BaseObject *pObject)
{
	CPA_BaseObject		*pElem;
	CString				csName, csNameRef;
	int					iIcon, iIconRef;
	int					iInd;

	iIconRef = GetCorrespondingIcon(pObject);
	csNameRef = pObject->GetNameToDraw();

	for (iInd = 0; iInd < m_pSortedList->GetCount(); iInd++)
	{
		pElem = m_pSortedList->GetObjectWithIndex(iInd, E_lo_Edited);
		// get icon
		iIcon = GetCorrespondingIcon(pElem);
		csName = pElem->GetNameToDraw();
	
		if (iIcon > iIconRef)
			return iInd;
		if ((iIcon == iIconRef)&&(csName >= csNameRef))
			return iInd;
	}

	return (m_pSortedList->GetCount() - 1);
}

/*----------------------------------------
	Index By Name To Draw
----------------------------------------*/
int CPA_SortedListBox::GetIndexByNameToDraw (CPA_BaseObject *pObject)
{
	CPA_BaseObject		*pElem;
	CString				csName, csNameRef;
	int					iInd;

	csNameRef = pObject->GetNameToDraw();
	
	for (iInd = 0; iInd < m_pSortedList->GetCount(); iInd++)
	{
		pElem = m_pSortedList->GetObjectWithIndex(iInd, E_lo_Edited);
		csName = pElem->GetNameToDraw();
	
		if (csName >= csNameRef)
			return iInd;
	}
	return (m_pSortedList->GetCount() - 1);
}


/*----------------------------------------
	Index By Type To Draw
----------------------------------------*/
int CPA_SortedListBox::GetIndexByTypeToDraw (CPA_BaseObject *pObject)
{
	CPA_BaseObject		*pElem;
	CString				csType, csTypeRef;
	CString				csName, csNameRef;
	int					iInd;

	csTypeRef = pObject->GetTypeToDraw();
	csNameRef = pObject->GetNameToDraw();
	
	for (iInd = 0; iInd < m_pSortedList->GetCount(); iInd++)
	{
		pElem = m_pSortedList->GetObjectWithIndex(iInd, E_lo_Edited);
		csType = pElem->GetTypeToDraw();
		csName = pElem->GetNameToDraw();
	
		if (csType > csTypeRef)
			return iInd;
		if ((csType == csTypeRef)&&(csName >= csNameRef))
			return iInd;
	}

	return (m_pSortedList->GetCount() - 1);
}

/*----------------------------------------
	Index By Owner To Draw
----------------------------------------*/
int CPA_SortedListBox::GetIndexByOwnerToDraw (CPA_BaseObject *pObject)
{
	CPA_BaseObject		*pElem;
	CString				csOwner, csOwnerRef;
	CString				csName, csNameRef;
	int					iInd;

	csOwnerRef = pObject->GetOwnerToDraw();
	csNameRef = pObject->GetNameToDraw();
	
	for (iInd = 0; iInd < m_pSortedList->GetCount(); iInd++)
	{
		pElem = m_pSortedList->GetObjectWithIndex(iInd, E_lo_Edited);
		csOwner = pElem->GetOwnerToDraw();
		csName = pElem->GetNameToDraw();
	
		if (csOwner > csOwnerRef)
			return iInd;
		if ((csOwner == csOwnerRef)&&(csName >= csNameRef))
			return iInd;
	}

	return (m_pSortedList->GetCount() - 1);
}


/*----------------------------------------
	Resort List
----------------------------------------*/
void CPA_SortedListBox::fn_vSortListByCriteria(tdeSortCriteria eCriteria)
{
	CPA_BaseObject		*pElem;
	int					iInd, iNewInd;

	for (iInd = 0; iInd < m_pSortedList->GetCount(); iInd++)
	{
		pElem = m_pSortedList->GetObjectWithIndex(iInd, E_lo_Alpha);
		switch (eCriteria)
		{
			case E_sc_State:
				iNewInd = GetIndexByStateToDraw(pElem);
				break;
			case E_sc_Icon:
				iNewInd = GetIndexByIconToDraw(pElem);
				break;
			case E_sc_Name:
				iNewInd = GetIndexByNameToDraw(pElem);
				break;
			case E_sc_Type:
				iNewInd = GetIndexByTypeToDraw(pElem);
				break;
			case E_sc_Owner:
				iNewInd = GetIndexByOwnerToDraw(pElem);
				break;
		}
		m_pSortedList->fn_bChangeObjectOrder(pElem, iNewInd, E_lo_Edited);
	}
}



#endif // ACTIVE_EDITOR