mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-23 06:36:54 +00:00
1083 lines
26 KiB
C++
1083 lines
26 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
|
|
#include <vgui/MouseCode.h>
|
|
#include <vgui/KeyCode.h>
|
|
#include <KeyValues.h>
|
|
#include <vgui/ISurface.h>
|
|
#include <vgui/IVGui.h>
|
|
#include <vgui/IInput.h>
|
|
#include <vgui/IPanel.h>
|
|
#include <vgui/ILocalize.h>
|
|
|
|
#include <vgui_controls/Controls.h>
|
|
#include <vgui_controls/ScrollBar.h>
|
|
#include <vgui_controls/ImageList.h>
|
|
#include <vgui_controls/ImagePanel.h>
|
|
#include <vgui_controls/Label.h>
|
|
#include <vgui_controls/TextImage.h>
|
|
#include <vgui_controls/ListViewPanel.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
|
|
};
|
|
|
|
namespace vgui
|
|
{
|
|
class ListViewItem : public Label
|
|
{
|
|
DECLARE_CLASS_SIMPLE( ListViewItem, Label );
|
|
|
|
public:
|
|
ListViewItem(Panel *parent) : Label(parent, NULL, "")
|
|
{
|
|
m_pListViewPanel = (ListViewPanel*) parent;
|
|
m_pData = NULL;
|
|
m_bSelected = false;
|
|
SetPaintBackgroundEnabled(true);
|
|
}
|
|
|
|
~ListViewItem()
|
|
{
|
|
if (m_pData)
|
|
{
|
|
m_pData->deleteThis();
|
|
m_pData = NULL;
|
|
}
|
|
}
|
|
|
|
void SetData(const KeyValues *data)
|
|
{
|
|
if (m_pData)
|
|
{
|
|
m_pData->deleteThis();
|
|
}
|
|
m_pData = data->MakeCopy();
|
|
}
|
|
|
|
virtual void OnMousePressed( MouseCode code)
|
|
{
|
|
m_pListViewPanel->OnItemMousePressed(this, code);
|
|
}
|
|
|
|
virtual void OnMouseDoublePressed( MouseCode code)
|
|
{
|
|
// double press should only select the item
|
|
m_pListViewPanel->OnItemMouseDoublePressed(this, code);
|
|
}
|
|
|
|
KeyValues *GetData()
|
|
{
|
|
return m_pData;
|
|
}
|
|
|
|
void SetSelected(bool bSelected)
|
|
{
|
|
if (bSelected == m_bSelected)
|
|
return;
|
|
|
|
m_bSelected = bSelected;
|
|
if (bSelected)
|
|
{
|
|
RequestFocus();
|
|
}
|
|
|
|
UpdateImage();
|
|
InvalidateLayout();
|
|
Repaint();
|
|
}
|
|
|
|
virtual void PerformLayout()
|
|
{
|
|
TextImage *textImage = GetTextImage();
|
|
if (m_bSelected)
|
|
{
|
|
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())))
|
|
{
|
|
textImage->SetColor(m_ArmedFgColor2);
|
|
}
|
|
else
|
|
{
|
|
textImage->SetColor(m_FgColor2);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
textImage->SetColor(GetFgColor());
|
|
}
|
|
BaseClass::PerformLayout();
|
|
Repaint();
|
|
}
|
|
|
|
virtual void PaintBackground()
|
|
{
|
|
int wide, tall;
|
|
GetSize(wide, tall);
|
|
|
|
if ( m_bSelected )
|
|
{
|
|
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())))
|
|
{
|
|
surface()->DrawSetColor(m_ArmedBgColor);
|
|
}
|
|
else
|
|
{
|
|
surface()->DrawSetColor(m_SelectionBG2Color);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
surface()->DrawSetColor(GetBgColor());
|
|
}
|
|
surface()->DrawFilledRect(0, 0, wide, tall);
|
|
}
|
|
|
|
virtual void ApplySchemeSettings(IScheme *pScheme)
|
|
{
|
|
BaseClass::ApplySchemeSettings(pScheme);
|
|
|
|
m_ArmedFgColor2 = GetSchemeColor("ListPanel.SelectedTextColor", pScheme);
|
|
m_ArmedBgColor = GetSchemeColor("ListPanel.SelectedBgColor", pScheme);
|
|
|
|
m_FgColor1 = GetSchemeColor("ListPanel.TextColor", pScheme);
|
|
m_FgColor2 = GetSchemeColor("ListPanel.SelectedTextColor", pScheme);
|
|
|
|
m_BgColor = GetSchemeColor("ListPanel.BgColor", GetBgColor(), pScheme);
|
|
m_BgColor = GetSchemeColor("ListPanel.TextBgColor", m_BgColor, pScheme);
|
|
m_SelectionBG2Color = GetSchemeColor("ListPanel.SelectedOutOfFocusBgColor", pScheme);
|
|
SetBgColor(m_BgColor);
|
|
SetFgColor(m_FgColor1);
|
|
|
|
UpdateImage();
|
|
}
|
|
|
|
void UpdateImage()
|
|
{
|
|
if ( m_pListViewPanel->m_pImageList )
|
|
{
|
|
int imageIndex = 0;
|
|
if ( m_bSelected )
|
|
{
|
|
imageIndex = m_pData->GetInt("imageSelected", 0);
|
|
}
|
|
if ( imageIndex == 0 )
|
|
{
|
|
imageIndex = m_pData->GetInt("image", 0);
|
|
}
|
|
if ( m_pListViewPanel->m_pImageList->IsValidIndex(imageIndex) )
|
|
{
|
|
SetImageAtIndex(0, m_pListViewPanel->m_pImageList->GetImage(imageIndex), 0);
|
|
}
|
|
else
|
|
{
|
|
// use the default
|
|
SetImageAtIndex(0, m_pListViewPanel->m_pImageList->GetImage(1), 0);
|
|
}
|
|
SizeToContents();
|
|
InvalidateLayout();
|
|
}
|
|
}
|
|
|
|
private:
|
|
|
|
Color m_FgColor1;
|
|
Color m_FgColor2;
|
|
Color m_BgColor;
|
|
Color m_ArmedFgColor2;
|
|
Color m_ArmedBgColor;
|
|
Color m_SelectionBG2Color;
|
|
|
|
//IBorder *_keyFocusBorder; // maybe in the future when I'm the 'active' but not selected item, I'll have a border
|
|
|
|
KeyValues *m_pData;
|
|
ListViewPanel *m_pListViewPanel;
|
|
bool m_bSelected;
|
|
};
|
|
}
|
|
|
|
static bool DefaultSortFunc(KeyValues *kv1, KeyValues *kv2)
|
|
{
|
|
const char *string1 = kv1->GetString("text");
|
|
const char *string2 = kv2->GetString("text");
|
|
return Q_stricmp(string1, string2) < 0;
|
|
}
|
|
|
|
DECLARE_BUILD_FACTORY( ListViewPanel );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor
|
|
//-----------------------------------------------------------------------------
|
|
ListViewPanel::ListViewPanel(Panel *parent, const char *panelName) : Panel(parent, panelName)
|
|
{
|
|
m_iRowHeight = 20;
|
|
m_bNeedsSort = false;
|
|
m_hFont = NULL;
|
|
m_pImageList = NULL;
|
|
m_bDeleteImageListWhenDone = false;
|
|
m_pSortFunc = DefaultSortFunc;
|
|
m_ShiftStartItemID = -1;
|
|
|
|
m_hbar = new ScrollBar(this, "HorizScrollBar", false);
|
|
m_hbar->AddActionSignalTarget(this);
|
|
m_hbar->SetVisible(false);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
ListViewPanel::~ListViewPanel()
|
|
{
|
|
DeleteAllItems();
|
|
|
|
delete m_hbar;
|
|
|
|
if ( m_bDeleteImageListWhenDone )
|
|
{
|
|
delete m_pImageList;
|
|
m_pImageList = NULL;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int ListViewPanel::AddItem(const KeyValues *data, bool bScrollToItem, bool bSortOnAdd)
|
|
{
|
|
ListViewItem *pNewItem = new ListViewItem(this);
|
|
pNewItem->SetData(data);
|
|
if (m_hFont)
|
|
{
|
|
pNewItem->SetFont(m_hFont);
|
|
}
|
|
int itemID = m_DataItems.AddToTail(pNewItem);
|
|
ApplyItemChanges(itemID);
|
|
m_SortedItems.AddToTail(itemID);
|
|
|
|
if ( bSortOnAdd )
|
|
{
|
|
m_bNeedsSort = true;
|
|
}
|
|
|
|
InvalidateLayout();
|
|
|
|
if ( bScrollToItem )
|
|
{
|
|
ScrollToItem(itemID);
|
|
}
|
|
|
|
return itemID;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::ScrollToItem(int itemID)
|
|
{
|
|
if (!m_hbar->IsVisible())
|
|
{
|
|
return;
|
|
}
|
|
int val = m_hbar->GetValue();
|
|
|
|
int wide, tall;
|
|
GetSize( wide, tall );
|
|
|
|
int maxWidth = GetItemsMaxWidth();
|
|
int maxColVisible = wide / maxWidth;
|
|
int itemsPerCol = GetItemsPerColumn();
|
|
|
|
int itemIndex = m_SortedItems.Find(itemID);
|
|
int desiredCol = itemIndex / itemsPerCol;
|
|
if (desiredCol < val || desiredCol >= (val + maxColVisible) )
|
|
{
|
|
m_hbar->SetValue(desiredCol);
|
|
}
|
|
|
|
InvalidateLayout();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int ListViewPanel::GetItemCount()
|
|
{
|
|
return m_DataItems.Count();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
KeyValues *ListViewPanel::GetItem(int itemID)
|
|
{
|
|
if ( !m_DataItems.IsValidIndex(itemID) )
|
|
return NULL;
|
|
|
|
return m_DataItems[itemID]->GetData();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get ItemID from position in panel - valid from [0, GetItemCount)
|
|
//-----------------------------------------------------------------------------
|
|
int ListViewPanel::GetItemIDFromPos(int iPos)
|
|
{
|
|
if ( m_SortedItems.IsValidIndex(iPos) )
|
|
{
|
|
return m_SortedItems[iPos];
|
|
}
|
|
else
|
|
{
|
|
return m_DataItems.InvalidIndex();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::ApplyItemChanges(int itemID)
|
|
{
|
|
if ( !m_DataItems.IsValidIndex(itemID) )
|
|
return;
|
|
|
|
KeyValues *kv = m_DataItems[itemID]->GetData();
|
|
ListViewItem *pLabel = m_DataItems[itemID];
|
|
|
|
pLabel->SetText(kv->GetString("text"));
|
|
pLabel->SetTextImageIndex(1);
|
|
pLabel->SetImagePreOffset(1, 5);
|
|
|
|
TextImage *pTextImage = pLabel->GetTextImage();
|
|
pTextImage->ResizeImageToContent();
|
|
|
|
pLabel->UpdateImage();
|
|
pLabel->SizeToContents();
|
|
pLabel->InvalidateLayout();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::RemoveItem(int itemID)
|
|
{
|
|
if ( !m_DataItems.IsValidIndex(itemID) )
|
|
return;
|
|
|
|
m_DataItems[itemID]->MarkForDeletion();
|
|
|
|
// mark the keyValues for deletion
|
|
m_DataItems.Remove(itemID);
|
|
m_SortedItems.FindAndRemove(itemID);
|
|
m_SelectedItems.FindAndRemove(itemID);
|
|
|
|
InvalidateLayout();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::DeleteAllItems()
|
|
{
|
|
FOR_EACH_LL( m_DataItems, index )
|
|
{
|
|
m_DataItems[index]->MarkForDeletion();
|
|
}
|
|
m_DataItems.RemoveAll();
|
|
m_SortedItems.RemoveAll();
|
|
m_SelectedItems.RemoveAll();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int ListViewPanel::InvalidItemID()
|
|
{
|
|
return m_DataItems.InvalidIndex();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool ListViewPanel::IsValidItemID(int itemID)
|
|
{
|
|
return m_DataItems.IsValidIndex(itemID);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::SetSortFunc(ListViewSortFunc_t func)
|
|
{
|
|
if ( func )
|
|
{
|
|
m_pSortFunc = func;
|
|
SortList();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::SortList()
|
|
{
|
|
m_SortedItems.RemoveAll();
|
|
|
|
// find all the items in this section
|
|
for( int i = m_DataItems.Head(); i != m_DataItems.InvalidIndex(); i = m_DataItems.Next( i ) )
|
|
{
|
|
// insert the items sorted
|
|
if (m_pSortFunc)
|
|
{
|
|
int insertionPoint;
|
|
for (insertionPoint = 0; insertionPoint < m_SortedItems.Count(); insertionPoint++)
|
|
{
|
|
if ( m_pSortFunc(m_DataItems[i]->GetData(), m_DataItems[m_SortedItems[insertionPoint]]->GetData() ) )
|
|
break;
|
|
}
|
|
|
|
if (insertionPoint == m_SortedItems.Count())
|
|
{
|
|
m_SortedItems.AddToTail(i);
|
|
}
|
|
else
|
|
{
|
|
m_SortedItems.InsertBefore(insertionPoint, i);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// just add to the end
|
|
m_SortedItems.AddToTail(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::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_pImageList = NULL;
|
|
}
|
|
|
|
m_bDeleteImageListWhenDone = deleteImageListWhenDone;
|
|
m_pImageList = imageList;
|
|
|
|
FOR_EACH_LL( m_DataItems, i )
|
|
{
|
|
m_DataItems[i]->UpdateImage();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::SetFont(HFont font)
|
|
{
|
|
Assert( font );
|
|
if ( !font )
|
|
return;
|
|
|
|
m_hFont = font;
|
|
m_iRowHeight = surface()->GetFontTall(font) + 1;
|
|
|
|
FOR_EACH_LL( m_DataItems, i )
|
|
{
|
|
m_DataItems[i]->SetFont(m_hFont);
|
|
TextImage *pTextImage = m_DataItems[i]->GetTextImage();
|
|
pTextImage->ResizeImageToContent();
|
|
m_DataItems[i]->SizeToContents();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int ListViewPanel::GetSelectedItemsCount()
|
|
{
|
|
return m_SelectedItems.Count();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int ListViewPanel::GetSelectedItem(int selectionIndex)
|
|
{
|
|
if ( m_SelectedItems.IsValidIndex(selectionIndex) )
|
|
return m_SelectedItems[selectionIndex];
|
|
|
|
return -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::ClearSelectedItems()
|
|
{
|
|
int i;
|
|
for (i = 0 ; i < m_SelectedItems.Count(); i++)
|
|
{
|
|
if ( m_DataItems.IsValidIndex(m_SelectedItems[i]) )
|
|
{
|
|
m_DataItems[m_SelectedItems[i]]->SetSelected(false);
|
|
}
|
|
}
|
|
m_SelectedItems.RemoveAll();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::AddSelectedItem(int itemID)
|
|
{
|
|
if ( m_SelectedItems.Find(itemID) == -1 )
|
|
{
|
|
m_SelectedItems.AddToTail(itemID);
|
|
m_DataItems[itemID]->SetSelected(true);
|
|
m_LastSelectedItemID = itemID;
|
|
m_ShiftStartItemID = itemID;
|
|
PostActionSignal(new KeyValues("ListViewItemSelected"));
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::SetSingleSelectedItem(int itemID)
|
|
{
|
|
ClearSelectedItems();
|
|
AddSelectedItem(itemID);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::OnMouseWheeled(int delta)
|
|
{
|
|
int val = m_hbar->GetValue();
|
|
val -= delta;
|
|
m_hbar->SetValue(val);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::OnSizeChanged(int wide, int tall)
|
|
{
|
|
BaseClass::OnSizeChanged(wide, tall);
|
|
InvalidateLayout();
|
|
Repaint();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int ListViewPanel::GetItemsMaxWidth()
|
|
{
|
|
int maxWidth = 0;
|
|
FOR_EACH_LL( m_DataItems, i )
|
|
{
|
|
int labelWide, labelTall;
|
|
m_DataItems[i]->GetSize(labelWide, labelTall);
|
|
if (labelWide > maxWidth)
|
|
{
|
|
maxWidth = labelWide + 25;
|
|
}
|
|
}
|
|
return maxWidth;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::PerformLayout()
|
|
{
|
|
if (m_bNeedsSort)
|
|
{
|
|
SortList();
|
|
}
|
|
|
|
if ( m_DataItems.Count() == 0 )
|
|
return;
|
|
|
|
int wide, tall;
|
|
GetSize(wide, tall);
|
|
|
|
int maxWidth = GetItemsMaxWidth();
|
|
if (maxWidth < 24)
|
|
{
|
|
maxWidth = 24;
|
|
}
|
|
int maxColVisible = wide / maxWidth;
|
|
|
|
m_hbar->SetVisible(false);
|
|
int itemsPerCol = GetItemsPerColumn();
|
|
if (itemsPerCol < 1)
|
|
{
|
|
itemsPerCol = 1;
|
|
}
|
|
int cols = ( GetItemCount() + (itemsPerCol - 1) ) / itemsPerCol;
|
|
|
|
int startItem = 0;
|
|
if ( cols > maxColVisible)
|
|
{
|
|
m_hbar->SetVisible(true);
|
|
|
|
// recalulate # per column now that we've made the hbar visible
|
|
itemsPerCol = GetItemsPerColumn();
|
|
cols = ( GetItemCount() + (itemsPerCol - 1) ) / (itemsPerCol > 0 ? itemsPerCol : 1 );
|
|
|
|
m_hbar->SetEnabled(false);
|
|
m_hbar->SetRangeWindow( maxColVisible );
|
|
m_hbar->SetRange( 0, cols);
|
|
m_hbar->SetButtonPressedScrollValue( 1 );
|
|
|
|
m_hbar->SetPos(0, tall - (m_hbar->GetTall()+WINDOW_BORDER_WIDTH));
|
|
m_hbar->SetSize(wide - (WINDOW_BORDER_WIDTH*2), m_hbar->GetTall());
|
|
m_hbar->InvalidateLayout();
|
|
|
|
int val = m_hbar->GetValue();
|
|
startItem += val*itemsPerCol;
|
|
}
|
|
else
|
|
{
|
|
m_hbar->SetVisible(false);
|
|
}
|
|
int lastItemVisible = startItem + (( maxColVisible + 1 )* itemsPerCol) - 1;
|
|
|
|
int itemsThisCol = 0;
|
|
int x = 0;
|
|
int y = 0;
|
|
int i;
|
|
for ( i = 0 ; i < m_SortedItems.Count() ; i++ )
|
|
{
|
|
if ( i >= startItem && i <= lastItemVisible )
|
|
{
|
|
m_DataItems[ m_SortedItems[i] ]->SetVisible(true);
|
|
m_DataItems[ m_SortedItems[i] ]->SetPos(x, y);
|
|
itemsThisCol++;
|
|
if ( itemsThisCol == itemsPerCol )
|
|
{
|
|
y = 0;
|
|
x += maxWidth;
|
|
itemsThisCol = 0;
|
|
}
|
|
else
|
|
{
|
|
y += m_iRowHeight;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_DataItems[ m_SortedItems[i] ]->SetVisible(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::Paint()
|
|
{
|
|
BaseClass::Paint();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::ApplySchemeSettings(IScheme *pScheme)
|
|
{
|
|
BaseClass::ApplySchemeSettings(pScheme);
|
|
|
|
SetBgColor(GetSchemeColor("ListPanel.BgColor", pScheme));
|
|
SetBorder(pScheme->GetBorder("ButtonDepressedBorder"));
|
|
|
|
m_LabelFgColor = GetSchemeColor("ListPanel.TextColor", pScheme);
|
|
m_SelectionFgColor = GetSchemeColor("ListPanel.SelectedTextColor", m_LabelFgColor, pScheme);
|
|
|
|
m_hFont = pScheme->GetFont("Default", IsProportional());
|
|
SetFont(m_hFont);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::OnMousePressed( MouseCode code)
|
|
{
|
|
if (code == MOUSE_LEFT || code == MOUSE_RIGHT)
|
|
{
|
|
ClearSelectedItems();
|
|
RequestFocus();
|
|
}
|
|
// check for context menu open
|
|
if (code == MOUSE_RIGHT)
|
|
{
|
|
// post it, but with the invalid row
|
|
PostActionSignal(new KeyValues("OpenContextMenu", "itemID", -1));
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::OnShiftSelect(int itemID)
|
|
{
|
|
// if we dont' have a valid selected ItemID - then we just choose the first item
|
|
if ( !m_DataItems.IsValidIndex(m_ShiftStartItemID) )
|
|
{
|
|
m_ShiftStartItemID = m_DataItems.Head();
|
|
}
|
|
|
|
// find out if the just pressed item is "earlier" or is the 'last selected item'
|
|
int lowerPos = -1, upperPos = -1;
|
|
int i;
|
|
for ( i = 0 ; i < m_SortedItems.Count() ; i++ )
|
|
{
|
|
if ( m_SortedItems[i] == itemID )
|
|
{
|
|
lowerPos = i;
|
|
upperPos = m_SortedItems.Find(m_ShiftStartItemID);
|
|
break;
|
|
}
|
|
else if ( m_SortedItems[i] == m_ShiftStartItemID )
|
|
{
|
|
lowerPos = m_SortedItems.Find(m_ShiftStartItemID);
|
|
upperPos = i;
|
|
break;
|
|
}
|
|
}
|
|
assert(lowerPos <= upperPos);
|
|
if ( !input()->IsKeyDown(KEY_LCONTROL) && !input()->IsKeyDown(KEY_RCONTROL) )
|
|
{
|
|
ClearSelectedItems();
|
|
}
|
|
|
|
for ( i = lowerPos ; i <= upperPos ; i ++)
|
|
{
|
|
// do not use AddSelectedItem because we don't want to switch the shiftStartItemID
|
|
m_DataItems[ m_SortedItems[i] ]->SetSelected(true);
|
|
m_SelectedItems.AddToTail(m_SortedItems[i]);
|
|
m_LastSelectedItemID = itemID;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::OnItemMousePressed(ListViewItem* pItem, MouseCode code)
|
|
{
|
|
int itemID = m_DataItems.Find(pItem);
|
|
if (!m_DataItems.IsValidIndex(itemID))
|
|
return;
|
|
|
|
// check for context menu open
|
|
if (code == MOUSE_RIGHT)
|
|
{
|
|
// if this is a new item - unselect everything else
|
|
if ( m_SelectedItems.Find(itemID) == -1)
|
|
{
|
|
ClearSelectedItems();
|
|
AddSelectedItem(itemID);
|
|
}
|
|
|
|
PostActionSignal(new KeyValues("OpenContextMenu", "itemID", itemID));
|
|
}
|
|
else
|
|
{
|
|
if ( input()->IsKeyDown(KEY_LSHIFT) || input()->IsKeyDown(KEY_RSHIFT) )
|
|
{
|
|
OnShiftSelect(itemID);
|
|
}
|
|
else if ( input()->IsKeyDown(KEY_LCONTROL) || input()->IsKeyDown(KEY_RCONTROL) )
|
|
{
|
|
if ( m_SelectedItems.Find(itemID) != -1)
|
|
{
|
|
m_SelectedItems.FindAndRemove(itemID);
|
|
pItem->SetSelected(false);
|
|
|
|
// manually select these since we 'last' clicked on these items
|
|
m_ShiftStartItemID = itemID;
|
|
m_LastSelectedItemID = itemID;
|
|
m_DataItems[itemID]->RequestFocus();
|
|
}
|
|
else
|
|
{
|
|
AddSelectedItem(itemID);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ClearSelectedItems();
|
|
AddSelectedItem(itemID);
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::OnMouseDoublePressed( MouseCode code)
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::OnItemMouseDoublePressed(ListViewItem* pItem, MouseCode code)
|
|
{
|
|
if (code == MOUSE_LEFT)
|
|
{
|
|
OnKeyCodeTyped(KEY_ENTER);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::FinishKeyPress(int itemID)
|
|
{
|
|
if ( input()->IsKeyDown(KEY_LSHIFT) || input()->IsKeyDown(KEY_RSHIFT) )
|
|
{
|
|
OnShiftSelect(itemID);
|
|
}
|
|
else if ( input()->IsKeyDown(KEY_LCONTROL) || input()->IsKeyDown(KEY_RCONTROL) )
|
|
{
|
|
m_DataItems[itemID]->RequestFocus();
|
|
m_LastSelectedItemID = itemID;
|
|
}
|
|
else
|
|
{
|
|
SetSingleSelectedItem(itemID);
|
|
}
|
|
ScrollToItem(itemID);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::OnKeyCodeTyped( KeyCode code )
|
|
{
|
|
if ( m_DataItems.Count() == 0 )
|
|
return;
|
|
|
|
switch (code)
|
|
{
|
|
case KEY_HOME:
|
|
{
|
|
if (m_SortedItems.Count() > 0)
|
|
{
|
|
int itemID = m_SortedItems[0];
|
|
FinishKeyPress(itemID);
|
|
}
|
|
break;
|
|
}
|
|
case KEY_END:
|
|
{
|
|
if (m_DataItems.Count() > 0)
|
|
{
|
|
int itemID = m_SortedItems[ m_SortedItems.Count() - 1 ];
|
|
FinishKeyPress(itemID);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case KEY_UP:
|
|
{
|
|
int itemPos = m_SortedItems.Find( m_LastSelectedItemID );
|
|
itemPos--;
|
|
if (itemPos < 0)
|
|
itemPos = 0;
|
|
|
|
FinishKeyPress(m_SortedItems[itemPos]);
|
|
break;
|
|
}
|
|
|
|
case KEY_DOWN:
|
|
{
|
|
int itemPos = m_SortedItems.Find( m_LastSelectedItemID );
|
|
itemPos++;
|
|
if (itemPos >= m_DataItems.Count())
|
|
itemPos = m_DataItems.Count() - 1;
|
|
|
|
FinishKeyPress(m_SortedItems[itemPos]);
|
|
break;
|
|
}
|
|
|
|
case KEY_LEFT:
|
|
{
|
|
int itemPos = m_SortedItems.Find( m_LastSelectedItemID );
|
|
itemPos -= GetItemsPerColumn();
|
|
if (itemPos < 0)
|
|
{
|
|
itemPos = 0;
|
|
}
|
|
FinishKeyPress(m_SortedItems[itemPos]);
|
|
break;
|
|
}
|
|
|
|
case KEY_RIGHT:
|
|
{
|
|
int itemPos = m_SortedItems.Find( m_LastSelectedItemID );
|
|
itemPos += GetItemsPerColumn();
|
|
if (itemPos >= m_SortedItems.Count())
|
|
{
|
|
itemPos = m_SortedItems.Count() - 1;
|
|
}
|
|
FinishKeyPress(m_SortedItems[itemPos]);
|
|
break;
|
|
}
|
|
|
|
case KEY_PAGEUP:
|
|
{
|
|
int wide, tall;
|
|
GetSize(wide, tall);
|
|
|
|
int maxWidth = GetItemsMaxWidth();
|
|
if (maxWidth == 0)
|
|
{
|
|
maxWidth = wide;
|
|
}
|
|
int maxColVisible = wide / maxWidth;
|
|
int delta = maxColVisible * GetItemsPerColumn();
|
|
|
|
int itemPos = m_SortedItems.Find( m_LastSelectedItemID );
|
|
itemPos -= delta;
|
|
if (itemPos < 0)
|
|
{
|
|
itemPos = 0;
|
|
}
|
|
|
|
FinishKeyPress(m_SortedItems[itemPos]);
|
|
break;
|
|
}
|
|
case KEY_PAGEDOWN:
|
|
{
|
|
int wide, tall;
|
|
GetSize(wide, tall);
|
|
|
|
int maxWidth = GetItemsMaxWidth();
|
|
if (maxWidth == 0)
|
|
{
|
|
maxWidth = wide;
|
|
}
|
|
int maxColVisible = wide / maxWidth;
|
|
int delta = maxColVisible * GetItemsPerColumn();
|
|
|
|
int itemPos = m_SortedItems.Find( m_LastSelectedItemID );
|
|
itemPos += delta;
|
|
if (itemPos >= m_SortedItems.Count())
|
|
{
|
|
itemPos = m_SortedItems.Count() - 1;
|
|
}
|
|
|
|
FinishKeyPress(m_SortedItems[itemPos]);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
BaseClass::OnKeyCodeTyped(code);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::OnKeyTyped(wchar_t unichar)
|
|
{
|
|
if (!iswcntrl(unichar))
|
|
{
|
|
wchar_t uniString[2];
|
|
uniString[0] = unichar;
|
|
uniString[1] = 0;
|
|
|
|
char buf[2];
|
|
g_pVGuiLocalize->ConvertUnicodeToANSI(uniString, buf, sizeof(buf));
|
|
|
|
int i;
|
|
int itemPos = m_SortedItems.Find(m_LastSelectedItemID);
|
|
if ( m_SortedItems.IsValidIndex(itemPos))
|
|
{
|
|
itemPos++;
|
|
// start from the item AFTER our last selected Item and go to end
|
|
for ( i = itemPos ; i != m_SortedItems.Count(); i++)
|
|
{
|
|
KeyValues *kv = m_DataItems[ m_SortedItems[i] ]->GetData();
|
|
const char *pszText = kv->GetString("text");
|
|
if (!strnicmp(pszText, buf, 1))
|
|
{
|
|
// select the next of this letter
|
|
SetSingleSelectedItem(m_SortedItems[i]);
|
|
ScrollToItem(m_SortedItems[i]);
|
|
return;
|
|
}
|
|
}
|
|
// if the after this item we couldn't fine an item with the same letter, fall through and just start from the beginning of list to the last selected item
|
|
}
|
|
|
|
for ( i = 0 ; i < m_SortedItems.Count() ; i++ )
|
|
{
|
|
// we've gone all the way around - break - if we had a valid index, this is one more that last selectedItem, if not it's an illegal index
|
|
if ( i == itemPos)
|
|
break;
|
|
|
|
KeyValues *kv = m_DataItems[ m_SortedItems[i] ]->GetData();
|
|
const char *pszText = kv->GetString("text");
|
|
if (!strnicmp(pszText, buf, 1))
|
|
{
|
|
SetSingleSelectedItem(m_SortedItems[i]);
|
|
ScrollToItem(m_SortedItems[i]);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
BaseClass::OnKeyTyped(unichar);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ListViewPanel::OnSliderMoved()
|
|
{
|
|
InvalidateLayout();
|
|
Repaint();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int ListViewPanel::GetItemsPerColumn()
|
|
{
|
|
int wide, tall;
|
|
GetSize(wide, tall);
|
|
|
|
if ( m_hbar->IsVisible() )
|
|
{
|
|
tall -= m_hbar->GetTall();
|
|
}
|
|
|
|
return tall / m_iRowHeight; // should round down
|
|
}
|
|
|