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

1441 lines
38 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include <ctype.h>
#include <stdio.h>
#include <utlvector.h>
#include <vgui/IInput.h>
#include <vgui/ILocalize.h>
#include <vgui/ISurface.h>
#include <vgui/ISystem.h>
#include <vgui/KeyCode.h>
#include <KeyValues.h>
#include <vgui/MouseCode.h>
#include <vgui_controls/BuildModeDialog.h>
#include <vgui_controls/Label.h>
#include <vgui_controls/TextEntry.h>
#include <vgui_controls/Button.h>
#include <vgui_controls/CheckButton.h>
#include <vgui_controls/RadioButton.h>
#include <vgui_controls/MenuButton.h>
#include <vgui_controls/ComboBox.h>
#include <vgui_controls/BuildGroup.h>
#include <vgui_controls/MessageBox.h>
#include <vgui_controls/Menu.h>
#include <vgui_controls/Divider.h>
#include <vgui_controls/PanelListPanel.h>
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
using namespace vgui;
struct PanelItem_t
{
PanelItem_t() : m_EditLabel(NULL) {}
Panel *m_EditLabel;
TextEntry *m_EditPanel;
ComboBox *m_pCombo;
Button *m_EditButton;
char m_szName[64];
int m_iType;
};
class CSmallTextEntry : public TextEntry
{
DECLARE_CLASS_SIMPLE( CSmallTextEntry, TextEntry );
public:
CSmallTextEntry( Panel *parent, char const *panelName ) :
BaseClass( parent, panelName )
{
}
virtual void ApplySchemeSettings( IScheme *scheme )
{
BaseClass::ApplySchemeSettings( scheme );
SetFont( scheme->GetFont( "DefaultVerySmall" ) );
}
};
//-----------------------------------------------------------------------------
// Purpose: Holds a list of all the edit fields for the currently selected panel
//-----------------------------------------------------------------------------
class BuildModeDialog::PanelList
{
public:
CUtlVector<PanelItem_t> m_PanelList;
void AddItem( Panel *label, TextEntry *edit, ComboBox *combo, Button *button, const char *name, int type )
{
PanelItem_t item;
item.m_EditLabel = label;
item.m_EditPanel = edit;
Q_strncpy(item.m_szName, name, sizeof(item.m_szName));
item.m_iType = type;
item.m_pCombo = combo;
item.m_EditButton = button;
m_PanelList.AddToTail( item );
}
void RemoveAll( void )
{
for ( int i = 0; i < m_PanelList.Size(); i++ )
{
PanelItem_t *item = &m_PanelList[i];
delete item->m_EditLabel;
delete item->m_EditPanel;
delete item->m_EditButton;
}
m_PanelList.RemoveAll();
m_pControls->RemoveAll();
}
KeyValues *m_pResourceData;
PanelListPanel *m_pControls;
};
//-----------------------------------------------------------------------------
// Purpose: Dialog for adding localized strings
//-----------------------------------------------------------------------------
class BuildModeLocalizedStringEditDialog : public Frame
{
DECLARE_CLASS_SIMPLE(BuildModeLocalizedStringEditDialog, Frame);
public:
#pragma warning( disable : 4355 )
BuildModeLocalizedStringEditDialog() : Frame(this, NULL)
{
m_pTokenEntry = new TextEntry(this, NULL);
m_pValueEntry = new TextEntry(this, NULL);
m_pFileCombo = new ComboBox(this, NULL, 12, false);
m_pOKButton = new Button(this, NULL, "OK");
m_pCancelButton = new Button(this, NULL, "Cancel");
m_pCancelButton->SetCommand("Close");
m_pOKButton->SetCommand("OK");
// add the files to the combo
for (int i = 0; i < g_pVGuiLocalize->GetLocalizationFileCount(); i++)
{
m_pFileCombo->AddItem(g_pVGuiLocalize->GetLocalizationFileName(i), NULL);
}
}
#pragma warning( default : 4355 )
virtual void DoModal(const char *token)
{
input()->SetAppModalSurface(GetVPanel());
// setup data
m_pTokenEntry->SetText(token);
// lookup the value
StringIndex_t val = g_pVGuiLocalize->FindIndex(token);
if (val != INVALID_LOCALIZE_STRING_INDEX)
{
m_pValueEntry->SetText(g_pVGuiLocalize->GetValueByIndex(val));
// set the place in the file combo
m_pFileCombo->SetText(g_pVGuiLocalize->GetFileNameByIndex(val));
}
else
{
m_pValueEntry->SetText("");
}
}
private:
virtual void PerformLayout()
{
}
virtual void OnClose()
{
input()->SetAppModalSurface(NULL);
BaseClass::OnClose();
//PostActionSignal(new KeyValues("Command"
}
virtual void OnCommand(const char *command)
{
if (!stricmp(command, "OK"))
{
//!! apply changes
}
else
{
BaseClass::OnCommand(command);
}
}
vgui::TextEntry *m_pTokenEntry;
vgui::TextEntry *m_pValueEntry;
vgui::ComboBox *m_pFileCombo;
vgui::Button *m_pOKButton;
vgui::Button *m_pCancelButton;
};
class CBuildModeDialogMgr
{
public:
void Add( BuildModeDialog *pDlg );
void Remove( BuildModeDialog *pDlg );
int Count() const;
private:
CUtlVector< BuildModeDialog * > m_vecBuildDialogs;
};
static CBuildModeDialogMgr g_BuildModeDialogMgr;
void CBuildModeDialogMgr::Add( BuildModeDialog *pDlg )
{
if ( m_vecBuildDialogs.Find( pDlg ) == m_vecBuildDialogs.InvalidIndex() )
{
m_vecBuildDialogs.AddToTail( pDlg );
}
}
void CBuildModeDialogMgr::Remove( BuildModeDialog *pDlg )
{
m_vecBuildDialogs.FindAndRemove( pDlg );
}
int CBuildModeDialogMgr::Count() const
{
return m_vecBuildDialogs.Count();
}
int GetBuildModeDialogCount()
{
return g_BuildModeDialogMgr.Count();
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
BuildModeDialog::BuildModeDialog(BuildGroup *buildGroup) : Frame(buildGroup->GetContextPanel(), "BuildModeDialog")
{
SetMinimumSize(300, 256);
SetSize(300, 420);
m_pCurrentPanel = NULL;
m_pEditableParents = NULL;
m_pEditableChildren = NULL;
m_pNextChild = NULL;
m_pPrevChild = NULL;
m_pBuildGroup = buildGroup;
_undoSettings = NULL;
_copySettings = NULL;
_autoUpdate = false;
MakePopup();
SetTitle("VGUI Build Mode Editor", true);
CreateControls();
LoadUserConfig("BuildModeDialog");
g_BuildModeDialogMgr.Add( this );
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
BuildModeDialog::~BuildModeDialog()
{
g_BuildModeDialogMgr.Remove( this );
m_pPanelList->m_pResourceData->deleteThis();
m_pPanelList->m_pControls->DeleteAllItems();
if (_undoSettings)
_undoSettings->deleteThis();
if (_copySettings)
_copySettings->deleteThis();
}
//-----------------------------------------------------------------------------
// Purpose: makes sure build mode has been shut down properly
//-----------------------------------------------------------------------------
void BuildModeDialog::OnClose()
{
if (m_pBuildGroup->IsEnabled())
{
m_pBuildGroup->SetEnabled(false);
}
else
{
BaseClass::OnClose();
MarkForDeletion();
}
}
class CBuildModeNavCombo : public ComboBox
{
DECLARE_CLASS_SIMPLE( CBuildModeNavCombo, ComboBox );
public:
CBuildModeNavCombo(Panel *parent, const char *panelName, int numLines, bool allowEdit, bool getParents, Panel *context ) :
BaseClass( parent, panelName, numLines, allowEdit ),
m_bParents( getParents )
{
m_hContext = context;
}
virtual void OnShowMenu(Menu *menu)
{
menu->DeleteAllItems();
if ( !m_hContext.Get() )
return;
if ( m_bParents )
{
Panel *p = m_hContext->GetParent();
while ( p )
{
EditablePanel *ep = dynamic_cast < EditablePanel * >( p );
if ( ep && ep->GetBuildGroup() )
{
KeyValues *kv = new KeyValues( "Panel" );
kv->SetPtr( "ptr", p );
char const *text = ep->GetName() ? ep->GetName() : "unnamed";
menu->AddMenuItem( text, new KeyValues("SetText", "text", text), GetParent(), kv );
}
p = p->GetParent();
}
}
else
{
int i;
int c = m_hContext->GetChildCount();
for ( i = 0; i < c; ++i )
{
EditablePanel *ep = dynamic_cast < EditablePanel * >( m_hContext->GetChild( i ) );
if ( ep && ep->IsVisible() && ep->GetBuildGroup() )
{
KeyValues *kv = new KeyValues( "Panel" );
kv->SetPtr( "ptr", ep );
char const *text = ep->GetName() ? ep->GetName() : "unnamed";
menu->AddMenuItem( text, new KeyValues("SetText", "text", text), GetParent(), kv );
}
}
}
}
private:
bool m_bParents;
vgui::PHandle m_hContext;
};
//-----------------------------------------------------------------------------
// Purpose: Creates the build mode editing controls
//-----------------------------------------------------------------------------
void BuildModeDialog::CreateControls()
{
int i;
m_pPanelList = new PanelList;
m_pPanelList->m_pResourceData = new KeyValues( "BuildDialog" );
m_pPanelList->m_pControls = new PanelListPanel(this, "BuildModeControls");
// file to edit combo box is first
m_pFileSelectionCombo = new ComboBox(this, "FileSelectionCombo", 10, false);
for ( i = 0; i < m_pBuildGroup->GetRegisteredControlSettingsFileCount(); i++)
{
m_pFileSelectionCombo->AddItem(m_pBuildGroup->GetRegisteredControlSettingsFileByIndex(i), NULL);
}
if (m_pFileSelectionCombo->GetItemCount() < 2)
{
m_pFileSelectionCombo->SetEnabled(false);
}
int buttonH = 18;
// status info at top of dialog
m_pStatusLabel = new Label(this, "StatusLabel", "[nothing currently selected]");
m_pStatusLabel->SetTextColorState(Label::CS_DULL);
m_pStatusLabel->SetTall( buttonH );
m_pDivider = new Divider(this, "Divider");
// drop-down combo box for adding new controls
m_pAddNewControlCombo = new ComboBox(this, NULL, 30, false);
m_pAddNewControlCombo->SetSize(116, buttonH);
m_pAddNewControlCombo->SetOpenDirection(Menu::DOWN);
m_pEditableParents = new CBuildModeNavCombo( this, NULL, 15, false, true, m_pBuildGroup->GetContextPanel() );
m_pEditableParents->SetSize(116, buttonH);
m_pEditableParents->SetOpenDirection(Menu::DOWN);
m_pEditableChildren = new CBuildModeNavCombo( this, NULL, 15, false, false, m_pBuildGroup->GetContextPanel() );
m_pEditableChildren->SetSize(116, buttonH);
m_pEditableChildren->SetOpenDirection(Menu::DOWN);
m_pNextChild = new Button( this, "NextChild", "Next", this );
m_pNextChild->SetCommand( new KeyValues( "OnChangeChild", "direction", 1 ) );
m_pPrevChild = new Button( this, "PrevChild", "Prev", this );
m_pPrevChild->SetCommand( new KeyValues( "OnChangeChild", "direction", -1 ) );
// controls that can be added
// this list comes from controls EditablePanel can create by name.
int defaultItem = m_pAddNewControlCombo->AddItem("None", NULL);
CUtlVector< char const * > names;
CBuildFactoryHelper::GetFactoryNames( names );
// Sort the names
CUtlRBTree< char const *, int > sorted( 0, 0, StringLessThan );
for ( i = 0; i < names.Count(); ++i )
{
sorted.Insert( names[ i ] );
}
for ( i = sorted.FirstInorder(); i != sorted.InvalidIndex(); i = sorted.NextInorder( i ) )
{
m_pAddNewControlCombo->AddItem( sorted[ i ], NULL );
}
m_pAddNewControlCombo->ActivateItem(defaultItem);
m_pExitButton = new Button(this, "ExitButton", "&Exit");
m_pExitButton->SetSize(64, buttonH);
m_pSaveButton = new Button(this, "SaveButton", "&Save");
m_pSaveButton->SetSize(64, buttonH);
m_pApplyButton = new Button(this, "ApplyButton", "&Apply");
m_pApplyButton->SetSize(64, buttonH);
m_pReloadLocalization = new Button( this, "Localization", "&Reload Localization" );
m_pReloadLocalization->SetSize( 100, buttonH );
m_pExitButton->SetCommand("Exit");
m_pSaveButton->SetCommand("Save");
m_pApplyButton->SetCommand("Apply");
m_pReloadLocalization->SetCommand( new KeyValues( "ReloadLocalization" ) );
m_pDeleteButton = new Button(this, "DeletePanelButton", "Delete");
m_pDeleteButton->SetSize(64, buttonH);
m_pDeleteButton->SetCommand("DeletePanel");
m_pVarsButton = new MenuButton(this, "VarsButton", "Variables");
m_pVarsButton->SetSize(72, buttonH);
m_pVarsButton->SetOpenDirection(Menu::UP);
// iterate the vars
KeyValues *vars = m_pBuildGroup->GetDialogVariables();
if (vars && vars->GetFirstSubKey())
{
// create the menu
m_pVarsButton->SetEnabled(true);
Menu *menu = new Menu(m_pVarsButton, "VarsMenu");
// set all the variables to be copied to the clipboard when selected
for (KeyValues *kv = vars->GetFirstSubKey(); kv != NULL; kv = kv->GetNextKey())
{
char buf[32];
_snprintf(buf, sizeof(buf), "%%%s%%", kv->GetName());
menu->AddMenuItem(kv->GetName(), new KeyValues("SetClipboardText", "text", buf), this);
}
m_pVarsButton->SetMenu(menu);
}
else
{
// no variables
m_pVarsButton->SetEnabled(false);
}
m_pApplyButton->SetTabPosition(1);
m_pPanelList->m_pControls->SetTabPosition(2);
m_pVarsButton->SetTabPosition(3);
m_pDeleteButton->SetTabPosition(4);
m_pAddNewControlCombo->SetTabPosition(5);
m_pSaveButton->SetTabPosition(6);
m_pExitButton->SetTabPosition(7);
m_pEditableParents->SetTabPosition( 8 );
m_pEditableChildren->SetTabPosition( 9 );
m_pPrevChild->SetTabPosition( 10 );
m_pNextChild->SetTabPosition( 11 );
m_pReloadLocalization->SetTabPosition( 12 );
}
void BuildModeDialog::ApplySchemeSettings( IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
HFont font = pScheme->GetFont( "DefaultVerySmall" );
m_pStatusLabel->SetFont( font );
m_pReloadLocalization->SetFont( font );
m_pExitButton->SetFont( font );
m_pSaveButton->SetFont( font );
m_pApplyButton->SetFont( font );
m_pAddNewControlCombo->SetFont( font );
m_pEditableParents->SetFont( font );
m_pEditableChildren->SetFont( font );
m_pDeleteButton->SetFont( font );
m_pVarsButton->SetFont( font );
m_pPrevChild->SetFont( font );
m_pNextChild->SetFont( font );
}
//-----------------------------------------------------------------------------
// Purpose: lays out controls
//-----------------------------------------------------------------------------
void BuildModeDialog::PerformLayout()
{
BaseClass::PerformLayout();
// layout parameters
const int BORDER_GAP = 16, YGAP_SMALL = 4, YGAP_LARGE = 8, TITLE_HEIGHT = 24, BOTTOM_CONTROLS_HEIGHT = 145, XGAP = 6;
int wide, tall;
GetSize(wide, tall);
int xpos = BORDER_GAP;
int ypos = BORDER_GAP + TITLE_HEIGHT;
// controls from top down
// selection combo
m_pFileSelectionCombo->SetBounds(xpos, ypos, wide - (BORDER_GAP * 2), m_pStatusLabel->GetTall());
ypos += (m_pStatusLabel->GetTall() + YGAP_SMALL);
// status
m_pStatusLabel->SetBounds(xpos, ypos, wide - (BORDER_GAP * 2), m_pStatusLabel->GetTall());
ypos += (m_pStatusLabel->GetTall() + YGAP_SMALL);
// center control
m_pPanelList->m_pControls->SetPos(xpos, ypos);
m_pPanelList->m_pControls->SetSize(wide - (BORDER_GAP * 2), tall - (ypos + BOTTOM_CONTROLS_HEIGHT));
// controls from bottom-right
ypos = tall - BORDER_GAP;
xpos = BORDER_GAP + m_pVarsButton->GetWide() + m_pDeleteButton->GetWide() + m_pAddNewControlCombo->GetWide() + (XGAP * 2);
// bottom row of buttons
ypos -= m_pApplyButton->GetTall();
xpos -= m_pApplyButton->GetWide();
m_pApplyButton->SetPos(xpos, ypos);
xpos -= m_pExitButton->GetWide();
xpos -= XGAP;
m_pExitButton->SetPos(xpos, ypos);
xpos -= m_pSaveButton->GetWide();
xpos -= XGAP;
m_pSaveButton->SetPos(xpos, ypos);
// divider
xpos = BORDER_GAP;
ypos -= (YGAP_LARGE + m_pDivider->GetTall());
m_pDivider->SetBounds(xpos, ypos, wide - (xpos + BORDER_GAP), 2);
ypos -= (YGAP_LARGE + m_pVarsButton->GetTall());
xpos = BORDER_GAP;
m_pEditableParents->SetPos( xpos, ypos );
m_pEditableChildren->SetPos( xpos + 150, ypos );
ypos -= (YGAP_LARGE + 18 );
xpos = BORDER_GAP;
m_pReloadLocalization->SetPos( xpos, ypos );
xpos += ( XGAP ) + m_pReloadLocalization->GetWide();
m_pPrevChild->SetPos( xpos, ypos );
m_pPrevChild->SetSize( 64, m_pReloadLocalization->GetTall() );
xpos += ( XGAP ) + m_pPrevChild->GetWide();
m_pNextChild->SetPos( xpos, ypos );
m_pNextChild->SetSize( 64, m_pReloadLocalization->GetTall() );
ypos -= (YGAP_LARGE + m_pVarsButton->GetTall());
xpos = BORDER_GAP;
// edit buttons
m_pVarsButton->SetPos(xpos, ypos);
xpos += (XGAP + m_pVarsButton->GetWide());
m_pDeleteButton->SetPos(xpos, ypos);
xpos += (XGAP + m_pDeleteButton->GetWide());
m_pAddNewControlCombo->SetPos(xpos, ypos);
}
//-----------------------------------------------------------------------------
// Purpose: Deletes all the controls from the panel
//-----------------------------------------------------------------------------
void BuildModeDialog::RemoveAllControls( void )
{
// free the array
m_pPanelList->RemoveAll();
}
//-----------------------------------------------------------------------------
// Purpose: simple helper function to get a token from a string
// Input : char **string - pointer to the string pointer, which will be incremented
// Output : const char * - pointer to the token
//-----------------------------------------------------------------------------
const char *ParseTokenFromString( const char **string )
{
static char buf[128];
buf[0] = 0;
// find the first alnum character
const char *tok = *string;
while ( !V_isalnum(*tok) && *tok != 0 )
{
tok++;
}
// read in all the alnum characters
int pos = 0;
while ( V_isalnum(tok[pos]) )
{
buf[pos] = tok[pos];
pos++;
}
// null terminate the token
buf[pos] = 0;
// update the main string pointer
*string = &(tok[pos]);
// return a pointer to the static buffer
return buf;
}
void BuildModeDialog::OnTextKillFocus()
{
if ( !m_pCurrentPanel )
return;
ApplyDataToControls();
}
//-----------------------------------------------------------------------------
// Purpose: sets up the current control to edit
//-----------------------------------------------------------------------------
void BuildModeDialog::SetActiveControl(Panel *controlToEdit)
{
if (m_pCurrentPanel == controlToEdit)
{
// it's already set, so just update the property data and quit
if (m_pCurrentPanel)
{
UpdateControlData(m_pCurrentPanel);
}
return;
}
// reset the data
m_pCurrentPanel = controlToEdit;
RemoveAllControls();
m_pPanelList->m_pControls->MoveScrollBarToTop();
if (!m_pCurrentPanel)
{
m_pStatusLabel->SetText("[nothing currently selected]");
m_pStatusLabel->SetTextColorState(Label::CS_DULL);
RemoveAllControls();
return;
}
// get the control description string
const char *controlDesc = m_pCurrentPanel->GetDescription();
// parse out the control description
int tabPosition = 1;
while (1)
{
const char *dataType = ParseTokenFromString(&controlDesc);
// finish when we have no more tokens
if (*dataType == 0)
break;
// default the data type to a string
int datat = TYPE_STRING;
if (!stricmp(dataType, "int"))
{
datat = TYPE_STRING; //!! just for now
}
else if (!stricmp(dataType, "alignment"))
{
datat = TYPE_ALIGNMENT;
}
else if (!stricmp(dataType, "autoresize"))
{
datat = TYPE_AUTORESIZE;
}
else if (!stricmp(dataType, "corner"))
{
datat = TYPE_CORNER;
}
else if (!stricmp(dataType, "localize"))
{
datat = TYPE_LOCALIZEDSTRING;
}
// get the field name
const char *fieldName = ParseTokenFromString(&controlDesc);
int itemHeight = 18;
// build a control & label
Label *label = new Label(this, NULL, fieldName);
label->SetSize(96, itemHeight);
label->SetContentAlignment(Label::a_east);
TextEntry *edit = NULL;
ComboBox *editCombo = NULL;
Button *editButton = NULL;
if (datat == TYPE_ALIGNMENT)
{
// drop-down combo box
editCombo = new ComboBox(this, NULL, 9, false);
editCombo->AddItem("north-west", NULL);
editCombo->AddItem("north", NULL);
editCombo->AddItem("north-east", NULL);
editCombo->AddItem("west", NULL);
editCombo->AddItem("center", NULL);
editCombo->AddItem("east", NULL);
editCombo->AddItem("south-west", NULL);
editCombo->AddItem("south", NULL);
editCombo->AddItem("south-east", NULL);
edit = editCombo;
}
else if (datat == TYPE_AUTORESIZE)
{
// drop-down combo box
editCombo = new ComboBox(this, NULL, 4, false);
editCombo->AddItem( "0 - no auto-resize", NULL);
editCombo->AddItem( "1 - resize right", NULL);
editCombo->AddItem( "2 - resize down", NULL);
editCombo->AddItem( "3 - down & right", NULL);
edit = editCombo;
}
else if (datat == TYPE_CORNER)
{
// drop-down combo box
editCombo = new ComboBox(this, NULL, 4, false);
editCombo->AddItem("0 - top-left", NULL);
editCombo->AddItem("1 - top-right", NULL);
editCombo->AddItem("2 - bottom-left", NULL);
editCombo->AddItem("3 - bottom-right", NULL);
edit = editCombo;
}
else if (datat == TYPE_LOCALIZEDSTRING)
{
editButton = new Button(this, NULL, "...");
editButton->SetParent(this);
editButton->AddActionSignalTarget(this);
editButton->SetTabPosition(tabPosition++);
editButton->SetTall( itemHeight );
label->SetAssociatedControl(editButton);
}
else
{
// normal string edit
edit = new CSmallTextEntry(this, NULL);
}
if (edit)
{
edit->SetTall( itemHeight );
edit->SetParent(this);
edit->AddActionSignalTarget(this);
edit->SetTabPosition(tabPosition++);
label->SetAssociatedControl(edit);
}
HFont smallFont = scheme()->GetIScheme( GetScheme() )->GetFont( "DefaultVerySmall" );
if ( label )
{
label->SetFont( smallFont );
}
if ( edit )
{
edit->SetFont( smallFont );
}
if ( editCombo )
{
editCombo->SetFont( smallFont );
}
if ( editButton )
{
editButton->SetFont( smallFont );
}
// add to our control list
m_pPanelList->AddItem(label, edit, editCombo, editButton, fieldName, datat);
if ( edit )
{
m_pPanelList->m_pControls->AddItem(label, edit);
}
else
{
m_pPanelList->m_pControls->AddItem(label, editButton);
}
}
// check and see if the current panel is a Label
// iterate through the class hierarchy
if ( controlToEdit->IsBuildModeDeletable() )
{
m_pDeleteButton->SetEnabled(true);
}
else
{
m_pDeleteButton->SetEnabled(false);
}
// update the property data in the dialog
UpdateControlData(m_pCurrentPanel);
// set our title
if ( m_pBuildGroup->GetResourceName() )
{
m_pFileSelectionCombo->SetText(m_pBuildGroup->GetResourceName());
}
else
{
m_pFileSelectionCombo->SetText("[ no resource file associated with dialog ]");
}
m_pApplyButton->SetEnabled(false);
InvalidateLayout();
Repaint();
}
//-----------------------------------------------------------------------------
// Purpose: Updates the edit fields with information about the control
//-----------------------------------------------------------------------------
void BuildModeDialog::UpdateControlData(Panel *control)
{
KeyValues *dat = m_pPanelList->m_pResourceData->FindKey( control->GetName(), true );
control->GetSettings( dat );
// apply the settings to the edit panels
for ( int i = 0; i < m_pPanelList->m_PanelList.Size(); i++ )
{
const char *name = m_pPanelList->m_PanelList[i].m_szName;
const char *datstring = dat->GetString( name, "" );
UpdateEditControl(m_pPanelList->m_PanelList[i], datstring);
}
char statusText[512];
Q_snprintf(statusText, sizeof(statusText), "%s: \'%s\'", control->GetClassName(), control->GetName());
m_pStatusLabel->SetText(statusText);
m_pStatusLabel->SetTextColorState(Label::CS_NORMAL);
}
//-----------------------------------------------------------------------------
// Purpose: Updates the data in a single edit control
//-----------------------------------------------------------------------------
void BuildModeDialog::UpdateEditControl(PanelItem_t &panelItem, const char *datstring)
{
switch (panelItem.m_iType)
{
case TYPE_AUTORESIZE:
case TYPE_CORNER:
{
int dat = atoi(datstring);
panelItem.m_pCombo->ActivateItemByRow(dat);
}
break;
case TYPE_LOCALIZEDSTRING:
{
panelItem.m_EditButton->SetText(datstring);
}
break;
default:
{
wchar_t unicode[512];
g_pVGuiLocalize->ConvertANSIToUnicode(datstring, unicode, sizeof(unicode));
panelItem.m_EditPanel->SetText(unicode);
}
break;
}
}
//-----------------------------------------------------------------------------
// Purpose: Called when one of the buttons is pressed
//-----------------------------------------------------------------------------
void BuildModeDialog::OnCommand(const char *command)
{
if (!stricmp(command, "Save"))
{
// apply the current data and save it to disk
ApplyDataToControls();
if (m_pBuildGroup->SaveControlSettings())
{
// disable save button until another change has been made
m_pSaveButton->SetEnabled(false);
}
}
else if (!stricmp(command, "Exit"))
{
// exit build mode
ExitBuildMode();
}
else if (!stricmp(command, "Apply"))
{
// apply data to controls
ApplyDataToControls();
}
else if (!stricmp(command, "DeletePanel"))
{
OnDeletePanel();
}
else if (!stricmp(command, "RevertToSaved"))
{
RevertToSaved();
}
else if (!stricmp(command, "ShowHelp"))
{
ShowHelp();
}
else
{
BaseClass::OnCommand(command);
}
}
//-----------------------------------------------------------------------------
// Purpose: Deletes a panel from the buildgroup
//-----------------------------------------------------------------------------
void BuildModeDialog::OnDeletePanel()
{
if (!m_pCurrentPanel->IsBuildModeEditable())
{
return;
}
m_pBuildGroup->RemoveSettings();
SetActiveControl(m_pBuildGroup->GetCurrentPanel());
_undoSettings->deleteThis();
_undoSettings = NULL;
m_pSaveButton->SetEnabled(true);
}
//-----------------------------------------------------------------------------
// Purpose: Applies the current settings to the build controls
//-----------------------------------------------------------------------------
void BuildModeDialog::ApplyDataToControls()
{
// don't apply if the panel is not editable
if ( !m_pCurrentPanel->IsBuildModeEditable())
{
UpdateControlData( m_pCurrentPanel );
return; // return success, since we are behaving as expected.
}
char fieldName[512];
if (m_pPanelList->m_PanelList[0].m_EditPanel)
{
m_pPanelList->m_PanelList[0].m_EditPanel->GetText(fieldName, sizeof(fieldName));
}
else
{
m_pPanelList->m_PanelList[0].m_EditButton->GetText(fieldName, sizeof(fieldName));
}
// check to see if any buildgroup panels have this name
Panel *panel = m_pBuildGroup->FieldNameTaken(fieldName);
if (panel)
{
if (panel != m_pCurrentPanel)// make sure name is taken by some other panel not this one
{
char messageString[255];
Q_snprintf(messageString, sizeof( messageString ), "Fieldname is not unique: %s\nRename it and try again.", fieldName);
MessageBox *errorBox = new MessageBox("Cannot Apply", messageString);
errorBox->DoModal();
UpdateControlData(m_pCurrentPanel);
m_pApplyButton->SetEnabled(false);
return;
}
}
// create a section to store settings
// m_pPanelList->m_pResourceData->getSection( m_pCurrentPanel->GetName(), true );
KeyValues *dat = new KeyValues( m_pCurrentPanel->GetName() );
// loop through the textedit filling in settings
for ( int i = 0; i < m_pPanelList->m_PanelList.Size(); i++ )
{
const char *name = m_pPanelList->m_PanelList[i].m_szName;
char buf[512];
if (m_pPanelList->m_PanelList[i].m_EditPanel)
{
m_pPanelList->m_PanelList[i].m_EditPanel->GetText(buf, sizeof(buf));
}
else
{
m_pPanelList->m_PanelList[i].m_EditButton->GetText(buf, sizeof(buf));
}
switch (m_pPanelList->m_PanelList[i].m_iType)
{
case TYPE_CORNER:
case TYPE_AUTORESIZE:
// the integer value is assumed to be the first part of the string for these items
dat->SetInt(name, atoi(buf));
break;
default:
dat->SetString(name, buf);
break;
}
}
// dat is built, hand it back to the control
m_pCurrentPanel->ApplySettings( dat );
if ( m_pBuildGroup->GetContextPanel() )
{
m_pBuildGroup->GetContextPanel()->Repaint();
}
m_pApplyButton->SetEnabled(false);
m_pSaveButton->SetEnabled(true);
}
//-----------------------------------------------------------------------------
// Purpose: Store the settings of the current panel in a KeyValues
//-----------------------------------------------------------------------------
void BuildModeDialog::StoreUndoSettings()
{
// don't save if the planel is not editable
if ( !m_pCurrentPanel->IsBuildModeEditable())
{
if (_undoSettings)
_undoSettings->deleteThis();
_undoSettings = NULL;
return;
}
if (_undoSettings)
{
_undoSettings->deleteThis();
_undoSettings = NULL;
}
_undoSettings = StoreSettings();
}
//-----------------------------------------------------------------------------
// Purpose: Revert to the stored the settings of the current panel in a keyValues
//-----------------------------------------------------------------------------
void BuildModeDialog::DoUndo()
{
if ( _undoSettings )
{
m_pCurrentPanel->ApplySettings( _undoSettings );
UpdateControlData(m_pCurrentPanel);
_undoSettings->deleteThis();
_undoSettings = NULL;
}
m_pSaveButton->SetEnabled(true);
}
//-----------------------------------------------------------------------------
// Purpose: Copy the settings of the current panel into a keyValues
//-----------------------------------------------------------------------------
void BuildModeDialog::DoCopy()
{
if (_copySettings)
{
_copySettings->deleteThis();
_copySettings = NULL;
}
_copySettings = StoreSettings();
Q_strncpy (_copyClassName, m_pCurrentPanel->GetClassName(), sizeof( _copyClassName ) );
}
//-----------------------------------------------------------------------------
// Purpose: Create a new Panel with the _copySettings applied
//-----------------------------------------------------------------------------
void BuildModeDialog::DoPaste()
{
// Make a new control located where you had the mouse
int x, y;
input()->GetCursorPos(x, y);
m_pBuildGroup->GetContextPanel()->ScreenToLocal(x,y);
Panel *newPanel = OnNewControl(_copyClassName, x, y);
if (newPanel)
{
newPanel->ApplySettings(_copySettings);
newPanel->SetPos(x, y);
char name[255];
m_pBuildGroup->GetNewFieldName(name, sizeof(name), newPanel);
newPanel->SetName(name);
}
}
//-----------------------------------------------------------------------------
// Purpose: Store the settings of the current panel in a keyValues
//-----------------------------------------------------------------------------
KeyValues *BuildModeDialog::StoreSettings()
{
KeyValues *storedSettings;
storedSettings = new KeyValues( m_pCurrentPanel->GetName() );
// loop through the textedit filling in settings
for ( int i = 0; i < m_pPanelList->m_PanelList.Size(); i++ )
{
const char *name = m_pPanelList->m_PanelList[i].m_szName;
char buf[512];
if (m_pPanelList->m_PanelList[i].m_EditPanel)
{
m_pPanelList->m_PanelList[i].m_EditPanel->GetText(buf, sizeof(buf));
}
else
{
m_pPanelList->m_PanelList[i].m_EditButton->GetText(buf, sizeof(buf));
}
switch (m_pPanelList->m_PanelList[i].m_iType)
{
case TYPE_CORNER:
case TYPE_AUTORESIZE:
// the integer value is assumed to be the first part of the string for these items
storedSettings->SetInt(name, atoi(buf));
break;
default:
storedSettings->SetString(name, buf);
break;
}
}
return storedSettings;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void BuildModeDialog::OnKeyCodeTyped(KeyCode code)
{
if (code == KEY_ENTER) // if someone hits return apply the changes
{
ApplyDataToControls();
}
else
{
Frame::OnKeyCodeTyped(code);
}
}
//-----------------------------------------------------------------------------
// Purpose: Checks to see if any text has changed
//-----------------------------------------------------------------------------
void BuildModeDialog::OnTextChanged( Panel *panel )
{
if (panel == m_pFileSelectionCombo)
{
// reload file if it's changed
char newFile[512];
m_pFileSelectionCombo->GetText(newFile, sizeof(newFile));
if (stricmp(newFile, m_pBuildGroup->GetResourceName()) != 0)
{
// file has changed, reload
SetActiveControl(NULL);
m_pBuildGroup->ChangeControlSettingsFile(newFile);
}
return;
}
if (panel == m_pAddNewControlCombo)
{
char buf[40];
m_pAddNewControlCombo->GetText(buf, 40);
if (stricmp(buf, "None") != 0)
{
OnNewControl(buf);
// reset box back to None
m_pAddNewControlCombo->ActivateItemByRow( 0 );
}
}
if ( panel == m_pEditableChildren )
{
KeyValues *kv = m_pEditableChildren->GetActiveItemUserData();
if ( kv )
{
EditablePanel *ep = reinterpret_cast< EditablePanel * >( kv->GetPtr( "ptr" ) );
if ( ep )
{
ep->ActivateBuildMode();
}
}
}
if ( panel == m_pEditableParents )
{
KeyValues *kv = m_pEditableParents->GetActiveItemUserData();
if ( kv )
{
EditablePanel *ep = reinterpret_cast< EditablePanel * >( kv->GetPtr( "ptr" ) );
if ( ep )
{
ep->ActivateBuildMode();
}
}
}
if (m_pCurrentPanel && m_pCurrentPanel->IsBuildModeEditable())
{
m_pApplyButton->SetEnabled(true);
}
if (_autoUpdate)
{
ApplyDataToControls();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void BuildModeDialog::ExitBuildMode( void )
{
// make sure rulers are off
if (m_pBuildGroup->HasRulersOn())
{
m_pBuildGroup->ToggleRulerDisplay();
}
m_pBuildGroup->SetEnabled(false);
}
//-----------------------------------------------------------------------------
// Purpose: Create a new control in the context panel
//-----------------------------------------------------------------------------
Panel *BuildModeDialog::OnNewControl( const char *name, int x, int y)
{
// returns NULL on failure
Panel *newPanel = m_pBuildGroup->NewControl(name, x, y);
if (newPanel)
{
// call mouse commands to simulate selecting the new
// panel. This will set everything up correctly in the buildGroup.
m_pBuildGroup->MousePressed(MOUSE_LEFT, newPanel);
m_pBuildGroup->MouseReleased(MOUSE_LEFT, newPanel);
}
m_pSaveButton->SetEnabled(true);
return newPanel;
}
//-----------------------------------------------------------------------------
// Purpose: enable the save button, useful when buildgroup needs to Activate it.
//-----------------------------------------------------------------------------
void BuildModeDialog::EnableSaveButton()
{
m_pSaveButton->SetEnabled(true);
}
//-----------------------------------------------------------------------------
// Purpose: Revert to the saved settings in the .res file
//-----------------------------------------------------------------------------
void BuildModeDialog::RevertToSaved()
{
// hide the dialog as reloading will destroy it
surface()->SetPanelVisible(this->GetVPanel(), false);
m_pBuildGroup->ReloadControlSettings();
}
//-----------------------------------------------------------------------------
// Purpose: Display some information about the editor
//-----------------------------------------------------------------------------
void BuildModeDialog::ShowHelp()
{
char helpText[]= "In the Build Mode Dialog Window:\n"
"Delete button - deletes the currently selected panel if it is deletable.\n"
"Apply button - applies changes to the Context Panel.\n"
"Save button - saves all settings to file. \n"
"Revert to saved- reloads the last saved file.\n"
"Auto Update - any changes apply instantly.\n"
"Typing Enter in any text field applies changes.\n"
"New Control menu - creates a new panel in the upper left corner.\n\n"
"In the Context Panel:\n"
"After selecting and moving a panel Ctrl-z will undo the move.\n"
"Shift clicking panels allows multiple panels to be selected into a group.\n"
"Ctrl-c copies the settings of the last selected panel.\n"
"Ctrl-v creates a new panel with the copied settings at the location of the mouse pointer.\n"
"Arrow keys slowly move panels, holding shift + arrow will slowly resize it.\n"
"Holding right mouse button down opens a dropdown panel creation menu.\n"
" Panel will be created where the menu was opened.\n"
"Delete key deletes the currently selected panel if it is deletable.\n"
" Does nothing to multiple selections.";
MessageBox *helpDlg = new MessageBox ("Build Mode Help", helpText, this);
helpDlg->AddActionSignalTarget(this);
helpDlg->DoModal();
}
void BuildModeDialog::ShutdownBuildMode()
{
m_pBuildGroup->SetEnabled(false);
}
void BuildModeDialog::OnPanelMoved()
{
m_pApplyButton->SetEnabled(true);
}
//-----------------------------------------------------------------------------
// Purpose: message handles thats sets the text in the clipboard
//-----------------------------------------------------------------------------
void BuildModeDialog::OnSetClipboardText(const char *text)
{
system()->SetClipboardText(text, strlen(text));
}
void BuildModeDialog::OnCreateNewControl( char const *text )
{
if ( !Q_stricmp( text, "None" ) )
return;
OnNewControl( text, m_nClick[ 0 ], m_nClick[ 1 ] );
}
void BuildModeDialog::OnShowNewControlMenu()
{
if ( !m_pBuildGroup )
return;
int i;
input()->GetCursorPos( m_nClick[ 0 ], m_nClick[ 1 ] );
m_pBuildGroup->GetContextPanel()->ScreenToLocal( m_nClick[ 0 ], m_nClick[ 1 ] );
if ( m_hContextMenu )
delete m_hContextMenu.Get();
m_hContextMenu = new Menu( this, "NewControls" );
// Show popup menu
m_hContextMenu->AddMenuItem( "None", "None", new KeyValues( "CreateNewControl", "text", "None" ), this );
CUtlVector< char const * > names;
CBuildFactoryHelper::GetFactoryNames( names );
// Sort the names
CUtlRBTree< char const *, int > sorted( 0, 0, StringLessThan );
for ( i = 0; i < names.Count(); ++i )
{
sorted.Insert( names[ i ] );
}
for ( i = sorted.FirstInorder(); i != sorted.InvalidIndex(); i = sorted.NextInorder( i ) )
{
m_hContextMenu->AddMenuItem( sorted[ i ], sorted[ i ], new KeyValues( "CreateNewControl", "text", sorted[ i ] ), this );
}
Menu::PlaceContextMenu( this, m_hContextMenu );
}
void BuildModeDialog::OnReloadLocalization()
{
// reload localization files
g_pVGuiLocalize->ReloadLocalizationFiles( );
}
bool BuildModeDialog::IsBuildGroupEnabled()
{
// Don't ever edit the actual build dialog!!!
return false;
}
void BuildModeDialog::OnChangeChild( int direction )
{
Assert( direction == 1 || direction == -1 );
if ( !m_pBuildGroup )
return;
Panel *current = m_pCurrentPanel;
Panel *context = m_pBuildGroup->GetContextPanel();
if ( !current || current == context )
{
current = NULL;
if ( context->GetChildCount() > 0 )
{
current = context->GetChild( 0 );
}
}
else
{
int i;
// Move in direction requested
int children = context->GetChildCount();
for ( i = 0; i < children; ++i )
{
Panel *child = context->GetChild( i );
if ( child == current )
{
break;
}
}
if ( i < children )
{
for ( int offset = 1; offset < children; ++offset )
{
int test = ( i + ( direction * offset ) ) % children;
if ( test < 0 )
test += children;
if ( test == i )
continue;
Panel *check = context->GetChild( test );
BuildModeDialog *bm = dynamic_cast< BuildModeDialog * >( check );
if ( bm )
continue;
current = check;
break;
}
}
}
if ( !current )
{
return;
}
SetActiveControl( current );
}