/// ------------------------------------------------------------------------------------
/// <summary>
/// Prepares the selected files to be uploaded to REAP using RAMP.
/// </summary>
/// <param name="owner">RAMP dialog owner</param>
/// <param name="dialogFont">RAMP dialog font (for localization and consistency)</param>
/// <param name="localizationDialogIcon"></param>
/// <param name="filesToArchive"></param>
/// <param name="mediator"></param>
/// <param name="thisapp"></param>
/// <param name="cache"></param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
public bool ArchiveNow(Form owner, Font dialogFont, Icon localizationDialogIcon,
IEnumerable<string> filesToArchive, Mediator mediator, FwApp thisapp, FdoCache cache)
{
var viProvider = new VersionInfoProvider(Assembly.LoadFile(thisapp.ProductExecutableFile), false);
var wsMgr = cache.ServiceLocator.GetInstance<IWritingSystemManager>();
var appName = thisapp.ApplicationName;
var title = cache.LanguageProject.ShortName;
var uiLocale = wsMgr.Get(cache.DefaultUserWs).IcuLocale;
var projectId = cache.LanguageProject.ShortName;
var model = new RampArchivingDlgViewModel(Application.ProductName, title, projectId, /*appSpecificArchivalProcessInfo:*/ string.Empty, SetFilesToArchive(filesToArchive), GetFileDescription);
// image files should be labeled as Graphic rather than Photograph (the default).
model.ImagesArePhotographs = false;
// show the count of media files, not the duration
model.ShowRecordingCountNotLength = true;
// set the general description, in each available language
IMultiString descr = cache.LanguageProject.Description;
var descriptions = new Dictionary<string, string>();
foreach (int wsid in descr.AvailableWritingSystemIds)
{
var descrText = descr.get_String(wsid).Text;
if ((!string.IsNullOrEmpty(descrText)) && (descrText != "***"))
descriptions[wsMgr.Get(wsid).GetIso3Code()] = descrText;
}
if (descriptions.Count > 0)
model.SetDescription(descriptions);
AddMetsPairs(model, viProvider.ShortNumericAppVersion, cache);
const string localizationMgrId = "Archiving";
if (s_localizationMgr == null)
{
s_localizationMgr = LocalizationManager.Create(
uiLocale,
localizationMgrId, viProvider.ProductName, viProvider.NumericAppVersion,
FwDirectoryFinder.GetCodeSubDirectory("ArchivingLocalizations"),
Path.Combine(Application.CompanyName, appName),
localizationDialogIcon, "*****@*****.**", "SIL.Archiving");
}
else
{
LocalizationManager.SetUILanguage(uiLocale, true);
}
// create the dialog
using (var dlg = new ArchivingDlg(model, localizationMgrId, dialogFont, new FormSettings()))
using (var reportingAdapter = new PalasoErrorReportingAdapter(dlg, mediator))
{
ErrorReport.SetErrorReporter(reportingAdapter);
dlg.ShowDialog(owner);
ErrorReport.SetErrorReporter(null);
}
return true;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Perform one-time initialization of a new Scripture project
/// </summary>
/// <param name="cache">The database cache</param>
/// <param name="app">The TE application.</param>
/// <param name="progressDlg">The progress dialog (can be null).</param>
/// <returns>
/// true if data loaded successfully; false, otherwise
/// </returns>
/// ------------------------------------------------------------------------------------
public static bool Initialize(FdoCache cache, FwApp app,
IThreadedProgress progressDlg)
{
TeScrInitializer scrInitializer = new TeScrInitializer(cache);
scrInitializer.m_app = app;
return scrInitializer.Initialize(progressDlg);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="FwRegistrySettings"/> class.
/// </summary>
/// <param name="app">The application.</param>
/// ------------------------------------------------------------------------------------
public FwRegistrySettings(FwApp app)
{
if (app == null)
throw new ArgumentNullException("app");
m_firstTimeAppHasBeenRun = new RegistryBoolSetting(app.SettingsKey, "FirstTime", true);
m_showSideBar = new RegistryBoolSetting(app.SettingsKey, "ShowSideBar", true);
m_showStatusBar = new RegistryBoolSetting(app.SettingsKey, "ShowStatusBar", true);
m_openLastEditedProject = new RegistryBoolSetting(app.SettingsKey, "OpenLastEditedProject", false);
m_loadingProcessId = new RegistryIntSetting(app.SettingsKey, "LoadingProcessId", 0);
m_numberOfLaunches = new RegistryIntSetting(app.SettingsKey, "launches", 0);
m_numberOfSeriousCrashes = new RegistryIntSetting(app.SettingsKey, "NumberOfSeriousCrashes", 0);
m_numberOfAnnoyingCrashes = new RegistryIntSetting(app.SettingsKey, "NumberOfAnnoyingCrashes", 0);
m_totalAppRuntime = new RegistryIntSetting(app.SettingsKey, "TotalAppRuntime", 0);
m_appStartupTime = new RegistryStringSetting(app.SettingsKey, "LatestAppStartupTime", string.Empty);
m_latestProject = new RegistryStringSetting(app.SettingsKey, "LatestProject", string.Empty);
m_latestServer = new RegistryStringSetting(app.SettingsKey, "LatestServer", string.Empty);
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="NotesMainWnd"/> class.
/// </summary>
/// <param name="app">The app</param>
/// <param name="stylesheet">The stylesheet</param>
/// <param name="zoomPercent">The zoom percentage</param>
/// -----------------------------------------------------------------------------------
public NotesMainWnd(FwApp app, FwStyleSheet stylesheet, float zoomPercent) : base(app, null)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
Name = "NotesMainWnd";
m_zoomPercent = zoomPercent;
m_scr = m_app.Cache.LangProject.TranslatedScriptureOA;
m_StyleSheet = stylesheet;
SetupSideBarInfoBar();
AddFilters();
// Save the max. width for the sidebar and set it to the default width.
// m_maxSideBarWidth = m_sideBarContainer.Width;
m_sideBarContainer.Width = kDefaultSideBarWidth;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Shows an instance of this dialog on a separate thread.
/// </summary>
/// <param name="args">The application arguments</param>
/// <param name="whatToWaitFor">The condition we're waiting for.</param>
/// <param name="appToStart">The application to start.</param>
/// <param name="appToWaitFor">The application to wait for (null if waiting for
/// WindowToActivate).</param>
/// ------------------------------------------------------------------------------------
internal static void ShowOnSeparateThread(FwAppArgs args, WaitFor whatToWaitFor,
FwApp appToStart, FwApp appToWaitFor)
{
if (whatToWaitFor != WaitFor.WindowToActivate && appToWaitFor == null)
throw new ArgumentNullException("appToWaitFor");
if (appToStart == null)
throw new ArgumentNullException("appToStart");
ApplicationBusyDialog dlg = new ApplicationBusyDialog();
dlg.m_whatToWaitFor = whatToWaitFor;
dlg.m_args = args;
dlg.m_appToStart = appToStart;
dlg.m_appToWaitFor = appToWaitFor;
Thread thread = new Thread(dlg.WaitForOtherApp);
thread.IsBackground = true;
thread.SetApartmentState(ApartmentState.STA);
thread.Name = "WaitForOtherBusyApp";
thread.CurrentUICulture = Thread.CurrentThread.CurrentUICulture;
thread.Start();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Perform a Paratext streamlined import
/// </summary>
/// <param name="mainWnd">The main window.</param>
/// <param name="stylesheet">The Scripture stylesheet.</param>
/// <param name="app">The app.</param>
/// <returns><c>true</c> if something got imported; <c>false</c> otherwise</returns>
/// ------------------------------------------------------------------------------------
public static bool ImportParatext(Form mainWnd, FwStyleSheet stylesheet, FwApp app)
{
TeImportManager mgr = new TeImportManager(mainWnd, stylesheet, app, true);
return mgr.ImportSf();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="TeImportManager"/> class.
/// </summary>
/// <param name="mainWnd">The main window initiating the import</param>
/// <param name="styleSheet">The stylesheet.</param>
/// <param name="app">The app.</param>
/// <param name="fParatextStreamlinedImport">if set to <c>true</c> do a Paratext
/// streamlined import (minimal UI).</param>
/// ------------------------------------------------------------------------------------
internal TeImportManager(Form mainWnd, FwStyleSheet styleSheet, FwApp app,
bool fParatextStreamlinedImport)
: this(app.Cache, styleSheet, app, fParatextStreamlinedImport)
{
m_mainWnd = mainWnd;
m_importCallbacks = new DummyImportCallbacks();
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// Construct a new form
/// </summary>
/// <param name="app">the app.</param>
/// <param name="wndCopyFrom">Source window to copy from.</param>
/// <param name="iconStream"></param>
/// <param name="configStream"></param>
/// -----------------------------------------------------------------------------------
public FwXWindow(FwApp app, Form wndCopyFrom, Stream iconStream,
Stream configStream) : this()
{
m_app = app;
m_configFile = null;
Init(iconStream, wndCopyFrom, app.Cache);
LoadUI(configStream);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Closes all main windows for the specified application ignoring any errors that
/// occur.
/// </summary>
/// <param name="app">The application.</param>
/// ------------------------------------------------------------------------------------
private static void CloseAllMainWindowsForApp(FwApp app)
{
if (app == null)
return;
foreach (Form mainWnd in app.MainWindows.OfType<Form>())
{
if (mainWnd.IsDisposed)
continue; // This can happen in renaming.
// This is typically used if an exception happens to gracefully close any
// open main windows so we need to ignore any errors because we have no
// idea what state the application is in.
Form wnd = mainWnd;
mainWnd.Invoke((Action) (() => ExceptionHelper.LogAndIgnoreErrors(wnd.Close)));
}
}
public RestoreDefaultsDlg(FwApp app) : this()
{
m_app = app;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// C'tor for TESTING with MockFwXWindow
/// </summary>
/// <param name="app"></param>
/// <param name="configFile">Only sets the member variable here, does NOT load UI.</param>
/// ------------------------------------------------------------------------------------
public FwXWindow(FwApp app, string configFile)
{
BasicInit(app);
Debug.Assert(File.Exists(configFile));
m_app = app;
m_configFile = configFile;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the status of the previous attempt to startup the specified application.
/// </summary>
/// <param name="app">The application.</param>
/// ------------------------------------------------------------------------------------
private static StartupStatus GetPreviousStartupStatus(FwApp app)
{
int loadingId = app.RegistrySettings.LoadingProcessId;
if (loadingId > 0)
{
// The last attempt to load the application never finished. We need to decide
// if it didn't finish because of a crash or if its still in the process of
// loading.
return ExistingProcesses.Any(process => process.Id == loadingId) ?
StartupStatus.StillLoading : StartupStatus.Failed;
}
return StartupStatus.Successful;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="IgnoreAppMessageProccessing"/> class.
/// </summary>
/// <param name="instance">The FwApp.</param>
/// ------------------------------------------------------------------------------------
public IgnoreAppMessageProccessing(FwApp instance)
{
if (instance == null)
return;
m_app = instance;
try
{
foreach (IFwMainWnd mainWnd in instance.MainWindows)
{
if (mainWnd is FwMainWnd)
{
m_oldPrsMsgsVals[mainWnd] = ((FwMainWnd)mainWnd).Mediator.ProcessMessages;
((FwMainWnd)mainWnd).Mediator.ProcessMessages = false;
}
}
}
catch
{
// This is only used when bringing up the error dialog. We don't want to bother
// with this exception since we have no idea what state the application is in.
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Shutdowns the specified application. The application will be disposed of immediately.
/// If no other applications are running, then FieldWorks will also be shutdown.
/// </summary>
/// <param name="app">The application to shut down.</param>
/// <param name="fSaveSettings">True to have the application save its settings,
/// false otherwise</param>
/// ------------------------------------------------------------------------------------
internal static void ShutdownApp(FwApp app, bool fSaveSettings)
{
if (app != s_teApp && app != s_flexApp)
throw new ArgumentException("Application must belong to this FieldWorks", "app");
if (fSaveSettings)
app.SaveSettings();
if (s_activeMainWnd != null && app.MainWindows.Contains(s_activeMainWnd))
{
// The application that owns the active main window is being disposed. This
// means that the window is, most likely, already disposed.
s_activeMainWnd = null;
}
RecordLastAppForProject();
if (app == s_teApp)
s_teApp = null;
else if (app == s_flexApp)
s_flexApp = null;
// Make sure we do this after we set the variables to null to keep a race condition
// from happening where we want to GetOrCreateApplication() for the app that is
// being disposed.
try
{
app.Dispose();
}
catch
{
// continue shutdown even with an exception. It's possible we're shutting down because
// of a crash and we don't know what state the application is in.
}
ExitIfNoAppsRunning();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Attempts to shut down the specified application as nicely as possible ignoring any
/// errors that occur.
/// </summary>
/// <param name="app">The application.</param>
/// ------------------------------------------------------------------------------------
private static void GracefullyShutDownApp(FwApp app)
{
if (app == null)
return;
// This is typically used if an exception happens so we need to ignore any errors
// because we have no idea what state the application is in.
ExceptionHelper.LogAndIgnoreErrors(() => ShutdownApp(app, false));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes the specified application and creates a new main window for it. Also
/// does application-specific cache initialization.
/// </summary>
/// <param name="app">The application</param>
/// <param name="progressDlg">The progress dialog.</param>
/// <returns>True if the application was started successfully, false otherwise</returns>
/// ------------------------------------------------------------------------------------
private static bool InitializeApp(FwApp app, IThreadedProgress progressDlg)
{
using (new DataUpdateMonitor(null, "Application Initialization"))
app.DoApplicationInitialization(progressDlg);
using (new DataUpdateMonitor(null, "Loading Application Settings"))
app.LoadSettings();
using (NonUndoableUnitOfWorkHelper undoHelper = new NonUndoableUnitOfWorkHelper(
s_cache.ServiceLocator.GetInstance<IActionHandler>()))
using (new DataUpdateMonitor(null, "Application Cache Initialization"))
{
try
{
if (!app.InitCacheForApp(progressDlg))
throw new StartupException(Properties.Resources.kstidCacheInitFailure);
}
catch (Exception e)
{
if (e is StartupException)
throw;
throw new StartupException(Properties.Resources.kstidCacheInitFailure, e, true);
}
undoHelper.RollBack = false;
}
if (s_cache.ServiceLocator.GetInstance<IUndoStackManager>().HasUnsavedChanges)
{
if (progressDlg != null)
{
progressDlg.Message = String.Format(Properties.Resources.kstidSaving, s_cache.ProjectId.UiName);
progressDlg.IsIndeterminate = true;
}
s_cache.ServiceLocator.GetInstance<IUndoStackManager>().Save();
if (progressDlg != null)
progressDlg.IsIndeterminate = false;
}
return CreateAndInitNewMainWindow(app, true, null, false);
}
private static bool InitializeFirstApp(FwApp app, ProjectId projectId)
{
Debug.Assert(s_cache == null && s_projectId == null, "This should only get called once");
Debug.Assert(projectId != null, "Should have exited the program");
using (var process = Process.GetCurrentProcess())
{
app.RegistrySettings.LoadingProcessId = process.Id;
}
if (String.IsNullOrEmpty(app.RegistrySettings.LatestProject))
{
// Until something gets saved, we will keep track of the first project opened.
app.RegistrySettings.LatestProject = projectId.Handle;
app.RegistrySettings.LatestServer = projectId.ServerName ?? string.Empty;
}
UsageEmailDialog.IncrementLaunchCount(app.SettingsKey); // count launches for bug reporting
ShowSplashScreen(app);
try
{
// Create the cache and let the application init the cache for what it needs
s_cache = CreateCache(projectId);
Debug.Assert(s_cache != null, "At this point we should know which project to load and have loaded it!");
if (s_noUserInterface || InitializeApp(app, s_splashScreen))
{
app.RegistrySettings.LoadingProcessId = 0;
#if !__MonoCS__
if (!WindowsInstallerQuery.IsThisInstalled() || app.ActiveMainWindow == null)
return true;
// Initialize NetSparkle to check for updates:
Settings.Default.IsBTE = WindowsInstallerQuery.IsThisBTE();
var appCastUrl = Settings.Default.IsBTE
? (Settings.Default.CheckForBetaUpdates
? CoreImpl.Properties.Resources.ResourceManager.GetString("kstidAppcastBteBetasUrl")
: CoreImpl.Properties.Resources.ResourceManager.GetString("kstidAppcastBteUrl"))
: (Settings.Default.CheckForBetaUpdates
? CoreImpl.Properties.Resources.ResourceManager.GetString("kstidAppcastSeBetasUrl")
: CoreImpl.Properties.Resources.ResourceManager.GetString("kstidAppcastSeUrl"));
var sparkle = SingletonsContainer.Get("Sparkle", () => new Sparkle(appCastUrl, app.ActiveMainWindow.Icon));
sparkle.AboutToExitForInstallerRun += delegate(object sender, CancelEventArgs args)
{
CloseAllMainWindows();
if(app.ActiveMainWindow != null)
{
args.Cancel = true;
}
};
if (Settings.Default.AutoCheckForUpdates)
sparkle.CheckOnFirstApplicationIdle();
#endif
return true;
}
}
catch (UnauthorizedAccessException uae)
{
if (MiscUtils.IsUnix)
{
// Tell Mono user he/she needs to logout and log back in
MessageBox.Show(ResourceHelper.GetResourceString("ksNeedToJoinFwGroup"));
}
throw;
}
catch (FdoDataMigrationForbiddenException)
{
// tell the user to close all other applications using this project
MessageBox.Show(ResourceHelper.GetResourceString("kstidDataMigrationProhibitedText"),
ResourceHelper.GetResourceString("kstidDataMigrationProhibitedCaption"), MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
CloseSplashScreen();
}
return false;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets an existing app or creates a new one for the application type specified on
/// the command line.
/// </summary>
/// <param name="args">The application arguments.</param>
/// <returns>An app to use (can be null if no valid app was specified)</returns>
/// ------------------------------------------------------------------------------------
private static FwApp GetOrCreateApplication(FwAppArgs args)
{
var appAbbrev = args.AppAbbrev;
if (String.IsNullOrEmpty(appAbbrev))
{
// Probably a double-click of the data file. See if we can figure out who last had it open.
appAbbrev = GetDefaultApp(args);
}
if (appAbbrev.Equals(FwUtils.ksTeAbbrev, StringComparison.InvariantCultureIgnoreCase))
{
if (FwUtils.IsTEInstalled)
{
if (s_teApp == null)
{
s_teApp = (FwApp)DynamicLoader.CreateObject(FwDirectoryFinder.TeDll,
FwUtils.ksFullTeAppObjectName, s_fwManager, GetHelpTopicProvider(appAbbrev), args);
s_teAppKey = s_teApp.SettingsKey;
}
return s_teApp;
}
}
else if (appAbbrev.Equals(FwUtils.ksFlexAbbrev, StringComparison.InvariantCultureIgnoreCase))
{
if (FwUtils.IsFlexInstalled)
{
if (s_flexApp == null)
{
s_flexApp = (FwApp)DynamicLoader.CreateObject(FwDirectoryFinder.FlexDll,
FwUtils.ksFullFlexAppObjectName, s_fwManager, GetHelpTopicProvider(appAbbrev), args);
s_flexAppKey = s_flexApp.SettingsKey;
}
return s_flexApp;
}
}
ShowCommandLineHelp();
return null;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Import an OXES (Open XML for Editing Scripture) file.
/// </summary>
/// <param name="mainWnd">The main WND.</param>
/// <param name="importCallbacks">The import callbacks.</param>
/// <param name="app">The app.</param>
/// ------------------------------------------------------------------------------------
public static void ImportXml(FwMainWnd mainWnd, ITeImportCallbacks importCallbacks,
FwApp app)
{
TeImportManager mgr = new TeImportManager(mainWnd, importCallbacks, app, false);
mgr.ImportXml();
}
private static void WarnUserAboutFailedLiftImportIfNecessary(FwApp fwApp)
{
var mainWindow = fwApp.ActiveMainWindow as IFwMainWnd;
if(mainWindow != null)
{
mainWindow.Mediator.SendMessage("WarnUserAboutFailedLiftImportIfNecessary", null);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="TeImportManager"/> class.
/// </summary>
/// <param name="mainWnd">The main window initiating the import</param>
/// <param name="importCallbacks">The import callbacks.</param>
/// <param name="app">The app.</param>
/// <param name="fParatextStreamlinedImport">if set to <c>true</c> do a Paratext
/// streamlined import (minimal UI).</param>
/// ------------------------------------------------------------------------------------
internal TeImportManager(FwMainWnd mainWnd, ITeImportCallbacks importCallbacks,
FwApp app, bool fParatextStreamlinedImport)
: this(app.Cache, mainWnd.StyleSheet, app, fParatextStreamlinedImport)
{
m_mainWnd = mainWnd;
m_importCallbacks = importCallbacks;
}
public void SetUp()
{
CheckDisposed();
m_inMemoryCache = InMemoryFdoCache.CreateInMemoryFdoCache();
m_mainWnd = new DynamicMock(typeof(IFwMainWnd));
m_mainWnd.SetupResult("Cache", Cache);
m_app = new DummyFwApp();
}
private void BasicInit(FwApp app)
{
m_delegate = new MainWindowDelegate(this);
m_delegate.App = app;
m_mediator.HelpTopicProvider = app;
m_mediator.FeedbackInfoProvider = app;
m_mediator.PropertyTable.SetProperty("App", app);
m_mediator.PropertyTable.SetPropertyPersistence("App", false);
string path = null;
if (app != null) // if configFile in FwXApp == null
{
path = FdoFileHelper.GetConfigSettingsDir(app.Cache.ProjectId.ProjectFolder);
Directory.CreateDirectory(path);
}
m_mediator.PropertyTable.UserSettingDirectory = path;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Moves the external link directory and files to the new FW 7.0 or later location.
/// </summary>
/// <param name="app">The application.</param>
/// ------------------------------------------------------------------------------------
private static void MoveExternalLinkDirectoryAndFiles(FwApp app)
{
var sLinkedFilesRootDir = app.Cache.LangProject.LinkedFilesRootDir;
NonUndoableUnitOfWorkHelper.Do(app.Cache.ActionHandlerAccessor, () =>
{
app.Cache.LangProject.LinkedFilesRootDir = FdoFileHelper.GetDefaultLinkedFilesDir(
app.Cache.ProjectId.ProjectFolder);
});
app.UpdateExternalLinks(sLinkedFilesRootDir);
}
/// ------------------------------------------------------------------------------------
/// <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>
/// 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>
/// 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_app != null)
m_app.Dispose(); // Ensure cache disposed and WSF shutdown.
if (m_inMemoryCache != null)
m_inMemoryCache.Dispose();
}
// Dispose unmanaged resources here, whether disposing is true or false.
m_app = null;
m_mainWnd = null;
m_inMemoryCache = null;
m_isDisposed = true;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Creates a new main window and initializes it. The specified App is responsible for
/// creating the proper main window type.
/// </summary>
/// <param name="app">The app</param>
/// <param name="fNewCache"><c>true</c> if we didn't reuse an existing cache</param>
/// <param name="wndCopyFrom">The window to copy from (optional).</param>
/// <param name="fOpeningNewProject"><c>true</c> if opening a new project</param>
/// <returns>True if the main window was create and initialized successfully</returns>
/// ------------------------------------------------------------------------------------
internal static bool CreateAndInitNewMainWindow(FwApp app, bool fNewCache, Form wndCopyFrom,
bool fOpeningNewProject)
{
Debug.Assert(app == s_flexApp || app == s_teApp);
WriteSplashScreen(app.GetResourceString("kstidInitWindow"));
Form fwMainWindow;
try
{
// Construct the new window, of the proper derived type
fwMainWindow = app.NewMainAppWnd(s_splashScreen, fNewCache, wndCopyFrom, fOpeningNewProject);
// Let the application do its initialization of the new window
using (new DataUpdateMonitor(fwMainWindow, "Creating new main window"))
app.InitAndShowMainWindow(fwMainWindow, wndCopyFrom);
// It seems to get activated before we connect the Activate event. But it IS active by now;
// so just record it now as the active one.
s_activeMainWnd = (IFwMainWnd)fwMainWindow;
}
catch (StartupException ex)
{
// REVIEW: Can this actually happen when just creating a new main window?
CloseSplashScreen();
MessageBox.Show(ex.Message, Properties.Resources.ksErrorCaption,
MessageBoxButtons.OK, MessageBoxIcon.Error);
return false;
}
CloseSplashScreen();
if (!((IFwMainWnd)fwMainWindow).OnFinishedInit())
return false; // did not initialize properly!
fwMainWindow.Activated += FwMainWindowActivated;
fwMainWindow.Closing += FwMainWindowClosing;
return true;
}
public void TearDown()
{
CheckDisposed();
// Note: m_inMemoryCache has to be dispsoed first,
// and then the app can be disposed.
// Otherwise, m_inMemoryCache can't do waht it wants with
// its NewFdoCache object, as it will already have been disposed.
if (m_inMemoryCache != null)
{
m_inMemoryCache.Dispose();
m_inMemoryCache = null;
}
if (m_app != null)
{
m_app.Dispose(); // Ensure cache disposed and WSF shutdown.
m_app = null;
}
m_mainWnd = null;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="FwMainWnd"/> class.
/// </summary>
/// <param name="app">The app.</param>
/// <param name="wndCopyFrom">The Window to copy from.</param>
/// ------------------------------------------------------------------------------------
public FwMainWnd(FwApp app, Form wndCopyFrom) : this(app.Cache)
{
m_app = app;
m_delegate.App = app;
m_fWindowIsCopy = (wndCopyFrom != null);
CreateMenusAndToolBars();
CreateSideBarInfoBarAdapter();
m_mediator.HelpTopicProvider = app;
m_mediator.FeedbackInfoProvider = app;
m_mediator.PropertyTable.SetProperty("App", app);
m_mediator.PropertyTable.SetPropertyPersistence("App", false);
}