void OnExpiredCredentials (WPARAM wp, LPARAM lp)
{
BOOL fExpired = (BOOL)wp;
LPCREDENTIALSDLG_PARAMS lpp = (LPCREDENTIALSDLG_PARAMS)lp;
if (lpp && lpp->bcdp.pfShowWarningEver && *(lpp->bcdp.pfShowWarningEver))
{
int idsWarning = (wp) ? IDS_BADCREDS_DESC_EXPIRED : IDS_BADCREDS_DESC_DESTROYED;
int idsDesc = (lpp->bcdp.idsDesc) ? lpp->bcdp.idsDesc : IDS_BADCREDS_DESC2;
LPTSTR pszDesc = FormatString (idsDesc, TEXT("%s"), lpp->szCell);
LPTSTR pszFullText = FormatString (idsWarning, TEXT("%s%s%m"), lpp->szCell, pszDesc, IDS_BADCREDS_DESC3);
FreeString (pszDesc);
REALBADCREDSDLG_PARAMS pp;
memset (&pp, 0x00, sizeof(pp));
pp.pszFullText = pszFullText;
memcpy (&pp.bcdp, &lpp->bcdp, sizeof(BADCREDSDLG_PARAMS));
if (ModalDialogParam (IDD_APPLIB_BADCREDS, NULL, (DLGPROC)BadCreds_DlgProc, (LPARAM)&pp) != IDCANCEL)
{
AfsAppLib_ShowCredentialsDialog (lpp);
}
FreeString (pszFullText);
}
if (lpp)
{
Delete (lpp);
}
}
void Server_SyncVLDB_OnInitDialog (HWND hDlg, LPIDENT lpi)
{
if (lpi->fIsServer())
{
TCHAR szServer[ cchNAME ];
lpi->GetServerName (szServer);
LPTSTR pszText = FormatString (IDS_SYNCVLDB_SVR_DESC, TEXT("%s"), szServer);
SetDlgItemText (hDlg, IDC_SYNC_DESC, pszText);
FreeString (pszText);
pszText = FormatString (IDS_SYNCVLDB_SVR_DESC2, TEXT("%s"), szServer);
SetDlgItemText (hDlg, IDC_SYNC_DESC2, pszText);
FreeString (pszText);
ShowWindow (hDlg, SW_SHOW);
}
else // (lpi->fIsAggregate())
{
TCHAR szServer[ cchNAME ];
lpi->GetServerName (szServer);
TCHAR szAggregate[ cchNAME ];
lpi->GetAggregateName (szAggregate);
LPTSTR pszText = FormatString (IDS_SYNCVLDB_AGG_DESC, TEXT("%s%s"), szServer, szAggregate);
SetDlgItemText (hDlg, IDC_SYNC_DESC, pszText);
FreeString (pszText);
pszText = FormatString (IDS_SYNCVLDB_AGG_DESC2, TEXT("%s%s"), szServer, szAggregate);
SetDlgItemText (hDlg, IDC_SYNC_DESC2, pszText);
FreeString (pszText);
StartTask (taskAGG_FIND_GHOST, hDlg, lpi);
}
}
void Services_StartStop_OnInitDialog (HWND hDlg, LPSERVICE_STARTSTOP_PARAMS lpp)
{
LPTSTR pszString = FormatString ((lpp->fStart) ? IDS_STARTSERVICE_TITLE : IDS_STOPSERVICE_TITLE);
SetWindowText (hDlg, pszString);
FreeString (pszString);
TCHAR szServer[ cchNAME ];
lpp->lpi->GetServerName (szServer);
TCHAR szService[ cchNAME ];
lpp->lpi->GetServiceName (szService);
pszString = FormatString ((lpp->fStart) ? IDS_STARTSERVICE_TEXT : IDS_STOPSERVICE_TEXT, TEXT("%s%s"), szServer, szService);
SetDlgItemText (hDlg, IDC_STARTSTOP_TEXT, pszString);
FreeString (pszString);
pszString = FormatString ((lpp->fStart) ? IDS_STARTSERVICE_STARTUP : IDS_STOPSERVICE_STARTUP, TEXT("%s%s"), szServer, szService);
SetDlgItemText (hDlg, IDC_STARTSTOP_STARTUP, pszString);
FreeString (pszString);
pszString = FormatString ((lpp->fStart) ? IDS_STARTSERVICE_PERMANENT : IDS_STOPSERVICE_PERMANENT, TEXT("%s%s"), szServer, szService);
SetDlgItemText (hDlg, IDC_STARTSTOP_PERMANENT, pszString);
FreeString (pszString);
pszString = FormatString ((lpp->fStart) ? IDS_STARTSERVICE_TEMPORARY : IDS_STOPSERVICE_TEMPORARY, TEXT("%s%s"), szServer, szService);
SetDlgItemText (hDlg, IDC_STARTSTOP_TEMPORARY, pszString);
FreeString (pszString);
CheckDlgButton (hDlg, IDC_STARTSTOP_PERMANENT, !lpp->fTemporary);
CheckDlgButton (hDlg, IDC_STARTSTOP_TEMPORARY, lpp->fTemporary);
}
void Filesets_General_OnInitDialog (HWND hDlg, LPIDENT lpi)
{
TCHAR szText[ cchRESOURCE ];
TCHAR szSvrName[ cchNAME ];
TCHAR szAggName[ cchNAME ];
TCHAR szSetName[ cchNAME ];
VOLUMEID vidFileset;
lpi->GetServerName (szSvrName);
lpi->GetAggregateName (szAggName);
lpi->GetFilesetName (szSetName);
lpi->GetFilesetID (&vidFileset);
GetDlgItemText (hDlg, IDC_SET_NAME, szText, cchRESOURCE);
LPTSTR pszText = FormatString (szText, TEXT("%s%s%s"), szSvrName, szAggName, szSetName);
SetDlgItemText (hDlg, IDC_SET_NAME, pszText);
FreeString (pszText);
pszText = FormatString (TEXT("%1"), TEXT("%lu"), vidFileset);
SetDlgItemText (hDlg, IDC_SET_ID, pszText);
FreeString (pszText);
EnableWindow (GetDlgItem (hDlg, IDC_SET_LOCK), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_SET_UNLOCK), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_SET_QUOTA), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_SET_WARN), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_SET_WARN_SETFULL_DEF), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_SET_WARN_SETFULL), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_SET_WARN_SETFULL_PERCENT), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_SET_WARN_SETFULL_DESC), FALSE);
}
USER::~USER (void)
{
if (m_lpiThis)
m_lpiThis->m_cRef --;
FreeString (m_mszOwnerOf);
FreeString (m_mszMemberOf);
}
void Subsets_FreeSubset (LPSUBSET sub)
{
if (sub != NULL)
{
if (sub->pszMonitored)
FreeString (sub->pszMonitored);
if (sub->pszUnmonitored)
FreeString (sub->pszUnmonitored);
Delete (sub);
}
}
DWORD WINAPI Message_ThreadProc (PVOID lp)
{
LPMESSAGE_PARAMS pmp = (LPMESSAGE_PARAMS)lp;
DWORD rc = MessageBox (NULL, pmp->pszText, pmp->pszTitle, pmp->dwType);
FreeString (pmp->pszText);
FreeString (pmp->pszTitle);
Delete(pmp);
return rc;
}
void Subsets_GetSubsetFromDialog (HWND hDlg, LPSUBSET sub)
{
HWND hList = GetDlgItem (hDlg, IDC_SUBSET_LIST);
if (sub->pszMonitored)
{
FreeString (sub->pszMonitored);
sub->pszMonitored = NULL;
}
if (sub->pszUnmonitored)
{
FreeString (sub->pszUnmonitored);
sub->pszUnmonitored = NULL;
}
// Is there only one server box checked?
//
int iiMax = (int) SendMessage (hList, LB_GETCOUNT, 0, 0);
size_t cChecked = 0;
int iiChecked;
for (int ii = 0; ii < iiMax; ++ii)
{
if (LB_GetCheck (hList, ii))
{
iiChecked = ii;
if ((++cChecked) > 1)
break;
}
}
if (cChecked == 1) // Only one is checked--use pszMonitored.
{
TCHAR szServer[ cchNAME ];
SendMessage (hList, LB_GETTEXT, iiChecked, (LPARAM)szServer);
FormatMultiString (&sub->pszMonitored, TRUE, TEXT("%1"), TEXT("%s"), szServer);
}
else // Use pszUnmonitored.
{
for (int ii = 0; ii < iiMax; ++ii)
{
if (!LB_GetCheck (hList, ii))
{
TCHAR szServer[ cchNAME ];
SendMessage (hList, LB_GETTEXT, ii, (LPARAM)szServer);
FormatMultiString (&sub->pszUnmonitored, TRUE, TEXT("%1"), TEXT("%s"), szServer);
}
}
}
}
void
FreeMenuList(struct MenuSpecial *ms)
{
struct MenuItem *item, *next, *stop, *special = ms->ms_Item;
APTR parent = ms->ms_Parent;
UBYTE type = ms->ms_Type;
if (!parent || !special)
return;
stop = special->NextItem;
if (type == MST_FIRSTITEM) {
item = ((struct Menu *)parent)->FirstItem;
((struct Menu *)parent)->FirstItem = special;
} else if (type == MST_FIRSTSUBITEM) {
item = ((struct MenuItem *)parent)->SubItem;
((struct MenuItem *)parent)->SubItem = special;
} else {
item = ((struct MenuItem *)parent)->NextItem;
((struct MenuItem *)parent)->NextItem = special;
}
for (;item != stop; item = next) {
next = item->NextItem;
if (item->Flags & ITEMTEXT) {
FreeString(((struct IntuiText *)item->ItemFill)->IText);
FreePooled(pool, item->ItemFill, sizeof(struct IntuiText));
}
FreePooled(pool, item, sizeof(struct SpecialMenuItem));
}
}
void nsOEStringBundle::GetStringByID( PRInt32 stringID, nsString& result, nsIStringBundle *pBundle)
{
PRUnichar *ptrv = GetStringByID( stringID, pBundle);
result = ptrv;
FreeString( ptrv);
}
void Server_Hosts_OnInitDialog (HWND hDlg, LPSVR_HOSTS_PARAMS lpp)
{
TCHAR szServer[ cchNAME ];
lpp->lpiServer->GetServerName (szServer);
LPTSTR pszText = FormatString (IDS_HOST_TITLE, TEXT("%s"), szServer);
SetDlgItemText (hDlg, IDC_HOST_TITLE, pszText);
FreeString (pszText);
HWND hList = GetDlgItem (hDlg, IDC_HOST_LIST);
// We'll need an imagelist, if we want icons in the list.
//
HIMAGELIST hLarge;
if ((hLarge = ImageList_Create (32, 32, ILC_COLOR4 | ILC_MASK, 1, 1)) != 0)
AfsAppLib_AddToImageList (hLarge, IDI_SERVER, TRUE);
HIMAGELIST hSmall;
if ((hSmall = ImageList_Create (16, 16, ILC_COLOR4 | ILC_MASK, 1, 1)) != 0)
AfsAppLib_AddToImageList (hSmall, IDI_SERVER, FALSE);
FastList_SetImageLists (hList, hSmall, hLarge);
// Start loading the host list
//
StartTask (taskSVR_HOSTLIST_OPEN, hDlg, lpp->lpiServer);
EnableWindow (hList, FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_HOST_ADD), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_HOST_REMOVE), FALSE);
}
void Server_Salvage_OnEndTask_Salvage (HWND hDlg, LPIDENT lpiSalvage, LPTASKPACKET ptp)
{
if (!ptp->rc)
{
ErrorDialog (ptp->status, IDS_ERROR_CANT_SALVAGE);
DestroyWindow (hDlg);
}
else
{
if (TASKDATA(ptp)->pszText1)
{
SetDlgItemText (hDlg, IDC_SALVAGE_DETAILS, TASKDATA(ptp)->pszText1);
}
else
{
TCHAR szServer[ cchNAME ];
lpiSalvage->GetServerName (szServer);
LPTSTR pszNoLog = FormatString (IDS_ERROR_CANT_READ_SALVAGE_LOG, TEXT("%s"), szServer);
SetDlgItemText (hDlg, IDC_SALVAGE_DETAILS, pszNoLog);
FreeString (pszNoLog);
}
ShowWindow (hDlg, SW_SHOW);
}
}
void Group_Create_OnNames (HWND hDlg)
{
TCHAR szSeparators[ cchRESOURCE ];
GetString (szSeparators, IDS_SEPARATORS);
lstrcat (szSeparators, TEXT(" \t"));
LPTSTR pszNames = GetEditText (GetDlgItem (hDlg, IDC_NEWGROUP_NAME));
EnableWindow (GetDlgItem (hDlg, IDOK), (pszNames && *pszNames));
BOOL fMultiple = FALSE;
for (LPTSTR psz = pszNames; !fMultiple && psz && *psz; ++psz)
{
if (lstrchr (szSeparators, *psz))
fMultiple = TRUE;
}
FreeString (pszNames);
EnableWindow (GetDlgItem (hDlg, IDC_NEWGROUP_ID_AUTO), !fMultiple);
EnableWindow (GetDlgItem (hDlg, IDC_NEWGROUP_ID_MANUAL), !fMultiple);
if (fMultiple)
{
CheckDlgButton (hDlg, IDC_NEWGROUP_ID_AUTO, TRUE);
CheckDlgButton (hDlg, IDC_NEWGROUP_ID_MANUAL, FALSE);
Group_Create_OnID (hDlg);
}
}
void nsEudoraStringBundle::GetStringByID(int32_t stringID, nsString& result)
{
PRUnichar *ptrv = GetStringByID(stringID);
result = ptrv;
FreeString(ptrv);
}
void Group_Create_OnInitDialog (HWND hDlg)
{
LPCREATEGROUPDLG lpp = (LPCREATEGROUPDLG)GetWindowLongPtr (hDlg, DWLP_USER);
// Fix the title of the dialog
//
ULONG status;
TCHAR szName[ cchNAME ];
asc_CellNameGet_Fast (g.idClient, g.idCell, szName, &status);
TCHAR szText[ cchRESOURCE ];
GetDlgItemText (hDlg, IDC_NEWGROUP_TITLE, szText, cchRESOURCE);
LPTSTR pszText = FormatString (szText, TEXT("%s"), szName);
SetDlgItemText (hDlg, IDC_NEWGROUP_TITLE, pszText);
FreeString (pszText);
// Attach a spinner to the ID control
//
CheckDlgButton (hDlg, IDC_NEWGROUP_ID_AUTO, TRUE);
CreateSpinner (GetDlgItem (hDlg, IDC_NEWGROUP_ID), 10, TRUE, -0x7FFFFFFF, -1, -1);
Group_Create_OnID (hDlg);
StartTask (taskOBJECT_GET, hDlg, (PVOID)(g.idCell));
}
DOS_TIME
CloseReadFile(
UINT *pcline
)
{
assert(Frb.fOpen);
assert(Frb.pf != NULL);
assert(Frb.pszFile != NULL);
if (Frb.fMakefile && DEBUG_4) {
BuildError("Closing file\n");
}
if (Frb.cNull > 1) {
BuildError("%hu null bytes in file\n", Frb.cNull);
}
fclose(Frb.pf);
Frb.fOpen = FALSE;
Frb.pf = NULL;
FreeString(&Frb.pszFile, MT_FRBSTRING);
if (Frb.pfrbNext != NULL) {
FILEREADBUF *pfrb;
FreeMem((VOID **) &Frb.pbBuffer, MT_IOBUFFER);
pfrb = Frb.pfrbNext;
if (pfrb->DateTime.value < Frb.DateTime.value) {
pfrb->DateTime = Frb.DateTime; // propagate subordinate timestamp
}
memcpy(&Frb, pfrb, sizeof(*pfrb));
FreeMem((VOID **) &pfrb, MT_FILEREADBUF);
}
if (pcline != NULL) {
*pcline = Frb.cLine;
}
return(Frb.DateTime);
}
static void FreeList( vlc_value_t *p_val )
{
int i;
for( i = 0; i < p_val->p_list->i_count; i++ )
{
switch( p_val->p_list->pi_types[i] & VLC_VAR_TYPE )
{
case VLC_VAR_STRING:
FreeString( &p_val->p_list->p_values[i] );
break;
case VLC_VAR_MUTEX:
FreeMutex( &p_val->p_list->p_values[i] );
break;
default:
break;
}
}
if( p_val->p_list->i_count )
{
free( p_val->p_list->p_values );
free( p_val->p_list->pi_types );
}
free( p_val->p_list );
}
void Server_SelectServer (HWND hDlg, LPIDENT lpiNew, BOOL fForceRedraw)
{
LPIDENT lpiOld = Server_GetServer (hDlg);
if (lpiNew != lpiOld)
{
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR)lpiNew);
if (hDlg != g.hMain)
{
if (lpiOld)
PropCache_Delete (pcSERVER, lpiOld);
if (lpiNew)
{
PropCache_Add (pcSERVER, lpiNew, hDlg);
TCHAR szName[ cchNAME ];
lpiNew->GetServerName (szName);
LPTSTR pszTitle = FormatString (IDS_SERVER_TITLE, TEXT("%s"), szName);
SetWindowText (hDlg, pszTitle);
FreeString (pszTitle);
}
}
fForceRedraw = TRUE;
}
if (fForceRedraw)
{
Server_ForceRedraw (hDlg);
}
}
void Server_FillAddrList (HWND hDlg, LPSERVERSTATUS lpss, BOOL fCanAddUnspecified)
{
HWND hList = GetDlgItem (hDlg, IDC_SVR_ADDRESSES);
LB_StartChange (hList, TRUE);
if (!lpss || !lpss->nAddresses)
{
if (fCanAddUnspecified)
(void)LB_AddItem (hList, IDS_SVR_NO_ADDR, (LPARAM)-1);
}
else for (size_t iAddr = 0; iAddr < lpss->nAddresses; ++iAddr)
{
int AddrInt;
AfsClass_AddressToInt (&AddrInt, &lpss->aAddresses[ iAddr ]);
if (AddrInt == 0)
continue;
LPTSTR pszAddress = FormatString (TEXT("%1"), TEXT("%a"), &lpss->aAddresses[ iAddr ]);
(void)LB_AddItem (hList, pszAddress, (LPARAM)iAddr);
FreeString (pszAddress);
}
LB_EndChange (hList, 0);
}
UINT_PTR AfsAppLib_GetCredentials (LPCTSTR pszCell, ULONG *pStatus)
{
UINT_PTR hCreds = 0;
ULONG status = 0;
UINT_PTR idClient;
if ((idClient = AfsAppLib_GetAdminServerClientID()) != 0)
{
hCreds = asc_CredentialsGet (idClient, pszCell, &status);
}
else
if (OpenClientLibrary())
{
LPSTR pszCellA = StringToAnsi (pszCell);
afsclient_TokenGetExisting (pszCellA, (PVOID *)&hCreds, (afs_status_p)&status);
FreeString (pszCellA, pszCell);
CloseClientLibrary();
}
if (!hCreds && pStatus)
*pStatus = status;
return hCreds;
}
void OpenCell_OnGotCreds (HWND hDlg, LPARAM lp)
{
LPOPENCELL_ONCELL_PARAMS lpp;
if ((lpp = (LPOPENCELL_ONCELL_PARAMS)lp) != NULL)
{
// Don't do anything to the dialog if the user has chosen a different
// cell than that for which we just queried credentials.
//
TCHAR szCell[ cchNAME ];
GetDlgItemText (hDlg, IDC_OPENCELL_CELL, szCell, cchNAME);
if (!lstrcmpi (szCell, lpp->szCell))
{
TCHAR szPrevCreds[ cchRESOURCE ];
GetDlgItemText (hDlg, IDC_OPENCELL_OLDCREDS, szPrevCreds, cchRESOURCE);
if (!lpp->fGotCreds)
{
LPTSTR psz = FormatString (IDS_CREDS_NONE, TEXT("%s"), lpp->szCell);
SetDlgItemText (hDlg, IDC_OPENCELL_OLDCREDS, psz);
FreeString (psz);
}
else if (!AfsAppLib_IsTimeInFuture (&lpp->stExpire))
{
LPTSTR pszCreds = FormatString (IDS_CREDS_EXPIRED, TEXT("%s%s%t"), lpp->szCell, lpp->szUser, &lpp->stExpire);
SetDlgItemText (hDlg, IDC_OPENCELL_OLDCREDS, pszCreds);
FreeString (pszCreds);
}
else
{
LPTSTR pszCreds = FormatString (IDS_CREDS_VALID, TEXT("%s%s%t"), lpp->szCell, lpp->szUser, &lpp->stExpire);
SetDlgItemText (hDlg, IDC_OPENCELL_OLDCREDS, pszCreds);
FreeString (pszCreds);
}
SetDlgItemText (hDlg, IDC_OPENCELL_ID, (lpp->fGotCreds) ? lpp->szUser : TEXT("admin"));
if (!lpp->fValidCreds && !szPrevCreds[0])
PostMessage (hDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hDlg,IDC_OPENCELL_PASSWORD), TRUE);
}
Delete (lpp);
}
}
void Browse_OnSelect (HWND hDlg)
{
LPBROWSE_PARAMS lpp;
if ((lpp = (LPBROWSE_PARAMS)GetWindowLongPtr (hDlg, DWLP_USER)) != NULL)
{
if (!lpp->fQuerying)
{
HWND hList = GetDlgItem (hDlg, IDC_BROWSE_LIST);
static TCHAR szSeparator[ cchRESOURCE ] = TEXT("");
if (szSeparator[0] == TEXT('\0'))
{
if (!GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_SLIST, szSeparator, cchRESOURCE))
lstrcpy (szSeparator, TEXT(","));
lstrcat (szSeparator, TEXT(" "));
}
LPTSTR pszText = NULL;
HLISTITEM hItem = NULL;
while ((hItem = FastList_FindNextSelected (hList, hItem)) != NULL)
{
LPCTSTR pszName;
if ((pszName = FastList_GetItemText (hList, hItem, 0)) != NULL)
{
LPTSTR pszNew;
if (pszText)
pszNew = FormatString (TEXT("%1%2%3"), TEXT("%s%s%s"), pszText, szSeparator, pszName);
else
pszNew = FormatString (TEXT("%1"), TEXT("%s"), pszName);
if (pszText)
FreeString (pszText);
pszText = pszNew;
}
if (pszText && !lpp->fAllowMultiple)
break;
}
SetDlgItemText (hDlg, IDC_BROWSE_NAMED, (pszText) ? pszText : TEXT(""));
if (pszText)
FreeString (pszText);
}
}
}
void Filesets_Restore_OnEndTask_LookupFileset (HWND hDlg, LPTASKPACKET ptp, LPSET_RESTORE_PARAMS psrp)
{
if (ptp)
{
psrp->lpi = (ptp->rc) ? TASKDATA(ptp)->lpi : NULL;
}
if (!psrp->lpi)
{
psrp->lpi = (LPIDENT)FL_GetSelectedData (GetDlgItem (hDlg, IDC_AGG_LIST));
}
BOOL fCreate = (psrp->lpi && psrp->lpi->fIsFileset()) ? FALSE : TRUE;
TCHAR szFileset[ cchNAME ];
GetDlgItemText (hDlg, IDC_RESTORE_SETNAME, szFileset, cchNAME);
LPTSTR pszText;
if (szFileset[0] == TEXT('\0'))
{
pszText = CloneString (TEXT(""));
}
else if (fCreate)
{
pszText = FormatString (IDS_RESTORE_CREATESET, TEXT("%s"), szFileset);
}
else
{
TCHAR szServer[ cchNAME ];
TCHAR szAggregate[ cchNAME ];
psrp->lpi->GetServerName (szServer);
psrp->lpi->GetAggregateName (szAggregate);
pszText = FormatString (IDS_RESTORE_OVERWRITESET, TEXT("%s%s%s"), szServer, szAggregate, szFileset);
}
SetDlgItemText (hDlg, IDC_RESTORE_CREATE, pszText);
FreeString (pszText);
EnableWindow (GetDlgItem (hDlg, IDC_RESTORE_SERVER), fCreate);
EnableWindow (GetDlgItem (hDlg, IDC_AGG_LIST), fCreate);
if (psrp->lpi)
{
LPIDENT lpiServer = (LPIDENT)CB_GetSelectedData (GetDlgItem (hDlg, IDC_RESTORE_SERVER));
if (psrp->lpi->GetServer() != lpiServer)
{
CB_SetSelectedByData (GetDlgItem (hDlg, IDC_RESTORE_SERVER), (LPARAM)psrp->lpi->GetServer());
Filesets_Restore_OnSelectServer (hDlg, psrp);
}
else if (!psrp->lpi->fIsServer())
{
FL_SetSelectedByData (GetDlgItem (hDlg, IDC_AGG_LIST), (LPARAM)psrp->lpi->GetAggregate());
}
}
Filesets_Restore_EnableOK (hDlg, psrp);
}
//frees everything associated with this string. This discards all characters, image data, etc.
void CTextureString::FreeData()
{
FreeString();
//and release our texture image
m_TextureImage = NULL;
//reset our extents
m_rExtents.Init(0, 0, 0, 0);
}
void NewAddr_OnInitDialog (HWND hDlg, LPSOCKADDR_IN pAddr)
{
TCHAR szText[ cchRESOURCE ];
GetDlgItemText (hDlg, IDC_TITLE, szText, cchRESOURCE);
LPTSTR pszTitle = FormatString (szText, TEXT("%a"), pAddr);
SetDlgItemText (hDlg, IDC_TITLE, pszTitle);
FreeString (pszTitle);
SA_SetAddr (GetDlgItem (hDlg, IDC_ADDRESS), pAddr);
}
bool VString::CopyString(const char *pStr)
{
FreeString();
m_pStr = (char*)malloc(strlen(pStr)+1);
if(!m_pStr)
return false;
strcpy(m_pStr, pStr);
return true;
}
// Sets the string for this reference object.
//
// This method sets the string to be referenced by this reference object.
//
// \param pStr
// string to reference
//
// \param bOwn
// if true then this object will create and keep copy of the input string, if false then
// just reference (pointer) to the input string will be kept.
void SetString( const char* pStr, bool bOwn = true )
{
FreeString();
m_bOwnString = bOwn;
if( m_bOwnString )
m_pStr = vStrDup( pStr );
else
m_pStr = pStr;
}
void Server_General_OnEndTask_InitDialog (HWND hDlg, LPIDENT lpiServer, LPTASKPACKET ptp)
{
TCHAR szText[ cchRESOURCE ];
if (!ptp->rc)
{
GetString (szText, IDS_UNKNOWN);
SetDlgItemText (hDlg, IDC_SVR_NUMAGGREGATES, szText);
SetDlgItemText (hDlg, IDC_SVR_CAPACITY, szText);
SetDlgItemText (hDlg, IDC_SVR_ALLOCATION, szText);
LB_StartChange (GetDlgItem (hDlg, IDC_SVR_ADDRESSES), TRUE);
LB_AddItem (GetDlgItem (hDlg, IDC_SVR_ADDRESSES), szText, (LPARAM)-1);
LB_EndChange (GetDlgItem (hDlg, IDC_SVR_ADDRESSES), (LPARAM)-1);
lpiServer->GetServerName (szText);
ErrorDialog (ptp->status, IDS_ERROR_REFRESH_SERVER_STATUS, TEXT("%s"), szText);
}
else
{
EnableWindow (GetDlgItem (hDlg, IDC_SVR_AUTH_YES), TRUE);
EnableWindow (GetDlgItem (hDlg, IDC_SVR_AUTH_NO), TRUE);
EnableWindow (GetDlgItem (hDlg, IDC_SVR_CHANGEADDR), TRUE);
wsprintf (szText, TEXT("%lu"), TASKDATA(ptp)->nAggr);
SetDlgItemText (hDlg, IDC_SVR_NUMAGGREGATES, szText);
LPTSTR pszText = FormatString (IDS_SVR_CAPACITY, TEXT("%.1B"), (double)TASKDATA(ptp)->ckCapacity * 1024.0);
SetDlgItemText (hDlg, IDC_SVR_CAPACITY, pszText);
FreeString (pszText);
DWORD dwPercentUsed = 100;
if (TASKDATA(ptp)->ckCapacity)
dwPercentUsed = (DWORD)( (double)100 * TASKDATA(ptp)->ckAllocation / TASKDATA(ptp)->ckCapacity );
pszText = FormatString (IDS_SVR_ALLOCATION, TEXT("%.1B%lu"), (double)TASKDATA(ptp)->ckAllocation * 1024.0, dwPercentUsed);
SetDlgItemText (hDlg, IDC_SVR_ALLOCATION, pszText);
FreeString (pszText);
Server_FillAddrList (hDlg, &TASKDATA(ptp)->ss);
}
}
//called to allocate a string. This will allocate the characters, the string, and handle copying
//them over
bool CTextureString::AllocateString(const wchar_t* pszString)
{
//make sure we don't already have a string allocated
FreeString();
if(!pszString)
return false;
//we now want to create a string using the other string as a base. This is done by first allocating
//our characters, matching them to the appropriate glyphs, and then ordering them
m_nNumCharacters = LTStrLen(pszString);
//allocate our main memory block
uint32 nMemBlockSize = 0;
nMemBlockSize += AlignAllocSize(sizeof(CTextureStringChar) * m_nNumCharacters);
nMemBlockSize += AlignAllocSize(sizeof(wchar_t) * m_nNumCharacters + 1);
uint8* pMemBlock;
LT_MEM_TRACK_ALLOC(pMemBlock = new uint8[nMemBlockSize], MEMORY_CATEGORY);
if(!pMemBlock)
{
FreeString();
return false;
}
CMemBlockAllocator Allocator(pMemBlock, nMemBlockSize);
//allocate the new buffer of characters
m_pCharacters = Allocator.AllocateObjects<CTextureStringChar>(m_nNumCharacters);
m_pszString = Allocator.AllocateObjects<wchar_t>(m_nNumCharacters + 1);
LTStrCpy(m_pszString, pszString, m_nNumCharacters + 1);
//sanity check on our memory block
if ( !(Allocator.GetAllocationOffset() == Allocator.GetBlockSize()))
ASSERT(!"Error: Incorrect usage of texture string memory block");
//success
return true;
}
void Actions_Refresh (void)
{
size_t nItems = 0;
TCHAR szText[ cchRESOURCE ];
HWND hList;
if ((hList = GetDlgItem (l.hAction, IDC_ACTION_LIST)) != NULL)
{
LPARAM lpOld = FL_StartChange (hList, TRUE);
if (l.pActionList)
{
for (size_t ii = 0; ii < l.pActionList->cEntries; ++ii)
{
LPTSTR pszDesc;
if ((pszDesc = GetActionDescription (&l.pActionList->aEntries[ ii ].Action)) != NULL)
{
SYSTEMTIME st;
TicksToElapsedTime (&st, GetTickCount() - l.pActionList->aEntries[ ii ].Action.csecActive);
FormatElapsed (szText, TEXT("%s"), &st);
FASTLISTADDITEM flai;
memset (&flai, 0x00, sizeof(flai));
flai.hParent = NULL;
flai.iFirstImage = IMAGE_NOIMAGE;
flai.iSecondImage = IMAGE_NOIMAGE;
flai.pszText = pszDesc;
flai.lParam = (LPARAM)ii;
flai.dwFlags = FLIF_DISALLOW_SELECT;
HLISTITEM hItem;
if ((hItem = FastList_AddItem (hList, &flai)) != NULL)
FastList_SetItemText (hList, hItem, 1, szText);
++nItems;
FreeString (pszDesc);
}
}
}
FL_EndChange (hList, lpOld);
}
if (nItems == 0)
GetString (szText, IDS_ACTION_DESC_NONE);
else if (nItems == 1)
GetString (szText, IDS_ACTION_DESC_ONE);
else // (nItems >= 2)
GetString (szText, IDS_ACTION_DESC_MULT);
SetDlgItemText (l.hAction, IDC_ACTION_DESC, szText);
}
