1759 lines
48 KiB
C++
1759 lines
48 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//=============================================================================
|
|
//
|
|
//=============================================================================
|
|
|
|
|
|
// Standard includes
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <direct.h>
|
|
#include <Windows.h>
|
|
|
|
|
|
// Valve includes
|
|
#include "itemtest/itemtest_controls.h"
|
|
#include "vgui/IVGui.h"
|
|
#include "vgui/IInput.h"
|
|
#include "vgui/ISystem.h"
|
|
#include "vgui/IPanel.h"
|
|
#include "vgui_controls/CheckButton.h"
|
|
#include "vgui_controls/ComboBox.h"
|
|
#include "vgui_controls/FileOpenDialog.h"
|
|
#include "vgui_controls/Menu.h"
|
|
#include "vgui_controls/MenuItem.h"
|
|
#include "vgui_controls/MessageBox.h"
|
|
#include "vgui_controls/PanelListPanel.h"
|
|
#include "vgui_controls/ScrollBar.h"
|
|
#include "vgui_controls/TextImage.h"
|
|
#include "tier1/fmtstr.h"
|
|
|
|
|
|
// Local includes
|
|
#include "dualpanellist.h"
|
|
|
|
|
|
// Last include
|
|
#include <tier0/memdbgon.h>
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CItemUploadDialog *g_pItemUploadDialog = NULL;
|
|
|
|
|
|
//=============================================================================
|
|
//
|
|
//=============================================================================
|
|
CStatusLabel::CStatusLabel( vgui::Panel *pPanel, const char *pszName, bool bValid /* = false */ )
|
|
: BaseClass( pPanel, pszName, "" )
|
|
, m_bValid( bValid )
|
|
, m_cValid( 0, 192, 0, 255 )
|
|
, m_cInvalid( 192, 0, 0, 255 )
|
|
{
|
|
SetText( m_bValid ? "#valid" : "#invalid" );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CStatusLabel::ApplySchemeSettings( vgui::IScheme *pScheme )
|
|
{
|
|
BaseClass::ApplySchemeSettings( pScheme );
|
|
|
|
SetContentAlignment( vgui::Label::a_center );
|
|
|
|
m_cValid = pScheme->GetColor( "StatusLabel.ValidColor", m_cValid );
|
|
m_cInvalid = pScheme->GetColor( "StatusLabel.InvalidColor", m_cInvalid );
|
|
|
|
UpdateColors();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CStatusLabel::SetValid( bool bValid )
|
|
{
|
|
if ( bValid == m_bValid )
|
|
return;
|
|
|
|
m_bValid = bValid;
|
|
SetText( m_bValid ? "#valid" : "#invalid" );
|
|
|
|
UpdateColors();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool CStatusLabel::GetValid() const
|
|
{
|
|
return m_bValid;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CStatusLabel::UpdateColors()
|
|
{
|
|
// TODO: Set valid/invalid colors in scheme .res file...
|
|
if ( GetValid() )
|
|
{
|
|
SetBgColor( m_cValid );
|
|
}
|
|
else
|
|
{
|
|
SetBgColor( m_cInvalid );
|
|
}
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
//
|
|
//=============================================================================
|
|
CItemUploadSubPanel::CItemUploadSubPanel( vgui::Panel *pParent, const char *pszName, const char *pszNextName )
|
|
: BaseClass( pParent, pszName )
|
|
, m_sNextName( pszNextName )
|
|
{
|
|
// Set the Wizard panel if the parent is a Wizard panel (it should be)
|
|
vgui::WizardPanel *pWizardPanel = dynamic_cast< vgui::WizardPanel * >( pParent );
|
|
if ( pWizardPanel )
|
|
{
|
|
SetWizardPanel( pWizardPanel );
|
|
}
|
|
|
|
CFmtStr sTmp;
|
|
|
|
// Create the two standard widgets
|
|
|
|
if ( CItemUpload::GetDevMode() )
|
|
{
|
|
sTmp.sprintf( "#itemtest_wizard_%s_info_dev", GetName() );
|
|
const char *pszCheck = g_pVGuiLocalize->FindAsUTF8( sTmp );
|
|
|
|
if ( pszCheck == sTmp.Access() )
|
|
{
|
|
sTmp.Clear();
|
|
}
|
|
}
|
|
|
|
if ( sTmp.Length() <= 0 )
|
|
{
|
|
sTmp.sprintf( "#itemtest_wizard_%s_info", GetName() );
|
|
}
|
|
|
|
m_pLabel = new vgui::Label( this, "info", sTmp );
|
|
|
|
m_pPanelListPanel = new vgui::PanelListPanel( this, "list" );
|
|
|
|
m_pStatusLabel = new CStatusLabel( this, "statusLabel", false );
|
|
m_pStatusText = new vgui::Label( this, "statusText", "wonk" );
|
|
|
|
sTmp.sprintf( "itemtest_wizard_%s.res", GetName() );
|
|
|
|
LoadControlSettings( sTmp );
|
|
|
|
m_pLabel->SetAutoResize( PIN_TOPLEFT, AUTORESIZE_RIGHT, 0, 0, 0, 0 );
|
|
m_pLabel->SizeToContents(); // Supposedly doesn't work until layout but kind of does...
|
|
m_pLabel->SetWrap( true );
|
|
|
|
m_pStatusLabel->SetAutoResize( PIN_BOTTOMLEFT, AUTORESIZE_NO, 0, 0, 0, 0 );
|
|
|
|
if ( GetWizardPanel() && pszNextName == NULL )
|
|
{
|
|
GetWizardPanel()->SetFinishButtonEnabled( false );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CItemUploadSubPanel::PerformLayout()
|
|
{
|
|
BaseClass::PerformLayout();
|
|
|
|
int nOldWide = m_pLabel->GetWide();
|
|
m_pLabel->SizeToContents();
|
|
m_pLabel->SetWide( nOldWide );
|
|
|
|
int nX = 0;
|
|
int nY = 0;
|
|
|
|
m_pLabel->GetPos( nX, nY );
|
|
|
|
int nX1 = 0;
|
|
int nY1 = 0;
|
|
|
|
m_pStatusLabel->GetPos( nX1, nY1 );
|
|
|
|
m_pPanelListPanel->SetBounds( nX, nY + m_pLabel->GetTall() + 10, m_pLabel->GetWide(), nY1 - nY - m_pLabel->GetTall() - 20 );
|
|
|
|
bool bDone = false;
|
|
|
|
for ( int i = 1; i < m_pPanelListPanel->GetItemCount(); i += 2 )
|
|
{
|
|
vgui::Panel *pPanelA0 = m_pPanelListPanel->GetItemLabel( i - 1 );
|
|
vgui::Panel *pPanelA1 = m_pPanelListPanel->GetItemPanel( i - 1 );
|
|
vgui::Panel *pPanelB0 = m_pPanelListPanel->GetItemLabel( i );
|
|
vgui::Panel *pPanelB1 = m_pPanelListPanel->GetItemPanel( i );
|
|
|
|
pPanelA0->SetTall( pPanelA1->GetTall() );
|
|
pPanelB1->SetTall( pPanelB0->GetTall() );
|
|
|
|
if ( !bDone )
|
|
{
|
|
bDone = true;
|
|
m_pStatusLabel->SetSize( pPanelA0->GetWide(), pPanelB0->GetTall() );
|
|
}
|
|
}
|
|
|
|
m_pStatusLabel->GetPos( nX, nY );
|
|
m_pStatusText->SetPos( nX + m_pStatusLabel->GetWide() + 5, nY );
|
|
m_pStatusText->SetWide( m_pLabel->GetWide() - nX );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CItemUploadSubPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
|
|
{
|
|
BaseClass::ApplySchemeSettings( pScheme );
|
|
|
|
if ( dynamic_cast< CGlobalSubPanel * >( this ) )
|
|
return;
|
|
|
|
if ( dynamic_cast< CGeometrySubPanel * >( this ) )
|
|
return;
|
|
|
|
/*
|
|
#ifdef _DEBUG
|
|
|
|
m_pLabel->SetBgColor( Color( 255, 127, 0, 255 ) );
|
|
|
|
m_pPanelListPanel->SetBgColor( Color( 0, 127, 0 ) );
|
|
|
|
for ( int i = 1; i < m_pPanelListPanel->GetItemCount(); i += 2 )
|
|
{
|
|
vgui::Panel *pPanel = m_pPanelListPanel->GetItemPanel( i );
|
|
if ( pPanel )
|
|
{
|
|
pPanel->SetBgColor( Color( 0, 0, 255 ) );
|
|
}
|
|
}
|
|
|
|
#endif // _DEBUG
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CItemUploadSubPanel::OnDisplay()
|
|
{
|
|
UpdateGUI();
|
|
// UpdateStatus();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
vgui::WizardSubPanel *CItemUploadSubPanel::GetNextSubPanel()
|
|
{
|
|
return dynamic_cast< WizardSubPanel * >( GetWizardPanel()->FindChildByName( m_sNextName.Get() ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool CItemUploadSubPanel::UpdateStatus()
|
|
{
|
|
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
|
|
if ( !pItemUploadWizard )
|
|
return false;
|
|
|
|
if ( pItemUploadWizard->GetCurrentItemUploadSubPanel() != this )
|
|
return false;
|
|
|
|
CAsset &asset = pItemUploadWizard->Asset();
|
|
|
|
CFmtStr sTmp;
|
|
sTmp.sprintf( "#itemtest_wizard_%s_title", GetName() );
|
|
|
|
CUtlString sRelativeDir;
|
|
asset.GetRelativeDir( sRelativeDir, NULL );
|
|
|
|
const char *pszTitle = g_pVGuiLocalize->FindAsUTF8( sTmp );
|
|
|
|
CUtlString sStatusMsg;
|
|
if ( asset.IsOk( sStatusMsg ) && !sRelativeDir.IsEmpty() && pszTitle )
|
|
{
|
|
sTmp.sprintf( "%s : %s", pszTitle, sRelativeDir.Get() );
|
|
}
|
|
else if ( !sStatusMsg.IsEmpty() )
|
|
{
|
|
}
|
|
|
|
pItemUploadWizard->SetTitle( sTmp, true );
|
|
|
|
bool bValid = true;
|
|
for ( int i = 1; bValid && i < m_pPanelListPanel->GetItemCount(); i += 2 )
|
|
{
|
|
CStatusLabel *pStatusLabel = dynamic_cast< CStatusLabel * >( m_pPanelListPanel->GetItemLabel( i ) );
|
|
if ( !pStatusLabel )
|
|
continue;
|
|
|
|
bValid = bValid && pStatusLabel->GetValid();
|
|
}
|
|
|
|
m_pStatusLabel->SetValid( bValid );
|
|
|
|
sTmp.sprintf( "#itemtest_wizard_%s_%s", GetName(), bValid ? "valid" : "invalid" );
|
|
m_pStatusText->SetText( sTmp );
|
|
|
|
pItemUploadWizard->SetNextButtonEnabled( bValid );
|
|
|
|
if ( pItemUploadWizard->GetCurrentSubPanel() == this )
|
|
{
|
|
pItemUploadWizard->SetFinishButtonEnabled( m_sNextName.IsEmpty() ? true : false );
|
|
}
|
|
|
|
return bValid;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CItemUploadSubPanel::AddStatusPanels( const char *pszPrefix )
|
|
{
|
|
CFmtStr sTmp;
|
|
|
|
sTmp.sprintf( "%sStatusLabel", pszPrefix );
|
|
CStatusLabel *pStatusLabel = new CStatusLabel( this, sTmp );
|
|
|
|
sTmp.sprintf( "%sStatusText", pszPrefix );
|
|
vgui::Label *pStatusText = new vgui::Label( this, sTmp, "" );
|
|
|
|
m_pPanelListPanel->AddItem( pStatusLabel, pStatusText );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CItemUploadSubPanel::SetStatus( bool bValid, const char *pszPrefix, const char *pszMessage /* = NULL */, bool bHide /* = false */ )
|
|
{
|
|
CFmtStr sTmp;
|
|
sTmp.sprintf( "%sStatusLabel", pszPrefix );
|
|
|
|
CStatusLabel *pStatusLabel = dynamic_cast< CStatusLabel * >( m_pPanelListPanel->FindChildByName( sTmp, true ) );
|
|
if ( pStatusLabel )
|
|
{
|
|
pStatusLabel->SetValid( bValid );
|
|
pStatusLabel->SetVisible( !bHide );
|
|
}
|
|
|
|
sTmp.sprintf( "%sStatusText", pszPrefix );
|
|
vgui::Label *pStatusText = dynamic_cast< vgui::Label * >( m_pPanelListPanel->FindChildByName( sTmp, true ) );
|
|
if ( pStatusText )
|
|
{
|
|
if ( pszMessage )
|
|
{
|
|
pStatusText->SetText( pszMessage );
|
|
}
|
|
else
|
|
{
|
|
sTmp.sprintf( "#%s%s", pszPrefix, bValid ? "Valid" : "Invalid" );
|
|
pStatusText->SetText( sTmp );
|
|
}
|
|
|
|
pStatusText->SetVisible( !bHide );
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
//
|
|
//=============================================================================
|
|
class CFileLocationPanel : public vgui::Panel
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CFileLocationPanel, vgui::Panel );
|
|
|
|
public:
|
|
|
|
CFileLocationPanel( vgui::Panel *pParent, int nLodIndex )
|
|
: BaseClass( pParent )
|
|
{
|
|
m_pButtonBrowse = new vgui::Button( this, "BrowseButton", "#BrowseButton", pParent );
|
|
m_pButtonBrowse->SetCommand( new KeyValues( "Open" ) );
|
|
m_pButtonBrowse->AddActionSignalTarget( pParent );
|
|
|
|
m_pLabel = new vgui::Label( this, "FileLabel", "" );
|
|
}
|
|
|
|
virtual void PerformLayout()
|
|
{
|
|
BaseClass::PerformLayout();
|
|
|
|
int w = 0;
|
|
int h = 0;
|
|
GetSize( w, h );
|
|
|
|
m_pButtonBrowse->SizeToContents();
|
|
|
|
SetTall( m_pButtonBrowse->GetTall() );
|
|
|
|
m_pButtonBrowse->SetPos( w - m_pButtonBrowse->GetWide(), 0 );
|
|
m_pLabel->SetSize( w - m_pButtonBrowse->GetWide(), m_pButtonBrowse->GetTall() );
|
|
m_pLabel->SetPos( 0, 0 );
|
|
}
|
|
|
|
vgui::Button *m_pButtonBrowse;
|
|
vgui::Label *m_pLabel;
|
|
|
|
};
|
|
|
|
|
|
//=============================================================================
|
|
//
|
|
//=============================================================================
|
|
class CLODFileLocationPanel : public vgui::Panel
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CLODFileLocationPanel, vgui::Panel );
|
|
|
|
public:
|
|
|
|
CLODFileLocationPanel( vgui::Panel *pParent, int nLodIndex )
|
|
: BaseClass( pParent )
|
|
{
|
|
CFmtStr sButtonDelete;
|
|
sButtonDelete.sprintf( "#LOD%dDelete", nLodIndex );
|
|
|
|
m_pButtonDelete = new vgui::Button( this, sButtonDelete, sButtonDelete );
|
|
m_pButtonDelete->SetCommand( new KeyValues( "Delete", "nLODIndex", nLodIndex ) );
|
|
m_pButtonDelete->AddActionSignalTarget( pParent );
|
|
|
|
CFmtStr sButton;
|
|
sButton.sprintf( "#LOD%dButton", nLodIndex );
|
|
|
|
m_pButtonBrowse = new vgui::Button( this, sButton, sButton, pParent );
|
|
m_pButtonBrowse->SetCommand( new KeyValues( "Open", "nLODIndex", nLodIndex ) );
|
|
m_pButtonBrowse->AddActionSignalTarget( pParent );
|
|
|
|
CFmtStr sTextEntry;
|
|
sTextEntry.sprintf( "#LOD%dTextEntry", nLodIndex );
|
|
|
|
m_pLabel = new vgui::Label( this, sTextEntry, "" );
|
|
}
|
|
|
|
virtual void PerformLayout()
|
|
{
|
|
BaseClass::PerformLayout();
|
|
|
|
int w = 0;
|
|
int h = 0;
|
|
GetSize( w, h );
|
|
|
|
m_pButtonDelete->SizeToContents();
|
|
m_pButtonBrowse->SizeToContents();
|
|
|
|
SetTall( m_pButtonBrowse->GetTall() );
|
|
|
|
m_pButtonDelete->SetPos( w - m_pButtonDelete->GetWide(), 0 );
|
|
m_pButtonBrowse->SetPos( w - ( m_pButtonDelete->GetWide() + m_pButtonBrowse->GetWide() ), 0 );
|
|
m_pLabel->SetSize( w - ( m_pButtonDelete->GetWide() + m_pButtonBrowse->GetWide() ), m_pButtonBrowse->GetTall() );
|
|
m_pLabel->SetPos( 0, 0 );
|
|
}
|
|
|
|
vgui::Button *m_pButtonBrowse;
|
|
vgui::Button *m_pButtonDelete;
|
|
vgui::Label *m_pLabel;
|
|
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CGeometrySubPanel::CGeometrySubPanel( vgui::Panel *pParent, const char *pszName, const char *pszNextName )
|
|
: BaseClass( pParent, pszName, pszNextName )
|
|
{
|
|
m_pFileOpenStateMachine = new vgui::FileOpenStateMachine( this, this );
|
|
m_pFileOpenStateMachine->AddActionSignalTarget( this );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CGeometrySubPanel::UpdateGUI()
|
|
{
|
|
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
|
|
if ( !pItemUploadWizard )
|
|
return;
|
|
|
|
CAsset &asset = pItemUploadWizard->Asset();
|
|
|
|
int nGeometryCount = m_pPanelListPanel->GetItemCount() / 2;
|
|
|
|
for ( int i = 0; i < asset.TargetDMXCount(); ++i )
|
|
{
|
|
if ( i >= nGeometryCount )
|
|
{
|
|
AddGeometry();
|
|
nGeometryCount = m_pPanelListPanel->GetItemCount() / 2;
|
|
}
|
|
|
|
if ( i >= nGeometryCount )
|
|
break; // unrecoverable error
|
|
|
|
CLODFileLocationPanel *pFileLocationPanel = dynamic_cast< CLODFileLocationPanel * >( m_pPanelListPanel->GetItemPanel( i * 2 ) );
|
|
if ( !pFileLocationPanel )
|
|
continue;
|
|
|
|
vgui::Label *pLabel = pFileLocationPanel->m_pLabel;
|
|
if ( !pLabel )
|
|
continue;
|
|
|
|
CSmartPtr< CTargetDMX > pTargetDmx = asset.GetTargetDMX( i );
|
|
if ( !pTargetDmx )
|
|
continue;
|
|
|
|
pLabel->SetText( pTargetDmx->GetInputFile().Get() );
|
|
}
|
|
|
|
// Ensure an empty blank one at the end
|
|
if ( nGeometryCount == asset.TargetDMXCount() )
|
|
{
|
|
AddGeometry();
|
|
}
|
|
else
|
|
{
|
|
// Remove superfluous
|
|
while ( m_pPanelListPanel->GetItemCount() / 2 > ( asset.TargetDMXCount() + 1 ) )
|
|
{
|
|
m_pPanelListPanel->RemoveItem( m_pPanelListPanel->GetItemCount() - 1 );
|
|
m_pPanelListPanel->RemoveItem( m_pPanelListPanel->GetItemCount() - 1 );
|
|
}
|
|
|
|
// Set last one to empty
|
|
if ( ( m_pPanelListPanel->GetItemCount() / 2 ) == ( asset.TargetDMXCount() + 1 ) )
|
|
{
|
|
CLODFileLocationPanel *pFileLocationPanel = dynamic_cast< CLODFileLocationPanel * >( m_pPanelListPanel->GetItemPanel( m_pPanelListPanel->GetItemCount() - 2 ) );
|
|
if ( pFileLocationPanel )
|
|
{
|
|
vgui::Label *pLabel = pFileLocationPanel->m_pLabel;
|
|
if ( pLabel )
|
|
{
|
|
pLabel->SetText( "" );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
UpdateStatus();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool CGeometrySubPanel::UpdateStatus()
|
|
{
|
|
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
|
|
if ( !pItemUploadWizard )
|
|
return false;
|
|
|
|
CAsset &asset = pItemUploadWizard->Asset();
|
|
|
|
CFmtStr sTmp;
|
|
CFmtStr sErrString;
|
|
|
|
int nLODIndex = 0;
|
|
int nThisPolyCount = 0;
|
|
int nLastPolyCount = 0;
|
|
|
|
for ( int i = 0; i < m_pPanelListPanel->GetItemCount(); i += 2, ++nLODIndex )
|
|
{
|
|
CLODFileLocationPanel *pFileLocationPanel = dynamic_cast< CLODFileLocationPanel * >( m_pPanelListPanel->GetItemPanel( i ) );
|
|
if ( !pFileLocationPanel )
|
|
continue;
|
|
|
|
vgui::Label *pLabel = pFileLocationPanel->m_pLabel;
|
|
if ( !pLabel )
|
|
continue;
|
|
|
|
if ( i == ( m_pPanelListPanel->GetItemCount() - 4 ) )
|
|
{
|
|
pFileLocationPanel->m_pButtonDelete->SetEnabled( true );
|
|
}
|
|
else
|
|
{
|
|
pFileLocationPanel->m_pButtonDelete->SetEnabled( false );
|
|
}
|
|
|
|
sTmp.sprintf( "LOD%d", nLODIndex );
|
|
|
|
if ( i < ( m_pPanelListPanel->GetItemCount() - 2 ) )
|
|
{
|
|
CSmartPtr< CTargetDMX > pTargetDMX = asset.GetTargetDMX( nLODIndex );
|
|
|
|
if ( !pTargetDMX )
|
|
{
|
|
sErrString.sprintf( "Invalid Geometry: LOD %d is NULL", nLODIndex );
|
|
SetStatus( false, sTmp, sErrString );
|
|
continue;
|
|
}
|
|
|
|
CUtlString sStatusMsg;
|
|
if ( !pTargetDMX->IsOk( sStatusMsg ) )
|
|
{
|
|
SetStatus( false, sStatusMsg.Get() );
|
|
continue;
|
|
}
|
|
|
|
nLastPolyCount = nThisPolyCount;
|
|
nThisPolyCount = pTargetDMX->GetPolyCount();
|
|
|
|
if ( nThisPolyCount <= 0 )
|
|
{
|
|
sErrString.sprintf( "LOD %d has bad polygon count: %d", i, nThisPolyCount );
|
|
SetStatus( false, sTmp, sErrString );
|
|
continue;
|
|
}
|
|
|
|
if ( ( i > 0 ) && ( nThisPolyCount == nLastPolyCount ) )
|
|
{
|
|
sErrString.sprintf( "LOD %d (%d polys) has the same number of polygons as previous LOD %d (%d polys)",
|
|
nLODIndex, nThisPolyCount, nLODIndex - 1, nLastPolyCount );
|
|
SetStatus( false, sTmp, sErrString );
|
|
continue;
|
|
}
|
|
|
|
if ( ( i > 0 ) && ( nThisPolyCount >= nLastPolyCount ) )
|
|
{
|
|
sErrString.sprintf( "LOD %d (%d polys) has more polygons than previous LOD %d (%d polys)",
|
|
nLODIndex, nThisPolyCount, nLODIndex - 1, nLastPolyCount );
|
|
SetStatus( false, sTmp, sErrString );
|
|
continue;
|
|
}
|
|
|
|
SetStatus( true, sTmp );
|
|
}
|
|
else
|
|
{
|
|
SetStatus( true, sTmp, NULL, true );
|
|
}
|
|
}
|
|
|
|
bool bValid = BaseClass::UpdateStatus();
|
|
|
|
// In this case there are more validation checks to be performed
|
|
|
|
// Ensure each LOD is non-empty
|
|
if ( bValid )
|
|
{
|
|
sErrString.Clear();
|
|
|
|
// Ensure at least two LODs
|
|
if ( CItemUpload::GetDevMode() )
|
|
{
|
|
if ( asset.TargetDMXCount() < 1 )
|
|
{
|
|
bValid = false;
|
|
sErrString.sprintf( "At least 1 LOD is required" );
|
|
}
|
|
}
|
|
else if ( asset.TargetDMXCount() < 2 )
|
|
{
|
|
bValid = false;
|
|
sErrString.sprintf( "At least 2 LODs are required" );
|
|
}
|
|
|
|
// Any other overall checks can go here
|
|
|
|
m_pStatusLabel->SetValid( bValid );
|
|
|
|
if ( !bValid )
|
|
{
|
|
// Not sure how to translate this message with parameters, etc...
|
|
m_pStatusText->SetText( sErrString );
|
|
}
|
|
|
|
pItemUploadWizard->SetNextButtonEnabled( bValid );
|
|
}
|
|
|
|
return bValid;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CGeometrySubPanel::SetupFileOpenDialog(
|
|
vgui::FileOpenDialog *pDialog,
|
|
bool bOpenFile,
|
|
const char *pszFileName,
|
|
KeyValues *pContextKeyValues )
|
|
{
|
|
char pszStartingDir[ MAX_PATH ];
|
|
if ( !vgui::system()->GetRegistryString(
|
|
"HKEY_CURRENT_USER\\Software\\Valve\\itemtest\\geometry\\opendir",
|
|
pszStartingDir, sizeof( pszStartingDir ) ) )
|
|
{
|
|
_getcwd( pszStartingDir, ARRAYSIZE( pszStartingDir ));
|
|
|
|
CUtlString sVMod;
|
|
CUtlString sContentDir;
|
|
if ( CItemUpload::GetVMod( sVMod ) && !sVMod.IsEmpty() && CItemUpload::GetContentDir( sContentDir ) && !sContentDir.IsEmpty() && CItemUpload::FileExists( sContentDir.Get() ) )
|
|
{
|
|
sContentDir += "/";
|
|
sContentDir += sVMod;
|
|
sContentDir += "/models";
|
|
|
|
CUtlString sTmp = sContentDir;
|
|
sTmp += "/player";
|
|
|
|
if ( CItemUpload::FileExists( sTmp.Get() ) )
|
|
{
|
|
sContentDir = sTmp;
|
|
sTmp += "/items";
|
|
|
|
if ( CItemUpload::FileExists( sTmp.Get() ) )
|
|
{
|
|
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
|
|
if ( pItemUploadWizard )
|
|
{
|
|
CAsset &asset = pItemUploadWizard->Asset();
|
|
|
|
sContentDir = sTmp;
|
|
sTmp += "/";
|
|
sTmp += asset.GetClass();
|
|
}
|
|
|
|
// TODO: Add steam id?
|
|
|
|
V_FixupPathName( pszStartingDir, ARRAYSIZE( pszStartingDir ), sTmp.Get() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pDialog->SetStartDirectoryContext( "itemtest_geometry_browser", pszStartingDir );
|
|
|
|
if ( bOpenFile )
|
|
{
|
|
pDialog->AddFilter( "*.obj", "OBJ File (*.obj)", true, "obj" );
|
|
pDialog->AddFilter( "*.smd", "Valve SMD File (*.smd)", false, "smd" );
|
|
pDialog->AddFilter( "*.dmx", "Valve DMX File (*.dmx)", false, "dmx" );
|
|
pDialog->AddFilter( "*.*", "All Files (*.*)", false, "geometry" );
|
|
|
|
pDialog->SetTitle( "Open Geometry ( OBJ/SMD/DMX ) File", true );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool CGeometrySubPanel::OnReadFileFromDisk(
|
|
const char *pszFileName,
|
|
const char *pszFileFormat,
|
|
KeyValues *pContextKeyValues )
|
|
{
|
|
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
|
|
if ( !pItemUploadWizard )
|
|
return false;
|
|
|
|
const int nLODIndex = pContextKeyValues->GetInt( "nLODIndex", -1 );
|
|
if ( nLODIndex < 0 )
|
|
return false;
|
|
|
|
char szBuf0[ MAX_PATH ];
|
|
char szBuf1[ MAX_PATH ];
|
|
|
|
// Extract path and save to registry to open browser there next time
|
|
{
|
|
V_strncpy( szBuf0, pszFileName, sizeof( szBuf0 ) );
|
|
V_FixSlashes( szBuf0 );
|
|
V_StripFilename( szBuf0 );
|
|
|
|
_fullpath( szBuf1, szBuf0, ARRAYSIZE( szBuf1 ) );
|
|
|
|
vgui::system()->SetRegistryString(
|
|
"HKEY_CURRENT_USER\\Software\\Valve\\itemtest\\geometry\\opendir",
|
|
szBuf1 );
|
|
}
|
|
|
|
// Get the full path
|
|
_fullpath( szBuf1, pszFileName, ARRAYSIZE( szBuf1 ) );
|
|
|
|
CAsset &asset = pItemUploadWizard->Asset();
|
|
|
|
for ( int i = 0; i < asset.TargetDMXCount(); ++i )
|
|
{
|
|
CSmartPtr< CTargetDMX > pTargetDMX = asset.GetTargetDMX( i );
|
|
if ( !pTargetDMX )
|
|
continue;
|
|
|
|
if ( !V_strcmp( pTargetDMX->GetInputFile().Get(), szBuf1 ) )
|
|
{
|
|
vgui::MessageBox *pMessageBox = new vgui::MessageBox( "#duplicate_file_title", "#duplicate_file_text", this );
|
|
if ( pMessageBox )
|
|
{
|
|
pMessageBox->SetSize( 640, 480 );
|
|
pMessageBox->SetMinimumSize( 320, 120 );
|
|
|
|
pMessageBox->DoModal();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool bRet = false;
|
|
|
|
if ( nLODIndex < asset.TargetDMXCount() )
|
|
{
|
|
bRet = asset.SetTargetDMX( nLODIndex, szBuf1 );
|
|
}
|
|
else if ( nLODIndex == asset.TargetDMXCount() )
|
|
{
|
|
const int nCheck = asset.AddTargetDMX( szBuf1 );
|
|
Assert( nCheck == nLODIndex );
|
|
bRet = ( nCheck >= 0 );
|
|
}
|
|
|
|
UpdateGUI();
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool CGeometrySubPanel::OnWriteFileToDisk(
|
|
const char *pszFileName,
|
|
const char *pszFileFormat,
|
|
KeyValues *pContextKeyValues )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CGeometrySubPanel::OnOpen( int nLodIndex )
|
|
{
|
|
KeyValues *pContextKeyValues = new KeyValues( "FileOpen", "nLODIndex", nLodIndex );
|
|
m_pFileOpenStateMachine->OpenFile( "geometry", pContextKeyValues );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CGeometrySubPanel::OnDelete( int nLodIndex )
|
|
{
|
|
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
|
|
if ( !pItemUploadWizard )
|
|
return;
|
|
|
|
CAsset &asset = pItemUploadWizard->Asset();
|
|
|
|
asset.RemoveTargetDMX( nLodIndex );
|
|
|
|
UpdateGUI();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CGeometrySubPanel::AddGeometry()
|
|
{
|
|
const int nLodIndex = m_pPanelListPanel->GetItemCount() / 2;
|
|
|
|
CFmtStr sLabel;
|
|
sLabel.sprintf( "#LOD%dLabel", nLodIndex );
|
|
|
|
vgui::Label *pLabel = new vgui::Label( this, sLabel, sLabel );
|
|
pLabel->SetContentAlignment( vgui::Label::a_center );
|
|
|
|
CLODFileLocationPanel *pFileLocationPanel = new CLODFileLocationPanel( this, nLodIndex );
|
|
m_pPanelListPanel->AddItem( pLabel, pFileLocationPanel );
|
|
pFileLocationPanel->m_pLabel->AddActionSignalTarget( this );
|
|
pFileLocationPanel->m_pButtonBrowse->AddActionSignalTarget( this );
|
|
|
|
sLabel.sprintf( "lod%d", nLodIndex );
|
|
AddStatusPanels( sLabel );
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
//
|
|
//=============================================================================
|
|
class CVmtEntry : public CDualPanelList
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CVmtEntry, CDualPanelList );
|
|
public:
|
|
|
|
MESSAGE_FUNC_PTR( OnTextChanged, "TextChanged", panel );
|
|
MESSAGE_FUNC_PTR( OnOpen, "Open", panel );
|
|
|
|
CVmtEntry( CMaterialSubPanel *pMaterialSubPanel, const char *pszName, int nVmtIndex )
|
|
: CDualPanelList( pMaterialSubPanel, pszName )
|
|
, m_pMaterialSubPanel( pMaterialSubPanel )
|
|
, m_nVmtIndex( nVmtIndex )
|
|
{
|
|
{
|
|
vgui::Label *pMaterialLabel = new vgui::Label( this, "MaterialLabel", "#MaterialLabel" );
|
|
m_pMaterialName = new vgui::Label( this, "MaterialName", "#MaterialName" );
|
|
|
|
AddItem( pMaterialLabel, m_pMaterialName );
|
|
}
|
|
|
|
{
|
|
vgui::Label *pMaterialTypeLabel = new vgui::Label( this, "MaterialTypeLabel", "#MaterialTypeLabel" );
|
|
m_pMaterialType = new vgui::ComboBox( this, "MaterialTypeComboBox", 0, false );
|
|
m_pMaterialType->AddItem( "#Invalid", new KeyValues( "Invalid" ) );
|
|
m_pMaterialType->AddItem( "#Primary", new KeyValues( "Primary" ) );
|
|
m_pMaterialType->AddItem( "#Secondary", new KeyValues( "Secondary" ) );
|
|
m_pMaterialType->AddItem( "#DuplicateOfPrimary", new KeyValues( "DuplicateOfPrimary" ) );
|
|
m_pMaterialType->AddItem( "#DuplicateOfSecondary", new KeyValues( "DuplicateOfSecondary" ) );
|
|
m_pMaterialType->AddActionSignalTarget( this );
|
|
|
|
AddItem( pMaterialTypeLabel, m_pMaterialType );
|
|
}
|
|
|
|
{
|
|
vgui::Label *pRedBlueLabel = new vgui::Label( this, "CommonRedBlueLabel", "#CommonRedBlueLabel" );
|
|
m_pCommonRedBlue = new vgui::ComboBox( this, "CommonRedBlue", 0, false );
|
|
m_pCommonRedBlue->AddItem( "#Common", new KeyValues( "Common" ) );
|
|
m_pCommonRedBlue->AddItem( "#RedAndBlue", new KeyValues( "RedAndBlue" ) );
|
|
m_pCommonRedBlue->AddActionSignalTarget( this );
|
|
|
|
m_nCommonRedBlueId = AddItem( pRedBlueLabel, m_pCommonRedBlue );
|
|
}
|
|
|
|
{
|
|
vgui::Label *pCommonTextureLabel = new vgui::Label( this, "CommonTextureLabel", "#CommonTextureLabel" );
|
|
m_pCommonTextureFileLocation = new CFileLocationPanel( this, 0 );
|
|
|
|
m_nCommonId = AddItem( pCommonTextureLabel, m_pCommonTextureFileLocation );
|
|
}
|
|
|
|
{
|
|
vgui::Label *pRedTextureLabel = new vgui::Label( this, "RedTextureLabel", "#RedTextureLabel" );
|
|
m_pRedTextureFileLocation = new CFileLocationPanel( this, 1 );
|
|
|
|
m_nRedId = AddItem( pRedTextureLabel, m_pRedTextureFileLocation );
|
|
}
|
|
|
|
{
|
|
vgui::Label *pBlueTextureLabel = new vgui::Label( this, "BlueTextureLabel", "#BlueTextureLabel" );
|
|
m_pBlueTextureFileLocation = new CFileLocationPanel( this, 1 );
|
|
|
|
m_nBlueId = AddItem( pBlueTextureLabel, m_pBlueTextureFileLocation );
|
|
}
|
|
|
|
{
|
|
vgui::Label *pColorAlphaLabel = new vgui::Label( this, "ColorAlphaLabel", "#ColorAlphaLabel" );
|
|
|
|
m_pColorAlpha = new vgui::ComboBox( this, "ColorAlphaComboBox", 0, false );
|
|
m_pColorAlpha->AddItem( "#Nothing", new KeyValues( "None" ) );
|
|
m_pColorAlpha->AddItem( "#Transparency", new KeyValues( "Transparency" ) );
|
|
m_pColorAlpha->AddItem( "#Paintable", new KeyValues( "Paintable" ) );
|
|
m_pColorAlpha->AddItem( "#SpecPhong", new KeyValues( "SpecPhong" ) );
|
|
m_pColorAlpha->AddActionSignalTarget( this );
|
|
|
|
m_nColorAlphaId = AddItem( pColorAlphaLabel, m_pColorAlpha );
|
|
}
|
|
|
|
{
|
|
vgui::Label *pNormalMapLabel = new vgui::Label( this, "NormalMapLabel", "#NormalMapLabel" );
|
|
m_pNormalTextureFileLocation = new CFileLocationPanel( this, 2 );
|
|
|
|
m_nNormalId = AddItem( pNormalMapLabel, m_pNormalTextureFileLocation );
|
|
}
|
|
|
|
{
|
|
vgui::Label *pNormalAlphaLabel = new vgui::Label( this, "NormalAlphaLabel", "#NormalAlphaLabel" );
|
|
|
|
m_pNormalAlpha = new vgui::ComboBox( this, "NormalAlphaComboBox", 0, false );
|
|
m_pNormalAlpha->AddItem( "#Nothing", new KeyValues( "None" ) );
|
|
m_pNormalAlpha->AddItem( "#SpecPhong", new KeyValues( "SpecPhong" ) );
|
|
m_pNormalAlpha->AddActionSignalTarget( this );
|
|
|
|
m_nNormalAlphaId = AddItem( pNormalAlphaLabel, m_pNormalAlpha );
|
|
}
|
|
|
|
m_pCommonRedBlue->ActivateItem( 0 );
|
|
SetItemVisible( m_nColorAlphaId, false );
|
|
m_pColorAlpha->SilentActivateItem( 0 );
|
|
SetItemVisible( m_nNormalAlphaId, false );
|
|
m_pNormalAlpha->SilentActivateItem( 0 );
|
|
}
|
|
|
|
int m_nCommonRedBlueId;
|
|
int m_nCommonId;
|
|
int m_nRedId;
|
|
int m_nBlueId;
|
|
int m_nColorAlphaId;
|
|
int m_nNormalId;
|
|
int m_nNormalAlphaId;
|
|
|
|
vgui::Label *m_pMaterialName;
|
|
vgui::ComboBox *m_pMaterialType;
|
|
vgui::ComboBox *m_pCommonRedBlue;
|
|
CFileLocationPanel *m_pCommonTextureFileLocation;
|
|
CFileLocationPanel *m_pRedTextureFileLocation;
|
|
CFileLocationPanel *m_pBlueTextureFileLocation;
|
|
vgui::ComboBox *m_pColorAlpha;
|
|
CFileLocationPanel *m_pNormalTextureFileLocation;
|
|
vgui::ComboBox *m_pNormalAlpha;
|
|
|
|
CMaterialSubPanel *m_pMaterialSubPanel;
|
|
|
|
int m_nVmtIndex;
|
|
|
|
void SetMaterialId( const char *pszMaterialName )
|
|
{
|
|
if ( !m_pMaterialName )
|
|
return;
|
|
|
|
m_pMaterialName->SetText( pszMaterialName );
|
|
}
|
|
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CVmtEntry::OnTextChanged( vgui::Panel *pPanel )
|
|
{
|
|
CTargetVMT *pTargetVMT = m_pMaterialSubPanel->GetTargetVMT( m_nVmtIndex );
|
|
if ( !pTargetVMT )
|
|
return;
|
|
|
|
bool bUpdate = false;
|
|
|
|
if ( pPanel == m_pMaterialType )
|
|
{
|
|
KeyValues *pUserData = m_pMaterialType->GetActiveItemUserData();
|
|
if ( pUserData )
|
|
{
|
|
if ( !V_strcmp( "Invalid", pUserData->GetName() ) )
|
|
{
|
|
pTargetVMT->SetMaterialType( CTargetVMT::kInvalidMaterialType );
|
|
}
|
|
else if ( !V_strcmp( "Primary", pUserData->GetName() ) )
|
|
{
|
|
pTargetVMT->SetMaterialType( CTargetVMT::kPrimary );
|
|
}
|
|
else if ( !V_strcmp( "Secondary", pUserData->GetName() ) )
|
|
{
|
|
pTargetVMT->SetMaterialType( CTargetVMT::kSecondary );
|
|
}
|
|
else if ( !V_strcmp( "DuplicateOfPrimary", pUserData->GetName() ) )
|
|
{
|
|
pTargetVMT->SetDuplicate( CTargetVMT::kPrimary );
|
|
}
|
|
else if ( !V_strcmp( "DuplicateOfSecondary", pUserData->GetName() ) )
|
|
{
|
|
pTargetVMT->SetDuplicate( CTargetVMT::kSecondary );
|
|
}
|
|
else
|
|
{
|
|
AssertMsg1( 0, "Unknown Material Type: %s\n", pUserData->GetName() );
|
|
}
|
|
|
|
bUpdate = true;
|
|
}
|
|
}
|
|
else if ( pPanel == m_pCommonRedBlue )
|
|
{
|
|
KeyValues *pUserData = m_pCommonRedBlue->GetActiveItemUserData();
|
|
if ( pUserData )
|
|
{
|
|
const bool bCommon = !V_strcmp( "Common", pUserData->GetName() );
|
|
|
|
pTargetVMT->SetColorMapCommon( bCommon );
|
|
|
|
bUpdate = true;
|
|
}
|
|
}
|
|
else if ( pPanel == m_pColorAlpha )
|
|
{
|
|
KeyValues *pUserData = m_pColorAlpha->GetActiveItemUserData();
|
|
if ( pUserData )
|
|
{
|
|
const char *pszUserData = pUserData->GetName();
|
|
|
|
if ( StringHasPrefix( pszUserData, "T" ) )
|
|
{
|
|
pTargetVMT->SetColorAlphaType( CTargetVMT::kTransparency );
|
|
}
|
|
else if ( StringHasPrefix( pszUserData, "P" ) )
|
|
{
|
|
pTargetVMT->SetColorAlphaType( CTargetVMT::kPaintable );
|
|
}
|
|
else if ( StringHasPrefix( pszUserData, "S" ) )
|
|
{
|
|
pTargetVMT->SetColorAlphaType( CTargetVMT::kColorSpecPhong );
|
|
}
|
|
else
|
|
{
|
|
pTargetVMT->SetColorAlphaType( CTargetVMT::kNoColorAlpha );
|
|
}
|
|
|
|
bUpdate = true;
|
|
}
|
|
}
|
|
else if ( pPanel == m_pNormalAlpha )
|
|
{
|
|
KeyValues *pUserData = m_pNormalAlpha->GetActiveItemUserData();
|
|
if ( pUserData )
|
|
{
|
|
const char *pszUserData = pUserData->GetName();
|
|
|
|
if ( StringHasPrefix( pszUserData, "S" ) )
|
|
{
|
|
pTargetVMT->SetNormalAlphaType( CTargetVMT::kNormalSpecPhong );
|
|
}
|
|
else
|
|
{
|
|
pTargetVMT->SetNormalAlphaType( CTargetVMT::kNoNormalAlpha );
|
|
}
|
|
|
|
bUpdate = true;
|
|
}
|
|
}
|
|
|
|
if ( bUpdate )
|
|
{
|
|
InvalidateLayout();
|
|
m_pMaterialSubPanel->InvalidateLayout();
|
|
m_pMaterialSubPanel->UpdateGUI();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CVmtEntry::OnOpen( vgui::Panel *pPanel )
|
|
{
|
|
if ( !m_pMaterialSubPanel )
|
|
return;
|
|
|
|
if ( pPanel == m_pCommonTextureFileLocation->m_pButtonBrowse )
|
|
{
|
|
m_pMaterialSubPanel->Browse( this, CMaterialSubPanel::kCommon );
|
|
}
|
|
else if ( pPanel == m_pRedTextureFileLocation->m_pButtonBrowse )
|
|
{
|
|
m_pMaterialSubPanel->Browse( this, CMaterialSubPanel::kRed );
|
|
}
|
|
else if ( pPanel == m_pBlueTextureFileLocation->m_pButtonBrowse )
|
|
{
|
|
m_pMaterialSubPanel->Browse( this, CMaterialSubPanel::kBlue );
|
|
}
|
|
else if ( pPanel == m_pNormalTextureFileLocation->m_pButtonBrowse )
|
|
{
|
|
m_pMaterialSubPanel->Browse( this, CMaterialSubPanel::kNormal );
|
|
}
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
//
|
|
//=============================================================================
|
|
CMaterialSubPanel::CMaterialSubPanel( vgui::Panel *pParent, const char *pszName, const char *pszNextName )
|
|
: BaseClass( pParent, pszName, pszNextName )
|
|
{
|
|
m_pFileOpenStateMachine = new vgui::FileOpenStateMachine( this, this );
|
|
m_pFileOpenStateMachine->AddActionSignalTarget( this );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CMaterialSubPanel::InvalidateLayout()
|
|
{
|
|
BaseClass::InvalidateLayout();
|
|
m_pPanelListPanel->InvalidateLayout();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CMaterialSubPanel::UpdateGUI()
|
|
{
|
|
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
|
|
if ( !pItemUploadWizard )
|
|
return;
|
|
|
|
CAsset &asset = pItemUploadWizard->Asset();
|
|
|
|
int nMaterialCount = m_pPanelListPanel->GetItemCount() / 2;
|
|
|
|
CFmtStr sTmp;
|
|
|
|
// Add new gui elements & update existing
|
|
for ( int i = 0; i < asset.GetTargetVMTCount(); ++i )
|
|
{
|
|
if ( i >= nMaterialCount )
|
|
{
|
|
AddMaterial();
|
|
nMaterialCount = m_pPanelListPanel->GetItemCount() / 2;
|
|
}
|
|
|
|
if ( i >= nMaterialCount )
|
|
break; // unrecoverable error
|
|
|
|
CTargetVMT *pTargetVmt = asset.GetTargetVMT( i );
|
|
Assert( pTargetVmt );
|
|
|
|
if ( !pTargetVmt )
|
|
continue;
|
|
|
|
CVmtEntry *pVmtEntry = dynamic_cast< CVmtEntry * >( m_pPanelListPanel->GetItemPanel( i * 2 ) );
|
|
if ( !pVmtEntry )
|
|
continue;
|
|
|
|
CUtlString sMaterialId;
|
|
pTargetVmt->GetMaterialId( sMaterialId );
|
|
pVmtEntry->SetMaterialId( sMaterialId.Get() );
|
|
|
|
const bool bCommon = pTargetVmt->GetColorMapCommon();
|
|
|
|
pVmtEntry->m_pCommonRedBlue->SilentActivateItemByRow( bCommon ? 0 : 1 );
|
|
|
|
bool bVisible = true;
|
|
|
|
if ( pTargetVmt->GetDuplicate() )
|
|
{
|
|
bVisible = false;
|
|
|
|
switch ( pTargetVmt->GetMaterialType() )
|
|
{
|
|
case CTargetVMT::kInvalidMaterialType:
|
|
pVmtEntry->m_pMaterialType->SilentActivateItemByRow( 0 );
|
|
break;
|
|
case CTargetVMT::kPrimary:
|
|
pVmtEntry->m_pMaterialType->SilentActivateItemByRow( 3 );
|
|
break;
|
|
case CTargetVMT::kSecondary:
|
|
pVmtEntry->m_pMaterialType->SilentActivateItemByRow( 4 );
|
|
break;
|
|
default:
|
|
pVmtEntry->m_pMaterialType->ActivateItem( 0 );
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch ( pTargetVmt->GetMaterialType() )
|
|
{
|
|
case CTargetVMT::kInvalidMaterialType:
|
|
pVmtEntry->m_pMaterialType->SilentActivateItemByRow( 0 );
|
|
break;
|
|
case CTargetVMT::kPrimary:
|
|
pVmtEntry->m_pMaterialType->SilentActivateItemByRow( 1 );
|
|
break;
|
|
case CTargetVMT::kSecondary:
|
|
pVmtEntry->m_pMaterialType->SilentActivateItemByRow( 2 );
|
|
break;
|
|
default:
|
|
pVmtEntry->m_pMaterialType->ActivateItem( 0 );
|
|
break;
|
|
}
|
|
}
|
|
|
|
pVmtEntry->SetItemVisible( pVmtEntry->m_nCommonRedBlueId, bVisible );
|
|
pVmtEntry->SetItemVisible( pVmtEntry->m_nCommonId, bVisible && bCommon );
|
|
pVmtEntry->SetItemVisible( pVmtEntry->m_nRedId, bVisible && !bCommon );
|
|
pVmtEntry->SetItemVisible( pVmtEntry->m_nBlueId, bVisible && !bCommon );
|
|
pVmtEntry->SetItemVisible( pVmtEntry->m_nNormalId, bVisible );
|
|
|
|
bool bColorVisible = false;
|
|
|
|
CSmartPtr< CTargetVTF > pCommonTargetVTF = pTargetVmt->GetCommonTargetVTF();
|
|
if ( pCommonTargetVTF.IsValid() )
|
|
{
|
|
pVmtEntry->m_pCommonTextureFileLocation->m_pLabel->SetText( pCommonTargetVTF->GetInputFile() );
|
|
if ( pTargetVmt->GetColorMapCommon() && pCommonTargetVTF->HasAlpha() )
|
|
{
|
|
bColorVisible = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pVmtEntry->m_pCommonTextureFileLocation->m_pLabel->SetText( "" );
|
|
bColorVisible = false;
|
|
}
|
|
|
|
switch ( pTargetVmt->GetColorAlphaType() )
|
|
{
|
|
case CTargetVMT::kNoColorAlpha:
|
|
pVmtEntry->m_pColorAlpha->SilentActivateItemByRow( CTargetVMT::kNoColorAlpha );
|
|
break;
|
|
case CTargetVMT::kTransparency:
|
|
pVmtEntry->m_pColorAlpha->SilentActivateItemByRow( CTargetVMT::kTransparency );
|
|
break;
|
|
case CTargetVMT::kPaintable:
|
|
pVmtEntry->m_pColorAlpha->SilentActivateItemByRow( CTargetVMT::kPaintable );
|
|
break;
|
|
case CTargetVMT::kColorSpecPhong:
|
|
pVmtEntry->m_pColorAlpha->SilentActivateItemByRow( CTargetVMT::kColorSpecPhong );
|
|
break;
|
|
default:
|
|
pVmtEntry->m_pColorAlpha->SilentActivateItemByRow( CTargetVMT::kNoColorAlpha );
|
|
break;
|
|
}
|
|
|
|
CSmartPtr< CTargetVTF > pRedTargetVTF = pTargetVmt->GetRedTargetVTF();
|
|
CSmartPtr< CTargetVTF > pBlueTargetVTF = pTargetVmt->GetBlueTargetVTF();
|
|
if ( pRedTargetVTF.IsValid() )
|
|
{
|
|
pVmtEntry->m_pRedTextureFileLocation->m_pLabel->SetText( pRedTargetVTF->GetInputFile() );
|
|
}
|
|
else
|
|
{
|
|
pVmtEntry->m_pRedTextureFileLocation->m_pLabel->SetText( "" );
|
|
}
|
|
|
|
if ( pBlueTargetVTF.IsValid() )
|
|
{
|
|
pVmtEntry->m_pBlueTextureFileLocation->m_pLabel->SetText( pBlueTargetVTF->GetInputFile() );
|
|
}
|
|
else
|
|
{
|
|
pVmtEntry->m_pBlueTextureFileLocation->m_pLabel->SetText( "" );
|
|
}
|
|
|
|
if ( !pTargetVmt->GetColorMapCommon() && pRedTargetVTF.IsValid() && pBlueTargetVTF.IsValid() )
|
|
{
|
|
if ( pRedTargetVTF->HasAlpha() && pBlueTargetVTF->HasAlpha() )
|
|
{
|
|
bColorVisible = true;
|
|
}
|
|
}
|
|
|
|
pVmtEntry->SetItemVisible( pVmtEntry->m_nColorAlphaId, bVisible && bColorVisible );
|
|
|
|
bool bNormalVisible = false;
|
|
|
|
CSmartPtr< CTargetVTF > pNormalTargetVTF = pTargetVmt->GetNormalTargetVTF();
|
|
if ( pNormalTargetVTF.IsValid() )
|
|
{
|
|
pVmtEntry->m_pNormalTextureFileLocation->m_pLabel->SetText( pNormalTargetVTF->GetInputFile() );
|
|
if ( pNormalTargetVTF->HasAlpha() )
|
|
{
|
|
bNormalVisible = true;
|
|
}
|
|
}
|
|
|
|
switch ( pTargetVmt->GetNormalAlphaType() )
|
|
{
|
|
case CTargetVMT::kNoNormalAlpha:
|
|
pVmtEntry->m_pNormalAlpha->SilentActivateItemByRow( CTargetVMT::kNoNormalAlpha );
|
|
break;
|
|
case CTargetVMT::kNormalSpecPhong:
|
|
pVmtEntry->m_pNormalAlpha->SilentActivateItemByRow( CTargetVMT::kNormalSpecPhong );
|
|
break;
|
|
default:
|
|
pVmtEntry->m_pNormalAlpha->SilentActivateItemByRow( CTargetVMT::kNoNormalAlpha );
|
|
break;
|
|
}
|
|
|
|
pVmtEntry->SetItemVisible( pVmtEntry->m_nNormalAlphaId, bVisible && bNormalVisible );
|
|
|
|
pVmtEntry->InvalidateLayout();
|
|
}
|
|
|
|
// Remove superfluous
|
|
while ( ( m_pPanelListPanel->GetItemCount() / 2 ) > asset.GetTargetVMTCount() )
|
|
{
|
|
m_pPanelListPanel->RemoveItem( m_pPanelListPanel->GetItemCount() - 1 );
|
|
m_pPanelListPanel->RemoveItem( m_pPanelListPanel->GetItemCount() - 1 );
|
|
}
|
|
|
|
InvalidateLayout();
|
|
|
|
UpdateStatus();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// TODO: Set status
|
|
//-----------------------------------------------------------------------------
|
|
bool CMaterialSubPanel::UpdateStatus()
|
|
{
|
|
CFmtStr sTmp;
|
|
|
|
int nIndex = 0;
|
|
for ( int i = 0; i < m_pPanelListPanel->GetItemCount(); i += 2, ++nIndex )
|
|
{
|
|
CVmtEntry *pVmtEntry = dynamic_cast< CVmtEntry * >( m_pPanelListPanel->GetItemPanel( i ) );
|
|
if ( !pVmtEntry )
|
|
continue;
|
|
|
|
CTargetVMT *pTargetVMT = GetTargetVMT( pVmtEntry->m_nVmtIndex );
|
|
Assert( pTargetVMT );
|
|
if ( !pTargetVMT )
|
|
continue;
|
|
|
|
sTmp.sprintf( "VMT%d", nIndex );
|
|
|
|
CUtlString sMsg;
|
|
if ( pTargetVMT->IsOk( sMsg ) )
|
|
{
|
|
SetStatus( true, sTmp );
|
|
continue;
|
|
}
|
|
|
|
if ( sMsg.IsEmpty() )
|
|
{
|
|
SetStatus( false, sTmp, "VMT is not valid\n" );
|
|
}
|
|
else
|
|
{
|
|
SetStatus( false, sTmp, sMsg.Get() );
|
|
}
|
|
}
|
|
|
|
bool bValid = BaseClass::UpdateStatus();
|
|
|
|
return bValid;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CMaterialSubPanel::SetupFileOpenDialog(
|
|
vgui::FileOpenDialog *pDialog,
|
|
bool bOpenFile,
|
|
const char *pszFileName,
|
|
KeyValues *pContextKeyValues )
|
|
{
|
|
char pszStartingDir[ MAX_PATH ];
|
|
|
|
if ( !vgui::system()->GetRegistryString(
|
|
"HKEY_CURRENT_USER\\Software\\Valve\\itemtest\\texture\\opendir",
|
|
pszStartingDir, sizeof( pszStartingDir ) ) )
|
|
{
|
|
_getcwd( pszStartingDir, ARRAYSIZE( pszStartingDir ));
|
|
|
|
CUtlString sVMod;
|
|
CUtlString sContentDir;
|
|
if ( CItemUpload::GetVMod( sVMod ) && !sVMod.IsEmpty() && CItemUpload::GetContentDir( sContentDir ) && !sContentDir.IsEmpty() && CItemUpload::FileExists( sContentDir.Get() ) )
|
|
{
|
|
sContentDir += "/";
|
|
sContentDir += sVMod;
|
|
sContentDir += "/materialsrc/models";
|
|
|
|
CUtlString sTmp = sContentDir;
|
|
sTmp += "/player";
|
|
|
|
if ( CItemUpload::FileExists( sTmp.Get() ) )
|
|
{
|
|
sContentDir = sTmp;
|
|
sTmp += "/items";
|
|
|
|
if ( CItemUpload::FileExists( sTmp.Get() ) )
|
|
{
|
|
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
|
|
if ( pItemUploadWizard )
|
|
{
|
|
CAsset &asset = pItemUploadWizard->Asset();
|
|
|
|
sContentDir = sTmp;
|
|
sTmp += "/";
|
|
sTmp += asset.GetClass();
|
|
}
|
|
|
|
// TODO: Add steam id?
|
|
|
|
V_FixupPathName( pszStartingDir, ARRAYSIZE( pszStartingDir ), sTmp.Get() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pDialog->SetStartDirectoryContext( "itemtest_texture_browser", pszStartingDir );
|
|
|
|
// TODO: Remember the mask the user likes
|
|
if ( bOpenFile )
|
|
{
|
|
pDialog->AddFilter( "*.tga", "Targa TrueVision File (*.tga)", true, "tga" );
|
|
pDialog->AddFilter( "*.psd", "Photoshop Document (*.psd)", false, "psd" );
|
|
|
|
pDialog->SetTitle( "Open Texture File", true );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool CMaterialSubPanel::OnReadFileFromDisk(
|
|
const char *pszFileName,
|
|
const char *pszFileFormat,
|
|
KeyValues *pContextKeyValues )
|
|
{
|
|
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
|
|
if ( !pItemUploadWizard )
|
|
return false;
|
|
|
|
char szBuf0[ MAX_PATH ];
|
|
char szBuf1[ MAX_PATH ];
|
|
|
|
// Extract path and save to registry to open browser there next time
|
|
{
|
|
V_strncpy( szBuf0, pszFileName, sizeof( szBuf0 ) );
|
|
V_FixSlashes( szBuf0 );
|
|
V_StripFilename( szBuf0 );
|
|
|
|
_fullpath( szBuf1, szBuf0, ARRAYSIZE( szBuf1 ) );
|
|
|
|
vgui::system()->SetRegistryString(
|
|
"HKEY_CURRENT_USER\\Software\\Valve\\itemtest\\texture\\opendir",
|
|
szBuf1 );
|
|
}
|
|
|
|
// Get the full path
|
|
_fullpath( szBuf1, pszFileName, ARRAYSIZE( szBuf1 ) );
|
|
|
|
CAsset &asset = pItemUploadWizard->Asset();
|
|
|
|
CVmtEntry *pVmtEntry = reinterpret_cast< CVmtEntry * >( pContextKeyValues->GetPtr( "pVmtEntry" ) );
|
|
const Browse_t nBrowseType = static_cast< Browse_t >( pContextKeyValues->GetInt( "nBrowseType" ) );
|
|
|
|
bool bReturnVal = false;
|
|
|
|
for ( int i = 0; i < m_pPanelListPanel->GetItemCount(); i += 2 )
|
|
{
|
|
if ( pVmtEntry == dynamic_cast< CVmtEntry * >( m_pPanelListPanel->GetItemPanel( i ) ) )
|
|
{
|
|
const int nVmtIndex = i / 2;
|
|
CTargetVMT *pTargetVMT = asset.GetTargetVMT( nVmtIndex );
|
|
if ( pTargetVMT )
|
|
{
|
|
bReturnVal = true;
|
|
|
|
switch( nBrowseType )
|
|
{
|
|
case CMaterialSubPanel::kCommon:
|
|
pTargetVMT->SetCommonTargetVTF( szBuf1 );
|
|
break;
|
|
case CMaterialSubPanel::kRed:
|
|
pTargetVMT->SetRedTargetVTF( szBuf1 );
|
|
break;
|
|
case CMaterialSubPanel::kBlue:
|
|
pTargetVMT->SetBlueTargetVTF( szBuf1 );
|
|
break;
|
|
case CMaterialSubPanel::kNormal:
|
|
pTargetVMT->SetNormalTargetVTF( szBuf1 );
|
|
break;
|
|
default:
|
|
bReturnVal = false;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
UpdateGUI();
|
|
|
|
return bReturnVal;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool CMaterialSubPanel::OnWriteFileToDisk(
|
|
const char *pszFileName,
|
|
const char *pszFileFormat,
|
|
KeyValues *pContextKeyValues )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CMaterialSubPanel::Browse( CVmtEntry *pVmtEntry, Browse_t nBrowseType )
|
|
{
|
|
if ( !pVmtEntry )
|
|
return;
|
|
|
|
KeyValues *pContextKeyValues = new KeyValues( "FileOpen", "nBrowseType", nBrowseType );
|
|
pContextKeyValues->SetPtr( "pVmtEntry", pVmtEntry );
|
|
m_pFileOpenStateMachine->OpenFile( "geometry", pContextKeyValues );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CTargetVMT *CMaterialSubPanel::GetTargetVMT( int nTargetVMTIndex )
|
|
{
|
|
CItemUploadWizard *pItemUploadWizard = dynamic_cast< CItemUploadWizard * >( GetWizardPanel() );
|
|
if ( !pItemUploadWizard )
|
|
return NULL;
|
|
|
|
return pItemUploadWizard->Asset().GetTargetVMT( nTargetVMTIndex );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CMaterialSubPanel::AddMaterial()
|
|
{
|
|
const int nIndex = m_pPanelListPanel->GetItemCount() / 2;
|
|
|
|
CFmtStr sLabel;
|
|
sLabel.sprintf( "#VMT%dLabel", nIndex );
|
|
|
|
vgui::Label *pLabel = new vgui::Label( this, sLabel, sLabel );
|
|
pLabel->SetContentAlignment( vgui::Label::a_center );
|
|
|
|
sLabel.sprintf( "#VMT%dLabel2", nIndex );
|
|
|
|
CVmtEntry *pVmtEntry = new CVmtEntry( this, sLabel, nIndex );
|
|
|
|
pVmtEntry->SetAutoResize( PIN_TOPLEFT, AUTORESIZE_RIGHT, 0, 0, 0, 0 );
|
|
|
|
m_pPanelListPanel->AddItem( pLabel, pVmtEntry );
|
|
|
|
sLabel.sprintf( "vmt%d", nIndex );
|
|
AddStatusPanels( sLabel );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CItemUploadWizard::CItemUploadWizard(
|
|
vgui::Panel *pParent,
|
|
const char *pszName )
|
|
: BaseClass( pParent, pszName )
|
|
{
|
|
SetSize( 1024, 768 );
|
|
SetMinimumSize( 640, 480 );
|
|
|
|
vgui::WizardSubPanel *pSubPanel = NULL;
|
|
vgui::DHANDLE< vgui::WizardSubPanel > hSubPanel;
|
|
|
|
pSubPanel = new CGlobalSubPanel( this, "global", "geometry" );
|
|
pSubPanel->SetVisible( false );
|
|
hSubPanel = pSubPanel;
|
|
m_hSubPanelList.AddToTail( hSubPanel );
|
|
|
|
pSubPanel = new CGeometrySubPanel( this, "geometry", "texture" );
|
|
pSubPanel->SetVisible( false );
|
|
hSubPanel = pSubPanel;
|
|
m_hSubPanelList.AddToTail( hSubPanel );
|
|
|
|
pSubPanel = new CMaterialSubPanel( this, "texture", "final" );
|
|
pSubPanel->SetVisible( false );
|
|
hSubPanel = pSubPanel;
|
|
m_hSubPanelList.AddToTail( hSubPanel );
|
|
|
|
m_pFinalSubPanel = new CFinalSubPanel( this, "final", NULL );
|
|
pSubPanel = m_pFinalSubPanel;
|
|
pSubPanel->SetVisible( false );
|
|
hSubPanel = pSubPanel;
|
|
m_hSubPanelList.AddToTail( hSubPanel );
|
|
|
|
Run();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CItemUploadWizard::~CItemUploadWizard()
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CItemUploadWizard::Run()
|
|
{
|
|
vgui::WizardSubPanel *pStartPanel = dynamic_cast< vgui::WizardSubPanel * >( FindChildByName( "global" ) );
|
|
|
|
if ( !pStartPanel )
|
|
{
|
|
Error( "Missing CItemUploadWizard global Panel" );
|
|
}
|
|
|
|
BaseClass::Run( pStartPanel );
|
|
|
|
MoveToCenterOfScreen();
|
|
Activate();
|
|
|
|
vgui::input()->SetAppModalSurface( GetVPanel() );
|
|
|
|
CGlobalSubPanel *pGlobalSubPanel = dynamic_cast< CGlobalSubPanel * >( pStartPanel );
|
|
if ( pGlobalSubPanel )
|
|
{
|
|
pGlobalSubPanel->UpdateStatus();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CItemUploadWizard::UpdateGUI()
|
|
{
|
|
for ( int i = 0; i < m_hSubPanelList.Count(); ++i )
|
|
{
|
|
CItemUploadSubPanel *pSubPanel = dynamic_cast< CItemUploadSubPanel * >( m_hSubPanelList.Element( i ).Get() );
|
|
if ( !pSubPanel )
|
|
continue;
|
|
|
|
pSubPanel->UpdateGUI();
|
|
}
|
|
|
|
CItemUploadSubPanel *pItemUploadSubPanel = dynamic_cast< CItemUploadSubPanel * >( GetCurrentSubPanel() );
|
|
if ( pItemUploadSubPanel )
|
|
{
|
|
pItemUploadSubPanel->UpdateStatus();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CItemUploadWizard::OnFinishButton()
|
|
{
|
|
m_pFinalSubPanel->OnZip();
|
|
} |