able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/ext/docprop/userdef.c

2401 lines
59 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
////////////////////////////////////////////////////////////////////////////////
//
// UserDef.c
//
// MS Office User Defined Property Information
//
// Notes:
// To make this file useful for OLE objects, define OLE_PROPS.
//
// The macro lpDocObj must be used for all methods to access the
// object data to ensure that this will compile with OLE_PROPS defined.
//
// Data structures:
// The dictionary is stored internally as a map, mapping PIDs
// to the string names.
//
// The properties themselves are stored internally as a linked list
//
// Change history:
//
// Date Who What
// --------------------------------------------------------------------------
// 06/27/94 B. Wentz Created file
// 07/03/94 B. Wentz Added Iterator support
// 07/20/94 M. Jansson Updated include statements, due to changes in PDK
// 07/26/94 B. Wentz Changed Load & Save to use Document Summary stream
// 07/08/96 MikeHill Ignore UserDef properties that aren't UDTYPEs.
//
////////////////////////////////////////////////////////////////////////////////
#include "priv.h"
#pragma hdrstop
static void PASCAL RemoveFromList (LPUDOBJ lpUDObj, LPUDPROP lpudprop);
static void PASCAL DeallocNode (LPUDOBJ lpUDObj, LPUDPROP lpudp);
static void PASCAL VUdpropFreeString (LPUDPROP lpudp, BOOL fName);
static BOOL PASCAL FUdpropUpdate (LPUDPROP lpudp, LPUDOBJ lpUDObj, LPTSTR lpszPropName, LPTSTR lpszLinkMonik, LPVOID lpvValue, UDTYPES udtype, BOOL fLink);
static BOOL PASCAL FUdpropSetString (LPUDPROP lpudp, LPTSTR lptstr, BOOL fLimitLength, BOOL fName);
static BOOL PASCAL FUdpropMakeVisible (LPUDPROP lpudprop);
static BOOL PASCAL FUserDefMakeHidden (LPUDOBJ lpUDObj, LPTSTR lpsz);
static BOOL PASCAL FUdpropMakeHidden (LPUDPROP lpudprop);
#define lpDocObj (lpUDObj)
#define lpData ((LPUDINFO) lpUDObj->m_lpData)
////////////////////////////////////////////////////////////////////////////////
//
// OfficeDirtyUDObj
//
// Purpose:
// Sets object state to dirty or clean.
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT VOID OfficeDirtyUDObj
(LPUDOBJ lpUDObj, // The object
BOOL fDirty) // Flag indicating if the object is dirty.
{
Assert(lpUDObj != NULL);
lpUDObj->m_fObjChanged = fDirty;
} // OfficeDirtyUDObj
////////////////////////////////////////////////////////////////////////////////
//
// FreeUDData
//
// Purpose:
// Deallocates all the member data for the object
//
// Note:
// Assumes object is valid.
//
////////////////////////////////////////////////////////////////////////////////
void PASCAL
FreeUDData
(LPUDOBJ lpUDObj, // Pointer to valid object
BOOL fTmp) // Indicates tmp data should be freed
{
LPUDPROP lpudp;
LPUDPROP lpudpT;
lpudp = (fTmp) ? lpData->lpudpTmpHead : lpData->lpudpHead;
while (lpudp != NULL)
{
lpudpT = lpudp;
lpudp = (LPUDPROP) lpudp->llist.lpllistNext;
VUdpropFree(&lpudpT);
}
if (fTmp)
{
lpData->lpudpTmpCache = NULL;
lpData->lpudpTmpHead = NULL;
lpData->dwcTmpProps = 0;
lpData->dwcTmpLinks = 0;
}
else
{
lpData->lpudpCache = NULL;
lpData->lpudpHead = NULL;
lpData->dwcProps = 0;
lpData->dwcLinks = 0;
}
} // FreeUDData
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefCreate
//
// Purpose:
// Create a User-defined property exchange object.
//
////////////////////////////////////////////////////////////////////////////////
BOOL
FUserDefCreate
(LPUDOBJ FAR *lplpUDObj, // Pointer to pointer to object
void *prglpfn[]) // Pointer to functions
{
LPUDOBJ lpUDObj; // Hack - a temp, must call it "lpUdObj" for macros to work!
if (lplpUDObj == NULL)
return(TRUE);
// Make sure we get valid args before we start alloc'ing
if ((prglpfn == NULL) || (prglpfn[ifnCPConvert] == NULL) ||
((prglpfn[ifnFSzToNum] == NULL) && (prglpfn[ifnFNumToSz] != NULL)) ||
((prglpfn[ifnFSzToNum] != NULL) && (prglpfn[ifnFNumToSz] == NULL))
)
{
return FALSE;
}
if ((*lplpUDObj = PvMemAlloc(sizeof(USERPROP))) == NULL)
{
// REVIEW: Add alert
return FALSE;
}
lpDocObj = *lplpUDObj;
//
// If alloc fails, free the original object too.
//
if ((lpData = PvMemAlloc(sizeof (UDINFO))) == NULL)
{
//
// REVIEW: Add alert
//
VFreeMemP(*lplpUDObj, sizeof(USERPROP));
return FALSE;
}
FillBuf ((void *) lpData, (int) 0, sizeof(UDINFO) );
//
// Save the fnc's for code page convert, SzToNum, NumToSz
//
lpData->lpfnFCPConvert = (BOOL (*)(LPTSTR, DWORD, DWORD, BOOL)) prglpfn[ifnCPConvert];
lpData->lpfnFSzToNum = (BOOL (*)(NUM *, LPTSTR)) prglpfn[ifnFSzToNum];
lpData->lpfnFNumToSz = (BOOL (*)(NUM *, LPTSTR, DWORD)) prglpfn[ifnFNumToSz];
OfficeDirtyUDObj (*lplpUDObj, FALSE);
(*lplpUDObj)->m_hPage = NULL;
return TRUE;
} // FUserDefCreate
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefDestroy
//
// Purpose:
// Destroy a User-defined property exchange object.
//
////////////////////////////////////////////////////////////////////////////////
BOOL
FUserDefDestroy
(LPUDOBJ FAR *lplpUDObj) // Pointer to pointer to object
{
#define lpUDData ((LPUDINFO)(((LPUDOBJ) *lplpUDObj)->m_lpData))
DWORD irg;
if ((lplpUDObj == NULL) || (*lplpUDObj == NULL))
return TRUE;
if (lpUDData != NULL)
{
FreeUDData (*lplpUDObj, FALSE);
FreeUDData (*lplpUDObj, TRUE);
//
// Invalidate any OLE Automation DocumentProperty objects we might have
//
InvalidateVBAObjects(NULL, NULL, *lplpUDObj);
VFreeMemP((*lplpUDObj)->m_lpData, sizeof(UDINFO));
}
VFreeMemP(*lplpUDObj, sizeof(USERPROP));
*lplpUDObj = NULL;
return TRUE;
#undef lpUDData
} // FUserDefDestroy
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefClear
//
// Purpose:
// Clears a User-defined property object without destroying it. All stored
// data is lost.
//
////////////////////////////////////////////////////////////////////////////////
BOOL
FUserDefClear(LPUDOBJ lpUDObj) // Pointer to object
{
if ((lpDocObj == NULL) || (lpData == NULL))
return TRUE;
FreeUDData (lpDocObj, FALSE);
FreeUDData (lpDocObj, TRUE);
//
// Invalidate any OLE Automation DocumentProperty objects we might have
//
InvalidateVBAObjects(NULL, NULL, lpUDObj);
//
// Clear the data, don't blt over the fn's stored at the end.
//
FillBuf ((void *) lpData, (int) 0, (sizeof (UDINFO) - ifnUDMax*(sizeof (void *))));
OfficeDirtyUDObj (lpUDObj, TRUE);
return TRUE;
} // FUserDefClear
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefShouldSave
//
// Purpose:
// Indicates if the data has changed, meaning a write is needed.
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT BOOL
FUserDefShouldSave
(LPUDOBJ lpUDObj) // Pointer to object
{
if (lpUDObj == NULL)
return FALSE;
return lpDocObj->m_fObjChanged;
} // FUserDefShouldSave
////////////////////////////////////////////////////////////////////////////////
//
// UdtypesUserDefType
//
// Purpose:
// Returns the type of the given Property Value from the string
//
// Returns wUDInvalid on error
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT UDTYPES
UdtypesUserDefType
(LPUDOBJ lpUDObj,
LPTSTR lpsz)
{
LPUDPROP lpudprop;
if ((lpUDObj == NULL) ||
(lpData == NULL) ||
(lpsz == NULL)
)
{
return wUDinvalid;
}
//
// Find the node that has this name.
//
lpudprop = LpudpropFindMatchingName (lpUDObj, lpsz);
if (lpudprop == NULL || lpudprop->lppropvar == NULL)
return wUDinvalid;
// Return the VarType (which is a UDTYPE)
return (lpudprop->lppropvar->vt);
} // UdtypesUserDefType
////////////////////////////////////////////////////////////////////////////////
//
// LpvoidUserDefGetPropVal
//
// Purpose:
// This will return the Property Value for the given Property String.
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT LPVOID
LpvoidUserDefGetPropVal
(LPUDOBJ lpUDObj, // Pointer to object
LPTSTR lpszProp, // Property string
DWORD cbMax, // Size of lpv
LPVOID lpv, // Buffer for prop val
DWORD dwMask, // Mask for what value is needed
BOOL *pfLink, // Indicates a link
BOOL *pfLinkInvalid) // Is the link invalid
{
LPUDPROP lpudprop;
if ((lpUDObj == NULL) ||
(lpData == NULL) ||
(lpszProp == NULL) ||
(cbMax == 0 && lpv != NULL) ||
(pfLink == NULL) ||
(pfLinkInvalid == NULL) ||
((lpv == NULL) && (!(dwMask & UD_PTRWIZARD)))
)
{
return NULL;
}
//
// Find the node that has this name.
//
lpudprop = LpudpropFindMatchingName (lpUDObj, lpszProp);
if (lpudprop == NULL)
return NULL;
Assert (lpudprop->lppropvar != NULL);
*pfLink = (lpudprop->lpstzLink != NULL);
// Links are always invalid in the shell (there's no app to update the data).
#ifdef SHELL
*pfLinkInvalid = lpudprop->fLinkInvalid = TRUE;
#else
*pfLinkInvalid = lpudprop->fLinkInvalid;
#endif
//
// Return based on the type and flags
//
if (dwMask & UD_LINK)
{
if (dwMask & UD_PTRWIZARD)
{
if (lpudprop->lpstzLink != NULL)
return((LPVOID) (PSTR (lpudprop->lpstzLink)));
return(NULL);
}
if (lpudprop->lpstzLink != NULL)
{
PbSzNCopy (lpv, lpudprop->lpstzLink, cbMax);
return (lpv);
}
else
return(NULL);
}
if (dwMask & UD_PTRWIZARD)
{
// If this is a string, return it's pointer from the
// PropVariant. Otherwise, return a pointer into
// the data of the PropVariant.
return (lpudprop->lppropvar->vt == VT_LPTSTR) ?
(LPVOID) lpudprop->lppropvar->pszVal :
(LPVOID) &lpudprop->lppropvar->lVal;
}
// Copy the property from the PropVariant to the caller-provided
// buffer.
return( FPropVarCopyToBuf( lpudprop->lppropvar,
cbMax,
lpv
) ? lpv : NULL
);
} // LpvoidUserDefGetPropVal
////////////////////////////////////////////////////////////////////////////////
//
// LppropvarUserDefAddProp
//
// Purpose:
// This will add a new Property to the set, with the given
// Property string, type, and data.
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT LPPROPVARIANT
LppropvarUserDefAddProp
(LPUDOBJ lpUDObj, // Pointer to object
LPTSTR lpszPropName, // Property string
LPVOID lpvVal, // Property value
UDTYPES udtype, // Property type
LPTSTR lpszLinkMonik, // Link name
BOOL fLink, // Indicates the property is a link
BOOL fHidden) // Indicates the property is hidden
{
LPUDPROP lpudprop;
LPUDPROP lpudpropMatch;
BOOL fCreated;
if ((lpUDObj == NULL) ||
(lpData == NULL) ||
(lpszPropName == NULL) ||
(*lpszPropName == 0) ||
(lpvVal == NULL) ||
(!ISUDTYPE(udtype)) ||
(fLink && (lpszLinkMonik == NULL))
)
{
return FALSE;
}
// Create a UDPROP to be added to the linked-list.
lpudprop = LpudpropCreate();
if (lpudprop == NULL)
return FALSE;
// Put the data into the UDPROP.
if (!FUdpropUpdate( lpudprop,
lpUDObj,
lpszPropName,
lpszLinkMonik,
lpvVal,
udtype,
fLink)
)
{
VUdpropFree (&lpudprop);
return(FALSE);
}
//
// Find this node
//
lpudpropMatch = LpudpropFindMatchingName (lpUDObj, lpszPropName);
if (lpudpropMatch==NULL)
{
//
// Create a node and put it in the list
// If a new node was created, it must be added to the list...
//
if (fLink)
lpData->dwcLinks++;
lpData->dwcProps++;
AddNodeToList (lpUDObj, lpudprop);
} // if (lpudpropMatch==NULL)
else
{
// We must replace the existing UDPROP with the new
// value.
// Free any existing property name and link name in this
// UDPROP, and free its value.
VUdpropFreeString (lpudpropMatch, TRUE);
VUdpropFreeString (lpudpropMatch, FALSE);
PropVariantClear (lpudpropMatch->lppropvar);
CoTaskMemFree (lpudpropMatch->lppropvar);
lpudpropMatch->lppropvar = NULL;
// Put the linked-list pointer in the existing UDPROP into
// the new UDPROP, then copy the new UDPROP back over
// the matching PROP (this way, we don't have to
// update the UDPROP that points to the match).
lpudprop->llist=lpudpropMatch->llist;
PbMemCopy(lpudpropMatch, lpudprop, sizeof(UDPROP));
// Clear out the caller-provided UDPROP, free it, but
// then set the pointer to the matching entry and clear
// the match pointer. Thus, after we're done and whether
// there was a match or not, lpudprop will point to the
// correct UDPROP.
FillBuf (lpudprop, 0, sizeof(UDPROP));
VUdpropFree (&lpudprop);
lpudprop = lpudpropMatch;
lpudpropMatch = NULL;
} // if (lpudpropMatch==NULL) ... else
//
// If the client asked for a hidden property, do it if
// the name was the real name, not a link
//
if (fHidden && !fLink)
{
fCreated=FUserDefMakeHidden (lpUDObj, lpszPropName); // Should never return false
Assert(fCreated);
}
OfficeDirtyUDObj (lpUDObj, TRUE);
// If successful, return a pointer to the PropVariant with the value.
if (lpudprop)
return lpudprop->lppropvar;
else
return NULL;
} // LppropvarUserDefAddProp
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefDeleteProp
//
// Purpose:
// This will delete a Property from the set given a Property string.
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT BOOL
FUserDefDeleteProp
(LPUDOBJ lpUDObj, // Pointer to object
LPTSTR lpsz) // String to delete
{
LPUDPROP lpudprop;
if ((lpUDObj == NULL) ||
(lpData == NULL) ||
(lpsz == NULL))
return FALSE;
// Find the node
lpudprop = LpudpropFindMatchingName (lpUDObj, lpsz);
if (lpudprop == NULL)
return FALSE;
lpData->dwcProps--;
if (lpudprop->lpstzLink != NULL)
lpData->dwcLinks--;
RemoveFromList (lpUDObj, lpudprop);
VUdpropFree (&lpudprop);
OfficeDirtyUDObj (lpUDObj, TRUE);
return TRUE;
} // FUserDefDeleteProp
////////////////////////////////////////////////////////////////////////////////
//
// LpudiUserDefCreateIterator
//
// Purpose:
// Create a User-defined Properties iterator
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT LPUDITER
LpudiUserDefCreateIterator
(LPUDOBJ lpUDObj) // Pointer to object
{
LPUDITER lpudi;
if ((lpUDObj == NULL) ||
(lpData == NULL) ||
(lpData->lpudpHead == NULL)) // No custom props
return NULL;
// Create & Init the iterator
lpudi = PvMemAlloc(sizeof(UDITER));
if (lpudi == NULL)
return(NULL);
FillBuf (lpudi, 0, sizeof (UDITER));
lpudi->lpudp = lpData->lpudpHead;
return lpudi;
} // LpudiUserDefCreateIterator
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefDestroyIterator
//
// Purpose:
// Destroy a User-defined Properties iterator
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT BOOL
FUserDefDestroyIterator
(LPUDITER *lplpUDIter) // Pointer to iterator
{
if ((lplpUDIter == NULL) || (*lplpUDIter == NULL))
return TRUE;
VFreeMemP(*lplpUDIter, sizeof(UDITER));
*lplpUDIter = NULL;
return TRUE;
} // FUserDefDestroyIterator
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefIteratorValid
//
// Purpose:
// Determine if an iterator is still valid
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT BOOL
FUserDefIteratorValid
(LPUDITER lpUDIter) // Pointer to iterator
{
if (lpUDIter == NULL)
return FALSE;
return (lpUDIter->lpudp != NULL);
} // FUserDefIteratorValid
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefIteratorNext
//
// Purpose:
// Iterate to the next element
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT BOOL
FUserDefIteratorNext
(LPUDITER lpUDIter) // Pointer to iterator
{
if (lpUDIter == NULL)
return FALSE;
// Move to the next node, if possible.
#ifdef OLD
if (lpUDIter->lpudp != NULL)
lpUDIter->lpudp = (LPUDPROP) lpUDIter->lpudp->llist.lpllistNext;
return TRUE;
#endif
if (lpUDIter->lpudp == NULL)
return FALSE;
lpUDIter->lpudp = (LPUDPROP) lpUDIter->lpudp->llist.lpllistNext;
return(lpUDIter->lpudp != NULL);
} // FUserDefIteratorNext
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefIteratorIsLink
//
// Purpose:
// Returns TRUE if the iterator is a link, FALSE otherwise
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT BOOL
FUserDefIteratorIsLink
(LPUDITER lpUDIter) // Pointer to iterator
{
if ((lpUDIter == NULL) || (lpUDIter->lpudp == NULL))
return FALSE;
return(lpUDIter->lpudp->lpstzLink != NULL);
} // FUserDefIteratorIsLink
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefIteratorIsLinkInvalid
//
// Purpose:
// Returns TRUE if the iterator is an invalid link, FALSE otherwise
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT BOOL
FUserDefIteratorIsLinkInvalid
(LPUDITER lpUDIter) // Pointer to iterator
{
if ((lpUDIter == NULL) || (lpUDIter->lpudp == NULL))
return(FALSE);
if (lpUDIter->lpudp->lpstzLink == NULL)
return(FALSE);
return(lpUDIter->lpudp->fLinkInvalid);
} // FUserDefIteratorIsLinkInvalid
////////////////////////////////////////////////////////////////////////////////
//
// UdtypesUserDefIteratorType
//
// Purpose:
// Returns the type of the given Property Value from the iterator
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT UDTYPES
UdtypesUserDefIteratorType
(LPUDITER lpUDIter) // Pointer to iterator
{
if ((lpUDIter == NULL) ||
(lpUDIter->lpudp == NULL) ||
(lpUDIter->lpudp->lppropvar == NULL))
return wUDinvalid;
return (lpUDIter->lpudp->lppropvar->vt);
} // UdtypesUserDefIteratorType
////////////////////////////////////////////////////////////////////////////////
//
// LpvoidUserDefGetIteratorVal
//
// Purpose:
// This will return the Property Value for the given iterator
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT LPVOID
LpvoidUserDefGetIteratorVal
(LPUDITER lpUDIter, // Pointer to iterator
DWORD cbMax, // Max size of lpv
LPVOID lpv, // Buffer to copy data value to
DWORD dwMask, // Mask indicating the value to get
BOOL *pfLink, // Flag indicating the link is desired
BOOL *pfLinkInvalid) // Flag indicating if the link is invalid
{
if ((cbMax == 0) ||
((lpv == NULL) && (!(dwMask & UD_PTRWIZARD))) ||
(lpUDIter == NULL) ||
(pfLink == NULL) ||
(pfLinkInvalid == NULL) ||
(lpUDIter->lpudp == NULL))
return NULL;
*pfLink = (lpUDIter->lpudp->lpstzLink != NULL);
*pfLinkInvalid = lpUDIter->lpudp->fLinkInvalid;
// Return based on the type and flags
if (dwMask & UD_LINK)
{
if (dwMask & UD_PTRWIZARD)
{
if (lpUDIter->lpudp->lpstzLink != NULL)
return((LPVOID) (PSTR (lpUDIter->lpudp->lpstzLink)));
return(NULL);
}
if (lpUDIter->lpudp->lpstzLink != NULL)
{
PbSzNCopy (lpv, lpUDIter->lpudp->lpstzLink, cbMax);
return (lpv);
}
else
return(NULL);
}
if (dwMask & UD_PTRWIZARD)
{
Assert (lpUDIter->lpudp->lppropvar != NULL);
Assert (lpUDIter->lpudp->lppropvar->vt == VT_LPTSTR
||
lpUDIter->lpudp->lppropvar->vt == VT_INT_PTR);
// If this is a string property, return a pointer to it.
// Otherwise it is a Long/LongPtr, and we return its value.
return ( lpUDIter->lpudp->lppropvar->vt == VT_LPTSTR
? (LPVOID) lpUDIter->lpudp->lppropvar->pszVal
#ifdef _WIN64
: (LPVOID) lpUDIter->lpudp->lppropvar->hVal.QuadPart
#else
: (LPVOID) lpUDIter->lpudp->lppropvar->lVal
#endif
);
}
// Copy the value of this property into a caller-provided buffer.
return(FPropVarCopyToBuf(lpUDIter->lpudp->lppropvar, cbMax, lpv) ? lpv : NULL);
} // LpvoidUserDefGetIteratorVal
////////////////////////////////////////////////////////////////////////////////
//
// LpszUserDefIteratorName
//
// Purpose:
// This will return the Property String (name) for the property
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT LPTSTR
LpszUserDefIteratorName
(LPUDITER lpUDIter, // Pointer to iterator
DWORD cbMax, // Max size of lpsz
LPTSTR lpsz) // Buffer to copy into, or UD_PTRWIZARD
{
if ((cbMax == 0) ||
(lpsz == NULL) ||
(lpUDIter == NULL) ||
(lpUDIter->lpudp == NULL))
{
return NULL;
}
// If the lpsz input is not actually a pointer, but the
// UD_PTRWIZARD value, then the caller doesn't want
// us to copy the name into a buffer, they just want
// us to return a pointer to the name.
if ((INT_PTR) lpsz == UD_PTRWIZARD)
{
AssertSz ((IsBadReadPtr (lpsz, sizeof(LPTSTR))), TEXT("UD_PTRWIZARD should be a bogus pointer value!"));
return (lpUDIter->lpudp->lpstzName);
}
// The caller gave us a real buffer in lpsz.
// Copy the name into it, and return it.
PbSzNCopy (lpsz, lpUDIter->lpudp->lpstzName, cbMax-1);
lpsz[cbMax-1] = TEXT('\0');
return lpsz;
} // LpszUserDefIteratorName
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefIteratorSetPropString
//
// Purpose:
// Sets the name of the iterator.
//
////////////////////////////////////////////////////////////////////////////////
DLLFUNC BOOL OFC_CALLTYPE
FUserDefIteratorSetPropString
(LPUDOBJ lpUDObj, // Pointer to object
LPUDITER lpUDIter, // Pointer to iterator
LPTSTR lpszNew) // Pointer to new name
{
if ((lpUDObj == NULL) ||
(lpData == NULL) ||
(lpszNew == NULL) ||
(lpUDIter == NULL) ||
(lpUDIter->lpudp == NULL))
return FALSE;
// Update the node
if (!FUdpropSetString (lpUDIter->lpudp, lpszNew, TRUE, TRUE))
return FALSE;
OfficeDirtyUDObj (lpUDObj, TRUE);
return TRUE;
} // FUserDefIteratorSetPropString
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefIteratorChangeVal
//
// Purpose:
// Changes the value of the data stored.
//
////////////////////////////////////////////////////////////////////////////////
DLLFUNC BOOL OFC_CALLTYPE
FUserDefIteratorChangeVal
(LPUDOBJ lpUDObj, // Pointer to object
LPUDITER lpUDIter, // Pointer to iterator
UDTYPES udtype, // The type
LPVOID lpv, // New value.
BOOL fLinkInvalid) // Is the link still valid?
{
if ((lpUDObj == NULL) ||
(lpData == NULL) ||
(lpUDIter == NULL) ||
(!ISUDTYPE (udtype)) ||
(lpUDIter->lpudp == NULL))
return FALSE;
if (fLinkInvalid)
{
if (lpUDIter->lpudp->lpstzLink == NULL)
return FALSE;
lpUDIter->lpudp->fLinkInvalid = TRUE;
return TRUE;
}
else
lpUDIter->lpudp->fLinkInvalid = FALSE;
if (!FPropVarLoad (lpUDIter->lpudp->lppropvar, (VARTYPE)udtype, lpv))
return FALSE;
OfficeDirtyUDObj (lpUDObj, TRUE);
return TRUE;
} // FUserDefIteratorChangeVal
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefIteratorSetLink
//
// Purpose:
// Sets the link value for a property. This is NOT a public API.
//
////////////////////////////////////////////////////////////////////////////////
BOOL PASCAL
FUserDefIteratorSetLink
(LPUDOBJ lpUDObj, // Pointer to object
LPUDITER lpUDIter, // Pointer to iterator
LPTSTR lpszLink) // New link name
{
if ((lpUDObj == NULL) ||
(lpData == NULL) ||
(lpUDIter == NULL) ||
(lpUDIter->lpudp == NULL))
return FALSE;
Assert(lpszLink != NULL);
Assert(*lpszLink != TEXT('\0'));
// Should already be a link
Assert(lpUDIter->lpudp->lpstzLink != NULL);
if (!FUdpropSetString (lpUDIter->lpudp, lpszLink, FALSE, FALSE))
return FALSE;
return TRUE;
} // FUserDefIteratorSetLink
////////////////////////////////////////////////////////////////////////////////
//
// LpudiUserDefCreateIterFromLpudp
//
// Purpose:
// Creates an iterator object from a node. This is not a public API.
//
////////////////////////////////////////////////////////////////////////////////
LPUDITER PASCAL
LpudiUserDefCreateIterFromLpudp
(LPUDOBJ lpUDObj, // Pointer to object
LPUDPROP lpudp) // Pointer to node
{
LPUDITER lpudi;
if ((lpUDObj == NULL) ||
(lpData == NULL) ||
(lpudp == NULL))
return NULL;
lpudi = LpudiUserDefCreateIterator (lpUDObj);
if (lpudi != NULL)
lpudi->lpudp = lpudp;
return lpudi;
} // LpudiUserDefCreateIterFromLpudp
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefIsHidden
//
// Purpose:
// Determine if a Property string is hidden.
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT BOOL
FUserDefIsHidden
(LPUDOBJ lpUDObj, // Pointer to object
LPTSTR lpsz) // Property string
{
if (lpsz == NULL)
return FALSE;
// We don't really need the object, we can tell from the name
return (lpsz[0] == HIDDENPREFIX);
} // FUserDefIsHidden
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefMakeVisible
//
// Purpose:
// Make a property visible based on the Property string
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT BOOL
FUserDefMakeVisible
(LPUDOBJ lpUDObj, // Pointer to object
LPTSTR lpsz) // String to hide.
{
LPUDPROP lpudprop;
ULONG cb;
if ((lpUDObj == NULL) ||
(lpData == NULL) ||
(lpsz == NULL))
return FALSE;
// Find the name
lpudprop = LpudpropFindMatchingName (lpUDObj, lpsz);
if (lpudprop == NULL)
return FALSE;
if (!FUdpropMakeVisible (lpudprop))
return FALSE;
OfficeDirtyUDObj (lpUDObj, TRUE);
return TRUE;
} // FUserDefMakeVisible
////////////////////////////////////////////////////////////////////////////////
//
// FUserDefMakeHidden
//
// Purpose:
// Hide a Property based on the Property string.
//
////////////////////////////////////////////////////////////////////////////////
static BOOL PASCAL
FUserDefMakeHidden
(LPUDOBJ lpUDObj, // Pointer to object
LPTSTR lpsz) // String to hide
{
LPUDPROP lpudprop;
LPTSTR lpstzT;
if ((lpUDObj == NULL) ||
(lpData == NULL) ||
(lpsz == NULL))
return FALSE;
// Find the name
lpudprop = LpudpropFindMatchingName (lpUDObj, lpsz);
if (lpudprop == NULL)
return FALSE;
if (!FUdpropMakeHidden (lpudprop))
return FALSE;
OfficeDirtyUDObj (lpUDObj, TRUE);
return TRUE;
} // FUserDefMakeHidden
////////////////////////////////////////////////////////////////////////////////
//
// LpudpropFindMatchingName
//
// Purpose:
// Returns a node with a matching name, NULL otherwise.
//
////////////////////////////////////////////////////////////////////////////////
LPUDPROP PASCAL
LpudpropFindMatchingName
(LPUDOBJ lpUDObj, // Pointer to object
LPTSTR lpsz) // String to search for
{
LPUDPROP lpudprop;
TCHAR sz[256];
BOOL fCopy = FALSE;
if ((lpUDObj == NULL) || (lpData == NULL))
return(NULL);
if (CchTszLen(lpsz) > 255)
{
PbSzNCopy(sz, lpsz, 255);
sz[255] = 0;
fCopy = TRUE;
}
// Check the cache first
if (lpData->lpudpCache != NULL)
{
Assert ((lpData->lpudpCache->lpstzName != NULL));
// lstrcmpi returns 0 if 2 strings are equal.....
if (!(lstrcmpi (fCopy ? sz : lpsz, (LPTSTR)PSTR (lpData->lpudpCache->lpstzName))))
return lpData->lpudpCache;
}
lpudprop = lpData->lpudpHead;
while (lpudprop != NULL)
{
Assert ((lpudprop->lpstzName != NULL));
// lstrcmpi returns 0 if 2 strings are equal.....
if (!(lstrcmpi (fCopy ? sz : lpsz, (LPTSTR)PSTR (lpudprop->lpstzName))))
{
// Set the cache to the last node found
lpData->lpudpCache = lpudprop;
return lpudprop;
}
lpudprop = (LPUDPROP) lpudprop->llist.lpllistNext;
} // while
return NULL;
} // LpudpropFindMatchingName
////////////////////////////////////////////////////////////////////////////////
//
// LpudpropFindMatchingPID
//
// Purpose:
// Searches the linked-list in the caller-provided UDINFO structure
// for a UDPROP with the requested PropID.
//
// Inputs:
// LPUDOBJ - The UDINFO structure
// PROPID - The PID to search for.
//
// Output:
// The requested LPUDPROP, or NULL if not found.
//
////////////////////////////////////////////////////////////////////////////////
LPUDPROP PASCAL
LpudpropFindMatchingPID
(LPUDOBJ lpUDObj,
PROPID propid)
{
// ------
// Locals
// ------
LPUDPROP lpudprop = NULL;
BOOL fCopy = FALSE;
// -----
// Begin
// -----
// Validate the inputs.
if ((lpUDObj == NULL) || (lpData == NULL))
{
AssertSz (0, TEXT("Invalid inputs"));
goto Exit;
}
// Check the cache first
if (lpData->lpudpCache != NULL
&&
lpData->lpudpCache->propid == propid)
{
lpudprop = lpData->lpudpCache;
goto Exit;
}
// Search the linked-list.
lpudprop = lpData->lpudpHead;
while (lpudprop != NULL)
{
if (lpudprop->propid == propid)
{
lpData->lpudpCache = lpudprop;
goto Exit;
}
lpudprop = (LPUDPROP) lpudprop->llist.lpllistNext;
}
// ----
// Exit
// ----
Exit:
return lpudprop;
} // LpudpropFindMatchingPID
////////////////////////////////////////////////////////////////////////////////
//
// FAddPropToList
//
// Purpose:
// Adds the given object to the list. The type and value must
// be filled in before calling this.
//
// The linked-list we're adding to has one entry for each of
// the user-defined properties. Each entry has the property
// value, it's PID, and it's name. If the property is linked
// to document content, the link name (e.g. a Bookmark name
// in Word) is also in this entry. Note that the property set
// stores the property value as one property, with its name in the
// dictionary, and it stores the link name as a second property.
// Consequently, this routine will be called twice for such
// properties: on the first call we'll create a new entry in the
// linked-list, adding the property ID, name, and value; on the
// second call we'll pull out that entry, and add the link name.
//
// On success, the input lppropvar & lpstatpropstg are cleared.
// On error, all inputs are left unmodified.
//
////////////////////////////////////////////////////////////////////////////////
BOOL PASCAL
FAddPropToList
(LPUDOBJ lpUDObj,
LPPROPVARIANT lppropvar,
STATPROPSTG *lpstatpropstg,
LPUDPROP lpudprop) // Property to add
{
// ------
// Locals
// ------
BOOL fSuccess = FALSE;
LPTSTR lpstz;
LPUDPROP lpudpT;
BOOL fLink;
USES_CONVERSION ;
Assert(lpUDObj != NULL);
Assert(lpudprop != NULL); // Is this a bogus assert?
Assert(lppropvar != NULL && lpstatpropstg != NULL);
// If the PId has one of the special masks, strip it off
// so the PId will match the normal value.
fLink = lpstatpropstg->propid & PID_LINKMASK;
lpstatpropstg->propid &= ~PID_LINKMASK;
// ------------------------------------------------------------
// See if we can find this property already in the linked-list.
// If we have a name, use that, otherwise use the PID.
// ------------------------------------------------------------
if (lpstatpropstg->lpwstrName != NULL)
{
// Search by name.
// [scotthan] Re: bogus cast to TCHAR in propio.c when this thing
// was read out of the file. If this is an ANSI build, it's going to store
// a TCHAR* value!. So we need to reciprocate the cast...
lpudpT = LpudpropFindMatchingName (lpUDObj, (LPTSTR)lpstatpropstg->lpwstrName );
}
else
{
// Search by PID
lpudpT = LpudpropFindMatchingPID (lpUDObj, lpstatpropstg->propid);
}
// --------------------------------------------------------------
// If this property isn't already in the linked-list, add it now.
// --------------------------------------------------------------
if (lpudpT == NULL)
{
// This should be a named property. If it's not
// named, then it should be a link, and the property
// it links should have been in the linked-list already
// (i.e., the lpudpT should have been non-NULL).
if (lpstatpropstg->lpwstrName == NULL)
{
AssertSz (0, TEXT("Missing name in User-Defined properties"));
goto Exit;
}
// Allocate memory for the property value.
lpudprop->lppropvar = CoTaskMemAlloc (sizeof(PROPVARIANT));
if (lpudprop->lppropvar == NULL)
{
AssertSz (0, TEXT("Couldn't allocate lpudprop->lppropvar"));
goto Exit;
}
// Load the property ID, name, and value.
// Note that if we had an error before here, we left
// the caller's inputs un-touched. Since no more errors
// can occur, we'll never have half-modified data in an
// error case.
lpudprop->propid = lpstatpropstg->propid;
// [scotthan] Re: bogus cast to TCHAR in propio.c when this thing
// was read out of the file. If this is an ANSI build, it's going to store
// a TCHAR* value!. So we need to reciprocate the cast...
lpudprop->lpstzName = (LPTSTR)lpstatpropstg->lpwstrName;
lpstatpropstg->lpwstrName = NULL;
*lpudprop->lppropvar = *lppropvar;
PropVariantInit (lppropvar);
lpData->dwcProps++;
AddNodeToList (lpUDObj, lpudprop);
} // if ((lpudpT = LpudpropFindMatchingName (lpUDInfo, lpstatpropstg->lpwsz)) == NULL)
// --------------------------------------------------------
// Otherwise (this property is already in the linked-list),
// add this new link name or value to the UDPROP.
// --------------------------------------------------------
else
{
// If this is a link being added, then update the link-name in the
// extant property.
if (fLink)
{
// lpudpT points to the entry in our linked-list for this
// property. But it shouldn't already have a link-name (there
// can only be one link-name per property).
if (lpudpT->lpstzLink != NULL)
{
AssertSz (0, TEXT("Invalid property set - link name defined twice"));
goto Exit;
}
// Since this is a link-name, it should be a string.
if (lppropvar->vt != VT_LPTSTR)
{
AssertSz (0, TEXT("Invalid property set - link name isn't a string"));
goto Exit;
}
// Point the UDPROP to the link name, and take ownership
// of it by clearing the caller's pointer.
Assert (lppropvar->pszVal != NULL);
lpudpT->lpstzLink = (LPTSTR) lppropvar->pszVal;
PropVariantInit (lppropvar);
lpData->dwcLinks++;
} // if (fLink)
// Otherwise, this isn't a link name, it's a value. So point the
// UDPROP to it's data.
else
{
*lpudpT->lppropvar = *lppropvar;
PropVariantInit (lppropvar);
} // if (fLink) ... else
} // if ((lpudpT = LpudpropFindMatchingName ... else
fSuccess = TRUE;
Exit:
// Just in case we were given a name that we didn't
// need, clear it now so that the caller knows that
// on success, they needn't worry about the buffers
// pointed to by lppropvar & lpstatpropstg.
if (fSuccess)
{
if (lpstatpropstg->lpwstrName != NULL)
{
CoTaskMemFree (lpstatpropstg->lpwstrName);
lpstatpropstg->lpwstrName = NULL;
}
}
return(fSuccess);
} // FAddPropToList
////////////////////////////////////////////////////////////////////////////////
//
// AddNodeToList
//
// Purpose:
// Adds the given node to the list.
//
////////////////////////////////////////////////////////////////////////////////
void PASCAL
AddNodeToList
(LPUDOBJ lpUDObj, // Pointer to object
LPUDPROP lpudprop) // Node to add
{
// Put the new node at the end
if (lpData->lpudpHead != NULL)
{
if (lpData->lpudpHead->llist.lpllistPrev != NULL)
{
((LPUDPROP) lpData->lpudpHead->llist.lpllistPrev)->llist.lpllistNext = (LPLLIST) lpudprop;
lpudprop->llist.lpllistPrev = lpData->lpudpHead->llist.lpllistPrev;
}
else
{
lpData->lpudpHead->llist.lpllistNext = (LPLLIST) lpudprop;
lpudprop->llist.lpllistPrev = (LPLLIST) lpData->lpudpHead;
}
lpData->lpudpHead->llist.lpllistPrev = (LPLLIST) lpudprop;
}
else
{
lpData->lpudpHead = lpudprop;
lpudprop->llist.lpllistPrev = NULL;
}
lpudprop->llist.lpllistNext = NULL;
lpData->lpudpCache = lpudprop;
} // AddNodeToList
////////////////////////////////////////////////////////////////////////////////
//
// RemoveFromList
//
// Purpose:
// Removes the given node from the list
//
////////////////////////////////////////////////////////////////////////////////
static void PASCAL
RemoveFromList
(LPUDOBJ lpUDObj, // Pointer to object
LPUDPROP lpudprop) // The node itself.
{
AssertSz ((lpData->lpudpHead != NULL), TEXT("List is corrupt"));
// If we're removing the cached node, invalidate the cache
if (lpudprop == lpData->lpudpCache)
{
lpData->lpudpCache = NULL;
}
// Be sure the head gets updated, if the node is at the front
if (lpudprop == lpData->lpudpHead)
{
lpData->lpudpHead = (LPUDPROP) lpudprop->llist.lpllistNext;
if (lpData->lpudpHead != NULL)
{
lpData->lpudpHead->llist.lpllistPrev = lpudprop->llist.lpllistPrev;
}
return;
}
// Update the links
if (lpudprop->llist.lpllistNext != NULL)
{
((LPUDPROP) lpudprop->llist.lpllistNext)->llist.lpllistPrev = lpudprop->llist.lpllistPrev;
}
if (lpudprop->llist.lpllistPrev != NULL)
{
((LPUDPROP) lpudprop->llist.lpllistPrev)->llist.lpllistNext = lpudprop->llist.lpllistNext;
}
// If it is the last node in the list, be sure the head is updated
if (lpudprop == (LPUDPROP) lpData->lpudpHead->llist.lpllistPrev)
{
lpData->lpudpHead->llist.lpllistPrev = lpudprop->llist.lpllistPrev;
}
} // RemoveFromList
////////////////////////////////////////////////////////////////////////////////
//
// DeallocValue
//
// Purpose:
// Deallocates the value in the buffer.
//
////////////////////////////////////////////////////////////////////////////////
void PASCAL
DeallocValue
(LPVOID *lplpvBuf, // Pointer to buffer to dealloc
UDTYPES udtype) // Type stored in buffer
{
DWORD cb=0;
if (*lplpvBuf == NULL)
return;
switch (udtype)
{
case wUDdate :
case wUDfloat :
Assert(sizeof(FILETIME) == sizeof(NUM));
cb = sizeof(NUM);
break;
case wUDlpsz :
cb = CBTSTR(*lplpvBuf);
break;
case wUDbool:
case wUDdw:
AssertSz (((sizeof(LPVOID) >= sizeof(DWORD)) && (sizeof(LPVOID) >= sizeof(WORD))),
TEXT("Sizes of basic types have changed!"));
return;
default:
Assert(fFalse);
return;
}
VFreeMemP(*lplpvBuf,cb);
*lplpvBuf = NULL;
} // DeallocValue
////////////////////////////////////////////////////////////////////////////////
//
// VUdpropFree
//
// Purpose:
// Free a UDPROP (which is in a linked-list).
//
// Inputs:
// LPUDPROP * - A pointer-to-pointer-to a UDPROP object.
//
// Output:
// None.
//
////////////////////////////////////////////////////////////////////////////////
VOID
VUdpropFree
(LPUDPROP *lplpudp)
{
// Validate the inputs.
if (lplpudp == NULL
||
*lplpudp == NULL)
{
goto Exit;
}
// If this property has a name, free that buffer.
if ((*lplpudp)->lpstzName)
{
CoTaskMemFree ((*lplpudp)->lpstzName);
}
// If this property has a link-name, free it too.
if ((*lplpudp)->lpstzLink)
{
CoTaskMemFree ((*lplpudp)->lpstzLink);
}
// Clear the property value, which will free any associated
// buffer. Then free the PropVariant itself.
PropVariantClear ((*lplpudp)->lppropvar);
CoTaskMemFree ((*lplpudp)->lppropvar);
CoTaskMemFree (*lplpudp);
*lplpudp = NULL;
Exit:
return;
} // VUdpropFree
////////////////////////////////////////////////////////////////////////////////
//
// FUdpropUpdate
//
// Purpose:
// Updates the given node with the given data
//
// It's the caller's responsibility to free lpudp if this function
// fails.
//
// Inputs:
// LPUDPROP - The node in the linked-list for this property.
// LPUDOBJ - All User-Defined data (including the properties)
// LPTSTR - The property name.
// LPTSTR - The link-name
// LPVOID - The new value
// UDTYPES - The type of the value.
// BOOL - TRUE if this is a link.
//
////////////////////////////////////////////////////////////////////////////////
static BOOL PASCAL
FUdpropUpdate
(LPUDPROP lpudp,
LPUDOBJ lpUDObj,
LPTSTR lpszPropName,
LPTSTR lpszLinkMonik,
LPVOID lpvValue,
UDTYPES udtype,
BOOL fLink)
{
// ------
// Locals
// ------
BOOL fSuccess = FALSE;
// -----
// Begin
// -----
// Validate the inputs.
if ((lpudp == NULL) ||
(lpszPropName == NULL) ||
(lpvValue == NULL) ||
(fLink && (lpszLinkMonik == NULL)) ||
(!ISUDTYPE(udtype)))
{
goto Exit;
}
// Update the property name
if (!FUdpropSetString (lpudp, lpszPropName, TRUE, TRUE))
goto Exit;
// If necessary, allocate a PropVariant for the UDPROPS
if (lpudp->lppropvar == NULL)
{
lpudp->lppropvar = CoTaskMemAlloc (sizeof(PROPVARIANT));
if (lpudp->lppropvar == NULL)
{
goto Exit;
}
}
// Put the property value into the PropVariant
PropVariantClear (lpudp->lppropvar);
if (!FPropVarLoad (lpudp->lppropvar, (VARTYPE)udtype, lpvValue))
{
goto Exit;
}
// Update the link name if this is a link, otherwise
// free any existing link name.
if (fLink)
{
if(!FUdpropSetString (lpudp, lpszLinkMonik, FALSE, FALSE))
goto Exit;
}
else
{
VUdpropFreeString (lpudp, FALSE);
lpData->dwcLinks--;
}
// ----
// Exit
// ----
fSuccess = TRUE;
Exit:
return(fSuccess);
} // FUdpropUpdate
////////////////////////////////////////////////////////////////////////////////
//
// FMakeTmpUDProps
//
// Purpose:
// Create a temporary copy of the User-Defined property data
//
////////////////////////////////////////////////////////////////////////////////
BOOL
FMakeTmpUDProps
(LPUDOBJ lpUDObj) // Pointer to object
{
// ------
// Locals
// ------
BOOL fSuccess = FALSE;
LPUDPROP lpudpCur;
LPUDPROP lpudpTmpCur;
DWORD dw;
LPVOID lpv;
// -----
// Begin
// -----
// Validate the inputs.
if ((lpUDObj == NULL) ||
(lpData == NULL))
{
goto Exit;
}
FDeleteTmpUDProps (lpUDObj);
// Move all the original list data to the tmp list
lpData->dwcTmpLinks = lpData->dwcLinks;
lpData->dwcTmpProps = lpData->dwcProps;
lpData->lpudpTmpHead = lpData->lpudpHead;
lpData->lpudpTmpCache = lpData->lpudpCache;
// Reinitialize the object data
lpData->dwcLinks = 0;
lpData->dwcProps = 0;
lpData->lpudpCache = NULL;
lpudpTmpCur = lpData->lpudpHead = NULL;
// Remember that we just put all the original data in the tmp ptrs.
lpudpCur = lpData->lpudpTmpHead;
// Loop through the old data and copy to the temp list
while (lpudpCur != NULL)
{
// Create a new UDPROP
lpudpTmpCur = LpudpropCreate();
if (lpudpTmpCur == NULL)
goto Exit;
// Set the name in the UDPROP
if (!FUdpropSetString (lpudpTmpCur, lpudpCur->lpstzName, FALSE, TRUE))
goto Exit;
// If we have a link-name, set it too in the UDPROP
if (lpudpCur->lpstzLink != NULL)
{
if (!FUdpropSetString (lpudpTmpCur, lpudpCur->lpstzLink, FALSE, FALSE))
goto Exit;
lpData->dwcLinks++;
}
// Allocate a PropVariant to hold the property value.
lpudpTmpCur->lppropvar = CoTaskMemAlloc (sizeof(PROPVARIANT));
if (lpudpTmpCur->lppropvar == NULL)
{
goto Exit;
}
// Copy the PropVariant into the temporary UDPROP.
PropVariantCopy (lpudpTmpCur->lppropvar, lpudpCur->lppropvar);
// Also show if this is an invalid link or not.
lpudpTmpCur->fLinkInvalid = lpudpCur->fLinkInvalid;
// Add this new temporary UDPROP to the linked-list.
AddNodeToList (lpUDObj, lpudpTmpCur);
lpData->dwcProps++;
// Move on to the next property.
lpudpCur = (LPUDPROP) lpudpCur->llist.lpllistNext;
} // while (lpudpCur != NULL)
// ----
// Exit
// ----
fSuccess = TRUE;
Exit:
// If there was an error, put everything back and deallocate anything we created
if (!fSuccess)
{
FSwapTmpUDProps (lpUDObj);
FDeleteTmpUDProps (lpUDObj);
}
return fSuccess;
} // FMakeTmpUDProps
////////////////////////////////////////////////////////////////////////////////
//
// FSwapTmpUDProps
//
// Purpose:
// Swap the "temp" copy with the real copy of User-Defined property data
//
////////////////////////////////////////////////////////////////////////////////
BOOL
FSwapTmpUDProps
(LPUDOBJ lpUDObj)
{
DWORD dwT;
LPUDPROP lpudpT;
if ((lpUDObj == NULL) ||
(lpData == NULL))
return FALSE;
dwT = lpData->dwcLinks;
lpData->dwcLinks = lpData->dwcTmpLinks;
lpData->dwcTmpLinks = dwT;
dwT = lpData->dwcProps;
lpData->dwcProps = lpData->dwcTmpProps;
lpData->dwcTmpProps = dwT;
lpudpT = lpData->lpudpHead;
lpData->lpudpHead = lpData->lpudpTmpHead;
lpData->lpudpTmpHead = lpudpT;
lpudpT = lpData->lpudpCache;
lpData->lpudpCache = lpData->lpudpTmpCache;
lpData->lpudpTmpCache = lpudpT;
return TRUE;
} // FSwapTmpUDProps
////////////////////////////////////////////////////////////////////////////////
//
// FDeleteTmpUDProps
//
// Purpose:
// Delete the "temp" copy of the data
//
////////////////////////////////////////////////////////////////////////////////
BOOL
FDeleteTmpUDProps
(LPUDOBJ lpUDObj)
{
if ((lpUDObj == NULL) ||
(lpData == NULL))
return FALSE;
FreeUDData (lpUDObj, TRUE);
return TRUE;
} // FDeleteTmpU
////////////////////////////////////////////////////////////////////////////////
//
// FUdpropMakeVisible
//
// Purpose:
// Make a property in a UDPROP visibile by removing the
// "_" that prepends the property name.
//
// Inputs:
// LPUDPROP - The UDPROP to convert.
//
// Output:
// TRUE if successful.
//
////////////////////////////////////////////////////////////////////////////////
static BOOL PASCAL
FUdpropMakeVisible (LPUDPROP lpudprop)
{
// ------
// Locals
// ------
BOOL fSuccess = FALSE;
ULONG cch;
// -----
// Begin
// -----
Assert (lpudprop != NULL);
// Is there anything to process?
if (lpudprop->lpstzName == NULL)
goto Exit;
// Simply move the string up one character, thus overlaying
// the prefix indicating a hidden property. If it's already
// a visible property we don't flag an error.
if (*lpudprop->lpstzName == HIDDENPREFIX)
{
cch = CchTszLen (lpudprop->lpstzName) + 1;
PbSzNCopy (lpudprop->lpstzName, &lpudprop->lpstzName[1], cch);
}
fSuccess = TRUE;
// ----
// Exit
// ----
Exit:
return (fSuccess);
} // FUdpropMakeVisible
////////////////////////////////////////////////////////////////////////////////
//
// FUdpropMakeHidden
//
// Purpose:
// Convert a property in a UDPROP so that it is a hidden
// property. Properties are considered hidden if the
// first character in their name is an "_".
//
// Inputs:
// LPUDPROP - The UDPROP to convert.
//
// Output:
// TRUE if successful.
//
////////////////////////////////////////////////////////////////////////////////
static BOOL PASCAL
FUdpropMakeHidden (LPUDPROP lpudprop)
{
// ------
// Locals
// ------
BOOL fSuccess = FALSE;
ULONG cch;
LPTSTR lpstzOld = NULL;
// -----
// Begin
// -----
// Intialize
Assert (lpudprop != NULL);
if (lpudprop->lpstzName == NULL)
goto Exit;
// Keep the old name.
lpstzOld = lpudprop->lpstzName;
// How many characters do we need in the new string?
cch = CchTszLen (lpstzOld) + 2; // Includes the NULL & prefix
// Allocate the memory.
lpudprop->lpstzName = CoTaskMemAlloc (cch * sizeof(TCHAR));
if (lpudprop->lpstzName == NULL)
goto Exit;
// Set the "_" prefix to indicate this is a hidden property.
lpudprop->lpstzName[0] = HIDDENPREFIX;
// Copy the original property name after the prefix in the UDPROP.
PbSzNCopy (&lpudprop->lpstzName[1],
lpstzOld,
cch - 1); // One chacter less than cch to accout for hidden prefix.
// Free the old buffer
CoTaskMemFree (lpstzOld);
// ----
// Exit
// ----
fSuccess = TRUE;
Exit:
// If there was an error, ensure that the UDPROP is left as
// we found it.
if (!fSuccess)
{
if (lpstzOld != NULL)
{
if (lpudprop->lpstzName != NULL)
{
CoTaskMemFree (lpudprop->lpstzName);
}
lpudprop->lpstzName = lpstzOld;
}
}
return (fSuccess);
} // FUdpropMakeHidden
////////////////////////////////////////////////////////////////////////////////
//
// FUdpropSetString
//
// Purpose:
// Set the name or link-name string in a UDPROP.
// If the UDPROP already contains the string, free
// it.
//
// Inputs:
// LPUDPROP - A UDPROP (a property in the linked-list)
// LPTSTR - The new name or link-name
// BOOL - True => limit the length of the string to BUFMAX characters
// (including the NULL terminator)
// BOOL - True => set the (property) name, False => set the link-name
//
////////////////////////////////////////////////////////////////////////////////
static BOOL PASCAL
FUdpropSetString
(LPUDPROP lpudp,
LPTSTR lptstr,
BOOL fLimitLength,
BOOL fName)
{
// ------
// Locals
// ------
BOOL fSuccess = FALSE; // Return value
LPTSTR lptstrNew = NULL; // Pointed to be the UDPROP.
ULONG cch, cb;
// ----------
// Initialize
// ----------
// Validate the inputs.
if (lpudp == NULL
||
lptstr == NULL)
{
goto Exit;
}
// ----------------
// Set the new name
// ----------------
// Calculate the sizes.
cch = CchTszLen(lptstr);
if (fLimitLength && cch >= BUFMAX)
{
cch = BUFMAX - 1;
}
cb = (cch + 1) * sizeof(TCHAR); // Leave room for the NULL.
// Allocate new memory.
lptstrNew = CoTaskMemAlloc (cb);
if (lptstrNew == NULL)
{
goto Exit;
}
// Copy the buffer (the buffer size is cch+1 including the NULL)
// Also, terminate the target string, since it may be a truncation
// of the source string.
PbSzNCopy (lptstrNew, lptstr, cch+1);
lptstrNew[cch] = TEXT('\0');
// Put this new buffer in the UDPROP.
if (fName)
lpudp->lpstzName = lptstrNew;
else
lpudp->lpstzLink = lptstrNew;
lptstrNew = NULL;
// ----
// Exit
// ----
fSuccess = TRUE;
Exit:
if (lptstrNew != NULL)
CoTaskMemFree (lptstrNew);
return (fSuccess);
} // FUdpropSetString
////////////////////////////////////////////////////////////////////////////////
//
// VUdpropFreeString
//
// Purpose:
// Free one of the two strings in a UDPROP - the
// name string or the link-name string. It is not
// considered an error if either the UDPROP or the
// string doesn't exist.
//
// Inputs:
// LPUDPROP - The UDPROP containing the strings.
// BOOL - TRUE indicates we should free the
// name, FALSE indicates we should free
// the link name.
//
// Output:
// None.
//
////////////////////////////////////////////////////////////////////////////////
static void PASCAL
VUdpropFreeString
(LPUDPROP lpudp,
BOOL fName)
{
// Is this really a UDPROP?
if (lpudp != NULL)
{
// Should we delete the name?
if (fName && lpudp->lpstzName)
{
CoTaskMemFree (lpudp->lpstzName);
lpudp->lpstzName = NULL;
}
// Should we delete the link name?
else if (!fName && lpudp->lpstzLink)
{
CoTaskMemFree (lpudp->lpstzLink);
lpudp->lpstzLink = NULL;
}
} // if (lpudp != NULL)
return;
} // VUdpropFreeString
/////////////////////////////////////////////////////////////////////////////////////
//
// LpudpropCreate
//
// Purpose:
// Create a new UDPROP structure (an element of a linked-
// list, and holds information about a single property).
//
// Inputs:
// None
//
// Output:
// A LPUDPROP if successful, NULL otherwise.
//
/////////////////////////////////////////////////////////////////////////////////////
LPUDPROP
LpudpropCreate ( void )
{
// Create a buffer for the UDPROP
LPUDPROP lpudp = CoTaskMemAlloc (sizeof(UDPROP));
// Zero the buffer.
if (lpudp != NULL)
{
FillBuf (lpudp, 0, sizeof(UDPROP));
}
return (lpudp);
} // LpudpropCreate
////////////////////////////////////////////////////////////////////////////////
//
// LppropvarUserDefGetPropVal
//
// Purpose:
// Return a PropVariant pointer for the requested
// property (requested by property name).
//
// Inputs:
// LPUDOBJ - All UD data (including properties)
// LPTSTR - The name of the desired property
// BOOL * - True if this is a link.
// BOOL * - True if this link is invalid.
//
// Output:
// An LPPROPVARINT, or NULL if there was an error.
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT LPPROPVARIANT
LppropvarUserDefGetPropVal
(LPUDOBJ lpUDObj, // Pointer to object
LPTSTR lpszProp, // Property string
BOOL *pfLink, // Indicates a link
BOOL *pfLinkInvalid) // Is the link invalid
{
// ------
// Locals
// ------
LPUDPROP lpudprop;
LPPROPVARIANT lppropvar;
// --------------
// Initialization
// --------------
if ((lpUDObj == NULL) ||
(lpData == NULL) ||
(lpszProp == NULL))
{
return NULL;
}
// ---------------------------------
// Find the node that has this name.
// ---------------------------------
lpudprop = LpudpropFindMatchingName (lpUDObj, lpszProp);
if (lpudprop == NULL)
return NULL;
// Is this a link?
if (pfLink != NULL)
{
*pfLink = (lpudprop->lpstzLink != NULL);
}
// Is this an invalid link? (In the Shell, all properties are
// invalid).
if (pfLinkInvalid != NULL)
{
#ifdef SHELL
*pfLinkInvalid = lpudprop->fLinkInvalid = TRUE;
#else
*pfLinkInvalid = lpudprop->fLinkInvalid;
#endif
}
// ----
// Exit
// ----
return (lpudprop->lppropvar);
} // LppropvarUserDefGetPropVal
////////////////////////////////////////////////////////////////////////////////
//
// LppropvarUserDefGetIteratorVal
//
// Purpose:
// Given an iterator value, get the property value.
//
// Inputs:
// LPUDITER - The Iterator value.
// BOOL * - Set to True if this value is a link.
// BOLL * - Set to True if this value is invalid link.
//
// Outputs:
// LPPROPVARIANT of the property value.
//
////////////////////////////////////////////////////////////////////////////////
DLLEXPORT LPPROPVARIANT
LppropvarUserDefGetIteratorVal
(LPUDITER lpUDIter,
BOOL *pfLink,
BOOL *pfLinkInvalid )
{
// Validate the inputs
if ((lpUDIter == NULL) ||
(lpUDIter->lpudp == NULL))
return NULL;
// Is this a Link?
if (pfLink != NULL)
{
*pfLink = (lpUDIter->lpudp->lpstzLink != NULL);
}
// Is this an invalid link?
if (pfLinkInvalid != NULL)
{
*pfLinkInvalid = lpUDIter->lpudp->fLinkInvalid;
}
// Return a pointer to the PropVariant
return (lpUDIter->lpudp->lppropvar);
} // LpvoidUserDefGetIteratorVal
Reference in a new issue Copy permalink