public void FindInDictionary(IOleDbEncap ode, IFwMetaDataCache mdc, IVwOleDbDa oleDbAccess, IVwSelection sel) { using (FdoCache cache = new FdoCache(ode, mdc, oleDbAccess)) { if (sel == null) { return; } IVwSelection sel2 = sel.EndPoint(false); if (sel2 == null) { return; } IVwSelection sel3 = sel2.GrowToWord(); if (sel3 == null) { return; } ITsString tss; int ichMin, ichLim, hvo, tag, ws; bool fAssocPrev; sel3.TextSelInfo(false, out tss, out ichMin, out fAssocPrev, out hvo, out tag, out ws); sel3.TextSelInfo(true, out tss, out ichLim, out fAssocPrev, out hvo, out tag, out ws); // TODO (TimS): need to supply help information (last 2 params) LexEntryUi.DisplayOrCreateEntry(cache, hvo, tag, ws, ichMin, ichLim, null, null, null, string.Empty); return; } }
/// <summary> /// Clean up any resources being used. /// </summary> protected override void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (IsDisposed) { return; } base.Dispose(disposing); if (disposing) { if (components != null) { components.Dispose(); } if (m_xmlVc != null) { m_xmlVc.Dispose(); } } m_xmlVc = null; m_layoutName = null; m_sXmlSpec = null; m_docSpec = null; m_xnSpec = null; m_mdc = null; m_stringTable = null; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="T:FwModelBrowser"/> class. /// </summary> /// ------------------------------------------------------------------------------------ public FwModelBrowser() { // // Required for Windows Form Designer support // InitializeComponent(); #if USINGCPP m_ode = OleDbEncapClass.Create(); m_ode.Init(SystemInformation.ComputerName + "\\SILFW", "TestLangProj", null, FwKernelLib.OdeLockTimeoutMode.koltReturnError, (int)FwKernelLib.OdeLockTimeoutValue.koltvFwDefault); m_mdc = FwMetaDataCacheClass.Create(); m_mdc.Init(m_ode); #else string modelDir = DirectoryFinder.FwSourceDirectory; modelDir = modelDir.Substring(0, modelDir.LastIndexOf('\\')); modelDir = Path.Combine(modelDir, @"Output\XMI"); m_mdc = MetaDataCache.CreateMetaDataCache(Path.Combine(modelDir, "xmi2cellar3.xml")); #endif uint clid = 0; string classname = m_mdc.GetClassName(clid); m_tvClasses.SuspendLayout(); AddNode(m_tvClasses.Nodes, classname, clid); m_tvClasses.Nodes[0].Expand(); m_tvClasses.ResumeLayout(false); }
/// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> protected virtual void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (m_isDisposed) { return; } if (disposing) { // Dispose managed resources here. if (m_map != null) { m_map.Clear(); } } // Dispose unmanaged resources here, whether disposing is true or false. m_mdc = null; m_layoutInventory = null; m_partInventory = null; m_map = null; m_isDisposed = true; }
public void Teardown() { if (m_wsf != null && Marshal.IsComObject(m_wsf)) { m_wsf.Shutdown(); Marshal.ReleaseComObject(m_wsf); } m_wsf = null; if (Marshal.IsComObject(m_cda)) { Marshal.ReleaseComObject(m_cda); } m_cda = null; if (Marshal.IsComObject(m_mdc)) { Marshal.ReleaseComObject(m_mdc); } m_mdc = null; if (Marshal.IsComObject(m_sda)) { Marshal.ReleaseComObject(m_sda); } m_sda = null; m_layoutInventory = null; m_columnList = null; m_layouts = null; m_partInventory = null; }
public virtual void FixtureSetup() { string bogusDataPathname = "Good.xml"; StreamWriter w = File.CreateText(bogusDataPathname); w.WriteLine("<?xml version='1.0' encoding='utf-8'?>"); w.WriteLine("<EntireModel>"); w.WriteLine("<CellarModule id='cellar' num='0'>"); w.WriteLine("<class num='1' id='MyClass' abstract='false' base='CmObject' >"); w.WriteLine("<props>"); // flid='1001' w.WriteLine("<basic num='1' id='myField' sig='int' userlabel='My Field' fieldhelp='Abandon hope' fieldxml='Some stuff' listroot='25' wsselector='10'/>"); // flid='1002' kcptNumeric = 3, Not used in official model w.WriteLine("<basic num='2' id='myField' sig='Numeric'/>"); // flid='1003' kcptFloat = 4, Not used in official model w.WriteLine("<basic num='3' id='myField' sig='Float'/>"); // flid='1004' kcptImage = 7, Not used in official model w.WriteLine("<basic num='4' id='myField' sig='Image'/>"); // flid='1005' kcptMultiBigUnicode = 20, Not used in official model w.WriteLine("<basic num='5' id='myField' sig='MultiUnicode' big='true'/>"); w.WriteLine("</props>"); w.WriteLine("</class>"); w.WriteLine("</CellarModule>"); w.WriteLine("</EntireModel>"); w.Flush(); w.Close(); try { m_mdc = MetaDataCache.CreateMetaDataCache(bogusDataPathname); } finally { File.Delete(bogusDataPathname); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="T:FwModelBrowser"/> class. /// </summary> /// ------------------------------------------------------------------------------------ public FwModelBrowser() { // // Required for Windows Form Designer support // InitializeComponent(); #if USINGCPP m_ode = OleDbEncapClass.Create(); m_ode.Init(SystemInformation.ComputerName + "\\SILFW", "TestLangProj", null, FwKernelLib.OdeLockTimeoutMode.koltReturnError, (int)FwKernelLib.OdeLockTimeoutValue.koltvFwDefault); m_mdc = FwMetaDataCacheClass.Create(); m_mdc.Init(m_ode); #else string modelDir = DirectoryFinder.FwSourceDirectory; modelDir = modelDir.Substring(0, modelDir.LastIndexOf('\\')); modelDir = Path.Combine(modelDir, @"Output\XMI"); m_mdc = MetaDataCache.CreateMetaDataCache(Path.Combine(modelDir, "xmi2cellar3.xml")); #endif uint clid = 0; string classname = m_mdc.GetClassName(clid); m_tvClasses.SuspendLayout(); AddNode(m_tvClasses.Nodes, classname, clid); m_tvClasses.Nodes[0].Expand(); m_tvClasses.ResumeLayout(false); }
public SimpleDataParser(IFwMetaDataCache mdc, IVwCacheDa cda) { m_mdc = mdc; m_cda = cda; m_sda = cda as ISilDataAccess; m_wsf = m_sda.WritingSystemFactory; }
public SimpleDataParser(IFwMetaDataCache mdc, IVwCacheDa cda) { m_mdc = mdc; m_cda = cda; m_sda = (ISilDataAccess)cda; m_wsf = m_sda.WritingSystemFactory; }
internal void DumpFieldInfo(IFwMetaDataCache mdc) { if (this.Depth == 0) { Debug.WriteLine(""); } for (int i = 0; i < this.Depth; ++i) { Debug.Write(" "); } if (Source != 0) { Debug.WriteLine("[" + this.Depth + "]info.Source = " + this.Source + " = " + GetFancyFieldName(this.Source, mdc)); } else { Debug.WriteLine("Root (target) class: " + mdc.GetClassName(m_targetClass)); } for (int i = 0; i < this.AtomicFields.Count; ++i) { for (int j = 0; j < this.Depth; ++j) { Debug.Write(" "); } Debug.WriteLine(" Atomic[" + i + "] flid = " + this.AtomicFields[i].flid + "(" + GetFancyFieldName(this.AtomicFields[i].flid, mdc) + "); ws = " + this.AtomicFields[i].ws); } for (int i = 0; i < this.SeqFields.Count; ++i) { this.SeqFields[i].DumpFieldInfo(mdc); } }
public XUpdater(FdoCache cache, string sFxtPath) { m_cache = cache; FxtDocument = new XmlDocument(); FxtDocument.Load(sFxtPath); m_mdc = m_cache.MetaDataCacheAccessor; }
private string GetFancyFieldName(int flid, IFwMetaDataCache mdc) { string f = mdc.GetFieldName(flid); string c = mdc.GetOwnClsName(flid); return(c + '_' + f); }
public void Teardown() { if (Marshal.IsComObject(m_cda)) { Marshal.ReleaseComObject(m_cda); } m_cda = null; if (Marshal.IsComObject(m_mdc)) { Marshal.ReleaseComObject(m_mdc); } m_mdc = null; if (Marshal.IsComObject(m_sda)) { Marshal.ReleaseComObject(m_sda); } m_sda = null; m_layoutInventory = null; m_columnList = null; m_layouts = null; m_partInventory = null; m_wsManager = null; }
/// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> protected virtual void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (m_isDisposed) { return; } if (disposing) { // Dispose managed resources here. // does not belong to us! // if (m_layouts != null) // m_layouts.Dispose(); } // Dispose unmanaged resources here, whether disposing is true or false. m_sda = null; m_layoutName = null; m_mdc = null; m_cache = null; m_layouts = null; m_colSpec = null; m_isDisposed = true; }
static internal int GetCustomFieldFlid(XmlNode caller, IFwMetaDataCache mdc, ICmObject obj) { string fieldName = XmlUtils.GetManditoryAttributeValue(caller, "param"); int flid = (int)mdc.GetFieldId2((uint)obj.ClassID, fieldName, true); return(flid); }
/// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> protected virtual void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (m_isDisposed) { return; } // m_sda COM object block removed due to crash in Finializer thread LT-6124 if (disposing) { if (m_sda != null) { m_sda.RemoveNotification(this); } if (m_cache.CreateModifyManager == this) { m_cache.CreateModifyManager = null; } } // Dispose unmanaged resources here, whether disposing is true or false. m_sda = null; m_cache = null; // ensures it can't be used again without crashing. m_mdc = null; m_recentMods = null; m_isDisposed = true; }
/// <summary> /// initialize fields based on input node. /// </summary> /// <param name="mdc"></param> /// <param name="input"></param> protected virtual void InitMemberVariablesFromInput(IFwMetaDataCache mdc, XmlNode input) { m_className = XmlUtils.GetManditoryAttributeValue(input, "class"); m_clsid = mdc.GetClassId(m_className); m_fieldType = XmlUtils.GetManditoryAttributeValue(input, "fieldType"); m_restrictions = XmlUtils.GetOptionalAttributeValue(input, "restrictions", "none"); m_source = XmlUtils.GetFirstNonCommentChild(input); }
/// <summary> /// Make a part generator for the specified "generate" element, interpreting names /// using the specified metadatacache, using vc and rootClassId for handling generate nodes /// that refer to layouts. /// </summary> /// <param name="mdc"></param> /// <param name="input"></param> /// <param name="vc">for parts/layouts</param> /// <param name="rootClassId">class of root object from which column layouts can be computed</param> public PartGenerator(IFwMetaDataCache mdc, XmlNode input, XmlVc vc, int rootClassId) { m_mdc = mdc; m_vc = vc; m_rootClassId = rootClassId; m_input = input; InitMemberVariablesFromInput(mdc, input); }
/// <summary> /// initialize fields based on input node. /// </summary> /// <param name="mdc"></param> /// <param name="input"></param> protected virtual void InitMemberVariablesFromInput(IFwMetaDataCache mdc, XmlNode input) { m_className = XmlUtils.GetManditoryAttributeValue(input, "class"); m_clsid = mdc.GetClassId(m_className); m_fieldType = XmlUtils.GetManditoryAttributeValue(input, "fieldType"); m_restrictions = XmlUtils.GetOptionalAttributeValue(input, "restrictions", "none"); m_source = XmlUtils.GetFirstNonCommentChild(input); }
/// <summary> /// Make a part generator for the specified "generate" element, interpreting names /// using the specified metadatacache, using vc and rootClassId for handling generate nodes /// that refer to layouts. /// </summary> /// <param name="mdc"></param> /// <param name="input"></param> /// <param name="vc">for parts/layouts</param> /// <param name="rootClassId">class of root object from which column layouts can be computed</param> public PartGenerator(IFwMetaDataCache mdc, XmlNode input, XmlVc vc, int rootClassId) { m_mdc = mdc; m_vc = vc; m_rootClassId = rootClassId; m_input = input; InitMemberVariablesFromInput(mdc, input); }
/// <summary> /// Make a part generator for the specified "generate" element, interpreting names /// using the specified metadatacache, using vc and rootClassId for handling generate nodes /// that refer to layouts. /// </summary> /// <param name="cache"></param> /// <param name="input"></param> /// <param name="vc">for parts/layouts</param> /// <param name="rootClassId">class of root object from which column layouts can be computed</param> public PartGenerator(FdoCache cache, XmlNode input, XmlVc vc, int rootClassId) { m_cache = cache; m_mdc = cache.MetaDataCacheAccessor; m_vc = vc; m_rootClassId = rootClassId; m_input = input; InitMemberVariablesFromInput(cache.MetaDataCacheAccessor, input); }
public virtual void FixtureSetup() { FileUtils.Manager.SetFileAdapter(new MockFileOS()); using (TextWriter fw = FileUtils.OpenFileForWrite("TestModel.xsd", Encoding.UTF8)) fw.Write(Properties.Resources.TestModel_xsd); using (TextWriter fw = FileUtils.OpenFileForWrite("TestModel.xml", Encoding.UTF8)) fw.Write(Properties.Resources.TestModel_xml); m_metaDataCache = MetaDataCache.CreateMetaDataCache("TestModel.xml"); }
/// <summary> /// Make a part generator for the specified "generate" element, interpreting names /// using the specified metadatacache, using vc and rootClassId for handling generate nodes /// that refer to layouts. /// </summary> /// <param name="cache"></param> /// <param name="input"></param> /// <param name="vc">for parts/layouts</param> /// <param name="rootClassId">class of root object from which column layouts can be computed</param> public PartGenerator(FdoCache cache, XmlNode input, XmlVc vc, int rootClassId) { m_cache = cache; m_mdc = cache.MetaDataCacheAccessor; m_vc = vc; m_rootClassId = rootClassId; m_input = input; InitMemberVariablesFromInput(cache.MetaDataCacheAccessor, input); }
static internal void EliminateExtraStyleAndWsInfo(IFwMetaDataCache mdc, FwPasteFixTssEventArgs e, int flid) { var type = (CellarPropertyType)mdc.GetFieldType(flid); if (type == CellarPropertyType.MultiUnicode || type == CellarPropertyType.Unicode) { e.TsString = e.TsString.ToWsOnlyString(); } }
/// <summary> /// /// </summary> /// <param name="mdc"></param> /// <param name="tbl"></param> /// <param name="clsId"></param> /// <param name="titleStr">*{dstClass}* if couldn't find result.</param> /// <returns>true if we found an alternate form. false if titleStr is null or in *{ClassName}* format.</returns> public static bool TryFindPluralFormFromClassId(IFwMetaDataCache mdc, StringTable tbl, int clsId, out string titleStr) { titleStr = null; if (clsId != 0) { string className = mdc.GetClassName(clsId); return TryFindString(tbl, "AlternativeTitles", String.Format("{0}-Plural", className), out titleStr); } return false; }
/// <summary> /// Create one and install it to work on a particular cache. /// </summary> /// <param name="cache"></param> public CreateModifyTimeManager(FdoCache cache) { m_cache = cache; Debug.Assert(cache.CreateModifyManager == null); cache.CreateModifyManager = this; m_sda = cache.MainCacheAccessor; m_sda.AddNotification(this); m_mdc = cache.MetaDataCacheAccessor; }
/// <summary> /// Create one and install it to work on a particular cache. /// </summary> /// <param name="cache"></param> public CreateModifyTimeManager(FdoCache cache) { m_cache = cache; Debug.Assert(cache.CreateModifyManager == null); cache.CreateModifyManager = this; m_sda = cache.MainCacheAccessor; m_sda.AddNotification(this); m_mdc = cache.MetaDataCacheAccessor; }
/// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> private void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (m_isDisposed) { return; } if (disposing) { if (m_wsCache != null) { m_wsCache.Clear(); } if (m_delayedAtomicReferences != null) { m_delayedAtomicReferences.Clear(); } if (m_delayedVecterReferences != null) { m_delayedVecterReferences.Clear(); } if (m_cachedFlids != null) { m_cachedFlids.Clear(); } if (m_tsf != null) { m_tsf.Dispose(); } } // Dispose unmanaged resources here, whether disposing is true or false. if (m_itsf != null) { if (Marshal.IsComObject(m_itsf)) { Marshal.ReleaseComObject(m_itsf); } m_itsf = null; } m_tsf = null; m_metaDataCache = null; m_realDataCache = null; m_wsCache = null; m_delayedAtomicReferences = null; m_delayedVecterReferences = null; m_cachedFlids = null; m_isDisposed = true; }
private void InitializeDynamically(IFwMetaDataCache mdc, bool fLoadFlexLayouts, string sDatabase) { m_mdc = mdc; m_layoutInventory = Inventory.GetInventory("layouts", sDatabase); m_partInventory = Inventory.GetInventory("parts", sDatabase); if (m_layoutInventory == null || m_partInventory == null) { InitializePartInventories(fLoadFlexLayouts, sDatabase); m_layoutInventory = Inventory.GetInventory("layouts", sDatabase); m_partInventory = Inventory.GetInventory("parts", sDatabase); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="LayoutCache"/> class. /// </summary> /// <param name="mdc">The MDC.</param> /// <param name="sDatabase">The database name.</param> /// <param name="app">The application.</param> /// <param name="projectPath">The project folder.</param> /// ------------------------------------------------------------------------------------ public LayoutCache(IFwMetaDataCache mdc, string sDatabase, IApp app, String projectPath) { m_mdc = mdc; m_layoutInventory = Inventory.GetInventory("layouts", sDatabase); m_partInventory = Inventory.GetInventory("parts", sDatabase); if (m_layoutInventory == null || m_partInventory == null) { InitializePartInventories(sDatabase, app, projectPath); m_layoutInventory = Inventory.GetInventory("layouts", sDatabase); m_partInventory = Inventory.GetInventory("parts", sDatabase); } }
private void InitializeDynamically(IFwMetaDataCache mdc, bool fLoadFlexLayouts, string sDatabase) { m_mdc = mdc; m_layoutInventory = Inventory.GetInventory("layouts", sDatabase); m_partInventory = Inventory.GetInventory("parts", sDatabase); if (m_layoutInventory == null || m_partInventory == null) { InitializePartInventories(fLoadFlexLayouts, sDatabase); m_layoutInventory = Inventory.GetInventory("layouts", sDatabase); m_partInventory = Inventory.GetInventory("parts", sDatabase); } }
bool m_fGotFocus = false; // True if we have focus. public TypeAheadSupportVc(int tag, LcmCache cache) { m_tag = tag; IFwMetaDataCache mdc = cache.DomainDataByFlid.MetaDataCache; m_clid = mdc.GetOwnClsId(m_tag); m_className = mdc.GetClassName(m_clid); m_fieldName = mdc.GetFieldName(m_tag); m_type = (CellarPropertyType)(mdc.GetFieldType(m_tag) & (int)CellarPropertyTypeFilter.VirtualMask); m_sda = cache.DomainDataByFlid; Cache = cache; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="LayoutCache"/> class. /// </summary> /// <param name="mdc">The MDC.</param> /// <param name="sDatabase">The database name.</param> /// <param name="app">The application.</param> /// <param name="projectPath">The project folder.</param> /// ------------------------------------------------------------------------------------ public LayoutCache(IFwMetaDataCache mdc, string sDatabase, IApp app, String projectPath) { m_mdc = mdc; m_layoutInventory = Inventory.GetInventory("layouts", sDatabase); m_partInventory = Inventory.GetInventory("parts", sDatabase); if (m_layoutInventory == null || m_partInventory == null) { InitializePartInventories(sDatabase, app, projectPath); m_layoutInventory = Inventory.GetInventory("layouts", sDatabase); m_partInventory = Inventory.GetInventory("parts", sDatabase); } }
/// <summary> /// looks up plural form alternative first for given flid, secondly for its destination class. /// </summary> /// <param name="mdc"></param> /// <param name="tbl"></param> /// <param name="owningFlid"></param> /// <param name="titleStr">*{dstClass}* if couldn't find result.</param> /// <returns>true if we found an alternate form. false if titleStr is null or in *{key}* format.</returns> public static bool TryFindPluralFormFromFlid(IFwMetaDataCache mdc, StringTable tbl, int owningFlid, out string titleStr) { // first see if we can find an expanded name for the name of a flid. string flidName = mdc.GetFieldName(owningFlid); if (!String.IsNullOrEmpty(flidName)) { if (TryFindString(tbl, "AlternativeTitles", flidName, out titleStr)) return true; } // secondly, see if we can find the plural form for the destination class. int dstClass = mdc.GetDstClsId(owningFlid); return TryFindPluralFormFromClassId(mdc, tbl, dstClass, out titleStr); }
public static LfMultiParagraph GetCustomStTextValuesAsLfMultiPara(IStText obj, int flid, IWritingSystemManager wsManager, IFwMetaDataCache metaDataCacheAccessor, int fallbackWs) { if (obj == null || obj.ParagraphsOS == null || obj.ParagraphsOS.Count == 0) return null; var result = new LfMultiParagraph(); result.Paragraphs = obj.ParagraphsOS.OfType<IStTxtPara>().Where(para => para.Contents != null).Select(para => FdoParaToLfPara(para, wsManager)).ToList(); // StText objects in FDO have a single primary writing system, unlike MultiString or MultiUnicode objects int fieldWs = metaDataCacheAccessor.GetFieldWs(flid); string wsStr = wsManager.GetStrFromWs(fieldWs); if (wsStr == null) wsStr = wsManager.GetStrFromWs(fallbackWs); result.InputSystem = wsStr; return result; }
public override void Init(FdoCache cache, Mediator mediator, XmlNode recordListNode) { CheckDisposed(); // <recordList class="WfiWordform" field="Occurrences"/> BaseInit(cache, mediator, recordListNode); IFwMetaDataCache mdc = VirtualListPublisher.MetaDataCache; m_flid = mdc.GetFieldId2(WfiWordformTags.kClassId, "Occurrences", false); Sorter = new OccurrenceSorter { Cache = cache, SpecialDataAccess = VirtualListPublisher }; }
bool m_fGotFocus = false; // True if we have focus. public TypeAheadSupportVc(int tag, FdoCache cache) { m_tag = tag; IFwMetaDataCache mdc = cache.MetaDataCacheAccessor; m_clid = mdc.GetOwnClsId((uint)m_tag); m_className = mdc.GetClassName(m_clid); m_fieldName = mdc.GetFieldName((uint)m_tag); m_type = mdc.GetFieldType((uint)m_tag); m_type = m_type & 0x1f; // strip off virtual bit. m_sda = cache.MainCacheAccessor; m_cache = cache; CreateVirtualProperties(); }
/// <summary> /// Set configuration displayProperty from cmObjectCustomFieldFlid set elements' OwningList DisplayOption. /// /// If cmObjectCustomFieldFlid refers to a set of elements (in cmObject), then examine the setting on the owning list of the /// elements to determine which property of each element to use when /// displaying each element in a slice, and record that information in configurationNode. This information is used /// in DetailControls.VectorReferenceVc.Display(). /// Addresses LT-15705. /// </summary> internal static void SetConfigurationDisplayPropertyIfNeeded(XmlNode configurationNode, ICmObject cmObject, int cmObjectCustomFieldFlid, ISilDataAccess mainCacheAccessor, ILcmServiceLocator fdoServiceLocator, IFwMetaDataCache metadataCache) { var fieldType = metadataCache.GetFieldType(cmObjectCustomFieldFlid); if (!(fieldType == (int)CellarPropertyType.ReferenceCollection || fieldType == (int)CellarPropertyType.OwningCollection || fieldType == (int)CellarPropertyType.ReferenceSequence || fieldType == (int)CellarPropertyType.OwningSequence)) { return; } var element = FetchFirstElementFromSet(cmObject, cmObjectCustomFieldFlid, mainCacheAccessor, fdoServiceLocator); if (element == null) { return; } var displayOption = element.OwningList.DisplayOption; string propertyNameToGetAndShow = null; switch ((PossNameType)displayOption) { case PossNameType.kpntName: propertyNameToGetAndShow = "ShortNameTSS"; break; case PossNameType.kpntNameAndAbbrev: propertyNameToGetAndShow = "AbbrAndNameTSS"; break; case PossNameType.kpntAbbreviation: propertyNameToGetAndShow = "AbbrevHierarchyString"; break; default: break; } if (propertyNameToGetAndShow == null) { return; } SetDisplayPropertyInXMLConfiguration(configurationNode, propertyNameToGetAndShow); }
/// <summary> /// /// </summary> /// <param name="root"></param> /// <param name="mdc"></param> /// <param name="keyAttrNames"></param> /// <param name="vc">for parts/layouts</param> /// <param name="rootClassId">class of the root object used to compute parts/layouts</param> /// <returns></returns> static private List <XmlNode> GetGeneratedChildren(XmlNode root, IFwMetaDataCache mdc, string[] keyAttrNames, XmlVc vc, int rootClassId) { List <XmlNode> result = new List <XmlNode>(); string generateModeForColumns = XmlUtils.GetOptionalAttributeValue(root, "generate"); bool m_fGenerateChildPartsForParentLayouts = (generateModeForColumns == "childPartsForParentLayouts"); // childPartsForParentLayouts foreach (XmlNode child in root.ChildNodes) { if (child is XmlComment) { continue; } if (m_fGenerateChildPartsForParentLayouts) { ChildPartGenerator cpg = new ChildPartGenerator(mdc, child, vc, rootClassId); cpg.GenerateChildPartsIfNeeded(); } if (child.Name != "generate") { result.Add(child); continue; } PartGenerator generator = new PartGenerator(mdc, child, vc, rootClassId); foreach (XmlNode genNode in generator.Generate()) { bool match = false; if (keyAttrNames != null) { foreach (XmlNode matchNode in root.ChildNodes) { if (MatchNodes(matchNode, genNode, keyAttrNames)) { match = true; break; } } } if (!match) // not already present, or not checking; add it. { result.Add(genNode); } } } return(result); }
static internal int GetCustomFieldFlid(XmlNode caller, IFwMetaDataCache mdc, ICmObject obj) { string fieldName = XmlUtils.GetManditoryAttributeValue(caller, "param"); // It would be nice to avoid all the possible throws for invalid fields, but hard // to achieve in a static method. try { int flid = mdc.GetFieldId2(obj.ClassID, fieldName, true); return(flid); } catch { return(0); } }
/// <summary> /// /// </summary> /// <param name="mdc"></param> /// <param name="input">the column node (not generate node)</param> protected override void InitMemberVariablesFromInput(IFwMetaDataCache mdc, XmlNode input) { if (input.Name == "generate") { // first column child is the node we want to try to generate. m_source = input.SelectSingleNode("./column"); return; } else if (input.Name != "column") { throw new ArgumentException("ChildPartGenerator expects input to be column node, not {0}", input.Name); } m_source = input; //m_clsid = m_rootClassId; //m_className = mdc.GetClassName(m_rootClassId); }
/// <summary> /// Get a list of flids for the given class, and type. /// </summary> /// <param name="mdc"></param> /// <param name="clsid"></param> /// <param name="flidType"></param> /// <returns></returns> static public uint[] GetFieldsInClassOfType(IFwMetaDataCache mdc, uint clsid, FieldType flidType) { uint[] retval = new uint[0]; int nflidType = (int)flidType; int flidCount = mdc.GetFields(clsid, true, nflidType, 0, ArrayPtr.Null); if (flidCount > 0) { using (ArrayPtr rgflid = new ArrayPtr(flidCount * Marshal.SizeOf(typeof(uint)))) { int flidCount2 = mdc.GetFields(clsid, true, nflidType, flidCount, rgflid); Debug.Assert(flidCount == flidCount2); retval = (uint[])MarshalEx.NativeToArray(rgflid, flidCount, typeof(uint)); } } return(retval); }
public void GenerateMlCustomString() { IFwMetaDataCache mdc = FwMetaDataCacheClass.Create(); string m_sTestPath = Path.Combine(DirectoryFinder.FwSourceDirectory, @"DbAccess\Test\SampleCm.xml"); mdc.InitXml(m_sTestPath, true); XmlDocument docSrc = new XmlDocument(); docSrc.LoadXml( "<generate class=\"LexEntry\" fieldType=\"mlstring\" restrictions=\"customOnly\"> " + "<column label=\"$label\"> " + "<seq field=\"Senses\" sep=\"$delimiter:commaSpace\"> " + "<string field=\"$fieldName\" ws=\"$ws:analysis\" class=\"LexEntry\"/> " + "</seq> " + "</column> " + "</generate>"); XmlNode source = TestXmlViewsUtils.GetRootNode(docSrc, "generate"); Assert.IsNotNull(source); PartGenerator generator = new PartGenerator(mdc, source); string[] fields = generator.FieldNames; Assert.AreEqual(1, fields.Length); Assert.IsTrue(StringArrayIncludes(fields, "custom")); XmlNode[] results = generator.Generate(); // SampleCm.xml has three ML attrs on LexEntry Assert.AreEqual(1, results.Length); XmlDocument docExpected3 = new XmlDocument(); docExpected3.LoadXml( "<column label=\"Restrictions\" originalLabel=\"Restrictions\" > " + "<seq field=\"Senses\" sep=\"$delimiter:commaSpace\"> " + "<string field=\"custom\" ws=\"$ws:analysis\" class=\"LexEntry\"/> " + "</seq> " + "</column>"); XmlNode expected3 = TestXmlViewsUtils.GetRootNode(docExpected3, "column"); Assert.IsTrue(SomeNodeMatches(results, expected3)); }
public void FindInDictionary(IOleDbEncap ode, IFwMetaDataCache mdc, IVwOleDbDa oleDbAccess, IVwSelection sel) { using (FdoCache cache = new FdoCache(ode, mdc, oleDbAccess)) { if (sel == null) return; IVwSelection sel2 = sel.EndPoint(false); if (sel2 == null) return; IVwSelection sel3 = sel2.GrowToWord(); if (sel3 == null) return; ITsString tss; int ichMin, ichLim, hvo, tag, ws; bool fAssocPrev; sel3.TextSelInfo(false, out tss, out ichMin, out fAssocPrev, out hvo, out tag, out ws); sel3.TextSelInfo(true, out tss, out ichLim, out fAssocPrev, out hvo, out tag, out ws); // TODO (TimS): need to supply help information (last 2 params) LexEntryUi.DisplayOrCreateEntry(cache, hvo, tag, ws, ichMin, ichLim, null, null, null, string.Empty); return; } }
/// <summary> /// Create a RealDataCache object, and laod it with metadata and real data. /// </summary> /// <param name="metadataPathname"></param> /// <param name="realDataPathname"></param> /// <param name="objects"></param> /// <returns></returns> public RealDataCache LoadCache(string metadataPathname, string realDataPathname, Dictionary<int, uint> objects) { CheckDisposed(); m_realDataCache = new RealDataCache(); m_realDataCache.CheckWithMDC = false; try { #if DEBUG //Process objectBrowser = Process.GetCurrentProcess(); //long memory = objectBrowser.PrivateMemorySize64; //Debug.WriteLine(String.Format("Memory used (start load): {0}.", memory.ToString())); DateTime start = DateTime.Now; #endif m_metaDataCache = new MetaDataCache(); m_metaDataCache.InitXml(metadataPathname, true); m_realDataCache.MetaDataCache = m_metaDataCache; #if DEBUG DateTime end = DateTime.Now; TimeSpan span = new TimeSpan(end.Ticks - start.Ticks); string totalTime = String.Format("Hours: {0}, Minutes: {1}, Seconds: {2}, Millseconds: {3}", span.Hours.ToString(), span.Minutes.ToString(), span.Seconds.ToString(), span.Milliseconds.ToString()); Debug.WriteLine("Time to load MDC: " + totalTime); start = end; //memory = objectBrowser.PrivateMemorySize64; //Debug.WriteLine(String.Format("Memory used (loaded MDC load): {0}.", memory.ToString())); #endif XmlDocument doc = new XmlDocument(); doc.Load(realDataPathname); #if DEBUG end = DateTime.Now; span = new TimeSpan(end.Ticks - start.Ticks); totalTime = String.Format("Hours: {0}, Minutes: {1}, Seconds: {2}, Millseconds: {3}", span.Hours.ToString(), span.Minutes.ToString(), span.Seconds.ToString(), span.Milliseconds.ToString()); Debug.WriteLine("Time to load XML: " + totalTime); start = end; //memory = objectBrowser.PrivateMemorySize64; //Debug.WriteLine(String.Format("Memory used (loaded data XML): {0}.", memory.ToString())); #endif // Load Writing Systems first. int ord = 0; int hvo; uint clid = 0; { XmlNodeList wsNodes = doc.DocumentElement.SelectNodes("LgWritingSystem"); uint flid = m_metaDataCache.GetFieldId("LgWritingSystem", "ICULocale", false); // We need a full list of ints and strings for Wses, // before we can load string data, // so cache the barebones first. foreach (XmlNode wsNode in wsNodes) { hvo = BootstrapWs(wsNode, flid, out clid, objects); } foreach (XmlNode wsNode in wsNodes) { string uid = wsNode.Attributes["id"].Value.Substring(1); hvo = m_realDataCache.get_ObjFromGuid(new Guid(uid)); LoadObject(wsNode, hvo, clid, objects); } } // Now load other ownerless objects, except LangProject and Wses. foreach (XmlNode otherOwnerlessNode in doc.DocumentElement.ChildNodes) { if (otherOwnerlessNode.Name != "LangProject" && otherOwnerlessNode.Name != "LgWritingSystem") { hvo = LoadCmObjectProperties(otherOwnerlessNode, 0, 0, ord, out clid, objects); LoadObject(otherOwnerlessNode, hvo, clid, objects); } } // Now load LangProject XmlNode langProjectNode = doc.DocumentElement.SelectSingleNode("LangProject"); hvo = LoadCmObjectProperties(langProjectNode, 0, 0, ord, out clid, objects); LoadObject(langProjectNode, hvo, clid, objects); // Set references // Set atomic references foreach (KeyValuePair<HvoFlidKey, XmlNode> kvp in m_delayedAtomicReferences) { string uid = kvp.Value.Attributes["target"].Value.Substring(1); try { int hvoTarget = m_realDataCache.get_ObjFromGuid(new Guid(uid)); m_realDataCache.CacheObjProp(kvp.Key.Hvo, (int)kvp.Key.Flid, hvoTarget); } catch { // Invalid reference. Just clear the cache in case there is a save. m_realDataCache.SetObjProp(kvp.Key.Hvo, (int)kvp.Key.Flid, 0); } } //// Remove all items from m_delayedAtomicReferences that are in handledRefs. //// Theory has it that m_delayedAtomicReferences should then be empty. m_delayedAtomicReferences.Clear(); // Set vector (col or seq) references. foreach (KeyValuePair<HvoFlidKey, List<XmlNode>> kvp in m_delayedVecterReferences) { List<int> hvos = new List<int>(); foreach (XmlNode obj in kvp.Value) { string uid = obj.Attributes["target"].Value.Substring(1); try { int ownedHvo = m_realDataCache.get_ObjFromGuid(new Guid(uid)); hvos.Add(ownedHvo); } catch { // Invalid reference. Just remove the bogus hvo. // Since the id is added after the exception, it is effectively 'removed'. Debug.WriteLine("Bogus Id found."); } } m_realDataCache.CacheVecProp(kvp.Key.Hvo, (int)kvp.Key.Flid, hvos.ToArray(), hvos.Count); } m_delayedVecterReferences.Clear(); #if DEBUG end = DateTime.Now; span = new TimeSpan(end.Ticks - start.Ticks); totalTime = String.Format("Hours: {0}, Minutes: {1}, Seconds: {2}, Millseconds: {3}", span.Hours.ToString(), span.Minutes.ToString(), span.Seconds.ToString(), span.Milliseconds.ToString()); Debug.WriteLine("Time to load main Cache: " + totalTime); start = end; Debug.WriteLine(String.Format("Number of objects cached: {0}", (m_realDataCache.NextHvo - 1).ToString())); //memory = objectBrowser..PrivateMemorySize64; //Debug.WriteLine(String.Format("Memory used (cache loaded): {0}.", memory.ToString())); #endif } finally { m_realDataCache.CheckWithMDC = true; } return m_realDataCache; }
/// <summary> /// Initialize the dialog after creating it. /// </summary> /// <param name="configurationParameters"></param> /// <param name="cache"></param> /// <param name="styleSheet"></param> /// <param name="mainWindowDelegateCallbacks"></param> /// <param name="mediator"></param> public void SetConfigDlgInfo(XmlNode configurationParameters, FdoCache cache, FwStyleSheet styleSheet, IMainWindowDelegateCallbacks mainWindowDelegateCallbacks, Mediator mediator, string sLayoutPropertyName) { CheckDisposed(); m_configurationParameters = configurationParameters; string labelKey = XmlUtils.GetAttributeValue(configurationParameters, "viewTypeLabelKey"); if (!String.IsNullOrEmpty(labelKey)) { string sLabel = xWorksStrings.ResourceManager.GetString(labelKey); if (!String.IsNullOrEmpty(sLabel)) m_lblViewType.Text = sLabel; } m_cache = cache; m_mdc = m_cache.MetaDataCacheAccessor; m_styleSheet = styleSheet; m_callbacks = mainWindowDelegateCallbacks; m_mediator = mediator; m_sLayoutPropertyName = sLayoutPropertyName; if (m_mediator != null && m_mediator.HasStringTable) m_stringTbl = m_mediator.StringTbl; m_layouts = Inventory.GetInventory("layouts", cache.DatabaseName); m_parts = Inventory.GetInventory("parts", cache.DatabaseName); string configObjectName = XmlUtils.GetLocalizedAttributeValue(m_mediator.StringTbl, configurationParameters, "configureObjectName", ""); this.Text = String.Format(this.Text, configObjectName); m_defaultRootLayoutName = XmlUtils.GetAttributeValue(configurationParameters, "layout"); string sLayoutType = null; if (m_mediator != null && m_mediator.PropertyTable != null) { object objType = m_mediator.PropertyTable.GetValue(m_sLayoutPropertyName); if (objType != null) sLayoutType = (string)objType; } if (String.IsNullOrEmpty(sLayoutType)) sLayoutType = m_defaultRootLayoutName; CreateComboAndTreeItems(sLayoutType); // Restore the location and size from last time we called this dialog. if (m_mediator != null && m_mediator.PropertyTable != null) { object locWnd = m_mediator.PropertyTable.GetValue("XmlDocConfigureDlg_Location"); object szWnd = m_mediator.PropertyTable.GetValue("XmlDocConfigureDlg_Size"); if (locWnd != null && szWnd != null) { Rectangle rect = new Rectangle((Point)locWnd, (Size)szWnd); ScreenUtils.EnsureVisibleRect(ref rect); DesktopBounds = rect; StartPosition = FormStartPosition.Manual; } } // Make a help topic ID m_helpTopicID = generateChooserHelpTopicID(configObjectName); // Load the list for the styles combo box. SetStylesList(); }
/// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> private void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (m_isDisposed) return; if (disposing) { if (m_wsCache != null) m_wsCache.Clear(); if (m_delayedAtomicReferences != null) m_delayedAtomicReferences.Clear(); if (m_delayedVecterReferences != null) m_delayedVecterReferences.Clear(); if (m_cachedFlids != null) m_cachedFlids.Clear(); if (m_tsf != null) m_tsf.Dispose(); } // Dispose unmanaged resources here, whether disposing is true or false. if (m_itsf != null) { if (Marshal.IsComObject(m_itsf)) Marshal.ReleaseComObject(m_itsf); m_itsf = null; } m_tsf = null; m_metaDataCache = null; m_realDataCache = null; m_wsCache = null; m_delayedAtomicReferences = null; m_delayedVecterReferences = null; m_cachedFlids = null; m_isDisposed = true; }
/// <summary> /// Get a list of flids for the given class, and type. /// </summary> /// <param name="mdc"></param> /// <param name="clsid"></param> /// <param name="flidType"></param> /// <returns></returns> static public uint[] GetFieldsInClassOfType(IFwMetaDataCache mdc, uint clsid, FieldType flidType) { uint[] retval = new uint[0]; int nflidType = (int)flidType; int flidCount = mdc.GetFields(clsid, true, nflidType, 0, ArrayPtr.Null); if(flidCount > 0) { using (ArrayPtr rgflid = new ArrayPtr(flidCount * Marshal.SizeOf(typeof(uint)))) { int flidCount2 = mdc.GetFields(clsid, true, nflidType, flidCount, rgflid); Debug.Assert(flidCount == flidCount2); retval = (uint[])MarshalEx.NativeToArray(rgflid, flidCount, typeof(uint)); } } return retval; }
public virtual void FixtureSetup() { FileUtils.Manager.SetFileAdapter(new MockFileOS()); using (TextWriter fw = FileUtils.OpenFileForWrite("TestModel.xsd", Encoding.UTF8)) fw.Write(Properties.Resources.TestModel_xsd); using (TextWriter fw = FileUtils.OpenFileForWrite("TestModel.xml", Encoding.UTF8)) fw.Write(Properties.Resources.TestModel_xml); m_metaDataCache = MetaDataCache.CreateMetaDataCache("TestModel.xml"); }
/// <summary> /// Load the list (given by owner and sFieldName) from the given TextReader. /// </summary> public void ImportList(ICmObject owner, string sFieldName, TextReader reader, IProgress progress) { m_cache = owner.Cache; m_mdc = m_cache.MetaDataCache; m_wsf = m_cache.WritingSystemFactory; m_progress = progress; NonUndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(m_cache.ActionHandlerAccessor, () => { int flidList = m_mdc.GetFieldId(owner.ClassName, sFieldName, true); if (flidList == 0) throw new Exception(String.Format("Invalid list fieldname (programming error): {0}", sFieldName)); using (var xrdr = XmlReader.Create(reader)) { xrdr.MoveToContent(); if (xrdr.Name != owner.ClassName) throw new Exception(String.Format("Unexpected outer element: {0}", xrdr.Name)); if (!xrdr.ReadToDescendant(sFieldName)) throw new Exception(String.Format("Unexpected second element: {0}", xrdr.Name)); if (!xrdr.ReadToDescendant("CmPossibilityList")) throw new Exception(String.Format("Unexpected third element: {0}", xrdr.Name)); ICmPossibilityList list; int hvo = m_cache.MainCacheAccessor.get_ObjectProp(owner.Hvo, flidList); if (hvo == 0) hvo = m_cache.MainCacheAccessor.MakeNewObject(CmPossibilityListTags.kClassId, owner.Hvo, flidList, -2); ICmPossibilityListRepository repo = m_cache.ServiceLocator.GetInstance<ICmPossibilityListRepository>(); list = repo.GetObject(hvo); string sItemClassName = "CmPossibility"; xrdr.Read(); while (xrdr.Depth == 3) { xrdr.MoveToContent(); if (xrdr.Depth < 3) break; switch (xrdr.Name) { case "Description": SetMultiStringFromXml(xrdr, list.Description); break; case "Name": SetMultiUnicodeFromXml(xrdr, list.Name); break; case "Abbreviation": SetMultiUnicodeFromXml(xrdr, list.Abbreviation); break; case "Depth": list.Depth = ReadIntFromXml(xrdr); break; case "DisplayOption": list.DisplayOption = ReadIntFromXml(xrdr); break; case "HelpFile": list.HelpFile = ReadUnicodeFromXml(xrdr); break; case "IsClosed": list.IsClosed = ReadBoolFromXml(xrdr); break; case "IsSorted": list.IsSorted = ReadBoolFromXml(xrdr); break; case "IsVernacular": list.IsVernacular = ReadBoolFromXml(xrdr); break; case "ItemClsid": list.ItemClsid = ReadIntFromXml(xrdr); sItemClassName = m_mdc.GetClassName(list.ItemClsid); break; case "ListVersion": list.ListVersion = ReadGuidFromXml(xrdr); break; case "PreventChoiceAboveLevel": list.PreventChoiceAboveLevel = ReadIntFromXml(xrdr); break; case "PreventDuplicates": list.PreventDuplicates = ReadBoolFromXml(xrdr); break; case "PreventNodeChoices": list.PreventNodeChoices = ReadBoolFromXml(xrdr); break; case "UseExtendedFields": list.UseExtendedFields = ReadBoolFromXml(xrdr); break; case "WsSelector": list.WsSelector = ReadIntFromXml(xrdr); break; case "Possibilities": LoadPossibilitiesFromXml(xrdr, list, sItemClassName); break; case "HeaderFooterSets": throw new Exception("We don't (yet?) handle HeaderFooterSets for CmPossibilityList (programming issue)"); case "Publications": throw new Exception("We don't (yet?) handle Publications for CmPossibilityList (programming issue)"); default: throw new Exception(String.Format("Unknown field element in CmPossibilityList: {0}", xrdr.Name)); } } xrdr.Close(); if (m_mapRelatedDomains.Count > 0) SetRelatedDomainsLinks(); } }); }
/// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> private void Dispose(bool disposing) { System.Diagnostics.Debug.WriteLineIf(!disposing, "****** Missing Dispose() call for " + GetType().Name + ". ****** "); // Must not be run more than once. if (m_isDisposed) return; if (disposing) { // Dispose managed resources here. ClearAllData(); } // Dispose unmanaged resources here, whether disposing is true or false. m_metaDataCache = null; m_actionhandler = null; m_lgWritingSystemFactory = null; m_basicObjectCache = null; m_extendedKeyCache = null; m_basicITsStringCache = null; m_basicByteArrayCache = null; m_guidCache = null; m_guidToHvo = null; m_intCache = null; m_longCache = null; m_boolCache = null; m_vectorCache = null; m_timeStampCache = null; m_isDisposed = true; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> /// ------------------------------------------------------------------------------------ protected virtual void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (m_isDisposed) return; if (disposing) { // Dispose managed resources here. } // Dispose unmanaged resources here, whether disposing is true or false. m_metaDataCache = null; m_isDisposed = true; }
public virtual void FixtureSetup() { string modelDir = DirectoryFinder.FwSourceDirectory; modelDir = modelDir.Substring(0, modelDir.LastIndexOf('\\')); modelDir = Path.Combine(modelDir, @"Output\XMI"); m_metaDataCache = MetaDataCache.CreateMetaDataCache(Path.Combine(modelDir, "xmi2cellar3.xml")); }
internal void DumpFieldInfo(IFwMetaDataCache mdc) { if (this.Depth == 0) Debug.WriteLine(""); for (int i = 0; i < this.Depth; ++i) Debug.Write(" "); if (Source != 0) { Debug.WriteLine("[" + this.Depth + "]info.Source = " + this.Source + " = " + GetFancyFieldName(this.Source, mdc)); } else { Debug.WriteLine("Root (target) class: " + mdc.GetClassName(m_targetClass)); } for (int i = 0; i < this.AtomicFields.Count; ++i) { for (int j = 0; j < this.Depth; ++j) Debug.Write(" "); Debug.WriteLine(" Atomic[" + i + "] flid = " + this.AtomicFields[i].flid + "(" + GetFancyFieldName(this.AtomicFields[i].flid, mdc) + "); ws = " + this.AtomicFields[i].ws); } for (int i = 0; i < this.SeqFields.Count; ++i) this.SeqFields[i].DumpFieldInfo(mdc); }
static internal bool IsMultilingual(int flid, IFwMetaDataCache mdc) { switch ((CellarPropertyType)(mdc.GetFieldType(flid) & (int)CellarPropertyTypeFilter.VirtualMask)) { case CellarPropertyType.MultiString: case CellarPropertyType.MultiUnicode: return true; default: return false; } }
/// <summary> /// Clean up any resources being used. /// </summary> protected override void Dispose( bool disposing ) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (IsDisposed) return; base.Dispose(disposing); if( disposing ) { if(components != null) { components.Dispose(); } if (m_xmlVc != null) m_xmlVc.Dispose(); } m_xmlVc = null; m_stringTable = null; m_mdc = null; m_sXmlSpec = null; m_docSpec = null; m_xnSpec = null; }
private string GetFancyFieldName(int flid, IFwMetaDataCache mdc) { string f = mdc.GetFieldName(flid); string c = mdc.GetOwnClsName(flid); return c + '_' + f; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Return true if this is a property the mdc can't tell us about. /// This is overridden in RootSite, where we can cast it to IFwMetaDataCacheManaged and really find out. /// </summary> /// ------------------------------------------------------------------------------------ protected override bool IsUnknownProp(IFwMetaDataCache mdc, int tag) { return !(mdc is IFwMetaDataCacheManaged && ((IFwMetaDataCacheManaged)mdc).FieldExists(tag)); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes the WritingSystemPropertiesDialog class. Clients written in .Net with an FdoCache /// should use the version of the constructor that accepts an FdoCache. COM clients that /// do not have an FdoCache should use the default constructor and then call this method /// to initialize the object. /// </summary> /// <param name="ode"></param> /// <param name="mdc"></param> /// <param name="oleDbAccess"></param> /// <param name="helpTopicProvider">IHelpTopicProvider object used to get help /// information</param> /// <param name="stylesheet">Used for the FwTextBox</param> /// ------------------------------------------------------------------------------------ public void Initialize(IOleDbEncap ode, IFwMetaDataCache mdc, IVwOleDbDa oleDbAccess, IHelpTopicProvider helpTopicProvider, IVwStylesheet stylesheet) { CheckDisposed(); FdoCache cache = new FdoCache(ode, mdc, oleDbAccess); m_cacheMadeLocally = true; Initialize(cache, helpTopicProvider, stylesheet); }
static internal int GetCustomFieldFlid(XmlNode caller, IFwMetaDataCache mdc, ICmObject obj) { string fieldName = XmlUtils.GetManditoryAttributeValue(caller, "param"); // It would be nice to avoid all the possible throws for invalid fields, but hard // to achieve in a static method. try { int flid = mdc.GetFieldId2(obj.ClassID, fieldName, true); return flid; } catch { return 0; } }