mirror of
https://github.com/FWGS/hlsdk-xash3d
synced 2024-11-22 09:57:21 +01:00
368 lines
7.2 KiB
C++
368 lines
7.2 KiB
C++
//========= Copyright (c) 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;
|
|
}
|
|
|