public void XHTMLExportGetDigraphMapsFromICUSortRules_TertiaryIgnorableDoesNotCrash()
		{
			var ws = Cache.LangProject.DefaultVernacularWritingSystem;
			ws.SortRules = "&[last tertiary ignorable] = \\";
			ws.SortUsing = WritingSystemDefinition.SortRulesType.CustomICU;

			var exporter = new ConfiguredExport(null, null, 0);
			string output;
			using(var stream = new MemoryStream())
			{
				using(var writer = new StreamWriter(stream))
				{
					exporter.Initialize(Cache, null, writer, null, "xhtml", null, "dicBody");
					Dictionary<string, string> mapChars = null;
					Set<string> ignoreSet = null;
					Set<string> data = null;
					Assert.DoesNotThrow(() => data = exporter.GetDigraphs(ws.Id, out mapChars, out ignoreSet));
					// The second test catches the real world scenario, GetDigraphs is actually called many times, but the first time
					// is the only one that should trigger the algorithm, afterward the information is cached in the exporter.
					Assert.DoesNotThrow(() => data = exporter.GetDigraphs(ws.Id, out mapChars, out ignoreSet));
					Assert.AreEqual(mapChars.Count, 0, "Too many characters found equivalents");
					Assert.AreEqual(ignoreSet.Count, 1, "Ignorable character not parsed from rule");
				}
			}
		}
		public void XHTMLExportGetDigraphMapsFirstCharactersFromICUSortRules()
		{
			var ws = Cache.LangProject.DefaultVernacularWritingSystem;
			ws.SortRules = "&b < az << a < c <<< ch";
			ws.SortUsing = WritingSystemDefinition.SortRulesType.CustomICU;

			var exporter = new ConfiguredExport(null, null, 0);
			string output;
			using (var stream = new MemoryStream())
			{
				using (var writer = new StreamWriter(stream))
				{
					exporter.Initialize(Cache, null, writer, null, "xhtml", null, "dicBody");
					Dictionary<string, string> mapChars;
					Set<string> ignoreSet;
					var data = exporter.GetDigraphs(ws.Id, out mapChars, out ignoreSet);
					Assert.AreEqual(mapChars.Count, 2, "Too many characters found equivalents");
					Assert.AreEqual(mapChars["a"], "az");
					Assert.AreEqual(mapChars["ch"], "c");
				}
			}
		}
		public void XHTMLExportGetDigraphMapsFromICUSortRules_UnicodeTertiaryIgnorableWorks()
		{
			var ws = Cache.LangProject.DefaultVernacularWritingSystem;
			ws.SortRules = "&[last tertiary ignorable] = \\uA78C";
			ws.SortUsing = WritingSystemDefinition.SortRulesType.CustomICU;

			var exporter = new ConfiguredExport(null, null, 0);
			string output;
			using(var stream = new MemoryStream())
			{
				using(var writer = new StreamWriter(stream))
				{
					exporter.Initialize(Cache, null, writer, null, "xhtml", null, "dicBody");
					Dictionary<string, string> mapChars = null;
					Set<string> ignoreSet = null;
					Set<string> data = null;
					Assert.DoesNotThrow(() => data = exporter.GetDigraphs(ws.Id, out mapChars, out ignoreSet));
					Assert.AreEqual(mapChars.Count, 0, "Too many characters found equivalents");
					Assert.AreEqual(ignoreSet.Count, 1, "Ignorable character not parsed from rule");
					Assert.IsTrue(ignoreSet.Contains('\uA78C'.ToString(CultureInfo.InvariantCulture)));
				}
			}
		}
Esempio n. 4
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Exports the configured doc view.
		/// </summary>
		/// <param name="progressDlg">The progress dialog.</param>
		/// <param name="parameters">The parameters.</param>
		/// <returns>Always null.</returns>
		/// ------------------------------------------------------------------------------------
		private object ExportConfiguredDocView(IAdvInd4 progressDlg, params object[] parameters)
		{
			Debug.Assert(parameters.Length == 3);
			m_progressDlg = progressDlg;
			if (m_xvc == null)
				return null;

			string outPath = (string)parameters[0];
			string fxtPath = (string)parameters[1];
			FxtType ft = (FxtType)parameters[2];

			try
			{
				m_cache.EnableBulkLoadingIfPossible(true);

				using (TextWriter w = new StreamWriter(outPath))
				{
					FileInfo outFile = new FileInfo(outPath);
#if DEBUG
					string dirPath = Path.GetTempPath();
					int copyCount = 1;
					string s = string.Format("Starting Configured Export at {0}",
						System.DateTime.Now.ToLongTimeString());
					Debug.WriteLine(s);
#endif
					m_ce = new ConfiguredExport(null, m_cache.MainCacheAccessor, m_hvoRootObj);
					m_ce.Initialize(m_cache, w, ft.m_sDataType, ft.m_sFormat, outPath);
					m_ce.UpdateProgress += new SIL.FieldWorks.Common.Controls.ConfiguredExport.ProgressHandler(ce_UpdateProgress);
					m_xvc.Display(m_ce, m_hvoRootObj, m_seqView.RootFrag);
					m_ce.Finish(ft.m_sDataType);
					w.Close();
#if DEBUG
					s = string.Format("Finished Configured Export Dump at {0}",
						System.DateTime.Now.ToLongTimeString());
					Debug.WriteLine(s);
#endif
					if (ft.m_sXsltFiles != null && ft.m_sXsltFiles.Length != 0)
					{
						string[] rgsXslts = ft.m_sXsltFiles.Split(new char[] { ';' });
						int cXslts = rgsXslts.GetLength(0);
						progressDlg.Position = 0;
						progressDlg.SetRange(0, cXslts);
						progressDlg.Message =
							xWorksStrings.ProcessingIntoFinalForm;
						int idx = fxtPath.LastIndexOfAny(new char[] { '/', '\\' });
						if (idx < 0)
							idx = 0;
						else
							++idx;
						string basePath = fxtPath.Substring(0, idx);
						for (int ix = 0; ix <= cXslts; ++ix)
						{
#if DEBUG
							File.Copy(outPath, Path.Combine(dirPath, "DebugOnlyExportStage" + copyCount + ".txt"), true);
							copyCount++;
							if (ix < cXslts)
								s = String.Format("Starting Configured Export XSLT file {0} at {1}",
									rgsXslts[ix], System.DateTime.Now.ToLongTimeString());
							else
								s = String.Format("Starting final postprocess phase at {0}",
									System.DateTime.Now.ToLongTimeString());
							Debug.WriteLine(s);
#endif
							if (ix < cXslts)
							{
								string sXsltPath = basePath + rgsXslts[ix];
								m_ce.PostProcess(sXsltPath, outPath, ix + 1);
							}
							else
							{
								m_ce.PostProcess(null, outPath, ix + 1);
							}
							progressDlg.Step(0);
						}
					}

					if (ft.m_sFormat.ToLowerInvariant() == "xhtml")
					{
						IVwStylesheet vss = null;
						if (m_seqView.RootBox != null)
							vss = m_seqView.RootBox.Stylesheet;
						m_ce.WriteCssFile(Path.ChangeExtension(outPath, ".css"), vss);
					}
					m_ce = null;
#if DEBUG
					File.Copy(outPath, Path.Combine(dirPath, "DebugOnlyExportStage" + copyCount + ".txt"), true);
					s = string.Format("Totally Finished Configured Export at {0}",
						System.DateTime.Now.ToLongTimeString());
					Debug.WriteLine(s);
#endif
				}
			}
			finally
			{
				m_cache.EnableBulkLoadingIfPossible(false);
			}
			return null;
		}
Esempio n. 5
0
		protected void DoExport(string outPath, bool fLiftOutput)
		{
			string fxtPath = (string)m_exportList.SelectedItems[0].Tag;
			FxtType ft = m_rgFxtTypes[FxtIndex(fxtPath)];
			using (new SIL.FieldWorks.Common.Utils.WaitCursor(this))
			{
				using (ProgressDialogWithTask progressDlg = new ProgressDialogWithTask(this))
				{
					try
					{
						progressDlg.Title = String.Format(xWorksStrings.Exporting0,
							m_exportList.SelectedItems[0].SubItems[0].Text);
						progressDlg.Message = xWorksStrings.Exporting_;

						switch (ft.m_ft)
						{
							case FxtTypes.kftFxt:
								using (m_dumper = new XDumper(m_cache))
								{
									m_dumper.UpdateProgress +=
										new XDumper.ProgressHandler(OnDumperUpdateProgress);
									m_dumper.SetProgressMessage +=
										new EventHandler<XDumper.MessageArgs>(OnDumperSetProgressMessage);
									progressDlg.SetRange(0, m_dumper.GetProgressMaximum());
									progressDlg.CancelButtonVisible = true;
									progressDlg.Restartable = true;
									progressDlg.ProgressBarStyle = ProgressBarStyle.Continuous;
									progressDlg.Cancel += new CancelHandler(Onm_progressDlg_Cancel);

									progressDlg.RunTask(true, new BackgroundTaskInvoker(ExportFxt),
										outPath, fxtPath, fLiftOutput);
								}
								break;
							case FxtTypes.kftConfigured:
							case FxtTypes.kftReversal:
								progressDlg.SetRange(0, m_seqView.ObjectCount);
								progressDlg.CancelButtonVisible = true;
								progressDlg.Cancel += new CancelHandler(ce_Cancel);

								progressDlg.RunTask(true, new BackgroundTaskInvoker(ExportConfiguredDocView),
									outPath, fxtPath, ft);
								break;
						}
					}
					catch (WorkerThreadException e)
					{
						if (e.InnerException is CancelException)
						{
							MessageBox.Show(this, e.InnerException.Message);
							m_ce = null;
						}
						else
						{
							string msg = xWorksStrings.ErrorExporting_ProbablyBug + "\n" + e.InnerException.Message;
							MessageBox.Show(this, msg);
						}
					}
					finally
					{
						m_progressDlg = null;
						m_dumper = null;
						this.Close();
					}
				}
			}
		}
		private void TestBeginCssClassForFlowType(string flowType)
		{
			var exporter = new ConfiguredExport(null, null, 0);
			string output;
			using (var stream = new MemoryStream())
			{
				using (var writer = new StreamWriter(stream))
				{
					exporter.Initialize(Cache, null, writer, null, "xhtml", null, "dicBody");

					var frag = new XmlDocument();
					frag.LoadXml("<p css='some#style' flowType='" + flowType + "'/>");

					exporter.BeginCssClassIfNeeded(frag.DocumentElement);
					writer.Flush();
					stream.Seek(0, SeekOrigin.Begin);
					using (var reader = new StreamReader(stream))
					{
						output = reader.ReadToEnd();
					}
				}
			}
			Assert.That(output, Is.StringContaining("class=\"someNUMBER_SIGNstyle\""));
		}
		public void XHTMLExportGetDigraphMapsFirstCharactersFromOtherSortRules()
		{
			var ws = Cache.LangProject.DefaultVernacularWritingSystem;
			ws.SortRules = "fr";
			ws.SortUsing = WritingSystemDefinition.SortRulesType.OtherLanguage;

			var exporter = new ConfiguredExport(null, null, 0);
			string output;
			using (var stream = new MemoryStream())
			{
				using (var writer = new StreamWriter(stream))
				{
					exporter.Initialize(Cache, null, writer, null, "xhtml", null, "dicBody");
					Dictionary<string, string> mapChars;
					Set<string> ignoreSet;
					var data = exporter.GetDigraphs(ws.Id, out mapChars, out ignoreSet);
					Assert.AreEqual(mapChars.Count, 0, "No equivalents expected");
				}
			}
		}
Esempio n. 8
0
        /// ------------------------------------------------------------------------------------
        /// <summary>
        /// Exports the configured doc view.
        /// </summary>
        /// <param name="progressDlg">The progress dialog.</param>
        /// <param name="parameters">The parameters.</param>
        /// <returns>Always null.</returns>
        /// ------------------------------------------------------------------------------------
        protected object ExportConfiguredDocView(IThreadedProgress progressDlg, object[] parameters)
        {
            Debug.Assert(parameters.Length == 4);
            m_progressDlg = progressDlg;
            if (m_xvc == null)
                return null;

            var outPath = (string) parameters[0];
            var fxtPath = (string) parameters[1];
            var ft = (FxtType) parameters[2];
            var vss = (IVwStylesheet) parameters[3];

            using (TextWriter w = new StreamWriter(outPath))
            {
                // FileInfo outFile = new FileInfo(outPath); // CS 219
            #if DEBUG
                string dirPath = Path.GetTempPath();
                int copyCount = 1;
                string s = string.Format("Starting Configured Export at {0}",
                    DateTime.Now.ToLongTimeString());
                Debug.WriteLine(s);
            #endif
                m_ce = new ConfiguredExport(null, m_xvc.DataAccess, m_hvoRootObj);
                string sBodyClass = (m_areaOrig == "notebook") ? "notebookBody" : "dicBody";
                m_ce.Initialize(m_cache, m_mediator, w, ft.m_sDataType, ft.m_sFormat, outPath, sBodyClass);
                m_ce.UpdateProgress += ce_UpdateProgress;
                m_xvc.Display(m_ce, m_hvoRootObj, m_seqView.RootFrag);
                m_ce.Finish(ft.m_sDataType);
                w.Close();
            #if DEBUG
                s = string.Format("Finished Configured Export Dump at {0}",
                    DateTime.Now.ToLongTimeString());
                Debug.WriteLine(s);
            #endif
                if (!string.IsNullOrEmpty(ft.m_sXsltFiles))
                {
                    string[] rgsXslts = ft.m_sXsltFiles.Split(new[] { ';' });
                    int cXslts = rgsXslts.GetLength(0);
                    progressDlg.Position = 0;
                    progressDlg.Minimum = 0;
                    progressDlg.Maximum = cXslts;
                    progressDlg.Message = xWorksStrings.ProcessingIntoFinalForm;
                    int idx = fxtPath.LastIndexOfAny(new[] { '/', '\\' });
                    if (idx < 0)
                        idx = 0;
                    else
                        ++idx;
                    string basePath = fxtPath.Substring(0, idx);
                    for (int ix = 0; ix <= cXslts; ++ix)
                    {
            #if DEBUG
                        File.Copy(outPath, Path.Combine(dirPath, "DebugOnlyExportStage" + copyCount + ".txt"), true);
                        copyCount++;
                        if (ix < cXslts)
                            s = String.Format("Starting Configured Export XSLT file {0} at {1}",
                                rgsXslts[ix], DateTime.Now.ToLongTimeString());
                        else
                            s = String.Format("Starting final postprocess phase at {0}",
                                DateTime.Now.ToLongTimeString());
                        Debug.WriteLine(s);
            #endif
                        if (ix < cXslts)
                        {
                            string sXsltPath = basePath + rgsXslts[ix];
                            m_ce.PostProcess(sXsltPath, outPath, ix + 1);
                        }
                        else
                        {
                            m_ce.PostProcess(null, outPath, ix + 1);
                        }
                        progressDlg.Step(0);
                    }
                }

                if (ft.m_sFormat.ToLowerInvariant() == "xhtml")
                {
                    m_ce.WriteCssFile(Path.ChangeExtension(outPath, ".css"), vss, AllowDictionaryParagraphIndent(ft));
                }
                m_ce = null;
            #if DEBUG
                File.Copy(outPath, Path.Combine(dirPath, "DebugOnlyExportStage" + copyCount + ".txt"), true);
                s = string.Format("Totally Finished Configured Export at {0}",
                    DateTime.Now.ToLongTimeString());
                Debug.WriteLine(s);
            #endif
            }

            return null;
        }
Esempio n. 9
0
        protected void DoExport(string outPath, bool fLiftOutput)
        {
            string fxtPath = (string)m_exportItems[0].Tag;
            FxtType ft = m_rgFxtTypes[FxtIndex(fxtPath)];
            using (new WaitCursor(this))
            {
                using (var progressDlg = new ProgressDialogWithTask(this))
                {
                    try
                    {
                        progressDlg.Title = String.Format(xWorksStrings.Exporting0,
                            m_exportItems[0].SubItems[0].Text);
                        progressDlg.Message = xWorksStrings.Exporting_;

                        switch (ft.m_ft)
                        {
                            case FxtTypes.kftFxt:
                                m_dumper = new XDumper(m_cache);
                                m_dumper.UpdateProgress += OnDumperUpdateProgress;
                                m_dumper.SetProgressMessage += OnDumperSetProgressMessage;
                                progressDlg.Minimum = 0;
                                progressDlg.Maximum = m_dumper.GetProgressMaximum();
                                progressDlg.AllowCancel = true;
                                progressDlg.Restartable = true;

                                progressDlg.RunTask(true, ExportFxt, outPath, fxtPath, fLiftOutput);
                                break;
                            case FxtTypes.kftConfigured:
                            case FxtTypes.kftReversal:
                            case FxtTypes.kftClassifiedDict:
                                progressDlg.Minimum = 0;
                                progressDlg.Maximum = m_seqView.ObjectCount;
                                progressDlg.AllowCancel = true;

                                IVwStylesheet vss = m_seqView.RootBox == null ? null : m_seqView.RootBox.Stylesheet;
                                progressDlg.RunTask(true, ExportConfiguredDocView,
                                    outPath, fxtPath, ft, vss);
                                break;
                            case FxtTypes.kftTranslatedLists:
                                progressDlg.Minimum = 0;
                                progressDlg.Maximum = m_translatedLists.Count;
                                progressDlg.AllowCancel = true;

                                progressDlg.RunTask(true, ExportTranslatedLists, outPath);
                                break;
                            case FxtTypes.kftSemanticDomains:
                                // Potentially, we could count semantic domains and try to make the export update for each.
                                // In practice this only takes a second or two on a typical modern computer
                                // an the main export routine is borrowed from kftTranslatedLists and set up to count each
                                // list as one step. For now, claiming this export just has one step seems good enough.
                                progressDlg.Minimum = 0;
                                progressDlg.Maximum = 1;
                                progressDlg.AllowCancel = true;

                                progressDlg.RunTask(true, ExportSemanticDomains, outPath, ft, fxtPath, m_allQuestions);
                                break;
                            case FxtTypes.kftPathway:
                                break;
                            case FxtTypes.kftLift:
                                progressDlg.Minimum = 0;
                                progressDlg.Maximum = 1000;
                                progressDlg.AllowCancel = true;
                                progressDlg.Restartable = true;
                                progressDlg.RunTask(true, ExportLift, outPath, ft.m_filtered);
                                break;
                            case FxtTypes.kftGrammarSketch:
                                progressDlg.Minimum = 0;
                                progressDlg.Maximum = 1000;
                                progressDlg.AllowCancel = true;
                                progressDlg.Restartable = true;
                                progressDlg.RunTask(true, ExportGrammarSketch, outPath, ft.m_sDataType, ft.m_sXsltFiles);
                                break;
                        }
                    }
                    catch (WorkerThreadException e)
                    {
                        if (e.InnerException is CancelException)
                        {
                            MessageBox.Show(this, e.InnerException.Message);
                            m_ce = null;
                        }
                        else if (e.InnerException is LiftFormatException)
                        {
                            // Show the pretty yellow semi-crash dialog box, with instructions for the
                            // user to report the bug.
                            var app = (IApp) m_mediator.PropertyTable.GetValue("App");
                            ErrorReporter.ReportException(new Exception(xWorksStrings.ksLiftExportBugReport, e.InnerException),
                                app.SettingsKey, m_mediator.FeedbackInfoProvider.SupportEmailAddress, this, false);
                        }
                        else
                        {
                            string msg = xWorksStrings.ErrorExporting_ProbablyBug + Environment.NewLine + e.InnerException.Message;
                            MessageBox.Show(this, msg);
                        }
                    }
                    finally
                    {
                        m_progressDlg = null;
                        m_dumper = null;
                        Close();
                    }
                }
            }
        }