//--------------------------------------------
//set
//-------------------------------------------
public void set(int npc_id, Task_event evt,
int cvar1_index, int cvar1, VARTYPE cvar1_type,
int cvar2_index, int cvar2, VARTYPE cvar2_type,
int money, VARTYPE money_type,
int rcvar1_index, int rcvar1, VARRESULT rcvar1_type,
int rcvar2_index, int rcvar2, VARRESULT rcvar2_type,
int var1, int var2, int var3, int var4)
{
this.npc_id = npc_id;
this.evt += evt;
this.cvar1_index = cvar1_index;
this.cvar1 = cvar1;
this.cvar1_type = cvar1_type;
this.cvar2_index = cvar2_index;
this.cvar2 = cvar2;
this.cvar2_type = cvar2_type;
this.rcvar1_index = rcvar1_index;
this.rcvar1 = rcvar1;
this.rcvar1_type = rcvar1_type;
this.rcvar2_index = rcvar2_index;
this.rcvar2 = rcvar2;
this.rcvar2_type = rcvar2_type;
this.money = money;
this.money_type = money_type;
this.var1 = var1;
this.var2 = var2;
this.var3 = var3;
this.var4 = var4;
}
public void PROPVARIANTOtherPropsTest(VARTYPE vt, string prop)
{
object value;
Assert.That(() =>
{
if ((value = GetSampleData(vt)) == null)
{
return;
}
using (var pv = new PROPVARIANT(value, (VarEnum)vt))
{
var isa = value.GetType().IsArray;
Assert.That(pv.vt, Is.EqualTo(vt));
if (isa)
{
Assert.That(pv.Value, Is.EquivalentTo((IEnumerable)value));
}
else
{
Assert.That(pv.Value, Is.EqualTo(value));
}
var pi = pv.GetType().GetProperty(prop);
Assert.That(pi, Is.Not.Null);
if (isa)
{
Assert.That(pi.GetValue(pv), Is.EquivalentTo((IEnumerable)value));
}
else
{
Assert.That(pi.GetValue(pv), Is.EqualTo(value));
}
}
}, Throws.Nothing);
}
public void set(int npc_id, Task_event evt,
int cvar1_index, int cvar1, VARTYPE cvar1_type,
int rcvar1_index, int rcvar1, VARRESULT rcvar1_type
)
{
set(npc_id, evt,
cvar1_index, cvar1, cvar1_type,
rcvar1_index, rcvar1, rcvar1_type,
0, 0, 0, 0);
}
public void PROPVARIANTPropsTest(object value, VARTYPE vt, string prop)
{
using (var pv = new PROPVARIANT(value))
{
Assert.That(pv.vt, Is.EqualTo(vt));
Assert.That(pv.Value, Is.EqualTo(value));
var pi = pv.GetType().GetProperty(prop);
Assert.That(pi, Is.Not.Null);
Assert.That(pi.GetValue(pv), Is.EqualTo(value));
}
}
private static void PVRefTest <T>(T?nval, VARTYPE vt, string prop) where T : struct
{
var pi = typeof(PROPVARIANT).GetProperty(prop);
Assert.That(pi, Is.Not.Null);
using (var pv = new PROPVARIANT(null, (VarEnum)(VARTYPE.VT_BYREF | vt)))
{
Assert.That(pv.vt, Is.EqualTo(vt | VARTYPE.VT_BYREF));
Assert.That(pv.Value, Is.Null);
Assert.That(pi.GetValue(pv), Is.Null);
}
}
public static void Dispose(ref PROPVARIANT variant)
{
const VARTYPE flagMask = VARTYPE.VT_ARRAY | VARTYPE.VT_VECTOR | VARTYPE.VT_BYREF;
bool hasFlag = (variant.Type & flagMask) != (VARTYPE)0;
Action <PROPVARIANT> disposer;
if (disposers.TryGetValue(variant.Type, out disposer) ||
(hasFlag && disposers.TryGetValue(variant.Type & flagMask, out disposer)))
{
disposer.Invoke(variant);
}
variant = new PROPVARIANT();
}
public void set(int npc_id, Task_event evt,
int cvar1_index, int cvar1, VARTYPE cvar1_type,
int rcvar1_index, int rcvar1, VARRESULT rcvar1_type,
int var1, int var2, int var3, int var4)
{
set(npc_id, evt,
cvar1_index, cvar1, cvar1_type,
0, 0, VARTYPE.ANY,
0, VARTYPE.ANY,
rcvar1_index, rcvar1, rcvar1_type,
0, 0, VARRESULT.NOTHING,
var1, var2, var3, var4);
}
public static bool TryDecode <T>(ref PROPVARIANT variant, out T value)
{
const VARTYPE flagMask = VARTYPE.VT_ARRAY | VARTYPE.VT_VECTOR | VARTYPE.VT_BYREF;
bool hasFlag = (variant.Type & flagMask) != (VARTYPE)0;
Func <PROPVARIANT, object> decoder;
if (decoders.TryGetValue(variant.Type, out decoder) ||
(hasFlag && decoders.TryGetValue(variant.Type & flagMask, out decoder)))
{
value = (T)decoder.Invoke(variant);
return(true);
}
else
{
value = default(T);
return(false);
}
}
public void PROPVARIANTEnumPropsTest(object value, VARTYPE vt, string prop)
{
const int len = 5;
var arr = Array.CreateInstance(value.GetType(), len);
for (var i = 0; i < len; i++)
{
arr.SetValue(value, i);
}
using (var pv = new PROPVARIANT(arr))
{
Assert.That(pv.vt, Is.EqualTo(vt | VARTYPE.VT_VECTOR));
Assert.That(pv.Value, Is.EquivalentTo(arr));
var pi = pv.GetType().GetProperty(prop);
Assert.That(pi, Is.Not.Null);
Assert.That(pi.GetValue(pv), Is.EquivalentTo(arr));
}
}
/// <summary>Gets the .NET runtime type which corresponds to the <see cref="VARTYPE"/>.</summary>
/// <param name="vt">The <see cref="VARTYPE"/> enumeration value to evaluate.</param>
/// <returns>
/// <para>The corresponding .NET runtime type.</para>
/// <para>
/// If <paramref name="vt"/> specifies <see cref="VARTYPE.VT_VECTOR"/> or <see cref="VARTYPE.VT_ARRAY"/>, the return type is an
/// array of the element type.
/// </para>
/// <para>
/// If <paramref name="vt"/> specifies <see cref="VARTYPE.VT_BYREF"/> and the element type is a value type, the return type is a
/// pointer to the element type.
/// </para>
/// </returns>
public static Type GetCorrespondingType(this VARTYPE vt)
{
var elemVT = vt & ~(VARTYPE)0xF000;
var specVT = vt & (VARTYPE)0xF000;
var type = CorrespondingTypeAttribute.GetCorrespondingTypes(elemVT).FirstOrDefault();
if (type is null || elemVT == 0)
{
return(null);
}
// Change type if by reference
if (specVT.IsFlagSet(VARTYPE.VT_BYREF) && type.IsValueType)
{
type = type.MakePointerType();
}
// Change type if vector
if (specVT.IsFlagSet(VARTYPE.VT_VECTOR) || specVT.IsFlagSet(VARTYPE.VT_ARRAY))
{
type = type.MakeArrayType();
}
return(type);
}
private static object GetSampleData(VARTYPE vt)
{
switch (vt)
{
case VARTYPE.VT_ARRAY | VARTYPE.VT_VARIANT:
return(new object[] { 100, "100" });
case VARTYPE.VT_BLOB:
return(new BLOB {
cbSize = 200, pBlobData = Marshal.AllocCoTaskMem(200)
});
case VARTYPE.VT_CY:
case VARTYPE.VT_BYREF | VARTYPE.VT_CY:
case VARTYPE.VT_BYREF | VARTYPE.VT_DECIMAL:
return(12345.6789M);
case VARTYPE.VT_BYREF | VARTYPE.VT_VARIANT:
return(null);
case VARTYPE.VT_CF:
return(new CLIPDATA("MYCUSTOMFMT"));
case VARTYPE.VT_CLSID:
return(Guid.NewGuid());
case VARTYPE.VT_DATE:
case VARTYPE.VT_BYREF | VARTYPE.VT_DATE:
return(new DateTime(1999, 12, 31, 23, 59, 59));
case VARTYPE.VT_DISPATCH:
return(Activator.CreateInstance(Type.GetTypeFromProgID("Excel.Application")));
case VARTYPE.VT_ERROR:
case VARTYPE.VT_BYREF | VARTYPE.VT_ERROR:
return(new Win32Error(5));
case VARTYPE.VT_FILETIME:
return(new DateTime(1999, 12, 31, 23, 59, 59).ToFileTimeStruct());
case VARTYPE.VT_BSTR:
case VARTYPE.VT_BYREF | VARTYPE.VT_BSTR:
case VARTYPE.VT_LPSTR:
case VARTYPE.VT_LPWSTR:
return("string");
case VARTYPE.VT_STORAGE:
StgCreateStorageEx(Path.GetTempFileName(), STGM.STGM_DELETEONRELEASE | STGM.STGM_CREATE | STGM.STGM_DIRECT | STGM.STGM_READWRITE | STGM.STGM_SHARE_EXCLUSIVE, STGFMT.STGFMT_DOCFILE, 0, IntPtr.Zero, IntPtr.Zero, typeof(IStorage).GUID, out object iptr);
return((IStorage)iptr);
case VARTYPE.VT_STREAM:
SHCreateStreamOnFileEx(AdvApi32Tests.fn, STGM.STGM_READ | STGM.STGM_SHARE_EXCLUSIVE, 0, false, null, out IStream stm);
return(stm);
case VARTYPE.VT_UNKNOWN:
return(new IShellLinkW());
case VARTYPE.VT_VECTOR | VARTYPE.VT_BSTR:
case VARTYPE.VT_VECTOR | VARTYPE.VT_LPSTR:
case VARTYPE.VT_VECTOR | VARTYPE.VT_LPWSTR:
return(new[] { "A", "B", "C" });
case VARTYPE.VT_VECTOR | VARTYPE.VT_CF:
return(new[] { new CLIPDATA(), new CLIPDATA() });
case VARTYPE.VT_VECTOR | VARTYPE.VT_CLSID:
return(new[] { Guid.NewGuid(), Guid.NewGuid() });
case VARTYPE.VT_VECTOR | VARTYPE.VT_CY:
return(new[] { 12345.6789M, 98765.4321M });
case VARTYPE.VT_VECTOR | VARTYPE.VT_DATE:
return(new[] { new DateTime(1999, 12, 31, 23, 59, 59), new DateTime(2000, 1, 1, 0, 0, 1) });
case VARTYPE.VT_VECTOR | VARTYPE.VT_ERROR:
return(new[] { new Win32Error(1), new Win32Error(5) });
case VARTYPE.VT_VECTOR | VARTYPE.VT_FILETIME:
return(new[] { new DateTime(1999, 12, 31, 23, 59, 59).ToFileTimeStruct(), new DateTime(2000, 1, 1, 0, 0, 1).ToFileTimeStruct() });
case VARTYPE.VT_VECTOR | VARTYPE.VT_VARIANT:
return(new[] { new PROPVARIANT(100), new PROPVARIANT(200) });
case VARTYPE.VT_VERSIONED_STREAM:
return(null);
default:
return(null);
}
}
GetOleProperty(
Guid fmtid,
uint propId
)
{
CheckDisposed();
// fmtid is always either DocSum or Sum.
IPropertyStorage ps =
fmtid == FormatId.SummaryInformation ? _psSummInfo : _psDocSummInfo;
if (ps == null)
{
// This file doesn't even contain the property storage that this
// property belongs to, so it certainly doesn't contain the property.
return(null);
}
object obj = null;
PROPSPEC[] propSpecs = new PROPSPEC[1];
PROPVARIANT[] vals = new PROPVARIANT[1];
propSpecs[0].propType = (uint)PropSpecType.Id;
propSpecs[0].union.propId = propId;
VARTYPE vtExpected = GetVtFromPropId(fmtid, propId);
int hresult = ps.ReadMultiple(1, propSpecs, vals);
if (hresult == SafeNativeCompoundFileConstants.S_OK)
{
try
{
if (vals[0].vt != vtExpected)
{
throw new FileFormatException(
SR.Get(
SRID.WrongDocumentPropertyVariantType,
propId,
fmtid.ToString(),
vals[0].vt,
vtExpected
)
);
}
switch (vals[0].vt)
{
case VARTYPE.VT_LPSTR:
//
// We store string properties as CP_ACP or UTF-8.
// But no matter which format the string was encoded, we always use the UTF-8
// encoder/decoder to decode the byte array, because the UTF-8 code of an ASCII
// string is the same as the ASCII string.
//
IntPtr pszVal = vals[0].union.pszVal;
//
// Because both the ASCII string and UTF-8 encoded string (byte array) are
// stored in a memory block (pszVal) terminated by null, we can use
// Marshal.PtrToStringAnsi(pszVal) to convert the memory block pointed by
// pszVal to a string. Then from the string.Length, we can get the number of
// bytes in the memory block. Otherwise, we cannot easily tell how many bytes
// are stored in pszVal without an extra parameter.
//
string ansiString = Marshal.PtrToStringAnsi(pszVal);
int nLen = ansiString.Length;
byte[] byteArray = new byte[nLen];
Marshal.Copy(pszVal, byteArray, 0, nLen);
obj = UTF8Encoding.UTF8.GetString(byteArray);
break;
case VARTYPE.VT_FILETIME:
//
// DateTime doesn't have a conversion from FILETIME. It has a
// misleadingly named "FromFileTime" method that actually wants
// a long. So...
//
obj = new Nullable <DateTime>(DateTime.FromFileTime(vals[0].union.hVal));
break;
default:
throw new FileFormatException(
SR.Get(SRID.InvalidDocumentPropertyVariantType, vals[0].vt));
}
}
finally
{
#pragma warning suppress 6031 // suppressing a "by design" ignored return value
SafeNativeCompoundFileMethods.SafePropVariantClear(ref vals[0]);
}
}
else if (hresult == SafeNativeCompoundFileConstants.S_FALSE)
{
// Do nothing -- return the null object reference.
}
else
{
SecurityHelper.ThrowExceptionForHR(hresult);
}
return(obj);
}
/*public void GetCF()
* {
* foreach (var f in Directory.EnumerateFiles(TestCaseSources.TempDir, "*.*", SearchOption.AllDirectories))
* {
* try
* {
* SHGetPropertyStoreFromParsingName(f, null, GETPROPERTYSTOREFLAGS.GPS_READWRITE,
* Marshal.GenerateGuidForType(typeof(IPropertyStore)), out var ps);
* if (ps == null) continue;
* using (var pv = new PROPVARIANT())
* {
* ps.GetValue(PROPERTYKEY.System.Thumbnail, pv);
* if (pv.IsNullOrEmpty) continue;
* if (pv.vt == VARTYPE.VT_CF)
* TestContext.WriteLine(f);
* }
* ps = null;
* }
* catch
* {
* }
* }
* }*/
private static object GetSampleData(VARTYPE vt)
{
switch (vt)
{
case VARTYPE.VT_ARRAY | VARTYPE.VT_VARIANT:
return(new object[] { 100, "100" });
case VARTYPE.VT_ARRAY | VARTYPE.VT_I4:
var sa = SafeArrayCreateVector(VARTYPE.VT_I4, 0, 4U);
for (int i = 0; i < 4U; i++)
{
using var p = new PinnedObject(i);
SafeArrayPutElement(sa, i, p);
}
return(sa);
case VARTYPE.VT_BLOB:
return(new BLOB {
cbSize = 200, pBlobData = Marshal.AllocCoTaskMem(200)
});
case VARTYPE.VT_CY:
case VARTYPE.VT_BYREF | VARTYPE.VT_CY:
case VARTYPE.VT_BYREF | VARTYPE.VT_DECIMAL:
return(12345.6789M);
case VARTYPE.VT_BYREF | VARTYPE.VT_VARIANT:
return(null);
case VARTYPE.VT_CF:
return(new CLIPDATA("MYCUSTOMFMT"));
case VARTYPE.VT_CLSID:
return(Guid.NewGuid());
case VARTYPE.VT_DATE:
case VARTYPE.VT_BYREF | VARTYPE.VT_DATE:
return(new DateTime(1999, 12, 31, 23, 59, 59));
case VARTYPE.VT_DISPATCH:
return(Activator.CreateInstance(Type.GetTypeFromProgID("Excel.Application")));
case VARTYPE.VT_ERROR:
case VARTYPE.VT_BYREF | VARTYPE.VT_ERROR:
return(new Win32Error(5));
case VARTYPE.VT_FILETIME:
return(new DateTime(1999, 12, 31, 23, 59, 59).ToFileTimeStruct());
case VARTYPE.VT_BYREF | VARTYPE.VT_BSTR:
return(Marshal.StringToBSTR("string"));
case VARTYPE.VT_BSTR:
case VARTYPE.VT_LPSTR:
case VARTYPE.VT_LPWSTR:
return("string");
case VARTYPE.VT_STORAGE:
StgCreateStorageEx(Path.GetTempFileName(), STGM.STGM_DELETEONRELEASE | STGM.STGM_CREATE | STGM.STGM_DIRECT | STGM.STGM_READWRITE | STGM.STGM_SHARE_EXCLUSIVE, STGFMT.STGFMT_DOCFILE, 0, IntPtr.Zero, IntPtr.Zero, typeof(IStorage).GUID, out var iptr);
return((IStorage)iptr);
case VARTYPE.VT_STREAM:
SHCreateStreamOnFileEx(TestCaseSources.SmallFile, STGM.STGM_READ | STGM.STGM_SHARE_EXCLUSIVE, 0, false, null, out var stm);
return(stm);
case VARTYPE.VT_UNKNOWN:
return(Activator.CreateInstance(Type.GetTypeFromProgID("ADODB.Error")));
case VARTYPE.VT_VECTOR | VARTYPE.VT_BSTR:
case VARTYPE.VT_VECTOR | VARTYPE.VT_LPSTR:
case VARTYPE.VT_VECTOR | VARTYPE.VT_LPWSTR:
return(new[] { "A", "B", "C" });
case VARTYPE.VT_VECTOR | VARTYPE.VT_CF:
return(new[] { new CLIPDATA(), new CLIPDATA() });
case VARTYPE.VT_VECTOR | VARTYPE.VT_CLSID:
return(new[] { Guid.NewGuid(), Guid.NewGuid() });
case VARTYPE.VT_VECTOR | VARTYPE.VT_CY:
return(new[] { 12345.6789M, 98765.4321M });
case VARTYPE.VT_VECTOR | VARTYPE.VT_DATE:
return(new[] { new DateTime(1999, 12, 31, 23, 59, 59), new DateTime(2000, 1, 1, 0, 0, 1) });
case VARTYPE.VT_VECTOR | VARTYPE.VT_ERROR:
return(new[] { new Win32Error(1), new Win32Error(5) });
case VARTYPE.VT_VECTOR | VARTYPE.VT_FILETIME:
return(new[] { new DateTime(1999, 12, 31, 23, 59, 59).ToFileTimeStruct(), new DateTime(2000, 1, 1, 0, 0, 1).ToFileTimeStruct() });
case VARTYPE.VT_VECTOR | VARTYPE.VT_VARIANT:
return(new[] { new PROPVARIANT(100), new PROPVARIANT(200) });
case VARTYPE.VT_VERSIONED_STREAM:
return(null);
default:
return(null);
}
}
public static extern IntPtr SafeArrayCreateEx(VARTYPE vt, uint cDims, ref SAFEARRAYBOUND rgsabound, IntPtr pvExtra);
public static extern IntPtr SafeArrayCreateVector(VARTYPE vt, int lowerBound, uint cElems);
public static extern HRESULT PropVariantChangeType([Out] PROPVARIANT ppropvarDest, [In] PROPVARIANT propvarSrc, PROPVAR_CHANGE_FLAGS flags, VARTYPE vt);
public PROPVARIANT(string value)
{
vt = VARTYPE.VT_LPWSTR;
p = Marshal.StringToCoTaskMemUni(value);
}