//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================

#include <assert.h>
#include "vgui_grid.h"


using namespace vgui;


#define AssertCheck(expr, msg) \
	if(!(expr))\
	{\
		assert(!msg);\
		return 0;\
	}



// ------------------------------------------------------------------------------ //
// CGrid::CGridEntry.
// ------------------------------------------------------------------------------ //

CGrid::CGridEntry::CGridEntry()
{
	m_pPanel = NULL;
	m_bUnderline = false;
}

CGrid::CGridEntry::~CGridEntry()
{
}


// ------------------------------------------------------------------------------ //
// CGrid.
// ------------------------------------------------------------------------------ //

CGrid::CGrid()
{
	Clear();
}


CGrid::~CGrid()
{
	Term();
}


bool CGrid::SetDimensions(int xCols, int yRows)
{
	Term();

	m_GridEntries = new CGridEntry[xCols * yRows];
	m_Widths = new int[xCols*2 + yRows*2];
	m_Heights = m_Widths + xCols;
	m_ColOffsets = m_Heights + yRows;
	m_RowOffsets = m_ColOffsets + xCols;

	if(!m_GridEntries || !m_Widths)
	{
		Term();
		return false;
	}

	memset(m_Widths, 0, sizeof(int) * (xCols*2 + yRows*2));

	m_xCols = xCols;
	m_yRows = yRows;
	return true;
}


void CGrid::Term()
{
	delete [] m_GridEntries;
	delete [] m_Widths;
	Clear();
}


Panel* CGrid::GetEntry(int x, int y)
{
	return GridEntry(x, y)->m_pPanel;
}


bool CGrid::SetEntry(int x, int y, Panel *pPanel)
{
	CGridEntry *pEntry = GridEntry(x, y);
	if(!pEntry)
		return false;

	if(pEntry->m_pPanel)
		pEntry->m_pPanel->setParent(NULL);

	pEntry->m_pPanel = pPanel;
	if(pPanel)
		pPanel->setParent(this);

	m_bDirty = true;
	return true;
}


int CGrid::GetXSpacing()
{
	return m_xSpacing;
}


int CGrid::GetYSpacing()
{
	return m_ySpacing;
}


void CGrid::SetSpacing(int xSpacing, int ySpacing)
{
	if(xSpacing != m_xSpacing)
	{
		m_xSpacing = xSpacing;
		CalcColOffsets(0);
		m_bDirty = true;
	}

	if(ySpacing != m_ySpacing)
	{
		m_ySpacing = ySpacing;
		CalcRowOffsets(0);
		m_bDirty = true;
	}
}


bool CGrid::SetColumnWidth(int iColumn, int width)
{
	AssertCheck(iColumn >= 0 && iColumn < m_xCols, "CGrid::SetColumnWidth : invalid location specified");
	m_Widths[iColumn] = width;
	CalcColOffsets(iColumn+1);
	m_bDirty = true;
	return true;
}


bool CGrid::SetRowHeight(int iRow, int height)
{
	AssertCheck(iRow >= 0 && iRow < m_yRows, "CGrid::SetColumnWidth : invalid location specified");
	m_Heights[iRow] = height;
	CalcRowOffsets(iRow+1);
	m_bDirty = true;
	return true;
}


int CGrid::GetColumnWidth(int iColumn)
{
	AssertCheck(iColumn >= 0 && iColumn < m_xCols, "CGrid::GetColumnWidth: invalid location specified");
	return m_Widths[iColumn];
}


int CGrid::GetRowHeight(int iRow)
{
	AssertCheck(iRow >= 0 && iRow < m_yRows, "CGrid::GetRowHeight: invalid location specified");
	return m_Heights[iRow];
}


int CGrid::CalcFitColumnWidth(int iColumn)
{
	AssertCheck(iColumn >= 0 && iColumn < m_xCols, "CGrid::CalcFitColumnWidth: invalid location specified");

	int maxSize = 0;
	for(int i=0; i < m_yRows; i++)
	{
		Panel *pPanel = GridEntry(iColumn, i)->m_pPanel;
		if(!pPanel)
			continue;

		int w, h;
		pPanel->getSize(w,h);
		if(w > maxSize)
			maxSize = w;
	}

	return maxSize;
}


int CGrid::CalcFitRowHeight(int iRow)
{
	AssertCheck(iRow >= 0 && iRow < m_yRows, "CGrid::CalcFitRowHeight: invalid location specified");

	int maxSize = 0;
	for(int i=0; i < m_xCols; i++)
	{
		Panel *pPanel = GridEntry(i, iRow)->m_pPanel;
		if(!pPanel)
			continue;

		int w, h;
		pPanel->getSize(w,h);
		if(h > maxSize)
			maxSize = h;
	}

	return maxSize;
}


void CGrid::AutoSetRowHeights()
{
	for(int i=0; i < m_yRows; i++)
		SetRowHeight(i, CalcFitRowHeight(i));
}


bool CGrid::GetEntryBox(
	int col, int row, int &x, int &y, int &w, int &h)
{
	AssertCheck(col >= 0 && col < m_xCols && row >= 0 && row < m_yRows, "CGrid::GetEntryBox: invalid location specified");

	x = m_ColOffsets[col];
	w = m_Widths[col];

	y = m_RowOffsets[row];
	h = m_Heights[row];
	return true;	
}


bool CGrid::CopyColumnWidths(CGrid *pOther)
{
	if(!pOther || pOther->m_xCols != m_xCols)
		return false;

	for(int i=0; i < m_xCols; i++)
		m_Widths[i] = pOther->m_Widths[i];

	CalcColOffsets(0);
	m_bDirty = true;
	return true;
}


void CGrid::RepositionContents()
{
	for(int x=0; x < m_xCols; x++)
	{
		for(int y=0; y < m_yRows; y++)
		{
			Panel *pPanel = GridEntry(x,y)->m_pPanel;
			if(!pPanel)
				continue;

			pPanel->setBounds(
				m_ColOffsets[x], 
				m_RowOffsets[y],
				m_Widths[x], 
				m_Heights[y]);
		}
	}

	m_bDirty = false;
}


int CGrid::CalcDrawHeight()
{
	if(m_yRows > 0)
	{
		return m_RowOffsets[m_yRows-1] + m_Heights[m_yRows - 1] + m_ySpacing;
	}
	else
	{
		return 0;
	}
}


void CGrid::paint()
{
	if(m_bDirty)
		RepositionContents();

	Panel::paint();

	// walk the grid looking for underlined rows
	int x = 0, y = 0;
	for (int row = 0; row < m_yRows; row++)
	{
		CGridEntry *cell = GridEntry(0, row);

		y += cell->m_pPanel->getTall() + m_ySpacing;
		if (cell->m_bUnderline)
		{
			drawSetColor(cell->m_UnderlineColor[0], cell->m_UnderlineColor[1], cell->m_UnderlineColor[2], cell->m_UnderlineColor[3]);
			drawFilledRect(0, y - (cell->m_iUnderlineOffset + 1), getWide(), y - cell->m_iUnderlineOffset);
		}
	}
}

void CGrid::paintBackground()
{
	Panel::paintBackground();
}

//-----------------------------------------------------------------------------
// Purpose: sets underline color for a particular row
//-----------------------------------------------------------------------------
void CGrid::SetRowUnderline(int row, bool enabled, int offset, int r, int g, int b, int a)
{
	CGridEntry *cell = GridEntry(0, row);
	cell->m_bUnderline = enabled;
	if (enabled)
	{
		cell->m_iUnderlineOffset = offset;
		cell->m_UnderlineColor[0] = r;
		cell->m_UnderlineColor[1] = g;
		cell->m_UnderlineColor[2] = b;
		cell->m_UnderlineColor[3] = a;
	}
}

void CGrid::Clear()
{
	m_xCols = m_yRows = 0;
	m_Widths = NULL;
	m_GridEntries = NULL;
	m_xSpacing = m_ySpacing = 0;
	m_bDirty = false;
}


CGrid::CGridEntry* CGrid::GridEntry(int x, int y)
{
	AssertCheck(x >= 0 && x < m_xCols && y >= 0 && y < m_yRows, "CGrid::GridEntry: invalid location specified");
	return &m_GridEntries[y*m_xCols + x];
}


void CGrid::CalcColOffsets(int iStart)
{
	int cur = m_xSpacing;
	if(iStart != 0)
		cur += m_ColOffsets[iStart-1] + m_Widths[iStart-1];

	for(int i=iStart; i < m_xCols; i++)
	{
		m_ColOffsets[i] = cur;
		cur += m_Widths[i] + m_xSpacing;
	}
}


void CGrid::CalcRowOffsets(int iStart)
{
	int cur = m_ySpacing;
	if(iStart != 0)
		cur += m_RowOffsets[iStart-1];

	for(int i=iStart; i < m_yRows; i++)
	{
		m_RowOffsets[i] = cur;
		cur += m_Heights[i] + m_ySpacing;
	}
}

bool CGrid::getCellAtPoint(int worldX, int worldY, int &row, int &col)
{
	row = -1; col = -1;
	for(int x=0; x < m_xCols; x++)
	{
		for(int y=0; y < m_yRows; y++)
		{
			Panel *pPanel = GridEntry(x,y)->m_pPanel;
			if (!pPanel)
				continue;

			if (pPanel->isWithin(worldX, worldY))
			{
				col = x;
				row = y;
				return true;
			}
		}
	}
		
	return false;
}