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.

1348 lines
34 KiB

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Additional permissions under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#include "HeadSpin.h"
#include "plAgeDescInterface.h"
#include "max.h"
#include "resource.h"
#include "../plFile/hsFiles.h"
#include "../plAgeDescription/plAgeDescription.h"
#include "plMaxCFGFile.h"
#include "hsStream.h"
#include "hsUtils.h"
#include "../../AssetMan/PublicInterface/MaxAssInterface.h"
#include "plMaxAccelerators.h"
#include <string>
using std::string;
extern HINSTANCE hInstance;
//// Tree Data Wrapper Class //////////////////////////////////////////////////
class plAgeFile
{
protected:
void IGetAgeName(const char* path)
{
char name[_MAX_FNAME];
_splitpath(path, nil, nil, name, nil);
fAgeName = name;
}
public:
jvUniqueId fAssetID;
string fPath;
string fAgeName;
enum Types
{
kAssetFile,
kLocalFile
};
Types fType;
plAgeFile(Types type) : fType(type), fPath(nil) { }
plAgeFile(Types type, const char *path) : fType(type)
{
fPath = path;
IGetAgeName(path);
}
plAgeFile(Types type, const char *path, jvUniqueId& id) : fType(type), fAssetID(id)
{
fPath = path;
IGetAgeName(path);
}
};
//// Static Tree Helpers //////////////////////////////////////////////////////
static HTREEITEM SAddTreeItem( HWND hTree, HTREEITEM hParent, const char *label, int userData );
static int SGetTreeData( HWND tree, HTREEITEM item );
static void RemovePageItem( HWND listBox, int item )
{
plAgePage *page = (plAgePage *)ListBox_GetItemData( listBox, item );
delete page;
ListBox_DeleteString( listBox, item );
}
//// Dummy Dialog Proc ////////////////////////////////////////////////////////
BOOL CALLBACK DumbDialogProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam )
{
switch( msg )
{
case WM_COMMAND:
EndDialog( hDlg, LOWORD( wParam ) );
return TRUE;
}
return FALSE;
}
//// Constructor/Destructor ///////////////////////////////////////////////////
plAgeDescInterface::plAgeDescInterface() : fhDlg(nil), fDirty(false), fSpin(nil), fCurAge(-1)
{
fCurrAgeCheckedOut = false;
fBoldFont = nil;
fAssetManIface = nil;
// Make sure the date/time picker controls we need are initialized
INITCOMMONCONTROLSEX icc;
icc.dwSize = sizeof(INITCOMMONCONTROLSEX);
icc.dwICC = ICC_DATE_CLASSES;
InitCommonControlsEx(&icc);
}
plAgeDescInterface::~plAgeDescInterface()
{
IClearAgeFiles(fAgeFiles);
DeleteObject( fBoldFont );
DeleteObject( fHiliteBrush );
fBoldFont = nil;
delete fAssetManIface;
fAssetManIface = nil;
}
plAgeDescInterface& plAgeDescInterface::Instance()
{
static plAgeDescInterface theInstance;
return theInstance;
}
void plAgeDescInterface::Open()
{
if (!fhDlg)
{
CreateDialog(hInstance,
MAKEINTRESOURCE(IDD_AGE_DESC),
GetCOREInterface()->GetMAXHWnd(),
ForwardDlgProc);
GetCOREInterface()->RegisterDlgWnd(fhDlg);
ShowWindow(fhDlg, SW_SHOW);
}
}
BOOL CALLBACK plAgeDescInterface::ForwardDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
return Instance().DlgProc(hDlg, msg, wParam, lParam);
}
BOOL plAgeDescInterface::DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_INITDIALOG:
fhDlg = hDlg;
if( fAssetManIface == nil )
fAssetManIface = TRACKED_NEW MaxAssBranchAccess();
// Make our bold font by getting the normal font and bolding
if( fBoldFont == nil )
{
HFONT origFont = (HFONT)SendMessage( hDlg, WM_GETFONT, 0, 0 );
LOGFONT origInfo, newInfo;
GetObject( origFont, sizeof( origInfo ), &origInfo );
memcpy( &newInfo, &origInfo, sizeof( newInfo ) );
newInfo.lfWeight = FW_BOLD;
fBoldFont = CreateFontIndirect( &newInfo );
}
if( fHiliteBrush == nil )
fHiliteBrush = CreateSolidBrush( RGB( 255, 0, 0 ) );
IInitControls();
IFillAgeTree();
return TRUE;
case WM_DESTROY:
delete fAssetManIface;
fAssetManIface = nil;
return TRUE;
// Day length spinner changed
case CC_SPINNER_CHANGE:
if (LOWORD(wParam) == IDC_DAYLEN_SPINNER ||
LOWORD(wParam) == IDC_CAP_SPINNER ||
LOWORD(wParam) == IDC_SEQPREFIX_SPIN )
{
fDirty = true;
return TRUE;
}
break;
case WM_CLOSE:
::SendMessage( fhDlg, WM_COMMAND, IDOK, 0 );
return true;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
case IDCANCEL:
if( IMakeSureCheckedIn() )
{
IUpdateCurAge();
DestroyWindow(fhDlg);
fhDlg = nil;
fDirty = false;
fCurAge = -1;
fSpin = nil;
}
return TRUE;
// case IDC_AGE_LIST:
// if (HIWORD(wParam) == LBN_SELCHANGE)
// {
// IUpdateCurAge();
// return TRUE;
// }
// break;
case IDC_AGE_CHECKOUT:
ICheckOutCurrentAge();
return TRUE;
case IDC_AGE_CHECKIN:
ICheckInCurrentAge();
return TRUE;
case IDC_AGE_UNDOCHECKOUT:
IUndoCheckOutCurrentAge();
return TRUE;
case IDC_AGE_NEW:
if (HIWORD(wParam) == BN_CLICKED)
{
INewAge();
return TRUE;
}
break;
case IDC_PAGE_NEW:
if (HIWORD(wParam) == BN_CLICKED)
{
INewPage();
return TRUE;
}
break;
case IDC_PAGE_DEL:
if (HIWORD(wParam) == BN_CLICKED)
{
HWND hPage = GetDlgItem(hDlg, IDC_PAGE_LIST);
int sel = ListBox_GetCurSel(hPage);
if (sel != LB_ERR)
{
RemovePageItem( hPage, sel );
fDirty = true;
}
return TRUE;
}
break;
case IDC_PAGE_LIST:
if( HIWORD( wParam ) == LBN_SELCHANGE )
{
// Sel change
HWND list = GetDlgItem( hDlg, IDC_PAGE_LIST );
int sel = ListBox_GetCurSel( list );
if( sel != LB_ERR )
{
IEnablePageControls(true);
plAgePage *page = (plAgePage *)ListBox_GetItemData( list, sel );
CheckDlgButton( hDlg, IDC_ADM_DONTLOAD, ( page->GetFlags() & plAgePage::kPreventAutoLoad ) ? TRUE : FALSE );
CheckDlgButton( hDlg, IDC_ADM_LOADSDL, ( page->GetFlags() & plAgePage::kLoadIfSDLPresent ) ? TRUE : FALSE );
CheckDlgButton( hDlg, IDC_ADM_LOCAL_ONLY, ( page->GetFlags() & plAgePage::kIsLocalOnly ) ? TRUE : FALSE );
CheckDlgButton( hDlg, IDC_ADM_VOLATILE, ( page->GetFlags() & plAgePage::kIsVolatile ) ? TRUE : FALSE );
}
else
IEnablePageControls(false);
}
break;
case IDC_ADM_DONTLOAD:
case IDC_ADM_LOADSDL:
case IDC_ADM_LOCAL_ONLY:
case IDC_ADM_VOLATILE:
ICheckedPageFlag(LOWORD(wParam));
break;
case IDC_EDITREG:
// Ask the user to make sure they really want to do this
if( GetAsyncKeyState( VK_SHIFT ) & (~1) )
{
if( MessageBox( hDlg, "Are you sure you wish to reassign the sequence prefix for this age?", "WARNING", MB_YESNO | MB_ICONEXCLAMATION ) == IDYES )
{
Int32 prefix = (Int32)IGetNextFreeSequencePrefix( IsDlgButtonChecked( hDlg, IDC_RSVDCHECK ) );
fSeqPrefixSpin->SetValue( ( prefix >= 0 ) ? prefix : -prefix, false );
fDirty = true;
}
}
else
{
if( MessageBox( hDlg, "Editing the registry data for an age can be extremely dangerous and "
"can cause instabilities and crashes, particularly with multiplayer. "
"Are you sure you want to do this?", "WARNING", MB_YESNO | MB_ICONEXCLAMATION ) == IDYES )
{
// Enable the controls
EnableWindow( GetDlgItem( hDlg, IDC_RSVDCHECK ), TRUE );
EnableWindow( GetDlgItem( hDlg, IDC_SEQPREFIX_EDIT ), TRUE );
EnableWindow( GetDlgItem( hDlg, IDC_SEQPREFIX_SPIN ), TRUE );
}
}
return TRUE;
case IDC_RSVDCHECK:
fDirty = true;
return FALSE; // Still process as normal
case IDC_BRANCHCOMBO:
if( HIWORD( wParam ) == CBN_SELCHANGE )
{
int idx = SendDlgItemMessage( hDlg, IDC_BRANCHCOMBO, CB_GETCURSEL, 0, 0 );
if( idx != CB_ERR )
{
int id = SendDlgItemMessage( hDlg, IDC_BRANCHCOMBO, CB_GETITEMDATA, idx, 0 );
fAssetManIface->SetCurrBranch( id );
IFillAgeTree();
}
}
return TRUE;
}
break;
case WM_PAINT:
PAINTSTRUCT paintInfo;
BeginPaint( hDlg, &paintInfo );
if( fCurrAgeCheckedOut )
{
RECT r;
HWND dummy = GetDlgItem( hDlg, IDC_AGEDESC );
GetClientRect( dummy, &r );
MapWindowPoints( dummy, hDlg, (POINT *)&r, 2 );
for( int i = 0; i < 3; i++ )
{
InflateRect( &r, -1, -1 );
FrameRect( paintInfo.hdc, &r, fHiliteBrush );
}
}
EndPaint( hDlg, &paintInfo );
return TRUE;
case WM_NOTIFY:
{
NMHDR *hdr = (NMHDR*)lParam;
// Message from the start date/time controls
if (hdr->idFrom == IDC_DATE || hdr->idFrom == IDC_TIME)
{
if (hdr->code == NM_KILLFOCUS)
{
plMaxAccelerators::Enable();
return TRUE;
}
else if (hdr->code == NM_SETFOCUS)
{
plMaxAccelerators::Disable();
return TRUE;
}
// Time or date changed, set dirty
else if (hdr->code == DTN_DATETIMECHANGE)
{
fDirty = true;
return TRUE;
}
}
else if( hdr->idFrom == IDC_AGE_LIST )
{
if( hdr->code == NM_CUSTOMDRAW )
{
// Custom draw notifications for our treeView control
LPNMTVCUSTOMDRAW treeNotify = (LPNMTVCUSTOMDRAW)lParam;
if( treeNotify->nmcd.dwDrawStage == CDDS_PREPAINT )
{
// Sent at the start of redraw, lets us request more specific notifys
SetWindowLong( hDlg, DWL_MSGRESULT, CDRF_NOTIFYITEMDRAW );
return TRUE;
}
else if( treeNotify->nmcd.dwDrawStage == CDDS_ITEMPREPAINT )
{
// Prepaint on an item. We get to change item font and color here
int idx = SGetTreeData( hdr->hwndFrom, (HTREEITEM)treeNotify->nmcd.dwItemSpec );
/* if( item == nil || item->fType != plAgeFile::kBranch )
{
// Default drawing, with default font and such
SetWindowLong( hDlg, DWL_MSGRESULT, CDRF_DODEFAULT );
return TRUE;
}
*/
// Color change (only if the item isn't selected)
if( (HTREEITEM)treeNotify->nmcd.dwItemSpec != TreeView_GetSelection( hdr->hwndFrom ) )
{
treeNotify->clrText = GetColorManager()->GetColor( kText );
treeNotify->clrTextBk = GetColorManager()->GetColor( kWindow );
}
if (idx == -1)
{
// Set a bold font for the branch headers
if( fBoldFont != nil )
SelectObject( treeNotify->nmcd.hdc, fBoldFont );
}
// Let Windows know we changed the font
SetWindowLong( hDlg, DWL_MSGRESULT, CDRF_NEWFONT );
return TRUE;
}
else
// Let the default handle it
return FALSE;
}
else if( hdr->code == TVN_SELCHANGING )
{
SetWindowLong( hDlg, DWL_MSGRESULT, !IMakeSureCheckedIn() );
return TRUE;
}
else if( hdr->code == TVN_SELCHANGED )
{
// Update the viewing age
IUpdateCurAge();
return TRUE;
}
}
}
break;
}
return FALSE;
}
void plAgeDescInterface::ICheckedPageFlag(int ctrlID)
{
HWND hList = GetDlgItem(fhDlg, IDC_PAGE_LIST);
int sel = ListBox_GetCurSel(hList);
if (sel == LB_ERR)
return;
plAgePage* page = (plAgePage*)ListBox_GetItemData(hList, sel);
bool isChecked = (IsDlgButtonChecked(fhDlg, ctrlID) == BST_CHECKED);
if (ctrlID == IDC_ADM_DONTLOAD)
{
if (isChecked)
{
page->SetFlags(plAgePage::kPreventAutoLoad, true);
// Doesn't make sense to have loadWithSDL checked too
CheckDlgButton(fhDlg, IDC_ADM_LOADSDL, FALSE);
page->SetFlags(plAgePage::kLoadIfSDLPresent, false);
}
else
page->SetFlags(plAgePage::kPreventAutoLoad, false);
}
else if (ctrlID == IDC_ADM_LOADSDL)
{
if (isChecked)
{
page->SetFlags(plAgePage::kLoadIfSDLPresent, true);
// Doesn't make sense to have dontLoad checked too
CheckDlgButton(fhDlg, IDC_ADM_DONTLOAD, FALSE);
page->SetFlags(plAgePage::kPreventAutoLoad, false);
}
else
page->SetFlags(plAgePage::kLoadIfSDLPresent, false);
}
else if (ctrlID == IDC_ADM_LOCAL_ONLY)
{
page->SetFlags(plAgePage::kIsLocalOnly, isChecked);
}
else if (ctrlID == IDC_ADM_VOLATILE)
{
page->SetFlags(plAgePage::kIsVolatile, isChecked);
}
}
void plAgeDescInterface::ICheckOutCurrentAge( void )
{
hsAssert( !fCurrAgeCheckedOut, "Trying to re-check out an age!" );
plAgeFile *currAge = IGetCurrentAge();
if( currAge == nil )
{
hsAssert( false, "How are you checking out an age if none is selected?" );
return;
}
if( currAge->fType != plAgeFile::kAssetFile )
return;
// Check it out from AssetMan
bool checkOutSuccess = (*fAssetManIface)->CheckOutAsset( currAge->fAssetID, fCheckedOutPath, sizeof( fCheckedOutPath ) );
if( !checkOutSuccess )
{
hsMessageBox( "Unable to check out age file from AssetMan. Most likely somebody already has it checked out.", "Error", hsMessageBoxNormal );
return;
}
fCurrAgeCheckedOut = true;
// Make sure we loaded the latest version
ILoadAge( fCheckedOutPath, true );
IInvalidateCheckOutIndicator();
IEnableControls( true );
}
void plAgeDescInterface::ICheckInCurrentAge( void )
{
hsAssert( fCurrAgeCheckedOut, "Trying to check in an age when none is checked out!" );
plAgeFile *currAge = IGetCurrentAge();
if( currAge == nil )
{
hsAssert( false, "How are you checking in an age if none is selected?" );
return;
}
// Save the sucker
ISaveCurAge( fCheckedOutPath );
// Check the age file back in to AssetMan
(*fAssetManIface)->CheckInAsset( currAge->fAssetID, fCheckedOutPath, "" );
fCurrAgeCheckedOut = false;
IInvalidateCheckOutIndicator();
IEnableControls( true );
}
void plAgeDescInterface::IUndoCheckOutCurrentAge( void )
{
hsAssert( fCurrAgeCheckedOut, "Trying to undo check out an age when none is checked out!" );
plAgeFile *currAge = IGetCurrentAge();
if( currAge == nil )
{
hsAssert( false, "How are you undoing a checkout if no age is selected?" );
return;
}
// Check the age file back in to AssetMan
(*fAssetManIface)->UndoCheckOutAsset(currAge->fAssetID);
fCurrAgeCheckedOut = false;
// Reload the non-saved version
ILoadAge( fCheckedOutPath );
IInvalidateCheckOutIndicator();
IEnableControls( true );
}
void plAgeDescInterface::IInvalidateCheckOutIndicator( void )
{
RECT r;
HWND dummy = GetDlgItem( fhDlg, IDC_AGEDESC );
GetClientRect( dummy, &r );
MapWindowPoints( dummy, fhDlg, (POINT *)&r, 2 );
RedrawWindow( fhDlg, &r, nil, RDW_INVALIDATE | RDW_ERASE );
}
hsBool plAgeDescInterface::IMakeSureCheckedIn( void )
{
int result;
plAgeFile* currAge = IGetCurrentAge();
if (!currAge)
return true;
if ( currAge->fType == plAgeFile::kAssetFile && fCurrAgeCheckedOut )
{
// We're switching away from an age we have checked out--ask what they want to do
result = DialogBox( hInstance, MAKEINTRESOURCE( IDD_AGE_CHECKIN ),
GetCOREInterface()->GetMAXHWnd(), DumbDialogProc );
if( result == IDCANCEL )
{
// Got cancelled
return false;
}
else if( result == IDYES )
{
ICheckInCurrentAge();
}
else
{
IUndoCheckOutCurrentAge();
}
}
else if( currAge->fType == plAgeFile::kLocalFile && fDirty )
{
// Ask if we want to save changes
result = DialogBox( hInstance, MAKEINTRESOURCE( IDD_AGE_SAVEYESNO ),
GetCOREInterface()->GetMAXHWnd(), DumbDialogProc );
if( result == IDCANCEL )
{
// Got cancelled
return false;
}
else if( result == IDYES )
{
ISaveCurAge( currAge->fPath.c_str() );
}
else
{
// Reload the non-saved version
ILoadAge( currAge->fPath.c_str() );
}
IEnableControls( true );
}
return true;
}
void plAgeDescInterface::IUpdateCurAge( void )
{
// Get the current age selection
plAgeFile *currAge = IGetCurrentAge();
if (currAge == nil)
{
ISetControlDefaults();
IEnableControls( false );
return;
}
IEnableControls( true );
if( currAge->fType == plAgeFile::kAssetFile )
{
// Gotta get the latest version from assetMan before loading
char localFilename[ MAX_PATH ];
if( !(*fAssetManIface)->GetLatestVersionFile( currAge->fAssetID, localFilename, sizeof( localFilename ) ) )
{
hsMessageBox( "Unable to get latest version of age asset from AssetMan. Things are about to get very funky...", "ERROR", hsMessageBoxNormal );
}
else
{
ILoadAge( localFilename );
}
}
else
// Load the local age, also check its sequence #s
ILoadAge( currAge->fPath.c_str(), true );
}
static const int kDefaultCapacity = 10;
void plAgeDescInterface::IInitControls()
{
// Fill the branch combo box
SendDlgItemMessage( fhDlg, IDC_BRANCHCOMBO, CB_RESETCONTENT, 0, 0 );
const jvTypeArray &branches = (*fAssetManIface)->GetBranches();
int i, curr = 0;
for( i = 0; i < branches.Size(); i++ )
{
int idx = SendDlgItemMessage( fhDlg, IDC_BRANCHCOMBO, CB_ADDSTRING, 0, (LPARAM)(const char *)( branches[ i ].Name ) );
SendDlgItemMessage( fhDlg, IDC_BRANCHCOMBO, CB_SETITEMDATA, idx, (LPARAM)branches[ i ].Id );
if( branches[ i ].Id == fAssetManIface->GetCurrBranch() )
curr = i;
}
SendDlgItemMessage( fhDlg, IDC_BRANCHCOMBO, CB_SETCURSEL, curr, 0 );
fSpin = SetupFloatSpinner(fhDlg, IDC_DAYLEN_SPINNER, IDC_DAYLEN_EDIT, 1.f, 100.f, 24.f);
fCapSpin = SetupIntSpinner(fhDlg, IDC_CAP_SPINNER, IDC_CAP_EDIT, 1, 250, kDefaultCapacity);
fSeqPrefixSpin = SetupIntSpinner(fhDlg, IDC_SEQPREFIX_SPIN, IDC_SEQPREFIX_EDIT, 1, 102400, 1);
SendDlgItemMessage( fhDlg, IDC_AGELIST_STATIC, WM_SETFONT, (WPARAM)fBoldFont, MAKELPARAM( TRUE, 0 ) );
SendDlgItemMessage( fhDlg, IDC_AGEDESC, WM_SETFONT, (WPARAM)fBoldFont, MAKELPARAM( TRUE, 0 ) );
ISetControlDefaults();
IEnableControls(false);
}
void plAgeDescInterface::ISetControlDefaults()
{
HWND hDate = GetDlgItem(fhDlg, IDC_DATE);
HWND hTime = GetDlgItem(fhDlg, IDC_TIME);
SYSTEMTIME st = {0};
st.wDay = 1;
st.wMonth = 1;
st.wYear = 2000;
DateTime_SetSystemtime(hDate, GDT_VALID, &st);
DateTime_SetSystemtime(hTime, GDT_VALID, &st);
fSpin->SetValue(24.f, FALSE);
fCapSpin->SetValue(kDefaultCapacity, FALSE);
CheckDlgButton( fhDlg, IDC_ADM_DONTLOAD, FALSE );
int i;
HWND ctrl = GetDlgItem( fhDlg, IDC_PAGE_LIST );
for( i = SendMessage( ctrl, LB_GETCOUNT, 0, 0 ) - 1; i >= 0; i-- )
RemovePageItem( ctrl, i );
SetDlgItemText( fhDlg, IDC_AGEDESC, "Age Description" );
}
void plAgeDescInterface::IEnableControls(bool enable)
{
bool checkedOut = true;
plAgeFile *currAge = IGetCurrentAge();
if( currAge != nil && currAge->fType == plAgeFile::kAssetFile )
checkedOut = fCurrAgeCheckedOut && enable;
else if( currAge != nil && currAge->fType == plAgeFile::kLocalFile )
checkedOut = enable;
else
checkedOut = false;
EnableWindow(GetDlgItem(fhDlg, IDC_DATE), checkedOut );
EnableWindow(GetDlgItem(fhDlg, IDC_TIME), checkedOut );
EnableWindow(GetDlgItem(fhDlg, IDC_PAGE_LIST), checkedOut );
EnableWindow(GetDlgItem(fhDlg, IDC_PAGE_NEW), checkedOut );
EnableWindow(GetDlgItem(fhDlg, IDC_PAGE_DEL), checkedOut );
EnableWindow(GetDlgItem(fhDlg, IDC_EDITREG), checkedOut );
if (!enable || !checkedOut)
IEnablePageControls(false);
fSpin->Enable(checkedOut );
fCapSpin->Enable(checkedOut );
if( currAge != nil && currAge->fType == plAgeFile::kAssetFile )
{
EnableWindow( GetDlgItem( fhDlg, IDC_AGE_CHECKIN ), checkedOut );
EnableWindow( GetDlgItem( fhDlg, IDC_AGE_UNDOCHECKOUT ), checkedOut );
EnableWindow( GetDlgItem( fhDlg, IDC_AGE_CHECKOUT ), !checkedOut );
}
else
{
EnableWindow( GetDlgItem( fhDlg, IDC_AGE_CHECKIN ), false );
EnableWindow( GetDlgItem( fhDlg, IDC_AGE_UNDOCHECKOUT ), false );
EnableWindow( GetDlgItem( fhDlg, IDC_AGE_CHECKOUT ), false );
}
}
void plAgeDescInterface::IEnablePageControls(bool enable)
{
EnableWindow(GetDlgItem(fhDlg, IDC_ADM_DONTLOAD), enable);
EnableWindow(GetDlgItem(fhDlg, IDC_ADM_LOADSDL), enable);
EnableWindow(GetDlgItem(fhDlg, IDC_ADM_LOCAL_ONLY), enable);
EnableWindow(GetDlgItem(fhDlg, IDC_ADM_VOLATILE), enable);
}
bool plAgeDescInterface::IGetLocalAgePath(char *path)
{
// Get the path to the description folder
const char *plasmaPath = plMaxConfig::GetClientPath();
if (!plasmaPath)
return false;
strcpy(path, plasmaPath);
strcat(path, plAgeDescription::kAgeDescPath);
// Make sure the desc folder exists
CreateDirectory(path, NULL);
return true;
}
int plAgeDescInterface::IFindAge(const char* ageName, vector<plAgeFile*>& ageFiles)
{
for (int i = 0; i < ageFiles.size(); i++)
if (ageFiles[i]->fAgeName == ageName)
return i;
return -1;
}
void plAgeDescInterface::IGetAgeFiles(vector<plAgeFile*>& ageFiles)
{
IClearAgeFiles(ageFiles);
char agePath[MAX_PATH];
// Make list of "local" ages. This might contain copies of those in AssetMan, so we make the
// list first and take out the ones that are in AssetMan
char localPath[MAX_PATH];
if (IGetLocalAgePath(localPath))
{
hsFolderIterator ageFolder(localPath);
while (ageFolder.NextFileSuffix(".age"))
{
ageFolder.GetPathAndName(agePath);
plAgeFile* age = TRACKED_NEW plAgeFile(plAgeFile::kLocalFile, agePath);
ageFiles.push_back(age);
}
}
// Add AssetMan ages, if available (since we're static, go thru the main MaxAss interface)
MaxAssInterface *assetMan = GetMaxAssInterface();
if( assetMan!= nil )
{
hsTArray<jvUniqueId> doneAssets;
jvArray<jvUniqueId>* assets = assetMan->GetAssetsByType(MaxAssInterface::kTypeAge);
for (int i = 0; i < assets->Size(); i++)
{
if( doneAssets.Find( (*assets)[ i ] ) == doneAssets.kMissingIndex )
{
if (assetMan->GetLatestVersionFile((*assets)[i], agePath, sizeof(agePath)))
{
plAgeFile* age = TRACKED_NEW plAgeFile(plAgeFile::kAssetFile, agePath, (*assets)[i]);
int existing = IFindAge(age->fAgeName.c_str(), ageFiles);
// Remove it from our "local" list if there, since it's a duplicate
if (existing != -1)
{
delete ageFiles[existing];
ageFiles[existing] = age;
}
else
ageFiles.push_back(age);
doneAssets.Append( (*assets)[ i ] );
}
}
}
assets->DeleteSelf();
}
}
void plAgeDescInterface::IClearAgeFiles(vector<plAgeFile*>& ageFiles)
{
for (int i = 0; i < ageFiles.size(); i++)
delete ageFiles[i];
ageFiles.clear();
}
void plAgeDescInterface::BuildAgeFileList( hsTArray<char *> &ageList )
{
vector<plAgeFile*> tempAgeFiles;
IGetAgeFiles(tempAgeFiles);
for (int i = 0; i < tempAgeFiles.size(); i++)
{
ageList.Push(hsStrcpy(tempAgeFiles[i]->fPath.c_str()));
delete tempAgeFiles[ i ];
}
}
//// IFillAgeTree /////////////////////////////////////////////////////////////
// Refreshes/inits the tree view of all ages we have to work with. If
// specified, will also get the latest version of the .age files from assetMan.
void plAgeDescInterface::IFillAgeTree( void )
{
HWND ageTree = GetDlgItem( fhDlg, IDC_AGE_LIST );
// Clear the tree first and add our two root headers
TreeView_DeleteAllItems(ageTree);
if( fAssetManIface != nil )
fAssetManBranch = SAddTreeItem(ageTree, nil, "AssetMan Ages", -1);
else
fAssetManBranch = nil;
fLocalBranch = SAddTreeItem(ageTree, nil, "Local Ages", -1);
IGetAgeFiles(fAgeFiles);
// Add the ages to the tree
for (int i = 0; i < fAgeFiles.size(); i++)
{
SAddTreeItem(ageTree,
(fAgeFiles[i]->fType == plAgeFile::kAssetFile) ? fAssetManBranch : fLocalBranch,
fAgeFiles[i]->fAgeName.c_str(),
i);
}
// Select the first age to view
IUpdateCurAge();
}
BOOL CALLBACK NewAgeDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
static char *name = nil;
switch (msg)
{
case WM_INITDIALOG:
name = (char*)lParam;
SetWindowText(hDlg, name);
return TRUE;
case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDOK)
{
if (GetDlgItemText(hDlg, IDC_AGE_NAME, name, _MAX_FNAME) > 0)
EndDialog(hDlg, 1);
else
EndDialog(hDlg, 0);
return TRUE;
}
else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDCANCEL)
{
EndDialog(hDlg, 0);
return TRUE;
}
}
return FALSE;
}
BOOL CALLBACK NewSeqNumberProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
static char msg1[] = "This age currently does not have a sequence number assigned to it. All ages "
"must have a unique sequence number for multiplayer to work. Unassigned ages "
"will get a temporary random number at export time, but will result in undefined "
"(but probably bad) behavior during multiplayer games. In general, you should "
"always assign a sequence number to an age unless you have a very specific and "
"good reason not to.";
static char msg2[] = "The ADManager can find and assign a new, unique sequence number to this age for "
"you. You can choose to assign a normal or a global/reserved number. Normal ages "
"are ones for gameplay (that you can link to, walk around in, etc.), while "
"global/reserved ages are typically for storing data (such as avatars, GUI dialogs, etc.)";
char msg3[ 512 ];
switch (msg)
{
case WM_INITDIALOG:
SetDlgItemText( hDlg, IDC_INFOMSG, msg1 );
SetDlgItemText( hDlg, IDC_ADMMSG, msg2 );
sprintf( msg3, "Age: %s", (char *)lParam );
SetDlgItemText( hDlg, IDC_AGEMSG, msg3 );
return TRUE;
case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED )
{
EndDialog( hDlg, LOWORD( wParam ) );
return TRUE;
}
}
return FALSE;
}
void plAgeDescInterface::INewAge()
{
VARIANT assetId;
VariantInit(&assetId);
bool makeAsset = true;
if( hsMessageBox( "Do you wish to store your new age in AssetMan?", "Make source-controlled?", hsMessageBoxYesNo ) == hsMBoxNo )
makeAsset = false;
char newAssetFilename[ MAX_PATH ];
if (!fAssetManIface)
makeAsset = false;
if( !IGetLocalAgePath( newAssetFilename ) )
return;
char name[_MAX_FNAME];
strcpy(name, "New Age Name");
// Get the name of the new age from the user
int ret = DialogBoxParam(hInstance,
MAKEINTRESOURCE(IDD_AGE_NAME),
GetCOREInterface()->GetMAXHWnd(),
NewAgeDlgProc,
(LPARAM)name);
if (ret != 1)
return;
strcat(newAssetFilename, name);
strcat(newAssetFilename, ".age");
if( !makeAsset )
fForceSeqNumLocal = true;
ISetControlDefaults();
ISaveCurAge(newAssetFilename, true); // Check sequence # while we're at it
fForceSeqNumLocal = false;
if( makeAsset )
(*fAssetManIface)->AddNewAsset(newAssetFilename);
// Refresh the tree now
IFillAgeTree();
}
void plAgeDescInterface::INewPage()
{
char name[256];
strcpy(name, "New Page Name");
// Get the name of the new age from the user
int ret = DialogBoxParam(hInstance,
MAKEINTRESOURCE(IDD_AGE_NAME),
GetCOREInterface()->GetMAXHWnd(),
NewAgeDlgProc,
(LPARAM)name);
if (ret != 1)
return;
HWND hPages = GetDlgItem(fhDlg, IDC_PAGE_LIST);
// Make sure this page doesn't already exist
int count = ListBox_GetCount(hPages);
for (int i = 0; i < count; i++)
{
char pageName[256];
ListBox_GetText(hPages, i, pageName);
if (!strcmp(pageName, name))
return;
}
// Add the new page and select it
int idx = ListBox_AddString(hPages, name);
// Choose a new sequence suffix for it
plAgePage *newPage = TRACKED_NEW plAgePage( name, IGetFreePageSeqSuffix( hPages ), 0 );
ListBox_SetItemData( hPages, idx, (LPARAM)newPage );
fDirty = true;
}
UInt32 plAgeDescInterface::IGetFreePageSeqSuffix( HWND pageCombo )
{
int i, count = ListBox_GetCount( pageCombo );
UInt32 searchSeq = 1;
do
{
for( i = 0; i < count; i++ )
{
plAgePage *page = (plAgePage *)ListBox_GetItemData( pageCombo, i );
if( page != nil && page->GetSeqSuffix() == searchSeq )
{
searchSeq++;
break;
}
}
} while( i < count );
return searchSeq;
}
void plAgeDescInterface::ISaveCurAge( const char *path, hsBool checkSeqNum )
{
hsUNIXStream s;
if( !s.Open( path, "wt" ) )
{
hsMessageBox("Unable to open the Age Description file for writing. Updates not saved.", "Error", hsMessageBoxNormal);
return;
}
plAgeDescription aged;
aged.SetAgeNameFromPath( path );
// set the date and time
HWND hDate = GetDlgItem(fhDlg, IDC_DATE);
SYSTEMTIME dst = {0};
DateTime_GetSystemtime(hDate, &dst);
HWND hTime = GetDlgItem(fhDlg, IDC_TIME);
SYSTEMTIME tst = {0};
DateTime_GetSystemtime(hTime, &tst);
aged.SetStart(dst.wYear,dst.wMonth,dst.wDay,tst.wHour,tst.wMinute,tst.wSecond);
aged.SetDayLength(fSpin->GetFVal());
aged.SetMaxCapacity(fCapSpin->GetIVal());
if( checkSeqNum )
{
ICheckSequenceNumber( aged );
}
else if( IsDlgButtonChecked( fhDlg, IDC_RSVDCHECK ) )
{
// Store reserved sequence prefix
aged.SetSequencePrefix( -fSeqPrefixSpin->GetIVal() );
}
else
{
aged.SetSequencePrefix( fSeqPrefixSpin->GetIVal() );
}
// gather pages
HWND hPages = GetDlgItem(fhDlg, IDC_PAGE_LIST);
int count = ListBox_GetCount(hPages);
if (count != LB_ERR)
{
for (int i = 0; i < count; i++)
{
char pageName[256];
ListBox_GetText(hPages, i, pageName);
plAgePage *page = (plAgePage *)ListBox_GetItemData( hPages, i );
aged.AppendPage( pageName, page->GetSeqSuffix(), page->GetFlags() );
}
}
// write it all out
aged.Write(&s);
s.Close();
}
//// ICheckSequenceNumber /////////////////////////////////////////////////////
// Checks to make sure the sequence prefix is valid. If not, asks to assign
// a good one.
void plAgeDescInterface::ICheckSequenceNumber( plAgeDescription &aged )
{
if( aged.GetSequencePrefix() == 0 ) // Default of uninitialized
{
// Ask about the sequence #
int ret = DialogBoxParam( hInstance, MAKEINTRESOURCE( IDD_AGE_SEQNUM ),
GetCOREInterface()->GetMAXHWnd(),
NewSeqNumberProc, (LPARAM)aged.GetAgeName() );
if( ret == IDYES )
{
aged.SetSequencePrefix( IGetNextFreeSequencePrefix( false ) );
fDirty = true;
}
else if( ret == IDNO )
{
aged.SetSequencePrefix( IGetNextFreeSequencePrefix( true ) );
fDirty = true;
}
}
}
void plAgeDescInterface::ILoadAge( const char *path, hsBool checkSeqNum )
{
ISetControlDefaults();
fDirty = false;
// create and read the age desc
plAgeDescription aged( path );
// Get the name of the age
char ageName[_MAX_FNAME];
_splitpath( path, nil, nil, ageName, nil );
// Check the sequence prefix #
if( checkSeqNum )
ICheckSequenceNumber( aged );
char str[ _MAX_FNAME + 30 ];
sprintf( str, "Description for %s", ageName );
SetDlgItemText( fhDlg, IDC_AGEDESC, str );
// Set up the Dlgs
SYSTEMTIME st;
HWND hTime = GetDlgItem(fhDlg, IDC_TIME);
memset(&st,0, sizeof(st));
st.wYear = 2000;
st.wMonth = 1;
st.wDay = 1;
st.wHour = aged.GetStartHour();
st.wMinute = aged.GetStartMinute();
st.wSecond = aged.GetStartSecond();
DateTime_SetSystemtime(hTime, GDT_VALID, &st);
HWND hDate = GetDlgItem(fhDlg, IDC_DATE);
memset(&st,0, sizeof(st));
st.wMonth = aged.GetStartMonth();
st.wDay = aged.GetStartDay();
st.wYear = aged.GetStartYear();
DateTime_SetSystemtime(hDate, GDT_VALID, &st);
fSpin->SetValue(aged.GetDayLength(), FALSE);
int maxCap = aged.GetMaxCapacity();
if (maxCap == -1)
{
maxCap = kDefaultCapacity;
fDirty = true;
}
fCapSpin->SetValue(maxCap, FALSE);
Int32 seqPrefix = aged.GetSequencePrefix();
if( seqPrefix < 0 )
{
// Reserved prefix
fSeqPrefixSpin->SetValue( (int)( -seqPrefix ), FALSE );
CheckDlgButton( fhDlg, IDC_RSVDCHECK, BST_CHECKED );
}
else
{
fSeqPrefixSpin->SetValue( (int)seqPrefix, FALSE );
CheckDlgButton( fhDlg, IDC_RSVDCHECK, BST_UNCHECKED );
}
// Disable the registry controls for now
EnableWindow( GetDlgItem( fhDlg, IDC_RSVDCHECK ), false );
EnableWindow( GetDlgItem( fhDlg, IDC_SEQPREFIX_EDIT ), false );
EnableWindow( GetDlgItem( fhDlg, IDC_SEQPREFIX_SPIN ), false );
aged.SeekFirstPage();
plAgePage *page;
HWND hPage = GetDlgItem(fhDlg, IDC_PAGE_LIST);
while( ( page = aged.GetNextPage() ) != nil )
{
int idx = ListBox_AddString( hPage, page->GetName() );
ListBox_SetItemData( hPage, idx, (LPARAM)new plAgePage( *page ) );
}
}
UInt32 plAgeDescInterface::IGetNextFreeSequencePrefix( hsBool getReservedPrefix )
{
Int32 searchSeq = getReservedPrefix ? -1 : 1;
hsTArray<char *> ageList;
int i;
hsTArray<plAgeDescription> ages;
if( fForceSeqNumLocal )
searchSeq = getReservedPrefix ? -1024 : 1024;
IGetAgeFiles(fAgeFiles);
ages.SetCount( fAgeFiles.size() );
for( i = 0; i < fAgeFiles.size(); i++ )
{
hsUNIXStream stream;
if( stream.Open( fAgeFiles[ i ]->fPath.c_str(), "rt" ) )
{
ages[ i ].Read( &stream );
stream.Close();
}
}
do
{
if( getReservedPrefix )
{
for( i = 0; i < ages.GetCount(); i++ )
{
if( ages[ i ].GetSequencePrefix() == searchSeq )
{
searchSeq--;
break;
}
}
}
else
{
for( i = 0; i < ages.GetCount(); i++ )
{
if( ages[ i ].GetSequencePrefix() == searchSeq )
{
searchSeq++;
break;
}
}
}
} while( i < ages.GetCount() );
return searchSeq;
}
plAgeFile* plAgeDescInterface::IGetCurrentAge( void )
{
HWND ageTree = GetDlgItem( fhDlg, IDC_AGE_LIST );
fCurrAgeItem = TreeView_GetSelection( ageTree );
if( fCurrAgeItem == nil )
return nil;
int idx = SGetTreeData( ageTree, fCurrAgeItem );
if (idx == -1)
return nil;
return fAgeFiles[idx];
}
//// SAddTreeItem /////////////////////////////////////////////////////////////
// Static helper function for adding an item to a treeView
static HTREEITEM SAddTreeItem( HWND hTree, HTREEITEM hParent, const char *label, int userData )
{
TVITEM tvi = {0};
tvi.mask = TVIF_TEXT | TVIF_PARAM;
tvi.pszText = (char *)label;
tvi.cchTextMax = strlen( label );
tvi.lParam = (LPARAM)userData;
if( userData == -1 )
{
tvi.mask |= TVIF_STATE;
tvi.state = tvi.stateMask = TVIS_BOLD | TVIS_EXPANDED;
}
TVINSERTSTRUCT tvins = {0};
tvins.item = tvi;
tvins.hParent = hParent;
tvins.hInsertAfter = TVI_LAST;
return TreeView_InsertItem( hTree, &tvins );
}
//// SGetTreeData /////////////////////////////////////////////////////////////
// Gets the tree data for the given item
int SGetTreeData( HWND tree, HTREEITEM item )
{
TVITEM itemInfo;
itemInfo.mask = TVIF_PARAM | TVIF_HANDLE;
itemInfo.hItem = item;
TreeView_GetItem( tree, &itemInfo );
return itemInfo.lParam;
}