/// <summary>
///
/// </summary>
/// <param name="featSys"></param>
/// <param name="mediator"></param>
/// <param name="propertyTable"></param>
/// <param name="launchedFromInsertMenu"></param>
public void SetDlginfo(IFsFeatureSystem featSys, Mediator mediator, XCore.PropertyTable propertyTable, bool launchedFromInsertMenu)
{
// default to inflection features
string sXmlFile = Path.Combine(FwDirectoryFinder.CodeDirectory, String.Format("Language Explorer{0}MGA{0}GlossLists{0}EticGlossList.xml", Path.DirectorySeparatorChar));
SetDlginfo(featSys, mediator, propertyTable, launchedFromInsertMenu, "masterInflFeatListDlg", sXmlFile);
}
private void Init(LcmCache cache, Mediator mediator, XCore.PropertyTable propertyTable, ICmPossibilityList list, int ws, bool useAbbr, Form parent)
{
m_mediator = mediator;
m_propertyTable = propertyTable;
if (parent == null)
{
if (m_propertyTable != null)
{
IApp app = m_propertyTable.GetValue <IApp>("App");
if (app != null)
{
parent = app.ActiveMainWindow;
}
if (parent == null)
{
parent = m_propertyTable.GetValue <Form>("window");
}
}
if (parent == null)
{
parent = Form.ActiveForm; // desperate for something...
}
}
m_cache = cache;
m_useAbbr = useAbbr;
m_parent = parent;
m_list = list;
m_ws = ws;
}
/// <summary>
///
/// </summary>
/// <param name="featSys"></param>
/// <param name="mediator"></param>
/// <param name="propertyTable"></param>
/// <param name="launchedFromInsertMenu"></param>
/// <param name="sWindowKey">used to store location and size of dialog window</param>
/// <param name="sXmlFile">file containing the XML form of the gloss list</param>
public void SetDlginfo(IFsFeatureSystem featSys, Mediator mediator, XCore.PropertyTable propertyTable, bool launchedFromInsertMenu, string sWindowKey, string sXmlFile)
{
CheckDisposed();
m_featureSystem = featSys;
m_featureList = featSys.FeaturesOC;
m_launchedFromInsertMenu = launchedFromInsertMenu;
m_mediator = mediator;
m_propertyTable = propertyTable;
if (m_propertyTable != null)
{
m_sWindowKeyLocation = sWindowKey + "Location";
m_sWindowKeySize = sWindowKey + "Size";
ResetWindowLocationAndSize();
m_helpTopicProvider = m_propertyTable.GetValue <IHelpTopicProvider>("HelpTopicProvider");
helpProvider = new HelpProvider();
helpProvider.HelpNamespace = m_helpTopicProvider.HelpFile;
helpProvider.SetHelpKeyword(this, m_helpTopicProvider.GetHelpString(s_helpTopic));
helpProvider.SetHelpNavigator(this, HelpNavigator.Topic);
}
m_cache = featSys.Cache;
LoadMasterFeatures(sXmlFile);
m_tvMasterList.Cache = m_cache;
}
/// <summary>
/// Set up the dlg in preparation to showing it.
/// </summary>
/// <param name="cache">FDO cache.</param>
/// <param name="propertyTable"></param>
/// <param name="wp">Strings used for various items in this dialog.</param>
/// <param name="mediator"></param>
/// <param name="mainObj"></param>
/// <param name="mergeCandidates"></param>
/// <param name="guiControl"></param>
/// <param name="helpTopic"></param>
public void SetDlgInfo(LcmCache cache, Mediator mediator, XCore.PropertyTable propertyTable, WindowParams wp, DummyCmObject mainObj, List <DummyCmObject> mergeCandidates,
string guiControl, string helpTopic)
{
CheckDisposed();
Debug.Assert(cache != null);
m_mediator = mediator;
m_propertyTable = propertyTable;
m_cache = cache;
m_mainObj = mainObj;
m_fwTextBoxBottomMsg.WritingSystemFactory = m_cache.WritingSystemFactory;
m_fwTextBoxBottomMsg.WritingSystemCode = m_cache.WritingSystemFactory.UserWs;
InitBrowseView(guiControl, mergeCandidates);
Text = wp.m_title;
label2.Text = wp.m_label;
m_helpTopic = helpTopic;
if (m_helpTopic != null && m_helpTopicProvider != null) // m_helpTopicProvider could be null for testing
{
helpProvider = new HelpProvider();
helpProvider.HelpNamespace = m_helpTopicProvider.HelpFile;
helpProvider.SetHelpKeyword(this, m_helpTopicProvider.GetHelpString(m_helpTopic));
helpProvider.SetHelpNavigator(this, HelpNavigator.Topic);
}
MoveWindowToPreviousPosition();
}
/// <summary>
/// Initialize the control.
/// </summary>
/// <param name="cache"></param>
/// <param name="mediator"></param>
/// <param name="ctrlAssistant"></param>
/// <param name="parentForm"></param>
/// <param name="propertyTable"></param>
public void Initialize(LcmCache cache, Mediator mediator, XCore.PropertyTable propertyTable, Control ctrlAssistant, Form parentForm)
{
CheckDisposed();
Debug.Assert(ctrlAssistant != null);
m_ctrlAssistant = ctrlAssistant;
Initialize(cache, mediator, propertyTable, parentForm, new SandboxGenericMSA());
}
/// <summary>
/// Init the dialog with an existing context.
/// </summary>
/// <param name="cache"></param>
/// <param name="mediator"></param>
/// <param name="propertyTable"></param>
/// <param name="rule"></param>
/// <param name="ctxt"></param>
public void SetDlgInfo(LcmCache cache, Mediator mediator, XCore.PropertyTable propertyTable, IPhRegularRule rule, IPhSimpleContextNC ctxt)
{
CheckDisposed();
IFsFeatStruc fs = ((IPhNCFeatures)ctxt.FeatureStructureRA).FeaturesOA;
SetDlgInfo(cache, mediator, propertyTable, ctxt.FeatureStructureRA.Hvo, PhNCFeaturesTags.kflidFeatures, fs, rule, ctxt);
}
/// <summary>
/// Restore any appropriate settings which have values in the property table
/// </summary>
public static void RestoreSettings(IFdoServiceLocator services, PropertyTable propertyTable)
{
var hcSettings = propertyTable.GetStringProperty(khomographconfiguration, null);
if (hcSettings != null)
{
var hc = services.GetInstance<HomographConfiguration>();
hc.PersistData = hcSettings;
}
}
void IFwExtension.Init(LcmCache cache, Mediator mediator, PropertyTable propertyTable)
{
m_mediator = mediator;
m_propertyTable = propertyTable;
m_cache = cache;
m_helpTopicProvider = m_propertyTable.GetValue <IHelpTopicProvider>("HelpTopicProvider");
m_sUserWs = m_cache.ServiceLocator.WritingSystemManager.UserWritingSystem.Id;
m_sNewUserWs = m_sUserWs;
m_userInterfaceChooser.Init(m_sUserWs);
// Populate Plugins tab page list.
var baseConfigPath = FwDirectoryFinder.GetCodeSubDirectory(
Path.Combine("Language Explorer", "Configuration"));
string basePluginPath = Path.Combine(baseConfigPath, "Available Plugins");
// The extension XML files should be stored in the data area, not in the code area.
// This reduces the need for users to have administrative privileges.
string baseExtensionPath = Path.Combine(FwDirectoryFinder.DataDirectory,
Path.Combine("Language Explorer", "Configuration"));
foreach (string dir in Directory.GetDirectories(basePluginPath))
{
Debug.WriteLine(dir);
// Currently not offering Concorder plugin in FW7, therefore, we
// can remove the feature until we need to implement. (FWNX-755)
if (Platform.IsUnix && dir == Path.Combine(basePluginPath, "Concorder"))
{
continue;
}
string managerPath = Path.Combine(dir, "ExtensionManager.xml");
if (File.Exists(managerPath))
{
XmlDocument managerDoc = new XmlDocument();
managerDoc.Load(managerPath);
XmlNode managerNode = managerDoc.SelectSingleNode("/manager");
m_lvPlugins.SuspendLayout();
ListViewItem lvi = new ListViewItem();
lvi.Tag = managerDoc;
lvi.Text = managerNode.Attributes["name"].Value;
lvi.SubItems.Add(managerNode.Attributes["description"].Value);
// See if it is installed and check the lvi if it is.
XmlNode configfilesNode = managerNode.SelectSingleNode("configfiles");
string extensionPath = Path.Combine(baseExtensionPath, configfilesNode.Attributes["targetdir"].Value);
lvi.Checked = Directory.Exists(extensionPath);
m_plugins.Add(lvi.Text, lvi.Checked); // Remember original installed state.
m_lvPlugins.Items.Add(lvi);
m_lvPlugins.ResumeLayout();
}
}
if (m_helpTopicProvider != null) // Will be null when running tests
{
helpProvider = new HelpProvider();
helpProvider.HelpNamespace = m_helpTopicProvider.HelpFile;
helpProvider.SetHelpKeyword(this, m_helpTopicProvider.GetHelpString(s_helpTopic));
helpProvider.SetHelpNavigator(this, HelpNavigator.Topic);
}
}
/// <summary>
/// Set up the dlg in preparation to showing it.
/// </summary>
/// <param name="cache">FDO cache.</param>
/// <param name="mediator">Mediator used to restore saved siz and location info.</param>
/// <param name="propertyTable"></param>
/// <param name="startingEntry">Entry that cannot be used as a match in this dlg.</param>
public void SetDlgInfo(LcmCache cache, Mediator mediator, XCore.PropertyTable propertyTable, ILexEntry startingEntry)
{
CheckDisposed();
Debug.Assert(startingEntry != null);
m_startingEntry = startingEntry;
SetDlgInfo(cache, null, mediator, propertyTable);
}
public InterestingTextList(PropertyTable propertyTable, ITextRepository repo,
IStTextRepository stTextRepo, bool includeScripture)
{
m_textRepository = repo;
m_propertyTable = propertyTable;
m_stTextRepository = stTextRepo;
CoreTexts = GetCoreTexts();
m_scriptureTexts = GetScriptureTexts();
IncludeScripture = includeScripture;
GetCache();
}
/// <summary>
/// Init the dialog with an existing FS. Warning: the fs passed in
/// might get deleted if it proves to be a duplicate. Retrieve the new FS after running it.
/// This constructor is used in MsaInflectionFeatureListDlgLauncher.HandleChooser.
/// </summary>
/// <param name="cache"></param>
/// <param name="mediator"></param>
/// <param name="propertyTable"></param>
/// <param name="fs"></param>
/// <param name="owningFlid"></param>
public void SetDlgInfo(LcmCache cache, Mediator mediator, XCore.PropertyTable propertyTable, IFsFeatStruc fs, int owningFlid)
{
CheckDisposed();
m_fs = fs;
m_propertyTable = propertyTable;
Mediator = mediator;
m_cache = cache;
m_owningFlid = owningFlid;
LoadInflFeats(fs);
EnableLink();
}
/// <summary>
/// Init the dialog with an MSA and flid that does not yet contain a feature structure.
/// </summary>
/// <param name="cache"></param>
/// <param name="mediator"></param>
/// <param name="propertyTable"></param>
/// <param name="cobj"></param>
/// <param name="owningFlid"></param>
public void SetDlgInfo(LcmCache cache, Mediator mediator, XCore.PropertyTable propertyTable, ICmObject cobj, int owningFlid)
{
CheckDisposed();
m_fs = null;
m_owningFlid = owningFlid;
m_hvoOwner = cobj.Hvo;
m_propertyTable = propertyTable;
Mediator = mediator;
m_cache = cache;
LoadInflFeats(cobj, owningFlid);
EnableLink();
}
public MasterCategoryListChooserLauncher(Form popupMgrParent, Mediator mediator, XCore.PropertyTable propertyTable,
ICmPossibilityList possibilityList, string fieldName, ILexSense sense)
{
m_parentOfPopupMgr = popupMgrParent;
m_mediator = mediator;
m_propertyTable = propertyTable;
CategoryList = possibilityList;
m_sense = sense;
FieldName = fieldName;
Cache = m_sense.Cache;
Application.Idle += new EventHandler(LaunchChooseFromMasterCategoryListOnIdle);
}
/// <summary/>
public void SetDlginfo(ICmPossibilityList posList, Mediator mediator, XCore.PropertyTable propertyTable, bool launchedFromInsertMenu, IPartOfSpeech subItemOwner)
{
CheckDisposed();
m_subItemOwner = subItemOwner; // May be null, which is fine.
m_posList = posList;
m_launchedFromInsertMenu = launchedFromInsertMenu;
m_mediator = mediator;
m_propertyTable = propertyTable;
if (m_propertyTable != null)
{
// Reset window location.
// Get location to the stored values, if any.
if (m_propertyTable.PropertyExists("masterCatListDlgLocation") &&
m_propertyTable.PropertyExists("masterCatListDlgSize"))
{
var locWnd = m_propertyTable.GetValue <Point>("masterCatListDlgLocation");
var szWnd = m_propertyTable.GetValue <Size>("masterCatListDlgSize");
Rectangle rect = new Rectangle(locWnd, szWnd);
ScreenHelper.EnsureVisibleRect(ref rect);
DesktopBounds = rect;
StartPosition = FormStartPosition.Manual;
}
m_helpTopicProvider = m_propertyTable.GetValue <IHelpTopicProvider>("HelpTopicProvider");
if (m_helpTopicProvider != null)
{
helpProvider = new HelpProvider();
helpProvider.HelpNamespace = m_helpTopicProvider.HelpFile;
helpProvider.SetHelpKeyword(this, m_helpTopicProvider.GetHelpString(s_helpTopic));
helpProvider.SetHelpNavigator(this, HelpNavigator.Topic);
}
}
m_bnHelp.Enabled = (m_helpTopicProvider != null);
Debug.Assert(posList != null);
m_cache = posList.Cache;
var posSet = new HashSet <IPartOfSpeech>();
foreach (IPartOfSpeech pos in posList.ReallyReallyAllPossibilities)
{
posSet.Add(pos);
}
LoadMasterCategories(posSet);
}
/// <summary>
/// Set up the dlg in preparation to showing it.
/// </summary>
/// <param name="cache">FDO cache.</param>
/// <param name="wp">Strings used for various items in this dialog.</param>
/// <param name="mediator">The mediator.</param>
/// <param name="propertyTable"></param>
/// <param name="tssform">The form.</param>
/// <param name="hvoType">The HVO of the type.</param>
public void SetDlgInfo(LcmCache cache, WindowParams wp, Mediator mediator, XCore.PropertyTable propertyTable, ITsString tssform, int hvoType)
{
CheckDisposed();
SetDlgInfo(cache, wp, mediator, propertyTable, tssform);
m_formOrig = m_tbForm.Text;
m_hvoType = hvoType;
// JohnT: a prior call to SetForm should have established whether this button
// is enabled...and it should NOT be, if there are no entries selected,
// typically because none at all match the form.
//btnOK.Enabled = true;
m_btnOK.Width += 30;
m_btnOK.Left += 90;
m_btnClose.Width += 30; // for balance...
ShowControlsBasedOnPanel1Position();
}
private void SetDlgInfo(LcmCache cache, Mediator mediator, XCore.PropertyTable propertyTable, int hvoOwner, int owningFlid, IFsFeatStruc fs, IPhRegularRule rule, IPhSimpleContextNC ctxt)
{
m_fs = fs;
m_owningFlid = owningFlid;
m_hvoOwner = hvoOwner;
m_rule = rule;
m_ctxt = ctxt;
m_mediator = mediator;
m_propertyTable = propertyTable;
if (m_propertyTable != null)
{
// Reset window location.
// Get location to the stored values, if any.
if (m_propertyTable.PropertyExists("phonFeatListDlgLocation") &&
m_propertyTable.PropertyExists("phonFeatListDlgSize"))
{
var locWnd = m_propertyTable.GetValue <Point>("phonFeatListDlgLocation");
var szWnd = m_propertyTable.GetValue <Size>("phonFeatListDlgSize");
var rect = new Rectangle(locWnd, szWnd);
ScreenHelper.EnsureVisibleRect(ref rect);
DesktopBounds = rect;
StartPosition = FormStartPosition.Manual;
}
var helpTopicProvider = (m_propertyTable.GetValue <IHelpTopicProvider>("HelpTopicProvider"));
if (helpTopicProvider != null) // Will be null when running tests
{
m_helpProvider.HelpNamespace = helpTopicProvider.HelpFile;
m_helpProvider.SetHelpKeyword(this, helpTopicProvider.GetHelpString(m_helpTopic));
m_helpProvider.SetHelpNavigator(this, HelpNavigator.Topic);
}
}
m_cache = cache;
m_valuesCombo.WritingSystemFactory = m_cache.LanguageWritingSystemFactoryAccessor;
m_valuesCombo.StyleSheet = FontHeightAdjuster.StyleSheetFromPropertyTable(m_propertyTable);
LoadPhonFeats(m_fs);
BuildInitialBrowseView();
}
/// <summary>
/// From IFwExtension
/// </summary>
/// <param name="cache"></param>
/// <param name="mediator"></param>
/// <param name="propertyTable"></param>
void IFwExtension.Init(LcmCache cache, Mediator mediator, XCore.PropertyTable propertyTable)
{
m_cache = cache;
m_mediator = mediator;
m_propertyTable = propertyTable;
string sPrevFile = m_propertyTable.GetStringProperty(FilePropertyName, null);
if (!String.IsNullOrEmpty(sPrevFile))
{
tbPath.Text = sPrevFile;
UpdateButtons();
}
string sMergeStyle = m_propertyTable.GetStringProperty(MergeStylePropertyName, null);
if (!String.IsNullOrEmpty(sMergeStyle))
{
m_msImport = (FlexLiftMerger.MergeStyle)Enum.Parse(typeof(FlexLiftMerger.MergeStyle), sMergeStyle, true);
switch (m_msImport)
{
case FlexLiftMerger.MergeStyle.MsKeepOld:
m_rbKeepCurrent.Checked = true;
break;
case FlexLiftMerger.MergeStyle.MsKeepNew:
m_rbKeepNew.Checked = true;
break;
case FlexLiftMerger.MergeStyle.MsKeepBoth:
m_rbKeepBoth.Checked = true;
break;
default:
m_rbKeepCurrent.Checked = true;
break;
}
}
}
public void SetDlgInfo(LcmCache cache, Mediator mediator, XCore.PropertyTable propertyTable, ICmObject owner)
{
CheckDisposed();
m_cache = cache;
m_owner = owner;
m_helpTopic = "khtpDataNotebook-InsertRecordDlg";
m_helpTopicProvider = propertyTable.GetValue <IHelpTopicProvider>("HelpTopicProvider");
if (m_helpTopicProvider != null) // Will be null when running tests
{
m_helpProvider.HelpNamespace = m_helpTopicProvider.HelpFile;
m_helpProvider.SetHelpKeyword(this, m_helpTopicProvider.GetHelpString(m_helpTopic));
m_helpProvider.SetHelpNavigator(this, HelpNavigator.Topic);
}
IVwStylesheet stylesheet = FontHeightAdjuster.StyleSheetFromPropertyTable(propertyTable);
m_titleTextBox.StyleSheet = stylesheet;
m_titleTextBox.WritingSystemFactory = m_cache.WritingSystemFactory;
m_titleTextBox.WritingSystemCode = m_cache.DefaultAnalWs;
AdjustControlAndDialogHeight(m_titleTextBox, m_titleTextBox.PreferredHeight);
m_typeCombo.StyleSheet = stylesheet;
m_typeCombo.WritingSystemFactory = m_cache.WritingSystemFactory;
m_typeCombo.WritingSystemCode = m_cache.DefaultAnalWs;
AdjustControlAndDialogHeight(m_typeCombo, m_typeCombo.PreferredHeight);
ICmPossibilityList recTypes = m_cache.LanguageProject.ResearchNotebookOA.RecTypesOA;
m_typePopupTreeManager = new PossibilityListPopupTreeManager(m_typeCombo, m_cache, mediator, propertyTable,
recTypes, cache.DefaultAnalWs, false, this);
m_typePopupTreeManager.LoadPopupTree(m_cache.ServiceLocator.GetObject(RnResearchNbkTags.kguidRecObservation).Hvo);
// Ensure that we start out focused in the Title text box. See FWR-2731.
m_titleTextBox.Select();
}
/// <summary>
/// set the value of a property to a node of a list. Also sets the corresponding parameters property.
/// </summary>
/// <remarks> this is static so that it can be called by the XCore initializationcode and set from the contents of the XML configuration file</remarks>
/// <param name="mediator"></param>
/// <param name="choice"></param>
/// <param name="propertyName"></param>
public static void ChooseSinglePropertyAtomicValue(Mediator mediator, string choiceValue,
XmlNode choiceParameters,string propertyName, PropertyTable.SettingsGroup settingsGroup)
{
//a hack (that may be we could live with)
// if(choiceParameters !=null)
// {
mediator.PropertyTable.SetProperty(propertyName+"Parameters", choiceParameters, settingsGroup);
//it is possible that we would like to persist these parameters
//however, as a practical matter, you cannot have XmlNodes witch do not belong to a document.
//therefore, they could not be deserialize if we did save them.
//unless, of course, we convert them to a string before serializing.
//However, when de-serializing, what document would we attach the new xmlnode to?
mediator.PropertyTable.SetPropertyPersistence(propertyName+"Parameters", false, settingsGroup);
//}
//remember, each of these calls to SetProperty() generate a broadcast, so the order of these two calls
//is relevant.
mediator.PropertyTable.SetProperty(propertyName, choiceValue, settingsGroup);
if (choiceParameters != null)
{
//since we cannot persist the parameters, it's safer to not persist the choice either.
mediator.PropertyTable.SetPropertyPersistence(propertyName, false, settingsGroup);
}
}
public ChoiceBase(Mediator mediator, PropertyTable propertyTable, XmlNode configurationNode, IUIAdapter adapter, ChoiceGroup parent)
: base(mediator, propertyTable, adapter, configurationNode)
{
m_parent = parent;
}
/// <summary>
/// Constructor.
/// </summary>
public POSPopupTreeManager(TreeCombo treeCombo, LcmCache cache, ICmPossibilityList list, int ws, bool useAbbr, Mediator mediator, XCore.PropertyTable propertyTable, Form parent)
: base(treeCombo, cache, mediator, propertyTable, list, ws, useAbbr, parent)
{
}
/// <summary>
/// </summary>
public void LoadSettings(PropertyTable pt)
{
if (pt == null || !NeedToReloadSettings)
return;
ResetOwningObj();
string sHvos = GetPropertyTableValue(pt);
m_ids = PropertyTableList(sHvos);
m_fNeedToReloadSettings = false;
}
/// <summary>
/// Save any appropriate settings to the property table
/// </summary>
public static void SaveSettings(IFdoServiceLocator services, PropertyTable propertyTable)
{
var hc = services.GetInstance<HomographConfiguration>();
propertyTable.SetProperty(khomographconfiguration, hc.PersistData);
}
/// <summary>
///
/// </summary>
/// <param name="mediator"></param>
/// <param name="propertyTable"></param>
/// <param name="configurationNode"></param>
/// <param name="adapter"></param>
/// <param name="parent"></param>
public CommandChoice(Mediator mediator, PropertyTable propertyTable, XmlNode configurationNode, IUIAdapter adapter, ChoiceGroup parent)
: base(mediator, propertyTable, configurationNode, adapter, parent)
{
m_idOfCorrespondingCommand = XmlUtils.GetAttributeValue(m_configurationNode, "command");
m_defaultLabelOverride = XmlUtils.GetLocalizedAttributeValue(m_configurationNode, "label", null);
}
public InterestingTextList(PropertyTable propertyTable, ITextRepository repo, IStTextRepository stTextRepo)
: this(propertyTable, repo, stTextRepo, 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 override void Dispose(bool disposing)
{
//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
// Can be called more than once, but not run more than once.
if (m_isDisposed)
return;
if (disposing)
{
// Dispose managed resources here.
// Use a copy of the m_colleagues Set,
// since the Dispose methods on the colleague should remove itself from m_colleagues,
// which will cause an exception to be throw (list changed while spinning through it.
Set<IxCoreColleague> copyOfColleagues = new Set<IxCoreColleague>(m_colleagues.ToArray());
m_colleagues.Clear(); // Just get rid of them now.
foreach (IxCoreColleague icc in copyOfColleagues)
{
if (icc is IDisposable)
{
// Is the class marked with [XCore.MediatorDispose],
// or is it in the temporary colleague holder?
object[] attrs = icc.GetType().GetCustomAttributes(typeof(MediatorDisposeAttribute), true);
if ((attrs != null && attrs.Length > 0)
|| m_temporaryColleague == icc)
{
(icc as IDisposable).Dispose();
}
}
}
copyOfColleagues.Clear();
if (m_propertyTable != null)
m_propertyTable.Dispose();
if (m_commandSet != null)
m_commandSet.Dispose();
if (m_pathVariables != null)
m_pathVariables.Clear();
if (m_disposedColleagues != null)
m_disposedColleagues.Clear();
if (m_jobs != null)
m_jobs.Clear();
if (m_pendingjobs != null)
m_pendingjobs.Clear();
if (m_MethodsOnAnyColleague != null)
m_MethodsOnAnyColleague.Clear();
m_idleQueue.Dispose();
}
// Dispose unmanaged resources here, whether disposing is true or false.
m_mainWndPtr = IntPtr.Zero;
m_MethodsOnAnyColleague = null;
m_pendingjobs = null;
m_jobs = null;
m_disposedColleagues = null;
m_temporaryColleague = null;
m_propertyTable = null;
m_commandSet = null;
m_colleagues = null;
m_pathVariables = null;
/* It is illegal to try to access managed stuff in this part of the Dispose method.
#if DEBUG
//DebugMsg("-- Number of calls to the InvokeRecursively method = " + m_invokeCount.ToString());
DebugMsg("-- Number of saved calls to Type.GetMethod = " + m_SavedCalls.ToString());
DebugMsg("-- Mediator MsgHash info: count=" + m_MethodsNOTonColleagues.Count + " mx depth=" + m_MethodsCount);
DebugMsg("-- Mediator - Calls to check for method on colleague: " + m_MethodChecks);
#endif
*/
m_isDisposed = true;
base.Dispose(disposing);
}
/// <summary>
/// Store this virtual property's settings to the property table so they can be persisted in local settings.
/// </summary>
/// <param name="pt"></param>
internal void StoreSettings(PropertyTable pt)
{
if (pt == null)
return;
pt.SetProperty(m_propertyTableKey, GetPropertyTableValue(), true, PropertyTable.SettingsGroup.LocalSettings);
}
/// <summary>
/// Sets the DLG info.
/// </summary>
/// <param name="cache">The cache.</param>
/// <param name="mediator">The mediator.</param>
/// <param name="propertyTable"></param>
/// <param name="tssVariantLexemeForm">The variant lexeme form.</param>
public void SetDlgInfo(LcmCache cache, Mediator mediator, XCore.PropertyTable propertyTable, ITsString tssVariantLexemeForm)
{
m_tssVariantLexemeForm = tssVariantLexemeForm;
base.SetDlgInfo(cache, mediator, propertyTable, null);
}
public void Init(Mediator mediator, PropertyTable propertyTable, XmlNode configurationParameters)
{
}
private void ResetPropertyTable()
{
m_mediator = new Mediator();
m_settings = m_mediator.PropertyTable;
}
public SeparatorChoice(Mediator mediator, PropertyTable propertyTable, XmlNode configurationNode, IUIAdapter adapter, ChoiceGroup parent)
: base(mediator, propertyTable, configurationNode, adapter, parent)
{
}
static bool m_fHandlingClick = false; // prevent multiple simultaneous OnClick operations.
#endregion
public ListPropertyChoice(Mediator mediator, PropertyTable propertyTable, ListItem listItem, IUIAdapter adapter, ChoiceGroup parent)
: base(mediator, propertyTable, adapter, parent)
{
m_listItem = listItem;
}
public static void ChooseSinglePropertySequenceValue(Mediator mediator, string choiceValue,
XmlNode choiceParameterNode, string propertyName, bool fEmptyAllowed, PropertyTable.SettingsGroup settingsGroup)
{
mediator.PropertyTable.SetProperty(propertyName + "Parameters", choiceParameterNode, settingsGroup);
mediator.PropertyTable.SetPropertyPersistence(propertyName + "Parameters", false, settingsGroup);
string sValue = mediator.PropertyTable.GetStringProperty(propertyName, "", settingsGroup);
string[] rgsValues = sValue.Split(',');
int idx = -1;
if (sValue == choiceValue)
{
if (fEmptyAllowed)
sValue = "";
}
else if ((idx = IndexOf(rgsValues, choiceValue)) != -1)
{
// remove the choiceValue from the string.
Debug.Assert(rgsValues.Length > 1);
System.Text.StringBuilder sbValues = new System.Text.StringBuilder(sValue.Length);
for (int i = 0; i < rgsValues.Length; ++i)
{
if (idx != i)
{
if (sbValues.Length > 0)
sbValues.Append(",");
sbValues.Append(rgsValues[i]);
}
}
sValue = sbValues.ToString();
}
else
{
if (sValue.Length == 0)
sValue = choiceValue;
else
sValue = sValue + "," + choiceValue;
}
mediator.PropertyTable.SetProperty(propertyName, sValue, settingsGroup);
mediator.PropertyTable.SetPropertyPersistence(propertyName, false, settingsGroup);
}
/// <summary>
/// Constructor.
/// </summary>
public InflectionFeaturePopupTreeManager(TreeCombo treeCombo, LcmCache cache, bool useAbbr, Mediator mediator, XCore.PropertyTable propertyTable, Form parent, int wsDisplay)
: base(treeCombo, cache, mediator, propertyTable, cache.LanguageProject.PartsOfSpeechOA, wsDisplay, useAbbr, parent)
{
}
public static PropertyTable.SettingsGroup GetSettingsGroup(XmlNode configurationNode, PropertyTable.SettingsGroup defaultSettings)
{
string settingsGroupValue = XmlUtils.GetAttributeValue(configurationNode, "settingsGroup");
if (String.IsNullOrEmpty(settingsGroupValue))
return defaultSettings;
switch (settingsGroupValue)
{
case "local":
return PropertyTable.SettingsGroup.LocalSettings;
case "global":
return PropertyTable.SettingsGroup.GlobalSettings;
default:
throw new Exception(String.Format("GetSettingsGroup does not yet support {0} for 'settingsGroup' attribute.", settingsGroupValue));
}
}
public ChoiceBase(Mediator mediator, PropertyTable propertyTable, IUIAdapter adapter, ChoiceGroup parent)
: base(mediator, propertyTable, adapter, null)
{
m_parent = parent;
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="Mediator"/> class.
/// </summary>
/// -----------------------------------------------------------------------------------
public Mediator()
{
m_propertyTable = new PropertyTable(this);
m_MethodsOnAnyColleague = new Set<string>();
// m_allowCommandsToExecute = false;
// NOTE: to set the trace level, create a config file like the following and set
// it there. Values are: Off=0, Error=1, Warning=2, Info=3, Verbose=4.
// <configuration>
// <system.diagnostics>
// <switches>
// <add name="Mediator" value="3" />
// </switches>
// </system.diagnostics>
// </configuration>
// OR you can temporarily uncomment one of the following:
//invokeSwitch.Level = TraceLevel.Info; //some output. Will tell you what methods are being invoke, on whom.
//NB: To make this much use, you'll need to disable the IDLE processing in XWindow.
//otherwise, XCore will spend all of its time tracing things here during idle time
// and you won't be able to find the bug You are seeking.
/* -----------------------------------------------------------------
* TraceLevel.Verbose will show something like this (BUT SO MUCH IT'S HARDLY USEABLE):
Looking for listeners for Msg: DisplayWritingSystemList
[XCore.MockupDialogLauncher
{XCore.MockupDialogLauncher
Checking : XCore.MockupDialogLauncher
}
]
[SIL.FieldWorks.WordWorks.Parser.ParserListener
{SIL.FieldWorks.WordWorks.Parser.ParserListener
Checking : SIL.FieldWorks.WordWorks.Parser.ParserListener
}
]
[SIL.FieldWorks.XWorks.WritingSystemListHandler
{SIL.FieldWorks.XWorks.WritingSystemListHandler
Checking : SIL.FieldWorks.XWorks.WritingSystemListHandler
Invoking method: SIL.FieldWorks.XWorks.WritingSystemListHandler
Invoking Method: OnDisplayWritingSystemList on SIL.FieldWorks.XWorks.WritingSystemListHandler
}
]
*/
}
/// <summary>
/// create a PersistenceProvider which uses the XCore PropertyTable.
/// </summary>
/// <param name="propertyTable"></param>
public PersistenceProvider(PropertyTable propertyTable)
{
m_contextString= "Default";
m_propertyTable = propertyTable;
}
/// <summary>
/// Common init of the dialog, whether or not we have a starting lex entry.
/// </summary>
/// <param name="cache"></param>
/// <param name="wp"></param>
/// <param name="mediator"></param>
/// <param name="propertyTable"></param>
public override void SetDlgInfo(LcmCache cache, WindowParams wp, Mediator mediator, XCore.PropertyTable propertyTable)
{
CheckDisposed();
base.SetDlgInfo(cache, wp, mediator, propertyTable);
// This is needed to make the replacement MatchingEntriesBrowser visible:
Controls.SetChildIndex(m_matchingObjectsBrowser, 0);
m_fwcbAllomorphs.WritingSystemFactory = cache.WritingSystemFactory;
m_fwcbAllomorphs.WritingSystemCode = cache.ServiceLocator.WritingSystems.DefaultVernacularWritingSystem.Handle;
// For a resizeable dialog, we don't want AdjustForStylesheet to really change its size,
// because then it ends up growing every time it launches!
int oldHeight = Height;
m_fwcbAllomorphs.AdjustForStyleSheet(this, grplbl, propertyTable);
Height = oldHeight;
}
/// <summary>
/// Init the dialog with a POS.
/// If a new feature structure is created, it will currently be in the ReferenceForms of the POS.
/// Eventually we want to make a new field for this purpose. (This is used by bulk edit
/// to store previously used feature structures.)
/// </summary>
/// <param name="cache"></param>
/// <param name="mediator"></param>
/// <param name="propertyTable"></param>
/// <param name="pos"></param>
public void SetDlgInfo(LcmCache cache, Mediator mediator, XCore.PropertyTable propertyTable, IPartOfSpeech pos)
{
SetDlgInfo(cache, mediator, propertyTable, pos, PartOfSpeechTags.kflidReferenceForms);
}
/// <summary>
/// Store in the property table what needs to be there so that we will use the specified set of scripture
/// texts as 'interesting'.
/// </summary>
/// <param name="propertyTable"></param>
public static void SetScriptureTextsInPropertyTable(PropertyTable propertyTable, IEnumerable<IStText> texts)
{
propertyTable.SetProperty(PersistPropertyName, MakeIdList(texts.Cast<ICmObject>()));
}
/// <summary>
/// create a PersistenceProvider which uses the XCore PropertyTable.
/// </summary>
/// <param name="context">used to provide persistence and access to settings
/// limited to a particular context. For example, if they control is used in
/// three different places, we don't necessarily want to control to use the
/// same settings each time. So each case would need its own context string.</param>
/// <param name="propertyTable"></param>
public PersistenceProvider(string context, PropertyTable propertyTable)
{
m_contextString= context;
m_propertyTable = propertyTable;
}
/// <summary>
/// get the value for our virtual handler from the property table.
/// </summary>
/// <param name="pt"></param>
/// <returns></returns>
private string GetPropertyTableValue(PropertyTable pt)
{
if (pt == null)
return null;
return pt.GetStringProperty(m_propertyTableKey, null);
}
public override void SetDlgInfo(LcmCache cache, WindowParams wp, Mediator mediator, XCore.PropertyTable propertyTable, string form)
{
SetDlgInfo(cache, wp, mediator, propertyTable, form, cache.DefaultAnalWs);
}
/// <summary>
/// Constructor.
/// </summary>
public MSAPopupTreeManager(PopupTree popupTree, LcmCache cache, ICmPossibilityList list,
int ws, bool useAbbr, Mediator mediator, XCore.PropertyTable propertyTable, Form parent)
: base(popupTree, cache, mediator, propertyTable, list, ws, useAbbr, parent)
{
LoadStrings();
}
/// <summary>
/// when calling the dialog from an "Insert Variant" context this
/// constructor is used to indicate that m_startingEntry is a componentLexeme
/// rather than the variant
/// </summary>
/// <param name="cache"></param>
/// <param name="mediator"></param>
/// <param name="propertyTable"></param>
/// <param name="componentLexeme">the entry we wish to find or create a variant for.</param>
protected void SetDlgInfoForComponentLexeme(LcmCache cache, Mediator mediator, XCore.PropertyTable propertyTable, IVariantComponentLexeme componentLexeme)
{
m_fBackRefToVariant = true;
ILexEntry startingEntry;
if (componentLexeme.ClassID == LexEntryTags.kClassId)
{
startingEntry = componentLexeme as ILexEntry;
}
else
{
startingEntry = componentLexeme.Owner as ILexEntry;
}
SetDlgInfo(cache, mediator, propertyTable, startingEntry);
// we are looking for an existing variant form
// so hide the Entry/Sense radio group box.
grplbl.Visible = false;
// also hide variant type.
tcVariantTypes.Visible = false;
lblVariantType.Visible = false;
m_fGetVariantEntryTypeFromTreeCombo = false;
lblCreateEntry.Visible = false;
// The dialog title and other labels need to reflect "Insert Variant" context.
m_formLabel.Text = LexTextControls.ks_Variant;
Text = LexTextControls.ksFindVariant;
m_btnInsert.Text = LexTextControls.ks_Create;
// We disable the "Create" button when we don't have text in the Find textbox.
UpdateButtonCreateNew();
}