/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// <param name="sender"></param> /// <param name="defaultMsg"></param> /// <param name="noMatchFoundType"></param> /// <returns></returns> /// ------------------------------------------------------------------------------------ private bool FindDlgMatchNotFound(object sender, string defaultMsg, FwFindReplaceDlg.MatchType noMatchFoundType) { m_noMatchFoundType = noMatchFoundType; return false; }
private void m_findReplaceSetupButton_Click(object sender, System.EventArgs e) { // Ensure that the find and replace strings have the correct writing system. int ws = -50; try { // Find the writing system for the selected column (see LT-5491). FieldComboItem fci = m_findReplaceTargetCombo.SelectedItem as FieldComboItem; if (fci == null) { MessageBox.Show(XMLViewsStrings.ksChooseEditTarget); return; } XmlNode xnField = m_bv.ColumnSpecs[fci.ColumnIndex]; string sWs = XmlViewsUtils.FindWsParam(xnField); if (String.IsNullOrEmpty(sWs)) { // It's likely a custom field with a ws selector in the field metadata. string sTransduce = XmlUtils.GetOptionalAttributeValue(xnField, "transduce"); if (!String.IsNullOrEmpty(sTransduce)) { string[] parts = sTransduce.Split('.'); if (parts.Length == 2) { string className = parts[0]; string fieldName = parts[1]; IFwMetaDataCache mdc = m_cache.DomainDataByFlid.MetaDataCache; try { int clid = mdc.GetClassId(className); int flid = mdc.GetFieldId2(clid, fieldName, true); ws = FieldReadWriter.GetWsFromMetaData(0, flid, m_cache); if (ws == 0) ws = m_cache.ServiceLocator.WritingSystems.DefaultVernacularWritingSystem.Handle; } catch { } } } } else if (!XmlViewsUtils.GetWsRequiresObject(sWs)) { // Try to convert the ws parameter into an int. Sometimes the parameter // cannot be interpreted without an object, such as when the ws is a magic // string that will change the actual ws depending on the contents of the // object. In these cases, we give -50 as a known constant to check for. // This can possibly throw an exception, so we'll enclose it in a try block. ws = WritingSystemServices.InterpretWsLabel(m_cache, sWs, null, 0, 0, null); } } catch { } if (ws == -50) ws = m_cache.ServiceLocator.WritingSystems.DefaultVernacularWritingSystem.Handle; ITsStrFactory tsf = m_cache.TsStrFactory; if (m_tssReplace == null) m_tssReplace = tsf.MakeString("", ws); else { // If we have a replacement TsString, but no pattern, keep the text but // no properties. if (m_pattern == null) m_tssReplace = tsf.MakeString(m_tssReplace.Text, ws); else if (!m_pattern.MatchOldWritingSystem) { // We have both a string and a pattern. We want to clear writing system information // on the string unless we are matching on WS. But we don't want to clear any style info. ITsStrBldr bldr = m_tssReplace.GetBldr(); bldr.SetIntPropValues(0, bldr.Length, (int)FwTextPropType.ktptWs, (int)FwTextPropVar.ktpvDefault, ws); m_tssReplace = bldr.GetString(); } } if (m_pattern != null) { if (m_pattern.Pattern == null) m_pattern.Pattern = tsf.MakeString("", ws); else if (!m_pattern.MatchOldWritingSystem) { // Enforce the expected writing system; but don't clear styles. ITsStrBldr bldr = m_pattern.Pattern.GetBldr(); bldr.SetIntPropValues(0, bldr.Length, (int)FwTextPropType.ktptWs, (int)FwTextPropVar.ktpvDefault, ws); m_pattern.Pattern = bldr.GetString(); } } using (FwFindReplaceDlg findDlg = new FwFindReplaceDlg()) { //Change the Title from "Find and Replace" to "Bulk Replace Setup" findDlg.Text = String.Format(XMLViewsStrings.khtpBulkReplaceTitle); IApp app = (IApp)m_mediator.PropertyTable.GetValue("App"); findDlg.SetDialogValues(m_cache, m_pattern, m_bv.BrowseView.StyleSheet, FindForm(), m_mediator.HelpTopicProvider, app); findDlg.RestoreAndPersistSettingsIn(m_mediator); // Set this AFTER it has the correct WSF! findDlg.ReplaceText = m_tssReplace; if (findDlg.ShowDialog(this) == DialogResult.OK) { m_tssReplace = findDlg.ResultReplaceText; UpdateFindReplaceSummary(); EnablePreviewApplyForFindReplace(); } } }
/// <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) { System.Diagnostics.Debug.WriteLineIf(!disposing, "****** Missing Dispose() call for " + GetType().Name + ". ****** "); // Must not be run more than once. if (IsDisposed || BeingDisposed) return; BeingDisposed = true; if (disposing) { UpdateAppRuntimeCounter(); Logger.WriteEvent("Disposing app: " + GetType().Name); RegistrySettings.FirstTimeAppHasBeenRun = false; // Dispose managed resources here. List<IFwMainWnd> mainWnds = new List<IFwMainWnd>(m_rgMainWindows); // Use another array, since m_rgMainWindows may change. m_rgMainWindows.Clear(); // In fact, just clear the main array, so the windows won't have to worry so much. foreach (IFwMainWnd mainWnd in mainWnds) { if (mainWnd is Form) { Form wnd = (Form)mainWnd; wnd.Closing -= OnClosingWindow; wnd.Closed -= OnWindowClosed; wnd.Activated -= fwMainWindow_Activated; wnd.HandleDestroyed -= fwMainWindow_HandleDestroyed; wnd.Dispose(); } else if (mainWnd is IDisposable) ((IDisposable)mainWnd).Dispose(); } if (m_findReplaceDlg != null) m_findReplaceDlg.Dispose(); #if DEBUG if (m_debugProcs != null) m_debugProcs.Dispose(); #endif ResourceHelper.ShutdownHelper(); if (m_registrySettings != null) m_registrySettings.Dispose(); Application.EnterThreadModal -= Application_EnterThreadModal; Application.LeaveThreadModal -= Application_LeaveThreadModal; Application.RemoveMessageFilter(this); PictureHolder.Dispose(); } // Dispose unmanaged resources here, whether disposing is true or false. m_rgMainWindows = null; m_activeMainWindow = null; m_registrySettings = null; m_findPattern = null; m_findReplaceDlg = null; m_suppressedCacheInfo = null; m_refreshView = null; PictureHolder = null; #if DEBUG m_debugProcs = null; #endif IsDisposed = true; BeingDisposed = false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Display the Find/Replace modeless dialog /// </summary> /// <param name="fReplace"><c>true</c> to make the replace tab active</param> /// <param name="rootsite">The view where the find will be conducted</param> /// <returns><c>true</c> if the dialog is successfully displayed</returns> /// ------------------------------------------------------------------------------------ public bool ShowFindReplaceDialog(bool fReplace, RootSite rootsite) { CheckDisposed(); if (rootsite == null || rootsite.RootBox == null) return false; int hvoRoot, frag; IVwViewConstructor vc; IVwStylesheet ss; rootsite.RootBox.GetRootObject(out hvoRoot, out vc, out frag, out ss); if (hvoRoot == 0) return false; if (FindReplaceDialog == null) { m_findReplaceDlg = new FwFindReplaceDlg(); ConfigureFindReplacedialog(); } bool fOverlay = (rootsite.RootBox.Overlay != null); if (m_findReplaceDlg.SetDialogValues(rootsite.Cache, FindPattern, rootsite, fReplace, fOverlay, rootsite.FindForm(), this, this)) { m_findReplaceDlg.Show(); return true; } return false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Close and remove the Find/Replace modeless dialog (result of LT-5702) /// </summary> /// ------------------------------------------------------------------------------------ public void RemoveFindReplaceDialog() { if (m_findReplaceDlg != null) { // Closing doesn't work as it tries to hide the dlg .. // so go for the .. dispose. It will do it 'base.Dispose()'! m_findReplaceDlg.Close(); m_findReplaceDlg.Dispose(); m_findReplaceDlg = 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 || m_beingDisposed) return; m_beingDisposed = true; UpdateAppRuntimeCounter(); if (disposing) { FwRegistrySettings.FirstTimeAppHasBeenRun = false; // Dispose managed resources here. Logger.ShutDown(); Application.ThreadException -= new ThreadExceptionEventHandler(HandleTopLevelError); List<IFwMainWnd> mainWnds = new List<IFwMainWnd>(m_rgMainWindows); // Use another array, since m_rgMainWindows may change. m_rgMainWindows.Clear(); // In fact, just clear the main array, so the windows won't have to worry so much. foreach (IFwMainWnd mainWnd in mainWnds) { if (mainWnd is Form) { Form wnd = (Form)mainWnd; wnd.Closing -= new CancelEventHandler(OnClosingWindow); wnd.Closed -= new EventHandler(OnWindowClosed); wnd.Activated -= new EventHandler(fwMainWindow_Activated); wnd.HandleDestroyed -= new EventHandler(fwMainWindow_HandleDestroyed); wnd.Dispose(); } else if (mainWnd is IDisposable) ((IDisposable)mainWnd).Dispose(); } if (m_caches != null) { foreach (FdoCache cache in m_caches.Values) cache.Dispose(); m_caches.Clear(); } if (m_findReplaceDlg != null) m_findReplaceDlg.Dispose(); #if DEBUG if (m_debugProcs != null) m_debugProcs.Dispose(); #endif // Close the splash screen if, for some reason, it's still hanging around. It // really shouldn't still be around by this time, except when some testing code // instantiates FwApp objects. This will make sure the splash screen goes away // when the FwApp object goes out of scope. CloseSplashScreen(); ResourceHelper.ShutdownHelper(); if (m_rgMainWindows != null) m_rgMainWindows.Clear(); if (m_commandLineArgs != null) m_commandLineArgs.Clear(); if (m_suppressedCaches != null) m_suppressedCaches.Clear(); if (m_refreshViewCaches != null) m_refreshViewCaches.Clear(); if (m_findPatterns != null) m_findPatterns.Clear(); Application.RemoveMessageFilter(this); } // Dispose unmanaged resources here, whether disposing is true or false. m_rgMainWindows = null; m_activeMainWindow = null; m_commandLineArgs = null; m_SplashScreenWnd = null; m_findPatterns = null; m_findReplaceDlg = null; m_suppressedCaches = null; m_refreshViewCaches = null; #if DEBUG m_debugProcs = null; #endif m_caches = null; s_app = null; m_isDisposed = true; m_beingDisposed = false; }