/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : Combat																		  *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/wwui/listctrl.cpp         $*
 *                                                                                             *
 *                       Author:: Patrick Smith                                                *
 *                                                                                             *
 *                     $Modtime:: 3/01/02 4:37p                                               $*
 *                                                                                             *
 *                    $Revision:: 41                                                          $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */


#include "listctrl.h"
#include "assetmgr.h"
#include "refcount.h"
#include "mousemgr.h"
#include "ww3d.h"
#include "dialogmgr.h"
#include "dialogbase.h"
#include "stylemgr.h"
#include <commctrl.h>


////////////////////////////////////////////////////////////////
//	Local constants
////////////////////////////////////////////////////////////////
const float	PULSE_RATE		= 2.0F;
const int	ROW_SPACING		= 4;


////////////////////////////////////////////////////////////////
//
//	ListCtrlClass
//
////////////////////////////////////////////////////////////////
ListCtrlClass::ListCtrlClass (void)	:
	CurrState (NORMAL),
	ScrollPos (0),
	HeaderRect (0, 0, 0, 0),
	TextRect (0, 0, 0, 0),
	CurrSel (-1),
	RowBorderHeight (0),
	PulsePercent (1.0F),
	PulseDirection (1.0F),
	IsScrollBarDisplayed (false),
	LastPageTopEntryIndex (0),
	IsSelectionAllowed(true),
	IsNoSelectionAllowed(false),
	IsMultipleSelection (false),
	SortColumn (0),
	SortType (SORT_NONE),
	MinRowHeight (0)
{
	//
	//	Configure each renderer
	//
	StyleMgrClass::Configure_Renderer (&ControlRenderer);
	StyleMgrClass::Configure_Renderer (&UnderlineRenderer);
	StyleMgrClass::Configure_Renderer (&HilightRenderer);
	StyleMgrClass::Configure_Hilighter (&HilightRenderer);

	//
	//	Set the font for each text renderer
	//
	StyleMgrClass::Assign_Font (&HeaderRenderer, StyleMgrClass::FONT_HEADER);
	StyleMgrClass::Assign_Font (&TextRenderer, StyleMgrClass::FONT_LISTS);
	TextRenderer.Set_Texture_Size_Hint (256);

	//
	//	We don't want the scroll bar getting focus
	//
	ScrollBarCtrl.Set_Wants_Focus (false);
	ScrollBarCtrl.Set_Advise_Sink (this);
	ScrollBarCtrl.Set_Is_Embedded (true);
	return ;
}


////////////////////////////////////////////////////////////////
//
//	~ListCtrlClass
//
////////////////////////////////////////////////////////////////
ListCtrlClass::~ListCtrlClass (void)
{
	Delete_All_Entries ();

	if (Parent != NULL) {
		Parent->Remove_Control (&ScrollBarCtrl);
	}

	return ;
}


void ListCtrlClass::Set_Tabstop(float stop)
{
	TextRenderer.Set_Tabstop(stop);
}


////////////////////////////////////////////////////////////////
//
//	Create_Control_Renderer
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Create_Control_Renderer (void)
{
	Render2DClass &renderer = ControlRenderer;

	//
	//	Configure this renderer
	//
	renderer.Reset ();
	renderer.Enable_Texturing (false);

	//
	//	Determine which color to draw the outline in
	//
	int color		= StyleMgrClass::Get_Line_Color ();
	int bkcolor		= StyleMgrClass::Get_Bk_Color ();
	if (CurrState == DISABLED) {
		color		= StyleMgrClass::Get_Disabled_Line_Color ();
		bkcolor	= StyleMgrClass::Get_Disabled_Bk_Color ();
	}

	//
	//	Draw the outline
	//
	renderer.Add_Rect (Rect, 1.0F, color, bkcolor);

	//
	//	Draw the selection bar if necessary
	//
	if (CurrSel != -1) {

		//
		//	Calculate what percentage our pulse effect is
		//
		PulsePercent += PulseDirection * PULSE_RATE * (DialogMgrClass::Get_Frame_Time () / 1000.0F);
		if (PulsePercent < 0 || PulsePercent > 1.0F) {
			PulseDirection = -PulseDirection;
			PulsePercent = WWMath::Clamp (PulsePercent, 0, 1);
		}

		//
		//	If this control has the focus then apply our pulsating effect to
		// the color of selection bar.
		//
		if (HasFocus) {

			float red	=  ((color & 0x00FF0000) >> 16) / 256.0F;
			float green	=  ((color & 0x0000FF00) >> 8) / 256.0F;
			float blue	=  ((color & 0x000000FF)) / 256.0F;

			float percent = (PulsePercent * 0.5F) + 0.5F;
			color = VRGB_TO_INT32 (Vector3 (red * percent, green * percent, blue * percent));
		}

		//
		//	Get the hilight rect
		//
		RectClass sel_rect;
		Get_Entry_Rect (CurrSel, sel_rect);
		if (sel_rect.Top >= TextRect.Top && sel_rect.Bottom <= TextRect.Bottom) {

			//
			//	Render the outline of the selection (if its on the screen)
			//
			renderer.Add_Outline (sel_rect, 1.0F, color);
		}
	}

	return ;
}


////////////////////////////////////////////////////////////////
//
//	Create_Text_Renderers
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Create_Text_Renderers (void)
{
	//
	//	Configure the text renderers
	//
	HeaderRenderer.Reset ();
	TextRenderer.Reset ();
	HilightRenderer.Reset ();
	UnderlineRenderer.Reset ();
	IconMgr.Reset_Renderers ();

	//
	//	Prepare the column header (if necessary)
	//
	if ((Style & LVS_NOCOLUMNHEADER) == 0) {

		//
		//	Render each column header
		//
		int x_pos = HeaderRect.Left;
		for (int index = 0; index < ColList.Count (); index ++) {

			//
			//	Build a bounding rectangle for this column header
			//
			RectClass rect = HeaderRect;
			rect.Left	= x_pos;
			rect.Right	= x_pos + (ColList[index]->Get_Width () * HeaderRect.Width ());

			//
			//	Let the last column extend to the edge
			//
			if (index == ColList.Count () - 1) {
				rect.Right = HeaderRect.Right;
			}

			//
			//	Get the color
			//
			int color = VRGB_TO_INT32 (ColList[index]->Get_Color ());

			//
			//	Underline the header
			//
			Vector2 text_extent = HeaderRenderer.Get_Text_Extents (ColList[index]->Get_Name ());
			float y_pos = (rect.Top + (rect.Height () / 2) + (text_extent.Y / 2)) + 2.0F;
			UnderlineRenderer.Add_Line (Vector2 (rect.Left, y_pos),
										Vector2 (rect.Left + text_extent.X, y_pos), 1.0F, color);

			//
			//	Draw the sort designator
			//
			if (SortType != SORT_NONE && SortColumn == index) {

				const float TRI_WIDTH	= 8;
				const float TRI_SPACE	= 2;

				float tri_size			= TRI_WIDTH * StyleMgrClass::Get_Y_Scale ();
				float tri_half_size	= tri_size * 0.5F;
				float tri_x_pos		= rect.Left + text_extent.X + tri_size + (TRI_SPACE * StyleMgrClass::Get_Y_Scale ());
				float tri_y_pos		= HeaderRect.Center ().Y;

				if (SortType == SORT_ASCENDING) {

					UnderlineRenderer.Add_Line (Vector2 (tri_x_pos - tri_half_size, tri_y_pos + tri_half_size),
												Vector2 (tri_x_pos + tri_half_size, tri_y_pos + tri_half_size), 1.0F, color);

					UnderlineRenderer.Add_Line (Vector2 (tri_x_pos + tri_half_size, tri_y_pos + tri_half_size),
												Vector2 (tri_x_pos, tri_y_pos - tri_half_size), 1.0F, color);

					UnderlineRenderer.Add_Line (Vector2 (tri_x_pos, tri_y_pos - tri_half_size),
												Vector2 (tri_x_pos - tri_half_size, tri_y_pos + tri_half_size), 1.0F, color);
					
				} else {

					UnderlineRenderer.Add_Line (Vector2 (tri_x_pos - tri_half_size, tri_y_pos - tri_half_size),
												Vector2 (tri_x_pos + tri_half_size, tri_y_pos - tri_half_size), 1.0F, color);

					UnderlineRenderer.Add_Line (Vector2 (tri_x_pos + tri_half_size, tri_y_pos - tri_half_size),
												Vector2 (tri_x_pos, tri_y_pos + tri_half_size), 1.0F, color);

					UnderlineRenderer.Add_Line (Vector2 (tri_x_pos, tri_y_pos + tri_half_size),
												Vector2 (tri_x_pos - tri_half_size, tri_y_pos - tri_half_size), 1.0F, color);
				}
			}

			//
			//	Render the text
			//
			StyleMgrClass::Render_Text (ColList[index]->Get_Name (), &HeaderRenderer,
									color, RGB_TO_INT32 (0, 0, 0), rect, true, true);

			//
			//	Move on to the next column
			//
			x_pos = rect.Right;
		}
	}

	//
	//	Render the data by rows
	//
	float y_pos		= TextRect.Top;
	int row_count	= Get_Entry_Count ();
	for (int row_index = ScrollPos; row_index < row_count; row_index ++) {

		//
		//	Get the height of this row
		//
		float row_height = RowInfoList[row_index]->Get_Height ();

		//
		//	Don't render past the bottom of the control
		//
		if ((y_pos + row_height) >= TextRect.Bottom) {
			break;
		}

		//
		//	Render each column in this row
		//
		float x_pos = TextRect.Left;
		for (int index = 0; index < ColList.Count (); index ++) {

			//
			//	Determine how wide this column is
			//
			float col_width = (ColList[index]->Get_Width () * HeaderRect.Width ());		
			if (index == ColList.Count () - 1) {
				col_width = TextRect.Right - x_pos;
			}

			//
			//	Build a bounding rectangle for this entry
			//
			RectClass rect;
			rect.Left	= int(x_pos);
			rect.Right	= int(x_pos + col_width);
			rect.Top		= int(y_pos);
			rect.Bottom	= int(y_pos + row_height);

			//
			//	Render the entry
			//
			Render_Entry (rect, index, row_index);

			//
			//	Move on to the next column
			//
			x_pos = rect.Right;
		}

		//
		//	Render a hilight on this row if necessary
		//
		if (Is_Entry_Selected (row_index)) {
			RectClass row_rect	= TextRect;
			row_rect.Top			= (int)max (TextRect.Top, (float)y_pos);
			row_rect.Bottom		= (int)min (TextRect.Bottom, (float)(y_pos + row_height));
			StyleMgrClass::Render_Hilight (&HilightRenderer, row_rect);
		}

		//
		//	Move down to the next row
		//
		y_pos += row_height;
	}

	return ;
}


////////////////////////////////////////////////////////////////
//
//	Render_Entry
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Render_Entry (const RectClass &clip_rect, int col_index, int row_index)
{
	RectClass rect = clip_rect;

	//
	//	Render the icons
	//
	int icon_count = ColList[col_index]->Get_Icon_Count (row_index);
	for (int index = 0; index < icon_count; index ++) {		
		
		//
		//	Render this icon
		//
		const char *icon_name = ColList[col_index]->Get_Icon (row_index, index);
		IconMgr.Render_Icon (rect, icon_name);

		//
		//	Move the rect by the width of the icon
		//
		rect.Left += IconMgr.Get_Icon_Width ();
	}

	//
	//	Get the text
	//
	const WCHAR *text = ColList[col_index]->Get_Entry_Text (row_index);
	int text_color		= VRGB_TO_INT32 (ColList[col_index]->Get_Entry_Color (row_index));
				
	//
	//	Render the text
	//
	StyleMgrClass::Render_Wrapped_Text (text, &TextRenderer, text_color,
							RGB_TO_INT32 (0, 0, 0), rect, true, true);

	return ;
}


////////////////////////////////////////////////////////////////
//
//	On_Set_Cursor
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::On_Set_Cursor (const Vector2 &mouse_pos)
{
	if (IsSelectionAllowed) {
		//
		//	Change the mouse cursor
		//
		MouseMgrClass::Set_Cursor (MouseMgrClass::CURSOR_ACTION);
	}

	return ;
}


////////////////////////////////////////////////////////////////
//
//	Set_Sort_Designator
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Set_Sort_Designator (int col_index, SORT_TYPE type)
{
	SortColumn	= col_index;
	SortType		= type;
	
	Set_Dirty ();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Sort_Alphabetically
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Sort_Alphabetically (int col_index, SORT_TYPE type)
{
	//
	//	Sort the entries
	//
	Sort (Default_Sort_Callback, MAKELONG ((WORD)col_index, (WORD)type));

	//
	//	Update the sort marker
	//
	Set_Sort_Designator (col_index, type);
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Default_Sort_Callback
//
////////////////////////////////////////////////////////////////
int CALLBACK
ListCtrlClass::Default_Sort_Callback (ListCtrlClass *list_ctrl, int item_index1, int item_index2, uint32 user_param)
{
	//
	//	Get the sorting params
	//
	int	sort_col_index = LOWORD (user_param);
	SORT_TYPE sort_type = (SORT_TYPE)HIWORD (user_param);
		
	//
	//	Sort by name
	//
	const WCHAR *name1 = list_ctrl->Get_Entry_Text (item_index1, sort_col_index);
	const WCHAR *name2 = list_ctrl->Get_Entry_Text (item_index2, sort_col_index);

	int retval = ::CompareStringW (LOCALE_USER_DEFAULT, NORM_IGNORECASE, name1, -1, name2, -1);

	if (retval == 0) {
		retval = wcsicmp(name1, name2);
	} else {
		retval -= 2;
	}

	//
	//	Invert the return value if we are sorting descendingly
	//
	if (sort_type == SORT_DESCENDING) {
		retval = -retval;
	}

	return retval;
}


////////////////////////////////////////////////////////////////
//
//	Update_Client_Rect
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Update_Client_Rect (void)
{
	Vector2 header_size = HeaderRenderer.Get_Text_Extents (L"W");

	//
	//	Set the client area
	//
	ClientRect = Rect;
	ClientRect.Inflate (Vector2 (-header_size.X, -1));
	HeaderRect	= ClientRect;
	TextRect		= ClientRect;

	//
	//	Calculate what the header rectangle should be
	//
	if ((Style & LVS_NOCOLUMNHEADER) == 0) {
		float char_height = header_size.Y;
		HeaderRect.Bottom	= HeaderRect.Top + (char_height * 3);
	} else {
		HeaderRect.Bottom = HeaderRect.Top;
	}

	//
	//	Move the text rectangle down
	//
	TextRect.Top = HeaderRect.Bottom;

	//float scale_y = Render2DClass::Get_Screen_Resolution().Height () / 600;

	//
	//	Choose an arbitrary width, the scroll bar
	// will snap to the only width it supports
	//
	float width = 10;

	//
	//	Calculate the scroll bar's rectangle
	//
	RectClass scroll_rect;
	scroll_rect.Left		= Rect.Right - width;
	scroll_rect.Top		= Rect.Top;
	scroll_rect.Right		= Rect.Right;
	scroll_rect.Bottom	= Rect.Bottom;

	//
	//	Size the scroll bar
	//
	ScrollBarCtrl.Set_Window_Rect (scroll_rect);	

	Set_Dirty ();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Find_Top_Of_Page
//
////////////////////////////////////////////////////////////////
int
ListCtrlClass::Find_Top_Of_Page (int bottom_index)
{
	int retval	= 0;
	//int count	= RowInfoList.Count ();	
	float y_pos	= TextRect.Bottom;

	//
	//	Scan the entries until we've found the first one
	// to extend off the top of the page
	//
	for (int index = bottom_index; index >= 0; index --) {
		y_pos -= RowInfoList[index]->Get_Height ();

		//
		//	If we've gone off the page, then back off one entry
		//
		if (y_pos < TextRect.Top) {
			retval = (index + 1);
			break;
		}
	}
	
	return retval;
}


////////////////////////////////////////////////////////////////
//
//	Find_End_Of_Page
//
////////////////////////////////////////////////////////////////
int
ListCtrlClass::Find_End_Of_Page (void)
{
	int count	= RowInfoList.Count ();
	int retval	= count;
	float y_pos	= TextRect.Top;

	//
	//	Scan the entries until we've found the first one
	// to extend off the page
	//
	for (int index = ScrollPos; index < count; index ++) {
		y_pos += RowInfoList[index]->Get_Height ();

		//
		//	If we've gone off the page, then back off one entry
		//
		if (y_pos >= TextRect.Bottom) {
			retval = (index - 1);
			break;
		}
	}
	
	return retval;
}


////////////////////////////////////////////////////////////////
//
//	Find_Last_Page_Top_Entry
//
////////////////////////////////////////////////////////////////
int
ListCtrlClass::Find_Last_Page_Top_Entry (void)
{
	int retval = 0;

	float y_pos	= TextRect.Bottom;
	int count	= RowInfoList.Count ();
	
	//
	//	Scan backwards from the bottom entry until we've
	// found one that extends off the top of the page.
	//
	for (int index = count - 1; index >= 0; index --) {
		y_pos -= RowInfoList[index]->Get_Height ();
		if (y_pos <= TextRect.Top) {
			retval = index + 1;
			break;
		}
	}
	
	return retval;
}


////////////////////////////////////////////////////////////////
//
//	Update_Scroll_Bar_Visibility
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Update_Scroll_Bar_Visibility (void)
{
	LastPageTopEntryIndex = Find_Last_Page_Top_Entry ();

	//
	//	Configure the scroll-bar's ranges
	//
	ScrollBarCtrl.Set_Page_Size (0);
	ScrollBarCtrl.Set_Range (0, LastPageTopEntryIndex);

	//
	//	Determine if we have more entries then we can
	// display on one page
	//
	bool needs_scrollbar	= false;
	float y_pos				= TextRect.Top;
	for (int index = 0; index < RowInfoList.Count (); index ++) {
		y_pos += RowInfoList[index]->Get_Height ();
		if (y_pos >= TextRect.Bottom) {
			needs_scrollbar = true;
			break;
		}
	}

	float new_right = 0;

	//
	//	Do we need to show a scroll bar?
	//
	bool was_scrollbar_displayed = IsScrollBarDisplayed;
	if (needs_scrollbar) {
		new_right = ScrollBarCtrl.Get_Window_Rect ().Left;
		IsScrollBarDisplayed = true;
	} else if (Parent != NULL) {
		new_right = ScrollBarCtrl.Get_Window_Rect ().Right;
		IsScrollBarDisplayed = false;
	}

	//
	//	Reset our window size (as necessary)
	//
	Rect.Right			= new_right;
	ClientRect.Right	= Rect.Right - (ClientRect.Left - Rect.Left);
	TextRect.Right		= ClientRect.Right;
	HeaderRect.Right	= ClientRect.Right;

	//
	//	Update the row heights of each entry if the scroll bar
	// visibility changed
	//
	if (was_scrollbar_displayed != IsScrollBarDisplayed) {
		for (index = 0; index < RowInfoList.Count (); index ++) {
			Update_Row_Height (index);
		}

		//
		//	Update the last page top entry
		//
		LastPageTopEntryIndex = Find_Last_Page_Top_Entry ();
	}

	//
	//	Configure the scroll-bar's ranges
	//
	ScrollBarCtrl.Set_Page_Size (0);
	ScrollBarCtrl.Set_Range (0, LastPageTopEntryIndex);

	//
	//	Configure the scroll bar's position
	//
	if (ScrollBarCtrl.Get_Pos () > LastPageTopEntryIndex) {
		int new_pos = max (LastPageTopEntryIndex, 0);
		ScrollBarCtrl.Set_Pos (new_pos);
	}

	return ;
}


////////////////////////////////////////////////////////////////
//
//	Render
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Render (void)
{
	//
	//	Recreate the renderers (if necessary)
	//
	if (IsDirty) {
		Update_Scroll_Bar_Visibility ();
		Create_Text_Renderers ();
	}

	if (IsScrollBarDisplayed) {
		Parent->Add_Control (&ScrollBarCtrl);
	} else {
		Parent->Remove_Control (&ScrollBarCtrl);
	}

	if (HasFocus || IsDirty) {
		Create_Control_Renderer ();
	}

	//
	//	Render the background and text
	//	
	IconMgr.Render_Icons ();
	TextRenderer.Render ();
	HilightRenderer.Render ();
	UnderlineRenderer.Render ();
	HeaderRenderer.Render ();
	ControlRenderer.Render ();

	DialogControlClass::Render ();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Get_First_Selected
//
////////////////////////////////////////////////////////////////
int
ListCtrlClass::Get_First_Selected (void) const
{
	int retval = -1;

	//
	//	Loop over all the entries in the list control
	//
	int entry_count = Get_Entry_Count ();
	for (int index = 0; index < entry_count; index ++) {
		
		//
		//	Is this entry selected?
		//
		if (RowInfoList[index]->Is_Selected ()) {
			retval = index;
			break;
		}
	}

	return retval;
}


////////////////////////////////////////////////////////////////
//
//	Get_Next_Selected
//
////////////////////////////////////////////////////////////////
int
ListCtrlClass::Get_Next_Selected (int index) const
{
	int retval = -1;

	//
	//	Loop over all the entries in the list control
	//
	int entry_count = Get_Entry_Count ();
	for (index ++; index < entry_count; index ++) {
		
		//
		//	Is this entry selected?
		//
		if (RowInfoList[index]->Is_Selected ()) {
			retval = index;
			break;
		}
	}

	return retval;
}


////////////////////////////////////////////////////////////////
//
//	Select_All
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Select_All (bool select)
{
	//
	//	Loop over all the entries in the list control
	//
	int entry_count = Get_Entry_Count ();
	for (int index = 0; index < entry_count; index ++) {
		RowInfoList[index]->Select (select);
	}

	Set_Dirty();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Toggle_Entry_Selection
//
////////////////////////////////////////////////////////////////
bool
ListCtrlClass::Toggle_Entry_Selection (int index)
{
	if (index < 0 || index >= Get_Entry_Count ()) {
		return false;
	}

	//
	//	Toggle the selection of this entry
	//
	bool selected = RowInfoList[index]->Is_Selected ();
	RowInfoList[index]->Select (!selected);
	Set_Dirty ();

	return false;
}


////////////////////////////////////////////////////////////////
//
//	On_LButton_DblClk
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::On_LButton_DblClk (const Vector2 &mouse_pos)
{
	int sel_entry = Entry_From_Pos (mouse_pos);
	if (sel_entry == CurrSel) {

		//
		//	Notify any advise sinks
		//
		ADVISE_NOTIFY (On_ListCtrl_DblClk (this, Get_ID (), sel_entry));
	}

	return ;
}


////////////////////////////////////////////////////////////////
//
//	On_LButton_Down
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::On_LButton_Down (const Vector2 &mouse_pos)
{
	if (mouse_pos.Y <= HeaderRect.Bottom) {

		//
		//	Find out which column was clicked
		//
		int col_index = Col_From_Pos (mouse_pos);

		if (-1 != col_index) {
			//
			//	Notify any advise sinks
			//
			ADVISE_NOTIFY (On_ListCtrl_Column_Click (this, Get_ID (), col_index));
		}
	} else {

		//
		//	Change the hilighted entry to reflect the mouse click
		//
		int new_sel = Entry_From_Pos (mouse_pos);
		if (new_sel != -1) {
			Set_Sel (new_sel, true);
		} else if (IsNoSelectionAllowed) {
			Set_Sel(-1, true);
		}
	}

	return ;
}


////////////////////////////////////////////////////////////////
//
//	On_LButton_Up
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::On_LButton_Up (const Vector2 &mouse_pos)
{
	return ;
}


////////////////////////////////////////////////////////////////
//
//	On_Mouse_Move
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::On_Mouse_Move (const Vector2 &mouse_pos)
{
	int sel_entry = Entry_From_Pos(mouse_pos);
	ADVISE_NOTIFY(On_ListCtrl_Mouse_Over(this, Get_ID(), sel_entry));
	return ;
}


////////////////////////////////////////////////////////////////
//
//	On_Set_Focus
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::On_Set_Focus (void)
{
	Set_Dirty ();

	DialogControlClass::On_Set_Focus ();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	On_Kill_Focus
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::On_Kill_Focus (DialogControlClass *focus)
{
	Set_Dirty ();

	DialogControlClass::On_Kill_Focus (focus);
	return ;
}


////////////////////////////////////////////////////////////////
//
//	On_Key_Down
//
////////////////////////////////////////////////////////////////
bool
ListCtrlClass::On_Key_Down (uint32 key_id, uint32 key_data)
{
	bool handled = true;

	switch (key_id)
	{
		case VK_UP:
		case VK_LEFT:
			Set_Sel (CurrSel - 1, true);
			break;

		case VK_DOWN:
		case VK_RIGHT:
			Set_Sel (CurrSel + 1, true);
			break;

		case VK_PRIOR:
			if (CurrSel == ScrollPos) {
				Scroll_Page (-1);
			} else {
				Set_Sel (ScrollPos, true);
			}
			break;

		case VK_NEXT:
		{
			int end_of_page = Find_End_Of_Page ();

			//
			//	If we are at the end of the page, then
			// scroll one page, otherwise snap to the 
			// end of the page
			//
			if (CurrSel == end_of_page) {
				Scroll_Page (1);
			} else {
				Set_Sel (end_of_page, true);
			}
			break;
		}

		case VK_HOME:
			Set_Sel (0, true);
			break;

		case VK_END:
			Set_Sel (Get_Entry_Count () - 1, true);
			break;

		case VK_SPACE:
		case VK_RETURN:
			ADVISE_NOTIFY(On_ListCtrl_DblClk(this, Get_ID(), Get_Curr_Sel()));
			break;

		default:
			handled = false;
			break;
	}

	return handled;
}


////////////////////////////////////////////////////////////////
//
//	Sort
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Sort (LISTCTRL_SORT_CALLBACK sort_callback, uint32 user_param)
{
	//
	//	Quick sort the data
	//
	int entry_count = Get_Entry_Count ();
	if (entry_count > 1) {
		Quick_Sort (0, entry_count - 1, sort_callback, user_param);
	}

	//
	//	Force a repaint
	//
	Set_Dirty ();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Quick_Sort
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Quick_Sort
(
	int							start_index,
	int							end_index,
	LISTCTRL_SORT_CALLBACK	sort_callback,
	uint32						user_param
)
{
	//
	//	Setup a handy macro for swapping all columns of a particular row
	//
	#define QSORT_ROW_SWAP(index1, index2)														\
		{																									\
			if (CurrSel == index1)			{ CurrSel = index2; }							\
			else if (CurrSel == index2)	{ CurrSel = index1; }							\
			ListRowClass *temp	= RowInfoList[index1];										\
			RowInfoList[index1]	= RowInfoList[index2];										\
			RowInfoList[index2]	= temp;															\
			for (int col_index = 0; col_index < ColList.Count (); col_index ++) {	\
				ColList[col_index]->Swap_Entries (index1, index2);							\
			}																								\
		}

	//
	//	Determine our ranges
	//
	int pivot_index	= start_index;
	int min_index		= min (start_index + 1, end_index);
	int max_index		= end_index;

	//
	//	If the range is large enough, try to pick
	// a *good* pivot point.
	//
	if ((end_index - start_index) > 10) {
		int middle_index = start_index + ((end_index - start_index) / 2);

		//
		//	Put the smaller of the middle and end indices into the middle slot
		//
		if ((*sort_callback) (this, end_index, middle_index, user_param) < 0) {
			QSORT_ROW_SWAP (end_index, middle_index);
		}

		//
		//	Put the larger of the middle and start indices into the start slot
		//
		if ((*sort_callback) (this, middle_index, start_index, user_param) > 0) {
			QSORT_ROW_SWAP (middle_index, start_index);
		}

		//
		//	Put the smaller of the start and end indices into the start slot
		//
		if ((*sort_callback) (this, end_index, start_index, user_param) < 0) {
			QSORT_ROW_SWAP (end_index, start_index);
		}
	}

	//
	//	Put all the other entries in our range on either the lower or upper
	// side of the pivot entry based on their relative sort value.
	//
	bool keep_going = true;
	do
	{
		//
		//	Find the first entry that is "greater-than" the pivot
		//
		for (; min_index <= max_index; min_index ++) {

			//
			//	Is this entry "greater-than" the pivot?
			//
			if ((*sort_callback) (this, min_index, start_index, user_param) > 0) {
				break;
			}

			//
			//	The last index that is "less-than" the pivot entry will
			// be the pivot's new index.
			//
			pivot_index = min_index;
		}

		//
		//	Find the last entry that is "less-than" the pivot
		//
		for (; max_index >= min_index; max_index --) {

			//
			//	Is this entry "less-than" the pivot?
			//
			if ((*sort_callback) (this, max_index, start_index, user_param) < 0) {
				break;
			}
		}

		//
		//	Have we processed all the entries in our range?
		//
		if (min_index >= max_index) {
			keep_going = false;
		} else {

			//
			//	Swap the entries
			//
			QSORT_ROW_SWAP (min_index, max_index);

			//
			//	For efficiency's sake, skip over the entries we just swapped.
			//
			min_index ++;
			max_index --;
			pivot_index ++;
		}

	} while (keep_going);

	//
	//	Insert the pivot point into its "sorted" position in the array (if necessary)
	//
	if (pivot_index > start_index) {
		QSORT_ROW_SWAP (start_index, pivot_index);
	}

	//
	//	Calculate the region below the pivot
	//
	int lower_range_min = start_index;
	int lower_range_max = pivot_index - 1;

	//
	//	Recurse (if necessary) into the region below the pivot
	//
	if (lower_range_max < end_index && lower_range_min < lower_range_max) {
		Quick_Sort (lower_range_min, lower_range_max, sort_callback, user_param);
	}

	//
	//	Calculate the region above the pivot
	//
	int upper_range_min = pivot_index + 1;
	int upper_range_max = end_index;

	//
	//	Recurse (if necessary) into the region above the pivot
	//
	if (upper_range_min > start_index && upper_range_min < upper_range_max) {
		Quick_Sort (upper_range_min, upper_range_max, sort_callback, user_param);
	}

	return ;
}


////////////////////////////////////////////////////////////////
//
//	On_Create
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::On_Create (void)
{
	return ;
}


////////////////////////////////////////////////////////////////
//
//	On_Destroy
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::On_Destroy (void)
{
	Delete_All_Entries ();
	Delete_All_Columns ();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Auto_Size_Columns_Include_Contents
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Auto_Size_Columns_Include_Contents (float col_spacing)
{
	float total_width = HeaderRect.Width ();

	//
	//	Loop over all the columns
	//
	for (int index = 0; index < ColList.Count (); index ++) {
		float max_width = HeaderRenderer.Get_Text_Extents (ColList[index]->Get_Name ()).X;

		//
		//	Now, take into consideration the largest entry we've got
		//
		int count = ColList[index]->Get_Entry_Count ();
		for (int row = 0; row < count; row ++) {
			float width = TextRenderer.Get_Text_Extents (ColList[index]->Get_Entry_Text (row)).X;
			max_width = max (width, max_width);

			//
			//	Add the width of all the icons to this row's total
			//
			int icon_count = ColList[index]->Get_Icon_Count (row);
			for (int icon_index = 0; icon_index < icon_count; icon_index ++) {
				max_width += IconMgr.Get_Icon_Width ();
			}
		}

		//
		//	Auto-size this column
		//
		float percent = (max_width + col_spacing) / total_width;
		ColList[index]->Set_Width (percent);
	}

	return ;
}


////////////////////////////////////////////////////////////////
//
//	Auto_Size_Columns
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Auto_Size_Columns (float col_spacing)
{
	float max_width = HeaderRect.Width ();

	for (int index = 0; index < ColList.Count (); index ++) {

		//
		//	Auto-size this column
		//
		float width		= HeaderRenderer.Get_Text_Extents (ColList[index]->Get_Name ()).X;
		float percent	= (width + col_spacing) / max_width;
		ColList[index]->Set_Width (percent);
	}

	return ;
}


////////////////////////////////////////////////////////////////
//
//	Add_Icon
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Add_Icon (int index, int col_index, const char *texture_name)
{
	if (col_index < 0 || col_index >= ColList.Count ()) {
		return ;
	}

	//
	//	Add an icon to this entry
	//
	IconMgr.Add_Icon (texture_name);
	ColList[col_index]->Add_Icon (index, texture_name);
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Reset_Icons
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Reset_Icons (int index, int col_index)
{
	if (col_index < 0 || col_index >= ColList.Count ()) {
		return ;
	}

	//
	//	Reset all the icons in this entry
	//
	ColList[col_index]->Reset_Icons (index);
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Add_Column
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Add_Column (const WCHAR *column_name, float width, const Vector3 &color)
{
	//
	//	Create a new column and add it to the list
	//
	ListColumnClass *column = new ListColumnClass;
	column->Set_Name (column_name);
	column->Set_Width (width);
	column->Set_Color (color);
	ColList.Add (column);
	Set_Dirty ();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Set_Column_Color
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Set_Column_Color (int col_index, const Vector3 &color)
{
	if (col_index < 0 || col_index >= ColList.Count ()) {
		return ;
	}

	ColList[col_index]->Set_Color (color);
	Set_Dirty ();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Remove_Column
//
////////////////////////////////////////////////////////////////
bool
ListCtrlClass::Remove_Column (int index)
{
	if (index < 0 || index >= ColList.Count ()) {
		return false;
	}

	//
	//	Free the column
	//
	ListColumnClass *column = ColList[index];
	delete column;

	//
	//	Remove the column from the list
	//
	ColList.Delete (index);
	Set_Dirty ();
	return true;
}


////////////////////////////////////////////////////////////////
//
//	Delete_All_Columns
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Delete_All_Columns (void)
{
	for (int index = 0; index < ColList.Count (); index ++) {
		ListColumnClass *column = ColList[index];
		delete column;
	}

	ColList.Delete_All ();
	Set_Dirty ();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Get_Column_Count
//
////////////////////////////////////////////////////////////////
int
ListCtrlClass::Get_Column_Count (void) const
{
	return ColList.Count ();
}


////////////////////////////////////////////////////////////////
//
//	Get_Entry_Count
//
////////////////////////////////////////////////////////////////
int
ListCtrlClass::Get_Entry_Count (void) const
{
	return RowInfoList.Count ();
}


////////////////////////////////////////////////////////////////
//
//	Delete_Entry
//
////////////////////////////////////////////////////////////////
bool
ListCtrlClass::Delete_Entry (int index)
{
	bool retval = true;

	//
	//	Nofity the advise sinks that we are deleting this entry
	//
	ADVISE_NOTIFY (On_ListCtrl_Delete_Entry (this, Get_ID (), index));

	//
	//	Remove this row from our data structures
	//
	if (index >= 0 && index < RowInfoList.Count ()) {
		delete RowInfoList[index];
		RowInfoList.Delete (index);
	}

	//
	//	Remove this entry from each column
	//
	for (int col_index = 0; col_index < ColList.Count (); col_index ++) {
		retval &= ColList[col_index]->Delete_Entry (index);
	}

	// When an entry that is before the current selection is deleted then
	// we need to adjust the current selection to reflect that.
	if (index < CurrSel) {
		--CurrSel;
	}

	//
	//	Update the current selection indicator (if necessary)
	//
	int entry_count = Get_Entry_Count ();
	if (CurrSel >= entry_count) {
		CurrSel = entry_count - 1;
	}

	//
	//	Hilight the new current selection (if necessary)
	//
	if (CurrSel >= 0 && CurrSel <= RowInfoList.Count ()) {
		RowInfoList[CurrSel]->Select ((IsMultipleSelection == false));
	}

	Set_Dirty ();
	return retval;
}


////////////////////////////////////////////////////////////////
//
//	Find_Entry
//
////////////////////////////////////////////////////////////////
int ListCtrlClass::Find_Entry(int col_index, const WCHAR* text)
{
	int count = ColList.Count();

	if (col_index >= 0 && col_index < count) {
		ListColumnClass* list = ColList[col_index];
		count = list->Get_Entry_Count();

		for (int index = 0; index < count; index++) {
			const WCHAR* entryText = list->Get_Entry_Text(index);

			if (wcscmp(entryText, text) == 0) {
				return index;
			}
		}
	}

	return -1;
}


////////////////////////////////////////////////////////////////
//
//	Insert_Entry
//
////////////////////////////////////////////////////////////////
int
ListCtrlClass::Insert_Entry (int index, const WCHAR *text)
{
	if (ColList.Count () <= 0) {
		return -1;
	}

	//
	//	Insert a blank row in our data structure
	//
	if (index < RowInfoList.Count ()) {
		RowInfoList.Insert (index + 1, new ListRowClass);
	} else {
		RowInfoList.Add (new ListRowClass);
	}

	//
	//	Insert a new entry in the first column with the given text
	//
	index = ColList[0]->Insert_Entry (index, text);

	//
	//	Use the default text color for each new entry
	//
	int color	= StyleMgrClass::Get_Text_Color ();
	float red	=  ((color & 0x00FF0000) >> 16) / 256.0F;
	float green	=  ((color & 0x0000FF00) >> 8) / 256.0F;
	float blue	=  ((color & 0x000000FF)) / 256.0F;
	Vector3 new_color (red, green, blue);
	
	ColList[0]->Set_Entry_Color (index, new_color);

	//
	//	Add blank entries to all the other columns
	//
	for (int col_index = 1; col_index < ColList.Count (); col_index ++) {
		ListColumnClass *column = ColList[col_index];
		column->Insert_Entry (index, L"");		
		column->Set_Entry_Color (index, new_color);
	}

	//
	//	Update the cached row height for this entry...
	//
	Update_Row_Height (index);

	//
	//	Update the last page top entry
	//
	LastPageTopEntryIndex = Find_Last_Page_Top_Entry ();
	Set_Dirty ();
	return index;
}


////////////////////////////////////////////////////////////////
//
//	Update_Row_Height
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Update_Row_Height (int row_index)
{
	int border_height		= (ROW_SPACING * StyleMgrClass::Get_Y_Scale ());
	float height			= (TextRenderer.Get_Text_Extents (L"W").Y + border_height);

	//
	//	Render each column in this row
	//
	float x_pos = TextRect.Left;
	for (int index = 0; index < ColList.Count (); index ++) {

		//
		//	Determine how wide this column is
		//
		float col_width = (ColList[index]->Get_Width () * HeaderRect.Width ());		
		if (index == ColList.Count () - 1) {
			col_width = TextRect.Right - x_pos;
		}

		//
		//	Set the wrapping width
		//
		TextRenderer.Set_Wrapping_Width (col_width);
		
		//
		//	Calculate the height of this text
		//
		const WCHAR *text = ColList[index]->Get_Entry_Text (row_index);
		Vector2 extents = TextRenderer.Get_Formatted_Text_Extents (text);
		height = max (height, extents.Y + border_height);

		//
		//	Increment the x-position
		//
		x_pos += col_width;
	}

	//
	//	Make sure the row is AT LEST MinRowHeight units high
	//
	float min_height	= MinRowHeight * StyleMgrClass::Get_Y_Scale ();
	height				= max (min_height, height);
	
	//
	//	Store the row height
	//
	RowInfoList[row_index]->Set_Height (height);

	TextRenderer.Set_Wrapping_Width (0);
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Set_Icon_Size
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Set_Icon_Size (float width, float height)
{
	//
	//	Pass these values on the icon manager
	//
	IconMgr.Set_Icon_Width (width);
	IconMgr.Set_Icon_Height (height);
	Set_Dirty ();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Set_Min_Row_Height
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Set_Min_Row_Height (int height)
{
	MinRowHeight = height;

	//
	//	Update each row using this new height information
	//
	for (int index = 0; index < RowInfoList.Count (); index ++) {
		Update_Row_Height (index);
	}

	Set_Dirty ();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Select_Entry
//
////////////////////////////////////////////////////////////////
bool
ListCtrlClass::Select_Entry (int index, bool onoff)
{
	if (index < 0 || index >= Get_Entry_Count ()) {
		return false;
	}

	//
	//	Set the selection state of the row
	//
	RowInfoList[index]->Select (onoff);
	Set_Dirty ();

	return true;
}


////////////////////////////////////////////////////////////////
//
//	Is_Entry_Selected
//
////////////////////////////////////////////////////////////////
bool
ListCtrlClass::Is_Entry_Selected (int index)
{
	bool retval = false;
	if (index >= 0 && index < Get_Entry_Count ()) {
		
		//
		//	Get the selection state of the row
		//
		retval = RowInfoList[index]->Is_Selected ();
		Set_Dirty ();
	}

	return retval;
}


////////////////////////////////////////////////////////////////
//
//	Set_Entry_Text
//
////////////////////////////////////////////////////////////////
bool
ListCtrlClass::Set_Entry_Text (int index, int col_index, const WCHAR *text)
{
	if (col_index < 0 || col_index >= ColList.Count ()) {
		return false;
	}

	//
	//	Change the text entry in this cell
	//
	ColList[col_index]->Set_Entry_Text (index, text);

	//
	//	Update the cached row height for this entry...
	//
	Update_Row_Height (index);

	//
	//	Update the last page top entry
	//
	LastPageTopEntryIndex = Find_Last_Page_Top_Entry ();
	Set_Dirty ();
	return true;
}


////////////////////////////////////////////////////////////////
//
//	Set_Entry_Int
//
////////////////////////////////////////////////////////////////
bool
ListCtrlClass::Set_Entry_Int (int index, int col_index, int value)
{
	if (col_index < 0 || col_index >= ColList.Count ()) {
		return false;
	}

	//
	//	Convert the integer to a string
	//
	WideStringClass number_str;
	number_str.Format (L"%d", value);

	//
	//	Change the text entry in this cell
	//
	ColList[col_index]->Set_Entry_Text (index, number_str);
	Set_Dirty ();
	return true;
}


////////////////////////////////////////////////////////////////
//
//	Set_Entry_Color
//
////////////////////////////////////////////////////////////////
bool
ListCtrlClass::Set_Entry_Color (int index, int col_index, const Vector3 &color)
{
	if (col_index < 0 || col_index >= ColList.Count ()) {
		return false;
	}

	//
	//	Change the color for the entry in this cell
	//
	ColList[col_index]->Set_Entry_Color (index, color);
	Set_Dirty ();
	return true;
}


////////////////////////////////////////////////////////////////
//
//	Set_Entry_Data
//
////////////////////////////////////////////////////////////////
bool
ListCtrlClass::Set_Entry_Data (int index, int col_index, uint32 user_data)
{
	//
	//	Store the user data in the first column
	//
	ColList[col_index]->Set_Entry_Data (index, user_data);
	return true;
}


////////////////////////////////////////////////////////////////
//
//	Get_Entry_Data
//
////////////////////////////////////////////////////////////////
uint32
ListCtrlClass::Get_Entry_Data (int index, int col_index)
{
	uint32 user_data = 0;

	//
	//	Lookup the user data
	//
	if (index >= 0 && index < Get_Entry_Count () && col_index >= 0 && col_index < ColList.Count ()) {
		user_data = ColList[col_index]->Get_Entry_Data (index);
	}

	return user_data;
}


////////////////////////////////////////////////////////////////
//
//	Get_Entry_Text
//
////////////////////////////////////////////////////////////////
const WCHAR *
ListCtrlClass::Get_Entry_Text (int index, int col_index)
{
	//
	//	Return the string to the caller
	//
	return ColList[col_index]->Get_Entry_Text (index);
}


////////////////////////////////////////////////////////////////
//
//	Delete_All_Entries
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Delete_All_Entries (void)
{
	//
	//	Notify the advise sinks (if necessary) that each entry
	// is being deleted
	//
	int entry_count = Get_Entry_Count ();
	for (int item_index = 0; item_index < entry_count; item_index ++) {
		ADVISE_NOTIFY (On_ListCtrl_Delete_Entry (this, Get_ID (), item_index));
	}

	//
	//	Delete each of our row information sturctures
	//
	for (int index = 0; index < RowInfoList.Count (); index ++) {
		delete RowInfoList[index];
	}
	RowInfoList.Delete_All ();

	//
	//	Now delete all the entries from each column
	//
	for (index = 0; index < ColList.Count (); index ++) {
		ColList[index]->Delete_All_Entries ();
	}

	Set_Dirty ();

	//
	//	Reset the scroll and current selection positions
	//
	ScrollPos	= 0;
	CurrSel		= -1;
	Set_Dirty ();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Scroll_To_End
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Scroll_To_End (void)
{
	//
	//	Update the last page top entry
	//
	LastPageTopEntryIndex = Find_Last_Page_Top_Entry ();

	//
	//	Force scroll to the end
	//
	ScrollPos = LastPageTopEntryIndex;
	ScrollPos = max (ScrollPos, 0);

	//
	//	Update the scrollbar
	//
	ScrollBarCtrl.Set_Pos (ScrollPos, false);

	Set_Dirty ();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Set_Curr_Sel
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Set_Curr_Sel (int new_sel)
{
	if (new_sel == -1) {
		Select_All(false);
		CurrSel = -1;
	} else {
		Set_Sel(new_sel, false);
	}

	return ;
}


////////////////////////////////////////////////////////////////
//
//	Set_Sel
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Set_Sel (int new_sel, bool notify)
{
	if (IsSelectionAllowed) {

		//
		//	Unselect the old entry (if necessary)
		//
		if (IsMultipleSelection == false) {
			Select_Entry (CurrSel, false);
		}

		int old_sel = CurrSel;

		if ((new_sel == -1) && IsNoSelectionAllowed) {
			CurrSel = -1;
		} else {
			//
			//	Bound the selection index
			//
			int count = Get_Entry_Count ();
			CurrSel = max (new_sel, 0);
			CurrSel = min (CurrSel, count - 1);

			//
			//	Select the new entry
			//
			if (IsMultipleSelection) {
				Toggle_Entry_Selection (CurrSel);
			} else {
				Select_Entry (CurrSel, true);
			}
		}

		//
		//	Notify anyone who cares that we have changed the selection
		//
		if (notify && (old_sel != CurrSel)) {
			ADVISE_NOTIFY(On_ListCtrl_Sel_Change(this, Get_ID(), old_sel, CurrSel));
		}

		//
		//	Force a repaint
		//
		Set_Dirty ();
		Update_Scroll_Pos ();
	}

	return ;
}


////////////////////////////////////////////////////////////////
//
//	Update_Scroll_Pos
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Update_Scroll_Pos (void)
{
	if (CurrSel < 0) {
		return ;
	}

	//
	//	Do we need to scroll up?
	//
	if (CurrSel < ScrollPos) {
		ScrollPos = CurrSel;
		Set_Dirty ();
	} else {

		//
		//	Do we need to scroll down?
		//
		RectClass rect;
		Get_Entry_Rect (CurrSel, rect);
		if (rect.Bottom >= TextRect.Bottom) {

			//
			//	Calculate where we should scroll to
			//
			ScrollPos = Find_Top_Of_Page (CurrSel);
			Set_Dirty ();
		}
	}

	//
	//	Update the scrollbar
	//
	ScrollBarCtrl.Set_Pos (ScrollPos, false);
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Get_Entry_Rect
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Get_Entry_Rect (int index, RectClass &rect)
{
	if (index < 0 || index >= RowInfoList.Count ()) {
		return ;
	}

	//
	//	Lookup the height of this row
	//
	float row_height	= RowInfoList[index]->Get_Height ();
	float y_pos			= -1000.0F;

	if (ScrollPos <= index) {

		//
		//	Calculate the starting y-position of this entry
		//
		y_pos = TextRect.Top;
		for (int curr_index = ScrollPos; curr_index < index; curr_index ++) {
			y_pos += RowInfoList[curr_index]->Get_Height ();
		}
	}

	rect.Left	= int(TextRect.Left);
	rect.Right	= int(TextRect.Right);
	rect.Top		= int(y_pos);
	rect.Bottom	= int(rect.Top + row_height);
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Col_From_Pos
//
////////////////////////////////////////////////////////////////
int
ListCtrlClass::Col_From_Pos (const Vector2 &mouse_pos)
{
	int retval = -1;

	//
	//	Test each column
	//
	int x_pos		= HeaderRect.Left;
	int col_count	= ColList.Count ();
	for (int col_index = 0; col_index < col_count; col_index ++) {

		//
		//	Determine how wide this column is
		//
		int col_width = (ColList[col_index]->Get_Width () * HeaderRect.Width ());

		//
		//	Let the last column extend to the edge
		//
		if (col_index == col_count - 1) {
			col_width = HeaderRect.Right - x_pos;
		}


		//
		//	Is the coordinate inside this col?
		//
		if (mouse_pos.X >= x_pos && mouse_pos.X <= (x_pos + col_width)) {
			retval = col_index;
			break;
		}

		//
		//	Move on to the next column
		//
		x_pos += col_width;
	}

	return retval;
}


////////////////////////////////////////////////////////////////
//
//	Entry_From_Pos
//
////////////////////////////////////////////////////////////////
int
ListCtrlClass::Entry_From_Pos (const Vector2 &mouse_pos)
{
	int retval = -1;
	if (mouse_pos.Y < TextRect.Top || mouse_pos.Y > TextRect.Bottom) {
		return -1;
	}

	//
	//	Test each row
	//
	int y_pos		= TextRect.Top;
	int row_count	= Get_Entry_Count ();
	for (int row_index = ScrollPos; row_index < row_count; row_index ++) {

		float row_height = RowInfoList[row_index]->Get_Height ();

		//
		//	Is the coordinate inside this row?
		//
		if (mouse_pos.Y >= y_pos && mouse_pos.Y <= (y_pos + row_height)) {
			retval = row_index;
			break;
		}

		//
		//	Move down to the next row
		//
		y_pos += row_height;

		//
		//	Stop searching if we've moved off the page
		//
		if (mouse_pos.Y >= TextRect.Bottom) {			
			break;
		}
	}

	return retval;
}


////////////////////////////////////////////////////////////////
//
//	Scroll_Page
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::Scroll_Page (int direction)
{	
	int count		= RowInfoList.Count ();
	float height	= TextRect.Height ();

	bool found = false;

	//
	//	Scan either direction from the current scroll
	// position until we've moved a whole page
	//
	for (	int index = ScrollPos;
			index >= 0 && index < count;
			index += direction)
	{		
		//
		//	Decrement the remaining distance
		//
		height -= RowInfoList[index]->Get_Height ();

		//
		//	If we've gone of the page, then back off one entry
		//
		if (height < 0) {
			ScrollPos = (index - direction);
			ScrollPos = min (ScrollPos, LastPageTopEntryIndex);
			ScrollBarCtrl.Set_Pos (ScrollPos, false);
			Set_Dirty ();
			found = true;
			break;
		}
	}

	//
	//	Check the boundary conditions
	//
	if (index < 0 && found == false) {
		ScrollPos = 0;
		ScrollBarCtrl.Set_Pos (ScrollPos, false);
		Set_Dirty ();		
	}

	return ;
}


////////////////////////////////////////////////////////////////
//
//	On_VScroll_Page
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::On_VScroll_Page (ScrollBarCtrlClass *scrollbar, int ctrl_id, int direction)
{
	Scroll_Page (direction);
	return ;
}


////////////////////////////////////////////////////////////////
//
//	On_VScroll
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::On_VScroll (ScrollBarCtrlClass *, int , int new_position)
{
	if (ScrollPos != new_position) {
		ScrollPos = new_position;
		Set_Dirty ();
	}
	return ;
}


////////////////////////////////////////////////////////////////
//
//	On_Mouse_Wheel
//
////////////////////////////////////////////////////////////////
void
ListCtrlClass::On_Mouse_Wheel (int direction)
{
	if (direction < 0) {
		if (ScrollPos > 0) {
			ScrollPos --;
			ScrollBarCtrl.Set_Pos (ScrollPos, false);
		}

	} else {
		if (ScrollPos < LastPageTopEntryIndex) {
			ScrollPos ++;
			ScrollBarCtrl.Set_Pos (ScrollPos, false);
		}
	}

	Set_Dirty ();
	return ;
}


//********************************************************************************//
//
//	Start of ListColumnClass
//
//********************************************************************************//


////////////////////////////////////////////////////////////////
//
//	Free_Data
//
////////////////////////////////////////////////////////////////
void
ListColumnClass::Free_Data (void)
{
	Delete_All_Entries ();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Reset_Contents
//
////////////////////////////////////////////////////////////////
void
ListColumnClass::Reset_Contents (void)
{
	//
	//	Remove all the entries
	//
	Free_Data ();
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Insert_Entry
//
////////////////////////////////////////////////////////////////
int
ListColumnClass::Insert_Entry (int index, const WCHAR *entry_name)
{
	ListEntryClass *entry = new ListEntryClass (entry_name);

	//
	//	Should we insert this entry  in the list or add it to the end?
	//
	if (index < EntryList.Count ()) {
		EntryList.Insert (index + 1, entry);
	} else {
		EntryList.Add (entry);
		index = (EntryList.Count () - 1);
	}

	return index;
}


////////////////////////////////////////////////////////////////
//
//	Delete_Entry
//
////////////////////////////////////////////////////////////////
bool
ListColumnClass::Delete_Entry (int index)
{
	bool retval = false;

	//
	//	Delete the entry if we can find it in our list
	//
	if (index >= 0 && index < EntryList.Count ()) {
		delete EntryList[index];
		EntryList.Delete (index);
	}

	return retval;
}


////////////////////////////////////////////////////////////////
//
//	Delete_All_Entries
//
////////////////////////////////////////////////////////////////
void
ListColumnClass::Delete_All_Entries (void)
{
	//
	//	Free each of the entries  in the list
	//
	for (int index = 0; index < EntryList.Count (); index ++) {
		delete EntryList[index];
	}

	EntryList.Delete_All ();	
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Move_Entry
//
////////////////////////////////////////////////////////////////
void
ListColumnClass::Move_Entry (int old_index, int new_index)
{
	if (	old_index < 0 || (old_index >= EntryList.Count ()) &&
			new_index < 0 || (new_index >= EntryList.Count ()))
	{
		return ;
	}

	//
	//	Move the entry
	//
	ListEntryClass *old_entry = EntryList[old_index];
	EntryList.Insert (new_index, old_entry);
	EntryList.Delete (old_index);
	return ;
}


////////////////////////////////////////////////////////////////
//
//	Swap_Entries
//
////////////////////////////////////////////////////////////////
void
ListColumnClass::Swap_Entries (int index1, int index2)
{
	if (	index1 < 0 || (index1 >= EntryList.Count ()) &&
			index2 < 0 || (index2 >= EntryList.Count ()))
	{
		return ;
	}

	//
	//	Move the entry
	//
	ListEntryClass *temp_entry = EntryList[index1];
	EntryList[index1] = EntryList[index2];
	EntryList[index2] = temp_entry;
	return ;
}