public void StringPropWrongLengthFmtTest()
{
CheckDisposed();
// Set class first, or it will throw an exception.
int hvo = 1;
uint clid = SilDataAccess.MetaDataCache.GetClassId("PhEnvironment");
SilDataAccess.SetInt(hvo, (int)CmObjectFields.kflidCmObject_Class, (int)clid);
int tag = (int)SilDataAccess.MetaDataCache.GetFieldId("PhEnvironment", "StringRepresentation", false);
ITsPropsBldr propsBldr = TsPropsBldrClass.Create();
propsBldr.SetStrPropValue((int)FwTextPropType.ktptNamedStyle, "Verse");
ITsStrBldr strBldr = TsStrBldrClass.Create();
// Test StringFields (which are basically the same, except that the
// format of the parameters is different)
strBldr.Replace(0, 0, "Third", propsBldr.GetTextProps());
ITsString tsString = strBldr.GetString();
int cbFmt;
byte[] rgbFmt;
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative(1000, typeof(byte)))
{
cbFmt = tsString.SerializeFmtRgb(arrayPtr, 1000);
rgbFmt = (byte[])MarshalEx.NativeToArray(arrayPtr, cbFmt, typeof(byte));
}
VwCacheDa.CacheStringFields(hvo, tag, tsString.Text,
tsString.Length, rgbFmt, cbFmt - 1);
}
/// <summary>
/// Override to filter the specified properties.
/// </summary>
public override int get_VecItem(int hvo, int tag, int index)
{
ITestItem tester;
if (!m_filterFlids.TryGetValue(tag, out tester))
{
return(base.get_VecItem(hvo, tag, index));
}
int chvoReal = BaseSda.get_VecSize(hvo, tag);
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative(chvoReal, typeof(int)))
{
BaseSda.VecProp(hvo, tag, chvoReal, out chvoReal, arrayPtr);
int[] candidates = (int[])MarshalEx.NativeToArray(arrayPtr, chvoReal, typeof(int));
int iresult = 0;
for (int icandidate = 0; icandidate < candidates.Length; icandidate++)
{
if (tester.Test(candidates[icandidate], BaseSda, m_validHvos))
{
if (iresult == index)
{
return(candidates[icandidate]);
}
iresult++;
}
}
throw new IndexOutOfRangeException("filtered vector does not contain that many items (wanted " + index +
" but have only " + iresult + ")");
}
}
public void StringFields_Replace()
{
CheckDisposed();
ITsPropsBldr propsBldr = TsPropsBldrClass.Create();
propsBldr.SetStrPropValue((int)FwTextPropType.ktptNamedStyle, "Verse");
ITsStrBldr strBldr = TsStrBldrClass.Create();
// Test StringFields (which are basically the same, except that the
// format of the parameters is different)
strBldr.Replace(0, 0, "Third", propsBldr.GetTextProps());
ITsString tsString = strBldr.GetString();
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative(1000, typeof(byte)))
{
int cbFmt = tsString.SerializeFmtRgb(arrayPtr, 1000);
byte[] rgbFmt = (byte[])MarshalEx.NativeToArray(arrayPtr, cbFmt, typeof(byte));
m_IVwCacheDa.CacheStringFields(1118, 2228, tsString.Text,
tsString.Length, rgbFmt, cbFmt);
strBldr.Replace(0, 5, "Fourth", propsBldr.GetTextProps());
tsString = strBldr.GetString();
m_IVwCacheDa.CacheStringFields(1118, 2228, tsString.Text,
tsString.Length, rgbFmt, cbFmt);
ITsString tsStringNew = m_ISilDataAccess.get_StringProp(1118, 2228);
Assert.AreEqual(tsString.Text, tsStringNew.Text);
}
}
/// <summary>
/// Gets all subclasses of the given class,
/// including itself (which is always the first result in the list,
/// so it can easily be skipped if desired).
/// </summary>
/// <param name='clid'>Class indentifier to work with.</param>
/// <param name='countMaximumToReturn'>Count of the maximum number of subclass IDs to return (Size of the array.)
/// When set to zero, countAllSubclasses will contain the full count, so a second call can use the right sized array.</param>
/// <param name='countAllSubclasses'>Count of how many subclass IDs are the output array.</param>
/// <param name='subclasses'>Array of subclass IDs.</param>
/// <remarks>
/// The list is therefore a complete list of the classes which are valid to store in a property whose
/// signature is the class identified by 'clid'.
/// </remarks>
public void GetAllSubclasses(System.UInt32 clid,
int countMaximumToReturn, out int countAllSubclasses,
[MarshalAs(UnmanagedType.CustomMarshaler,
MarshalTypeRef = typeof(ArrayPtrMarshaler),
SizeParamIndex = 1)] ArrayPtr /*ULONG[]*/ subclasses)
{
countAllSubclasses = 0; // Start with 0 for output parameter.
// It's easier to just use the maximum than to fret about the right count.
int countAllClasses = m_metaClassRecords.Count;
uint[] uIds = new uint[countMaximumToReturn];
List <uint> allSubclassClids = new List <uint>(countMaximumToReturn);
allSubclassClids.Add(clid);
GetAllSubclassesForClid(clid, allSubclassClids);
int iSubclassClid = 0;
countAllSubclasses = allSubclassClids.Count;
while (iSubclassClid < countMaximumToReturn && iSubclassClid < countAllSubclasses)
{
uIds[iSubclassClid] = allSubclassClids[iSubclassClid];
++iSubclassClid;
}
MarshalEx.ArrayToNative(subclasses, countMaximumToReturn, uIds);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Used by constructor.
/// Sets the text property vars for this proxy, from the name, type, and ws
/// </summary>
/// ------------------------------------------------------------------------------------
private void SetTextProps()
{
if (m_Context == ContextValues.EndMarker || m_sStyleName == null || m_sStyleName == string.Empty)
{ // props are not relevant for end markers or markers with no style name
m_ttpRunProps = m_ws == 0 ? null : StyleUtils.CharStyleTextProps(null, m_ws);
m_rgbParaProps = null;
return;
}
Debug.Assert(m_StyleType == StyleType.kstCharacter || m_StyleType == StyleType.kstParagraph);
Debug.Assert(m_ws != 0);
// For char style, the run props contain writing system & char style name; for para
// style, they contain only the writing system.
m_ttpRunProps = StyleUtils.CharStyleTextProps(
(m_StyleType == StyleType.kstCharacter) ? m_sStyleName : null, m_ws);
// For char style, the paragraph props are empty; for para style, they contain the
// para style name.
if (m_StyleType == StyleType.kstParagraph)
{
ITsTextProps props = StyleUtils.ParaStyleTextProps(m_sStyleName);
using (ArrayPtr rgbFmtBufPtr = MarshalEx.ArrayToNative <byte>(kcbFmtBufMax))
{
int nBytes = props.SerializeRgb(rgbFmtBufPtr, kcbFmtBufMax);
m_rgbParaProps = MarshalEx.NativeToArray <byte>(rgbFmtBufPtr, nBytes);
}
}
else
{
m_rgbParaProps = null;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Get a value determining if the new writing systems should be created as a side-effect
/// of a paste operation.
/// </summary>
/// <param name="wsf">writing system factory containing the new writing systems</param>
/// <param name="destWs">The destination writing system (writing system used at the
/// selection).</param>
/// <returns>
/// an indication of how the paste should be handled.
/// </returns>
/// ------------------------------------------------------------------------------------
public override PasteStatus DeterminePasteWs(ILgWritingSystemFactory wsf, out int destWs)
{
// Determine writing system at selection (destination for paste).
destWs = 0;
if (CurrentSelection != null)
{
destWs = CurrentSelection.GetWritingSystem(SelectionHelper.SelLimitType.Anchor);
}
if (destWs <= 0)
{
destWs = Cache.DefaultAnalWs; // set to default analysis, if 0.
}
int cws = wsf.NumberOfWs;
using (ArrayPtr ptr = MarshalEx.ArrayToNative <int>(cws))
{
wsf.GetWritingSystems(ptr, cws);
int[] vws = MarshalEx.NativeToArray <int>(ptr, cws);
for (int iws = 0; iws < cws; iws++)
{
if (vws[iws] != 0 && wsf.get_EngineOrNull(vws[iws]) == null)
{
// found corrupt writing system--don't want to use any ws in this pasted string
return(PasteStatus.UseDestWs);
}
}
}
return(PasteStatus.PreserveWs);
}
/// <summary>
/// Override to filter the specified properties.
/// </summary>
public override int get_VecSize(int hvo, int tag)
{
ITestItem tester;
if (!m_filterFlids.TryGetValue(tag, out tester))
{
return(base.get_VecSize(hvo, tag));
}
int chvoReal = BaseSda.get_VecSize(hvo, tag);
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative(chvoReal, typeof(int)))
{
BaseSda.VecProp(hvo, tag, chvoReal, out chvoReal, arrayPtr);
int[] candidates = (int[])MarshalEx.NativeToArray(arrayPtr, chvoReal, typeof(int));
int iresult = 0;
for (int icandidate = 0; icandidate < candidates.Length; icandidate++)
{
if (tester.Test(candidates[icandidate], BaseSda, m_validHvos))
{
iresult++;
}
}
return(iresult);
}
}
/// <summary>
/// Override to filter the specified properties.
/// </summary>
public override void VecProp(int hvo, int tag, int chvoMax, out int chvo, ArrayPtr rghvo)
{
ITestItem tester;
if (!m_filterFlids.TryGetValue(tag, out tester))
{
base.VecProp(hvo, tag, chvoMax, out chvo, rghvo);
return;
}
int chvoReal = BaseSda.get_VecSize(hvo, tag);
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative(chvoReal, typeof(int)))
{
BaseSda.VecProp(hvo, tag, chvoReal, out chvoReal, arrayPtr);
int[] candidates = (int[])MarshalEx.NativeToArray(arrayPtr, chvoReal, typeof(int));
int[] results = new int[chvoMax];
int iresult = 0;
for (int icandidate = 0; icandidate < candidates.Length; icandidate++)
{
if (tester.Test(candidates[icandidate], BaseSda, m_validHvos))
{
results[iresult++] = candidates[icandidate];
}
}
chvo = iresult;
MarshalEx.ArrayToNative(rghvo, chvoMax, results);
}
}
/// <summary>Gets the direct subclasses of the given class (not including itself).</summary>
/// <param name='clid'>Class indentifier to work with.</param>
/// <param name='countMaximumToReturn'>Count of the maximum number of subclass IDs to return (Size of the array.)
/// When set to zero, countDirectSubclasses will contain the full count, so a second call can use the right sized array.</param>
/// <param name='countDirectSubclasses'>Count of how many subclass IDs are the output array.</param>
/// <param name='subclasses'>Array of subclass IDs.</param>
public void GetDirectSubclasses(int clid,
int countMaximumToReturn, out int countDirectSubclasses,
[MarshalAs(UnmanagedType.CustomMarshaler,
MarshalTypeRef = typeof(ArrayPtrMarshaler),
SizeParamIndex = 1)] ArrayPtr /*ULONG[]*/ subclasses)
{
countDirectSubclasses = 0; // Start with 0 for output parameter.
var ids = new int[countMaximumToReturn];
if (!m_metaClassRecords.ContainsKey(clid))
{
throw new ArgumentException("Class not found.");
}
var mcr = m_metaClassRecords[clid];
countDirectSubclasses = mcr.m_directSubclasses.Count;
if (countMaximumToReturn == 0)
{
return; // Client only wanted the count.
}
if (countMaximumToReturn < countDirectSubclasses)
{
throw new ArgumentException("Output array is too small.", "countMaximumToReturn");
}
var iSubclassClid = 0;
for (var i = 0; i < mcr.m_directSubclasses.Count; ++i)
{
ids[iSubclassClid++] = mcr.m_directSubclasses[i];
}
MarshalEx.ArrayToNative(subclasses, countMaximumToReturn, ids);
}
public void BinaryPropTest()
{
CheckDisposed();
// ScrImportSet::ImportSettings:Binary
// Set class first, or it will throw an exception.
int hvo = 1;
uint clidAnal = SilDataAccess.MetaDataCache.GetClassId("ScrImportSet");
SilDataAccess.SetInt(hvo, (int)CmObjectFields.kflidCmObject_Class, (int)clidAnal);
int tag = (int)SilDataAccess.MetaDataCache.GetFieldId("ScrImportSet", "ImportSettings", false);
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative(3, typeof(int)))
{
int chvo;
byte[] prgb = new byte[] { 3, 4, 5 };
SilDataAccess.SetBinary(hvo, tag, prgb, prgb.Length);
SilDataAccess.BinaryPropRgb(hvo, tag, arrayPtr, 3, out chvo);
byte[] prgbNew = (byte[])MarshalEx.NativeToArray(arrayPtr, chvo, typeof(byte));
Assert.AreEqual(prgb.Length, prgbNew.Length);
for (int i = 0; i < prgbNew.Length; i++)
{
Assert.AreEqual(prgb[i], prgbNew[i]);
}
}
}
public void BinaryProp()
{
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative <int>(10))
{
int chvo = 99;
m_ISilDataAccess.BinaryPropRgb(1112, 2221, ArrayPtr.Null, 0, out chvo);
Assert.AreEqual(0, chvo);
byte[] prgb = new byte[] { 3, 4, 5 };
m_IVwCacheDa.CacheBinaryProp(1112, 2221, prgb, prgb.Length);
m_ISilDataAccess.BinaryPropRgb(1112, 2221, arrayPtr, 10, out chvo);
byte[] prgbNew = MarshalEx.NativeToArray <byte>(arrayPtr, chvo);
Assert.AreEqual(prgb.Length, prgbNew.Length);
for (int i = 0; i < prgbNew.Length; i++)
{
Assert.AreEqual(prgb[i], prgbNew[i]);
}
byte[] prgb2 = new byte[] { 6, 7, 8, 9 };
m_IVwCacheDa.CacheBinaryProp(1112, 2221, prgb2, prgb2.Length);
m_ISilDataAccess.BinaryPropRgb(1112, 2221, arrayPtr, 10, out chvo);
prgbNew = MarshalEx.NativeToArray <byte>(arrayPtr, chvo);
Assert.AreEqual(prgb2.Length, prgbNew.Length);
for (int i = 0; i < prgbNew.Length; i++)
{
Assert.AreEqual(prgb2[i], prgbNew[i]);
}
}
}
public void GetFieldsBadTest()
{
using (var flids = MarshalEx.ArrayToNative <int>(500))
{
int countAllFlidsOut = 1;
m_metaDataCache.GetFields(49, true, (int)CellarPropertyTypeFilter.All, countAllFlidsOut, flids);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Retrieve properties for all data types and verify that we only get the expected
/// values, i.e. the expected data type that we put in the cache.
/// </summary>
/// <param name="hvo">HVO part of the key</param>
/// <param name="tag">tag part of the key</param>
/// <param name="expValues">Expected values</param>
/// ------------------------------------------------------------------------------------
private void VerifyCache(int hvo, int tag, object[] expValues)
{
int hvoVal = m_ISilDataAccess.get_ObjectProp(hvo, tag);
Assert.AreEqual(expValues[0], hvoVal);
int chvo = 99;
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative <int>(10))
{
m_ISilDataAccess.VecProp(hvo, tag, 10, out chvo, arrayPtr);
if (expValues[1] is int[])
{
Assert.AreEqual(((int[])expValues[1]).Length, chvo);
}
else
{
Assert.AreEqual(expValues[1], chvo);
}
m_ISilDataAccess.BinaryPropRgb(hvo, tag, arrayPtr, 10, out chvo);
if (expValues[2] is byte[])
{
Assert.AreEqual(((byte[])expValues[2]).Length, chvo);
}
else
{
Assert.AreEqual(expValues[2], chvo);
}
Guid guidNew = m_ISilDataAccess.get_GuidProp(hvo, tag);
Assert.AreEqual(expValues[3], guidNew);
long valLong = m_ISilDataAccess.get_Int64Prop(hvo, tag);
Assert.AreEqual(expValues[4], valLong);
// Int64 and TimeProp use the same cache
valLong = m_ISilDataAccess.get_TimeProp(hvo, tag);
Assert.AreEqual(expValues[4], valLong);
int valInt = m_ISilDataAccess.get_IntProp(hvo, tag);
Assert.AreEqual(expValues[5], valInt);
ITsString tsStringNew = m_ISilDataAccess.get_MultiStringAlt(hvo, tag, 12345);
Assert.AreEqual(expValues[6], tsStringNew.Text);
tsStringNew = m_ISilDataAccess.get_StringProp(hvo, tag);
Assert.AreEqual(expValues[7], tsStringNew.Text);
string strNew = m_ISilDataAccess.get_UnicodeProp(hvo, tag);
Assert.AreEqual(expValues[8], strNew);
object obj = m_ISilDataAccess.get_UnknownProp(hvo, tag);
Assert.AreEqual(expValues[9], obj);
CheckIsPropInCache(hvo, tag, expValues);
}
}
/// <summary>
/// Gets a list of the fields for the specified class.
/// Fields of superclasses are also returned, if the relevant flag is true.
/// </summary>
/// <param name='clid'>Class identification number.</param>
/// <param name='includeSuperclasses'>'True' to also get superclass fields.</param>
/// <param name='fieldTypes'>
/// Gets all fields whose types match the specified argument,
/// which should be a combination of the fcpt values defined in CmTypes.h, e.g.,
/// to get all owning properties pass kfcptOwningCollection | kfcptOwningAtom | kfcptOwningSequence.
/// </param>
/// <param name='countFlidMax'>
/// Size of the 'flids' array.
/// (Use 0 to get the size to use in a second call to actually get them.)</param>
/// <param name='flids'>Array of flids.</param>
/// <returns>
/// Count of flids that are returned,
/// or that could be returned, if 'countFlidMax' is 0.</returns>
/// <exception cref="ArgumentException">
/// Thrown if the output array is too small.
/// </exception>
public int GetFields(int clid, bool includeSuperclasses, int fieldTypes, int countFlidMax,
[MarshalAs(UnmanagedType.CustomMarshaler,
MarshalTypeRef = typeof(ArrayPtrMarshaler),
SizeParamIndex = 3)] ArrayPtr /*ULONG[]*/ flids)
{
var countFlids = 0;
var iflid = 0;
var currentClid = clid;
var ids = new int[countFlidMax];
// This loop executes once if fIncludeSuperclasses is false, otherwise over clid
// and all superclasses.
for (; ;)
{
var mcr = m_metaClassRecords[currentClid];
for (var i = 0; i < mcr.m_fields.Count; ++i)
{
var flid = mcr.m_fields[i];
var mfr = m_metaFieldRecords[flid];
if (fieldTypes != (int)CellarPropertyTypeFilter.All)
{
// Look up field type and see if it matches
var fcpt = 1 << (int)mfr.m_fieldType;
if ((fieldTypes & fcpt) == 0)
{
continue; // don't return this one
}
}
countFlids++;
if (countFlidMax <= 0)
{
continue;
}
if (countFlids > countFlidMax)
{
throw new ArgumentException("Output array is too small.", "countFlidMax");
}
ids[iflid++] = flid;
}
if (!includeSuperclasses)
{
break;
}
if (currentClid == 0) // just processed the base object
{
break;
}
currentClid = mcr.m_baseClsid;
}
if (iflid > 0)
{
MarshalEx.ArrayToNative(flids, countFlidMax, ids);
}
return(countFlids);
}
public void GetFieldIdsTest()
{
var flidSize = m_mdc.FieldCount;
int[] uIds;
var testFlidSize = flidSize - 1;
using (var flidsPtr = MarshalEx.ArrayToNative <int>(testFlidSize))
{
m_mdc.GetFieldIds(testFlidSize, flidsPtr);
uIds = MarshalEx.NativeToArray <int>(flidsPtr, testFlidSize);
Assert.AreEqual(testFlidSize, uIds.Length, "Wrong size of fields returned.");
foreach (var flid in uIds)
{
Assert.IsTrue(flid > 0, "Wrong flid value: " + flid);
}
}
testFlidSize = flidSize;
using (var flidsPtr = MarshalEx.ArrayToNative <int>(testFlidSize))
{
m_mdc.GetFieldIds(testFlidSize, flidsPtr);
uIds = MarshalEx.NativeToArray <int>(flidsPtr, testFlidSize);
var uIdsNonCOM = m_mdc.GetFieldIds();
Assert.AreEqual(uIds.Length, uIdsNonCOM.Length, "COM non-COM GetFieldIds different sizes.");
for (var i = 0; i < uIdsNonCOM.Length; ++i)
{
Assert.AreEqual(uIdsNonCOM[i], uIds[i], "");
}
Assert.AreEqual(testFlidSize, uIds.Length, "Wrong size of fields returned.");
foreach (var flid in uIds)
{
Assert.IsTrue(flid > 0, "Wrong flid value: " + flid);
}
}
testFlidSize = flidSize + 1;
using (var flidsPtr = MarshalEx.ArrayToNative <int>(testFlidSize))
{
m_mdc.GetFieldIds(testFlidSize, flidsPtr);
uIds = MarshalEx.NativeToArray <int>(flidsPtr, testFlidSize);
Assert.AreEqual(testFlidSize, uIds.Length, "Wrong size of fields returned.");
for (var iflid = 0; iflid < uIds.Length; ++iflid)
{
var flid = uIds[iflid];
if (iflid < uIds.Length - 1)
{
Assert.IsTrue(flid > 0, "Wrong flid value: " + flid);
}
else
{
Assert.AreEqual(0, flid, "Wrong value for flid beyond actual length.");
}
}
}
}
/// <summary>
/// Gets a list of the fields for the specified class.
/// Fields of superclasses are also returned, if the relevant flag is true.
/// </summary>
/// <param name='clid'>Class identification number.</param>
/// <param name='includeSuperclasses'>'True' to also get superclass fields.</param>
/// <param name='fieldTypes'>
/// Gets all fields whose types match the specified argument,
/// which should be a combination of the fcpt values defined in CmTypes.h, e.g.,
/// to get all owning properties pass kfcptOwningCollection | kfcptOwningAtom | kfcptOwningSequence.
/// </param>
/// <param name='countFlidMax'>
/// Size of the 'flids' array.
/// (Use 0 to get the size to use in a second call to actually get them.)</param>
/// <param name='flids'>Array of flids.</param>
/// <returns>
/// Count of flids that are returned,
/// or that could be returned, if 'countFlidMax' is 0.</returns>
/// <exception cref="ArgumentException">
/// Thrown if the output array is too small.
/// </exception>
public int GetFields(System.UInt32 clid, bool includeSuperclasses, int fieldTypes, int countFlidMax,
[MarshalAs(UnmanagedType.CustomMarshaler,
MarshalTypeRef = typeof(ArrayPtrMarshaler),
SizeParamIndex = 3)] ArrayPtr /*ULONG[]*/ flids)
{
int countFlids = 0;
int iflid = 0;
uint currentClid = clid;
uint[] uIds = new uint[countFlidMax];
// This loop executes once if fIncludeSuperclasses is false, otherwise over clid
// and all superclasses.
for (; ;)
{
MetaClassRec mcr = m_metaClassRecords[currentClid];
for (int i = 0; i < mcr.m_fields.Count; ++i)
{
uint flid = mcr.m_fields[i];
MetaFieldRec mfr = m_metaFieldRecords[flid];
if (fieldTypes != (int)CellarModuleDefns.kgrfcptAll)
{
// Look up field type and see if it matches
int flidType = mfr.m_fieldType;
int fcpt = 1 << flidType;
if ((fieldTypes & fcpt) == 0)
{
continue; // don't return this one
}
}
countFlids++;
if (countFlidMax > 0)
{
if (countFlids > countFlidMax)
{
throw new ArgumentException("Output array is too small.", "countFlidMax");
}
uIds[iflid++] = flid;
}
}
if (!includeSuperclasses)
{
break;
}
if (currentClid == 0) // just processed CmObject
{
break;
}
currentClid = mcr.m_baseClsid;
}
if (iflid > 0)
{
MarshalEx.ArrayToNative(flids, countFlidMax, uIds);
}
return(countFlids);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Setups the font features.
/// </summary>
/// ------------------------------------------------------------------------------------
private void SetupFontFeatures()
{
if (m_fontName == null || m_fontName == "")
{
Enabled = false;
return;
}
IRenderEngine renderer;
if (FontHasGraphiteTables(m_fontName, false, false))
{
renderer = FwGrEngineClass.Create();
}
else
{
renderer = UniscribeEngineClass.Create();
}
renderer.WritingSystemFactory = m_wsf;
HoldDummyGraphics hdg = new HoldDummyGraphics(m_fontName, false, false, CreateGraphics());
renderer.InitRenderer(hdg.m_vwGraphics, m_fontFeatures);
m_featureEngine = renderer as IRenderingFeatures;
if (m_featureEngine == null)
{
Enabled = false;
hdg.Close();
return;
}
int cfid;
m_featureEngine.GetFeatureIDs(0, null, out cfid);
if (cfid == 0)
{
Enabled = false;
hdg.Close();
return;
}
if (cfid == 1)
{
// What if it's the dummy built-in graphite feature that we ignore?
// Get the list of features (only 1).
using (ArrayPtr idsM = MarshalEx.ArrayToNative(cfid, typeof(int)))
{
m_featureEngine.GetFeatureIDs(cfid, idsM, out cfid);
int [] ids = (int[])MarshalEx.NativeToArray(idsM, cfid, typeof(int));
if (ids[0] == kGrLangFeature)
{
Enabled = false;
hdg.Close();
return;
}
}
}
Enabled = true;
hdg.Close();
}
public void GetAllSubclasses_ClassL_Limited()
{
using (var clids = MarshalEx.ArrayToNative <int>(2))
{
// Check ClassL (but get it and only 1 of its subclasses).
int countAllSubclasses;
m_metaDataCache.GetAllSubclasses(35, 2, out countAllSubclasses, clids);
Assert.AreEqual(2, countAllSubclasses, "Wrong number of subclasses returned.");
}
}
public void GetAllSubclasses_ClassL()
{
using (var clids = MarshalEx.ArrayToNative <int>(10))
{
// Check ClassL (all of its direct subclasses).
int countAllSubclasses;
m_metaDataCache.GetAllSubclasses(35, 10, out countAllSubclasses, clids);
Assert.AreEqual(3, countAllSubclasses, "Wrong number of subclasses returned.");
}
}
public void GetAllSubclasses_None()
{
using (var clids = MarshalEx.ArrayToNative <int>(10))
{
// Check ClassC.
int countAllSubclasses;
m_metaDataCache.GetAllSubclasses(26, 10, out countAllSubclasses, clids);
Assert.AreEqual(1, countAllSubclasses, "Wrong number of subclasses returned.");
}
}
internal static int ComVecPropFromManagedVecProp(int[] hvos, int hvo, int tag, ArrayPtr rghvo, int chvoMax)
{
if (hvos.Length > chvoMax)
{
throw new ArgumentException("The count is greater than the parameter 'chvo'.");
}
MarshalEx.ArrayToNative(rghvo, chvoMax, hvos);
return(hvos.Length);
}
public void BinaryProp_BufferToSmall()
{
byte[] prgb2 = new byte[] { 6, 7, 8, 9 };
m_IVwCacheDa.CacheBinaryProp(1112, 2221, prgb2, prgb2.Length);
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative <int>(10))
{
int chvo;
m_ISilDataAccess.BinaryPropRgb(1112, 2221, arrayPtr, 2, out chvo);
}
}
/// <summary>
/// Get the items from a vector property.
/// </summary>
private static int[] GetVector(ISilDataAccess sda, int hvo, int tag)
{
var chvo = sda.get_VecSize(hvo, tag);
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative <int>(chvo))
{
sda.VecProp(hvo, tag, chvo, out chvo, arrayPtr);
return(MarshalEx.NativeToArray <int>(arrayPtr, chvo));
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Setups the font features.
/// </summary>
/// ------------------------------------------------------------------------------------
public void SetupFontFeatures()
{
CheckDisposed();
if (string.IsNullOrEmpty(m_fontName))
{
Enabled = false;
m_isGraphiteFont = false;
return;
}
using (var hdg = new HoldDummyGraphics(m_fontName, false, false, this))
{
IRenderEngine renderer = GraphiteEngineClass.Create();
renderer.InitRenderer(hdg.m_vwGraphics, m_fontFeatures);
// check if the font is a valid Graphite font
if (!renderer.FontIsValid)
{
m_isGraphiteFont = false;
Enabled = false;
return;
}
renderer.WritingSystemFactory = m_wsf;
m_isGraphiteFont = true;
m_featureEngine = renderer as IRenderingFeatures;
if (m_featureEngine == null)
{
Enabled = false;
return;
}
int cfid;
m_featureEngine.GetFeatureIDs(0, null, out cfid);
if (cfid == 0)
{
Enabled = false;
return;
}
if (cfid == 1)
{
// What if it's the dummy built-in graphite feature that we ignore?
// Get the list of features (only 1).
using (ArrayPtr idsM = MarshalEx.ArrayToNative <int>(cfid))
{
m_featureEngine.GetFeatureIDs(cfid, idsM, out cfid);
int [] ids = MarshalEx.NativeToArray <int>(idsM, cfid);
if (ids[0] == kGrLangFeature)
{
Enabled = false;
return;
}
}
}
Enabled = true;
}
}
public void GetFieldsTest()
{
using (var flids = MarshalEx.ArrayToNative <int>(500))
{
var countAllFlidsOut = m_mdc.GetFields(0, true, (int)CellarPropertyTypeFilter.All, 0, flids);
countAllFlidsOut = m_mdc.GetFields(0, true, (int)CellarPropertyTypeFilter.All, countAllFlidsOut, flids);
MarshalEx.NativeToArray <int>(flids, countAllFlidsOut);
Assert.AreEqual(7, countAllFlidsOut, "Wrong number of fields returned for CmObject.");
}
}
public void GetDirectSubclasses_None()
{
int countDirectSubclasses;
using (var clids = MarshalEx.ArrayToNative <int>(10))
{
// Check ClassB.
m_metaDataCache.GetDirectSubclasses(45, 10, out countDirectSubclasses, clids);
Assert.AreEqual(0, countDirectSubclasses, "Wrong number of subclasses returned.");
}
}
public void GetFieldsDoesNotIncludeBaseFields()
{
using (var flids = MarshalEx.ArrayToNative <int>(500))
{
var countAllFlidsOut = m_mdc.GetFields(MoStemAllomorphTags.kClassId, false, (int)CellarPropertyTypeFilter.All, 0, flids);
countAllFlidsOut = m_mdc.GetFields(MoStemAllomorphTags.kClassId, false, (int)CellarPropertyTypeFilter.All, countAllFlidsOut, flids);
var fields = new List <int>(MarshalEx.NativeToArray <int>(flids, countAllFlidsOut));
Assert.That(fields, Has.Member(MoStemAllomorphTags.kflidPhoneEnv)); // not inherited
Assert.That(fields, Has.No.Member(MoFormTags.kflidForm)); // inherited
}
}
public void GetAllSubclasses_BaseClass()
{
var countAllClasses = m_metaDataCache.ClassCount;
using (var clids = MarshalEx.ArrayToNative <int>(countAllClasses))
{
// Check BaseClass.
int countAllSubclasses;
m_metaDataCache.GetAllSubclasses(0, countAllClasses, out countAllSubclasses, clids);
Assert.AreEqual(countAllClasses, countAllSubclasses, "Wrong number of subclasses returned.");
}
}
public override void Load(int hvo, int tag, int ws, IVwCacheDa cda)
{
ISilDataAccess sda = cda as ISilDataAccess;
int cobj = sda.get_VecSize(hvo, m_tagReal);
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative(cobj + 1, typeof(int))) // one longer to leave room for dummy
{
sda.VecProp(hvo, m_tagReal, cobj, out cobj, arrayPtr);
int [] rgHvo = (int[])MarshalEx.NativeToArray(arrayPtr, cobj, typeof(int));
rgHvo[cobj] = TypeAheadSupportVc.kBaseFakeObj;
cda.CacheVecProp(hvo, tag, rgHvo, cobj + 1);
}
}
/// <summary>
/// Make one that wraps the specified cache and passes items in the specified property of the specified root object.
/// </summary>
public FilterSdaDecorator(ISilDataAccess domainDataByFlid, int mainFlid, int hvoRoot)
: base(domainDataByFlid)
{
m_mainFlid = mainFlid;
m_hvoRoot = hvoRoot;
int chvoReal = BaseSda.get_VecSize(m_hvoRoot, m_mainFlid);
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative(chvoReal, typeof(int)))
{
BaseSda.VecProp(m_hvoRoot, m_mainFlid, chvoReal, out chvoReal, arrayPtr);
m_validHvos = new Set <int>((int[])MarshalEx.NativeToArray(arrayPtr, chvoReal, typeof(int)));
}
}