/// ----------------------------------------------------------------------------------- /// <summary> /// Clean up any resources being used. /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged /// resources; <c>false</c> to release only unmanaged resources. /// </param> /// ----------------------------------------------------------------------------------- protected override void Dispose( bool disposing ) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (IsDisposed) return; if (disposing) { if (m_messageFilterInstalled) { Application.RemoveMessageFilter(this); m_messageFilterInstalled = false; } // We don't want to call Controls.Clear() here, because that causes the controls // to change size (and fire the events for it...). It causes CreateMenuAndToolbars() // to be called, so we end up with two toolbar adapters, but we dispose only one, // so eventually it tries to access the already disposed mediator. //Controls.Clear(); // No, since m_bookMerger owns it. // if (m_differences != null) // m_differences.Dispose(); if (m_viewHelper != null) m_viewHelper.Dispose(); if (m_msgMediator != null) { m_msgMediator.RemoveColleague(this); // m_msgMediator gets disposed from calling components.Dispose() below } if (m_undoTaskHelper != null) m_undoTaskHelper.Dispose(); if(components != null) { components.Dispose(); } } // Deal with unmanaged stuff here. m_viewHelper = null; m_differences = null; // Just null it, since m_bookMerger owns it and will dispose it. m_msgMediator = null; m_bookMerger = null; // Client gave it, so it has to dispose it. m_cache = null; m_scr = null; m_stylesheet = null; m_undoTaskHelper = null; base.Dispose( disposing ); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="T:SplitGrid"/> class. /// </summary> /// <param name="cache">The cache.</param> /// <param name="styleSheet">The style sheet.</param> /// <param name="columns">The number of columns.</param> /// <param name="rows">The number of rows.</param> /// ------------------------------------------------------------------------------------ public SplitGrid(FdoCache cache, IVwStylesheet styleSheet, int rows, int columns) { m_cache = cache; m_StyleSheet = styleSheet; m_grid = CreateDataGridView(); m_defaultGroup = new RootSiteGroup(this); m_groups.Add(m_defaultGroup); m_activeViewHelper = new ActiveViewHelper(this); BorderStyle = BorderStyle.None; SuspendLayout(); m_grid.Dock = DockStyle.Fill; m_grid.BackgroundColor = SystemColors.Control; m_grid.BorderStyle = BorderStyle.None; m_grid.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; m_grid.SelectionMode = DataGridViewSelectionMode.CellSelect; m_grid.RowHeadersVisible = false; m_grid.ColumnHeadersVisible = false; m_grid.AllowUserToAddRows = false; m_grid.AllowUserToDeleteRows = false; m_grid.AllowUserToOrderColumns = false; m_grid.AdvancedCellBorderStyle.All = DataGridViewAdvancedCellBorderStyle.Outset; m_grid.AdvancedCellBorderStyle.Top = DataGridViewAdvancedCellBorderStyle.None; m_grid.ScrollBars = ScrollBars.None; m_grid.RowStateChanged += new DataGridViewRowStateChangedEventHandler(OnRowStateChanged); m_grid.ColumnStateChanged += new DataGridViewColumnStateChangedEventHandler(OnColumnStateChanged); m_grid.MouseDown += new MouseEventHandler(OnGridMouseDown); m_grid.MouseUp += new MouseEventHandler(OnGridMouseUp); m_grid.RowTemplate = new DataGridViewControlRow(); for (int i = 0; i < columns; i++) { DataGridViewControlColumn column = new DataGridViewControlColumn(i == columns - 1); m_grid.Columns.Add(column); } m_MaxRows = rows; Controls.Add(m_grid); ResumeLayout(true); m_grid.BringToFront(); Visible = false; }
/// ----------------------------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="DiffDialog"/> class. /// </summary> /// <param name="bookMerger"></param> /// <param name="cache"></param> /// <param name="stylesheet"></param> /// <param name="zoomFactorDraft">The zoom percentage to be used for the "draft" (i.e., /// main Scripture) view</param> /// <param name="zoomFactorFootnote">The zoom percentage to be used for the "footnote" /// view</param> /// <param name="fDoCollapseUndo">true if we want to collapse to a single Undo item on close.</param> /// ----------------------------------------------------------------------------------- public DiffDialog(BookMerger bookMerger, FdoCache cache, IVwStylesheet stylesheet, float zoomFactorDraft, float zoomFactorFootnote, bool fDoCollapseUndo) { Debug.Assert(cache != null); m_viewHelper = new ActiveViewHelper(this); m_fDoCollapseUndo = fDoCollapseUndo; // Required for Windows Form Designer support InitializeComponent(); // just as fallback in case the Designer replaced FwContainer with Container // in InitializeComponent()... if (!(components is FwContainer)) components = new FwContainer(components); // the last column of the table layout manager in the last row should have the // width of the scroll bar TableLayoutPanel tablePanel = tableLayoutPanel.GetControlFromPosition(0, 3) as TableLayoutPanel; tablePanel.ColumnStyles[3].Width = SystemInformation.VerticalScrollBarWidth - SystemInformation.FixedFrameBorderSize.Width; tablePanel = tableLayoutPanel.GetControlFromPosition(1, 3) as TableLayoutPanel; tablePanel.ColumnStyles[3].Width = SystemInformation.VerticalScrollBarWidth - SystemInformation.FixedFrameBorderSize.Width; m_msgMediator = new Mediator(); m_msgMediator.AddColleague(this); components.Add(m_msgMediator); m_bookMerger = bookMerger; m_differences = bookMerger.Differences; m_cache = cache; m_scr = m_cache.LangProject.TranslatedScriptureOA; m_stylesheet = stylesheet; m_zoomFactorDraft = zoomFactorDraft; m_zoomFactorFootnote = zoomFactorFootnote; // Don't start out in edit mode m_editMode = false; // If the diff is a comparison of the current against a normal saved version, then // change the label text. ScrDraft draft = new ScrDraft(m_cache, m_bookMerger.BookRev.OwnerHVO); if (draft.Type == ScrDraftType.SavedVersion) { lblSavedVersion.Text = string.Format(TeDiffViewResources.kstidSavedVersion, draft.Description); } else lblSavedVersion.Text = string.Format(lblSavedVersion.Text, draft.Description); CreateUndoMark(); }
/// ----------------------------------------------------------------------------------- /// <summary> /// Clean up any resources being used. /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged /// resources; <c>false</c> to release only unmanaged resources. /// </param> /// ----------------------------------------------------------------------------------- protected override void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (IsDisposed) return; if (disposing) { if (m_viewHelper != null) m_viewHelper.Dispose(); if (m_app != null) { // The removing of the window needs to happen later; after this main window is // already disposed of. This is needed for side-effects that require a running // message loop (such as closing the TE notes view which would normally // happen at this call without a running message loop) m_app.FwManager.ExecuteAsync(m_app.RemoveWindow, this); } } // NOTE: base.Dispose() may need the FdoCache which RemoveWindow() wants to delete. base.Dispose(disposing); m_viewHelper = null; m_delegate = null; }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// <param name="disposing"></param> /// ------------------------------------------------------------------------------------ protected override void Dispose(bool disposing) { System.Diagnostics.Debug.WriteLineIf(!disposing, "****** Missing Dispose() call for " + GetType().Name + ". ****** "); if (disposing) { if (m_groups != null) { foreach (RootSiteGroup group in m_groups) group.Dispose(); m_groups.Clear(); if (Parent != null && Parent is Form) ((Form)Parent).Shown -= new EventHandler(OnShown); // m_grid will be disposed from base class } if (m_activeViewHelper != null) m_activeViewHelper.Dispose(); } m_groups = null; m_grid = null; m_StyleSheet = null; m_cache = null; m_activeViewHelper = null; base.Dispose(disposing); }
/// ----------------------------------------------------------------------------------- /// <summary> /// Clean up any resources being used. /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged /// resources; <c>false</c> to release only unmanaged resources. /// </param> /// ----------------------------------------------------------------------------------- protected override void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (IsDisposed) return; FdoCache wndCache = null; if (disposing) { if (m_delegate != null) m_delegate.Dispose(); if (m_viewHelper != null) m_viewHelper.Dispose(); if (FwApp.App != null) { FwApp.App.OkToCloseApp = false; FwApp.App.RemoveWindow(this, out wndCache); } } // NOTE: base.Dispose() may need the FdoCache which RemoveWindow() wants to delete. base.Dispose(disposing); if (disposing) { if (FwApp.App != null) { FwApp.App.OkToCloseApp = true; if (wndCache != null) FwApp.App.RemoveFdoCache(wndCache); } } m_viewHelper = null; m_delegate = null; IncomingLinkHandler = null; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Construct a new form /// </summary> /// <param name="app">The app.</param> /// <param name="wndCopyFrom">Source window to copy from</param> /// <param name="iconStream">The icon stream.</param> /// <param name="configFile">The config file.</param> /// <param name="startupLink">The link to follow once the window is initialized.</param> /// <param name="inAutomatedTest">if set to <c>true</c>, (well behaved) code will avoid /// bringing up dialogs that we cannot respond to (like confirmation and error dialogs) /// and it should cause the system to avoid saving the settings to a file (or at least /// saving them in some special way so as not to mess up the user.)</param> /// ------------------------------------------------------------------------------------ public FwXWindow(FwApp app, Form wndCopyFrom, Stream iconStream, string configFile, FwLinkArgs startupLink, bool inAutomatedTest) { BasicInit(app); m_startupLink = startupLink; Debug.Assert(File.Exists(configFile)); m_app = app; m_configFile = configFile; Init(iconStream, wndCopyFrom, app.Cache); if(inAutomatedTest) { Mediator.PropertyTable.SetProperty("DoingAutomatedTest", true); Mediator.PropertyTable.SetPropertyPersistence("DoingAutomatedTest", false); } // The order of the next two lines has been changed because the loading of the UI // properly depends on m_viewHelper being initialized. Why this was not so with DNB // I do not know. // Here is the orginal order (along with a comment between them that seemed to imply this // new order could be a problem, but no obvious ones have appeared in my testing. /* * LoadUI(configFile); * // Reload additional property settings that depend on knowing the database name. * m_viewHelper = new ActiveViewHelper(this); */ m_viewHelper = new ActiveViewHelper(this); LoadUI(configFile); m_viewHelper.ActiveViewChanged += new EventHandler<EventArgs>(ActiveViewChanged); }
/// <summary> /// Construct a new form /// </summary> /// <param name="cache"></param> /// <param name="wndCopyFrom">Source window to copy from</param> /// <param name="iconStream"></param> /// <param name="configFile"></param> /// <param name="app"></param> /// <param name="inAutomatedTest"></param> public FwXWindow(FdoCache cache, Form wndCopyFrom, Stream iconStream, string configFile, bool inAutomatedTest) { BasicInit(); int dbversion, cobjects, mdfSize, ldfSize; DbOps.ReadOneIntFromCommand(cache, "select DbVer from version$", null, out dbversion); DbOps.ReadOneIntFromCommand(cache, "select count(id) from CmObject", null, out cobjects); DbOps.ReadOneIntFromCommand(cache, "select size from dbo.sysfiles where fileid = 1", null, out mdfSize); DbOps.ReadOneIntFromCommand(cache, "select size from dbo.sysfiles where fileid = 2", null, out ldfSize); // REVIEW (EberhardB): This doesn't work if you have multiple databases open because // the properties are stored in static variables. Opening a second database overwrites // the values from the first database! // DB: TestLangProj, Ver: 200129, CmObjects: 55105, Mdf size: 5256, Ldf size: 1280 SIL.Utils.ErrorReporter.AddProperty("DB", cache.DatabaseName + ", Ver: " + dbversion + ", CmObjects: " + cobjects + ", Mdf size: " + (mdfSize * 8) + "K, Ldf size: " + (ldfSize * 8) + "K"); SIL.Utils.ErrorReporter.AddProperty("LangProject", cache.LangProject.Name.AnalysisDefaultWritingSystem); Debug.Assert(File.Exists(configFile)); m_configFile = configFile; Init(iconStream, wndCopyFrom, cache); if(inAutomatedTest) { //this should cause (well behaved) code to avoid bringing up dialogs // that we cannot respond to (like confirmation and error dialogs) //and it should cause the system to avoid saving the settings to a file (or at least //saving them in some special way so as not to mess up the user.) Mediator.PropertyTable.SetProperty("DoingAutomatedTest", true); Mediator.PropertyTable.SetPropertyPersistence("DoingAutomatedTest", false); } LoadUI(configFile); // Reload additional property settings that depend on knowing the database name. m_viewHelper = new ActiveViewHelper(this); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Clean up any resources being used. /// </summary> /// ------------------------------------------------------------------------------------ protected override void Dispose(bool disposing) { Debug.WriteLineIf(!disposing, "****************** Missing Dispose() call for " + GetType().Name + ". ******************"); // Must not be run more than once. if (IsDisposed || m_beingDisposed || Disposing) return; m_beingDisposed = true; if (disposing) { foreach (Control ctrl in m_rgClientViews.Values) { // Dispose of any views that aren't in the form currently. if (ctrl.Parent == null) ctrl.Dispose(); } if (m_mediator != null) { m_mediator.ProcessMessages = false; m_mediator.RemoveColleague(this); } if (m_cboZoomPercent != null) m_cboZoomPercent.Dispose(); if (m_paraStylesComboBox != null) m_paraStylesComboBox.Dispose(); if (m_charStylesComboBox != null) m_charStylesComboBox.Dispose(); if (m_writingSystemSelector != null) m_writingSystemSelector.Dispose(); if (m_progressHandler != null) m_progressHandler.Dispose(); if (m_writingSystemSelector != null) m_writingSystemSelector.Dispose(); if (m_UndoRedoDropDown != null) m_UndoRedoDropDown.Dispose(); if (components != null) components.Dispose(); // no need to explicitly call Dispose on m_persistence - it's part of // components collection and gets disposed there. if (m_rgClientViews != null) m_rgClientViews.Clear(); if (m_tmAdapter != null) { m_tmAdapter.LoadControlContainerItem -= LoadCustomToolBarControls; m_tmAdapter.InitializeComboItem -= InitializeToolBarCombos; m_tmAdapter.Dispose(); } if (m_cache != null) m_cache.ProjectNameChanged -= ProjectNameChanged; if (m_app != null) { // The removing of the window from the app's collection needs to happen later, after // this main window is already disposed of. This is needed for side-effects // that require a running message loop (such as closing the TE notes view // which would normally happen at this call without a running message loop) m_app.FwManager.ExecuteAsync(m_app.RemoveWindow, this); } } m_cboZoomPercent = null; m_paraStylesComboBox = null; m_charStylesComboBox = null; m_writingSystemSelector = null; m_delegate = null; m_tmAdapter = null; m_UndoRedoDropDown = null; m_writingSystemSelector = null; m_StyleSheet = null; m_selectedView = null; m_rgClientViews = null; #if !__MonoCS__ base.Dispose(disposing); #else try { base.Dispose(disposing); } catch (System.ArgumentOutOfRangeException) { // TODO-Linux: examine ToolStrip disposal in UIAdapter // is ToolStrip (from UIAdapter?) being Disposed multiple times? } #endif if (disposing) { if (m_viewHelper != null) m_viewHelper.Dispose(); if (m_mediator != null) m_mediator.Dispose(); } m_cache = null; m_viewHelper = null; m_mediator = null; m_app = null; m_beingDisposed = false; }
/// ----------------------------------------------------------------------------------- /// <summary> /// Default constructor for FwMainWnd. /// </summary> /// ----------------------------------------------------------------------------------- protected FwMainWnd() { // // Required for Windows Form Designer support // InitializeComponent(); m_mediator = new Mediator(); m_delegate = new MainWindowDelegate(this); // m_Resources = new System.Resources.ResourceManager(typeof(FwMainWnd)); m_rgClientViews = new Dictionary<string, IRootSite>(); m_viewHelper = new ActiveViewHelper(this); m_progressHandler = new StatusBarProgressHandler(statusBarFwPanel1, ProgressPanel); // Set the width of the side bar splitContainer.MaxFirstPanePercentage = 0.5f; splitContainer.SplitterDistance = kDefaultSideBarWidth; splitContainer.SettingsKey = SettingsKey; Debug.Assert(components is FwContainer, "Member variable components should be of " + "type FwContainer. If the Designer changed it, please change it back!"); if (!(components is FwContainer)) components = new FwContainer(components); // Add this as a component so that children can retrieve services components.Add(this); }
/// ------------------------------------------------------------------------------------ /// <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. ******************"); // Must not be run more than once. if (IsDisposed) return; if (disposing) { // Dispose managed resources here. Debug.Assert(m_scrollingController == null || Controls.Contains(m_scrollingController as Control)); if (m_slaves != null) { // We need to close all of the rootboxes because when controls are // destroyed they cause the other controls still on the parent to // resize. If the rootbox is sync'd with other views then the other // views will try to layout their rootboxes. This is BAD!!! :) foreach (RootSite site in m_slaves) site.CloseRootBox(); foreach (Control ctrl in m_slaves) { if (!Controls.Contains(ctrl)) ctrl.Dispose(); } } if (m_slaves != null) m_slaves.Clear(); } // Dispose unmanaged resources here, whether disposing is true or false. m_slaves = null; if (m_sync != null) { Marshal.ReleaseComObject(m_sync); m_sync = null; } m_activeViewHelper = null; m_scrollingController = null; base.Dispose(disposing); }
/// ------------------------------------------------------------------------------------ /// <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 || m_beingDisposed || Disposing) return; m_beingDisposed = true; FdoCache wndCache = null; if (disposing) { foreach (Control ctrl in m_rgClientWindows.Values) { // Dispose of any views that aren't in the form currently. if (ctrl.Parent == null) ctrl.Dispose(); } if (m_mediator != null) { m_mediator.ProcessMessages = false; m_mediator.RemoveColleague(this); } if (m_writingSystemSelector != null) m_writingSystemSelector.Dispose(); if (m_UndoRedoDropDown != null) m_UndoRedoDropDown.Dispose(); if (components != null) components.Dispose(); // no need to explicitly call Dispose on m_persistence - it's part of // components collection and gets disposed there. if (m_delegate != null) m_delegate.Dispose(); if (m_rgClientWindows != null) m_rgClientWindows.Clear(); if (m_cache != null && m_cache.ProgressBar == m_progressHandler) m_cache.ProgressBar = null; if (FwApp.App != null) { FwApp.App.OkToCloseApp = false; // Make sure we don't shutdown too soon FwApp.App.RemoveWindow(this, out wndCache); } } m_delegate = null; m_UndoRedoDropDown = null; m_writingSystemSelector = null; m_StyleSheet = null; m_selectedView = null; m_rgClientWindows = null; base.Dispose(disposing); if (disposing) { if (m_viewHelper != null) m_viewHelper.Dispose(); if (m_mediator != null) m_mediator.Dispose(); if (FwApp.App != null) { // Remove the cache as the last step. Hopefully this will fix some // ObjectDisposed exceptions we get but can't reproduce. (TE-8340) FwApp.App.OkToCloseApp = true; if (wndCache != null) FwApp.App.RemoveFdoCache(wndCache); } } m_cache = null; m_viewHelper = null; m_mediator = null; m_beingDisposed = false; }