4497 lines
124 KiB
C++
4497 lines
124 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "dme_controls/elementpropertiestree.h"
|
|
#include "tier1/KeyValues.h"
|
|
#include "datamodel/dmelement.h"
|
|
|
|
#include "vgui/IInput.h"
|
|
#include "vgui/ISurface.h"
|
|
#include "vgui/ISystem.h"
|
|
#include "vgui/IVgui.h"
|
|
#include "vgui/Cursor.h"
|
|
#include "vgui_controls/TextEntry.h"
|
|
#include "vgui_controls/ComboBox.h"
|
|
#include "vgui_controls/Button.h"
|
|
#include "vgui_controls/FileOpenDialog.h"
|
|
#include "vgui_controls/Menu.h"
|
|
#include "vgui_controls/MenuItem.h"
|
|
#include "vgui_controls/MenuButton.h"
|
|
#include "vgui_controls/PanelListPanel.h"
|
|
#include "vgui_controls/ScrollBar.h"
|
|
#include "movieobjects/dmeeditortypedictionary.h"
|
|
#include "dme_controls/AttributeTextPanel.h"
|
|
#include "dme_controls/DmePanel.h"
|
|
#include "dme_controls/dmecontrols_utils.h"
|
|
#include "tier1/ConVar.h"
|
|
#include "tier2/fileutils.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
class CElementTreeViewListControl;
|
|
|
|
using namespace vgui;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// CElementTree
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class CElementTree : public TreeView
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CElementTree, TreeView );
|
|
public:
|
|
CElementTree( CElementPropertiesTreeInternal *parent, const char *panelName );
|
|
~CElementTree();
|
|
|
|
virtual void OnCommand( const char *cmd );
|
|
virtual void ApplySchemeSettings( IScheme *pScheme );
|
|
virtual void InvalidateLayout( bool layoutNow = false, bool reloadScheme = false );
|
|
virtual void GenerateChildrenOfNode(int itemIndex);
|
|
// override to open a custom context menu on a node being selected and right-clicked
|
|
virtual void GenerateContextMenu( int itemIndex, int x, int y );
|
|
|
|
virtual void GenerateDragDataForItem( int itemIndex, KeyValues *msg );
|
|
|
|
virtual void OnLabelChanged( int itemIndex, const char *oldString, const char *newString );
|
|
|
|
virtual bool IsItemDroppable( int m_ItemIndex, CUtlVector< KeyValues * >& msglist );
|
|
virtual void OnItemDropped( int m_ItemIndex, CUtlVector< KeyValues * >& msglist );
|
|
virtual bool GetItemDropContextMenu( int itemIndex, Menu *menu, CUtlVector< KeyValues * >& msglist );
|
|
virtual HCursor GetItemDropCursor( int itemIndex, CUtlVector< KeyValues * >& msglist );
|
|
|
|
ScrollBar *GetScrollBar();
|
|
|
|
private:
|
|
Menu *m_pEditMenu;
|
|
CElementPropertiesTreeInternal *m_pParent;
|
|
ScrollBar *m_pVertSB;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructor
|
|
//-----------------------------------------------------------------------------
|
|
CElementTree::CElementTree( CElementPropertiesTreeInternal *parent, const char *panelName ) :
|
|
BaseClass( (Panel *)parent, panelName ),
|
|
m_pEditMenu( 0 ),
|
|
m_pParent( parent )
|
|
{
|
|
SetAllowLabelEditing( true );
|
|
SetAllowMultipleSelections( true );
|
|
|
|
m_pVertSB = SetScrollBarExternal( true, this );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Destructor
|
|
//-----------------------------------------------------------------------------
|
|
CElementTree::~CElementTree()
|
|
{
|
|
delete m_pEditMenu;
|
|
}
|
|
|
|
ScrollBar *CElementTree::GetScrollBar()
|
|
{
|
|
return m_pVertSB;
|
|
}
|
|
|
|
bool CElementTree::IsItemDroppable( int itemIndex, CUtlVector< KeyValues * >& msglist )
|
|
{
|
|
return m_pParent->IsItemDroppable( itemIndex, msglist );
|
|
}
|
|
|
|
bool CElementTree::GetItemDropContextMenu( int itemIndex, Menu *menu, CUtlVector< KeyValues * >& msglist )
|
|
{
|
|
return m_pParent->GetItemDropContextMenu( itemIndex, menu, msglist );
|
|
}
|
|
|
|
void CElementTree::OnItemDropped( int itemIndex, CUtlVector< KeyValues * >& msglist )
|
|
{
|
|
m_pParent->OnItemDropped( itemIndex, msglist );
|
|
}
|
|
|
|
HCursor CElementTree::GetItemDropCursor( int itemIndex, CUtlVector< KeyValues * >& msglist )
|
|
{
|
|
return m_pParent->GetItemDropCursor( itemIndex, msglist );
|
|
}
|
|
|
|
void CElementTree::OnLabelChanged( int itemIndex, const char *oldString, const char *newString )
|
|
{
|
|
m_pParent->OnLabelChanged( itemIndex, oldString, newString );
|
|
}
|
|
|
|
void CElementTree::GenerateDragDataForItem( int itemIndex, KeyValues *msg )
|
|
{
|
|
m_pParent->GenerateDragDataForItem( itemIndex, msg );
|
|
}
|
|
|
|
// override to open a custom context menu on a node being selected and right-clicked
|
|
void CElementTree::GenerateContextMenu( int itemIndex, int x, int y )
|
|
{
|
|
m_pParent->GenerateContextMenu( itemIndex, x, y );
|
|
}
|
|
|
|
|
|
void CElementTree::ApplySchemeSettings( IScheme *pScheme )
|
|
{
|
|
// Intentionally skip to Panel:: instead of BaseClass::!!!
|
|
Panel::ApplySchemeSettings( pScheme );
|
|
|
|
SetFont( pScheme->GetFont( "DmePropertyVerySmall", IsProportional() ) );
|
|
}
|
|
|
|
void CElementTree::InvalidateLayout( bool layoutNow, bool reloadScheme )
|
|
{
|
|
BaseClass::InvalidateLayout( layoutNow, reloadScheme );
|
|
if ( GetParent() && !reloadScheme )
|
|
{
|
|
GetParent()->InvalidateLayout( layoutNow, false );
|
|
}
|
|
}
|
|
|
|
void CElementTree::OnCommand( const char *cmd )
|
|
{
|
|
// Relay to parent
|
|
GetParent()->OnCommand( cmd );
|
|
}
|
|
|
|
void CElementTree::GenerateChildrenOfNode(int itemIndex)
|
|
{
|
|
m_pParent->GenerateChildrenOfNode( itemIndex );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Class: CElementTreeViewListControl
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CElementTreeViewListControl::CElementTreeViewListControl( Panel *pParent, const char *pName )
|
|
: BaseClass( pParent, pName ), m_Panels( 0, 0, PanelsLessFunc )
|
|
{
|
|
|
|
m_iTreeColumnWidth = 200;
|
|
m_iFontSize = 1;
|
|
m_bMouseLeftIsDown = false;
|
|
m_bMouseIsDragging = false;
|
|
m_bDrawGrid = false;
|
|
|
|
// why do this here?
|
|
SetScheme( vgui::scheme()->LoadSchemeFromFile( "Resource/BoxRocket.res", "BoxRocket" ) );
|
|
|
|
// the column lable font
|
|
vgui::IScheme *scheme = vgui::scheme()->GetIScheme( GetScheme() );
|
|
HFont font = scheme->GetFont( "DefaultVerySmall", IsProportional() );
|
|
|
|
SetTitleBarInfo( font, 18 );
|
|
|
|
SetPostChildPaintEnabled( true );
|
|
SetBorderColor( Color( 255, 255, 196, 64 ) );
|
|
|
|
SetKeyBoardInputEnabled( true );
|
|
}
|
|
|
|
|
|
int CElementTreeViewListControl::AddItem( KeyValues *data, bool allowLabelEditing, int parentItemIndex, CUtlVector< vgui::Panel * >& columnPanels )
|
|
{
|
|
int itemIndex = GetTree()->AddItem( data, parentItemIndex );
|
|
if ( allowLabelEditing )
|
|
{
|
|
GetTree()->SetLabelEditingAllowed( itemIndex, allowLabelEditing );
|
|
}
|
|
|
|
GetTree()->SetItemFgColor( itemIndex, GetFgColor() );
|
|
GetTree()->SetItemBgColor( itemIndex, GetBgColor() );
|
|
|
|
ColumnPanels_t search;
|
|
search.treeViewItem = itemIndex;
|
|
|
|
int idx = m_Panels.Find( search );
|
|
if ( idx == m_Panels.InvalidIndex() )
|
|
{
|
|
ColumnPanels_t newInfo;
|
|
newInfo.treeViewItem = itemIndex;
|
|
idx = m_Panels.Insert( newInfo );
|
|
}
|
|
|
|
ColumnPanels_t& info = m_Panels[ idx ];
|
|
|
|
info.SetList( columnPanels );
|
|
|
|
int c = columnPanels.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
if ( columnPanels[ i ] )
|
|
{
|
|
columnPanels[ i ]->SetParent( this );
|
|
}
|
|
}
|
|
|
|
// GetTree()->InvalidateLayout( false, true );
|
|
|
|
return itemIndex;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Removes an item recursively
|
|
//-----------------------------------------------------------------------------
|
|
void CElementTreeViewListControl::RemoveItem_R( int nItemIndex )
|
|
{
|
|
ColumnPanels_t search;
|
|
search.treeViewItem = nItemIndex;
|
|
int idx = m_Panels.Find( search );
|
|
if ( idx != m_Panels.InvalidIndex() )
|
|
{
|
|
ColumnPanels_t& info = m_Panels[ idx ];
|
|
int nCount = info.m_Columns.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
if ( info.m_Columns[i] )
|
|
{
|
|
info.m_Columns[i]->SetParent( (Panel*)NULL );
|
|
info.m_Columns[i]->MarkForDeletion();
|
|
}
|
|
}
|
|
m_Panels.RemoveAt( idx );
|
|
}
|
|
|
|
int nCount = GetTree()->GetNumChildren( nItemIndex );
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
RemoveItem_R( GetTree()->GetChild( nItemIndex, i ) );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Removes an item
|
|
//-----------------------------------------------------------------------------
|
|
void CElementTreeViewListControl::RemoveItem( int nItemIndex )
|
|
{
|
|
RemoveItem_R( nItemIndex );
|
|
GetTree()->RemoveItem( nItemIndex, false, true );
|
|
RecalculateRows();
|
|
InvalidateLayout();
|
|
}
|
|
|
|
|
|
int CElementTreeViewListControl::GetTreeColumnWidth()
|
|
{
|
|
return m_iTreeColumnWidth;
|
|
}
|
|
|
|
void CElementTreeViewListControl::SetTreeColumnWidth(int w)
|
|
{
|
|
m_iTreeColumnWidth = w;
|
|
SetColumnInfo( 0, "Tree", m_iTreeColumnWidth );
|
|
}
|
|
|
|
void CElementTreeViewListControl::ApplySchemeSettings( IScheme *pScheme )
|
|
{
|
|
BaseClass::ApplySchemeSettings( pScheme );
|
|
GetTree()->SetFont( pScheme->GetFont( "DmePropertyVerySmall", IsProportional() ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handle mouse drag resize of tree column (hack)
|
|
//-----------------------------------------------------------------------------
|
|
void CElementTreeViewListControl::OnCursorMoved(int x, int y)
|
|
{
|
|
|
|
if ( ( x > m_iTreeColumnWidth - 12 ) &&
|
|
( x < m_iTreeColumnWidth + 12 ) )
|
|
{
|
|
SetCursor( dc_sizewe );
|
|
if ( m_bMouseLeftIsDown )
|
|
{
|
|
m_bMouseIsDragging = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetCursor( dc_arrow );
|
|
}
|
|
|
|
if ( m_bMouseIsDragging )
|
|
{
|
|
SetCursor( dc_sizewe );
|
|
SetTreeColumnWidth( x );
|
|
InvalidateLayout( true );
|
|
}
|
|
|
|
}
|
|
|
|
void CElementTreeViewListControl::OnMousePressed( MouseCode code )
|
|
{
|
|
BaseClass::OnMousePressed( code );
|
|
if ( code == MOUSE_LEFT )
|
|
{
|
|
m_bMouseLeftIsDown = true;
|
|
}
|
|
input()->SetMouseCapture(GetVPanel());
|
|
RequestFocus();
|
|
}
|
|
|
|
void CElementTreeViewListControl::OnMouseReleased( MouseCode code )
|
|
{
|
|
BaseClass::OnMouseReleased( code );
|
|
if ( code == MOUSE_LEFT )
|
|
{
|
|
m_bMouseLeftIsDown = false;
|
|
m_bMouseIsDragging = false;
|
|
}
|
|
input()->SetMouseCapture(NULL);
|
|
}
|
|
|
|
void CElementTreeViewListControl::OnMouseDoublePressed( MouseCode code )
|
|
{
|
|
int x, y;
|
|
input()->GetCursorPos(x, y);
|
|
ScreenToLocal(x, y);
|
|
|
|
// resize the column to the max width of the tree
|
|
if ( ( x > m_iTreeColumnWidth - 12 ) &&
|
|
( x < m_iTreeColumnWidth + 12 ) )
|
|
{
|
|
ResizeTreeToExpandedWidth();
|
|
}
|
|
|
|
BaseClass::OnMouseDoublePressed( code );
|
|
|
|
}
|
|
|
|
void CElementTreeViewListControl::ResizeTreeToExpandedWidth()
|
|
{
|
|
int rows = GetNumRows();
|
|
int vbarTop, nItemsVisible;
|
|
bool hbarVisible = false;
|
|
GetTree()->GetVBarInfo( vbarTop, nItemsVisible, hbarVisible );
|
|
int vBarWidth = 0;
|
|
if ( nItemsVisible <= rows )
|
|
{
|
|
vBarWidth = 27;
|
|
}
|
|
SetTreeColumnWidth( GetTree()->GetVisibleMaxWidth() + vBarWidth + 14 );
|
|
}
|
|
|
|
void CElementTreeViewListControl::OnMouseWheeled(int delta)
|
|
{
|
|
|
|
bool ctrl = (input()->IsKeyDown(KEY_LCONTROL) || input()->IsKeyDown(KEY_RCONTROL));
|
|
bool alt = (input()->IsKeyDown(KEY_LALT) || input()->IsKeyDown(KEY_RALT));
|
|
|
|
if ( ctrl )
|
|
{
|
|
SetFontSize( GetFontSize() + delta );
|
|
}
|
|
else if ( alt )
|
|
{
|
|
ToggleDrawGrid();
|
|
}
|
|
else
|
|
{
|
|
// scroll the treeview control
|
|
ScrollBar *sb = ((CElementTree *)GetTree())->GetScrollBar();
|
|
sb->SetValue( sb->GetValue() + ( delta * -3 ) );
|
|
}
|
|
}
|
|
|
|
void CElementTreeViewListControl::ToggleDrawGrid()
|
|
{
|
|
m_bDrawGrid = !m_bDrawGrid;
|
|
}
|
|
|
|
bool CElementTreeViewListControl::IsDrawingGrid()
|
|
{
|
|
return m_bDrawGrid;
|
|
}
|
|
|
|
void CElementTreeViewListControl::PostChildPaint()
|
|
{
|
|
// why isn't SetBorderColor doing the job???
|
|
vgui::surface()->DrawSetColor( Color( 255, 255, 196, 32 ) );
|
|
|
|
int left, top, right, bottom;
|
|
int wide, tall;
|
|
GetSize( wide, tall );
|
|
GetGridElementBounds( 0, 0, left, top, right, bottom );
|
|
vgui::surface()->DrawFilledRect( right, 1, right+3, tall );
|
|
|
|
if ( m_bDrawGrid )
|
|
{
|
|
int numColumns = GetNumColumns();
|
|
int rows = GetNumRows();
|
|
|
|
int vbarTop, nItemsVisible;
|
|
bool hbarVisible = false;
|
|
GetTree()->GetVBarInfo( vbarTop, nItemsVisible, hbarVisible );
|
|
|
|
int vBarWidth = 0;
|
|
if ( nItemsVisible <= rows )
|
|
{
|
|
vBarWidth = 21;
|
|
}
|
|
|
|
if ( hbarVisible )
|
|
{
|
|
--nItemsVisible;
|
|
}
|
|
|
|
for ( int col = 0; col < numColumns; ++col )
|
|
{
|
|
for ( int row = 0; row < rows; ++row )
|
|
{
|
|
GetGridElementBounds( col, row, left, top, right, bottom );
|
|
if (col == 0)
|
|
{
|
|
vgui::surface()->DrawLine( left+4, bottom, right, bottom );
|
|
}
|
|
else
|
|
{
|
|
vgui::surface()->DrawLine( left-3, bottom, right-2, bottom );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int CElementTreeViewListControl::GetScrollBarSize()
|
|
{
|
|
ScrollBar *sb = ((CElementTree *)GetTree())->GetScrollBar();
|
|
if ( sb )
|
|
{
|
|
return sb->GetWide();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void CElementTreeViewListControl::PerformLayout()
|
|
{
|
|
BaseClass::PerformLayout();
|
|
|
|
// Assume all invisible at first
|
|
HideAll();
|
|
|
|
GetTree()->PerformLayout();
|
|
|
|
ScrollBar *sb = ((CElementTree *)GetTree())->GetScrollBar();
|
|
if ( sb && sb->GetParent() )
|
|
{
|
|
sb->SetBounds( sb->GetParent()->GetWide() - sb->GetWide(), 0, sb->GetWide(), sb->GetParent()->GetTall() );
|
|
}
|
|
|
|
int rowheight = GetTree()->GetRowHeight();
|
|
int treetop, visitems;
|
|
bool hbarVisible = false;
|
|
GetTree()->GetVBarInfo( treetop, visitems, hbarVisible );
|
|
if ( hbarVisible )
|
|
{
|
|
--visitems;
|
|
}
|
|
|
|
int offset = -treetop * rowheight;
|
|
|
|
int headerHeight = GetTitleBarHeight();
|
|
|
|
int numColumns = GetNumColumns();
|
|
// Now position column panels into the correct spot
|
|
int rows = GetNumRows();
|
|
int visItemCount = 0;
|
|
|
|
for ( int row = 0; row < rows; ++row )
|
|
{
|
|
int tvi = GetTreeItemAtRow( row );
|
|
|
|
for ( int col = 0; col < numColumns; ++col )
|
|
{
|
|
int left, top, right, bottom;
|
|
GetGridElementBounds( col, row, left, top, right, bottom );
|
|
|
|
ColumnPanels_t search;
|
|
search.treeViewItem = tvi;
|
|
|
|
int idx = m_Panels.Find( search );
|
|
if ( idx != m_Panels.InvalidIndex() )
|
|
{
|
|
ColumnPanels_t& info = m_Panels[ idx ];
|
|
|
|
if ( col >= info.m_Columns.Count() )
|
|
continue;
|
|
|
|
vgui::Panel *p = info.m_Columns[ col ];
|
|
if ( !p )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
bool vis = top + offset >= headerHeight;
|
|
if ( vis )
|
|
{
|
|
++visItemCount;
|
|
|
|
if ( visItemCount > visitems )
|
|
{
|
|
vis = false;
|
|
}
|
|
}
|
|
|
|
p->SetVisible( vis );
|
|
p->SetBounds( left + 4, top + offset, right - left, bottom - top );
|
|
|
|
p->InvalidateLayout();
|
|
}
|
|
else
|
|
{
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CElementTreeViewListControl::HideAll()
|
|
{
|
|
for ( int i = m_Panels.FirstInorder(); i != m_Panels.InvalidIndex(); i = m_Panels.NextInorder( i ) )
|
|
{
|
|
ColumnPanels_t& info = m_Panels[ i ];
|
|
int c = info.m_Columns.Count();
|
|
for ( int j = 0 ; j < c; ++j )
|
|
{
|
|
Panel *panel = info.m_Columns[ j ];
|
|
if ( !panel )
|
|
{
|
|
continue;
|
|
}
|
|
panel->SetVisible( false );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CElementTreeViewListControl::RemoveAll()
|
|
{
|
|
GetTree()->RemoveAll();
|
|
|
|
for ( int i = m_Panels.FirstInorder(); i != m_Panels.InvalidIndex(); i = m_Panels.NextInorder( i ) )
|
|
{
|
|
ColumnPanels_t& info = m_Panels[ i ];
|
|
int c = info.m_Columns.Count();
|
|
for ( int j = 0 ; j < c; ++j )
|
|
{
|
|
delete info.m_Columns[ j ];
|
|
}
|
|
info.m_Columns.RemoveAll();
|
|
}
|
|
m_Panels.RemoveAll();
|
|
InvalidateLayout();
|
|
}
|
|
|
|
HFont CElementTreeViewListControl::GetFont( int size )
|
|
{
|
|
vgui::IScheme *scheme = vgui::scheme()->GetIScheme( GetScheme() );
|
|
|
|
switch(size)
|
|
{
|
|
case 1:
|
|
return scheme->GetFont( "DmePropertyVerySmall", IsProportional() );
|
|
case 2:
|
|
return scheme->GetFont( "DmePropertySmall", IsProportional() );
|
|
case 3:
|
|
return scheme->GetFont( "DmeProperty", IsProportional() );
|
|
case 4:
|
|
return scheme->GetFont( "DmePropertyLarge", IsProportional() );
|
|
case 5:
|
|
return scheme->GetFont( "DmePropertyVeryLarge", IsProportional() );
|
|
default:
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
void CElementTreeViewListControl::SetFont( HFont font )
|
|
{
|
|
// set the font for the tree
|
|
GetTree()->SetFont( font );
|
|
|
|
// and now set the font on the data column...
|
|
for ( int i = m_Panels.FirstInorder(); i != m_Panels.InvalidIndex(); i = m_Panels.NextInorder( i ) )
|
|
{
|
|
ColumnPanels_t& info = m_Panels[ i ];
|
|
int c = info.m_Columns.Count();
|
|
for ( int j = 0 ; j < c; ++j )
|
|
{
|
|
Panel *panel = info.m_Columns[ j ];
|
|
if ( !panel )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
CBaseAttributePanel *attrPanel = dynamic_cast< CBaseAttributePanel * >( panel );
|
|
if ( !attrPanel )
|
|
{
|
|
continue;
|
|
}
|
|
attrPanel->SetFont( font );
|
|
}
|
|
}
|
|
}
|
|
|
|
int CElementTreeViewListControl::GetFontSize()
|
|
{
|
|
return m_iFontSize;
|
|
}
|
|
|
|
void CElementTreeViewListControl::SetFontSize( int size )
|
|
{
|
|
m_iFontSize = min( 5, max( 1, size ) );
|
|
SetFont( GetFont( m_iFontSize ) );
|
|
}
|
|
|
|
void CElementTreeViewListControl::ExpandItem(int itemIndex, bool bExpand)
|
|
{
|
|
GetTree()->ExpandItem( itemIndex, bExpand );
|
|
}
|
|
|
|
bool CElementTreeViewListControl::IsItemExpanded( int itemIndex )
|
|
{
|
|
return GetTree()->IsItemExpanded( itemIndex );
|
|
}
|
|
|
|
bool CElementTreeViewListControl::IsItemSelected( int itemIndex )
|
|
{
|
|
return GetTree()->IsItemSelected( itemIndex );
|
|
}
|
|
|
|
|
|
KeyValues *CElementTreeViewListControl::GetItemData(int itemIndex)
|
|
{
|
|
return GetTree()->GetItemData( itemIndex );
|
|
}
|
|
|
|
|
|
class CHistoryMenuButton : public MenuButton
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CHistoryMenuButton, MenuButton );
|
|
public:
|
|
CHistoryMenuButton( Panel *parent, const char *panelName, const char *text, CElementPropertiesTreeInternal *tree, int whichMenu );
|
|
|
|
virtual void OnShowMenu( Menu *menu );
|
|
virtual int OnCheckMenuItemCount();
|
|
|
|
|
|
private:
|
|
CElementPropertiesTreeInternal *m_pPropertiesTreeInternal;
|
|
int m_nWhichMenu;
|
|
};
|
|
|
|
CHistoryMenuButton::CHistoryMenuButton( Panel *parent, const char *panelName, const char *text, CElementPropertiesTreeInternal *tree, int whichMenu )
|
|
: BaseClass( parent, panelName, text ), m_pPropertiesTreeInternal( tree ), m_nWhichMenu( whichMenu )
|
|
{
|
|
Assert( m_pPropertiesTreeInternal );
|
|
}
|
|
|
|
int CHistoryMenuButton::OnCheckMenuItemCount()
|
|
{
|
|
Assert( m_pPropertiesTreeInternal );
|
|
if ( !m_pPropertiesTreeInternal )
|
|
return 0;
|
|
|
|
return m_pPropertiesTreeInternal->GetHistoryMenuItemCount( m_nWhichMenu );
|
|
}
|
|
|
|
void CHistoryMenuButton::OnShowMenu( Menu *menu )
|
|
{
|
|
Assert( m_pPropertiesTreeInternal );
|
|
if ( !m_pPropertiesTreeInternal )
|
|
return;
|
|
|
|
m_pPropertiesTreeInternal->PopulateHistoryMenu( m_nWhichMenu, menu );
|
|
}
|
|
|
|
class CSearchComboBox : public ComboBox
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CSearchComboBox, ComboBox );
|
|
public:
|
|
|
|
CSearchComboBox( CElementPropertiesTreeInternal *tree, vgui::Panel *parent, const char *panelName, int numLines, bool allowEdit );
|
|
|
|
virtual void OnMenuItemSelected();
|
|
virtual void OnShowMenu(Menu *menu);
|
|
|
|
private:
|
|
|
|
CElementPropertiesTreeInternal *m_pTree;
|
|
};
|
|
|
|
CSearchComboBox::CSearchComboBox( CElementPropertiesTreeInternal *tree, vgui::Panel *parent, const char *panelName, int numLines, bool allowEdit )
|
|
: BaseClass( parent, panelName, numLines, allowEdit ), m_pTree( tree )
|
|
{
|
|
Assert( m_pTree );
|
|
}
|
|
|
|
void CSearchComboBox::OnShowMenu(Menu *menu)
|
|
{
|
|
menu->DeleteAllItems();
|
|
Assert( m_pTree );
|
|
if ( m_pTree )
|
|
{
|
|
m_pTree->PopulateHistoryMenu( CElementPropertiesTreeInternal::DME_PROPERTIESTREE_MENU_SEARCHHSITORY, menu );
|
|
}
|
|
}
|
|
|
|
void CSearchComboBox::OnMenuItemSelected()
|
|
{
|
|
BaseClass::OnMenuItemSelected();
|
|
|
|
int idx = GetActiveItem();
|
|
if ( idx < 0 )
|
|
return;
|
|
|
|
char name[ 256 ];
|
|
GetItemText( idx, name, sizeof( name ) );
|
|
|
|
Assert( m_pTree );
|
|
if ( m_pTree && name[ 0 ] )
|
|
{
|
|
m_pTree->OnNavSearch( name );
|
|
}
|
|
}
|
|
|
|
class CPropertiesTreeToolbar : public Panel
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CPropertiesTreeToolbar, Panel );
|
|
public:
|
|
CPropertiesTreeToolbar( vgui::Panel *parent, const char *panelName, CElementPropertiesTreeInternal *tree );
|
|
|
|
virtual void ApplySchemeSettings( IScheme *scheme );
|
|
|
|
virtual void PerformLayout();
|
|
|
|
MESSAGE_FUNC( OnTextNewLine, "TextNewLine" );
|
|
|
|
virtual void OnKeyCodeTyped( KeyCode code );
|
|
|
|
void UpdateButtonState();
|
|
private:
|
|
|
|
CElementPropertiesTreeInternal *m_pTree;
|
|
|
|
CHistoryMenuButton *m_pBack;
|
|
CHistoryMenuButton *m_pFwd;
|
|
Label *m_pSearchLabel;
|
|
CSearchComboBox *m_pSearch;
|
|
// Button *m_pShowSearchResults;
|
|
};
|
|
|
|
CPropertiesTreeToolbar::CPropertiesTreeToolbar( vgui::Panel *parent, const char *panelName, CElementPropertiesTreeInternal *tree ) :
|
|
BaseClass( parent, panelName ), m_pTree( tree )
|
|
{
|
|
Assert( m_pTree );
|
|
|
|
SetPaintBackgroundEnabled( false );
|
|
|
|
m_pBack = new CHistoryMenuButton( this, "Nav_Back", "#Dme_NavBack", tree, CElementPropertiesTreeInternal::DME_PROPERTIESTREE_MENU_BACKWARD );
|
|
m_pBack->SetCommand( new KeyValues( "OnNavigateBack", "item", -1 ) );
|
|
m_pBack->AddActionSignalTarget( parent );
|
|
m_pBack->SetDropMenuButtonStyle( true );
|
|
|
|
m_pBack->SetMenu( new Menu( this, "Nav_BackMenu" ) );
|
|
|
|
m_pFwd = new CHistoryMenuButton( this, "Nav_Forward", "#Dme_NavForward", tree, CElementPropertiesTreeInternal::DME_PROPERTIESTREE_MENU_FORWARD );
|
|
m_pFwd->SetCommand( new KeyValues( "OnNavigateForward", "item", -1 ) );
|
|
m_pFwd->AddActionSignalTarget( parent );
|
|
m_pFwd->SetDropMenuButtonStyle( true );
|
|
m_pFwd->SetMenu( new Menu( this, "Nav_FwdMenu" ) );
|
|
|
|
m_pSearch = new CSearchComboBox( tree, this, "Nav_Search", 20, true );
|
|
m_pSearch->SendNewLine( true );
|
|
m_pSearch->SelectAllOnFocusAlways( true );
|
|
m_pSearch->AddActionSignalTarget( this );
|
|
|
|
/*
|
|
m_pShowSearchResults = new Button( this, "Nav_ShowResults", "Show Results" );
|
|
m_pShowSearchResults->SetCommand( new KeyValues( "OnShowSearchResults" ) );
|
|
m_pShowSearchResults->AddActionSignalTarget( parent );
|
|
*/
|
|
|
|
m_pSearchLabel = new Label( this, "Nav_SearchLabel", "#Dme_NavSearch" );
|
|
}
|
|
|
|
void CPropertiesTreeToolbar::UpdateButtonState()
|
|
{
|
|
m_pBack->SetEnabled( m_pTree->GetHistoryMenuItemCount( CElementPropertiesTreeInternal::DME_PROPERTIESTREE_MENU_BACKWARD ) > 0 ? true : false );
|
|
m_pFwd->SetEnabled( m_pTree->GetHistoryMenuItemCount( CElementPropertiesTreeInternal::DME_PROPERTIESTREE_MENU_FORWARD ) > 0 ? true : false );
|
|
|
|
//m_pShowSearchResults->SetEnabled( m_pTree->GetHistoryMenuItemCount( CElementPropertiesTreeInternal::DME_PROPERTIESTREE_MENU_SEARCHHSITORY ) > 0 ? true : false );
|
|
}
|
|
|
|
void CPropertiesTreeToolbar::OnTextNewLine()
|
|
{
|
|
Panel *parent = GetParent();
|
|
Assert( parent );
|
|
if ( !parent )
|
|
return;
|
|
|
|
char searchBuf[ 256 ];
|
|
m_pSearch->GetText( searchBuf, sizeof( searchBuf ) );
|
|
|
|
KeyValues *msg = new KeyValues( "OnNavigateSearch", "text", searchBuf );
|
|
|
|
PostMessage( parent, msg );
|
|
}
|
|
|
|
void CPropertiesTreeToolbar::OnKeyCodeTyped( KeyCode code )
|
|
{
|
|
switch ( code )
|
|
{
|
|
case KEY_F3:
|
|
{
|
|
bool shift = (input()->IsKeyDown(KEY_LSHIFT) || input()->IsKeyDown(KEY_RSHIFT));
|
|
|
|
Panel *parent = GetParent();
|
|
Assert( parent );
|
|
if ( parent )
|
|
{
|
|
KeyValues *msg = new KeyValues( "OnNavigateSearchAgain", "direction", shift ? -1 : 1 );
|
|
PostMessage( parent, msg );
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
BaseClass::OnKeyCodeTyped( code );
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CPropertiesTreeToolbar::ApplySchemeSettings( IScheme *scheme )
|
|
{
|
|
BaseClass::ApplySchemeSettings( scheme );
|
|
|
|
m_pBack->SetFont( scheme->GetFont( "DefaultVerySmall" ) );
|
|
m_pFwd->SetFont( scheme->GetFont( "DefaultVerySmall" ) );
|
|
m_pSearch->SetFont( scheme->GetFont( "DefaultVerySmall" ) );
|
|
m_pSearchLabel->SetFont( scheme->GetFont( "DefaultVerySmall" ) );
|
|
//m_pShowSearchResults->SetFont( scheme->GetFont( "DefaultVerySmall" ) );
|
|
|
|
m_pSearch->SendNewLine( true );
|
|
m_pSearch->SelectAllOnFocusAlways( true );
|
|
|
|
m_pBack->GetMenu()->SetFont( scheme->GetFont( "DefaultVerySmall" ) );
|
|
m_pFwd->GetMenu()->SetFont( scheme->GetFont( "DefaultVerySmall" ) );
|
|
}
|
|
|
|
void CPropertiesTreeToolbar::PerformLayout()
|
|
{
|
|
BaseClass::PerformLayout();
|
|
int w, h;
|
|
GetSize( w, h );
|
|
|
|
int buttonw = 75;
|
|
int buttonh = h - 6;
|
|
|
|
int x = 2;
|
|
|
|
m_pBack->SetBounds( x, 3, buttonw, buttonh );
|
|
|
|
x += buttonw + 2;
|
|
|
|
m_pFwd->SetBounds( x, 3, buttonw, buttonh );
|
|
|
|
x += buttonw + 15;
|
|
|
|
m_pSearchLabel->SetBounds( x, 2, 50, buttonh );
|
|
|
|
x += 50 + 2;
|
|
|
|
int textw = ( w - 2 ) - x;
|
|
|
|
//textw -= 75;
|
|
|
|
m_pSearch->SetBounds( x, 2, textw, buttonh );
|
|
|
|
//x += textw;
|
|
|
|
//m_pShowSearchResults->SetBounds( x, 2, 75, buttonh );
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// CElementPropertiesTreeInternal
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructor
|
|
//-----------------------------------------------------------------------------
|
|
CElementPropertiesTreeInternal::CElementPropertiesTreeInternal(
|
|
vgui::Panel *parent, IDmNotify *pNotify, CDmElement *pObject, bool autoApply /* = true */, CDmeEditorTypeDictionary *pDict /* = NULL */ ) :
|
|
BaseClass( parent, "ElementPropertiesTree" ),
|
|
m_pNotify( pNotify ),
|
|
m_hTypeDictionary( pDict ),
|
|
m_bAutoApply( autoApply ), m_bShowMemoryUsage( false )
|
|
{
|
|
m_hObject = pObject;
|
|
m_bSuppressHistoryUpdates = false;
|
|
m_nCurrentHistoryPosition = 0;
|
|
m_szSearchStr[ 0 ] = 0;
|
|
m_nCurrentSearchResult = 0;
|
|
|
|
SetVisible( true );
|
|
|
|
Assert( m_pNotify );
|
|
|
|
CElementTree *dmeTree = new CElementTree( this, "ElementTree" );
|
|
dmeTree->SetDragEnabledItems( true );
|
|
|
|
m_pTree = new CElementTreeViewListControl( this, "ElementTreeList" );
|
|
m_pTree->SetTreeView( dmeTree );
|
|
m_pTree->SetNumColumns( 2 );
|
|
m_pTree->SetColumnInfo( 0, "Tree", m_pTree->GetTreeColumnWidth() );
|
|
m_pTree->SetColumnInfo( 1, "Data", 1600 );
|
|
|
|
m_pToolBar = new CPropertiesTreeToolbar( this, "ElementTreeToolbar", this );
|
|
// m_pToolBar->SetTreeView( dmeTree );
|
|
|
|
ScrollBar *sb = dmeTree->GetScrollBar();
|
|
if ( sb )
|
|
{
|
|
sb->SetParent( m_pTree );
|
|
}
|
|
|
|
SETUP_PANEL( dmeTree );
|
|
SETUP_PANEL( m_pTree );
|
|
SETUP_PANEL( m_pToolBar );
|
|
|
|
{
|
|
CDmElement *pResults = CreateElement< CDmElement >( "Search Results", DMFILEID_INVALID );
|
|
Assert( pResults );
|
|
pResults->AddAttributeElementArray< CDmElement >( "results" );
|
|
m_SearchResultsRoot = pResults;
|
|
}
|
|
|
|
LoadControlSettings( "resource/BxElementPropertiesTree.res" );
|
|
|
|
m_hDragCopyCursor = surface()->CreateCursorFromFile( "resource/drag_copy.cur" );
|
|
m_hDragLinkCursor = surface()->CreateCursorFromFile( "resource/drag_link.cur" );
|
|
m_hDragMoveCursor = surface()->CreateCursorFromFile( "resource/drag_move.cur" );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Destructor
|
|
//-----------------------------------------------------------------------------
|
|
CElementPropertiesTreeInternal::~CElementPropertiesTreeInternal()
|
|
{
|
|
if ( m_SearchResultsRoot.Get() )
|
|
{
|
|
g_pDataModel->DestroyElement( m_SearchResultsRoot );
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::UpdateButtonState()
|
|
{
|
|
m_pToolBar->UpdateButtonState();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Message sent when something changed the element you're looking at
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::OnElementChangedExternally( int valuesOnly )
|
|
{
|
|
Refresh( valuesOnly ? REFRESH_VALUES_ONLY : REFRESH_TREE_VIEW );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the type dictionary
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::SetTypeDictionary( CDmeEditorTypeDictionary *pDict )
|
|
{
|
|
m_hTypeDictionary = pDict;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Initialization of the tree
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::Init( )
|
|
{
|
|
if ( !m_hObject.Get() )
|
|
return;
|
|
|
|
UpdateTree();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Applies changes to all attributes
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::ApplyChanges()
|
|
{
|
|
Assert( !m_bAutoApply );
|
|
|
|
if ( !m_hObject.Get() )
|
|
return;
|
|
|
|
int nCount = m_AttributeWidgets.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
attributewidgetfactorylist->ApplyChanges( m_AttributeWidgets[i].m_pValueWidget, this );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Refreshes all attributes
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::Refresh( RefreshType_t rebuild /* = false */, bool preservePrevSelectedItem /*= false*/ )
|
|
{
|
|
if ( !m_hObject.Get() )
|
|
return;
|
|
|
|
if ( rebuild == REFRESH_REBUILD )
|
|
{
|
|
SetObject( m_hObject.Get() );
|
|
return;
|
|
}
|
|
|
|
if ( rebuild != REFRESH_VALUES_ONLY )
|
|
{
|
|
RefreshTreeView( preservePrevSelectedItem );
|
|
}
|
|
else
|
|
{
|
|
RefreshTreeItemState( m_pTree->GetTree()->GetRootItemIndex() );
|
|
}
|
|
int nCount = m_AttributeWidgets.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
attributewidgetfactorylist->Refresh( m_AttributeWidgets[i].m_pValueWidget, this );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Start editing label, in place
|
|
// Input : -
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::OnRename()
|
|
{
|
|
if ( m_pTree->GetTree()->GetSelectedItemCount() != 1 )
|
|
return;
|
|
|
|
m_pTree->GetTree()->StartEditingLabel( m_pTree->GetTree()->GetFirstSelectedItem() );
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnCopy()
|
|
{
|
|
CUtlVector< int > selected;
|
|
m_pTree->GetTree()->GetSelectedItems( selected ) ;
|
|
int c = selected.Count();
|
|
if ( c <= 0 )
|
|
return;
|
|
|
|
// add in reverse order, since selection[0] is the last item selected
|
|
CUtlVector< KeyValues * > list;
|
|
for ( int i = c - 1; i >= 0; --i )
|
|
{
|
|
KeyValues *data = new KeyValues( "Clipboard" );
|
|
m_pTree->GetTree()->GenerateDragDataForItem( selected[ i ], data );
|
|
list.AddToTail( data );
|
|
}
|
|
|
|
if ( list.Count() > 0 )
|
|
{
|
|
g_pDataModel->SetClipboardData( list );
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::GetPathToItem( CUtlVector< TreeItem_t > &path, int itemIndex )
|
|
{
|
|
for ( int idx = itemIndex; idx != m_pTree->GetTree()->GetRootItemIndex(); idx = m_pTree->GetTree()->GetItemParent( idx ) )
|
|
{
|
|
KeyValues *itemData = m_pTree->GetTree()->GetItemData( idx );
|
|
bool isArrayElement = !itemData->IsEmpty( "arrayIndex" );
|
|
|
|
TreeItem_t treeitem;
|
|
treeitem.m_pElement = GetElementKeyValue< CDmElement >( itemData, "ownerelement" );
|
|
treeitem.m_pAttributeName = itemData->GetString( "attributeName", "" );
|
|
treeitem.m_pArrayElement = isArrayElement ? GetElementKeyValue< CDmElement >( itemData, "dmeelement" ) : NULL;
|
|
path.AddToTail( treeitem );
|
|
}
|
|
}
|
|
|
|
int CElementPropertiesTreeInternal::OpenPath( const CUtlVector< TreeItem_t > &path )
|
|
{
|
|
bool bFound = false;
|
|
|
|
int itemIndex = m_pTree->GetTree()->GetRootItemIndex();
|
|
int nPathItems = path.Count();
|
|
for ( int i = 0; i < nPathItems; ++i )
|
|
{
|
|
const TreeItem_t &childTreeItem = path[ i ];
|
|
|
|
bFound = false;
|
|
|
|
int nChildren = m_pTree->GetTree()->GetNumChildren( itemIndex );
|
|
for ( int i = 0; i < nChildren; ++i )
|
|
{
|
|
int nChildIndex = m_pTree->GetTree()->GetChild( itemIndex, i );
|
|
KeyValues *childData = m_pTree->GetTree()->GetItemData( nChildIndex );
|
|
|
|
bool isArrayElement = !childData->IsEmpty( "arrayIndex" );
|
|
CDmElement *pOwnerElement = GetElementKeyValue< CDmElement >( childData, "ownerelement" );
|
|
const char *pAttributeName = childData->GetString( "attributeName", "" );
|
|
CDmAttribute *pAttribute = pOwnerElement->GetAttribute( pAttributeName );
|
|
|
|
if ( isArrayElement )
|
|
{
|
|
Assert( childTreeItem.m_pArrayElement );
|
|
Assert( !V_strcmp( childTreeItem.m_pAttributeName, pAttributeName ) );
|
|
int nArrayIndex = childData->GetInt( "arrayIndex", -1 );
|
|
const CDmrElementArray<> array( pAttribute );
|
|
if ( nArrayIndex >= 0 && array[ nArrayIndex ] == childTreeItem.m_pArrayElement )
|
|
{
|
|
bFound = true;
|
|
itemIndex = nChildIndex;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Assert( !childTreeItem.m_pArrayElement );
|
|
if ( !V_strcmp( childTreeItem.m_pAttributeName, pAttributeName ) )
|
|
{
|
|
bFound = true;
|
|
itemIndex = nChildIndex;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !bFound )
|
|
return -1;
|
|
}
|
|
|
|
return bFound ? itemIndex : -1;
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnPaste_( bool reference )
|
|
{
|
|
CUtlVector< int > selected;
|
|
m_pTree->GetTree()->GetSelectedItems( selected ) ;
|
|
int c = selected.Count();
|
|
if ( !c )
|
|
return;
|
|
|
|
// Just choose first item for now
|
|
int itemIndex = selected[ 0 ];
|
|
KeyValues *itemData = m_pTree->GetItemData( itemIndex );
|
|
if ( !itemData )
|
|
return;
|
|
|
|
const char *elementType = itemData->GetString( "droppableelementtype" );
|
|
if ( !elementType || !elementType[ 0 ] )
|
|
return;
|
|
|
|
bool isArrayElement = !itemData->IsEmpty( "arrayIndex" );
|
|
|
|
//Check to see if this attribute refers to an element
|
|
CDmAttribute *pAttribute = ElementTree_GetAttribute( itemData );
|
|
if ( !pAttribute )
|
|
return;
|
|
|
|
DmAttributeType_t attType = pAttribute ? pAttribute->GetType() : AT_UNKNOWN;
|
|
bool isElementAttribute = attType == AT_ELEMENT || attType == AT_ELEMENT_ARRAY;
|
|
if ( !isElementAttribute )
|
|
return;
|
|
|
|
// get source data that will be pasted
|
|
CUtlVector< KeyValues * > msglist;
|
|
g_pDataModel->GetClipboardData( msglist );
|
|
|
|
CUtlVector< CDmElement * > list;
|
|
ElementTree_GetDroppableItems( msglist, "dmeelement", list );
|
|
if ( !list.Count() )
|
|
return;
|
|
|
|
// Pasting after an element array item or at the end of an element array
|
|
if ( isArrayElement || attType == AT_ELEMENT_ARRAY )
|
|
{
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, m_pNotify, reference ? "Paste Reference" : "Paste" );
|
|
|
|
CDmrElementArray<> array( pAttribute );
|
|
int nArrayIndex = isArrayElement ? itemData->GetInt( "arrayIndex" ) + 1 : array.Count();
|
|
DropItemsIntoArray( array, msglist, list, nArrayIndex, reference ? DO_LINK : DO_COPY );
|
|
}
|
|
// Pasting onto an element attribute
|
|
else
|
|
{
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, m_pNotify, reference ? "Paste Reference" : "Paste" );
|
|
|
|
pAttribute->SetValue( reference ? list[ 0 ] : list[ 0 ]->Copy() );
|
|
}
|
|
|
|
CUtlVector< TreeItem_t > dropTargetPath;
|
|
if ( isArrayElement )
|
|
{
|
|
itemIndex = m_pTree->GetTree()->GetItemParent( itemIndex ); // if we're an array element, start with the array itself
|
|
}
|
|
GetPathToItem( dropTargetPath, itemIndex );
|
|
|
|
// Does a forced refresh
|
|
Refresh( REFRESH_TREE_VIEW );
|
|
|
|
itemIndex = OpenPath( dropTargetPath );
|
|
if ( attType == AT_ELEMENT_ARRAY )
|
|
{
|
|
m_pTree->GetTree()->ExpandItem( itemIndex, true );
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnPaste()
|
|
{
|
|
Warning( "CElementPropertiesTreeInternal::OnPaste\n" );
|
|
OnPaste_( false );
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnPasteReference()
|
|
{
|
|
Warning( "CElementPropertiesTreeInternal::OnPasteReference\n" );
|
|
OnPaste_( true );
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnPasteInsert()
|
|
{
|
|
Warning( "CElementPropertiesTreeInternal::OnPasteInsert\n" );
|
|
}
|
|
|
|
void RemoveAllReferencesToElement( CDmElement *pElement )
|
|
{
|
|
if ( pElement == NULL )
|
|
return;
|
|
|
|
for ( DmElementHandle_t hElement = g_pDataModel->FirstAllocatedElement();
|
|
hElement != DMELEMENT_HANDLE_INVALID;
|
|
hElement = g_pDataModel->NextAllocatedElement( hElement ) )
|
|
{
|
|
CDmElement *pElt = g_pDataModel->GetElement( hElement );
|
|
if ( pElt )
|
|
{
|
|
pElt->RemoveAllReferencesToElement( pElement );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnDeleteSelected()
|
|
{
|
|
CUtlVector< KeyValues * > selection;
|
|
m_pTree->GetTree()->GetSelectedItemData( selection );
|
|
int nSelected = selection.Count();
|
|
if ( !nSelected )
|
|
return;
|
|
|
|
bool bChangeOccurred = false;
|
|
{
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, m_pNotify, "Delete Elements" );
|
|
|
|
for ( int si = 0; si < nSelected; ++si )
|
|
{
|
|
KeyValues *item = selection[ si ];
|
|
Assert( item );
|
|
|
|
// Check to see if this attribute refers to an element
|
|
CDmElement *pOwner = GetElementKeyValue<CDmElement>( item, "ownerelement" );
|
|
if ( pOwner == NULL )
|
|
continue;
|
|
|
|
CDmAttribute *pAttr = pOwner->GetAttribute( item->GetString( "attributeName" ) );
|
|
if ( pAttr == NULL )
|
|
continue;
|
|
|
|
bChangeOccurred = true;
|
|
|
|
DmAttributeType_t attrType = pAttr->GetType();
|
|
if ( attrType == AT_ELEMENT )
|
|
{
|
|
CDmElement *pElement = pAttr->GetValueElement<CDmElement>();
|
|
RemoveAllReferencesToElement( pElement );
|
|
}
|
|
else if ( attrType == AT_ELEMENT_ARRAY )
|
|
{
|
|
const CDmrElementArray<> array( pAttr );
|
|
int n = array.Count();
|
|
int index = item->GetInt( "arrayIndex", -1 );
|
|
if ( index >= 0 )
|
|
{
|
|
CDmElement *pElement = array[ index ];
|
|
RemoveAllReferencesToElement( pElement );
|
|
}
|
|
else
|
|
{
|
|
for ( int i = 0; i < n; ++i )
|
|
{
|
|
CDmElement *pElement = array[ i ];
|
|
RemoveAllReferencesToElement( pElement );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Does a forced refresh
|
|
if ( bChangeOccurred )
|
|
{
|
|
Refresh( REFRESH_TREE_VIEW );
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnCut()
|
|
{
|
|
OnCopy();
|
|
OnRemove();
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnClear()
|
|
{
|
|
bool bNeedRefresh = false;
|
|
CUtlVector< KeyValues * > data;
|
|
m_pTree->GetTree()->GetSelectedItemData( data );
|
|
int c = data.Count();
|
|
if ( !c )
|
|
return;
|
|
|
|
CElementTreeNotifyScopeGuard notify( "CElementPropertiesTreeInternal::OnClear", NOTIFY_SETDIRTYFLAG, m_pNotify );
|
|
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
KeyValues *item = data[ i ];
|
|
Assert( item );
|
|
|
|
//Check to see if this attribute refers to an element
|
|
CDmElement *pOwner = GetElementKeyValue<CDmElement>( item, "ownerelement" );
|
|
const char *pAttributeName = item->GetString( "attributeName" );
|
|
|
|
if ( pOwner && pAttributeName[ 0 ] )
|
|
{
|
|
CDmAttribute *pAttribute = pOwner->GetAttribute( pAttributeName );
|
|
DmAttributeType_t attType = pAttribute ? pAttribute->GetType( ) : AT_UNKNOWN;
|
|
switch ( attType )
|
|
{
|
|
default:
|
|
break;
|
|
|
|
case AT_ELEMENT:
|
|
{
|
|
bNeedRefresh = true;
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Remove Element" );
|
|
pAttribute->SetValue( DMELEMENT_HANDLE_INVALID );
|
|
}
|
|
break;
|
|
|
|
case AT_ELEMENT_ARRAY:
|
|
{
|
|
bNeedRefresh = true;
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Remove Element" );
|
|
CDmrGenericArray array( pAttribute );
|
|
if ( array.IsValid() )
|
|
{
|
|
array.RemoveAll();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( bNeedRefresh )
|
|
{
|
|
// Does a forced refresh
|
|
Refresh( REFRESH_TREE_VIEW );
|
|
}
|
|
}
|
|
|
|
// For each owner/attribute have an entry and them for each arrayIndex into any array type, need to sort by arrayIndex so we can remove them in reverse order
|
|
|
|
static bool ArrayIndexLessFunc( KeyValues * const &lhs, KeyValues* const &rhs )
|
|
{
|
|
bool arrayItem1 = !lhs->IsEmpty( "arrayIndex" ) ? true : false;
|
|
int arrayIndex1 = lhs->GetInt( "arrayIndex" );
|
|
bool arrayItem2 = !rhs->IsEmpty( "arrayIndex" ) ? true : false;
|
|
int arrayIndex2 = rhs->GetInt( "arrayIndex" );
|
|
|
|
if ( !arrayItem1 || !arrayItem2 )
|
|
return lhs < rhs;
|
|
|
|
return arrayIndex1 < arrayIndex2;
|
|
}
|
|
|
|
struct OwnerAttribute_t
|
|
{
|
|
OwnerAttribute_t() : sortedData( 0, 0, ArrayIndexLessFunc )
|
|
{
|
|
}
|
|
|
|
OwnerAttribute_t( const OwnerAttribute_t& src ) : sortedData( 0, 0, ArrayIndexLessFunc )
|
|
{
|
|
pOwner = src.pOwner;
|
|
symAttribute = src.symAttribute;
|
|
for ( int i = src.sortedData.FirstInorder(); i != src.sortedData.InvalidIndex(); i = src.sortedData.NextInorder( i ) )
|
|
{
|
|
sortedData.Insert( src.sortedData[ i ] );
|
|
}
|
|
}
|
|
|
|
static bool LessFunc( const OwnerAttribute_t& lhs, const OwnerAttribute_t& rhs )
|
|
{
|
|
if ( lhs.pOwner != rhs.pOwner )
|
|
return lhs.pOwner < rhs.pOwner;
|
|
|
|
return Q_stricmp( lhs.symAttribute.String(), rhs.symAttribute.String() ) < 0;
|
|
}
|
|
|
|
CDmElement *pOwner;
|
|
CUtlSymbol symAttribute;
|
|
|
|
CUtlRBTree< KeyValues *, int > sortedData;
|
|
};
|
|
|
|
class CSortedElementData
|
|
{
|
|
public:
|
|
CSortedElementData() : m_Sorted( 0, 0, OwnerAttribute_t::LessFunc )
|
|
{
|
|
}
|
|
|
|
void AddData( CDmElement *pOwner, const char *attribute, KeyValues *data )
|
|
{
|
|
OwnerAttribute_t search;
|
|
search.pOwner = pOwner;
|
|
search.symAttribute = attribute;
|
|
|
|
int idx = m_Sorted.Find( search );
|
|
if ( idx == m_Sorted.InvalidIndex() )
|
|
{
|
|
idx = m_Sorted.Insert( search );
|
|
}
|
|
|
|
OwnerAttribute_t *entry = &m_Sorted[ idx ];
|
|
Assert( entry );
|
|
|
|
entry->sortedData.Insert( data );
|
|
}
|
|
|
|
CUtlRBTree< OwnerAttribute_t, int > m_Sorted;
|
|
};
|
|
|
|
bool CElementPropertiesTreeInternal::OnRemoveFromData( KeyValues *item )
|
|
{
|
|
Assert( item );
|
|
|
|
bool arrayItem = !item->IsEmpty( "arrayIndex" );
|
|
int arrayIndex = item->GetInt( "arrayIndex" );
|
|
|
|
//Warning( " item[ %i ] (array? %s)\n", arrayIndex, arrayItem ? "yes" : "no" );
|
|
|
|
CDmElement *pOwner = GetElementKeyValue< CDmElement >( item, "ownerelement" );
|
|
const char *pAttributeName = item->GetString( "attributeName" );
|
|
if ( !pOwner || !pAttributeName[ 0 ] )
|
|
return false;
|
|
|
|
CDmAttribute *pAttribute = pOwner->GetAttribute( pAttributeName );
|
|
DmAttributeType_t attType = pAttribute ? pAttribute->GetType( ) : AT_UNKNOWN;
|
|
|
|
if ( arrayItem && IsArrayType( attType ) )
|
|
{
|
|
CDmrGenericArray array( pAttribute );
|
|
if ( !array.IsValid() )
|
|
return false;
|
|
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Remove Array element" );
|
|
|
|
array.Remove( arrayIndex );
|
|
return true;
|
|
}
|
|
|
|
if ( attType == AT_ELEMENT )
|
|
{
|
|
if ( pOwner->GetValue< DmElementHandle_t >( pAttributeName ) != DMELEMENT_HANDLE_INVALID )
|
|
{
|
|
// remove the referenced element from this attribute
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Remove Element" );
|
|
pAttribute->SetValue( DMELEMENT_HANDLE_INVALID );
|
|
}
|
|
else if ( !pAttribute->IsFlagSet( FATTRIB_EXTERNAL ) && !pAttribute->IsFlagSet( FATTRIB_READONLY ) )
|
|
{
|
|
// remove the attribute
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Remove Attribute" );
|
|
pOwner->RemoveAttribute( pAttributeName );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if ( attType == AT_ELEMENT_ARRAY )
|
|
{
|
|
CDmrGenericArray array( pOwner, pAttributeName );
|
|
if ( array.IsValid() && array.Count() > 0 )
|
|
{
|
|
// remove the all the elements from the array
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Remove Element Array Items" );
|
|
array.RemoveAll();
|
|
}
|
|
else if ( !pAttribute->IsFlagSet( FATTRIB_EXTERNAL ) && !pAttribute->IsFlagSet( FATTRIB_READONLY ) )
|
|
{
|
|
// remove the attribute
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Remove Attribute" );
|
|
pOwner->RemoveAttribute( pAttributeName );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if ( !pAttribute->IsFlagSet( FATTRIB_EXTERNAL )
|
|
&& !pAttribute->IsFlagSet( FATTRIB_TOPOLOGICAL )
|
|
&& !pAttribute->IsFlagSet( FATTRIB_READONLY ) )
|
|
{
|
|
if ( attType >= AT_FIRST_ARRAY_TYPE )
|
|
{
|
|
CDmrGenericArray array( pOwner, pAttributeName );
|
|
if ( array.IsValid() && array.Count() > 0 )
|
|
{
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Remove Array Items" );
|
|
array.RemoveAll();
|
|
}
|
|
else
|
|
{
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Remove Attribute" );
|
|
pOwner->RemoveAttribute( pAttributeName );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Remove Attribute" );
|
|
pOwner->RemoveAttribute( pAttributeName );
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CElementPropertiesTreeInternal::OnRemoveFromData( CUtlVector< KeyValues * >& list )
|
|
{
|
|
CSortedElementData sorted;
|
|
int i;
|
|
int c = list.Count();
|
|
for ( i = 0 ; i < c; ++i )
|
|
{
|
|
KeyValues *item = list[ i ];
|
|
//Check to see if this attribute refers to an element
|
|
CDmElement *pOwner = GetElementKeyValue< CDmElement >( item, "ownerelement" );
|
|
const char *pAttributeName = item->GetString( "attributeName" );
|
|
if ( !pOwner || !pAttributeName[ 0 ] )
|
|
continue;
|
|
|
|
sorted.AddData( pOwner, pAttributeName, item );
|
|
}
|
|
|
|
bool bRefreshRequired = false;
|
|
|
|
// Now walk the data in reverse order
|
|
for ( i = sorted.m_Sorted.FirstInorder(); i != sorted.m_Sorted.InvalidIndex(); i = sorted.m_Sorted.NextInorder( i ) )
|
|
{
|
|
OwnerAttribute_t& entry = sorted.m_Sorted[ i ];
|
|
|
|
// Walk it backward by array index...
|
|
for ( int j = entry.sortedData.LastInorder(); j != entry.sortedData.InvalidIndex(); j = entry.sortedData.PrevInorder( j ) )
|
|
{
|
|
KeyValues *item = entry.sortedData[ j ];
|
|
bRefreshRequired = OnRemoveFromData( item ) || bRefreshRequired;
|
|
}
|
|
}
|
|
|
|
return bRefreshRequired;
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnRemove()
|
|
{
|
|
CElementTreeNotifyScopeGuard notify( "CElementPropertiesTreeInternal::OnRemove", NOTIFY_SETDIRTYFLAG, m_pNotify );
|
|
|
|
CUtlVector< KeyValues * > data;
|
|
m_pTree->GetTree()->GetSelectedItemData( data );
|
|
bool bRefreshNeeded = OnRemoveFromData( data );
|
|
if ( bRefreshNeeded )
|
|
{
|
|
// Refresh the tree
|
|
Refresh( REFRESH_TREE_VIEW );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sorts by name
|
|
//-----------------------------------------------------------------------------
|
|
int ElementNameSortFunc( const void *arg1, const void *arg2 )
|
|
{
|
|
CDmElement *pElement1 = *(CDmElement**)arg1;
|
|
CDmElement *pElement2 = *(CDmElement**)arg2;
|
|
|
|
const char *pName1 = pElement1 ? pElement1->GetName() : "";
|
|
const char *pName2 = pElement2 ? pElement2->GetName() : "";
|
|
|
|
return Q_stricmp( pName1, pName2 );
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnSortByName()
|
|
{
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, m_pNotify, "Sort Element Array Attribute" );
|
|
|
|
CUtlVector< KeyValues * > list;
|
|
m_pTree->GetTree()->GetSelectedItemData( list );
|
|
|
|
int c = list.Count();
|
|
|
|
bool bRefreshNeeded = false;
|
|
for ( int i = 0 ; i < c; ++i )
|
|
{
|
|
KeyValues *item = list[ i ];
|
|
|
|
//Check to see if this attribute refers to an element
|
|
CDmElement *pOwner = GetElementKeyValue< CDmElement >( item, "ownerelement" );
|
|
const char *pAttributeName = item->GetString( "attributeName" );
|
|
|
|
CDmrElementArray<> elementArray( pOwner, pAttributeName );
|
|
if ( !elementArray.IsValid() )
|
|
continue;
|
|
|
|
int nCount = elementArray.Count();
|
|
if ( nCount == 0 )
|
|
continue;
|
|
|
|
bRefreshNeeded = true;
|
|
CDmElement **pArray = ( CDmElement** )_alloca( nCount * sizeof( CDmElement* ) );
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
pArray[i] = elementArray[i];
|
|
}
|
|
|
|
qsort( pArray, nCount, sizeof( CDmElement* ), ElementNameSortFunc );
|
|
|
|
elementArray.RemoveAll();
|
|
elementArray.AddMultipleToTail( nCount );
|
|
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
elementArray.Set( i, pArray[i] );
|
|
}
|
|
}
|
|
|
|
if ( bRefreshNeeded )
|
|
{
|
|
// Refresh the tree
|
|
Refresh( REFRESH_TREE_VIEW );
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::JumpToHistoryItem()
|
|
{
|
|
if ( m_nCurrentHistoryPosition < 0 || m_nCurrentHistoryPosition >= m_hHistory.Count() )
|
|
{
|
|
m_nCurrentHistoryPosition = 0;
|
|
}
|
|
|
|
if ( !m_hHistory.Count() )
|
|
return;
|
|
|
|
CDmElement *element = m_hHistory[ m_nCurrentHistoryPosition ].Get();
|
|
if ( !element )
|
|
return;
|
|
|
|
bool save = m_bSuppressHistoryUpdates;
|
|
m_bSuppressHistoryUpdates = true;
|
|
|
|
SetObject( element );
|
|
|
|
m_bSuppressHistoryUpdates = save;
|
|
|
|
// Does a forced refresh
|
|
Refresh( REFRESH_TREE_VIEW );
|
|
|
|
// Used by the Dme panel to refresh the combo boxes when we change objects
|
|
KeyValues *kv = new KeyValues( "NotifyViewedElementChanged" );
|
|
SetElementKeyValue( kv, "dmeelement", element );
|
|
PostActionSignal( kv );
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnShowSearchResults()
|
|
{
|
|
if ( !m_SearchResults.Count() )
|
|
return;
|
|
|
|
if ( !m_SearchResultsRoot.Get() )
|
|
return;
|
|
|
|
SetObject( m_SearchResultsRoot.Get() );
|
|
|
|
// Used by the Dme panel to refresh the combo boxes when we change objects
|
|
KeyValues *kv = new KeyValues( "NotifyViewedElementChanged" );
|
|
SetElementKeyValue( kv, "dmeelement", m_SearchResultsRoot.Get() );
|
|
PostActionSignal( kv );
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnNavBack( int item )
|
|
{
|
|
int c = m_hHistory.Count();
|
|
if ( c <= 1 )
|
|
return;
|
|
|
|
if ( item == -1 )
|
|
{
|
|
if ( m_nCurrentHistoryPosition >= c - 1 )
|
|
return;
|
|
|
|
item = 1;
|
|
}
|
|
|
|
m_nCurrentHistoryPosition += item;
|
|
Assert( m_nCurrentHistoryPosition < c );
|
|
|
|
JumpToHistoryItem();
|
|
|
|
UpdateButtonState();
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnNavForward( int item )
|
|
{
|
|
int c = m_hHistory.Count();
|
|
if ( c <= 0 )
|
|
return;
|
|
|
|
if ( item == -1 )
|
|
{
|
|
if ( m_nCurrentHistoryPosition <= 0 )
|
|
return;
|
|
|
|
item = 0;
|
|
}
|
|
|
|
++item;
|
|
|
|
m_nCurrentHistoryPosition -= item;
|
|
Assert( m_nCurrentHistoryPosition >= 0 );
|
|
|
|
JumpToHistoryItem();
|
|
|
|
UpdateButtonState();
|
|
}
|
|
|
|
bool CElementPropertiesTreeInternal::BuildExpansionListToFindElement_R(
|
|
CUtlRBTree< CDmElement *, int >& visited,
|
|
int depth,
|
|
SearchResult_t &sr,
|
|
CDmElement *owner,
|
|
CDmElement *element,
|
|
const char *attributeName,
|
|
int arrayIndex,
|
|
CUtlVector< int >& expandIndices
|
|
)
|
|
{
|
|
if ( !element )
|
|
return true;
|
|
|
|
if ( visited.Find( element ) != visited.InvalidIndex() )
|
|
return true;
|
|
|
|
visited.Insert( element );
|
|
|
|
int nAttributes = element->AttributeCount();
|
|
|
|
if ( element == sr.handle.Get() )
|
|
{
|
|
if ( sr.attributeName.Length() > 0 )
|
|
{
|
|
int idx = nAttributes - 1;
|
|
for ( CDmAttribute *attribute = element->FirstAttribute(); attribute; attribute = attribute->NextAttribute(), --idx )
|
|
{
|
|
const char *attributeName = attribute->GetName();
|
|
if ( !Q_stricmp( attributeName, sr.attributeName.Get() ) )
|
|
{
|
|
expandIndices.AddToTail( idx );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int idx = nAttributes - 1;
|
|
for ( CDmAttribute *attribute = element->FirstAttribute(); attribute; attribute = attribute->NextAttribute(), --idx )
|
|
{
|
|
const char *attributeName = attribute->GetName();
|
|
if ( attribute->GetType() == AT_ELEMENT )
|
|
{
|
|
if ( !BuildExpansionListToFindElement_R( visited, depth + 1, sr, element, attribute->GetValueElement<CDmElement>(), attributeName, -1, expandIndices ) )
|
|
{
|
|
expandIndices.AddToTail( idx );
|
|
return false;
|
|
}
|
|
}
|
|
else if ( attribute->GetType() == AT_ELEMENT_ARRAY )
|
|
{
|
|
// Walk child objects
|
|
const CDmrElementArray<CDmElement> elementArray( attribute );
|
|
int c = elementArray.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
if ( !BuildExpansionListToFindElement_R( visited, depth + 1, sr, element, elementArray[ i ], attributeName, i, expandIndices ) )
|
|
{
|
|
expandIndices.AddToTail( i );
|
|
expandIndices.AddToTail( idx );
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static ConVar dme_properties_maxsearchresults( "dme_properties_maxsearchresults", "50", 0, "Max number of search results to track." );
|
|
|
|
void CElementPropertiesTreeInternal::FindMatchingElements_R( CUtlRBTree< CDmElement *, int >& visited, const char *searchstr, CDmElement *element, CUtlVector< SearchResult_t >& list )
|
|
{
|
|
if ( list.Count() >= dme_properties_maxsearchresults.GetInt() )
|
|
return;
|
|
|
|
if ( !element )
|
|
return;
|
|
|
|
if ( visited.Find( element ) != visited.InvalidIndex() )
|
|
return;
|
|
|
|
visited.Insert( element );
|
|
|
|
if ( Q_stristr( element->GetName(), searchstr ) )
|
|
{
|
|
CDmeHandle< CDmElement > h;
|
|
h = element;
|
|
|
|
SearchResult_t sr;
|
|
sr.handle = h;
|
|
sr.attributeName = "";
|
|
|
|
if ( list.Find( sr ) == list.InvalidIndex() )
|
|
{
|
|
list.AddToTail( sr );
|
|
}
|
|
}
|
|
|
|
for ( CDmAttribute *attribute = element->FirstAttribute(); attribute; attribute = attribute->NextAttribute() )
|
|
{
|
|
const char *attributeName = attribute->GetName();
|
|
if ( Q_stristr( attributeName, searchstr ) )
|
|
{
|
|
CDmeHandle< CDmElement > h;
|
|
h = element;
|
|
|
|
SearchResult_t sr;
|
|
sr.handle = h;
|
|
sr.attributeName = attributeName;
|
|
|
|
if ( list.Find( sr ) == list.InvalidIndex() )
|
|
{
|
|
list.AddToTail( sr );
|
|
}
|
|
}
|
|
|
|
if ( attribute->GetType() == AT_ELEMENT )
|
|
{
|
|
FindMatchingElements_R( visited, searchstr, attribute->GetValueElement<CDmElement>(), list );
|
|
}
|
|
else if ( attribute->GetType() == AT_ELEMENT_ARRAY )
|
|
{
|
|
// Walk child objects
|
|
const CDmrElementArray<CDmElement> elementArray( attribute );
|
|
int c = elementArray.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
FindMatchingElements_R( visited, searchstr, elementArray[ i ], list );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnNavigateSearchAgain( int direction )
|
|
{
|
|
if ( m_SearchResults.Count() <= 0 )
|
|
{
|
|
surface()->PlaySound("common/warning.wav");
|
|
return;
|
|
}
|
|
|
|
if ( direction < 0 )
|
|
{
|
|
direction = -1;
|
|
}
|
|
else if ( direction >= 0 )
|
|
{
|
|
direction = 1;
|
|
}
|
|
|
|
m_nCurrentSearchResult = m_nCurrentSearchResult + direction;
|
|
|
|
if ( m_nCurrentSearchResult < 0 )
|
|
{
|
|
m_nCurrentSearchResult = 0;
|
|
surface()->PlaySound("common/warning.wav");
|
|
}
|
|
else if ( m_nCurrentSearchResult >= m_SearchResults.Count() )
|
|
{
|
|
m_nCurrentSearchResult = m_SearchResults.Count() - 1;
|
|
surface()->PlaySound("common/warning.wav");
|
|
}
|
|
|
|
NavigateToSearchResult();
|
|
|
|
UpdateButtonState();
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::NavigateToSearchResult()
|
|
{
|
|
if ( !m_SearchResults.Count() )
|
|
return;
|
|
|
|
// SetObject( m_SearchResultsRoot.Get() );
|
|
|
|
CUtlVector< int > expandIndices;
|
|
CUtlRBTree< CDmElement *, int > visited( 0, 0, DefLessFunc( CDmElement * ) );
|
|
|
|
BuildExpansionListToFindElement_R(
|
|
visited,
|
|
0,
|
|
m_SearchResults[ m_nCurrentSearchResult ],
|
|
m_hObject.Get(),
|
|
m_hObject.Get(),
|
|
"name",
|
|
-1,
|
|
expandIndices );
|
|
|
|
expandIndices.AddToTail( 0 );
|
|
|
|
// Close the tree and re-create the root node only
|
|
UpdateTree();
|
|
|
|
// NOTE: Updating the tree could have changed the root item index
|
|
int nIndex = m_pTree->GetTree()->GetRootItemIndex();
|
|
int c = expandIndices.Count();
|
|
for ( int i = c - 2; i >= 0 ; --i )
|
|
{
|
|
int idx = expandIndices[ i ];
|
|
|
|
// Expand the item
|
|
m_pTree->ExpandItem( nIndex, true );
|
|
|
|
#ifdef _DEBUG
|
|
int children = m_pTree->GetTree()->GetNumChildren( nIndex );
|
|
if ( idx >= children )
|
|
{
|
|
Assert( 0 );
|
|
break;
|
|
}
|
|
#endif
|
|
int childIndex = m_pTree->GetTree()->GetChild( nIndex, idx );
|
|
nIndex = childIndex;
|
|
}
|
|
|
|
m_pTree->ExpandItem( nIndex, true );
|
|
|
|
// Add to selection, but don't request focus (3rd param)
|
|
m_pTree->GetTree()->AddSelectedItem( nIndex, true, false );
|
|
m_pTree->GetTree()->MakeItemVisible( nIndex );
|
|
|
|
m_pTree->ResizeTreeToExpandedWidth();
|
|
|
|
DevMsg( "Displaying search result %d of %d\n", m_nCurrentSearchResult + 1, m_SearchResults.Count() );
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnNavSearch( const char *text )
|
|
{
|
|
Msg( "OnNavSearch(%s)\n", text);
|
|
if ( !text || !*text )
|
|
{
|
|
UpdateButtonState();
|
|
return;
|
|
}
|
|
|
|
bool changed = Q_stricmp( text, m_szSearchStr ) != 0 ? true : false;
|
|
if ( changed )
|
|
{
|
|
m_SearchResults.RemoveAll();
|
|
Q_strncpy( m_szSearchStr, text, sizeof( m_szSearchStr ) );
|
|
m_nCurrentSearchResult = 0;
|
|
|
|
CUtlRBTree< CDmElement *, int > visited( 0, 0, DefLessFunc( CDmElement * ) );
|
|
|
|
FindMatchingElements_R( visited, m_szSearchStr, m_hObject.Get(), m_SearchResults );
|
|
|
|
AddToSearchHistory( text );
|
|
|
|
if ( m_SearchResultsRoot.Get() )
|
|
{
|
|
CDisableUndoScopeGuard guard;
|
|
|
|
int c = m_SearchResults.Count();
|
|
|
|
char sz[ 512 ];
|
|
Q_snprintf( sz, sizeof( sz ), "Search Results [%d] for '%s'", c, m_szSearchStr );
|
|
|
|
m_SearchResultsRoot->SetName( sz );
|
|
|
|
CDmrElementArray<> array( m_SearchResultsRoot, "results" );
|
|
if ( array.IsValid() )
|
|
{
|
|
array.RemoveAll();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
if ( m_SearchResults[ i ].handle.Get() )
|
|
{
|
|
array.AddToTail( m_SearchResults[ i ].handle.GetHandle() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
++m_nCurrentSearchResult;
|
|
}
|
|
|
|
if ( !m_SearchResults.Count() )
|
|
{
|
|
// Close the tree and re-create the root node only
|
|
UpdateTree();
|
|
|
|
int nIndex = m_pTree->GetTree()->GetRootItemIndex();
|
|
m_pTree->ExpandItem( nIndex, true );
|
|
|
|
m_pTree->ResizeTreeToExpandedWidth();
|
|
|
|
UpdateButtonState();
|
|
return;
|
|
}
|
|
|
|
m_nCurrentSearchResult = clamp( m_nCurrentSearchResult, 0, m_SearchResults.Count() - 1 );
|
|
|
|
NavigateToSearchResult();
|
|
|
|
UpdateButtonState();
|
|
}
|
|
|
|
int CElementPropertiesTreeInternal::GetHistoryMenuItemCount( int whichMenu )
|
|
{
|
|
int c = m_hHistory.Count();
|
|
if ( !c )
|
|
return 0;
|
|
|
|
if ( m_nCurrentHistoryPosition == -1 )
|
|
{
|
|
m_nCurrentHistoryPosition = 0;
|
|
}
|
|
|
|
switch ( whichMenu )
|
|
{
|
|
default:
|
|
Assert( 0 );
|
|
break;
|
|
case DME_PROPERTIESTREE_MENU_BACKWARD:
|
|
{
|
|
return c - ( m_nCurrentHistoryPosition + 1 );
|
|
}
|
|
break;
|
|
case DME_PROPERTIESTREE_MENU_FORWARD:
|
|
{
|
|
return m_nCurrentHistoryPosition;
|
|
}
|
|
break;
|
|
case DME_PROPERTIESTREE_MENU_SEARCHHSITORY:
|
|
{
|
|
return m_SearchHistory.Count();
|
|
}
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::PopulateHistoryMenu( int whichMenu, Menu *menu )
|
|
{
|
|
ValidateHistory();
|
|
|
|
int c = m_hHistory.Count();
|
|
|
|
if ( m_nCurrentHistoryPosition == -1 )
|
|
{
|
|
m_nCurrentHistoryPosition = 0;
|
|
}
|
|
|
|
menu->DeleteAllItems();
|
|
switch ( whichMenu )
|
|
{
|
|
default:
|
|
Assert( 0 );
|
|
break;
|
|
case DME_PROPERTIESTREE_MENU_BACKWARD:
|
|
{
|
|
for ( int i = m_nCurrentHistoryPosition + 1; i < c; ++i )
|
|
{
|
|
CDmElement *element = m_hHistory[ i ].Get();
|
|
char sz[ 256 ];
|
|
Q_snprintf( sz, sizeof( sz ), "%s < %s >", element->GetName(), element->GetTypeString() );
|
|
menu->AddMenuItem( "backitem", sz, new KeyValues( "OnNavigateBack", "item", i ), this );
|
|
}
|
|
}
|
|
break;
|
|
case DME_PROPERTIESTREE_MENU_FORWARD:
|
|
{
|
|
for ( int i = 0 ; i < m_nCurrentHistoryPosition; ++i )
|
|
{
|
|
CDmElement *element = m_hHistory[ m_nCurrentHistoryPosition - i - 1 ].Get();
|
|
char sz[ 256 ];
|
|
Q_snprintf( sz, sizeof( sz ), "%s < %s >", element->GetName(), element->GetTypeString() );
|
|
menu->AddMenuItem( "fwditem", sz, new KeyValues( "OnNavigateForward", "item", i ), this );
|
|
}
|
|
}
|
|
break;
|
|
case DME_PROPERTIESTREE_MENU_SEARCHHSITORY:
|
|
{
|
|
int c = m_SearchHistory.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
CUtlString& str = m_SearchHistory[ i ];
|
|
menu->AddMenuItem( "search", str.Get(), new KeyValues( "OnNavSearch", "text", str.Get() ), this );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::AddToSearchHistory( const char *str )
|
|
{
|
|
CUtlString historyString;
|
|
historyString = str;
|
|
|
|
int c = m_SearchHistory.Count();
|
|
for ( int i = c - 1; i >= 0; --i )
|
|
{
|
|
CUtlString& entry = m_SearchHistory[ i ];
|
|
if ( entry == historyString )
|
|
{
|
|
m_SearchHistory.Remove( i );
|
|
break;
|
|
}
|
|
}
|
|
|
|
while ( m_SearchHistory.Count() >= DME_PROPERTIESTREE_MAXSEARCHHISTORYITEMS )
|
|
{
|
|
m_SearchHistory.Remove( m_SearchHistory.Count() - 1 );
|
|
}
|
|
|
|
// Newest item at head of list
|
|
m_SearchHistory.AddToHead( historyString );
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::AddToHistory( CDmElement *element )
|
|
{
|
|
if ( m_bSuppressHistoryUpdates )
|
|
return;
|
|
|
|
if ( !element )
|
|
return;
|
|
|
|
CDmeHandle< CDmElement > h;
|
|
h = element;
|
|
|
|
// Purge the forward list
|
|
if ( m_nCurrentHistoryPosition > 0 )
|
|
{
|
|
m_hHistory.RemoveMultiple( 0, m_nCurrentHistoryPosition );
|
|
m_nCurrentHistoryPosition = 0;
|
|
}
|
|
|
|
// Remove if it's already in the list
|
|
m_hHistory.FindAndRemove( h );
|
|
|
|
// Make sure there's room
|
|
while ( m_hHistory.Count() >= DME_PROPERTIESTREE_MAXHISTORYITEMS )
|
|
{
|
|
m_hHistory.Remove( m_hHistory.Count() - 1 );
|
|
}
|
|
|
|
// Most recent is at head
|
|
m_hHistory.AddToHead( h );
|
|
|
|
ValidateHistory();
|
|
|
|
UpdateButtonState();
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::ValidateHistory()
|
|
{
|
|
int i;
|
|
int c = m_hHistory.Count();
|
|
for ( i = c - 1 ; i >= 0; --i )
|
|
{
|
|
if ( !m_hHistory[ i ].Get() )
|
|
{
|
|
m_hHistory.Remove( i );
|
|
if ( i && i == m_nCurrentHistoryPosition )
|
|
{
|
|
--m_nCurrentHistoryPosition;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::SpewHistory()
|
|
{
|
|
int i;
|
|
int c = m_hHistory.Count();
|
|
for ( i = 0 ; i < c; ++i )
|
|
{
|
|
CDmElement *element = m_hHistory[ i ].Get();
|
|
Assert( element );
|
|
if ( !element )
|
|
continue;
|
|
|
|
Msg( "%s: [%02d] %s <%s>\n",
|
|
( ( i < m_nCurrentHistoryPosition ) ? "Fwd" : ( i == m_nCurrentHistoryPosition ? "Current" : "Backward" ) ),
|
|
i,
|
|
element->GetName(),
|
|
element->GetTypeString() );
|
|
}
|
|
}
|
|
|
|
|
|
void CElementPropertiesTreeInternal::AddAttribute( const char *pAttributeName, KeyValues *pContext )
|
|
{
|
|
if ( !pAttributeName || !pAttributeName[ 0 ] )
|
|
{
|
|
Warning( "Can't add attribute with an empty name\n" );
|
|
return;
|
|
}
|
|
|
|
const char *pAttributeType = pContext->GetString( "attributeType" );
|
|
CDmElement *pElement = GetElementKeyValue< CDmElement >( pContext, "element" );
|
|
if ( !pAttributeType || !pAttributeType[0] || !pElement )
|
|
return;
|
|
|
|
DmAttributeType_t attributeType = g_pDataModel->GetAttributeTypeForName( pAttributeType );
|
|
if ( attributeType == AT_UNKNOWN )
|
|
{
|
|
Warning( "Can't add attribute '%s' because type '%s' is not known\n", pAttributeName, pAttributeType );
|
|
return;
|
|
}
|
|
|
|
// Make sure attribute name isn't taken already
|
|
if ( pElement->HasAttribute( pAttributeName ) )
|
|
{
|
|
Warning( "Can't add attribute '%s', attribute with that name already exists\n", pAttributeName );
|
|
return;
|
|
}
|
|
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, m_pNotify, "Add Attribute" );
|
|
CDmAttribute *pAttribute = pElement->AddAttribute( pAttributeName, attributeType );
|
|
if ( pAttribute )
|
|
{
|
|
pAttribute->AddFlag( FATTRIB_USERDEFINED );
|
|
}
|
|
Refresh( REFRESH_TREE_VIEW );
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::SetElementAttribute( const char *pElementName, KeyValues *pContext )
|
|
{
|
|
if ( !pElementName || !pElementName[ 0 ] )
|
|
{
|
|
Warning( "Can't set an element attribute with an unnamed element!\n" );
|
|
return;
|
|
}
|
|
|
|
const char *pAttributeName = pContext->GetString( "attributeName" );
|
|
const char *pElementType = pContext->GetString( "elementType" );
|
|
CDmElement *pElement = GetElementKeyValue< CDmElement >( pContext, "element" );
|
|
if ( !pElementType || !pElementType[0] || !pElement )
|
|
return;
|
|
|
|
bool bRefreshRequired = false;
|
|
|
|
{
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, m_pNotify, "Set Element" );
|
|
DmElementHandle_t newElement = g_pDataModel->CreateElement( pElementType, pElementName, pElement->GetFileId() );
|
|
if ( newElement == DMELEMENT_HANDLE_INVALID )
|
|
return;
|
|
|
|
CDmAttribute *pAttribute = pElement->GetAttribute( pAttributeName );
|
|
DmAttributeType_t type = pAttribute ? pAttribute->GetType() : AT_UNKNOWN;
|
|
switch( type )
|
|
{
|
|
case AT_ELEMENT:
|
|
pAttribute->SetValue( newElement );
|
|
bRefreshRequired = true;
|
|
break;
|
|
|
|
case AT_ELEMENT_ARRAY:
|
|
{
|
|
CDmrElementArray<> array( pAttribute );
|
|
if ( !array.IsValid() )
|
|
{
|
|
g_pDataModel->DestroyElement( newElement );
|
|
return;
|
|
}
|
|
|
|
int idx = pContext->GetInt( "index", -1 );
|
|
|
|
bRefreshRequired = true;
|
|
if ( idx == -1 )
|
|
{
|
|
array.AddToTail( newElement );
|
|
}
|
|
else
|
|
{
|
|
array.SetHandle( idx, newElement );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( bRefreshRequired )
|
|
{
|
|
Refresh( REFRESH_TREE_VIEW );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called by the input dialog for add attribute + set element
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::OnInputCompleted( KeyValues *pParams )
|
|
{
|
|
KeyValues *pDlg = pParams->FindKey( "OnAddAttribute", false );
|
|
if ( pDlg )
|
|
{
|
|
const char *pAttributeName = pParams->GetString( "text" );
|
|
AddAttribute( pAttributeName, pDlg );
|
|
return;
|
|
}
|
|
|
|
pDlg = pParams->FindKey( "OnSetElement", false );
|
|
if ( pDlg )
|
|
{
|
|
const char *pElementName = pParams->GetString( "text" );
|
|
SetElementAttribute( pElementName, pDlg );
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Forwards commands to parent
|
|
//-----------------------------------------------------------------------------
|
|
bool CElementPropertiesTreeInternal::ShowSetElementAttributeDialog( CDmElement *pOwner,
|
|
const char *pAttributeName, int nArrayIndex, const char *pElementType )
|
|
{
|
|
if ( !pOwner || !pAttributeName || !pAttributeName[ 0 ] || !pElementType || !pElementType[ 0 ] )
|
|
return false;
|
|
|
|
static int elemNum = 0;
|
|
char elemName[ 512 ];
|
|
if ( elemNum++ == 0 )
|
|
{
|
|
Q_snprintf( elemName, sizeof( elemName ), "newElement" );
|
|
}
|
|
else
|
|
{
|
|
Q_snprintf( elemName, sizeof( elemName ), "newElement%i", elemNum );
|
|
}
|
|
|
|
KeyValues *kv = new KeyValues( "OnSetElement", "attributeName", pAttributeName );
|
|
SetElementKeyValue( kv, "element", pOwner );
|
|
kv->SetInt( "index", nArrayIndex );
|
|
kv->SetString( "elementType", pElementType );
|
|
|
|
InputDialog *pSetAttributeDialog = new InputDialog( this, "Set Element", "Element Name:", elemName );
|
|
pSetAttributeDialog->SetSmallCaption( true );
|
|
pSetAttributeDialog->SetDeleteSelfOnClose( true );
|
|
pSetAttributeDialog->DoModal( kv );
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CElementPropertiesTreeInternal::ShowAddAttributeDialog( CDmElement *pElement, const char *pAttributeType )
|
|
{
|
|
if ( !pElement || !pAttributeType || !pAttributeType[ 0 ] )
|
|
return false;
|
|
|
|
static int attrNum = 0;
|
|
char attrName[ 512 ];
|
|
if ( attrNum++ == 0 )
|
|
{
|
|
Q_snprintf( attrName, sizeof( attrName ), "newAttribute" );
|
|
}
|
|
else
|
|
{
|
|
Q_snprintf( attrName, sizeof( attrName ), "newAttribute%i", attrNum );
|
|
}
|
|
|
|
KeyValues *kv = new KeyValues( "OnAddAttribute", "attributeType", pAttributeType );
|
|
SetElementKeyValue( kv, "element", pElement );
|
|
|
|
InputDialog *pAddDialog = new InputDialog( this, "Add Attribute", "Attribute Name:", attrName );
|
|
pAddDialog->SetSmallCaption( true );
|
|
pAddDialog->SetDeleteSelfOnClose( true );
|
|
pAddDialog->DoModal( kv );
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Forwards commands to parent
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::OnCommand( const char *cmd )
|
|
{
|
|
CUtlVector< KeyValues * > data;
|
|
m_pTree->GetTree()->GetSelectedItemData( data );
|
|
if ( !data.Count() )
|
|
return;
|
|
|
|
int c = data.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
KeyValues *item = data[ i ];
|
|
Assert( item );
|
|
|
|
// Check to see if this attribute refers to an element
|
|
const char *pElementType = StringAfterPrefix( cmd, "element_" );
|
|
if ( pElementType )
|
|
{
|
|
CDmElement *pOwner = GetElementKeyValue< CDmElement >( item, "ownerelement" );
|
|
const char *pAttributeName = item->GetString( "attributeName" );
|
|
bool arrayItem = !item->IsEmpty( "arrayIndex" );
|
|
int arrayIndex = item->GetInt( "arrayIndex" );
|
|
if ( ShowSetElementAttributeDialog( pOwner, pAttributeName, arrayItem ? arrayIndex : -1, pElementType ) )
|
|
return;
|
|
continue;
|
|
}
|
|
|
|
const char *pAttributeType = StringAfterPrefix( cmd, "attribute_" );
|
|
if ( pAttributeType )
|
|
{
|
|
CDmElement *pElement = GetElementKeyValue< CDmElement >( item, "dmeelement" );
|
|
if ( ShowAddAttributeDialog( pElement, pAttributeType ) )
|
|
return;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( GetParent() )
|
|
{
|
|
GetParent()->OnCommand( cmd );
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnShowMemoryUsage()
|
|
{
|
|
m_bShowMemoryUsage = !m_bShowMemoryUsage;
|
|
Refresh( REFRESH_TREE_VIEW, true );
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnAddItem()
|
|
{
|
|
CUtlVector< KeyValues * > data;
|
|
m_pTree->GetTree()->GetSelectedItemData( data );
|
|
int c = data.Count();
|
|
if ( c == 0 )
|
|
return;
|
|
|
|
bool bRefreshRequired = false;
|
|
{
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, m_pNotify, "Add Item(s)" );
|
|
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
KeyValues *item = data[ i ];
|
|
Assert( item );
|
|
|
|
CDmElement *pOwner = GetElementKeyValue< CDmElement >( item, "ownerelement" );
|
|
const char *pAttributeName = item->GetString( "attributeName" );
|
|
CDmAttribute *pAttribute = pOwner->GetAttribute( pAttributeName );
|
|
DmAttributeType_t attType = pAttribute ? pAttribute->GetType() : AT_UNKNOWN;
|
|
|
|
if ( attType == AT_ELEMENT_ARRAY )
|
|
{
|
|
CDmrElementArray<> array( pAttribute );
|
|
if ( !array.IsValid() )
|
|
continue;
|
|
|
|
CUtlSymbol typeSymbol = array.GetElementType();
|
|
const char *pElementType = g_pDataModel->GetString( typeSymbol );
|
|
const char *pElementTypeName = StringAfterPrefix( pElementType, "Dme" );
|
|
if ( !pElementTypeName )
|
|
{
|
|
Warning( "CElementPropertiesTreeInternal::OnAddItem: Unknown Element Type %s\n", pElementType );
|
|
continue;
|
|
}
|
|
|
|
// make up a unique name
|
|
static int elementNum = 0;
|
|
char elementName[ 256 ];
|
|
if ( elementNum++ == 0 )
|
|
{
|
|
Q_snprintf( elementName, sizeof( elementName ), "new%s", pElementTypeName );
|
|
}
|
|
else
|
|
{
|
|
Q_snprintf( elementName, sizeof( elementName ), "new%s%i", pElementTypeName, elementNum );
|
|
}
|
|
|
|
DmElementHandle_t newElement = g_pDataModel->CreateElement( pElementType, elementName, pOwner->GetFileId() );
|
|
if ( newElement != DMELEMENT_HANDLE_INVALID )
|
|
{
|
|
array.AddToTail( newElement );
|
|
bRefreshRequired = true;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if ( attType >= AT_FIRST_ARRAY_TYPE )
|
|
{
|
|
CDmrGenericArray arrayAttr( pAttribute );
|
|
if ( arrayAttr.IsValid() )
|
|
{
|
|
arrayAttr.AddToTail();
|
|
bRefreshRequired = true;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( !bRefreshRequired )
|
|
{
|
|
guard.Abort();
|
|
}
|
|
}
|
|
|
|
if ( bRefreshRequired )
|
|
{
|
|
// Does a forced refresh
|
|
Refresh( REFRESH_TREE_VIEW );
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnSetShared( KeyValues *params )
|
|
{
|
|
bool bShared = params->GetInt( "shared" ) != 0;
|
|
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, m_pNotify, bShared ? "Mark Shared" : "Mark Not Shared" );
|
|
|
|
CUtlVector< KeyValues* > selected;
|
|
m_pTree->GetTree()->GetSelectedItemData( selected );
|
|
int nSelected = selected.Count();
|
|
for ( int i = 0; i < nSelected; ++i )
|
|
{
|
|
KeyValues *kv = selected[ i ];
|
|
CDmElement *pElement = GetElementKeyValue<CDmElement>( kv, "dmeelement" );
|
|
|
|
// element attribute or element array item
|
|
if ( pElement )
|
|
{
|
|
pElement->SetShared( bShared );
|
|
continue;
|
|
}
|
|
|
|
CDmElement *pOwner = GetElementKeyValue< CDmElement >( kv, "ownerelement" );
|
|
const char *pAttributeName = kv->GetString( "attributeName" );
|
|
|
|
const CDmrElementArray<> array( pOwner, pAttributeName );
|
|
if ( !array.IsValid() )
|
|
continue; // value attribute, value array item, or value array
|
|
|
|
// element array attribute
|
|
int nCount = array.Count();
|
|
for ( int j = 0; j < nCount; ++j )
|
|
{
|
|
CDmElement *pElement = array[ j ];
|
|
if ( !pElement )
|
|
continue;
|
|
|
|
pElement->SetShared( bShared );
|
|
}
|
|
}
|
|
|
|
Refresh( REFRESH_TREE_VIEW, true );
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnChangeFile( KeyValues *params )
|
|
{
|
|
const char *pFileName = params->GetString( "filename" );
|
|
DmFileId_t fileid = g_pDataModel->GetFileId( pFileName );
|
|
|
|
CUtlVector< KeyValues * > data;
|
|
m_pTree->GetTree()->GetSelectedItemData( data );
|
|
int nSelected = data.Count();
|
|
if ( !nSelected )
|
|
return;
|
|
|
|
CElementTreeNotifyScopeGuard notify( "CElementPropertiesTreeInternal::OnChangeFile", NOTIFY_SETDIRTYFLAG, m_pNotify );
|
|
|
|
bool bRefreshRequired = false;
|
|
for ( int i = 0; i < nSelected; ++i )
|
|
{
|
|
KeyValues *item = data[ i ];
|
|
Assert( item );
|
|
|
|
//Check to see if this attribute refers to an element
|
|
CDmElement *pElement = GetElementKeyValue< CDmElement >( item, "dmeelement" );
|
|
if ( !pElement )
|
|
continue;
|
|
|
|
if ( fileid == DMFILEID_INVALID )
|
|
{
|
|
fileid = g_pDataModel->FindOrCreateFileId( pElement->GetName() );
|
|
g_pDataModel->SetFileRoot( fileid, pElement->GetHandle() );
|
|
}
|
|
|
|
pElement->SetFileId( fileid, TD_DEEP );
|
|
bRefreshRequired = true;
|
|
}
|
|
|
|
if ( bRefreshRequired )
|
|
{
|
|
Refresh( REFRESH_REBUILD );
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnShowFileDialog( KeyValues *params )
|
|
{
|
|
const char *pTitle = params->GetString( "title" );
|
|
bool bOpenOnly = params->GetInt( "openOnly" ) != 0;
|
|
KeyValues *pContext = params->FindKey( "context" );
|
|
FileOpenDialog *pDialog = new FileOpenDialog( this, pTitle, bOpenOnly, pContext->MakeCopy() );
|
|
|
|
char pStartingDir[ MAX_PATH ];
|
|
GetModSubdirectory( NULL, pStartingDir, sizeof( pStartingDir ) );
|
|
Q_StripTrailingSlash( pStartingDir );
|
|
|
|
pDialog->SetStartDirectoryContext( pTitle, pStartingDir );
|
|
pDialog->AddFilter( "*.*", "All Files (*.*)", false );
|
|
pDialog->AddFilter( "*.dmx", "Generic MovieObjects File (*.dmx)", true, "movieobjects" ); // read/write generic movieobjects files
|
|
|
|
pDialog->SetDeleteSelfOnClose( true );
|
|
pDialog->AddActionSignalTarget( this );
|
|
pDialog->DoModal( true );
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnImportElement( const char *pFullPath, KeyValues *pContext )
|
|
{
|
|
CDmElement *pRoot = NULL;
|
|
DmFileId_t tempFileid;
|
|
{
|
|
CDisableUndoScopeGuard guard;
|
|
tempFileid = g_pDataModel->RestoreFromFile( pFullPath, NULL, NULL, &pRoot, CR_FORCE_COPY );
|
|
}
|
|
if ( !pRoot )
|
|
return;
|
|
|
|
CDmElement *pParent = GetElementKeyValue<CDmElement>( pContext, "owner" );
|
|
|
|
pRoot->SetFileId( pParent->GetFileId(), TD_DEEP, true );
|
|
g_pDataModel->RemoveFileId( tempFileid );
|
|
|
|
{
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, m_pNotify, "Import Element" );
|
|
|
|
const char *pAttributeName = pContext->GetString( "attribute" );
|
|
int nArrayIndex = pContext->GetInt( "index", -1 );
|
|
DmElementHandle_t hRoot = pRoot->GetHandle();
|
|
if ( nArrayIndex >= 0 )
|
|
{
|
|
CDmrElementArray<> elemArrayAttr( pParent, pAttributeName );
|
|
elemArrayAttr.SetHandle( nArrayIndex, hRoot );
|
|
}
|
|
else
|
|
{
|
|
CDmAttribute *pAttribute = pParent->GetAttribute( pAttributeName );
|
|
if ( pAttribute->GetType() == AT_ELEMENT )
|
|
{
|
|
pAttribute->SetValue( hRoot );
|
|
}
|
|
else if ( pAttribute->GetType() == AT_ELEMENT_ARRAY )
|
|
{
|
|
CDmrElementArray<> elemArrayAttr( pAttribute );
|
|
elemArrayAttr.AddToTail( hRoot );
|
|
}
|
|
}
|
|
}
|
|
|
|
Refresh( REFRESH_TREE_VIEW );
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnExportElement( const char *pFullPath, KeyValues *pContext )
|
|
{
|
|
CDmElement *pRoot = NULL;
|
|
|
|
CUtlVector< KeyValues * > selection;
|
|
m_pTree->GetTree()->GetSelectedItemData( selection );
|
|
int nSelected = selection.Count();
|
|
if ( nSelected <= 1 )
|
|
{
|
|
pRoot = GetElementKeyValue<CDmElement>( pContext, "element" );
|
|
}
|
|
else
|
|
{
|
|
// HACK - this is just a temporary hack - we should really force serialization to traverse past fileid changes in this case
|
|
KeyValues *item = selection[ 0 ];
|
|
CDmElement *pOwner = GetElementKeyValue< CDmElement >( item, "ownerelement" );
|
|
DmFileId_t fileid = pOwner->GetFileId();
|
|
|
|
pRoot = CreateElement< CDmElement >( pFullPath, fileid );
|
|
CDmrElementArray<> children( pRoot, "children", true );
|
|
|
|
for ( int si = 0; si < nSelected; ++si )
|
|
{
|
|
KeyValues *item = selection[ si ];
|
|
Assert( item );
|
|
|
|
//Check to see if this attribute refers to an element
|
|
CDmElement *pOwner = GetElementKeyValue< CDmElement >( item, "ownerelement" );
|
|
if ( pOwner == NULL )
|
|
continue;
|
|
|
|
CDmAttribute *pAttr = pOwner->GetAttribute( item->GetString( "attributeName" ) );
|
|
if ( pAttr == NULL )
|
|
continue;
|
|
|
|
DmAttributeType_t attrType = pAttr->GetType();
|
|
if ( attrType == AT_ELEMENT )
|
|
{
|
|
children.AddToTail( pAttr->GetValue< DmElementHandle_t >() );
|
|
}
|
|
else if ( attrType == AT_ELEMENT_ARRAY )
|
|
{
|
|
const CDmrElementArray<> arrayAttr( pAttr );
|
|
int n = arrayAttr.Count();
|
|
int index = item->GetInt( "arrayIndex", -1 );
|
|
if ( index >= 0 )
|
|
{
|
|
children.AddToTail( arrayAttr[ index ] );
|
|
}
|
|
else
|
|
{
|
|
for ( int i = 0; i < n; ++i )
|
|
{
|
|
children.AddToTail( arrayAttr[ i ] );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// if this control is ever moved to vgui_controls, change the default format to "dmx", the generic dmx format
|
|
const char *pFileFormat = "movieobjects";
|
|
const char *pFileEncoding = g_pDataModel->GetDefaultEncoding( pFileFormat );
|
|
g_pDataModel->SaveToFile( pFullPath, NULL, pFileEncoding, pFileFormat, pRoot );
|
|
|
|
if ( nSelected > 1 )
|
|
{
|
|
DestroyElement( pRoot );
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnFileSelected( KeyValues *params )
|
|
{
|
|
const char *pFullPath = params->GetString( "fullpath" );
|
|
KeyValues *pContext = params->FindKey( "context" );
|
|
const char *pCommand = pContext->GetString( "command" );
|
|
if ( V_strcmp( pCommand, "OnImportElement" ) == 0 )
|
|
{
|
|
OnImportElement( pFullPath, pContext );
|
|
}
|
|
else if ( V_strcmp( pCommand, "OnExportElement" ) == 0 )
|
|
{
|
|
OnExportElement( pFullPath, pContext );
|
|
}
|
|
else
|
|
{
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Creates an attribute data widget using a specifically requested widget
|
|
//-----------------------------------------------------------------------------
|
|
vgui::Panel *CElementPropertiesTreeInternal::CreateAttributeDataWidget( CDmElement *pElement,
|
|
const char *pWidgetName, CDmElement *obj, CDmAttribute *pAttribute, int nArrayIndex )
|
|
{
|
|
AttributeWidgetInfo_t info;
|
|
SetupWidgetInfo( &info, pElement, pAttribute, nArrayIndex );
|
|
IAttributeWidgetFactory *pFactory = attributewidgetfactorylist->GetWidgetFactory( pWidgetName );
|
|
if ( !pFactory )
|
|
return NULL;
|
|
return pFactory->Create( NULL, info );
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------
|
|
|
|
void CElementPropertiesTreeInternal::UpdateTree()
|
|
{
|
|
m_pTree->RemoveAll();
|
|
if ( m_hObject.Get() )
|
|
{
|
|
m_AttributeWidgets.RemoveAll();
|
|
|
|
char label[ 256 ];
|
|
Q_snprintf( label, sizeof( label ), "%s", m_hObject->GetValueString( "name" ) );
|
|
bool editableLabel = true;
|
|
|
|
KeyValues *kv = new KeyValues( "item" );
|
|
kv->SetString( "Text", label );
|
|
kv->SetInt( "Expand", 1 );
|
|
kv->SetInt( "dmeelement", m_hObject.Get() ? m_hObject.Get()->GetHandle() : DMELEMENT_HANDLE_INVALID );
|
|
kv->SetInt( "ownerelement", m_hObject.Get() ? m_hObject.Get()->GetHandle() : DMELEMENT_HANDLE_INVALID );
|
|
kv->SetString( "attributeName", "name" );
|
|
kv->SetInt( "root", m_hObject.Get() ? m_hObject.Get()->GetHandle() : DMELEMENT_HANDLE_INVALID);
|
|
kv->SetInt( "editablelabel", editableLabel ? 1 : 0 );
|
|
|
|
CDmElement *pElement = m_hObject.Get();
|
|
vgui::Panel *widget = CreateAttributeDataWidget( pElement, "element", pElement, NULL );
|
|
|
|
CUtlVector< Panel * > columns;
|
|
columns.AddToTail( NULL );
|
|
columns.AddToTail( widget );
|
|
int rootIndex = m_pTree->AddItem( kv, editableLabel, -1, columns );
|
|
|
|
m_pTree->GetTree()->SetItemFgColor( rootIndex, Color( 66, 196, 66, 255 ) );
|
|
m_pTree->GetTree()->SetItemSelectionUnfocusedBgColor( rootIndex, Color( 255, 153, 35, 255 ) );
|
|
|
|
kv->deleteThis();
|
|
|
|
// open up the root item (for now)
|
|
m_pTree->ExpandItem(rootIndex, true);
|
|
|
|
if ( m_SearchResultsRoot.Get() == m_hObject.Get() )
|
|
{
|
|
// Expand "results" too
|
|
TreeItem_t item;
|
|
|
|
item.m_pArrayElement = NULL;
|
|
item.m_pElement = m_SearchResultsRoot.Get();
|
|
item.m_pAttributeName = "results";
|
|
|
|
// Look for a match
|
|
int nChildIndex = FindTreeItem( rootIndex, item );
|
|
if ( nChildIndex >= 0 )
|
|
{
|
|
m_pTree->ExpandItem( nChildIndex, true );
|
|
}
|
|
}
|
|
}
|
|
m_pTree->InvalidateLayout();
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::GenerateDragDataForItem( int itemIndex, KeyValues *msg )
|
|
{
|
|
KeyValues *data = m_pTree->GetItemData( itemIndex );
|
|
if ( !data || !msg )
|
|
{
|
|
return;
|
|
}
|
|
|
|
msg->SetInt( "dmeelement", data->GetInt( "dmeelement" ) );
|
|
msg->SetInt( "ownerelement", data->GetInt( "ownerelement" ) );
|
|
msg->SetString( "attributeName", data->GetString( "attributeName" ) );
|
|
msg->SetInt( "arrayIndex", data->GetInt( "arrayIndex" ) );
|
|
|
|
msg->SetString( "text", data->GetString( "Text" ) );
|
|
}
|
|
|
|
struct DataModelFilenameArray
|
|
{
|
|
int Count() const
|
|
{
|
|
return g_pDataModel->NumFileIds();
|
|
}
|
|
const char *operator[]( int i ) const
|
|
{
|
|
return g_pDataModel->GetFileName( g_pDataModel->GetFileId( i ) );
|
|
}
|
|
};
|
|
|
|
void CElementPropertiesTreeInternal::GenerateContextMenu( int itemIndex, int x, int y )
|
|
{
|
|
KeyValues *data = m_pTree->GetItemData( itemIndex );
|
|
if ( !data )
|
|
{
|
|
Assert( data );
|
|
return;
|
|
}
|
|
|
|
if ( m_hContextMenu.Get() )
|
|
{
|
|
delete m_hContextMenu.Get();
|
|
m_hContextMenu = NULL;
|
|
}
|
|
|
|
m_hContextMenu = new Menu( this, "ActionMenu" );
|
|
m_hContextMenu->SetFont( m_pTree->GetTree()->GetFont() );
|
|
Menu::PlaceContextMenu( this, m_hContextMenu.Get() );
|
|
int id;
|
|
|
|
// ----------------------------------------------------
|
|
// What have we clicked on?
|
|
|
|
// inspect the data
|
|
CDmElement *pElement = GetElementKeyValue< CDmElement >( data, "dmeelement" );
|
|
CDmElement *pOwner = GetElementKeyValue< CDmElement >( data, "ownerelement" );
|
|
const char *pAttributeName = data->GetString( "attributeName" );
|
|
int nArrayIndex = data->GetInt( "arrayIndex", -1 );
|
|
|
|
// get the type
|
|
CDmAttribute *pAttribute = pOwner->GetAttribute( pAttributeName );
|
|
DmAttributeType_t attributeType = pAttribute->GetType();
|
|
|
|
// figure out the context
|
|
CDmrGenericArray array( pAttribute );
|
|
|
|
bool bIsAttribute = data->IsEmpty( "arrayIndex" );
|
|
bool bIsArrayItem = !bIsAttribute;
|
|
bool bIsArrayAttribute = !bIsArrayItem && ( attributeType >= AT_FIRST_ARRAY_TYPE );
|
|
bool bIsArrayAttributeEmpty = bIsArrayAttribute && ( array.Count() == 0 );
|
|
bool bIsElementAttribute = bIsAttribute && ( attributeType == AT_ELEMENT );
|
|
bool bIsElementArrayAttribute = bIsArrayAttribute && ( attributeType == AT_ELEMENT_ARRAY );
|
|
bool bIsElementArrayItem = bIsArrayItem && ( attributeType == AT_ELEMENT_ARRAY );
|
|
bool bIsElementAttributeNull = bIsElementAttribute && ( pElement == NULL );
|
|
|
|
// ----------------------------------------------------
|
|
// menu title == what's my context? ( 3 x 2 )
|
|
// 3: Item | Array | Attribute
|
|
// 2: Element | Not Element
|
|
|
|
if ( bIsElementArrayItem )
|
|
{
|
|
m_hContextMenu->AddCheckableMenuItem( "* Element Item Operations *", this );
|
|
}
|
|
else if ( bIsElementArrayAttribute )
|
|
{
|
|
m_hContextMenu->AddCheckableMenuItem( "* Element Array Operations *", this );
|
|
}
|
|
else if ( bIsElementAttribute )
|
|
{
|
|
m_hContextMenu->AddCheckableMenuItem( "* Element Attribute Operations *", this );
|
|
}
|
|
else if ( bIsArrayItem )
|
|
{
|
|
m_hContextMenu->AddCheckableMenuItem( "* Item Operations *", this );
|
|
}
|
|
else if ( bIsArrayAttribute )
|
|
{
|
|
m_hContextMenu->AddCheckableMenuItem( "* Array Operations *", this );
|
|
}
|
|
else if ( bIsAttribute )
|
|
{
|
|
m_hContextMenu->AddCheckableMenuItem( "* Attribute Operations *", this );
|
|
}
|
|
|
|
m_hContextMenu->AddSeparator();
|
|
|
|
// ----------------------------------------------------
|
|
// basic ops:
|
|
|
|
// cut / copy / paste
|
|
m_hContextMenu->AddMenuItem( "#DmeElementPropertiesCut", new KeyValues( "OnCut" ), this );
|
|
m_hContextMenu->AddMenuItem( "#DmeElementPropertiesCopy", new KeyValues( "OnCopy" ), this );
|
|
id = m_hContextMenu->AddMenuItem( "#DmeElementPropertiesPaste", new KeyValues( "OnPaste" ), this );
|
|
m_hContextMenu->SetItemEnabled( id, vgui::system()->GetClipboardTextCount() > 0 );
|
|
|
|
// paste special
|
|
// Would have to get the clipboard contents and examine to enable a cascading "Paste Special" menu here
|
|
Menu *pasteSpecial = new Menu( this, "Paste Special" );
|
|
pasteSpecial->SetFont( m_pTree->GetTree()->GetFont() );
|
|
id = m_hContextMenu->AddCascadingMenuItem( "#DmeElementPropertiesPasteSpecial", this, pasteSpecial );
|
|
m_hContextMenu->SetItemEnabled( id, vgui::system()->GetClipboardTextCount() > 0 );
|
|
id = pasteSpecial->AddMenuItem( "Nothing Special", this );
|
|
pasteSpecial->SetItemEnabled( id, false );
|
|
|
|
// clear or remove
|
|
int removeItemID;
|
|
if ( bIsArrayAttribute && !bIsArrayAttributeEmpty )
|
|
{
|
|
removeItemID = m_hContextMenu->AddMenuItem( "#DmeElementPropertiesClear", new KeyValues( "OnRemove" ), this );
|
|
}
|
|
else
|
|
{
|
|
removeItemID = m_hContextMenu->AddMenuItem( "#DmeElementPropertiesRemove", new KeyValues( "OnRemove" ), this );
|
|
}
|
|
|
|
// ----------------------------------------------------
|
|
// other ops
|
|
|
|
// Rename...
|
|
if ( data->GetInt( "editablelabel" ) )
|
|
{
|
|
if ( bIsArrayItem )
|
|
{
|
|
m_hContextMenu->AddMenuItem( "Rename Element...", new KeyValues( "OnRename" ), this );
|
|
}
|
|
else
|
|
{
|
|
m_hContextMenu->AddMenuItem( "Rename Attribute...", new KeyValues( "OnRename" ), this );
|
|
}
|
|
}
|
|
|
|
// sort by name
|
|
if ( bIsElementArrayAttribute && !bIsArrayAttributeEmpty )
|
|
{
|
|
m_hContextMenu->AddMenuItem( "#DmeElementPropertiesSortByName", new KeyValues( "OnSortByName" ), this );
|
|
}
|
|
|
|
// ----------------------------------------------------
|
|
// Add item/attr/elem ops:
|
|
|
|
// Add Item
|
|
if ( bIsArrayAttribute && !bIsElementArrayAttribute )
|
|
{
|
|
m_hContextMenu->AddMenuItem( "#DmeElementPropertiesAddItem", new KeyValues( "OnAddItem" ), this );
|
|
}
|
|
|
|
// Add Attribute
|
|
if ( ( bIsElementAttribute && !bIsElementAttributeNull ) || m_pTree->GetTree()->GetRootItemIndex() == itemIndex || bIsElementArrayItem )
|
|
{
|
|
Menu *addMenu = new Menu( this, "AddAttribute" );
|
|
addMenu->SetFont( m_pTree->GetTree()->GetFont() );
|
|
m_hContextMenu->AddCascadingMenuItem( "#DmeElementPropertiesAddAttribute", this, addMenu );
|
|
{
|
|
for ( int i = AT_FIRST_VALUE_TYPE; i < AT_TYPE_COUNT; ++i )
|
|
{
|
|
const char *typeName = g_pDataModel->GetAttributeNameForType( (DmAttributeType_t)i );
|
|
if ( typeName && typeName[ 0 ] )
|
|
{
|
|
char add_attribute[ 256 ];
|
|
Q_snprintf( add_attribute, sizeof( add_attribute ), "attribute_%s", typeName );
|
|
id = addMenu->AddMenuItem( typeName, new KeyValues( "Command", "command", add_attribute ), this );
|
|
addMenu->GetMenuItem( id )->SetContentAlignment( Label::a_center );
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// New, Add or Replace Element
|
|
if ( bIsElementAttribute || bIsElementArrayAttribute || bIsElementArrayItem )
|
|
{
|
|
Menu *addMenu = new Menu( this, "SetElement" );
|
|
addMenu->SetFont( m_pTree->GetTree()->GetFont() );
|
|
|
|
if ( bIsElementArrayAttribute )
|
|
{
|
|
m_hContextMenu->AddCascadingMenuItem( "#DmeElementPropertiesAddElement", this, addMenu );
|
|
}
|
|
else if ( bIsElementAttributeNull )
|
|
{
|
|
m_hContextMenu->AddCascadingMenuItem( "#DmeElementPropertiesNewElement", this, addMenu );
|
|
}
|
|
else if ( bIsElementAttribute || bIsElementArrayItem )
|
|
{
|
|
m_hContextMenu->AddCascadingMenuItem( "#DmeElementPropertiesReplaceElement", this, addMenu );
|
|
}
|
|
|
|
// Populate from factories
|
|
for ( int i = g_pDataModel->GetFirstFactory(); g_pDataModel->IsValidFactory( i ); i = g_pDataModel->GetNextFactory( i ) )
|
|
{
|
|
const char *elementType = g_pDataModel->GetFactoryName( i );
|
|
Assert( elementType && elementType[ 0 ] );
|
|
|
|
char add_element[ 256 ];
|
|
Q_snprintf( add_element, sizeof( add_element ), "element_%s", elementType );
|
|
id = addMenu->AddMenuItem( elementType, new KeyValues( "Command", "command", add_element ), this );
|
|
addMenu->GetMenuItem( id )->SetContentAlignment( Label::a_center );
|
|
}
|
|
}
|
|
|
|
// sharing
|
|
if ( ( bIsElementAttribute && !bIsElementAttributeNull ) || m_pTree->GetTree()->GetRootItemIndex() == itemIndex || bIsElementArrayAttribute || bIsElementArrayItem )
|
|
{
|
|
CUtlVector< KeyValues* > selected;
|
|
m_pTree->GetTree()->GetSelectedItemData( selected );
|
|
int nElements = 0;
|
|
int nShared = 0;
|
|
int nSelected = selected.Count();
|
|
for ( int i = 0; i < nSelected; ++i )
|
|
{
|
|
KeyValues *kv = selected[ i ];
|
|
CDmElement *pElement = GetElementKeyValue<CDmElement>( kv, "dmeelement" );
|
|
|
|
// element attribute or element array item
|
|
if ( pElement )
|
|
{
|
|
++nElements;
|
|
if ( pElement->IsShared() )
|
|
{
|
|
++nShared;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
CDmElement *pOwner = GetElementKeyValue< CDmElement >( kv, "ownerelement" );
|
|
const char *pAttributeName = kv->GetString( "attributeName" );
|
|
|
|
const CDmrElementArray<> array( pOwner, pAttributeName );
|
|
if ( !array.IsValid() )
|
|
continue; // value attribute, value array item, or value array
|
|
|
|
// element array attribute
|
|
int nCount = array.Count();
|
|
for ( int j = 0; j < nCount; ++j )
|
|
{
|
|
CDmElement *pElement = array[ j ];
|
|
if ( !pElement )
|
|
continue;
|
|
|
|
++nElements;
|
|
if ( pElement->IsShared() )
|
|
{
|
|
++nShared;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( nShared < nElements )
|
|
{
|
|
m_hContextMenu->AddMenuItem( "Mark Shared", new KeyValues( "OnSetShared", "shared", 1 ), this );
|
|
}
|
|
if ( nShared > 0 )
|
|
{
|
|
m_hContextMenu->AddMenuItem( "Mark Not Shared", new KeyValues( "OnSetShared", "shared", 0 ), this );
|
|
}
|
|
}
|
|
|
|
// import element
|
|
if ( bIsElementAttribute || bIsElementArrayAttribute || bIsElementArrayItem )
|
|
{
|
|
KeyValues *pContext = new KeyValues( "context", "command", "OnImportElement" );
|
|
pContext->SetInt( "owner", ( int )pOwner->GetHandle() );
|
|
pContext->SetString( "attribute", pAttributeName );
|
|
pContext->SetInt( "index", nArrayIndex );
|
|
|
|
KeyValues *kv = new KeyValues( "OnShowFileDialog", "title", "Import Element" );
|
|
kv->SetInt( "openOnly", 1 );
|
|
kv->AddSubKey( pContext );
|
|
m_hContextMenu->AddMenuItem( "Import element...", kv, this );
|
|
}
|
|
|
|
// export element
|
|
if ( ( bIsElementAttribute && !bIsElementAttributeNull ) || m_pTree->GetTree()->GetRootItemIndex() == itemIndex || bIsElementArrayItem )
|
|
{
|
|
KeyValues *pContext = new KeyValues( "context", "command", "OnExportElement" );
|
|
pContext->SetInt( "element", ( int )pElement->GetHandle() );
|
|
|
|
KeyValues *kv = new KeyValues( "OnShowFileDialog", "title", "Export Element" );
|
|
kv->SetInt( "openOnly", 0 );
|
|
kv->AddSubKey( pContext );
|
|
m_hContextMenu->AddMenuItem( "Export element...", kv, this );
|
|
}
|
|
|
|
if ( pElement )
|
|
{
|
|
Menu *menu = new Menu( this, "ChangeFile" );
|
|
menu->SetFont( m_pTree->GetTree()->GetFont() );
|
|
|
|
m_hContextMenu->AddCascadingMenuItem( "#DmeElementPropertiesChangeFileAssociation", this, menu );
|
|
|
|
int nFiles = g_pDataModel->NumFileIds();
|
|
for ( int i = 0; i < nFiles; ++i )
|
|
{
|
|
DmFileId_t fileid = g_pDataModel->GetFileId( i );
|
|
const char *pFileName = g_pDataModel->GetFileName( fileid );
|
|
|
|
if ( !pFileName || !*pFileName )
|
|
continue; // skip invalid and default fileids
|
|
|
|
char cmd[ 256 ];
|
|
Q_snprintf( cmd, sizeof( cmd ), "element_changefile %s", pFileName );
|
|
|
|
const char *pText = pFileName;
|
|
char text[ 256 ];
|
|
if ( pElement->GetFileId() == fileid )
|
|
{
|
|
Q_snprintf( text, sizeof( text ), "* %s", pFileName );
|
|
pText = text;
|
|
}
|
|
|
|
menu->AddMenuItem( pText, new KeyValues( "OnChangeFile", "filename", pFileName ), this );
|
|
}
|
|
|
|
char filename[ MAX_PATH ];
|
|
V_GenerateUniqueName( filename, sizeof( filename ), "unnamed", DataModelFilenameArray() );
|
|
|
|
menu->AddMenuItem( "<new file>", new KeyValues( "OnChangeFile", "filename", filename ), this );
|
|
}
|
|
|
|
// ----------------------------------------------------
|
|
// finally add a seperator after the "Remove" item, unless it's the last item
|
|
|
|
if ( ( m_hContextMenu->GetItemCount() - 1 ) != removeItemID )
|
|
{
|
|
m_hContextMenu->AddSeparatorAfterItem( removeItemID );
|
|
}
|
|
|
|
// ----------------------------------------------------
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::GenerateChildrenOfNode( int itemIndex )
|
|
{
|
|
KeyValues *data = m_pTree->GetItemData( itemIndex );
|
|
if ( !data )
|
|
{
|
|
Assert( data );
|
|
return;
|
|
}
|
|
|
|
//Check to see if this attribute refers to an element
|
|
CDmElement *obj = GetElementKeyValue<CDmElement>( data, "dmeelement" );
|
|
if ( obj )
|
|
{
|
|
InsertAttributes( itemIndex, obj );
|
|
return;
|
|
}
|
|
|
|
// Check to see if this node is an array entry, and then do nothing
|
|
if ( !data->IsEmpty( "arrayIndex" ) )
|
|
return;
|
|
|
|
// Check to see if this attribute is an array attribute
|
|
CDmElement *pOwner = GetElementKeyValue< CDmElement >( data, "ownerelement" );
|
|
if ( pOwner )
|
|
{
|
|
const char *pAttributeName = data->GetString( "attributeName" );
|
|
CDmAttribute *pAttribute = pOwner->GetAttribute( pAttributeName );
|
|
if ( pAttribute && IsArrayType( pAttribute->GetType() ) )
|
|
{
|
|
InsertAttributeArrayMembers( itemIndex, pOwner, pAttribute );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnLabelChanged( int itemIndex, const char *oldString, const char *newString )
|
|
{
|
|
KeyValues *data = m_pTree->GetItemData( itemIndex );
|
|
if ( !data )
|
|
{
|
|
Assert( data );
|
|
return;
|
|
}
|
|
|
|
// No change!!!
|
|
if ( !Q_stricmp( oldString, newString ) )
|
|
return;
|
|
|
|
CDmElement *pElement = GetElementKeyValue< CDmElement >( data, "dmeelement" );
|
|
bool bEditableLabel = data->GetInt( "editablelabel" );
|
|
|
|
CDmElement *pOwner = GetElementKeyValue< CDmElement >( data, "ownerelement" );
|
|
const char *pAttributeName = data->GetString( "attributeName" );
|
|
|
|
int bIsAttribute = data->GetInt( "isAttribute" );
|
|
|
|
int nNotifyFlags = 0;
|
|
if ( bEditableLabel )
|
|
{
|
|
if ( pElement && !bIsAttribute )
|
|
{
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, m_pNotify, "Rename Object" );
|
|
pElement->SetName( newString );
|
|
nNotifyFlags = NOTIFY_CHANGE_ATTRIBUTE_VALUE;
|
|
}
|
|
else if ( pOwner && pAttributeName )
|
|
{
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, m_pNotify, "Rename Attribute" );
|
|
pOwner->RenameAttribute( pAttributeName, newString );
|
|
nNotifyFlags = NOTIFY_CHANGE_TOPOLOGICAL;
|
|
}
|
|
}
|
|
|
|
if ( nNotifyFlags )
|
|
{
|
|
Refresh( ( nNotifyFlags == NOTIFY_CHANGE_ATTRIBUTE_VALUE ) ? REFRESH_VALUES_ONLY : REFRESH_TREE_VIEW );
|
|
}
|
|
}
|
|
|
|
bool CElementPropertiesTreeInternal::IsItemDroppable( int itemIndex, CUtlVector< KeyValues * >& msglist )
|
|
{
|
|
KeyValues *itemData = m_pTree->GetItemData( itemIndex );
|
|
if ( !itemData )
|
|
return false;
|
|
|
|
const char *elementType = itemData->GetString( "droppableelementtype" );
|
|
if ( !elementType || !elementType[ 0 ] )
|
|
return false;
|
|
|
|
CUtlVector< CDmElement * > list;
|
|
return ElementTree_GetDroppableItems( msglist, elementType, list );
|
|
}
|
|
|
|
HCursor CElementPropertiesTreeInternal::GetItemDropCursor( int itemIndex, CUtlVector< KeyValues * >& msglist )
|
|
{
|
|
DropOperation_t op = GetDropOperation( itemIndex, msglist );
|
|
if ( op == DO_COPY )
|
|
return m_hDragCopyCursor;
|
|
if ( op == DO_MOVE )
|
|
return m_hDragMoveCursor;
|
|
Assert( op == DO_LINK );
|
|
return m_hDragLinkCursor;
|
|
}
|
|
|
|
struct ArrayItem_t
|
|
{
|
|
ArrayItem_t( CDmAttribute *pAttr = NULL, int nIndex = -1 ) : m_pAttr( pAttr ), m_nIndex( nIndex ) {}
|
|
|
|
static bool LessFunc( const ArrayItem_t &lhs, const ArrayItem_t &rhs )
|
|
{
|
|
if ( lhs.m_pAttr != rhs.m_pAttr )
|
|
return lhs.m_pAttr < rhs.m_pAttr;
|
|
return lhs.m_nIndex < rhs.m_nIndex;
|
|
}
|
|
|
|
CDmAttribute *m_pAttr;
|
|
int m_nIndex;
|
|
};
|
|
|
|
void CElementPropertiesTreeInternal::DropItemsIntoArray( CDmrElementArray<> &array, CUtlVector< KeyValues* > &msglist, CUtlVector< CDmElement* > &list, int nArrayIndex, DropOperation_t op )
|
|
{
|
|
int nElements = list.Count();
|
|
if ( op == DO_COPY )
|
|
{
|
|
CUtlVector< CDmElement* > copylist;
|
|
CopyElements( list, copylist );
|
|
list.Swap( copylist );
|
|
}
|
|
else if ( op == DO_MOVE )
|
|
{
|
|
m_pTree->GetTree()->ClearSelection();
|
|
|
|
CUtlRBTree< ArrayItem_t > arrayItemSorter( 0, msglist.Count(), ArrayItem_t::LessFunc );
|
|
|
|
// sort all element array items and set element attributes to NULL
|
|
int nMsgs = msglist.Count();
|
|
for ( int i = 0; i < nMsgs; ++i )
|
|
{
|
|
KeyValues *itemData = msglist[ i ];
|
|
|
|
CDmElement *pOwner = GetElementKeyValue< CDmElement >( itemData, "ownerelement" );
|
|
const char *pAttributeName = itemData->GetString( "attributeName" );
|
|
|
|
if ( !pOwner || !pAttributeName || !*pAttributeName )
|
|
continue;
|
|
|
|
bool isArrayElement = !itemData->IsEmpty( "arrayIndex" );
|
|
CDmAttribute *pAttribute = pOwner->GetAttribute( pAttributeName, isArrayElement ? AT_ELEMENT_ARRAY : AT_ELEMENT );
|
|
if ( !pAttribute )
|
|
continue;
|
|
|
|
if ( isArrayElement )
|
|
{
|
|
int nIndex = itemData->GetInt( "arrayIndex", -1 );
|
|
if ( nIndex < 0 )
|
|
continue;
|
|
|
|
arrayItemSorter.Insert( ArrayItem_t( pAttribute, nIndex ) );
|
|
}
|
|
else
|
|
{
|
|
pAttribute->SetValue( DMELEMENT_HANDLE_INVALID );
|
|
}
|
|
}
|
|
|
|
// walk through all array items, back to front, so that removing won't mess up the indices
|
|
for ( int i = arrayItemSorter.LastInorder(); i != arrayItemSorter.InvalidIndex(); i = arrayItemSorter.PrevInorder( i ) )
|
|
{
|
|
ArrayItem_t &arrayItem = arrayItemSorter[ i ];
|
|
|
|
CDmrElementArray<> srcArray( arrayItem.m_pAttr );
|
|
srcArray.Remove( arrayItem.m_nIndex );
|
|
|
|
if ( arrayItem.m_pAttr == array.GetAttribute() && arrayItem.m_nIndex < nArrayIndex )
|
|
{
|
|
--nArrayIndex; // update nArrayIndex when items before it are removed
|
|
}
|
|
}
|
|
}
|
|
|
|
int base = array.InsertMultipleBefore( nArrayIndex, nElements );
|
|
// array.SetMultiple( base, nElements, list.Base() );
|
|
for ( int i = 0; i < nElements; ++i )
|
|
{
|
|
array.Set( base + i, list[ i ] );
|
|
if ( array[ base + i ] != list[ i ] )
|
|
{
|
|
// if couldn't be dropped into array, skip it and merge remaining items down by one
|
|
Assert( array[ base + i ] == NULL );
|
|
array.Remove( base + nElements - 1 );
|
|
--base;
|
|
}
|
|
}
|
|
}
|
|
|
|
CElementPropertiesTreeInternal::DropOperation_t CElementPropertiesTreeInternal::GetDropOperation( int itemIndex, CUtlVector< KeyValues * >& msglist )
|
|
{
|
|
bool bCtrlDown = input()->IsKeyDown( KEY_LCONTROL ) || input()->IsKeyDown( KEY_RCONTROL );
|
|
bool bAltDown = input()->IsKeyDown( KEY_LALT ) || input()->IsKeyDown( KEY_RALT );
|
|
bool bShiftDown = input()->IsKeyDown( KEY_LSHIFT ) || input()->IsKeyDown( KEY_RSHIFT );
|
|
|
|
if ( bAltDown || ( bShiftDown && bCtrlDown ) )
|
|
return DO_LINK;
|
|
if ( bCtrlDown )
|
|
return DO_COPY;
|
|
if ( bShiftDown )
|
|
return DO_MOVE;
|
|
|
|
KeyValues *itemData = m_pTree->GetItemData( itemIndex );
|
|
Assert( itemData );
|
|
if ( !itemData )
|
|
return DO_LINK;
|
|
|
|
if ( !ElementTree_IsArrayItem( itemData ) && ElementTree_GetAttributeType( itemData ) != AT_ELEMENT_ARRAY )
|
|
return DO_LINK; // dropping to a non-array attribute
|
|
|
|
DropOperation_t op = DO_UNKNOWN;
|
|
int nMsgs = msglist.Count();
|
|
for ( int i = 0; i < nMsgs; ++i )
|
|
{
|
|
KeyValues *pMsg = msglist[ i ];
|
|
if ( !pMsg || !GetElementKeyValue< CDmElement >( pMsg , "dmeelement" ) )
|
|
continue; // skip non-element drag/drop items
|
|
|
|
if ( !ElementTree_IsArrayItem( pMsg ) || ElementTree_GetAttributeType( pMsg ) != AT_ELEMENT_ARRAY )
|
|
return DO_LINK; // dragging from a non-array attribute
|
|
|
|
op = DO_MOVE; // basically, op will only stay DO_MOVE if *every* item is a non-element or is an array (or array item)
|
|
}
|
|
|
|
if ( op == DO_UNKNOWN )
|
|
{
|
|
Assert( 0 );
|
|
return DO_LINK;
|
|
}
|
|
|
|
return op;
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnItemDropped( int itemIndex, CUtlVector< KeyValues * >& msglist )
|
|
{
|
|
if ( !msglist.Count() )
|
|
return;
|
|
|
|
KeyValues *itemData = m_pTree->GetItemData( itemIndex );
|
|
if ( !itemData )
|
|
return;
|
|
|
|
const char *elementType = itemData->GetString( "droppableelementtype" );
|
|
if ( !elementType || !elementType[ 0 ] )
|
|
return;
|
|
|
|
CUtlVector< CDmElement * > list;
|
|
ElementTree_GetDroppableItems( msglist, "dmeelement", list );
|
|
if ( !list.Count() )
|
|
return;
|
|
|
|
bool isArrayElement = !itemData->IsEmpty( "arrayIndex" );
|
|
//Check to see if this attribute refers to an element
|
|
CDmElement *pOwner = GetElementKeyValue< CDmElement >( itemData, "ownerelement" );
|
|
const char *pAttributeName = itemData->GetString( "attributeName" );
|
|
|
|
if ( !pOwner )
|
|
return;
|
|
|
|
if ( !pAttributeName[ 0 ] )
|
|
return;
|
|
|
|
CDmAttribute *pAttribute = pOwner->GetAttribute( pAttributeName );
|
|
DmAttributeType_t attType = pAttribute ? pAttribute->GetType() : AT_UNKNOWN;
|
|
bool isElementAttribute = attType == AT_ELEMENT || attType == AT_ELEMENT_ARRAY;
|
|
if ( !isElementAttribute )
|
|
return;
|
|
|
|
DropOperation_t op = GetDropOperation( itemIndex, msglist );
|
|
|
|
const char *cmd = msglist[ 0 ]->GetString( "command" );
|
|
|
|
// Mouse if over an array entry which is an element array type...
|
|
if ( isArrayElement )
|
|
{
|
|
bool bReplace = Q_stricmp( cmd, "replace" ) == 0;
|
|
bool bBefore = Q_stricmp( cmd, "before" ) == 0;
|
|
bool bAfter = Q_stricmp( cmd, "after" ) == 0 || Q_stricmp( cmd, "default" ) == 0;
|
|
if ( !bReplace && !bBefore && !bAfter )
|
|
{
|
|
Warning( "Unknown command '%s'\n", cmd );
|
|
return;
|
|
}
|
|
|
|
char str[ 128 ];
|
|
V_snprintf( str, sizeof( str ), "%s %s element%s",
|
|
bReplace ? "Replace with" : "Insert",
|
|
op == DO_COPY ? "copied" : ( op == DO_MOVE ? "moved" : "referenced" ),
|
|
bBefore ? " before" : bAfter ? " after" : "" );
|
|
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, m_pNotify, str );
|
|
|
|
int nArrayIndex = itemData->GetInt( "arrayIndex" );
|
|
if ( bAfter )
|
|
{
|
|
++nArrayIndex;
|
|
}
|
|
|
|
CDmrElementArray<> array( pAttribute );
|
|
if ( bReplace )
|
|
{
|
|
array.Remove( nArrayIndex );
|
|
}
|
|
|
|
DropItemsIntoArray( array, msglist, list, nArrayIndex, op );
|
|
}
|
|
// Mouse is over an element attribute or element array attribute
|
|
else
|
|
{
|
|
// No head/tail stuff for AT_ELEMENT, just replace what's there
|
|
if ( attType == AT_ELEMENT )
|
|
{
|
|
char str[ 128 ];
|
|
V_snprintf( str, sizeof( str ), "Replace with %s element",
|
|
op == DO_COPY ? "copied" : ( op == DO_MOVE ? "moved" : "referenced" ) );
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, m_pNotify, str );
|
|
|
|
pAttribute->SetValue( op == DO_COPY ? list[ 0 ]->Copy() : list[ 0 ] );
|
|
|
|
if ( op == DO_MOVE )
|
|
{
|
|
int c = msglist.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
KeyValues *data = msglist[ i ];
|
|
CDmElement *e = GetElementKeyValue<CDmElement>( data, "dmeelement" );
|
|
Assert( !e || e == list[ 0 ] );
|
|
if ( e != list[ 0 ] )
|
|
continue;
|
|
|
|
OnRemoveFromData( data );
|
|
break;
|
|
}
|
|
m_pTree->GetTree()->ClearSelection();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool bTail = !cmd[ 0 ] || !Q_stricmp( cmd, "default" ) || !Q_stricmp( cmd, "tail" );
|
|
bool bHead = !bTail && !Q_stricmp( cmd, "head" );
|
|
bool bReplace = !bTail && !bHead && !Q_stricmp( cmd, "replace" );
|
|
if ( !bTail && !bHead && !bReplace )
|
|
{
|
|
Warning( "Unknown command '%s'\n", cmd );
|
|
return;
|
|
}
|
|
|
|
char str[ 128 ];
|
|
V_snprintf( str, sizeof( str ), "%s %s elements%s",
|
|
bReplace ? "Replace array with" : "Insert",
|
|
op == DO_COPY ? "copied" : ( op == DO_MOVE ? "moved" : "referenced" ),
|
|
bHead ? " at head" : bTail ? " at tail" : "" );
|
|
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, m_pNotify, str );
|
|
|
|
CDmrElementArray<> array( pAttribute );
|
|
if ( bReplace )
|
|
{
|
|
array.RemoveAll();
|
|
}
|
|
|
|
DropItemsIntoArray( array, msglist, list, bTail ? array.Count() : 0, op );
|
|
}
|
|
}
|
|
|
|
CUtlVector< TreeItem_t > dropTargetPath;
|
|
if ( isArrayElement )
|
|
{
|
|
itemIndex = m_pTree->GetTree()->GetItemParent( itemIndex ); // if we're an array element, start with the array itself
|
|
}
|
|
GetPathToItem( dropTargetPath, itemIndex );
|
|
|
|
// Does a forced refresh
|
|
Refresh( REFRESH_TREE_VIEW );
|
|
|
|
itemIndex = OpenPath( dropTargetPath );
|
|
if ( attType == AT_ELEMENT_ARRAY )
|
|
{
|
|
m_pTree->GetTree()->ExpandItem( itemIndex, true );
|
|
}
|
|
|
|
if ( op == DO_MOVE )
|
|
{
|
|
if ( isArrayElement || attType == AT_ELEMENT_ARRAY )
|
|
{
|
|
int nElements = list.Count();
|
|
for ( int i = 0; i < nElements; ++i )
|
|
{
|
|
int nChildren = m_pTree->GetTree()->GetNumChildren( itemIndex );
|
|
for ( int ci = 0; ci < nChildren; ++ci )
|
|
{
|
|
int nChildItem = m_pTree->GetTree()->GetChild( itemIndex, ci );
|
|
KeyValues *pChildData = m_pTree->GetTree()->GetItemData( nChildItem );
|
|
if ( list[ i ] == GetElementKeyValue< CDmElement >( pChildData, "dmeelement" ) )
|
|
{
|
|
m_pTree->GetTree()->AddSelectedItem( nChildItem, false );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_pTree->GetTree()->AddSelectedItem( itemIndex, true );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CElementPropertiesTreeInternal::GetItemDropContextMenu( int itemIndex, Menu *menu, CUtlVector< KeyValues * >& msglist )
|
|
{
|
|
KeyValues *itemData = m_pTree->GetItemData( itemIndex );
|
|
|
|
bool isArrayElement = !itemData->IsEmpty( "arrayIndex" );
|
|
//Check to see if this attribute refers to an element
|
|
CDmElement *pOwner = GetElementKeyValue<CDmElement>( itemData, "ownerelement" );
|
|
const char *pAttributeName = itemData->GetString( "attributeName" );
|
|
|
|
if ( !pOwner )
|
|
return false;
|
|
if ( !pAttributeName[ 0 ] )
|
|
return false;
|
|
|
|
bool isElementAttribute = false;
|
|
CDmAttribute *pAttribute = pOwner->GetAttribute( pAttributeName );
|
|
DmAttributeType_t attType = pAttribute ? pAttribute->GetType() : AT_UNKNOWN;
|
|
switch ( attType )
|
|
{
|
|
default:
|
|
break;
|
|
case AT_ELEMENT:
|
|
case AT_ELEMENT_ARRAY:
|
|
isElementAttribute = true;
|
|
break;
|
|
}
|
|
|
|
if ( isArrayElement && isElementAttribute )
|
|
{
|
|
menu->AddMenuItem( "After", "Insert after", "after", this );
|
|
menu->AddMenuItem( "Before", "Insert before", "before", this );
|
|
menu->AddMenuItem( "Replace", "Replace", "replace", this );
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if ( isElementAttribute && attType == AT_ELEMENT_ARRAY )
|
|
{
|
|
CDmrGenericArray array( pAttribute );
|
|
if ( array.IsValid() && array.Count() > 0 )
|
|
{
|
|
menu->AddMenuItem( "Tail", "Insert at tail", "tail", this );
|
|
menu->AddMenuItem( "Head", "Insert at head", "head", this );
|
|
menu->AddMenuItem( "Replace", "Replace", "replace", this );
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Set/get object
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::SetObject( CDmElement *object )
|
|
{
|
|
m_pTree->RemoveAll();
|
|
m_AttributeWidgets.RemoveAll();
|
|
|
|
AddToHistory( object );
|
|
|
|
m_hObject = object;
|
|
|
|
Init( );
|
|
}
|
|
|
|
CDmElement *CElementPropertiesTreeInternal::GetObject()
|
|
{
|
|
return m_hObject.Get();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Gets tree view text
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::GetTreeViewText( CDmElement* obj, CDmAttribute *pAttribute, int nArrayIndex, char *pBuffer, int nMaxLen, bool& editableText )
|
|
{
|
|
pBuffer[0] = 0;
|
|
|
|
editableText = false;
|
|
|
|
if ( !obj )
|
|
return;
|
|
|
|
const char *pAttributeName = pAttribute->GetName();
|
|
|
|
if ( nArrayIndex < 0 )
|
|
{
|
|
// non-array types
|
|
Q_strncpy( pBuffer, pAttributeName, nMaxLen );
|
|
|
|
editableText = !pAttribute->IsFlagSet( FATTRIB_EXTERNAL ) && !pAttribute->IsFlagSet( FATTRIB_READONLY );
|
|
}
|
|
else
|
|
{
|
|
// array types
|
|
DmAttributeType_t type = pAttribute->GetType( );
|
|
if ( type == AT_ELEMENT_ARRAY )
|
|
{
|
|
const CDmrElementArray<> elementArray( pAttribute );
|
|
CDmElement *pEntryElement = elementArray[nArrayIndex];
|
|
if ( pEntryElement )
|
|
{
|
|
Q_snprintf( pBuffer, nMaxLen, "%s", pEntryElement->GetValueString( "name" ) );
|
|
editableText = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Q_snprintf( pBuffer, nMaxLen, "%s[%d]", pAttributeName, nArrayIndex );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Finds the tree index of a child matching the particular element + attribute
|
|
//-----------------------------------------------------------------------------
|
|
int CElementPropertiesTreeInternal::FindTreeItem( int nParentIndex, const TreeItem_t &info )
|
|
{
|
|
// Look for a match
|
|
int nCount = m_pTree->GetTree()->GetNumChildren( nParentIndex );
|
|
for ( int i = nCount; --i >= 0; )
|
|
{
|
|
int nChildIndex = m_pTree->GetTree()->GetChild( nParentIndex, i );
|
|
KeyValues *data = m_pTree->GetItemData( nChildIndex );
|
|
Assert( data );
|
|
|
|
CDmElement *pElement = GetElementKeyValue< CDmElement >( data, "ownerelement" );
|
|
const char *pAttributeName = data->GetString( "attributeName" );
|
|
CDmElement *pArrayElement = NULL;
|
|
if ( data->GetInt( "arrayIndex", -1 ) != -1 )
|
|
{
|
|
// Only arrays of element pointers should refer to this
|
|
pArrayElement = GetElementKeyValue< CDmElement >( data, "dmeelement" );
|
|
}
|
|
|
|
if ( ( pElement == info.m_pElement ) && ( pArrayElement == info.m_pArrayElement ) &&
|
|
!Q_stricmp( pAttributeName, info.m_pAttributeName ) )
|
|
{
|
|
return nChildIndex;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::SpewOpenItems( int depth, OpenItemTree_t &tree, int nOpenTreeIndex, int nItemIndex )
|
|
{
|
|
int i = tree.FirstChild( nOpenTreeIndex );
|
|
if ( nOpenTreeIndex != tree.InvalidIndex() )
|
|
{
|
|
TreeInfo_t& info = tree[ nOpenTreeIndex ];
|
|
|
|
if ( info.m_nFlags & EP_EXPANDED )
|
|
{
|
|
Msg( "[%d] Marking %s <%s> %s array(%s) [expanded %i]\n",
|
|
depth,
|
|
info.m_Item.m_pElement->GetName(),
|
|
info.m_Item.m_pElement->GetTypeString(),
|
|
info.m_Item.m_pAttributeName.Get(),
|
|
info.m_Item.m_pArrayElement ? info.m_Item.m_pArrayElement->GetName() : "NULL",
|
|
info.m_nFlags & EP_EXPANDED ? 1 : 0 );
|
|
}
|
|
}
|
|
|
|
while ( i != tree.InvalidIndex() )
|
|
{
|
|
TreeInfo_t& info = tree[ i ];
|
|
// Look for a match
|
|
int nChildIndex = FindTreeItem( nItemIndex, info.m_Item );
|
|
if ( nChildIndex != -1 )
|
|
{
|
|
SpewOpenItems( depth + 1, tree, i, nChildIndex );
|
|
}
|
|
else
|
|
{
|
|
}
|
|
i = tree.NextSibling( i );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Expands all items in the open item tree if they exist
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::ExpandOpenItems( OpenItemTree_t &tree, int nOpenTreeIndex, int nItemIndex, bool makeVisible )
|
|
{
|
|
int i = tree.FirstChild( nOpenTreeIndex );
|
|
if ( nOpenTreeIndex != tree.InvalidIndex() )
|
|
{
|
|
TreeInfo_t& info = tree[ nOpenTreeIndex ];
|
|
if ( info.m_nFlags & EP_EXPANDED )
|
|
{
|
|
// Expand the item
|
|
m_pTree->ExpandItem( nItemIndex , true );
|
|
}
|
|
if ( info.m_nFlags & EP_SELECTED )
|
|
{
|
|
m_pTree->GetTree()->AddSelectedItem( nItemIndex, false, false );
|
|
if ( makeVisible )
|
|
{
|
|
m_pTree->GetTree()->MakeItemVisible( nItemIndex );
|
|
}
|
|
}
|
|
}
|
|
|
|
while ( i != tree.InvalidIndex() )
|
|
{
|
|
TreeInfo_t& info = tree[ i ];
|
|
// Look for a match
|
|
int nChildIndex = FindTreeItem( nItemIndex, info.m_Item );
|
|
if ( nChildIndex != -1 )
|
|
{
|
|
ExpandOpenItems( tree, i, nChildIndex, makeVisible );
|
|
}
|
|
else
|
|
{
|
|
if ( info.m_nFlags & EP_SELECTED )
|
|
{
|
|
// Look for preserved item
|
|
int nChildIndex = FindTreeItem( nItemIndex, info.m_Preserved );
|
|
if ( nChildIndex != -1 )
|
|
{
|
|
m_pTree->GetTree()->AddSelectedItem( nChildIndex, false, false );
|
|
if ( makeVisible )
|
|
{
|
|
m_pTree->GetTree()->MakeItemVisible( nChildIndex );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
i = tree.NextSibling( i );
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::FillInDataForItem( TreeItem_t &item, int nItemIndex )
|
|
{
|
|
KeyValues *data = m_pTree->GetItemData( nItemIndex );
|
|
if ( !data )
|
|
return;
|
|
|
|
item.m_pElement = GetElementKeyValue< CDmElement >( data, "ownerelement" );
|
|
item.m_pAttributeName = data->GetString( "attributeName" );
|
|
if ( data->GetInt( "arrayIndex", -1 ) != -1 )
|
|
{
|
|
// Only arrays of element pointers should refer to this
|
|
item.m_pArrayElement = GetElementKeyValue< CDmElement >( data, "dmeelement" );
|
|
}
|
|
else
|
|
{
|
|
item.m_pArrayElement = NULL;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Builds a list of open items
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::BuildOpenItemList( OpenItemTree_t &tree, int nParent, int nItemIndex, bool preservePrevSelectedItem )
|
|
{
|
|
KeyValues *data = m_pTree->GetItemData( nItemIndex );
|
|
if ( !data )
|
|
return;
|
|
|
|
bool expanded = m_pTree->IsItemExpanded( nItemIndex );
|
|
bool selected = m_pTree->IsItemSelected( nItemIndex );
|
|
|
|
int flags = 0;
|
|
if ( expanded )
|
|
{
|
|
flags |= EP_EXPANDED;
|
|
}
|
|
if ( selected )
|
|
{
|
|
flags |= EP_SELECTED;
|
|
}
|
|
|
|
int nChild = tree.InsertChildAfter( nParent, tree.InvalidIndex() );
|
|
TreeInfo_t &info = tree[nChild];
|
|
FillInDataForItem( info.m_Item, nItemIndex );
|
|
info.m_nFlags = flags;
|
|
|
|
if ( selected )
|
|
{
|
|
// Set up prev an next item
|
|
int preserve = preservePrevSelectedItem
|
|
? m_pTree->GetTree()->GetPrevChildItemIndex( nItemIndex ) :
|
|
m_pTree->GetTree()->GetNextChildItemIndex( nItemIndex );
|
|
|
|
if ( preserve != -1 )
|
|
{
|
|
FillInDataForItem( info.m_Preserved, preserve );
|
|
}
|
|
}
|
|
|
|
// Deal with children
|
|
int nCount = m_pTree->GetTree()->GetNumChildren( nItemIndex );
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
int nChildIndex = m_pTree->GetTree()->GetChild( nItemIndex, i );
|
|
BuildOpenItemList( tree, nChild, nChildIndex, preservePrevSelectedItem );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Builds a list of open items
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::RefreshTreeView( bool preservePrevSelectedItem /*= false*/ )
|
|
{
|
|
int nIndex = m_pTree->GetTree()->GetRootItemIndex();
|
|
if ( nIndex >= 0 )
|
|
{
|
|
// remember where the tree is scrolled to
|
|
ScrollBar *sBar = ((CElementTree *)m_pTree->GetTree())->GetScrollBar();
|
|
int sBarPos = sBar->GetValue();
|
|
|
|
// Build a tree of every open item in the tree view
|
|
OpenItemTree_t openItems;
|
|
BuildOpenItemList( openItems, openItems.InvalidIndex(), nIndex, preservePrevSelectedItem );
|
|
|
|
// Close the tree and re-create the root node only
|
|
UpdateTree();
|
|
|
|
// NOTE: Updating the tree could have changed the root item index
|
|
nIndex = m_pTree->GetTree()->GetRootItemIndex();
|
|
|
|
// Iterate through all previously open items and expand them if they exist
|
|
if ( openItems.Root() != openItems.InvalidIndex() )
|
|
{
|
|
ExpandOpenItems( openItems, openItems.Root(), nIndex, false );
|
|
}
|
|
|
|
// and now set the scroll pos back to where is was
|
|
// note: the layout needs to be re-Performed so that the
|
|
// scrollbars _range values are corrent or the SetValue will fail.
|
|
m_pTree->GetTree()->PerformLayout();
|
|
sBar->SetValue( sBarPos );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Refreshes the color state of the tree
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::SetTreeItemColor( int nItemID, CDmElement *pEntryElement, bool bIsElementArrayItem, bool bEditableLabel )
|
|
{
|
|
// dim any element tree items if they are muted or not visible
|
|
bool bIsDim = false;
|
|
int dimAlpha = 128;
|
|
if ( pEntryElement != NULL )
|
|
{
|
|
if ( ( pEntryElement->HasAttribute( "visible" ) && !pEntryElement->GetValue< bool >( "visible" ) )
|
|
|| ( pEntryElement->HasAttribute( "mute" ) && pEntryElement->GetValue< bool >( "mute" ) ) )
|
|
{
|
|
bIsDim = true;
|
|
}
|
|
}
|
|
|
|
// the unfocused Bg color should match the focused one
|
|
// so that we can dim lables based on visibility and mute state.
|
|
// note: focus is unimportant in this context ( I'm pretty sure )
|
|
m_pTree->GetTree()->SetItemSelectionBgColor( nItemID, Color( 255, 153, 35, bIsDim ? dimAlpha : 255 ) );
|
|
m_pTree->GetTree()->SetItemSelectionUnfocusedBgColor( nItemID, Color( 255, 153, 35, bIsDim ? dimAlpha : 255 ) );
|
|
|
|
if ( bIsElementArrayItem )
|
|
{
|
|
// element array items are green
|
|
m_pTree->GetTree()->SetItemFgColor( nItemID, Color( 66, 196, 66, bIsDim ? dimAlpha : 255 ) );
|
|
}
|
|
else if ( bEditableLabel )
|
|
{
|
|
// custom attributes are light yellow
|
|
m_pTree->GetTree()->SetItemFgColor( nItemID, Color( 190, 190, 105, bIsDim ? dimAlpha : 255 ) );
|
|
}
|
|
else
|
|
{
|
|
// otherwise it's just light grey
|
|
m_pTree->GetTree()->SetItemFgColor( nItemID, Color( 160, 160, 160, bIsDim ? dimAlpha : 255 ) );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Refreshes the color state of the tree
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::RefreshTreeItemState( int nItemID )
|
|
{
|
|
if ( nItemID < 0 )
|
|
return;
|
|
|
|
KeyValues *kv = m_pTree->GetTree()->GetItemData( nItemID );
|
|
CDmElement *pEntryElement = GetElementKeyValue<CDmElement>( kv, "dmeelement" );
|
|
bool bIsElementArrayItem = kv->GetInt( "elementArrayItem", 0 );
|
|
bool bEditableLabel = kv->GetInt( "editablelabel", 0 );
|
|
SetTreeItemColor( nItemID, pEntryElement, bIsElementArrayItem, bEditableLabel );
|
|
|
|
int nChildCount = m_pTree->GetTree()->GetNumChildren( nItemID );
|
|
for ( int i = 0; i < nChildCount; ++i )
|
|
{
|
|
int nChildID = m_pTree->GetTree()->GetChild( nItemID, i );
|
|
RefreshTreeItemState( nChildID );
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
//-----------------------------------------------------------------------------
|
|
// Adds a single entry into the tree
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::SetTreeEntryDimState( )
|
|
{
|
|
|
|
}
|
|
*/
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Adds a single entry into the tree
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::CreateTreeEntry( int parentNodeIndex, CDmElement* obj, CDmAttribute *pAttribute, int nArrayIndex, AttributeWidgets_t &widgets )
|
|
{
|
|
char pText[ 512 ];
|
|
bool bEditableLabel = false;
|
|
bool bIsExpandable = false;
|
|
CDmElement *pEntryElement = NULL;
|
|
|
|
GetTreeViewText( obj, pAttribute, nArrayIndex, pText, sizeof(pText), bEditableLabel );
|
|
|
|
const char *pAttributeName = pAttribute->GetName();
|
|
DmAttributeType_t type = pAttribute->GetType( );
|
|
|
|
bool bIsArrayItem = ( nArrayIndex > -1 );
|
|
bool bIsArrayAttribute = ( type >= AT_FIRST_ARRAY_TYPE ) && ! bIsArrayItem;
|
|
bool bIsElementAttribute = ( type == AT_ELEMENT ) && ! bIsArrayItem;
|
|
bool bIsElementArrayItem = ( type == AT_ELEMENT_ARRAY ) && bIsArrayItem;
|
|
bool bIsElementArrayAttribute = ( type == AT_ELEMENT_ARRAY ) && ! bIsArrayItem;
|
|
|
|
bool bIsDroppable = bIsElementArrayItem || bIsElementAttribute || bIsElementArrayAttribute;
|
|
|
|
if ( bIsElementArrayItem )
|
|
{
|
|
const CDmrElementArray<> elementArray( pAttribute );
|
|
pEntryElement = elementArray[nArrayIndex];
|
|
bIsExpandable = true;
|
|
}
|
|
else if ( bIsElementAttribute )
|
|
{
|
|
pEntryElement = obj->GetValueElement< CDmElement>( pAttributeName );
|
|
bIsExpandable = ( pEntryElement != NULL );
|
|
}
|
|
else if ( bIsArrayAttribute )
|
|
{
|
|
CDmrGenericArray array( pAttribute );
|
|
bIsExpandable = array.Count() > 0;
|
|
}
|
|
|
|
KeyValues *kv = new KeyValues( "item" );
|
|
kv->SetString( "Text", pText );
|
|
kv->SetInt( "Expand", bIsExpandable );
|
|
SetElementKeyValue( kv, "dmeelement", pEntryElement );
|
|
SetElementKeyValue( kv, "ownerelement", obj );
|
|
kv->SetString( "attributeName", pAttributeName );
|
|
kv->SetPtr( "widget", widgets.m_pValueWidget );
|
|
kv->SetInt( "elementArrayItem", bIsElementArrayItem ? 1 : 0 );
|
|
kv->SetInt( "editablelabel", bEditableLabel ? 1 : 0 );
|
|
kv->SetInt( "isAttribute", bIsArrayItem ? 0 : 1 );
|
|
kv->SetInt( "droppable", bIsDroppable ? 1 : 0 );
|
|
kv->SetFloat( "drophoverdelay", 1.0f );
|
|
|
|
if ( bIsArrayItem )
|
|
{
|
|
kv->SetInt( "arrayIndex", nArrayIndex );
|
|
}
|
|
|
|
if ( bIsDroppable )
|
|
{
|
|
// Can always drop onto arrays
|
|
kv->SetString( "droppableelementtype", "dmeelement" ); // FIXME: Should be able to restrict to certain types!!!
|
|
}
|
|
|
|
CUtlVector< vgui::Panel * > columns;
|
|
columns.AddToTail( NULL );
|
|
columns.AddToTail( widgets.m_pValueWidget );
|
|
int itemIndex = m_pTree->AddItem( kv, bEditableLabel, parentNodeIndex, columns );
|
|
SetTreeItemColor( itemIndex, pEntryElement, bIsElementArrayItem, bEditableLabel );
|
|
kv->deleteThis();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets up the attribute widget init info for a particular attribute
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::SetupWidgetInfo( AttributeWidgetInfo_t *pInfo, CDmElement *obj, CDmAttribute *pAttribute, int nArrayIndex )
|
|
{
|
|
const char *pAttributeName = pAttribute ? pAttribute->GetName() : "";
|
|
|
|
pInfo->m_pNotify = m_pNotify;
|
|
pInfo->m_bAutoApply = m_bAutoApply;
|
|
pInfo->m_pElement = obj;
|
|
pInfo->m_pAttributeName = pAttributeName;
|
|
pInfo->m_nArrayIndex = nArrayIndex;
|
|
pInfo->m_pEditorTypeDictionary = m_hTypeDictionary;
|
|
pInfo->m_pEditorInfo = NULL;
|
|
pInfo->m_bShowMemoryUsage = m_bShowMemoryUsage;
|
|
if ( m_hTypeDictionary && pAttributeName )
|
|
{
|
|
if ( nArrayIndex < 0 )
|
|
{
|
|
pInfo->m_pEditorInfo = m_hTypeDictionary->GetAttributeInfo( obj, pAttributeName );
|
|
}
|
|
else
|
|
{
|
|
pInfo->m_pEditorInfo = m_hTypeDictionary->GetAttributeArrayInfo( obj, pAttributeName );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Adds a single editable attributes of the element to the tree
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::InsertSingleAttribute( int parentNodeIndex, CDmElement *obj, CDmAttribute *pAttribute, int nArrayIndex )
|
|
{
|
|
const char *attributeName = pAttribute->GetName();
|
|
NOTE_UNUSED( attributeName );
|
|
|
|
// Get information about the widget to create
|
|
|
|
IAttributeWidgetFactory *pFactory = NULL;
|
|
if ( nArrayIndex >= 0 )
|
|
{
|
|
pFactory = attributewidgetfactorylist->GetArrayWidgetFactory( obj, pAttribute, m_hTypeDictionary );
|
|
}
|
|
else
|
|
{
|
|
pFactory = attributewidgetfactorylist->GetWidgetFactory( obj, pAttribute, m_hTypeDictionary );
|
|
}
|
|
if ( !pFactory )
|
|
return;
|
|
|
|
// Create the widget
|
|
AttributeWidgetInfo_t info;
|
|
SetupWidgetInfo( &info, obj, pAttribute, nArrayIndex );
|
|
|
|
AttributeWidgets_t attributeWidget;
|
|
attributeWidget.m_pValueWidget = pFactory->Create( NULL, info );
|
|
|
|
// set it to the current font size
|
|
CBaseAttributePanel *attrPanel = dynamic_cast< CBaseAttributePanel * >( attributeWidget.m_pValueWidget );
|
|
if ( attrPanel )
|
|
{
|
|
attrPanel->SetFont( m_pTree->GetFont( m_pTree->GetFontSize() ) );
|
|
}
|
|
|
|
// Now create the tree-view entry
|
|
CreateTreeEntry( parentNodeIndex, obj, pAttribute, nArrayIndex, attributeWidget );
|
|
|
|
// Add the attribute to the list of them
|
|
m_AttributeWidgets.AddToTail( attributeWidget );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Used to insert attributes in alphabetical order
|
|
//-----------------------------------------------------------------------------
|
|
struct AttributeInfo_t
|
|
{
|
|
CDmAttribute *m_pAttribute;
|
|
const char *m_pName;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Adds editable attributes of the element to the tree
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::InsertAttributes( int parentNodeIndex, CDmElement *obj )
|
|
{
|
|
Assert( obj );
|
|
|
|
// Build a list of attributes for sorting
|
|
AttributeInfo_t *pInfo = (AttributeInfo_t*)_alloca( obj->AttributeCount() * sizeof(AttributeInfo_t) );
|
|
int nCount = 0;
|
|
for ( CDmAttribute *pAttribute = obj->FirstAttribute(); pAttribute; pAttribute = pAttribute->NextAttribute() )
|
|
{
|
|
pInfo[nCount].m_pAttribute = pAttribute;
|
|
pInfo[nCount].m_pName = pAttribute->GetName();
|
|
++nCount;
|
|
}
|
|
|
|
// Iterate over each element and create a widget and tree entry for it
|
|
for ( int i = nCount - 1; i >= 0; --i )
|
|
{
|
|
InsertSingleAttribute( parentNodeIndex, obj, pInfo[i].m_pAttribute );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Removes an item from the tree recursively
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::RemoveItem_R( int nItemIndex )
|
|
{
|
|
KeyValues *data = m_pTree->GetItemData( nItemIndex );
|
|
if ( data )
|
|
{
|
|
AttributeWidgets_t search;
|
|
search.m_pValueWidget = static_cast<vgui::Panel*>( data->GetPtr( "widget", NULL ) );
|
|
if ( search.m_pValueWidget )
|
|
{
|
|
m_AttributeWidgets.FindAndRemove( search );
|
|
}
|
|
}
|
|
|
|
int nCount = m_pTree->GetTree()->GetNumChildren( nItemIndex );
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
RemoveItem_R( m_pTree->GetTree()->GetChild( nItemIndex, i ) );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Removes an item from the tree
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::RemoveItem( int nItemIndex )
|
|
{
|
|
RemoveItem_R( nItemIndex );
|
|
m_pTree->RemoveItem( nItemIndex );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Adds editable attribute array entries to the tree
|
|
//-----------------------------------------------------------------------------
|
|
void CElementPropertiesTreeInternal::InsertAttributeArrayMembers( int parentNodeIndex, CDmElement *obj, CDmAttribute *pAttribute )
|
|
{
|
|
Assert( obj );
|
|
|
|
// Iterate over each element and create a widget and tree entry for it
|
|
CDmrGenericArray array( pAttribute );
|
|
int c = array.Count();
|
|
for ( int i = 0; i < c; i++ )
|
|
{
|
|
InsertSingleAttribute( parentNodeIndex, obj, pAttribute, i );
|
|
}
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnKeyDelete()
|
|
{
|
|
RemoveSelected( false );
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::OnKeyBackspace()
|
|
{
|
|
RemoveSelected( true );
|
|
}
|
|
|
|
void CElementPropertiesTreeInternal::RemoveSelected( bool selectLeft )
|
|
{
|
|
CElementTreeUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, m_pNotify, "Delete Items" );
|
|
|
|
CUtlVector< KeyValues * > itemData;
|
|
m_pTree->GetTree()->GetSelectedItemData( itemData );
|
|
bool bRefreshNeeded = OnRemoveFromData( itemData );
|
|
|
|
if ( itemData.Count() > 1 )
|
|
{
|
|
// dont try to maintain the selection if multiple items are selected
|
|
m_pTree->GetTree()->ClearSelection();
|
|
}
|
|
|
|
if ( bRefreshNeeded )
|
|
{
|
|
// Refresh the tree
|
|
Refresh( REFRESH_TREE_VIEW, selectLeft );
|
|
}
|
|
}
|
|
|
|
bool CElementPropertiesTreeInternal::IsLabelBeingEdited() const
|
|
{
|
|
return m_pTree->GetTree()->IsLabelBeingEdited();
|
|
}
|
|
|
|
bool CElementPropertiesTreeInternal::HasItemsSelected() const
|
|
{
|
|
return m_pTree->GetTree()->GetSelectedItemCount() > 0 ? true : false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// protected accessors
|
|
//-----------------------------------------------------------------------------
|
|
KeyValues *CElementPropertiesTreeInternal::GetTreeItemData( int itemIndex )
|
|
{
|
|
return m_pTree->GetItemData( itemIndex );
|
|
}
|
|
|
|
|
|
void CElementPropertiesTreeInternal::OnRefresh()
|
|
{
|
|
// Does a forced refresh
|
|
Refresh( REFRESH_TREE_VIEW );
|
|
|
|
CElementTreeNotifyScopeGuard notify( "CElementPropertiesTreeInternal::OnRefresh", NOTIFY_SETDIRTYFLAG | NOTIFY_CHANGE_TOPOLOGICAL, m_pNotify );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// CElementPropertiesTree methods
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CElementPropertiesTree::CElementPropertiesTree( vgui::Panel *parent, IDmNotify *pNotify, CDmElement *pObject, CDmeEditorTypeDictionary *pDict )
|
|
: BaseClass( parent, "ElementPropertiesTreeFrame" )
|
|
{
|
|
SetTitle( "#BxElementPropertiesTree", true );
|
|
|
|
SetSizeable( true );
|
|
SetCloseButtonVisible( false );
|
|
SetMinimumSize( 600, 200 );
|
|
|
|
m_pProperties = new CElementPropertiesTreeInternal( this, pNotify, pObject, false, pDict );
|
|
|
|
m_pOK = new Button( this, "OK", "OK", this, "close" );
|
|
m_pApply = new Button( this, "Apply", "Apply", this, "apply" );
|
|
m_pCancel = new Button( this, "Cancel", "Cancel", this, "cancel" );
|
|
|
|
SetScheme( vgui::scheme()->LoadSchemeFromFile( "Resource/BoxRocket.res", "BoxRocket" ) );
|
|
LoadControlSettings( "resource/BxElementPropertiesTreeFrame.res" );
|
|
}
|
|
|
|
void CElementPropertiesTree::Init( )
|
|
{
|
|
m_pProperties->Init( );
|
|
}
|
|
|
|
void CElementPropertiesTree::ActivateBuildMode()
|
|
{
|
|
BaseClass::ActivateBuildMode();
|
|
m_pProperties->ActivateBuildMode();
|
|
}
|
|
|
|
void CElementPropertiesTree::Refresh( CElementPropertiesTreeInternal::RefreshType_t rebuild /* = REFRESH_REBUILD */, bool preservePrevSelectedItem /*= false*/ )
|
|
{
|
|
m_pProperties->Refresh( rebuild, preservePrevSelectedItem );
|
|
}
|
|
|
|
void CElementPropertiesTree::GenerateChildrenOfNode(int itemIndex)
|
|
{
|
|
m_pProperties->GenerateChildrenOfNode( itemIndex );
|
|
}
|
|
|
|
void CElementPropertiesTree::SetObject( CDmElement *object )
|
|
{
|
|
m_pProperties->SetObject( object );
|
|
}
|
|
|
|
void CElementPropertiesTree::OnCommand( const char *cmd )
|
|
{
|
|
if ( !Q_stricmp( cmd, "close" ) )
|
|
{
|
|
m_pProperties->ApplyChanges();
|
|
MarkForDeletion();
|
|
}
|
|
else if ( !Q_stricmp( cmd, "apply" ) )
|
|
{
|
|
m_pProperties->ApplyChanges();
|
|
m_pProperties->Refresh();
|
|
}
|
|
else if ( !Q_stricmp( cmd, "cancel" ) )
|
|
{
|
|
MarkForDeletion();
|
|
}
|
|
else
|
|
{
|
|
BaseClass::OnCommand( cmd );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Hook this into the DmePanel editing system
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
IMPLEMENT_DMEPANEL_FACTORY( CDmeElementPanel, DmElement, "DmeElementDefault", "Dme Element Editor", true );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructor
|
|
//-----------------------------------------------------------------------------
|
|
#pragma warning (disable:4355)
|
|
CDmeElementPanel::CDmeElementPanel( vgui::Panel *pParent, const char *pPanelName ) :
|
|
BaseClass( pParent, this, NULL )
|
|
{
|
|
}
|
|
#pragma warning (default:4355)
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when the panel changes something
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeElementPanel::NotifyDataChanged( const char *pReason, int nNotifySource, int nNotifyFlags )
|
|
{
|
|
if ( nNotifyFlags & ( NOTIFY_CHANGE_TOPOLOGICAL | NOTIFY_CHANGE_ATTRIBUTE_VALUE | NOTIFY_CHANGE_ATTRIBUTE_ARRAY_SIZE ) )
|
|
{
|
|
KeyValues *pKeyValues = new KeyValues( "DmeElementChanged", "notifyFlags", nNotifyFlags );
|
|
pKeyValues->SetString( "reason", pReason );
|
|
pKeyValues->SetInt( "source", nNotifySource );
|
|
PostActionSignal( pKeyValues );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called by the DmePanel framework to hook an element to this
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeElementPanel::SetDmeElement( CDmElement *pElement )
|
|
{
|
|
SetObject( pElement );
|
|
}
|