1676 lines
42 KiB
C++
1676 lines
42 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include <vgui/IBorder.h>
|
|
#include <vgui/IInput.h>
|
|
#include <vgui/IPanel.h>
|
|
#include <vgui/IScheme.h>
|
|
#include <vgui/ISystem.h>
|
|
#include <vgui/IVGui.h>
|
|
#include <vgui/KeyCode.h>
|
|
#include <KeyValues.h>
|
|
#include <vgui/MouseCode.h>
|
|
#include <vgui/ISurface.h>
|
|
#include <vgui_controls/Button.h>
|
|
#include <vgui_controls/Controls.h>
|
|
#include <vgui_controls/Label.h>
|
|
#include <vgui_controls/PropertySheet.h>
|
|
#include <vgui_controls/ComboBox.h>
|
|
#include <vgui_controls/Panel.h>
|
|
#include <vgui_controls/ToolWindow.h>
|
|
#include <vgui_controls/TextImage.h>
|
|
#include <vgui_controls/ImagePanel.h>
|
|
#include <vgui_controls/PropertyPage.h>
|
|
#include "vgui_controls/AnimationController.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
using namespace vgui;
|
|
|
|
namespace vgui
|
|
{
|
|
|
|
class ContextLabel : public Label
|
|
{
|
|
DECLARE_CLASS_SIMPLE( ContextLabel, Label );
|
|
public:
|
|
|
|
ContextLabel( Button *parent, char const *panelName, char const *text ):
|
|
BaseClass( (Panel *)parent, panelName, text ),
|
|
m_pTabButton( parent )
|
|
{
|
|
SetBlockDragChaining( true );
|
|
}
|
|
|
|
virtual void OnMousePressed( MouseCode code )
|
|
{
|
|
if ( m_pTabButton )
|
|
{
|
|
m_pTabButton->FireActionSignal();
|
|
}
|
|
}
|
|
|
|
virtual void OnMouseReleased( MouseCode code )
|
|
{
|
|
BaseClass::OnMouseReleased( code );
|
|
|
|
if ( GetParent() )
|
|
{
|
|
GetParent()->OnCommand( "ShowContextMenu" );
|
|
}
|
|
}
|
|
|
|
virtual void ApplySchemeSettings( IScheme *pScheme )
|
|
{
|
|
BaseClass::ApplySchemeSettings( pScheme );
|
|
|
|
HFont marlett = pScheme->GetFont( "Marlett" );
|
|
SetFont( marlett );
|
|
SetTextInset( 0, 0 );
|
|
SetContentAlignment( Label::a_northwest );
|
|
|
|
if ( GetParent() )
|
|
{
|
|
SetFgColor( pScheme->GetColor( "Button.TextColor", GetParent()->GetFgColor() ) );
|
|
SetBgColor( GetParent()->GetBgColor() );
|
|
}
|
|
}
|
|
private:
|
|
|
|
Button *m_pTabButton;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Helper for drag drop
|
|
// Input : msglist -
|
|
// Output : static PropertySheet
|
|
//-----------------------------------------------------------------------------
|
|
static PropertySheet *IsDroppingSheet( CUtlVector< KeyValues * >& msglist )
|
|
{
|
|
if ( msglist.Count() == 0 )
|
|
return NULL;
|
|
|
|
KeyValues *data = msglist[ 0 ];
|
|
PropertySheet *sheet = reinterpret_cast< PropertySheet * >( data->GetPtr( "propertysheet" ) );
|
|
if ( sheet )
|
|
return sheet;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: A single tab
|
|
//-----------------------------------------------------------------------------
|
|
class PageTab : public Button
|
|
{
|
|
DECLARE_CLASS_SIMPLE( PageTab, Button );
|
|
|
|
private:
|
|
bool _active;
|
|
Color _textColor;
|
|
Color _dimTextColor;
|
|
int m_bMaxTabWidth;
|
|
IBorder *m_pActiveBorder;
|
|
IBorder *m_pNormalBorder;
|
|
PropertySheet *m_pParent;
|
|
Panel *m_pPage;
|
|
ImagePanel *m_pImage;
|
|
char *m_pszImageName;
|
|
bool m_bShowContextLabel;
|
|
bool m_bAttemptingDrop;
|
|
ContextLabel *m_pContextLabel;
|
|
long m_hoverActivatePageTime;
|
|
long m_dropHoverTime;
|
|
|
|
public:
|
|
PageTab(PropertySheet *parent, const char *panelName, const char *text, char const *imageName, int maxTabWidth, Panel *page, bool showContextButton, long hoverActivatePageTime = -1 ) :
|
|
Button( (Panel *)parent, panelName, text),
|
|
m_pParent( parent ),
|
|
m_pPage( page ),
|
|
m_pImage( 0 ),
|
|
m_pszImageName( 0 ),
|
|
m_bShowContextLabel( showContextButton ),
|
|
m_bAttemptingDrop( false ),
|
|
m_hoverActivatePageTime( hoverActivatePageTime ),
|
|
m_dropHoverTime( -1 )
|
|
{
|
|
SetCommand(new KeyValues("TabPressed"));
|
|
_active = false;
|
|
m_bMaxTabWidth = maxTabWidth;
|
|
SetDropEnabled( true );
|
|
SetDragEnabled( m_pParent->IsDraggableTab() );
|
|
if ( imageName )
|
|
{
|
|
m_pImage = new ImagePanel( this, text );
|
|
int buflen = Q_strlen( imageName ) + 1;
|
|
m_pszImageName = new char[ buflen ];
|
|
Q_strncpy( m_pszImageName, imageName, buflen );
|
|
|
|
}
|
|
SetMouseClickEnabled( MOUSE_RIGHT, true );
|
|
m_pContextLabel = m_bShowContextLabel ? new ContextLabel( this, "Context", "9" ) : NULL;
|
|
|
|
REGISTER_COLOR_AS_OVERRIDABLE( _textColor, "selectedcolor" );
|
|
REGISTER_COLOR_AS_OVERRIDABLE( _dimTextColor, "unselectedcolor" );
|
|
}
|
|
|
|
~PageTab()
|
|
{
|
|
delete[] m_pszImageName;
|
|
}
|
|
|
|
virtual void Paint()
|
|
{
|
|
BaseClass::Paint();
|
|
}
|
|
|
|
virtual void OnCursorEntered()
|
|
{
|
|
m_dropHoverTime = system()->GetTimeMillis();
|
|
}
|
|
|
|
virtual void OnCursorExited()
|
|
{
|
|
m_dropHoverTime = -1;
|
|
}
|
|
|
|
virtual void OnThink()
|
|
{
|
|
if ( m_bAttemptingDrop && m_hoverActivatePageTime >= 0 && m_dropHoverTime >= 0 )
|
|
{
|
|
long hoverTime = system()->GetTimeMillis() - m_dropHoverTime;
|
|
if ( hoverTime > m_hoverActivatePageTime )
|
|
{
|
|
FireActionSignal();
|
|
SetSelected(true);
|
|
Repaint();
|
|
}
|
|
}
|
|
m_bAttemptingDrop = false;
|
|
|
|
BaseClass::OnThink();
|
|
}
|
|
|
|
virtual bool IsDroppable( CUtlVector< KeyValues * >&msglist )
|
|
{
|
|
m_bAttemptingDrop = true;
|
|
|
|
if ( !GetParent() )
|
|
return false;
|
|
|
|
PropertySheet *sheet = IsDroppingSheet( msglist );
|
|
if ( sheet )
|
|
return GetParent()->IsDroppable( msglist );
|
|
|
|
return BaseClass::IsDroppable( msglist );
|
|
}
|
|
|
|
virtual void OnDroppablePanelPaint( CUtlVector< KeyValues * >& msglist, CUtlVector< Panel * >& dragPanels )
|
|
{
|
|
PropertySheet *sheet = IsDroppingSheet( msglist );
|
|
if ( sheet )
|
|
{
|
|
Panel *target = GetParent()->GetDropTarget( msglist );
|
|
if ( target )
|
|
{
|
|
// Fixme, mouse pos could be wrong...
|
|
target->OnDroppablePanelPaint( msglist, dragPanels );
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Just highlight the tab if dropping onto active page via the tab
|
|
BaseClass::OnDroppablePanelPaint( msglist, dragPanels );
|
|
}
|
|
|
|
virtual void OnPanelDropped( CUtlVector< KeyValues * >& msglist )
|
|
{
|
|
PropertySheet *sheet = IsDroppingSheet( msglist );
|
|
if ( sheet )
|
|
{
|
|
Panel *target = GetParent()->GetDropTarget( msglist );
|
|
if ( target )
|
|
{
|
|
// Fixme, mouse pos could be wrong...
|
|
target->OnPanelDropped( msglist );
|
|
}
|
|
}
|
|
|
|
// Defer to active page...
|
|
Panel *active = m_pParent->GetActivePage();
|
|
if ( !active || !active->IsDroppable( msglist ) )
|
|
return;
|
|
|
|
active->OnPanelDropped( msglist );
|
|
}
|
|
|
|
virtual void OnDragFailed( CUtlVector< KeyValues * >& msglist )
|
|
{
|
|
PropertySheet *sheet = IsDroppingSheet( msglist );
|
|
if ( !sheet )
|
|
return;
|
|
|
|
// Create a new property sheet
|
|
if ( m_pParent->IsDraggableTab() )
|
|
{
|
|
if ( msglist.Count() == 1 )
|
|
{
|
|
KeyValues *data = msglist[ 0 ];
|
|
int screenx = data->GetInt( "screenx" );
|
|
int screeny = data->GetInt( "screeny" );
|
|
|
|
// m_pParent->ScreenToLocal( screenx, screeny );
|
|
if ( !m_pParent->IsWithin( screenx, screeny ) )
|
|
{
|
|
Panel *page = reinterpret_cast< Panel * >( data->GetPtr( "propertypage" ) );
|
|
sheet = reinterpret_cast< PropertySheet * >( data->GetPtr( "propertysheet" ) );
|
|
char const *title = data->GetString( "tabname", "" );
|
|
if ( !page || !sheet )
|
|
return;
|
|
|
|
// Can only create if sheet was part of a ToolWindow derived object
|
|
ToolWindow *tw = dynamic_cast< ToolWindow * >( sheet->GetParent() );
|
|
if ( tw )
|
|
{
|
|
IToolWindowFactory *factory = tw->GetToolWindowFactory();
|
|
if ( factory )
|
|
{
|
|
bool hasContextMenu = sheet->PageHasContextMenu( page );
|
|
sheet->RemovePage( page );
|
|
factory->InstanceToolWindow( tw->GetParent(), sheet->ShouldShowContextButtons(), page, title, hasContextMenu );
|
|
|
|
if ( sheet->GetNumPages() == 0 )
|
|
{
|
|
tw->MarkForDeletion();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void OnCreateDragData( KeyValues *msg )
|
|
{
|
|
Assert( m_pParent->IsDraggableTab() );
|
|
|
|
msg->SetPtr( "propertypage", m_pPage );
|
|
msg->SetPtr( "propertysheet", m_pParent );
|
|
char sz[ 256 ];
|
|
GetText( sz, sizeof( sz ) );
|
|
msg->SetString( "tabname", sz );
|
|
msg->SetString( "text", sz );
|
|
}
|
|
|
|
virtual void ApplySchemeSettings(IScheme *pScheme)
|
|
{
|
|
// set up the scheme settings
|
|
Button::ApplySchemeSettings(pScheme);
|
|
|
|
_textColor = GetSchemeColor("PropertySheet.SelectedTextColor", GetFgColor(), pScheme);
|
|
_dimTextColor = GetSchemeColor("PropertySheet.TextColor", GetFgColor(), pScheme);
|
|
m_pActiveBorder = pScheme->GetBorder("TabActiveBorder");
|
|
m_pNormalBorder = pScheme->GetBorder("TabBorder");
|
|
|
|
if ( m_pImage )
|
|
{
|
|
ClearImages();
|
|
m_pImage->SetImage(scheme()->GetImage(m_pszImageName, false));
|
|
AddImage( m_pImage->GetImage(), 2 );
|
|
int w, h;
|
|
m_pImage->GetSize( w, h );
|
|
w += m_pContextLabel ? 10 : 0;
|
|
if ( m_pContextLabel )
|
|
{
|
|
m_pImage->SetPos( 10, 0 );
|
|
}
|
|
SetSize( w + 4, h + 2 );
|
|
}
|
|
else
|
|
{
|
|
int wide, tall;
|
|
int contentWide, contentTall;
|
|
GetSize(wide, tall);
|
|
GetContentSize(contentWide, contentTall);
|
|
|
|
wide = max(m_bMaxTabWidth, contentWide + 10); // 10 = 5 pixels margin on each side
|
|
wide += m_pContextLabel ? 10 : 0;
|
|
SetSize(wide, tall);
|
|
}
|
|
|
|
if ( m_pContextLabel )
|
|
{
|
|
SetTextInset( 12, 0 );
|
|
}
|
|
}
|
|
|
|
virtual void ApplySettings( KeyValues *inResourceData )
|
|
{
|
|
const char *pBorder = inResourceData->GetString("activeborder_override", "");
|
|
if (*pBorder)
|
|
{
|
|
m_pActiveBorder = scheme()->GetIScheme(GetScheme())->GetBorder( pBorder );
|
|
}
|
|
pBorder = inResourceData->GetString("normalborder_override", "");
|
|
if (*pBorder)
|
|
{
|
|
m_pNormalBorder = scheme()->GetIScheme(GetScheme())->GetBorder( pBorder );
|
|
}
|
|
BaseClass::ApplySettings(inResourceData);
|
|
}
|
|
|
|
virtual void OnCommand( char const *cmd )
|
|
{
|
|
if ( !Q_stricmp( cmd, "ShowContextMenu" ) )
|
|
{
|
|
KeyValues *kv = new KeyValues("OpenContextMenu");
|
|
kv->SetPtr( "page", m_pPage );
|
|
kv->SetPtr( "contextlabel", m_pContextLabel );
|
|
PostActionSignal( kv );
|
|
return;
|
|
}
|
|
BaseClass::OnCommand( cmd );
|
|
}
|
|
|
|
IBorder *GetBorder(bool depressed, bool armed, bool selected, bool keyfocus)
|
|
{
|
|
if (_active)
|
|
{
|
|
return m_pActiveBorder;
|
|
}
|
|
return m_pNormalBorder;
|
|
}
|
|
|
|
virtual Color GetButtonFgColor()
|
|
{
|
|
if (_active)
|
|
{
|
|
return _textColor;
|
|
}
|
|
else
|
|
{
|
|
return _dimTextColor;
|
|
}
|
|
}
|
|
|
|
virtual void SetActive(bool state)
|
|
{
|
|
_active = state;
|
|
SetZPos( state ? 100 : 0 );
|
|
InvalidateLayout();
|
|
Repaint();
|
|
}
|
|
|
|
virtual void SetTabWidth( int iWidth )
|
|
{
|
|
m_bMaxTabWidth = iWidth;
|
|
InvalidateLayout();
|
|
}
|
|
|
|
virtual bool CanBeDefaultButton(void)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//Fire action signal when mouse is pressed down instead of on release.
|
|
virtual void OnMousePressed(MouseCode code)
|
|
{
|
|
// check for context menu open
|
|
if (!IsEnabled())
|
|
return;
|
|
|
|
if (!IsMouseClickEnabled(code))
|
|
return;
|
|
|
|
if (IsUseCaptureMouseEnabled())
|
|
{
|
|
{
|
|
RequestFocus();
|
|
FireActionSignal();
|
|
SetSelected(true);
|
|
Repaint();
|
|
}
|
|
|
|
// lock mouse input to going to this button
|
|
input()->SetMouseCapture(GetVPanel());
|
|
}
|
|
}
|
|
|
|
virtual void OnMouseReleased(MouseCode code)
|
|
{
|
|
// ensure mouse capture gets released
|
|
if (IsUseCaptureMouseEnabled())
|
|
{
|
|
input()->SetMouseCapture(NULL);
|
|
}
|
|
|
|
// make sure the button gets unselected
|
|
SetSelected(false);
|
|
Repaint();
|
|
|
|
if (code == MOUSE_RIGHT)
|
|
{
|
|
KeyValues *kv = new KeyValues("OpenContextMenu");
|
|
kv->SetPtr( "page", m_pPage );
|
|
kv->SetPtr( "contextlabel", m_pContextLabel );
|
|
PostActionSignal( kv );
|
|
}
|
|
}
|
|
|
|
virtual void PerformLayout()
|
|
{
|
|
BaseClass::PerformLayout();
|
|
|
|
if ( m_pContextLabel )
|
|
{
|
|
int w, h;
|
|
GetSize( w, h );
|
|
m_pContextLabel->SetBounds( 0, 0, 10, h );
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
}; // namespace vgui
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor
|
|
//-----------------------------------------------------------------------------
|
|
PropertySheet::PropertySheet(
|
|
Panel *parent,
|
|
const char *panelName,
|
|
bool draggableTabs /*= false*/ ) : BaseClass(parent, panelName)
|
|
{
|
|
_activePage = NULL;
|
|
_activeTab = NULL;
|
|
_tabWidth = 64;
|
|
_activeTabIndex = 0;
|
|
_showTabs = true;
|
|
_combo = NULL;
|
|
_tabFocus = false;
|
|
m_flPageTransitionEffectTime = 0.0f;
|
|
m_bSmallTabs = false;
|
|
m_tabFont = 0;
|
|
m_bDraggableTabs = draggableTabs;
|
|
m_pTabKV = NULL;
|
|
m_iTabHeight = 0;
|
|
m_iTabHeightSmall = 0;
|
|
|
|
if ( m_bDraggableTabs )
|
|
{
|
|
SetDropEnabled( true );
|
|
}
|
|
|
|
m_bKBNavigationEnabled = true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor, associates pages with a combo box
|
|
//-----------------------------------------------------------------------------
|
|
PropertySheet::PropertySheet(Panel *parent, const char *panelName, ComboBox *combo) : BaseClass(parent, panelName)
|
|
{
|
|
_activePage = NULL;
|
|
_activeTab = NULL;
|
|
_tabWidth = 64;
|
|
_activeTabIndex = 0;
|
|
_combo=combo;
|
|
_combo->AddActionSignalTarget(this);
|
|
_showTabs = false;
|
|
_tabFocus = false;
|
|
m_flPageTransitionEffectTime = 0.0f;
|
|
m_bSmallTabs = false;
|
|
m_tabFont = 0;
|
|
m_bDraggableTabs = false;
|
|
m_pTabKV = NULL;
|
|
m_iTabHeight = 0;
|
|
m_iTabHeightSmall = 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destructor
|
|
//-----------------------------------------------------------------------------
|
|
PropertySheet::~PropertySheet()
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: ToolWindow uses this to drag tools from container to container by dragging the tab
|
|
// Input : -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool PropertySheet::IsDraggableTab() const
|
|
{
|
|
return m_bDraggableTabs;
|
|
}
|
|
|
|
void PropertySheet::SetDraggableTabs( bool state )
|
|
{
|
|
m_bDraggableTabs = state;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Lower profile tabs
|
|
// Input : state -
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::SetSmallTabs( bool state )
|
|
{
|
|
m_bSmallTabs = state;
|
|
m_tabFont = scheme()->GetIScheme( GetScheme() )->GetFont( m_bSmallTabs ? "DefaultVerySmall" : "Default" );
|
|
int c = m_PageTabs.Count();
|
|
for ( int i = 0; i < c ; ++i )
|
|
{
|
|
PageTab *tab = m_PageTabs[ i ];
|
|
Assert( tab );
|
|
tab->SetFont( m_tabFont );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool PropertySheet::IsSmallTabs() const
|
|
{
|
|
return m_bSmallTabs;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : state -
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::ShowContextButtons( bool state )
|
|
{
|
|
m_bContextButton = state;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool PropertySheet::ShouldShowContextButtons() const
|
|
{
|
|
return m_bContextButton;
|
|
}
|
|
|
|
int PropertySheet::FindPage( Panel *page ) const
|
|
{
|
|
int c = m_Pages.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
if ( m_Pages[ i ].page == page )
|
|
return i;
|
|
}
|
|
|
|
return m_Pages.InvalidIndex();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: adds a page to the sheet
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::AddPage(Panel *page, const char *title, char const *imageName /*= NULL*/, bool bHasContextMenu /*= false*/ )
|
|
{
|
|
if (!page)
|
|
return;
|
|
|
|
// don't add the page if we already have it
|
|
if ( FindPage( page ) != m_Pages.InvalidIndex() )
|
|
return;
|
|
|
|
long hoverActivatePageTime = 250;
|
|
PageTab *tab = new PageTab(this, "tab", title, imageName, _tabWidth, page, m_bContextButton && bHasContextMenu, hoverActivatePageTime );
|
|
if ( m_bDraggableTabs )
|
|
{
|
|
tab->SetDragEnabled( true );
|
|
}
|
|
|
|
tab->SetFont( m_tabFont );
|
|
if(_showTabs)
|
|
{
|
|
tab->AddActionSignalTarget(this);
|
|
}
|
|
else if (_combo)
|
|
{
|
|
_combo->AddItem(title, NULL);
|
|
}
|
|
|
|
if ( m_pTabKV )
|
|
{
|
|
tab->ApplySettings( m_pTabKV );
|
|
}
|
|
|
|
m_PageTabs.AddToTail(tab);
|
|
|
|
Page_t info;
|
|
info.page = page;
|
|
info.contextMenu = m_bContextButton && bHasContextMenu;
|
|
|
|
m_Pages.AddToTail( info );
|
|
|
|
page->SetParent(this);
|
|
page->AddActionSignalTarget(this);
|
|
PostMessage(page, new KeyValues("ResetData"));
|
|
|
|
page->SetVisible(false);
|
|
InvalidateLayout();
|
|
|
|
if (!_activePage)
|
|
{
|
|
// first page becomes the active page
|
|
ChangeActiveTab( 0 );
|
|
if ( _activePage )
|
|
{
|
|
_activePage->RequestFocus( 0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::SetActivePage(Panel *page)
|
|
{
|
|
// walk the list looking for this page
|
|
int index = FindPage( page );
|
|
if (!m_Pages.IsValidIndex(index))
|
|
return;
|
|
|
|
ChangeActiveTab(index);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::SetTabWidth(int pixels)
|
|
{
|
|
if ( pixels < 0 )
|
|
{
|
|
if( !_activeTab )
|
|
return;
|
|
|
|
int nTall;
|
|
_activeTab->GetContentSize( pixels, nTall );
|
|
}
|
|
|
|
if ( _tabWidth == pixels )
|
|
return;
|
|
|
|
_tabWidth = pixels;
|
|
InvalidateLayout();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: reloads the data in all the property page
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::ResetAllData()
|
|
{
|
|
// iterate all the dialogs resetting them
|
|
for (int i = 0; i < m_Pages.Count(); i++)
|
|
{
|
|
ipanel()->SendMessage(m_Pages[i].page->GetVPanel(), new KeyValues("ResetData"), GetVPanel());
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Applies any changes made by the dialog
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::ApplyChanges()
|
|
{
|
|
// iterate all the dialogs resetting them
|
|
for (int i = 0; i < m_Pages.Count(); i++)
|
|
{
|
|
ipanel()->SendMessage(m_Pages[i].page->GetVPanel(), new KeyValues("ApplyChanges"), GetVPanel());
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets a pointer to the currently active page
|
|
//-----------------------------------------------------------------------------
|
|
Panel *PropertySheet::GetActivePage()
|
|
{
|
|
return _activePage;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets a pointer to the currently active tab
|
|
//-----------------------------------------------------------------------------
|
|
Panel *PropertySheet::GetActiveTab()
|
|
{
|
|
return _activeTab;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: returns the number of panels in the sheet
|
|
//-----------------------------------------------------------------------------
|
|
int PropertySheet::GetNumPages()
|
|
{
|
|
return m_Pages.Count();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: returns the name contained in the active tab
|
|
// Input : a text buffer to contain the output
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::GetActiveTabTitle (char *textOut, int bufferLen )
|
|
{
|
|
if(_activeTab) _activeTab->GetText(textOut, bufferLen);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: returns the name contained in the active tab
|
|
// Input : a text buffer to contain the output
|
|
//-----------------------------------------------------------------------------
|
|
bool PropertySheet::GetTabTitle( int i, char *textOut, int bufferLen )
|
|
{
|
|
if ( i < 0 || i >= m_PageTabs.Count() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
m_PageTabs[i]->GetText(textOut, bufferLen);
|
|
return true;
|
|
}
|
|
|
|
bool PropertySheet::SetTabTitle( int i, char *pchTitle )
|
|
{
|
|
if ( i < 0 || i >= m_PageTabs.Count() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
m_PageTabs[ i ]->SetText( pchTitle );
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the index of the currently active page
|
|
//-----------------------------------------------------------------------------
|
|
int PropertySheet::GetActivePageNum()
|
|
{
|
|
for (int i = 0; i < m_Pages.Count(); i++)
|
|
{
|
|
if (m_Pages[i].page == _activePage)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Forwards focus requests to current active page
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::RequestFocus(int direction)
|
|
{
|
|
if (direction == -1 || direction == 0)
|
|
{
|
|
if (_activePage)
|
|
{
|
|
_activePage->RequestFocus(direction);
|
|
_tabFocus = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_showTabs && _activeTab)
|
|
{
|
|
_activeTab->RequestFocus(direction);
|
|
_tabFocus = true;
|
|
}
|
|
else if (_activePage)
|
|
{
|
|
_activePage->RequestFocus(direction);
|
|
_tabFocus = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: moves focus back
|
|
//-----------------------------------------------------------------------------
|
|
bool PropertySheet::RequestFocusPrev(VPANEL panel)
|
|
{
|
|
if (_tabFocus || !_showTabs || !_activeTab)
|
|
{
|
|
_tabFocus = false;
|
|
return BaseClass::RequestFocusPrev(panel);
|
|
}
|
|
else
|
|
{
|
|
if (GetVParent())
|
|
{
|
|
PostMessage(GetVParent(), new KeyValues("FindDefaultButton"));
|
|
}
|
|
_activeTab->RequestFocus(-1);
|
|
_tabFocus = true;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: moves focus forward
|
|
//-----------------------------------------------------------------------------
|
|
bool PropertySheet::RequestFocusNext(VPANEL panel)
|
|
{
|
|
if (!_tabFocus || !_activePage)
|
|
{
|
|
return BaseClass::RequestFocusNext(panel);
|
|
}
|
|
else
|
|
{
|
|
if (!_activeTab)
|
|
{
|
|
return BaseClass::RequestFocusNext(panel);
|
|
}
|
|
else
|
|
{
|
|
_activePage->RequestFocus(1);
|
|
_tabFocus = false;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Gets scheme settings
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::ApplySchemeSettings(IScheme *pScheme)
|
|
{
|
|
BaseClass::ApplySchemeSettings(pScheme);
|
|
|
|
// a little backwards-compatibility with old scheme files
|
|
IBorder *pBorder = pScheme->GetBorder("PropertySheetBorder");
|
|
if (pBorder == pScheme->GetBorder("Default"))
|
|
{
|
|
// get the old name
|
|
pBorder = pScheme->GetBorder("RaisedBorder");
|
|
}
|
|
|
|
SetBorder(pBorder);
|
|
m_flPageTransitionEffectTime = atof(pScheme->GetResourceString("PropertySheet.TransitionEffectTime"));
|
|
|
|
m_tabFont = pScheme->GetFont( m_bSmallTabs ? "DefaultVerySmall" : "Default" );
|
|
|
|
if ( m_pTabKV )
|
|
{
|
|
for (int i = 0; i < m_PageTabs.Count(); i++)
|
|
{
|
|
m_PageTabs[i]->ApplySettings( m_pTabKV );
|
|
}
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
// HPE_BEGIN:
|
|
// [tj] Here, we used to use a single size variable and overwrite it when we scaled.
|
|
// This led to problems when we changes resolutions, so now we recalcuate the absolute
|
|
// size from the relative size each time (based on proportionality)
|
|
//=============================================================================
|
|
if ( IsProportional() )
|
|
{
|
|
m_iTabHeight = scheme()->GetProportionalScaledValueEx( GetScheme(), m_iSpecifiedTabHeight );
|
|
m_iTabHeightSmall = scheme()->GetProportionalScaledValueEx( GetScheme(), m_iSpecifiedTabHeightSmall );
|
|
}
|
|
else
|
|
{
|
|
m_iTabHeight = m_iSpecifiedTabHeight;
|
|
m_iTabHeightSmall = m_iSpecifiedTabHeightSmall;
|
|
}
|
|
//=============================================================================
|
|
// HPE_END
|
|
//=============================================================================
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::ApplySettings(KeyValues *inResourceData)
|
|
{
|
|
BaseClass::ApplySettings(inResourceData);
|
|
|
|
KeyValues *pTabKV = inResourceData->FindKey( "tabskv" );
|
|
if ( pTabKV )
|
|
{
|
|
if ( m_pTabKV )
|
|
{
|
|
m_pTabKV->deleteThis();
|
|
}
|
|
m_pTabKV = new KeyValues("tabkv");
|
|
pTabKV->CopySubkeys( m_pTabKV );
|
|
}
|
|
|
|
KeyValues *pTabWidthKV = inResourceData->FindKey( "tabwidth" );
|
|
if ( pTabWidthKV )
|
|
{
|
|
_tabWidth = scheme()->GetProportionalScaledValueEx(GetScheme(), pTabWidthKV->GetInt());
|
|
for (int i = 0; i < m_PageTabs.Count(); i++)
|
|
{
|
|
m_PageTabs[i]->SetTabWidth( _tabWidth );
|
|
}
|
|
}
|
|
|
|
KeyValues *pTransitionKV = inResourceData->FindKey( "transition_time" );
|
|
if ( pTransitionKV )
|
|
{
|
|
m_flPageTransitionEffectTime = pTransitionKV->GetFloat();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Paint our border specially, with the tabs in mind
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::PaintBorder()
|
|
{
|
|
IBorder *border = GetBorder();
|
|
if (!border)
|
|
return;
|
|
|
|
// draw the border, but with a break at the active tab
|
|
int px = 0, py = 0, pwide = 0, ptall = 0;
|
|
if (_activeTab)
|
|
{
|
|
_activeTab->GetBounds(px, py, pwide, ptall);
|
|
ptall -= 1;
|
|
}
|
|
|
|
// draw the border underneath the buttons, with a break
|
|
int wide, tall;
|
|
GetSize(wide, tall);
|
|
border->Paint(0, py + ptall, wide, tall, IBorder::SIDE_TOP, px + 1, px + pwide - 1);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Lays out the dialog
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::PerformLayout()
|
|
{
|
|
BaseClass::PerformLayout();
|
|
|
|
int x, y, wide, tall;
|
|
GetBounds(x, y, wide, tall);
|
|
if (_activePage)
|
|
{
|
|
int tabHeight = IsSmallTabs() ? m_iTabHeightSmall : m_iTabHeight;
|
|
|
|
if(_showTabs)
|
|
{
|
|
_activePage->SetBounds(0, tabHeight, wide, tall - tabHeight);
|
|
}
|
|
else
|
|
{
|
|
_activePage->SetBounds(0, 0, wide, tall );
|
|
}
|
|
_activePage->InvalidateLayout();
|
|
}
|
|
|
|
|
|
int xtab;
|
|
int limit = m_PageTabs.Count();
|
|
|
|
xtab = m_iTabXIndent;
|
|
|
|
// draw the visible tabs
|
|
if (_showTabs)
|
|
{
|
|
for (int i = 0; i < limit; i++)
|
|
{
|
|
int tabHeight = IsSmallTabs() ? (m_iTabHeightSmall-1) : (m_iTabHeight-1);
|
|
|
|
m_PageTabs[i]->GetSize(wide, tall);
|
|
|
|
if ( m_bTabFitText )
|
|
{
|
|
m_PageTabs[i]->SizeToContents();
|
|
wide = m_PageTabs[i]->GetWide();
|
|
|
|
int iXInset, iYInset;
|
|
m_PageTabs[i]->GetTextInset( &iXInset, &iYInset );
|
|
wide += (iXInset * 2);
|
|
}
|
|
|
|
if (m_PageTabs[i] == _activeTab)
|
|
{
|
|
// active tab is taller
|
|
_activeTab->SetBounds(xtab, 2, wide, tabHeight);
|
|
}
|
|
else
|
|
{
|
|
m_PageTabs[i]->SetBounds(xtab, 4, wide, tabHeight - 2);
|
|
}
|
|
m_PageTabs[i]->SetVisible(true);
|
|
xtab += (wide + 1) + m_iTabXDelta;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < limit; i++)
|
|
{
|
|
m_PageTabs[i]->SetVisible(false);
|
|
}
|
|
}
|
|
|
|
// ensure draw order (page drawing over all the tabs except one)
|
|
if (_activePage)
|
|
{
|
|
_activePage->MoveToFront();
|
|
_activePage->Repaint();
|
|
}
|
|
if (_activeTab)
|
|
{
|
|
_activeTab->MoveToFront();
|
|
_activeTab->Repaint();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Switches the active panel
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::OnTabPressed(Panel *panel)
|
|
{
|
|
// look for the tab in the list
|
|
for (int i = 0; i < m_PageTabs.Count(); i++)
|
|
{
|
|
if (m_PageTabs[i] == panel)
|
|
{
|
|
// flip to the new tab
|
|
ChangeActiveTab(i);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: returns the panel associated with index i
|
|
// Input : the index of the panel to return
|
|
//-----------------------------------------------------------------------------
|
|
Panel *PropertySheet::GetPage(int i)
|
|
{
|
|
if(i<0 || i>=m_Pages.Count())
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return m_Pages[i].page;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: disables page by name
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::DisablePage(const char *title)
|
|
{
|
|
SetPageEnabled(title, false);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: enables page by name
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::EnablePage(const char *title)
|
|
{
|
|
SetPageEnabled(title, true);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: enabled or disables page by name
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::SetPageEnabled(const char *title, bool state)
|
|
{
|
|
for (int i = 0; i < m_PageTabs.Count(); i++)
|
|
{
|
|
if (_showTabs)
|
|
{
|
|
char tmp[50];
|
|
m_PageTabs[i]->GetText(tmp,50);
|
|
if (!strnicmp(title,tmp,strlen(tmp)))
|
|
{
|
|
m_PageTabs[i]->SetEnabled(state);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_combo->SetItemEnabled(title,state);
|
|
}
|
|
}
|
|
}
|
|
|
|
void PropertySheet::RemoveAllPages()
|
|
{
|
|
int c = m_Pages.Count();
|
|
for ( int i = c - 1; i >= 0 ; --i )
|
|
{
|
|
RemovePage( m_Pages[ i ].page );
|
|
}
|
|
}
|
|
|
|
void PropertySheet::DeleteAllPages()
|
|
{
|
|
int c = m_Pages.Count();
|
|
for ( int i = c - 1; i >= 0 ; --i )
|
|
{
|
|
DeletePage( m_Pages[ i ].page );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: deletes the page associated with panel
|
|
// Input : *panel - the panel of the page to remove
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::RemovePage(Panel *panel)
|
|
{
|
|
int location = FindPage( panel );
|
|
if ( location == m_Pages.InvalidIndex() )
|
|
return;
|
|
|
|
// Since it's being deleted, don't animate!!!
|
|
m_hPreviouslyActivePage = NULL;
|
|
_activeTab = NULL;
|
|
|
|
// ASSUMPTION = that the number of pages equals number of tabs
|
|
if( _showTabs )
|
|
{
|
|
m_PageTabs[location]->RemoveActionSignalTarget( this );
|
|
}
|
|
// now remove the tab
|
|
PageTab *tab = m_PageTabs[ location ];
|
|
m_PageTabs.Remove( location );
|
|
tab->MarkForDeletion();
|
|
|
|
// Remove from page list
|
|
m_Pages.Remove( location );
|
|
|
|
// Unparent
|
|
panel->SetParent( (Panel *)NULL );
|
|
|
|
if ( _activePage == panel )
|
|
{
|
|
_activePage = NULL;
|
|
// if this page is currently active, backup to the page before this.
|
|
ChangeActiveTab( max( location - 1, 0 ) );
|
|
}
|
|
|
|
PerformLayout();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: deletes the page associated with panel
|
|
// Input : *panel - the panel of the page to remove
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::DeletePage(Panel *panel)
|
|
{
|
|
Assert( panel );
|
|
RemovePage( panel );
|
|
panel->MarkForDeletion();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: flips to the new tab, sending out all the right notifications
|
|
// flipping to a tab activates the tab.
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::ChangeActiveTab( int index )
|
|
{
|
|
if ( !m_Pages.IsValidIndex( index ) )
|
|
{
|
|
_activeTab = NULL;
|
|
if ( m_Pages.Count() > 0 )
|
|
{
|
|
_activePage = NULL;
|
|
|
|
if ( index < 0 )
|
|
{
|
|
ChangeActiveTab( m_Pages.Count() - 1 );
|
|
}
|
|
else
|
|
{
|
|
ChangeActiveTab( 0 );
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ( m_Pages[index].page == _activePage )
|
|
{
|
|
if ( _activeTab )
|
|
{
|
|
_activeTab->RequestFocus();
|
|
}
|
|
_tabFocus = true;
|
|
return;
|
|
}
|
|
|
|
int c = m_Pages.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
m_Pages[ i ].page->SetVisible( false );
|
|
}
|
|
|
|
m_hPreviouslyActivePage = _activePage;
|
|
// notify old page
|
|
if (_activePage)
|
|
{
|
|
ivgui()->PostMessage(_activePage->GetVPanel(), new KeyValues("PageHide"), GetVPanel());
|
|
KeyValues *msg = new KeyValues("PageTabActivated");
|
|
msg->SetPtr("panel", (Panel *)NULL);
|
|
ivgui()->PostMessage(_activePage->GetVPanel(), msg, GetVPanel());
|
|
}
|
|
if (_activeTab)
|
|
{
|
|
//_activeTabIndex=index;
|
|
_activeTab->SetActive(false);
|
|
|
|
// does the old tab have the focus?
|
|
_tabFocus = _activeTab->HasFocus();
|
|
}
|
|
else
|
|
{
|
|
_tabFocus = false;
|
|
}
|
|
|
|
// flip page
|
|
_activePage = m_Pages[index].page;
|
|
_activeTab = m_PageTabs[index];
|
|
_activeTabIndex = index;
|
|
|
|
_activePage->SetVisible(true);
|
|
_activePage->MoveToFront();
|
|
|
|
_activeTab->SetVisible(true);
|
|
_activeTab->MoveToFront();
|
|
_activeTab->SetActive(true);
|
|
|
|
if (_tabFocus)
|
|
{
|
|
// if a tab already has focused,give the new tab the focus
|
|
_activeTab->RequestFocus();
|
|
}
|
|
else
|
|
{
|
|
// otherwise, give the focus to the page
|
|
_activePage->RequestFocus();
|
|
}
|
|
|
|
if (!_showTabs)
|
|
{
|
|
_combo->ActivateItemByRow(index);
|
|
}
|
|
|
|
_activePage->MakeReadyForUse();
|
|
|
|
// transition effect
|
|
if (m_flPageTransitionEffectTime)
|
|
{
|
|
if (m_hPreviouslyActivePage.Get())
|
|
{
|
|
// fade out the previous page
|
|
GetAnimationController()->RunAnimationCommand(m_hPreviouslyActivePage, "Alpha", 0.0f, 0.0f, m_flPageTransitionEffectTime / 2, AnimationController::INTERPOLATOR_LINEAR);
|
|
}
|
|
|
|
// fade in the new page
|
|
_activePage->SetAlpha(0);
|
|
GetAnimationController()->RunAnimationCommand(_activePage, "Alpha", 255.0f, m_flPageTransitionEffectTime / 2, m_flPageTransitionEffectTime / 2, AnimationController::INTERPOLATOR_LINEAR);
|
|
}
|
|
else
|
|
{
|
|
if (m_hPreviouslyActivePage.Get())
|
|
{
|
|
// no transition, just hide the previous page
|
|
m_hPreviouslyActivePage->SetVisible(false);
|
|
}
|
|
_activePage->SetAlpha( 255 );
|
|
}
|
|
|
|
// notify
|
|
ivgui()->PostMessage(_activePage->GetVPanel(), new KeyValues("PageShow"), GetVPanel());
|
|
|
|
KeyValues *msg = new KeyValues("PageTabActivated");
|
|
msg->SetPtr("panel", (Panel *)_activeTab);
|
|
ivgui()->PostMessage(_activePage->GetVPanel(), msg, GetVPanel());
|
|
|
|
// tell parent
|
|
PostActionSignal(new KeyValues("PageChanged"));
|
|
|
|
// Repaint
|
|
InvalidateLayout();
|
|
Repaint();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Gets the panel with the specified hotkey, from the current page
|
|
//-----------------------------------------------------------------------------
|
|
Panel *PropertySheet::HasHotkey(wchar_t key)
|
|
{
|
|
if (!_activePage)
|
|
return NULL;
|
|
|
|
for (int i = 0; i < _activePage->GetChildCount(); i++)
|
|
{
|
|
Panel *hot = _activePage->GetChild(i)->HasHotkey(key);
|
|
if (hot)
|
|
{
|
|
return hot;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: catches the opencontextmenu event
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::OnOpenContextMenu( KeyValues *params )
|
|
{
|
|
// tell parent
|
|
KeyValues *kv = params->MakeCopy();
|
|
PostActionSignal( kv );
|
|
Panel *page = reinterpret_cast< Panel * >( params->GetPtr( "page" ) );
|
|
if ( page )
|
|
{
|
|
PostMessage( page->GetVPanel(), params->MakeCopy() );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handle key presses, through tabs.
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::OnKeyCodePressed(KeyCode code)
|
|
{
|
|
bool shift = (input()->IsKeyDown(KEY_LSHIFT) || input()->IsKeyDown(KEY_RSHIFT));
|
|
bool ctrl = (input()->IsKeyDown(KEY_LCONTROL) || input()->IsKeyDown(KEY_RCONTROL));
|
|
bool alt = (input()->IsKeyDown(KEY_LALT) || input()->IsKeyDown(KEY_RALT));
|
|
|
|
if ( ctrl && shift && alt && code == KEY_B )
|
|
{
|
|
// enable build mode
|
|
EditablePanel *ep = dynamic_cast< EditablePanel * >( GetActivePage() );
|
|
if ( ep )
|
|
{
|
|
ep->ActivateBuildMode();
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( IsKBNavigationEnabled() )
|
|
{
|
|
ButtonCode_t nButtonCode = GetBaseButtonCode( code );
|
|
|
|
switch ( nButtonCode )
|
|
{
|
|
// for now left and right arrows just open or close submenus if they are there.
|
|
case KEY_RIGHT:
|
|
case KEY_XBUTTON_RIGHT:
|
|
case KEY_XSTICK1_RIGHT:
|
|
case KEY_XSTICK2_RIGHT:
|
|
case STEAMCONTROLLER_DPAD_RIGHT:
|
|
{
|
|
ChangeActiveTab(_activeTabIndex+1);
|
|
break;
|
|
}
|
|
case KEY_LEFT:
|
|
case KEY_XBUTTON_LEFT:
|
|
case KEY_XSTICK1_LEFT:
|
|
case KEY_XSTICK2_LEFT:
|
|
case STEAMCONTROLLER_DPAD_LEFT:
|
|
{
|
|
ChangeActiveTab(_activeTabIndex-1);
|
|
break;
|
|
}
|
|
default:
|
|
BaseClass::OnKeyCodePressed(code);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BaseClass::OnKeyCodePressed(code);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called by the associated combo box (if in that mode), changes the current panel
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::OnTextChanged(Panel *panel,const wchar_t *wszText)
|
|
{
|
|
if ( panel == _combo )
|
|
{
|
|
wchar_t tabText[30];
|
|
for(int i = 0 ; i < m_PageTabs.Count() ; i++ )
|
|
{
|
|
tabText[0] = 0;
|
|
m_PageTabs[i]->GetText(tabText,30);
|
|
if ( !wcsicmp(wszText,tabText) )
|
|
{
|
|
ChangeActiveTab(i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::OnCommand(const char *command)
|
|
{
|
|
// propogate the close command to our parent
|
|
if (!stricmp(command, "Close") && GetVParent())
|
|
{
|
|
CallParentFunction(new KeyValues("Command", "command", command));
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::OnApplyButtonEnable()
|
|
{
|
|
// tell parent
|
|
PostActionSignal(new KeyValues("ApplyButtonEnable"));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::OnCurrentDefaultButtonSet( vgui::VPANEL defaultButton )
|
|
{
|
|
// forward the message up
|
|
if (GetVParent())
|
|
{
|
|
KeyValues *msg = new KeyValues("CurrentDefaultButtonSet");
|
|
msg->SetInt("button", ivgui()->PanelToHandle( defaultButton ) );
|
|
PostMessage(GetVParent(), msg);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::OnDefaultButtonSet( VPANEL defaultButton )
|
|
{
|
|
// forward the message up
|
|
if (GetVParent())
|
|
{
|
|
KeyValues *msg = new KeyValues("DefaultButtonSet");
|
|
msg->SetInt("button", ivgui()->PanelToHandle( defaultButton ) );
|
|
PostMessage(GetVParent(), msg);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::OnFindDefaultButton()
|
|
{
|
|
if (GetVParent())
|
|
{
|
|
PostMessage(GetVParent(), new KeyValues("FindDefaultButton"));
|
|
}
|
|
}
|
|
|
|
bool PropertySheet::PageHasContextMenu( Panel *page ) const
|
|
{
|
|
int pageNum = FindPage( page );
|
|
if ( pageNum == m_Pages.InvalidIndex() )
|
|
return false;
|
|
|
|
return m_Pages[ pageNum ].contextMenu;
|
|
}
|
|
|
|
void PropertySheet::OnPanelDropped( CUtlVector< KeyValues * >& msglist )
|
|
{
|
|
if ( msglist.Count() != 1 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
PropertySheet *sheet = IsDroppingSheet( msglist );
|
|
if ( !sheet )
|
|
{
|
|
// Defer to active page
|
|
if ( _activePage && _activePage->IsDropEnabled() )
|
|
{
|
|
return _activePage->OnPanelDropped( msglist );
|
|
}
|
|
return;
|
|
}
|
|
|
|
KeyValues *data = msglist[ 0 ];
|
|
|
|
Panel *page = reinterpret_cast< Panel * >( data->GetPtr( "propertypage" ) );
|
|
char const *title = data->GetString( "tabname", "" );
|
|
if ( !page || !sheet )
|
|
return;
|
|
|
|
// Can only create if sheet was part of a ToolWindow derived object
|
|
ToolWindow *tw = dynamic_cast< ToolWindow * >( sheet->GetParent() );
|
|
if ( tw )
|
|
{
|
|
IToolWindowFactory *factory = tw->GetToolWindowFactory();
|
|
if ( factory )
|
|
{
|
|
bool showContext = sheet->PageHasContextMenu( page );
|
|
sheet->RemovePage( page );
|
|
if ( sheet->GetNumPages() == 0 )
|
|
{
|
|
tw->MarkForDeletion();
|
|
}
|
|
|
|
AddPage( page, title, NULL, showContext );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool PropertySheet::IsDroppable( CUtlVector< KeyValues * >& msglist )
|
|
{
|
|
if ( !m_bDraggableTabs )
|
|
return false;
|
|
|
|
if ( msglist.Count() != 1 )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int mx, my;
|
|
input()->GetCursorPos( mx, my );
|
|
ScreenToLocal( mx, my );
|
|
|
|
int tabHeight = IsSmallTabs() ? m_iTabHeightSmall : m_iTabHeight;
|
|
if ( my > tabHeight )
|
|
return false;
|
|
|
|
PropertySheet *sheet = IsDroppingSheet( msglist );
|
|
if ( !sheet )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( sheet == this )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
// Mouse is now over a droppable panel
|
|
void PropertySheet::OnDroppablePanelPaint( CUtlVector< KeyValues * >& msglist, CUtlVector< Panel * >& dragPanels )
|
|
{
|
|
// Convert this panel's bounds to screen space
|
|
int x, y, w, h;
|
|
|
|
GetSize( w, h );
|
|
|
|
int tabHeight = IsSmallTabs() ? m_iTabHeightSmall : m_iTabHeight;
|
|
h = tabHeight + 4;
|
|
|
|
x = y = 0;
|
|
LocalToScreen( x, y );
|
|
|
|
surface()->DrawSetColor( GetDropFrameColor() );
|
|
// Draw 2 pixel frame
|
|
surface()->DrawOutlinedRect( x, y, x + w, y + h );
|
|
surface()->DrawOutlinedRect( x+1, y+1, x + w-1, y + h-1 );
|
|
|
|
if ( !IsDroppable( msglist ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( !_showTabs )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Draw a fake new tab...
|
|
|
|
x = 0;
|
|
y = 2;
|
|
w = 1;
|
|
h = tabHeight;
|
|
|
|
int last = m_PageTabs.Count();
|
|
if ( last != 0 )
|
|
{
|
|
m_PageTabs[ last - 1 ]->GetBounds( x, y, w, h );
|
|
}
|
|
|
|
// Compute left edge of "fake" tab
|
|
|
|
x += ( w + 1 );
|
|
|
|
// Compute size of new panel
|
|
KeyValues *data = msglist[ 0 ];
|
|
char const *text = data->GetString( "tabname", "" );
|
|
Assert( text );
|
|
|
|
PageTab *fakeTab = new PageTab( this, "FakeTab", text, NULL, _tabWidth, NULL, false );
|
|
fakeTab->SetBounds( x, 4, w, tabHeight - 4 );
|
|
fakeTab->SetFont( m_tabFont );
|
|
SETUP_PANEL( fakeTab );
|
|
fakeTab->Repaint();
|
|
surface()->SolveTraverse( fakeTab->GetVPanel(), true );
|
|
surface()->PaintTraverse( fakeTab->GetVPanel() );
|
|
delete fakeTab;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : state -
|
|
//-----------------------------------------------------------------------------
|
|
void PropertySheet::SetKBNavigationEnabled( bool state )
|
|
{
|
|
m_bKBNavigationEnabled = state;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool PropertySheet::IsKBNavigationEnabled() const
|
|
{
|
|
return m_bKBNavigationEnabled;
|
|
}
|