d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
212 Commits
25 Branches
6 Tags
221 MiB
Tree: 90cd6e0e15
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '90cd6e0e15'
${ noResults }
source-engine/vgui2/vgui_controls/ListPanel.cpp

3288 lines
88 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include <stdio.h>
#define PROTECTED_THINGS_DISABLE
#include <vgui/Cursor.h>
#include <vgui/IInput.h>
#include <vgui/ILocalize.h>
#include <vgui/IPanel.h>
#include <vgui/IScheme.h>
#include <vgui/ISystem.h>
#include <vgui/ISurface.h>
#include <vgui/IVGui.h>
#include <vgui/KeyCode.h>
#include <KeyValues.h>
#include <vgui/MouseCode.h>
#include <vgui_controls/Button.h>
#include <vgui_controls/Controls.h>
#include <vgui_controls/ImageList.h>
#include <vgui_controls/ImagePanel.h>
#include <vgui_controls/Label.h>
#include <vgui_controls/ListPanel.h>
#include <vgui_controls/ScrollBar.h>
#include <vgui_controls/TextImage.h>
#include <vgui_controls/Menu.h>
#include <vgui_controls/Tooltip.h>
// memdbgon must be the last include file in a .cpp file
#include "tier0/memdbgon.h"
using namespace vgui;
enum
{
WINDOW_BORDER_WIDTH=2 // the width of the window's border
};
#ifndef max
#define max(a,b) (((a) > (b)) ? (a) : (b))
#endif
#ifndef min
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef clamp
#define clamp( val, min, max ) ( ((val) > (max)) ? (max) : ( ((val) < (min)) ? (min) : (val) ) )
#endif
//-----------------------------------------------------------------------------
//
// Button at the top of columns used to re-sort
//
//-----------------------------------------------------------------------------
class ColumnButton : public Button
{
public:
ColumnButton(vgui::Panel *parent, const char *name, const char *text);
// Inherited from Button
virtual void ApplySchemeSettings(IScheme *pScheme);
virtual void OnMousePressed(MouseCode code);
void OpenColumnChoiceMenu();
};
ColumnButton::ColumnButton(vgui::Panel *parent, const char *name, const char *text) : Button(parent, name, text)
{
SetBlockDragChaining( true );
}
void ColumnButton::ApplySchemeSettings(IScheme *pScheme)
{
Button::ApplySchemeSettings(pScheme);
SetContentAlignment(Label::a_west);
SetFont(pScheme->GetFont("DefaultSmall", IsProportional()));
}
// Don't request focus.
// This will keep items in the listpanel selected.
void ColumnButton::OnMousePressed(MouseCode code)
{
if (!IsEnabled())
return;
if (code == MOUSE_RIGHT)
{
OpenColumnChoiceMenu();
return;
}
if (!IsMouseClickEnabled(code))
return;
if (IsUseCaptureMouseEnabled())
{
{
SetSelected(true);
Repaint();
}
// lock mouse input to going to this button
input()->SetMouseCapture(GetVPanel());
}
}
void ColumnButton::OpenColumnChoiceMenu()
{
CallParentFunction(new KeyValues("OpenColumnChoiceMenu"));
}
//-----------------------------------------------------------------------------
//
// Purpose: Handles resizing of columns
//
//-----------------------------------------------------------------------------
class Dragger : public Panel
{
public:
Dragger(int column);
// Inherited from Panel
virtual void OnMousePressed(MouseCode code);
virtual void OnMouseDoublePressed(MouseCode code);
virtual void OnMouseReleased(MouseCode code);
virtual void OnCursorMoved(int x, int y);
virtual void SetMovable(bool state);
private:
int m_iDragger;
bool m_bDragging;
int m_iDragPos;
bool m_bMovable; // whether this dragger is movable using mouse or not
};
Dragger::Dragger(int column)
{
m_iDragger = column;
SetPaintBackgroundEnabled(false);
SetPaintEnabled(false);
SetPaintBorderEnabled(false);
SetCursor(dc_sizewe);
m_bDragging = false;
m_bMovable = true; // movable by default
m_iDragPos = 0;
SetBlockDragChaining( true );
}
void Dragger::OnMousePressed(MouseCode code)
{
if (m_bMovable)
{
input()->SetMouseCapture(GetVPanel());
int x, y;
input()->GetCursorPos(x, y);
m_iDragPos = x;
m_bDragging = true;
}
}
void Dragger::OnMouseDoublePressed(MouseCode code)
{
if (m_bMovable)
{
// resize the column to the size of it's contents
PostMessage(GetParent(), new KeyValues("ResizeColumnToContents", "column", m_iDragger));
}
}
void Dragger::OnMouseReleased(MouseCode code)
{
if (m_bMovable)
{
input()->SetMouseCapture(NULL);
m_bDragging = false;
}
}
void Dragger::OnCursorMoved(int x, int y)
{
if (m_bDragging)
{
input()->GetCursorPos(x, y);
KeyValues *msg = new KeyValues("ColumnResized");
msg->SetInt("column", m_iDragger);
msg->SetInt("delta", x - m_iDragPos);
m_iDragPos = x;
if (GetVParent())
{
ivgui()->PostMessage(GetVParent(), msg, GetVPanel());
}
}
}
void Dragger::SetMovable(bool state)
{
m_bMovable = state;
// disable cursor change if the dragger is not movable
if( IsVisible() )
{
if (state)
{
// if its not movable we stick with the default arrow
// if parent windows Start getting fancy cursors we should probably retrive a parent
// cursor and set it to that
SetCursor(dc_sizewe);
}
else
{
SetCursor(dc_arrow);
}
}
}
namespace vgui
{
// optimized for sorting
class FastSortListPanelItem : public ListPanelItem
{
public:
// index into accessing item to sort
CUtlVector<int> m_SortedTreeIndexes;
// visibility flag (for quick hide/filter)
bool visible;
// precalculated sort orders
int primarySortIndexValue;
int secondarySortIndexValue;
};
}
static ListPanel *s_pCurrentSortingListPanel = NULL;
static const char *s_pCurrentSortingColumn = NULL;
static bool s_currentSortingColumnTypeIsText = false;
static SortFunc *s_pSortFunc = NULL;
static bool s_bSortAscending = true;
static SortFunc *s_pSortFuncSecondary = NULL;
static bool s_bSortAscendingSecondary = true;
//-----------------------------------------------------------------------------
// Purpose: Basic sort function, for use in qsort
//-----------------------------------------------------------------------------
static int __cdecl AscendingSortFunc(const void *elem1, const void *elem2)
{
int itemID1 = *((int *) elem1);
int itemID2 = *((int *) elem2);
// convert the item index into the ListPanelItem pointers
vgui::ListPanelItem *p1, *p2;
p1 = s_pCurrentSortingListPanel->GetItemData(itemID1);
p2 = s_pCurrentSortingListPanel->GetItemData(itemID2);
int result = s_pSortFunc( s_pCurrentSortingListPanel, *p1, *p2 );
if (result == 0)
{
// use the secondary sort functino
result = s_pSortFuncSecondary( s_pCurrentSortingListPanel, *p1, *p2 );
if (!s_bSortAscendingSecondary)
{
result = -result;
}
if (result == 0)
{
// sort by the pointers to make sure we get consistent results
if (p1 > p2)
{
result = 1;
}
else
{
result = -1;
}
}
}
else
{
// flip result if not doing an ascending sort
if (!s_bSortAscending)
{
result = -result;
}
}
return result;
}
//-----------------------------------------------------------------------------
// Purpose: Default column sorting function, puts things in alpabetical order
// If images are the same returns 1, else 0
//-----------------------------------------------------------------------------
static int __cdecl DefaultSortFunc(
ListPanel *pPanel,
const ListPanelItem &item1,
const ListPanelItem &item2 )
{
const vgui::ListPanelItem *p1 = &item1;
const vgui::ListPanelItem *p2 = &item2;
if ( !p1 || !p2 ) // No meaningful comparison
{
return 0;
}
const char *col = s_pCurrentSortingColumn;
if (s_currentSortingColumnTypeIsText) // textImage column
{
if (p1->kv->FindKey(col, true)->GetDataType() == KeyValues::TYPE_INT)
{
// compare ints
int s1 = p1->kv->GetInt(col, 0);
int s2 = p2->kv->GetInt(col, 0);
if (s1 < s2)
{
return -1;
}
else if (s1 > s2)
{
return 1;
}
return 0;
}
else
{
// compare as string
const char *s1 = p1->kv->GetString(col, "");
const char *s2 = p2->kv->GetString(col, "");
return Q_stricmp(s1, s2);
}
}
else // its an imagePanel column
{
const ImagePanel *s1 = (const ImagePanel *)p1->kv->GetPtr(col, NULL);
const ImagePanel *s2 = (const ImagePanel *)p2->kv->GetPtr(col, NULL);
if (s1 < s2)
{
return -1;
}
else if (s1 > s2)
{
return 1;
}
return 0;
}
}
//-----------------------------------------------------------------------------
// Purpose: Sorts items by comparing precalculated list values
//-----------------------------------------------------------------------------
static int __cdecl FastSortFunc(
ListPanel *pPanel,
const ListPanelItem &item1,
const ListPanelItem &item2 )
{
const vgui::FastSortListPanelItem *p1 = (vgui::FastSortListPanelItem *)&item1;
const vgui::FastSortListPanelItem *p2 = (vgui::FastSortListPanelItem *)&item2;
Assert(p1 && p2);
// compare the precalculated indices
if (p1->primarySortIndexValue < p2->primarySortIndexValue)
{
return 1;
}
else if (p1->primarySortIndexValue > p2->primarySortIndexValue)
{
return -1;
}
// they're equal, compare the secondary indices
if (p1->secondarySortIndexValue < p2->secondarySortIndexValue)
{
return 1;
}
else if (p1->secondarySortIndexValue > p2->secondarySortIndexValue)
{
return -1;
}
// still equal; just compare the pointers (so we get deterministic results)
return (p1 < p2) ? 1 : -1;
}
static int s_iDuplicateIndex = 1;
//-----------------------------------------------------------------------------
// Purpose: sorting function used in the column index redblack tree
//-----------------------------------------------------------------------------
bool ListPanel::RBTreeLessFunc(vgui::ListPanel::IndexItem_t &item1, vgui::ListPanel::IndexItem_t &item2)
{
int result = s_pSortFunc( s_pCurrentSortingListPanel, *item1.dataItem, *item2.dataItem);
if (result == 0)
{
// they're the same value, set their duplicate index to reflect that
if (item1.duplicateIndex)
{
item2.duplicateIndex = item1.duplicateIndex;
}
else if (item2.duplicateIndex)
{
item1.duplicateIndex = item2.duplicateIndex;
}
else
{
item1.duplicateIndex = item2.duplicateIndex = s_iDuplicateIndex++;
}
}
return (result > 0);
}
DECLARE_BUILD_FACTORY( ListPanel );
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
ListPanel::ListPanel(Panel *parent, const char *panelName) : BaseClass(parent, panelName)
{
m_bIgnoreDoubleClick = false;
m_bMultiselectEnabled = true;
m_iEditModeItemID = 0;
m_iEditModeColumn = 0;
m_iHeaderHeight = 20;
m_iRowHeight = 20;
m_bCanSelectIndividualCells = false;
m_iSelectedColumn = -1;
m_bAllowUserAddDeleteColumns = false;
m_hbar = new ScrollBar(this, "HorizScrollBar", false);
m_hbar->AddActionSignalTarget(this);
m_hbar->SetVisible(false);
m_vbar = new ScrollBar(this, "VertScrollBar", true);
m_vbar->SetVisible(false);
m_vbar->AddActionSignalTarget(this);
m_pLabel = new Label(this, NULL, "");
m_pLabel->SetVisible(false);
m_pLabel->SetPaintBackgroundEnabled(false);
m_pLabel->SetContentAlignment(Label::a_west);
m_pTextImage = new TextImage( "" );
m_pImagePanel = new ImagePanel(NULL, "ListImage");
m_pImagePanel->SetAutoDelete(false);
m_iSortColumn = -1;
m_iSortColumnSecondary = -1;
m_bSortAscending = true;
m_bSortAscendingSecondary = true;
m_lastBarWidth = 0;
m_iColumnDraggerMoved = -1;
m_bNeedsSort = false;
m_LastItemSelected = -1;
m_pImageList = NULL;
m_bDeleteImageListWhenDone = false;
m_pEmptyListText = new TextImage("");
m_nUserConfigFileVersion = 1;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
ListPanel::~ListPanel()
{
// free data from table
RemoveAll();
// free column headers
unsigned char i;
for ( i = m_ColumnsData.Head(); i != m_ColumnsData.InvalidIndex(); i= m_ColumnsData.Next( i ) )
{
m_ColumnsData[i].m_pHeader->MarkForDeletion();
m_ColumnsData[i].m_pResizer->MarkForDeletion();
}
m_ColumnsData.RemoveAll();
delete m_pTextImage;
delete m_pImagePanel;
delete m_vbar;
if ( m_bDeleteImageListWhenDone )
{
delete m_pImageList;
}
delete m_pEmptyListText;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::SetImageList(ImageList *imageList, bool deleteImageListWhenDone)
{
// get rid of existing list image if there's one and we're supposed to get rid of it
if ( m_pImageList && m_bDeleteImageListWhenDone )
{
delete m_pImageList;
}
m_bDeleteImageListWhenDone = deleteImageListWhenDone;
m_pImageList = imageList;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::SetColumnHeaderHeight( int height )
{
m_iHeaderHeight = height;
}
//-----------------------------------------------------------------------------
// Purpose: adds a column header.
// this->FindChildByName(columnHeaderName) can be used to retrieve a pointer to a header panel by name
//
// if minWidth and maxWidth are BOTH NOTRESIZABLE or RESIZABLE
// the min and max size will be calculated automatically for you with that attribute
// columns are resizable by default
// if min and max size are specified column is resizable
//
// A small note on passing numbers for minWidth and maxWidth,
// If the initial window size is larger than the sum of the original widths of the columns,
// you can wind up with the columns "snapping" to size after the first window focus
// This is because the dxPerBar being calculated in PerformLayout()
// is making resizable bounded headers exceed thier maxWidths at the Start.
// Solution is to either put in support for redistributing the extra dx being truncated and
// therefore added to the last column on window opening, which is what causes the snapping.
// OR to
// ensure the difference between the starting sum of widths is not too much smaller/bigger
// than the starting window size so the starting dx doesn't cause snapping to occur.
// The easiest thing is to simply set it so your column widths add up to the starting size of the window on opening.
//
// Another note: Always give bounds for the last column you add or make it not resizable.
//
// Columns can have text headers or images for headers (e.g. password icon)
//-----------------------------------------------------------------------------
void ListPanel::AddColumnHeader(int index, const char *columnName, const char *columnText, int width, int columnFlags)
{
if (columnFlags & COLUMN_FIXEDSIZE && !(columnFlags & COLUMN_RESIZEWITHWINDOW))
{
// for fixed size columns, set the min & max widths to be the same as the initial width
AddColumnHeader( index, columnName, columnText, width, width, width, columnFlags);
}
else
{
AddColumnHeader( index, columnName, columnText, width, 20, 10000, columnFlags);
}
}
//-----------------------------------------------------------------------------
// Purpose: Adds a new column
//-----------------------------------------------------------------------------
void ListPanel::AddColumnHeader(int index, const char *columnName, const char *columnText, int width, int minWidth, int maxWidth, int columnFlags)
{
Assert (minWidth <= width);
Assert (maxWidth >= width);
// get our permanent index
unsigned char columnDataIndex = m_ColumnsData.AddToTail();
// put this index on the tail, so all item's m_SortedTreeIndexes have a consistent mapping
m_ColumnsHistory.AddToTail(columnDataIndex);
// put this column in the right place visually
m_CurrentColumns.InsertBefore(index, columnDataIndex);
// create the actual column object
column_t &column = m_ColumnsData[columnDataIndex];
// create the column header button
Button *pButton = SETUP_PANEL(new ColumnButton(this, columnName, columnText)); // the cell rendering mucks with the button visibility during the solvetraverse loop,
//so force applyschemesettings to make sure its run
pButton->SetSize(width, 24);
pButton->AddActionSignalTarget(this);
pButton->SetContentAlignment(Label::a_west);
pButton->SetTextInset(5, 0);
column.m_pHeader = pButton;
column.m_iMinWidth = minWidth;
column.m_iMaxWidth = maxWidth;
column.m_bResizesWithWindow = columnFlags & COLUMN_RESIZEWITHWINDOW;
column.m_bTypeIsText = !(columnFlags & COLUMN_IMAGE);
column.m_bHidden = false;
column.m_bUnhidable = (columnFlags & COLUMN_UNHIDABLE);
column.m_nContentAlignment = Label::a_west;
Dragger *dragger = new Dragger(index);
dragger->SetParent(this);
dragger->AddActionSignalTarget(this);
dragger->MoveToFront();
if (minWidth == maxWidth || (columnFlags & COLUMN_FIXEDSIZE))
{
// not resizable so disable the slider
dragger->SetMovable(false);
}
column.m_pResizer = dragger;
// add default sort function
column.m_pSortFunc = NULL;
// Set the SortedTree less than func to the generic RBTreeLessThanFunc
m_ColumnsData[columnDataIndex].m_SortedTree.SetLessFunc((IndexRBTree_t::LessFunc_t)RBTreeLessFunc);
// go through all the headers and make sure their Command has the right column ID
ResetColumnHeaderCommands();
// create the new data index
ResortColumnRBTree(index);
// ensure scroll bar is topmost compared to column headers
m_vbar->MoveToFront();
// fix up our visibility
SetColumnVisible(index, !(columnFlags & COLUMN_HIDDEN));
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose: Recreates a column's RB Sorted Tree
//-----------------------------------------------------------------------------
void ListPanel::ResortColumnRBTree(int col)
{
Assert(m_CurrentColumns.IsValidIndex(col));
unsigned char dataColumnIndex = m_CurrentColumns[col];
int columnHistoryIndex = m_ColumnsHistory.Find(dataColumnIndex);
column_t &column = m_ColumnsData[dataColumnIndex];
IndexRBTree_t &rbtree = column.m_SortedTree;
// remove all elements - we're going to create from scratch
rbtree.RemoveAll();
s_pCurrentSortingListPanel = this;
s_currentSortingColumnTypeIsText = column.m_bTypeIsText; // type of data in the column
SortFunc *sortFunc = column.m_pSortFunc;
if ( !sortFunc )
{
sortFunc = DefaultSortFunc;
}
s_pSortFunc = sortFunc;
s_bSortAscending = true;
s_pSortFuncSecondary = NULL;
// sort all current data items for this column
FOR_EACH_LL( m_DataItems, i )
{
IndexItem_t item;
item.dataItem = m_DataItems[i];
item.duplicateIndex = 0;
FastSortListPanelItem *dataItem = (FastSortListPanelItem*) m_DataItems[i];
// if this item doesn't already have a SortedTreeIndex for this column,
// if can only be because this is the brand new column, so add it to the SortedTreeIndexes
if (dataItem->m_SortedTreeIndexes.Count() == m_ColumnsHistory.Count() - 1 &&
columnHistoryIndex == m_ColumnsHistory.Count() - 1)
{
dataItem->m_SortedTreeIndexes.AddToTail();
}
Assert( dataItem->m_SortedTreeIndexes.IsValidIndex(columnHistoryIndex) );
dataItem->m_SortedTreeIndexes[columnHistoryIndex] = rbtree.Insert(item);
}
}
//-----------------------------------------------------------------------------
// Purpose: Resets the "SetSortColumn" command for each column - in case columns were added or removed
//-----------------------------------------------------------------------------
void ListPanel::ResetColumnHeaderCommands()
{
int i;
for ( i = 0 ; i < m_CurrentColumns.Count() ; i++ )
{
Button *pButton = m_ColumnsData[m_CurrentColumns[i]].m_pHeader;
pButton->SetCommand(new KeyValues("SetSortColumn", "column", i));
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets the header text for a particular column.
//-----------------------------------------------------------------------------
void ListPanel::SetColumnHeaderText(int col, const char *text)
{
m_ColumnsData[m_CurrentColumns[col]].m_pHeader->SetText(text);
}
void ListPanel::SetColumnHeaderText(int col, wchar_t *text)
{
m_ColumnsData[m_CurrentColumns[col]].m_pHeader->SetText(text);
}
void ListPanel::SetColumnTextAlignment( int col, int align )
{
m_ColumnsData[m_CurrentColumns[col]].m_nContentAlignment = align;
}
//-----------------------------------------------------------------------------
// Purpose: Sets the column header to have an image instead of text
//-----------------------------------------------------------------------------
void ListPanel::SetColumnHeaderImage(int column, int imageListIndex)
{
Assert(m_pImageList);
m_ColumnsData[m_CurrentColumns[column]].m_pHeader->SetTextImageIndex(-1);
m_ColumnsData[m_CurrentColumns[column]].m_pHeader->SetImageAtIndex(0, m_pImageList->GetImage(imageListIndex), 0);
}
//-----------------------------------------------------------------------------
// Purpose: associates a tooltip with the column header
//-----------------------------------------------------------------------------
void ListPanel::SetColumnHeaderTooltip(int column, const char *tooltipText)
{
m_ColumnsData[m_CurrentColumns[column]].m_pHeader->GetTooltip()->SetText(tooltipText);
m_ColumnsData[m_CurrentColumns[column]].m_pHeader->GetTooltip()->SetTooltipFormatToSingleLine();
m_ColumnsData[m_CurrentColumns[column]].m_pHeader->GetTooltip()->SetTooltipDelay(0);
}
int ListPanel::GetNumColumnHeaders() const
{
return m_CurrentColumns.Count();
}
bool ListPanel::GetColumnHeaderText( int index, char *pOut, int maxLen )
{
if ( index < m_CurrentColumns.Count() )
{
m_ColumnsData[m_CurrentColumns[index]].m_pHeader->GetText( pOut, maxLen );
return true;
}
else
{
return false;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::SetColumnSortable(int col, bool sortable)
{
if (sortable)
{
m_ColumnsData[m_CurrentColumns[col]].m_pHeader->SetCommand(new KeyValues("SetSortColumn", "column", col));
}
else
{
m_ColumnsData[m_CurrentColumns[col]].m_pHeader->SetCommand((const char *)NULL);
}
}
//-----------------------------------------------------------------------------
// Purpose: Changes the visibility of a column
//-----------------------------------------------------------------------------
void ListPanel::SetColumnVisible(int col, bool visible)
{
column_t &column = m_ColumnsData[m_CurrentColumns[col]];
bool bHidden = !visible;
if (column.m_bHidden == bHidden)
return;
if (column.m_bUnhidable)
return;
column.m_bHidden = bHidden;
if (bHidden)
{
column.m_pHeader->SetVisible(false);
column.m_pResizer->SetVisible(false);
}
else
{
column.m_pHeader->SetVisible(true);
column.m_pResizer->SetVisible(true);
}
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::RemoveColumn(int col)
{
if ( !m_CurrentColumns.IsValidIndex( col ) )
return;
// find the appropriate column data
unsigned char columnDataIndex = m_CurrentColumns[col];
// remove it from the current columns
m_CurrentColumns.Remove(col);
// zero out this entry in m_ColumnsHistory
unsigned char i;
for ( i = 0 ; i < m_ColumnsHistory.Count() ; i++ )
{
if ( m_ColumnsHistory[i] == columnDataIndex )
{
m_ColumnsHistory[i] = m_ColumnsData.InvalidIndex();
break;
}
}
Assert( i != m_ColumnsHistory.Count() );
// delete and remove the column data
m_ColumnsData[columnDataIndex].m_SortedTree.RemoveAll();
m_ColumnsData[columnDataIndex].m_pHeader->MarkForDeletion();
m_ColumnsData[columnDataIndex].m_pResizer->MarkForDeletion();
m_ColumnsData.Remove(columnDataIndex);
ResetColumnHeaderCommands();
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose: Returns the index of a column by column->GetName()
//-----------------------------------------------------------------------------
int ListPanel::FindColumn(const char *columnName)
{
for (int i = 0; i < m_CurrentColumns.Count(); i++)
{
if (!stricmp(columnName, m_ColumnsData[m_CurrentColumns[i]].m_pHeader->GetName()))
{
return i;
}
}
return -1;
}
//-----------------------------------------------------------------------------
// Purpose: adds an item to the view
// data->GetName() is used to uniquely identify an item
// data sub items are matched against column header name to be used in the table
//-----------------------------------------------------------------------------
arm64 : fix intptr_t size
3 years ago
int ListPanel::AddItem( const KeyValues *item, uintp userData, bool bScrollToItem, bool bSortOnAdd)
1
5 years ago
{
FastSortListPanelItem *newitem = new FastSortListPanelItem;
newitem->kv = item->MakeCopy();
newitem->userData = userData;
newitem->m_pDragData = NULL;
newitem->m_bImage = newitem->kv->GetInt( "image" ) != 0 ? true : false;
newitem->m_nImageIndex = newitem->kv->GetInt( "image" );
newitem->m_nImageIndexSelected = newitem->kv->GetInt( "imageSelected" );
newitem->m_pIcon = reinterpret_cast< IImage * >( newitem->kv->GetPtr( "iconImage" ) );
int itemID = m_DataItems.AddToTail(newitem);
int displayRow = m_VisibleItems.AddToTail(itemID);
newitem->visible = true;
// put the item in each column's sorted Tree Index
IndexItem(itemID);
if ( bSortOnAdd )
{
m_bNeedsSort = true;
}
InvalidateLayout();
if ( bScrollToItem )
{
// scroll to last item
m_vbar->SetValue(displayRow);
}
return itemID;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
arm64 : fix intptr_t size
3 years ago
void ListPanel::SetUserData( int itemID, uintp userData )
1
5 years ago
{
if ( !m_DataItems.IsValidIndex(itemID) )
return;
m_DataItems[itemID]->userData = userData;
}
//-----------------------------------------------------------------------------
// Purpose: Finds the first itemID with a matching userData
//-----------------------------------------------------------------------------
arm64 : fix intptr_t size
3 years ago
int ListPanel::GetItemIDFromUserData( uintp userData )
1
5 years ago
{
FOR_EACH_LL( m_DataItems, itemID )
{
if (m_DataItems[itemID]->userData == userData)
return itemID;
}
// not found
return InvalidItemID();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int ListPanel::GetItemCount( void )
{
return m_VisibleItems.Count();
}
//-----------------------------------------------------------------------------
// Purpose: gets the item ID of an item by name (data->GetName())
//-----------------------------------------------------------------------------
int ListPanel::GetItem(const char *itemName)
{
FOR_EACH_LL( m_DataItems, i )
{
if (!stricmp(m_DataItems[i]->kv->GetName(), itemName))
{
return i;
}
}
// failure
return -1;
}
//-----------------------------------------------------------------------------
// Purpose: returns pointer to data the itemID holds
//-----------------------------------------------------------------------------
KeyValues *ListPanel::GetItem(int itemID)
{
if ( !m_DataItems.IsValidIndex(itemID) )
return NULL;
return m_DataItems[itemID]->kv;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int ListPanel::GetItemCurrentRow(int itemID)
{
return m_VisibleItems.Find(itemID);
}
//-----------------------------------------------------------------------------
// Attaches drag data to a particular item
//-----------------------------------------------------------------------------
void ListPanel::SetItemDragData( int itemID, const KeyValues *data )
{
ListPanelItem *pItem = m_DataItems[ itemID ];
if ( pItem->m_pDragData )
{
pItem->m_pDragData->deleteThis();
}
pItem->m_pDragData = data->MakeCopy();
}
//-----------------------------------------------------------------------------
// Attaches drag data to a particular item
//-----------------------------------------------------------------------------
void ListPanel::OnCreateDragData( KeyValues *msg )
{
int nCount = GetSelectedItemsCount();
if ( nCount == 0 )
return;
for ( int i = 0; i < nCount; ++i )
{
int nItemID = GetSelectedItem( i );
KeyValues *pDragData = m_DataItems[ nItemID ]->m_pDragData;
if ( pDragData )
{
KeyValues *pDragDataCopy = pDragData->MakeCopy();
msg->AddSubKey( pDragDataCopy );
}
}
// Add the keys of the last item directly into the root also
int nLastItemID = GetSelectedItem( nCount - 1 );
KeyValues *pLastItemDrag = m_DataItems[ nLastItemID ]->m_pDragData;
if ( pLastItemDrag )
{
pLastItemDrag->CopySubkeys( msg );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int ListPanel::GetItemIDFromRow(int currentRow)
{
if (!m_VisibleItems.IsValidIndex(currentRow))
return -1;
return m_VisibleItems[currentRow];
}
int ListPanel::FirstItem() const
{
return m_DataItems.Head();
}
int ListPanel::NextItem( int iItem ) const
{
return m_DataItems.Next( iItem );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int ListPanel::InvalidItemID() const
{
return m_DataItems.InvalidIndex();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool ListPanel::IsValidItemID(int itemID)
{
return m_DataItems.IsValidIndex(itemID);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
ListPanelItem *ListPanel::GetItemData( int itemID )
{
if ( !m_DataItems.IsValidIndex(itemID) )
return NULL;
return m_DataItems[ itemID ];
}
//-----------------------------------------------------------------------------
// Purpose: returns user data for itemID
//-----------------------------------------------------------------------------
arm64 : fix intptr_t size
3 years ago
uintp ListPanel::GetItemUserData(int itemID)
1
5 years ago
{
if ( !m_DataItems.IsValidIndex(itemID) )
return 0;
return m_DataItems[itemID]->userData;
}
//-----------------------------------------------------------------------------
// Purpose: updates the view with any changes to the data
// Input : itemID - index to update
//-----------------------------------------------------------------------------
void ListPanel::ApplyItemChanges(int itemID)
{
// reindex the item and then redraw
IndexItem(itemID);
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose: Adds the item into the column indexes
//-----------------------------------------------------------------------------
void ListPanel::IndexItem(int itemID)
{
FastSortListPanelItem *newitem = (FastSortListPanelItem*) m_DataItems[itemID];
// remove the item from the indexes and re-add
int maxCount = min(m_ColumnsHistory.Count(), newitem->m_SortedTreeIndexes.Count());
for (int i = 0; i < maxCount; i++)
{
IndexRBTree_t &rbtree = m_ColumnsData[m_ColumnsHistory[i]].m_SortedTree;
rbtree.RemoveAt(newitem->m_SortedTreeIndexes[i]);
}
// make sure it's all free
newitem->m_SortedTreeIndexes.RemoveAll();
// reserve one index per historical column - pad it out
newitem->m_SortedTreeIndexes.AddMultipleToTail(m_ColumnsHistory.Count());
// set the current sorting list (since the insert will need to sort)
s_pCurrentSortingListPanel = this;
// add the item into the RB tree for each column
for (int i = 0; i < m_ColumnsHistory.Count(); i++)
{
// skip over any removed columns
if ( m_ColumnsHistory[i] == m_ColumnsData.InvalidIndex() )
continue;
column_t &column = m_ColumnsData[m_ColumnsHistory[i]];
IndexItem_t item;
item.dataItem = newitem;
item.duplicateIndex = 0;
IndexRBTree_t &rbtree = column.m_SortedTree;
// setup sort state
s_pCurrentSortingListPanel = this;
s_pCurrentSortingColumn = column.m_pHeader->GetName(); // name of current column for sorting
s_currentSortingColumnTypeIsText = column.m_bTypeIsText; // type of data in the column
SortFunc *sortFunc = column.m_pSortFunc;
if (!sortFunc)
{
sortFunc = DefaultSortFunc;
}
s_pSortFunc = sortFunc;
s_bSortAscending = true;
s_pSortFuncSecondary = NULL;
// insert index
newitem->m_SortedTreeIndexes[i] = rbtree.Insert(item);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::RereadAllItems()
{
//!! need to make this more efficient
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Cleans up allocations associated with a particular item
//-----------------------------------------------------------------------------
void ListPanel::CleanupItem( FastSortListPanelItem *data )
{
if ( data )
{
if (data->kv)
{
data->kv->deleteThis();
}
if (data->m_pDragData)
{
data->m_pDragData->deleteThis();
}
delete data;
}
}
//-----------------------------------------------------------------------------
// Purpose: Removes an item at the specified item
//-----------------------------------------------------------------------------
void ListPanel::RemoveItem(int itemID)
{
#ifdef _X360
bool renavigate = false;
if(HasFocus())
{
for(int i = 0; i < GetSelectedItemsCount(); ++i)
{
if(itemID == GetSelectedItem(i))
{
renavigate = true;
break;
}
}
}
#endif
FastSortListPanelItem *data = (FastSortListPanelItem*) m_DataItems[itemID];
if (!data)
return;
// remove from column sorted indexes
int i;
for ( i = 0; i < m_ColumnsHistory.Count(); i++ )
{
if ( m_ColumnsHistory[i] == m_ColumnsData.InvalidIndex())
continue;
IndexRBTree_t &rbtree = m_ColumnsData[m_ColumnsHistory[i]].m_SortedTree;
rbtree.RemoveAt(data->m_SortedTreeIndexes[i]);
}
// remove from selection
m_SelectedItems.FindAndRemove(itemID);
PostActionSignal( new KeyValues("ItemDeselected") );
// remove from visible items
m_VisibleItems.FindAndRemove(itemID);
// remove from data
m_DataItems.Remove(itemID);
CleanupItem( data );
InvalidateLayout();
#ifdef _X360
if(renavigate)
{
NavigateTo();
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: clears and deletes all the memory used by the data items
//-----------------------------------------------------------------------------
void ListPanel::RemoveAll()
{
// remove all sort indexes
for (int i = 0; i < m_ColumnsHistory.Count(); i++)
{
m_ColumnsData[m_ColumnsHistory[i]].m_SortedTree.RemoveAll();
}
FOR_EACH_LL( m_DataItems, index )
{
FastSortListPanelItem *pItem = m_DataItems[index];
CleanupItem( pItem );
}
m_DataItems.RemoveAll();
m_VisibleItems.RemoveAll();
ClearSelectedItems();
InvalidateLayout();
#ifdef _X360
if(HasFocus())
{
NavigateTo();
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: obselete, use RemoveAll();
//-----------------------------------------------------------------------------
void ListPanel::DeleteAllItems()
{
RemoveAll();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::ResetScrollBar()
{
// delete and reallocate to besure the scroll bar's
// information is correct.
delete m_vbar;
m_vbar = new ScrollBar(this, "VertScrollBar", true);
m_vbar->SetVisible(false);
m_vbar->AddActionSignalTarget(this);
}
//-----------------------------------------------------------------------------
// Purpose: returns the count of selected rows
//-----------------------------------------------------------------------------
int ListPanel::GetSelectedItemsCount()
{
return m_SelectedItems.Count();
}
//-----------------------------------------------------------------------------
// Purpose: returns the selected item by selection index
// Input : selectionIndex - valid in range [0, GetNumSelectedRows)
// Output : int - itemID
//-----------------------------------------------------------------------------
int ListPanel::GetSelectedItem(int selectionIndex)
{
if ( m_SelectedItems.IsValidIndex(selectionIndex))
return m_SelectedItems[selectionIndex];
return -1;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int ListPanel::GetSelectedColumn()
{
return m_iSelectedColumn;
}
//-----------------------------------------------------------------------------
// Purpose: Clears all selected rows
//-----------------------------------------------------------------------------
void ListPanel::ClearSelectedItems()
{
int nPrevCount = m_SelectedItems.Count();
m_SelectedItems.RemoveAll();
if ( nPrevCount > 0 )
{
PostActionSignal( new KeyValues("ItemDeselected") );
}
m_LastItemSelected = -1;
m_iSelectedColumn = -1;
}
//-----------------------------------------------------------------------------
bool ListPanel::IsItemSelected( int itemID )
{
return m_DataItems.IsValidIndex( itemID ) && m_SelectedItems.HasElement( itemID );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::AddSelectedItem( int itemID )
{
if ( !m_DataItems.IsValidIndex(itemID) )
return;
Assert( !m_SelectedItems.HasElement( itemID ) );
m_LastItemSelected = itemID;
m_SelectedItems.AddToTail( itemID );
PostActionSignal( new KeyValues("ItemSelected") );
Repaint();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::SetSingleSelectedItem( int itemID )
{
ClearSelectedItems();
AddSelectedItem(itemID);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::SetSelectedCell(int itemID, int col)
{
if ( !m_bCanSelectIndividualCells )
{
SetSingleSelectedItem(itemID);
return;
}
// make sure it's a valid cell
if ( !m_DataItems.IsValidIndex(itemID) )
return;
if ( !m_CurrentColumns.IsValidIndex(col) )
return;
SetSingleSelectedItem( itemID );
m_iSelectedColumn = col;
}
//-----------------------------------------------------------------------------
// Purpose: returns the data held by a specific cell
//-----------------------------------------------------------------------------
void ListPanel::GetCellText(int itemID, int col, wchar_t *wbuffer, int bufferSizeInBytes)
{
if ( !wbuffer || !bufferSizeInBytes )
return;
wcscpy( wbuffer, L"" );
KeyValues *itemData = GetItem( itemID );
if ( !itemData )
{
return;
}
// Look up column header
if ( col < 0 || col >= m_CurrentColumns.Count() )
{
return;
}
const char *key = m_ColumnsData[m_CurrentColumns[col]].m_pHeader->GetName();
if ( !key || !key[ 0 ] )
{
return;
}
char const *val = itemData->GetString( key, "" );
if ( !val || !key[ 0 ] )
return;
const wchar_t *wval = NULL;
if ( val[ 0 ] == '#' )
{
StringIndex_t si = g_pVGuiLocalize->FindIndex( val + 1 );
if ( si != INVALID_LOCALIZE_STRING_INDEX )
{
wval = g_pVGuiLocalize->GetValueByIndex( si );
}
}
if ( !wval )
{
wval = itemData->GetWString( key, L"" );
}
wcsncpy( wbuffer, wval, bufferSizeInBytes/sizeof(wchar_t) );
wbuffer[ (bufferSizeInBytes/sizeof(wchar_t)) - 1 ] = 0;
}
//-----------------------------------------------------------------------------
// Purpose: returns the data held by a specific cell
//-----------------------------------------------------------------------------
IImage *ListPanel::GetCellImage(int itemID, int col) //, ImagePanel *&buffer)
{
// if ( !buffer )
// return;
KeyValues *itemData = GetItem( itemID );
if ( !itemData )
{
return NULL;
}
// Look up column header
if ( col < 0 || col >= m_CurrentColumns.Count() )
{
return NULL;
}
const char *key = m_ColumnsData[m_CurrentColumns[col]].m_pHeader->GetName();
if ( !key || !key[ 0 ] )
{
return NULL;
}
if ( !m_pImageList )
{
return NULL;
}
int imageIndex = itemData->GetInt( key, 0 );
if ( m_pImageList->IsValidIndex(imageIndex) )
{
if ( imageIndex > 0 )
{
return m_pImageList->GetImage(imageIndex);
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the panel to use to render a cell
//-----------------------------------------------------------------------------
Panel *ListPanel::GetCellRenderer(int itemID, int col)
{
Assert( m_pTextImage );
Assert( m_pImagePanel );
column_t &column = m_ColumnsData[ m_CurrentColumns[col] ];
IScheme *pScheme = scheme()->GetIScheme( GetScheme() );
m_pLabel->SetContentAlignment( (Label::Alignment)column.m_nContentAlignment );
if ( column.m_bTypeIsText )
{
wchar_t tempText[ 256 ];
// Grab cell text
GetCellText( itemID, col, tempText, 256 );
KeyValues *item = GetItem( itemID );
m_pTextImage->SetText(tempText);
int cw, tall;
m_pTextImage->GetContentSize(cw, tall);
// set cell size
Panel *header = column.m_pHeader;
int wide = header->GetWide();
m_pTextImage->SetSize( min( cw, wide - 5 ), tall);
m_pLabel->SetTextImageIndex( 0 );
m_pLabel->SetImageAtIndex(0, m_pTextImage, 3);
bool selected = false;
if ( m_SelectedItems.HasElement(itemID) && ( !m_bCanSelectIndividualCells || col == m_iSelectedColumn ) )
{
selected = true;
VPANEL focus = input()->GetFocus();
// if one of the children of the SectionedListPanel has focus, then 'we have focus' if we're selected
if (HasFocus() || (focus && ipanel()->HasParent(focus, GetVParent())))
{
m_pLabel->SetBgColor(GetSchemeColor("ListPanel.SelectedBgColor", pScheme));
// selection
}
else
{
m_pLabel->SetBgColor(GetSchemeColor("ListPanel.SelectedOutOfFocusBgColor", pScheme));
}
if ( item->IsEmpty("cellcolor") == false )
{
m_pTextImage->SetColor( item->GetColor( "cellcolor" ) );
}
else if ( item->GetInt("disabled", 0) == 0 )
{
m_pTextImage->SetColor(m_SelectionFgColor);
}
else
{
m_pTextImage->SetColor(m_DisabledSelectionFgColor);
}
m_pLabel->SetPaintBackgroundEnabled(true);
}
else
{
if ( item->IsEmpty("cellcolor") == false )
{
m_pTextImage->SetColor( item->GetColor( "cellcolor" ) );
}
else if ( item->GetInt("disabled", 0) == 0 )
{
m_pTextImage->SetColor(m_LabelFgColor);
}
else
{
m_pTextImage->SetColor(m_DisabledColor);
}
m_pLabel->SetPaintBackgroundEnabled(false);
}
FastSortListPanelItem *listItem = m_DataItems[ itemID ];
if ( col == 0 &&
listItem->m_bImage && m_pImageList )
{
IImage *pImage = NULL;
if ( listItem->m_pIcon )
{
pImage = listItem->m_pIcon;
}
else
{
int imageIndex = selected ? listItem->m_nImageIndexSelected : listItem->m_nImageIndex;
if ( m_pImageList->IsValidIndex(imageIndex) )
{
pImage = m_pImageList->GetImage(imageIndex);
}
}
if ( pImage )
{
m_pLabel->SetTextImageIndex( 1 );
m_pLabel->SetImageAtIndex(0, pImage, 0);
m_pLabel->SetImageAtIndex(1, m_pTextImage, 3);
}
}
return m_pLabel;
}
else // if its an Image Panel
{
if ( m_SelectedItems.HasElement(itemID) && ( !m_bCanSelectIndividualCells || col == m_iSelectedColumn ) )
{
VPANEL focus = input()->GetFocus();
// if one of the children of the SectionedListPanel has focus, then 'we have focus' if we're selected
if (HasFocus() || (focus && ipanel()->HasParent(focus, GetVParent())))
{
m_pLabel->SetBgColor(GetSchemeColor("ListPanel.SelectedBgColor", pScheme));
// selection
}
else
{
m_pLabel->SetBgColor(GetSchemeColor("ListPanel.SelectedOutOfFocusBgColor", pScheme));
}
// selection
m_pLabel->SetPaintBackgroundEnabled(true);
}
else
{
m_pLabel->SetPaintBackgroundEnabled(false);
}
IImage *pIImage = GetCellImage(itemID, col);
m_pLabel->SetImageAtIndex(0, pIImage, 0);
return m_pLabel;
}
}
//-----------------------------------------------------------------------------
// Purpose: relayouts out the panel after any internal changes
//-----------------------------------------------------------------------------
void ListPanel::PerformLayout()
{
if ( m_CurrentColumns.Count() == 0 )
return;
if (m_bNeedsSort)
{
SortList();
}
int rowsperpage = (int) GetRowsPerPage();
// count the number of visible items
int visibleItemCount = m_VisibleItems.Count();
//!! need to make it recalculate scroll positions
m_vbar->SetVisible(true);
m_vbar->SetEnabled(false);
m_vbar->SetRangeWindow( rowsperpage );
m_vbar->SetRange( 0, visibleItemCount);
m_vbar->SetButtonPressedScrollValue( 1 );
int wide, tall;
GetSize( wide, tall );
m_vbar->SetPos(wide - (m_vbar->GetWide()+WINDOW_BORDER_WIDTH), 0);
m_vbar->SetSize(m_vbar->GetWide(), tall - 2);
m_vbar->InvalidateLayout();
int buttonMaxXPos = wide - (m_vbar->GetWide()+WINDOW_BORDER_WIDTH);
int nColumns = m_CurrentColumns.Count();
// number of bars that can be resized
int numToResize=0;
if (m_iColumnDraggerMoved != -1) // we're resizing in response to a column dragger
{
numToResize = 1; // only one column will change size, the one we dragged
}
else // we're resizing in response to a window resize
{
for (int i = 0; i < nColumns; i++)
{
if ( m_ColumnsData[m_CurrentColumns[i]].m_bResizesWithWindow // column is resizable in response to window
&& !m_ColumnsData[m_CurrentColumns[i]].m_bHidden)
{
numToResize++;
}
}
}
int dxPerBar; // zero on window first opening
// location of the last column resizer
int oldSizeX = 0, oldSizeY = 0;
int lastColumnIndex = nColumns-1;
for (int i = nColumns-1; i >= 0; --i)
{
if (!m_ColumnsData[m_CurrentColumns[i]].m_bHidden)
{
m_ColumnsData[m_CurrentColumns[i]].m_pHeader->GetPos(oldSizeX, oldSizeY);
lastColumnIndex = i;
break;
}
}
bool bForceShrink = false;
if ( numToResize == 0 )
{
// make sure we've got enough to be within minwidth
int minWidth=0;
for (int i = 0; i < nColumns; i++)
{
if (!m_ColumnsData[m_CurrentColumns[i]].m_bHidden)
{
minWidth += m_ColumnsData[m_CurrentColumns[i]].m_iMinWidth;
}
}
// if all the minimum widths cannot fit in the space given, then we will shrink ALL columns an equal amount
if (minWidth > buttonMaxXPos)
{
int dx = buttonMaxXPos - minWidth;
dxPerBar=(int)((float)dx/(float)nColumns);
bForceShrink = true;
}
else
{
dxPerBar = 0;
}
m_lastBarWidth = buttonMaxXPos;
}
else if ( oldSizeX != 0 ) // make sure this isnt the first time we opened the window
{
int dx = buttonMaxXPos - m_lastBarWidth; // this is how much we grew or shrank.
// see how many bars we have and now much each should grow/shrink
dxPerBar=(int)((float)dx/(float)numToResize);
m_lastBarWidth = buttonMaxXPos;
}
else // this is the first time we've opened the window, make sure all our colums fit! resize if needed
{
int startingBarWidth=0;
for (int i = 0; i < nColumns; i++)
{
if (!m_ColumnsData[m_CurrentColumns[i]].m_bHidden)
{
startingBarWidth += m_ColumnsData[m_CurrentColumns[i]].m_pHeader->GetWide();
}
}
int dx = buttonMaxXPos - startingBarWidth; // this is how much we grew or shrank.
// see how many bars we have and now much each should grow/shrink
dxPerBar=(int)((float)dx/(float)numToResize);
m_lastBarWidth = buttonMaxXPos;
}
// Make sure nothing is smaller than minwidth to start with or else we'll get into trouble below.
for ( int i=0; i < nColumns; i++ )
{
column_t &column = m_ColumnsData[m_CurrentColumns[i]];
Panel *header = column.m_pHeader;
if ( header->GetWide() < column.m_iMinWidth )
header->SetWide( column.m_iMinWidth );
}
// This was a while(1) loop and we hit an infinite loop case, so now we max out the # of times it can loop.
for ( int iLoopSanityCheck=0; iLoopSanityCheck < 1000; iLoopSanityCheck++ )
{
// try and place headers as is - before we have to force items to be minimum width
int x = -1;
int i;
for ( i = 0; i < nColumns; i++)
{
column_t &column = m_ColumnsData[m_CurrentColumns[i]];
Panel *header = column.m_pHeader;
if (column.m_bHidden)
{
header->SetVisible(false);
continue;
}
header->SetPos(x, 0);
header->SetVisible(true);
// if we couldn't fit this column - then we need to force items to be minimum width
if ( x+column.m_iMinWidth >= buttonMaxXPos && !bForceShrink )
{
break;
}
int hWide = header->GetWide();
// calculate the column's width
// make it so the last column always attaches to the scroll bar
if ( i == lastColumnIndex )
{
hWide = buttonMaxXPos-x;
}
else if (i == m_iColumnDraggerMoved ) // column resizing using dragger
{
hWide += dxPerBar; // adjust width of column
}
else if ( m_iColumnDraggerMoved == -1 ) // window is resizing
{
// either this column is allowed to resize OR we are forcing it because we're shrinking all columns
if ( column.m_bResizesWithWindow || bForceShrink )
{
Assert ( column.m_iMinWidth <= column.m_iMaxWidth );
hWide += dxPerBar; // adjust width of column
}
}
// enforce column mins and max's - unless we're FORCING it to shrink
if ( hWide < column.m_iMinWidth && !bForceShrink )
{
hWide = column.m_iMinWidth; // adjust width of column
}
else if ( hWide > column.m_iMaxWidth )
{
hWide = column.m_iMaxWidth;
}
header->SetSize(hWide, m_vbar->GetWide());
x += hWide;
// set the resizers
Panel *sizer = column.m_pResizer;
if ( i == lastColumnIndex )
{
sizer->SetVisible(false);
}
else
{
sizer->SetVisible(true);
}
sizer->MoveToFront();
sizer->SetPos(x - 4, 0);
sizer->SetSize(8, m_vbar->GetWide());
}
// we made it all the way through
if ( i == nColumns )
break;
// we do this AFTER trying first, to let as many columns as possible try and get to their
// desired width before we forcing the minimum width on them
// get the total desired width of all the columns
int totalDesiredWidth = 0;
for ( i = 0 ; i < nColumns ; i++ )
{
if (!m_ColumnsData[m_CurrentColumns[i]].m_bHidden)
{
Panel *pHeader = m_ColumnsData[m_CurrentColumns[i]].m_pHeader;
totalDesiredWidth += pHeader->GetWide();
}
}
// shrink from the most right column to minimum width until we can fit them all
Assert(totalDesiredWidth > buttonMaxXPos);
for ( i = nColumns-1; i >= 0 ; i--)
{
column_t &column = m_ColumnsData[m_CurrentColumns[i]];
if (!column.m_bHidden)
{
Panel *pHeader = column.m_pHeader;
totalDesiredWidth -= pHeader->GetWide();
if ( totalDesiredWidth + column.m_iMinWidth <= buttonMaxXPos )
{
int newWidth = buttonMaxXPos - totalDesiredWidth;
pHeader->SetSize( newWidth, m_vbar->GetWide() );
break;
}
totalDesiredWidth += column.m_iMinWidth;
pHeader->SetSize(column.m_iMinWidth, m_vbar->GetWide());
}
}
// If we don't allow this to shrink, then as we resize, it can get stuck in an infinite loop.
dxPerBar -= 5;
if ( dxPerBar < 0 )
dxPerBar = 0;
if ( i == -1 )
{
break;
}
}
// setup edit mode
if ( m_hEditModePanel.Get() )
{
m_iTableStartX = 0;
m_iTableStartY = m_iHeaderHeight + 1;
int nTotalRows = m_VisibleItems.Count();
int nRowsPerPage = GetRowsPerPage();
// find the first visible item to display
int nStartItem = 0;
if (nRowsPerPage <= nTotalRows)
{
nStartItem = m_vbar->GetValue();
}
bool bDone = false;
int drawcount = 0;
for (int i = nStartItem; i < nTotalRows && !bDone; i++)
{
int x = 0;
if (!m_VisibleItems.IsValidIndex(i))
continue;
int itemID = m_VisibleItems[i];
// iterate the columns
for (int j = 0; j < m_CurrentColumns.Count(); j++)
{
Panel *header = m_ColumnsData[m_CurrentColumns[j]].m_pHeader;
if (!header->IsVisible())
continue;
wide = header->GetWide();
if ( itemID == m_iEditModeItemID &&
j == m_iEditModeColumn )
{
m_hEditModePanel->SetPos( x + m_iTableStartX + 2, (drawcount * m_iRowHeight) + m_iTableStartY);
m_hEditModePanel->SetSize( wide, m_iRowHeight - 1 );
bDone = true;
}
x += wide;
}
drawcount++;
}
}
Repaint();
m_iColumnDraggerMoved = -1; // reset to invalid column
m_iHeaderHeight = m_ColumnsData[0].m_pHeader ? m_ColumnsData[0].m_pHeader->GetTall() : m_iHeaderHeight;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::OnSizeChanged(int wide, int tall)
{
BaseClass::OnSizeChanged(wide, tall);
InvalidateLayout();
Repaint();
}
//-----------------------------------------------------------------------------
// Purpose: Renders the cells
//-----------------------------------------------------------------------------
void ListPanel::Paint()
{
if (m_bNeedsSort)
{
SortList();
}
// draw selection areas if any
int wide, tall;
GetSize( wide, tall );
m_iTableStartX = 0;
m_iTableStartY = m_iHeaderHeight + 1;
int nTotalRows = m_VisibleItems.Count();
int nRowsPerPage = GetRowsPerPage();
// find the first visible item to display
int nStartItem = 0;
if (nRowsPerPage <= nTotalRows)
{
nStartItem = m_vbar->GetValue();
}
int vbarInset = m_vbar->IsVisible() ? m_vbar->GetWide() : 0;
int maxw = wide - vbarInset - 8;
// debug timing functions
// double startTime, endTime;
// startTime = system()->GetCurrentTime();
// iterate through and draw each cell
bool bDone = false;
int drawcount = 0;
for (int i = nStartItem; i < nTotalRows && !bDone; i++)
{
int x = 0;
if (!m_VisibleItems.IsValidIndex(i))
continue;
int itemID = m_VisibleItems[i];
// iterate the columns
for (int j = 0; j < m_CurrentColumns.Count(); j++)
{
Panel *header = m_ColumnsData[m_CurrentColumns[j]].m_pHeader;
Panel *render = GetCellRenderer(itemID, j);
if (!header->IsVisible())
continue;
int hWide = header->GetWide();
if (render)
{
// setup render panel
if (render->GetVParent() != GetVPanel())
{
render->SetParent(GetVPanel());
}
if (!render->IsVisible())
{
render->SetVisible(true);
}
int xpos = x + m_iTableStartX + 2;
render->SetPos( xpos, (drawcount * m_iRowHeight) + m_iTableStartY);
int right = min( xpos + hWide, maxw );
int usew = right - xpos;
render->SetSize( usew, m_iRowHeight - 1 );
// mark the panel to draw immediately (since it will probably be recycled to draw other cells)
render->Repaint();
surface()->SolveTraverse(render->GetVPanel());
int x0, y0, x1, y1;
render->GetClipRect(x0, y0, x1, y1);
if ((y1 - y0) < (m_iRowHeight - 3))
{
bDone = true;
break;
}
surface()->PaintTraverse(render->GetVPanel());
}
/*
// work in progress, optimized paint for text
else
{
// just paint it ourselves
char tempText[256];
// Grab cell text
GetCellText(i, j, tempText, sizeof(tempText));
surface()->DrawSetTextPos(x + m_iTableStartX + 2, (drawcount * m_iRowHeight) + m_iTableStartY);
for (const char *pText = tempText; *pText != 0; pText++)
{
surface()->DrawUnicodeChar((wchar_t)*pText);
}
}
*/
x += hWide;
}
drawcount++;
}
m_pLabel->SetVisible(false);
// if the list is empty, draw some help text
if (m_VisibleItems.Count() < 1 && m_pEmptyListText)
{
m_pEmptyListText->SetPos(m_iTableStartX + 8, m_iTableStartY + 4);
m_pEmptyListText->SetSize(wide - 8, m_iRowHeight);
m_pEmptyListText->Paint();
}
// endTime = system()->GetCurrentTime();
// ivgui()->DPrintf2("ListPanel::Paint() (%.3f sec)\n", (float)(endTime - startTime));
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::PaintBackground()
{
BaseClass::PaintBackground();
}
//-----------------------------------------------------------------------------
// Handles multiselect
//-----------------------------------------------------------------------------
void ListPanel::HandleMultiSelection( int itemID, int row, int column )
{
// deal with 'multiple' row selection
// convert the last item selected to a row so we can multiply select by rows NOT items
int lastSelectedRow = (m_LastItemSelected != -1) ? m_VisibleItems.Find( m_LastItemSelected ) : row;
int startRow, endRow;
if ( row < lastSelectedRow )
{
startRow = row;
endRow = lastSelectedRow;
}
else
{
startRow = lastSelectedRow;
endRow = row;
}
// clear the selection if neither control key was down - we are going to readd ALL selected items
// in case the user changed the 'direction' of the shift add
if ( !input()->IsKeyDown(KEY_LCONTROL) && !input()->IsKeyDown(KEY_RCONTROL) )
{
ClearSelectedItems();
}
// add any items that we haven't added
for (int i = startRow; i <= endRow; i++)
{
// get the item indexes for these rows
int selectedItemID = m_VisibleItems[i];
if ( !m_SelectedItems.HasElement(selectedItemID) )
{
AddSelectedItem( selectedItemID );
}
}
}
//-----------------------------------------------------------------------------
// Handles multiselect
//-----------------------------------------------------------------------------
void ListPanel::HandleAddSelection( int itemID, int row, int column )
{
// dealing with row selection
if ( m_SelectedItems.HasElement( itemID ) )
{
// this row is already selected, remove
m_SelectedItems.FindAndRemove( itemID );
PostActionSignal( new KeyValues("ItemDeselected") );
m_LastItemSelected = itemID;
}
else
{
// add the row to the selection
AddSelectedItem( itemID );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::UpdateSelection( MouseCode code, int x, int y, int row, int column )
{
// make sure we're clicking on a real item
if ( row < 0 || row >= m_VisibleItems.Count() )
{
ClearSelectedItems();
return;
}
int itemID = m_VisibleItems[ row ];
// if we've right-clicked on a selection, don't change the selection
if ( code == MOUSE_RIGHT && m_SelectedItems.HasElement( itemID ) )
return;
if ( m_bCanSelectIndividualCells )
{
if ( input()->IsKeyDown(KEY_LCONTROL) || input()->IsKeyDown(KEY_RCONTROL) )
{
// we're ctrl selecting the same cell, clear it
if ( ( m_LastItemSelected == itemID ) && ( m_iSelectedColumn == column ) && ( m_SelectedItems.Count() == 1 ) )
{
ClearSelectedItems();
}
else
{
SetSelectedCell( itemID, column );
}
}
else
{
SetSelectedCell( itemID, column );
}
return;
}
if ( !m_bMultiselectEnabled )
{
SetSingleSelectedItem( itemID );
return;
}
if ( input()->IsKeyDown(KEY_LSHIFT) || input()->IsKeyDown(KEY_RSHIFT) )
{
// check for multi-select
HandleMultiSelection( itemID, row, column );
}
else if ( input()->IsKeyDown(KEY_LCONTROL) || input()->IsKeyDown(KEY_RCONTROL) )
{
// check for row-add select
HandleAddSelection( itemID, row, column );
}
else
{
// no CTRL or SHIFT keys
// reset the selection Start point
// if ( ( m_LastItemSelected != itemID ) || ( m_SelectedItems.Count() > 1 ) )
{
SetSingleSelectedItem( itemID );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::OnMousePressed( MouseCode code )
{
if (code == MOUSE_LEFT || code == MOUSE_RIGHT)
{
if ( m_VisibleItems.Count() > 0 )
{
// determine where we were pressed
int x, y, row, column;
input()->GetCursorPos(x, y);
GetCellAtPos(x, y, row, column);
UpdateSelection( code, x, y, row, column );
}
// get the key focus
RequestFocus();
}
// check for context menu open
if (code == MOUSE_RIGHT)
{
if ( m_SelectedItems.Count() > 0 )
{
PostActionSignal( new KeyValues("OpenContextMenu", "itemID", m_SelectedItems[0] ));
}
else
{
// post it, but with the invalid row
PostActionSignal( new KeyValues("OpenContextMenu", "itemID", -1 ));
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Scrolls the list according to the mouse wheel movement
//-----------------------------------------------------------------------------
void ListPanel::OnMouseWheeled(int delta)
{
if (m_hEditModePanel.Get())
{
// ignore mouse wheel in edit mode, forward right up to parent
CallParentFunction(new KeyValues("MouseWheeled", "delta", delta));
return;
}
int val = m_vbar->GetValue();
val -= (delta * 3);
m_vbar->SetValue(val);
}
//-----------------------------------------------------------------------------
// Purpose: Double-click act like the the item under the mouse was selected
// and then the enter key hit
//-----------------------------------------------------------------------------
void ListPanel::OnMouseDoublePressed(MouseCode code)
{
if (code == MOUSE_LEFT)
{
// select the item
OnMousePressed(code);
// post up an enter key being hit if anything was selected
if (GetSelectedItemsCount() > 0 && !m_bIgnoreDoubleClick )
{
OnKeyCodeTyped(KEY_ENTER);
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
#ifdef _X360
void ListPanel::OnKeyCodePressed(KeyCode code)
{
int nTotalRows = m_VisibleItems.Count();
int nTotalColumns = m_CurrentColumns.Count();
if ( nTotalRows == 0 )
return;
// calculate info for adjusting scrolling
int nStartItem = GetStartItem();
int nRowsPerPage = (int)GetRowsPerPage();
int nSelectedRow = 0;
if ( m_DataItems.IsValidIndex( m_LastItemSelected ) )
{
nSelectedRow = m_VisibleItems.Find( m_LastItemSelected );
}
int nSelectedColumn = m_iSelectedColumn;
switch(code)
{
case KEY_XBUTTON_UP:
case KEY_XSTICK1_UP:
case KEY_XSTICK2_UP:
if(GetItemCount() < 1 || nSelectedRow == nStartItem)
{
ClearSelectedItems();
BaseClass::OnKeyCodePressed(code);
return;
}
else
{
nSelectedRow -= 1;
}
break;
case KEY_XBUTTON_DOWN:
case KEY_XSTICK1_DOWN:
case KEY_XSTICK2_DOWN:
{
int itemId = GetSelectedItem(0);
if(itemId != -1 && GetItemCurrentRow(itemId) == (nTotalRows - 1))
{
ClearSelectedItems();
BaseClass::OnKeyCodePressed(code);
return;
}
else
{
nSelectedRow += 1;
}
}
break;
case KEY_XBUTTON_LEFT:
case KEY_XSTICK1_LEFT:
case KEY_XSTICK2_LEFT:
if (m_bCanSelectIndividualCells && (GetSelectedItemsCount() == 1) && (nSelectedColumn >= 0) )
{
nSelectedColumn--;
if (nSelectedColumn < 0)
{
nSelectedColumn = 0;
}
break;
}
break;
case KEY_XBUTTON_RIGHT:
case KEY_XSTICK1_RIGHT:
case KEY_XSTICK2_RIGHT:
if (m_bCanSelectIndividualCells && (GetSelectedItemsCount() == 1) && (nSelectedColumn >= 0) )
{
nSelectedColumn++;
if (nSelectedColumn >= nTotalColumns)
{
nSelectedColumn = nTotalColumns - 1;
}
break;
}
break;
case KEY_XBUTTON_A:
PostActionSignal( new KeyValues("ListPanelItemChosen", "itemID", m_SelectedItems[0] ));
break;
default:
BaseClass::OnKeyCodePressed(code);
break;
}
// make sure newly selected item is a valid range
nSelectedRow = clamp(nSelectedRow, 0, nTotalRows - 1);
int row = m_VisibleItems[ nSelectedRow ];
// This will select the cell if in single select mode, or the row in multiselect mode
if ( ( row != m_LastItemSelected ) || ( nSelectedColumn != m_iSelectedColumn ) || ( m_SelectedItems.Count() > 1 ) )
{
SetSelectedCell( row, nSelectedColumn );
}
// move the newly selected item to within the visible range
if ( nRowsPerPage < nTotalRows )
{
int nStartItem = m_vbar->GetValue();
if ( nSelectedRow < nStartItem )
{
// move the list back to match
m_vbar->SetValue( nSelectedRow );
}
else if ( nSelectedRow >= nStartItem + nRowsPerPage )
{
// move list forward to match
m_vbar->SetValue( nSelectedRow - nRowsPerPage + 1);
}
}
// redraw
InvalidateLayout();
}
#else
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::OnKeyCodePressed(KeyCode code)
{
if (m_hEditModePanel.Get())
{
// ignore arrow keys in edit mode
// forward right up to parent so that tab focus change doesn't occur
CallParentFunction(new KeyValues("KeyCodePressed", "code", code));
return;
}
int nTotalRows = m_VisibleItems.Count();
int nTotalColumns = m_CurrentColumns.Count();
if ( nTotalRows == 0 )
{
BaseClass::OnKeyCodePressed(code);
return;
}
// calculate info for adjusting scrolling
int nStartItem = GetStartItem();
int nRowsPerPage = (int)GetRowsPerPage();
int nSelectedRow = 0;
if ( m_DataItems.IsValidIndex( m_LastItemSelected ) )
{
nSelectedRow = m_VisibleItems.Find( m_LastItemSelected );
}
int nSelectedColumn = m_iSelectedColumn;
switch (code)
{
case KEY_HOME:
nSelectedRow = 0;
break;
case KEY_END:
nSelectedRow = nTotalRows - 1;
break;
case KEY_PAGEUP:
if (nSelectedRow <= nStartItem)
{
// move up a page
nSelectedRow -= (nRowsPerPage - 1);
}
else
{
// move to the top of the current page
nSelectedRow = nStartItem;
}
break;
case KEY_PAGEDOWN:
if (nSelectedRow >= (nStartItem + nRowsPerPage-1))
{
// move down a page
nSelectedRow += (nRowsPerPage - 1);
}
else
{
// move to the bottom of the current page
nSelectedRow = nStartItem + (nRowsPerPage - 1);
}
break;
case KEY_UP:
case KEY_XBUTTON_UP:
case KEY_XSTICK1_UP:
case KEY_XSTICK2_UP:
case STEAMCONTROLLER_DPAD_UP:
if ( nTotalRows > 0 )
{
nSelectedRow--;
break;
}
// fall through
case KEY_DOWN:
case KEY_XBUTTON_DOWN:
case KEY_XSTICK1_DOWN:
case KEY_XSTICK2_DOWN:
case STEAMCONTROLLER_DPAD_DOWN:
if ( nTotalRows > 0 )
{
nSelectedRow++;
break;
}
// fall through
case KEY_LEFT:
case KEY_XBUTTON_LEFT:
case KEY_XSTICK1_LEFT:
case KEY_XSTICK2_LEFT:
if (m_bCanSelectIndividualCells && (GetSelectedItemsCount() == 1) && (nSelectedColumn >= 0) )
{
nSelectedColumn--;
if (nSelectedColumn < 0)
{
nSelectedColumn = 0;
}
break;
}
// fall through
case KEY_RIGHT:
case KEY_XBUTTON_RIGHT:
case KEY_XSTICK1_RIGHT:
case KEY_XSTICK2_RIGHT:
if (m_bCanSelectIndividualCells && (GetSelectedItemsCount() == 1) && (nSelectedColumn >= 0) )
{
nSelectedColumn++;
if (nSelectedColumn >= nTotalColumns)
{
nSelectedColumn = nTotalColumns - 1;
}
break;
}
// fall through
default:
// chain back
BaseClass::OnKeyCodePressed(code);
return;
};
// make sure newly selected item is a valid range
nSelectedRow = clamp(nSelectedRow, 0, nTotalRows - 1);
int row = m_VisibleItems[ nSelectedRow ];
// This will select the cell if in single select mode, or the row in multiselect mode
if ( ( row != m_LastItemSelected ) || ( nSelectedColumn != m_iSelectedColumn ) || ( m_SelectedItems.Count() > 1 ) )
{
SetSelectedCell( row, nSelectedColumn );
}
// move the newly selected item to within the visible range
if ( nRowsPerPage < nTotalRows )
{
nStartItem = m_vbar->GetValue();
if ( nSelectedRow < nStartItem )
{
// move the list back to match
m_vbar->SetValue( nSelectedRow );
}
else if ( nSelectedRow >= nStartItem + nRowsPerPage )
{
// move list forward to match
m_vbar->SetValue( nSelectedRow - nRowsPerPage + 1);
}
}
// redraw
InvalidateLayout();
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool ListPanel::GetCellBounds( int row, int col, int& x, int& y, int& wide, int& tall )
{
if ( col < 0 || col >= m_CurrentColumns.Count() )
return false;
if ( row < 0 || row >= m_VisibleItems.Count() )
return false;
// Is row on screen?
int startitem = GetStartItem();
if ( row < startitem || row >= ( startitem + GetRowsPerPage() ) )
return false;
y = m_iTableStartY;
y += ( row - startitem ) * m_iRowHeight;
tall = m_iRowHeight;
// Compute column cell
x = m_iTableStartX;
// walk columns
int c = 0;
while ( c < col)
{
x += m_ColumnsData[m_CurrentColumns[c]].m_pHeader->GetWide();
c++;
}
wide = m_ColumnsData[m_CurrentColumns[c]].m_pHeader->GetWide();
return true;
}
//-----------------------------------------------------------------------------
// Purpose: returns true if any found, row and column are filled out
//-----------------------------------------------------------------------------
bool ListPanel::GetCellAtPos(int x, int y, int &row, int &col)
{
// convert to local
ScreenToLocal(x, y);
// move to Start of table
x -= m_iTableStartX;
y -= m_iTableStartY;
int startitem = GetStartItem();
// make sure it's still in valid area
if ( x >= 0 && y >= 0 )
{
// walk the rows (for when row height is independant each row)
// NOTE: if we do height independent rows, we will need to change GetCellBounds as well
for ( row = startitem ; row < m_VisibleItems.Count() ; row++ )
{
if ( y < ( ( ( row - startitem ) + 1 ) * m_iRowHeight ) )
break;
}
// walk columns
int startx = 0;
for ( col = 0 ; col < m_CurrentColumns.Count() ; col++ )
{
startx += m_ColumnsData[m_CurrentColumns[col]].m_pHeader->GetWide();
if ( x < startx )
break;
}
// make sure we're not out of range
if ( ! ( row == m_VisibleItems.Count() || col == m_CurrentColumns.Count() ) )
{
return true;
}
}
// out-of-bounds
row = col = -1;
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::ApplySchemeSettings(IScheme *pScheme)
{
// force label to apply scheme settings now so we can override it
m_pLabel->InvalidateLayout(true);
BaseClass::ApplySchemeSettings(pScheme);
SetBgColor(GetSchemeColor("ListPanel.BgColor", pScheme));
SetBorder(pScheme->GetBorder("ButtonDepressedBorder"));
m_pLabel->SetBgColor(GetSchemeColor("ListPanel.BgColor", pScheme));
m_LabelFgColor = GetSchemeColor("ListPanel.TextColor", pScheme);
m_DisabledColor = GetSchemeColor("ListPanel.DisabledTextColor", m_LabelFgColor, pScheme);
m_SelectionFgColor = GetSchemeColor("ListPanel.SelectedTextColor", m_LabelFgColor, pScheme);
m_DisabledSelectionFgColor = GetSchemeColor("ListPanel.DisabledSelectedTextColor", m_LabelFgColor, pScheme);
m_pEmptyListText->SetColor(GetSchemeColor("ListPanel.EmptyListInfoTextColor", pScheme));
SetFont( pScheme->GetFont("Default", IsProportional() ) );
m_pEmptyListText->SetFont( pScheme->GetFont( "Default", IsProportional() ) );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::SetSortFunc(int col, SortFunc *func)
{
Assert(col < m_CurrentColumns.Count());
unsigned char dataColumnIndex = m_CurrentColumns[col];
if ( !m_ColumnsData[dataColumnIndex].m_bTypeIsText && func != NULL)
{
m_ColumnsData[dataColumnIndex].m_pHeader->SetMouseClickEnabled(MOUSE_LEFT, 1);
}
m_ColumnsData[dataColumnIndex].m_pSortFunc = func;
// resort this column according to new sort func
ResortColumnRBTree(col);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::SetSortColumn(int column)
{
m_iSortColumn = column;
}
int ListPanel::GetSortColumn() const
{
return m_iSortColumn;
}
void ListPanel::SetSortColumnEx( int iPrimarySortColumn, int iSecondarySortColumn, bool bSortAscending )
{
m_iSortColumn = iPrimarySortColumn;
m_iSortColumnSecondary = iSecondarySortColumn;
m_bSortAscending = bSortAscending;
}
void ListPanel::GetSortColumnEx( int &iPrimarySortColumn, int &iSecondarySortColumn, bool &bSortAscending ) const
{
iPrimarySortColumn = m_iSortColumn;
iSecondarySortColumn = m_iSortColumnSecondary;
bSortAscending = m_bSortAscending;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::SortList( void )
{
m_bNeedsSort = false;
if ( m_VisibleItems.Count() <= 1 )
{
return;
}
// check if the last selected item is on the screen - if so, we should try to maintain it on screen
int startItem = GetStartItem();
int rowsperpage = (int) GetRowsPerPage();
int screenPosition = -1;
if ( m_LastItemSelected != -1 && m_SelectedItems.Count() > 0 )
{
int selectedItemRow = m_VisibleItems.Find(m_LastItemSelected);
if ( selectedItemRow >= startItem && selectedItemRow <= ( startItem + rowsperpage ) )
{
screenPosition = selectedItemRow - startItem;
}
}
// get the required sorting functions
s_pCurrentSortingListPanel = this;
// setup globals for use in qsort
s_pSortFunc = FastSortFunc;
s_bSortAscending = m_bSortAscending;
s_pSortFuncSecondary = FastSortFunc;
s_bSortAscendingSecondary = m_bSortAscendingSecondary;
// walk the tree and set up the current indices
if (m_CurrentColumns.IsValidIndex(m_iSortColumn))
{
IndexRBTree_t &rbtree = m_ColumnsData[m_CurrentColumns[m_iSortColumn]].m_SortedTree;
unsigned int index = rbtree.FirstInorder();
unsigned int lastIndex = rbtree.LastInorder();
int prevDuplicateIndex = 0;
int sortValue = 1;
while (1)
{
FastSortListPanelItem *dataItem = (FastSortListPanelItem*) rbtree[index].dataItem;
if (dataItem->visible)
{
// only increment the sort value if we're a different token from the previous
if (!prevDuplicateIndex || prevDuplicateIndex != rbtree[index].duplicateIndex)
{
sortValue++;
}
dataItem->primarySortIndexValue = sortValue;
prevDuplicateIndex = rbtree[index].duplicateIndex;
}
if (index == lastIndex)
break;
index = rbtree.NextInorder(index);
}
}
// setup secondary indices
if (m_CurrentColumns.IsValidIndex(m_iSortColumnSecondary))
{
IndexRBTree_t &rbtree = m_ColumnsData[m_CurrentColumns[m_iSortColumnSecondary]].m_SortedTree;
unsigned int index = rbtree.FirstInorder();
unsigned int lastIndex = rbtree.LastInorder();
int sortValue = 1;
int prevDuplicateIndex = 0;
while (1)
{
FastSortListPanelItem *dataItem = (FastSortListPanelItem*) rbtree[index].dataItem;
if (dataItem->visible)
{
// only increment the sort value if we're a different token from the previous
if (!prevDuplicateIndex || prevDuplicateIndex != rbtree[index].duplicateIndex)
{
sortValue++;
}
dataItem->secondarySortIndexValue = sortValue;
prevDuplicateIndex = rbtree[index].duplicateIndex;
}
if (index == lastIndex)
break;
index = rbtree.NextInorder(index);
}
}
// quick sort the list
qsort(m_VisibleItems.Base(), (size_t) m_VisibleItems.Count(), (size_t) sizeof(int), AscendingSortFunc);
if ( screenPosition != -1 )
{
int selectedItemRow = m_VisibleItems.Find(m_LastItemSelected);
// if we can put the last selected item in exactly the same spot, put it there, otherwise
// we need to be at the top of the list
if (selectedItemRow > screenPosition)
{
m_vbar->SetValue(selectedItemRow - screenPosition);
}
else
{
m_vbar->SetValue(0);
}
}
InvalidateLayout();
Repaint();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::SetFont(HFont font)
{
arm64 : fix intptr_t size
3 years ago
Assert( font );
1
5 years ago
if ( !font )
return;
m_pTextImage->SetFont(font);
m_iRowHeight = surface()->GetFontTall(font) + 2;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ListPanel::OnSliderMoved()
{
InvalidateLayout();
Repaint();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : deltax - deltas from current position
//-----------------------------------------------------------------------------
void ListPanel::OnColumnResized(int col, int delta)
{
m_iColumnDraggerMoved = col;
column_t& column = m_ColumnsData[m_CurrentColumns[col]];
Panel *header = column.m_pHeader;
int wide, tall;
header->GetSize(wide, tall);
wide += delta;
// enforce minimum sizes for the header
if ( wide < column.m_iMinWidth )
{
wide = column.m_iMinWidth;
}
// enforce maximum sizes for the header
if ( wide > column.m_iMaxWidth )
{
wide = column.m_iMaxWidth;
}
// make sure we have enough space for the columns to our right
int panelWide, panelTall;
GetSize( panelWide, panelTall );
int x, y;
header->GetPos(x, y);
int restColumnsMinWidth = 0;
int i;
for ( i = col+1 ; i < m_CurrentColumns.Count() ; i++ )
{
column_t& nextCol = m_ColumnsData[m_CurrentColumns[i]];
restColumnsMinWidth += nextCol.m_iMinWidth;
}
panelWide -= ( x + restColumnsMinWidth + m_vbar->GetWide() + WINDOW_BORDER_WIDTH );
if ( wide > panelWide )
{
wide = panelWide;
}
header->SetSize(wide, tall);
// the adjacent header will be moved automatically in PerformLayout()
header->InvalidateLayout();
InvalidateLayout();
Repaint();
}
//-----------------------------------------------------------------------------
// Purpose: sets which column we should sort with
//-----------------------------------------------------------------------------
void ListPanel::OnSetSortColumn(int column)
{
// if it's the primary column already, flip the sort direction
if (m_iSortColumn == column)
{
m_bSortAscending = !m_bSortAscending;
}
else
{
// switching sort columns, keep the old one as the secondary sort
m_iSortColumnSecondary = m_iSortColumn;
m_bSortAscendingSecondary = m_bSortAscending;
}
SetSortColumn(column);
SortList();
}
//-----------------------------------------------------------------------------
// Purpose: sets whether the item is visible or not
//-----------------------------------------------------------------------------
void ListPanel::SetItemVisible(int itemID, bool state)
{
if ( !m_DataItems.IsValidIndex(itemID) )
return;
FastSortListPanelItem *data = (FastSortListPanelItem*) m_DataItems[itemID];
if (data->visible == state)
return;
m_bNeedsSort = true;
data->visible = state;
if (data->visible)
{
// add back to end of list
m_VisibleItems.AddToTail(itemID);
}
else
{
// remove from selection if it is there.
if (m_SelectedItems.HasElement(itemID))
{
m_SelectedItems.FindAndRemove(itemID);
PostActionSignal( new KeyValues("ItemDeselected") );
}
// remove from data
m_VisibleItems.FindAndRemove(itemID);
InvalidateLayout();
}
}
//-----------------------------------------------------------------------------
// Is the item visible?
//-----------------------------------------------------------------------------
bool ListPanel::IsItemVisible( int itemID )
{
if ( !m_DataItems.IsValidIndex(itemID) )
return false;
FastSortListPanelItem *data = (FastSortListPanelItem*) m_DataItems[itemID];
return data->visible;
}
//-----------------------------------------------------------------------------
// Purpose: sets whether the item is disabled or not (effects item color)
//-----------------------------------------------------------------------------
void ListPanel::SetItemDisabled(int itemID, bool state)
{
if ( !m_DataItems.IsValidIndex(itemID) )
return;
m_DataItems[itemID]->kv->SetInt( "disabled", state );
}
//-----------------------------------------------------------------------------
// Purpose: Calculate number of rows per page
//-----------------------------------------------------------------------------
float ListPanel::GetRowsPerPage()
{
float rowsperpage = (float)( GetTall() - m_iHeaderHeight ) / (float)m_iRowHeight;
return rowsperpage;
}
//-----------------------------------------------------------------------------
// Purpose: Calculate the item we should Start on
//-----------------------------------------------------------------------------
int ListPanel::GetStartItem()
{
// if rowsperpage < total number of rows
if ( GetRowsPerPage() < (float) m_VisibleItems.Count() )
{
return m_vbar->GetValue();
}
return 0; // otherwise Start at top
}
//-----------------------------------------------------------------------------
// Purpose: whether or not to select specific cells (off by default)
//-----------------------------------------------------------------------------
void ListPanel::SetSelectIndividualCells(bool state)
{
m_bCanSelectIndividualCells = state;
}
//-----------------------------------------------------------------------------
// whether or not multiple cells/rows can be selected
//-----------------------------------------------------------------------------
void ListPanel::SetMultiselectEnabled( bool bState )
{
m_bMultiselectEnabled = bState;
}
bool ListPanel::IsMultiselectEnabled() const
{
return m_bMultiselectEnabled;
}
//-----------------------------------------------------------------------------
// Purpose: Sets the text which is displayed when the list is empty
//-----------------------------------------------------------------------------
void ListPanel::SetEmptyListText(const char *text)
{
m_pEmptyListText->SetText(text);
Repaint();
}
//-----------------------------------------------------------------------------
// Purpose: Sets the text which is displayed when the list is empty
//-----------------------------------------------------------------------------
void ListPanel::SetEmptyListText(const wchar_t *text)
{
m_pEmptyListText->SetText(text);
Repaint();
}
//-----------------------------------------------------------------------------
// Purpose: opens the content menu
//-----------------------------------------------------------------------------
void ListPanel::OpenColumnChoiceMenu()
{
if (!m_bAllowUserAddDeleteColumns)
return;
Menu *menu = new Menu(this, "ContextMenu");
int x, y;
input()->GetCursorPos(x, y);
menu->SetPos(x, y);
// add all the column choices to the menu
for ( int i = 0 ; i < m_CurrentColumns.Count() ; i++ )
{
column_t &column = m_ColumnsData[m_CurrentColumns[i]];
char name[128];
column.m_pHeader->GetText(name, sizeof(name));
int itemID = menu->AddCheckableMenuItem(name, new KeyValues("ToggleColumnVisible", "col", m_CurrentColumns[i]), this);
menu->SetMenuItemChecked(itemID, !column.m_bHidden);
if (column.m_bUnhidable)
{
menu->SetItemEnabled(itemID, false);
}
}
menu->SetVisible(true);
}
//-----------------------------------------------------------------------------
// Purpose: Resizes a column
//-----------------------------------------------------------------------------
void ListPanel::ResizeColumnToContents(int column)
{
// iterate all the items in the column, getting the size of each
column_t &col = m_ColumnsData[m_CurrentColumns[column]];
if (!col.m_bTypeIsText)
return;
// start with the size of the column text
int wide = 0, minRequiredWidth = 0, tall = 0;
col.m_pHeader->GetContentSize( minRequiredWidth, tall );
// iterate every item
for (int i = 0; i < m_VisibleItems.Count(); i++)
{
if (!m_VisibleItems.IsValidIndex(i))
continue;
// get the cell
int itemID = m_VisibleItems[i];
// get the text
wchar_t tempText[ 256 ];
GetCellText( itemID, column, tempText, 256 );
m_pTextImage->SetText(tempText);
m_pTextImage->GetContentSize(wide, tall);
if ( wide > minRequiredWidth )
{
minRequiredWidth = wide;
}
}
// Introduce a slight buffer between columns
minRequiredWidth += 4;
// call the resize
col.m_pHeader->GetSize(wide, tall);
OnColumnResized(column, minRequiredWidth - wide);
}
//-----------------------------------------------------------------------------
// Purpose: Changes the visibilty of a column
//-----------------------------------------------------------------------------
void ListPanel::OnToggleColumnVisible(int col)
{
if (!m_CurrentColumns.IsValidIndex(col))
return;
// toggle the state of the column
column_t &column = m_ColumnsData[m_CurrentColumns[col]];
SetColumnVisible(col, column.m_bHidden);
}
//-----------------------------------------------------------------------------
// Purpose: sets user settings
//-----------------------------------------------------------------------------
void ListPanel::ApplyUserConfigSettings(KeyValues *userConfig)
{
// Check for version mismatch, then don't load settings. (Just revert to the defaults.)
int version = userConfig->GetInt( "configVersion", 1 );
if ( version != m_nUserConfigFileVersion )
{
return;
}
// We save/restore m_lastBarWidth because all of the column widths are saved relative to that size.
// If we don't save it, you can run into this case:
// - Window width is 500, load sizes setup relative to a 1000-width window
// - Set window size to 1000
// - In PerformLayout, it thinks the window has grown by 500 (since m_lastBarWidth is 500 and new window width is 1000)
// so it pushes out any COLUMN_RESIZEWITHWINDOW columns to their max extent and shrinks everything else to its min extent.
m_lastBarWidth = userConfig->GetInt( "lastBarWidth", 0 );
// read which columns are hidden
for ( int i = 0; i < m_CurrentColumns.Count(); i++ )
{
char name[64];
_snprintf(name, sizeof(name), "%d_hidden", i);
int hidden = userConfig->GetInt(name, -1);
if (hidden == 0)
{
SetColumnVisible(i, true);
}
else if (hidden == 1)
{
SetColumnVisible(i, false);
}
_snprintf(name, sizeof(name), "%d_width", i);
int nWidth = userConfig->GetInt( name, -1 );
if ( nWidth >= 0 )
{
column_t &column = m_ColumnsData[m_CurrentColumns[i]];
column.m_pHeader->SetWide( nWidth );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: returns user config settings for this control
//-----------------------------------------------------------------------------
void ListPanel::GetUserConfigSettings(KeyValues *userConfig)
{
if ( m_nUserConfigFileVersion != 1 )
{
userConfig->SetInt( "configVersion", m_nUserConfigFileVersion );
}
userConfig->SetInt( "lastBarWidth", m_lastBarWidth );
// save which columns are hidden
for ( int i = 0 ; i < m_CurrentColumns.Count() ; i++ )
{
column_t &column = m_ColumnsData[m_CurrentColumns[i]];
char name[64];
_snprintf(name, sizeof(name), "%d_hidden", i);
userConfig->SetInt(name, column.m_bHidden ? 1 : 0);
_snprintf(name, sizeof(name), "%d_width", i);
userConfig->SetInt( name, column.m_pHeader->GetWide() );
}
}
//-----------------------------------------------------------------------------
// Purpose: optimization, return true if this control has any user config settings
//-----------------------------------------------------------------------------
bool ListPanel::HasUserConfigSettings()
{
return true;
}
//-----------------------------------------------------------------------------
// Purpose: data accessor
//-----------------------------------------------------------------------------
void ListPanel::SetAllowUserModificationOfColumns(bool allowed)
{
m_bAllowUserAddDeleteColumns = allowed;
}
void ListPanel::SetIgnoreDoubleClick( bool state )
{
m_bIgnoreDoubleClick = state;
}
//-----------------------------------------------------------------------------
// Purpose: set up a field for editing
//-----------------------------------------------------------------------------
void ListPanel::EnterEditMode(int itemID, int column, vgui::Panel *editPanel)
{
m_hEditModePanel = editPanel;
m_iEditModeItemID = itemID;
m_iEditModeColumn = column;
editPanel->SetParent(this);
editPanel->SetVisible(true);
editPanel->RequestFocus();
editPanel->MoveToFront();
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose: leaves editing mode
//-----------------------------------------------------------------------------
void ListPanel::LeaveEditMode()
{
if (m_hEditModePanel.Get())
{
m_hEditModePanel->SetVisible(false);
m_hEditModePanel->SetParent((Panel *)NULL);
m_hEditModePanel = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose: returns true if we are currently in inline editing mode
//-----------------------------------------------------------------------------
bool ListPanel::IsInEditMode()
{
return (m_hEditModePanel.Get() != NULL);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
#ifdef _X360
void ListPanel::NavigateTo()
{
BaseClass::NavigateTo();
// attempt to select the first item in the list when we get focus
if(GetItemCount())
{
SetSingleSelectedItem(FirstItem());
}
else // if we have no items, change focus
{
if(!NavigateDown())
{
NavigateUp();
}
}
}
#endif