/// <summary>
/// Step the progress bar by the given amount.
/// </summary>
public void Step(int n)
{
if (m_progress != null)
{
m_progress.Step(n);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// The task to do in the background. We just increment the progress and sleep in
/// between.
/// </summary>
/// <param name="progressDlg">The progress dialog.</param>
/// <param name="parameters">The parameters. Not used.</param>
/// <returns>Current progress</returns>
/// ------------------------------------------------------------------------------------
private object BackgroundTask(IAdvInd4 progressDlg, object[] parameters)
{
int i = 0;
for (; i < 10; i++)
{
if (m_fGotCancel)
{
break;
}
progressDlg.Step(1);
Thread.Sleep(1000);
}
return(i);
}
void OnDumperUpdateProgress(object sender)
{
if (m_progressDlg == null)
{
return;
}
int nMin, nMax;
m_progressDlg.GetRange(out nMin, out nMax);
if (m_progressDlg.Position >= nMax)
{
m_progressDlg.Position = 0;
}
m_progressDlg.Step(1);
if (m_progressDlg.Position > nMax)
{
m_progressDlg.Position = m_progressDlg.Position % nMax;
}
}
private void ExportBook(IScrBook book, IAdvInd4 progressDlg)
{
m_writer.WriteLine("<div class=\"scrBook\">");
m_xhtml.MapCssToLang("scrBook", LanguageCode(m_cache.DefaultVernWs));
ExportBookTitle(book);
int iFirst = 0;
int iLim = book.SectionsOS.Count;
if (m_what == ExportWhat.SingleBook)
{
iFirst = m_iFirstSection;
iLim = m_iLastSection + 1;
}
bool fColumnOutput = false;
for (int i = iFirst; i < iLim; ++i)
{
if (!book.SectionsOS[i].IsIntro && !fColumnOutput)
{
m_writer.WriteLine("<div class=\"columns\">");
m_xhtml.MapCssToLang("columns", LanguageCode(m_cache.DefaultVernWs));
fColumnOutput = true;
}
ExportBookSection(book.SectionsOS[i]);
if (m_cancel)
{
break;
}
progressDlg.Step(0);
}
if (fColumnOutput)
{
m_writer.WriteLine("</div>"); // matches <div class="columns">
}
m_writer.WriteLine("</div>"); // matches <div class="scrBook">
}
/// ------------------------------------------------------------------------------------
/// <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);
}
private void OnDumperUpdateProgress(object sender)
{
Debug.Assert(m_progressDlg != null);
m_progressDlg.Step(0);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Create a new language project for the new language name
/// </summary>
/// <param name="progressDlg">The progress dialog.</param>
/// <param name="parameters">The parameters: first parameter is resources, second is
/// name of the project (string), analysis and vernacular writing system
/// (NamedWritingSystem).</param>
/// <returns>Always null.</returns>
/// <remarks>Override DisplayUi to prevent progress dialog from showing.</remarks>
/// ------------------------------------------------------------------------------------
protected internal object CreateNewLangProj(IAdvInd4 progressDlg, params object[] parameters)
{
Debug.Assert(parameters.Length == 4);
ResourceManager resources = (ResourceManager)parameters[0];
string projectName = (string)parameters[1];
m_analWrtSys = (NamedWritingSystem)parameters[2];
m_vernWrtSys = (NamedWritingSystem)parameters[3];
string dbFileName;
string logFileName;
// Loading the new language project (LoadNewLangProj) took 120 steps. To be safe
// we calculate with 140. Loading newlangproj took 94% of the time, so the total is
// 150.
int nMax = 150;
progressDlg.SetRange(0, nMax);
if (resources != null)
{
progressDlg.Message = resources.GetString("kstidCreatingDB");
}
CreateNewDbFiles(projectName, out dbFileName, out logFileName);
progressDlg.Step(0);
m_dbName = AttachDatabase(dbFileName, logFileName);
progressDlg.Step(0);
if (resources != null)
{
progressDlg.Message = resources.GetString("kstidInitializingDB");
}
LoadNewLangProj(progressDlg);
// Create the FDO cache and writing systems.
progressDlg.Position = (int)(nMax * 0.95);
if (resources != null)
{
progressDlg.Message = resources.GetString("kstidCreatingWS");
}
int hvoLp = 0;
using (FdoCache cache = FdoCache.Create(m_dbName))
{
progressDlg.Step(0);
CreateAnalysisWritingSystem(cache);
progressDlg.Step(0);
CreateVernacularWritingSystem(cache);
// Fix sort methods that should use the vernacular writing system.
progressDlg.Step(0);
progressDlg.Step(0);
FixVernacularWritingSystemReferences(cache);
progressDlg.Step(0);
// set defaults so can access them now
cache.LangProject.CacheDefaultWritingSystems();
progressDlg.Step(0);
AssignVernacularWritingSystemToDefaultPhPhonemes(cache);
progressDlg.Step(0);
// Create a reversal index for the original default analysis writing system. (LT-4480)
IReversalIndex newIdx = cache.LangProject.LexDbOA.ReversalIndexesOC.Add(
new ReversalIndex());
ILgWritingSystem wsAnalysis = cache.LangProject.CurAnalysisWssRS[0];
newIdx.WritingSystemRA = wsAnalysis;
newIdx.Name.AnalysisDefaultWritingSystem = wsAnalysis.Name.AnalysisDefaultWritingSystem;
progressDlg.Step(0);
// Give the language project a default name. Later this can be modified by the
// user by changing it on the project properties dialog.
cache.LangProject.Name.UserDefaultWritingSystem = projectName;
hvoLp = cache.LangProject.Hvo;
cache.Save();
progressDlg.Position = nMax;
}
return(new NewLangProjReturnData(hvoLp, m_serverName, m_dbName));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Updates the key term equivalents.
/// </summary>
/// <param name="progressDlg">The progress dialog box.</param>
/// <param name="parameters">Not used</param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
private object UpdateKeyTermEquivalents(IAdvInd4 progressDlg, params object[] parameters)
{
m_cache.EnableBulkLoadingIfPossible(true);
List<InvalidRendering> invalidRenderings = new List<InvalidRendering>();
try
{
// first build a map from verses to the keyterms that should have renderings.
Set<int> chkTermIds = m_ktTree.ChkTermsWithRefs;
if (progressDlg != null)
{
progressDlg.Message = TeResourceHelper.GetResourceString("kstidUpdateKeyTermEquivalentsProgressLoading");
progressDlg.SetRange(0, chkTermIds.Count);
}
Dictionary<int, List<KeyTermRef>> bcvToChkRefs = new Dictionary<int, List<KeyTermRef>>();
foreach (int keyTermHvo in chkTermIds)
{
AddChkRefsToBCVmap(keyTermHvo, ref bcvToChkRefs);
if (progressDlg != null)
progressDlg.Step(0);
}
// set progress bar to the number of verses to step through.
if (progressDlg != null)
progressDlg.SetRange(0, bcvToChkRefs.Count);
// for each keyterm occurrences in each verse, make sure renderings are up to date.
List<int> sortedKeys = new List<int>(bcvToChkRefs.Keys);
sortedKeys.Sort();
foreach (int bcv in sortedKeys)
{
// REVIEW (TE-6532): For now, all Key Term Refs in the DB use the Original
// versisifcation. Should we support other versifications?
ScrReference currentVerse = new ScrReference(bcv, Paratext.ScrVers.Original,
m_scr.Versification);
if (progressDlg != null)
{
progressDlg.Message = String.Format(TeResourceHelper.GetResourceString("kstidUpdateKeyTermEquivalentsProgressMessage"),
currentVerse.AsString);
}
List<KeyTermRef> chkRefsForVerse = bcvToChkRefs[bcv];
foreach (KeyTermRef chkRef in chkRefsForVerse)
{
Dictionary<int, bool> renderingActuallyExistsInVerse = new Dictionary<int, bool>();
// skip doing anything about references that have been marked as "Ignore"
if (chkRef.Status == KeyTermRenderingStatus.Ignored)
continue;
if (chkRef.RenderingRAHvo != 0)
{
if (CanFindTextInVerse(chkRef.RenderingRA, currentVerse))
{
if (chkRef.RenderingStatus == KeyTermRenderingStatus.Missing)
chkRef.RenderingStatus = KeyTermRenderingStatus.Assigned;
continue;
}
}
// if an expected rendering is not found (or there was no previous assignment)
// see if we can find an alternative rendering to AutoAssign.
IChkTerm parentKeyTerm = chkRef.Owner as IChkTerm;
bool fFound = false;
foreach (IChkRendering rendering in parentKeyTerm.RenderingsOC)
{
if (rendering.SurfaceFormRA == null)
{
// We found a surface form that is not defined. Later we'll need to
// remove this rendering, but for now we'll continue to the next one.
invalidRenderings.Add(new InvalidRendering(parentKeyTerm, rendering));
continue;
}
if (CanFindTextInVerse(rendering.SurfaceFormRA, currentVerse))
{
try
{
chkRef.RenderingRA = rendering.SurfaceFormRA;
if (chkRef.RenderingStatus != KeyTermRenderingStatus.AutoAssigned)
chkRef.RenderingStatus = KeyTermRenderingStatus.AutoAssigned;
fFound = true;
break;
}
catch
{
// Unable to set rendering because it is invalid.
invalidRenderings.Add(new InvalidRendering(parentKeyTerm, rendering));
continue;
}
}
}
if (!fFound)
{
if (chkRef.RenderingStatus == KeyTermRenderingStatus.Assigned)
{
// keep RenderingsRA info, so we know what is missing.
chkRef.RenderingStatus = KeyTermRenderingStatus.Missing;
}
else
{
if (chkRef.RenderingRA != null)
chkRef.RenderingRA = null;
if (chkRef.RenderingStatus != KeyTermRenderingStatus.Unassigned)
chkRef.RenderingStatus = KeyTermRenderingStatus.Unassigned;
}
}
}
if (progressDlg != null)
progressDlg.Step(0);
}
return null;
}
finally
{
if (invalidRenderings.Count > 0)
{
// We found at least one invalid surface form, so we need to search through our
// renderings and remove any that are invalid.
foreach (InvalidRendering rendering in invalidRenderings)
rendering.m_parentKeyTerm.RenderingsOC.Remove(rendering.m_rendering);
}
m_cache.EnableBulkLoadingIfPossible(false);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// The task to do in the background. We just increment the progress and sleep in
/// between.
/// </summary>
/// <param name="progressDlg">The progress dialog.</param>
/// <param name="parameters">The parameters. Not used.</param>
/// <returns>Current progress</returns>
/// ------------------------------------------------------------------------------------
private object BackgroundTask(IAdvInd4 progressDlg, object[] parameters)
{
int i = 0;
for (; i < 10; i++)
{
if (m_fGotCancel)
break;
progressDlg.Step(1);
Thread.Sleep(1000);
}
return i;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Updates the verse bridges.
/// </summary>
/// <param name="progressDlg">The progress dialog.</param>
/// <param name="parameters">The parameters.</param>
/// <returns>Always null.</returns>
/// ------------------------------------------------------------------------------------
private object UpdateVerseBridges(IAdvInd4 progressDlg, params object[] parameters)
{
Debug.Assert(parameters.Length == 1);
string oldBridge = (string)parameters[0];
string newBridge = m_scr.Bridge;
foreach (ScrBook book in m_scr.ScriptureBooksOS)
{
progressDlg.Message =
string.Format(DlgResources.ResourceString("kstidUpdateVerseBridgesInBook"),
book.Name.UserDefaultWritingSystem);
foreach (ScrSection section in book.SectionsOS)
foreach (StTxtPara para in section.ContentOA.ParagraphsOS)
UpdateVerseBridgesInParagraph(para, oldBridge, newBridge);
progressDlg.Step(0);
}
return null;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Converts the chapter verse numbers.
/// </summary>
/// <param name="progressDlg">The progress DLG.</param>
/// <param name="parameters">The parameters.</param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
private object ConvertChapterVerseNumbers(IAdvInd4 progressDlg, params object[] parameters)
{
char zeroDigit = (m_scr.UseScriptDigits ? (char)m_scr.ScriptDigitZero : '0');
ILgCharacterPropertyEngine charEngine = m_cache.UnicodeCharProps;
foreach (ScrBook book in m_scr.ScriptureBooksOS)
{
// update the status with the book name.
progressDlg.Message =
string.Format(DlgResources.ResourceString("kstidConvertChapterVerseNumbersMessage"),
book.BestUIName);
foreach (ScrSection section in book.SectionsOS)
{
foreach (StTxtPara para in section.ContentOA.ParagraphsOS)
ConvertChapterVerseNumbers(para, zeroDigit, charEngine);
}
progressDlg.Step(0);
}
return null;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Redoes the footnote sequencing.
/// </summary>
/// <param name="progressDlg">The progress dialog.</param>
/// <param name="parameters">The parameters: none</param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
private object RedoFootnoteSequencing(IAdvInd4 progressDlg, params object[] parameters)
{
// for all of the books in the database...
foreach (ScrBook book in m_scr.ScriptureBooksOS)
{
// update the status with the book name.
progressDlg.Message =
string.Format(DlgResources.ResourceString("kstidFootnoteResequenceMessage"),
book.BestUIName);
// if the book has 26 footnotes or less then the resequence option will
// not matter.
if (book.FootnotesOS.Count > 26)
ScrFootnote.RecalculateFootnoteMarkers(book, 26);
progressDlg.Step(0);
}
return null;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Create a new language project for the new language name
/// </summary>
/// <param name="progressDlg">The progress dialog.</param>
/// <param name="parameters">The parameters: first parameter is resources, second is
/// name of the project (string), analysis and vernacular writing system
/// (NamedWritingSystem).</param>
/// <returns>Always null.</returns>
/// <remarks>Override DisplayUi to prevent progress dialog from showing.</remarks>
/// ------------------------------------------------------------------------------------
protected internal object CreateNewLangProj(IAdvInd4 progressDlg, params object[] parameters)
{
Debug.Assert(parameters.Length == 4);
ResourceManager resources = (ResourceManager)parameters[0];
string projectName = (string)parameters[1];
m_analWrtSys = (NamedWritingSystem)parameters[2];
m_vernWrtSys = (NamedWritingSystem)parameters[3];
string dbFileName;
string logFileName;
// Loading the new language project (LoadNewLangProj) took 120 steps. To be safe
// we calculate with 140. Loading newlangproj took 94% of the time, so the total is
// 150.
int nMax = 150;
progressDlg.SetRange(0, nMax);
if (resources != null)
progressDlg.Message = resources.GetString("kstidCreatingDB");
CreateNewDbFiles(projectName, out dbFileName, out logFileName);
progressDlg.Step(0);
m_dbName = AttachDatabase(dbFileName, logFileName);
progressDlg.Step(0);
if (resources != null)
progressDlg.Message = resources.GetString("kstidInitializingDB");
LoadNewLangProj(progressDlg);
// Create the FDO cache and writing systems.
progressDlg.Position = (int)(nMax * 0.95);
if (resources != null)
progressDlg.Message = resources.GetString("kstidCreatingWS");
int hvoLp = 0;
using (FdoCache cache = FdoCache.Create(m_dbName))
{
progressDlg.Step(0);
CreateAnalysisWritingSystem(cache);
progressDlg.Step(0);
CreateVernacularWritingSystem(cache);
// Fix sort methods that should use the vernacular writing system.
progressDlg.Step(0);
progressDlg.Step(0);
FixVernacularWritingSystemReferences(cache);
progressDlg.Step(0);
// set defaults so can access them now
cache.LangProject.CacheDefaultWritingSystems();
progressDlg.Step(0);
AssignVernacularWritingSystemToDefaultPhPhonemes(cache);
progressDlg.Step(0);
// Create a reversal index for the original default analysis writing system. (LT-4480)
IReversalIndex newIdx = cache.LangProject.LexDbOA.ReversalIndexesOC.Add(
new ReversalIndex());
ILgWritingSystem wsAnalysis = cache.LangProject.CurAnalysisWssRS[0];
newIdx.WritingSystemRA = wsAnalysis;
newIdx.Name.AnalysisDefaultWritingSystem = wsAnalysis.Name.AnalysisDefaultWritingSystem;
progressDlg.Step(0);
// Give the language project a default name. Later this can be modified by the
// user by changing it on the project properties dialog.
cache.LangProject.Name.UserDefaultWritingSystem = projectName;
hvoLp = cache.LangProject.Hvo;
cache.Save();
progressDlg.Position = nMax;
}
return new NewLangProjReturnData(hvoLp, m_serverName, m_dbName);
}
/// -------------------------------------------------------------------------------------
/// <summary>
/// Create a HeaderFooterSet for each HeaderFooterSet node in the given xml node list.
/// </summary>
/// <param name="progressDlg">Progress dialog</param>
/// <param name="hfSetNodes">the xml nodes to read</param>
/// -------------------------------------------------------------------------------------
protected void CreateHfSets(IAdvInd4 progressDlg, XmlNodeList hfSetNodes)
{
//create each HeaderFooterSet
foreach (XmlNode hfSetNode in hfSetNodes)
{
progressDlg.Step(0);
IPubHFSet hfSet = m_scr.FindHeaderFooterSetByName(
GetString(hfSetNode.Attributes, "Name"));
if (hfSet == null)
hfSet = m_scr.HeaderFooterSetsOC.Add(new PubHFSet());
// ENHANCE(TE-5897): If a user has modified a header/footer set, then changes
// to it in the factory H/F set should not be applied
ReadHeaderFooterSet(hfSet, hfSetNode, true, true);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Create a Publication for each publication node in the given xml node list.
/// </summary>
/// <param name="progressDlg">Progress dialog</param>
/// <param name="publicationNodes">the xml nodes to read</param>
/// <param name="hfSetNodes">The header/footer set nodes.</param>
/// ------------------------------------------------------------------------------------
private void CreatePublications(IAdvInd4 progressDlg, XmlNodeList publicationNodes,
XmlNodeList hfSetNodes)
{
// Remove any previously-defined publications.
m_scr.PublicationsOC.RemoveAll();
//create each publication
foreach (XmlNode publicationNode in publicationNodes)
{
progressDlg.Step(0);
XmlAttributeCollection attributes = publicationNode.Attributes;
string pubName = GetString(attributes, "Name");
// Determine the measurement unit to be used for all measurements in this pub
m_conversion = GetUnitConversion(attributes, "MeasurementUnits", kMpPerInch);
// Create the new Publication object and set non-variable properties
Publication pub = (Publication)m_scr.PublicationsOC.Add(new Publication());
pub.Name = pubName;
// This seems wrong. We don't know why the Publication.Description is a BigString,
// but for now we'll build a TsString to populate it.
ITsStrFactory strFactory = TsStrFactoryClass.Create();
pub.Description.UnderlyingTsString =
strFactory.MakeString(GetString(attributes, "Description"),
m_scr.Cache.DefaultUserWs);
pub.IsLandscape = GetBoolean(attributes, "IsLandscape", false);
GetPageHeightAndWidth(attributes, pub,
publicationNode.SelectSingleNode("SupportedPublicationSizes"));
pub.PaperHeight = 0;
pub.PaperWidth = 0;
pub.GutterMargin = GetMeasurement(attributes, "GutterMargin", 0, m_conversion);
pub.BindingEdge = GetGutterLoc(attributes, "BindingSide", BindingSide.Left);
pub.BaseFontSize = GetMeasurement(attributes, "BaseCharSize", 0, 1000);
// Line spacing < 0 means "exact", which is all we support currently
pub.BaseLineSpacing = -Math.Abs(GetMeasurement(attributes, "BaseLineSize", 0, 1000));
pub.SheetLayout = GetSheetLayout(attributes, MultiPageLayout.Simplex);
XmlNodeList divisionNodes = publicationNode.SelectNodes("Divisions/Division");
CreateDivisions(pub, divisionNodes, hfSetNodes);
}
}
private void ExportBook(IScrBook book, IAdvInd4 progressDlg)
{
m_writer.WriteLine("<div class=\"scrBook\">");
m_xhtml.MapCssToLang("scrBook", LanguageCode(m_cache.DefaultVernWs));
ExportBookTitle(book);
int iFirst = 0;
int iLim = book.SectionsOS.Count;
if (m_what == ExportWhat.SingleBook)
{
iFirst = m_iFirstSection;
iLim = m_iLastSection + 1;
}
bool fColumnOutput = false;
for (int i = iFirst; i < iLim; ++i)
{
if (!book.SectionsOS[i].IsIntro && !fColumnOutput)
{
m_writer.WriteLine("<div class=\"columns\">");
m_xhtml.MapCssToLang("columns", LanguageCode(m_cache.DefaultVernWs));
fColumnOutput = true;
}
ExportBookSection(book.SectionsOS[i]);
if (m_cancel)
break;
progressDlg.Step(0);
}
if (fColumnOutput)
m_writer.WriteLine("</div>"); // matches <div class="columns">
m_writer.WriteLine("</div>"); // matches <div class="scrBook">
}
/// -------------------------------------------------------------------------------------
/// <summary>
/// Create all of the ScrBookRef objects for each book of Scripture
/// </summary>
/// <param name="progressDlg">Progress dialog so the user can cancel</param>
/// -------------------------------------------------------------------------------------
protected void CreateScrBookRefs(IAdvInd4 progressDlg)
{
IScrRefSystem scr = m_cache.ScriptureReferenceSystem;
// If there are books existing, then delete them first.
for (int i = scr.BooksOS.Count - 1; i >= 0; i--)
scr.BooksOS.RemoveAt(i);
XmlDocument doc = new XmlDocument();
doc.Load(DirectoryFinder.FWCodeDirectory + @"\Translation Editor\ScrBookRef.xml");
ILgWritingSystemFactory wsf = m_cache.LanguageWritingSystemFactoryAccessor;
//Select and display the value of all the ISBN attributes.
XmlNodeList tagList = doc.SelectNodes("/ScrBookRef/writingsystem");
progressDlg.SetRange(0, tagList.Count * ScrReference.LastBook);
progressDlg.Position = 0;
progressDlg.Title = TeResourceHelper.GetResourceString("kstidCreatingBookNames");
foreach (XmlNode writingSystem in tagList)
{
XmlAttributeCollection attributes = writingSystem.Attributes;
string sLocale = attributes.GetNamedItem("iculocale").Value;
int ws = m_cache.LanguageEncodings.GetWsFromIcuLocale(sLocale);
if (ws == 0)
{
// It is possible that the XML file contains more languages than the
// database. If so, just ignore this writing system.
continue;
}
short iBook = 0;
XmlNodeList WSBooks = writingSystem.SelectNodes("book");
foreach (XmlNode book in WSBooks)
{
XmlAttributeCollection bookAttributes = book.Attributes;
string sSilBookId = bookAttributes.GetNamedItem("SILBookId").Value;
Debug.Assert(sSilBookId != null);
// Make sure books are coming in canonical order.
Debug.Assert(ScrReference.BookToNumber(sSilBookId) == iBook + 1);
string sName = bookAttributes.GetNamedItem("Name").Value;
string sAbbrev = bookAttributes.GetNamedItem("Abbreviation").Value;
string sAltName = bookAttributes.GetNamedItem("AlternateName").Value;
progressDlg.Message = string.Format(
TeResourceHelper.GetResourceString("kstidCreatingBookNamesStatusMsg"), sName);
progressDlg.Step(0);
// check for the book id
ScrBookRef bookRef = null;
if (scr.BooksOS.Count > iBook)
{
bookRef = (ScrBookRef)scr.BooksOS[iBook];
Debug.Assert(bookRef != null);
}
else
{
// add this book to the list
bookRef = new ScrBookRef();
scr.BooksOS.Append(bookRef);
}
if (sName != null)
bookRef.BookName.SetAlternative(sName, ws);
if (sAbbrev != null)
bookRef.BookAbbrev.SetAlternative(sAbbrev, ws);
if (sAltName != null)
bookRef.BookNameAlt.SetAlternative(sAltName, ws);
iBook++;
}
}
}
/// -------------------------------------------------------------------------------------
/// <summary>
/// Create all of the ScrBookRef objects for each book of Scripture
/// </summary>
/// <param name="progressDlg">Progress dialog so the user can cancel</param>
/// -------------------------------------------------------------------------------------
protected void CreateScrBookRefs(IAdvInd4 progressDlg)
{
IScrRefSystem scr = m_cache.ScriptureReferenceSystem;
// If there are books existing, then delete them first.
for (int i = scr.BooksOS.Count - 1; i >= 0; i--)
{
scr.BooksOS.RemoveAt(i);
}
XmlDocument doc = new XmlDocument();
doc.Load(DirectoryFinder.FWCodeDirectory + @"\Translation Editor\ScrBookRef.xml");
ILgWritingSystemFactory wsf = m_cache.LanguageWritingSystemFactoryAccessor;
//Select and display the value of all the ISBN attributes.
XmlNodeList tagList = doc.SelectNodes("/ScrBookRef/writingsystem");
progressDlg.SetRange(0, tagList.Count * ScrReference.LastBook);
progressDlg.Position = 0;
progressDlg.Title = TeResourceHelper.GetResourceString("kstidCreatingBookNames");
foreach (XmlNode writingSystem in tagList)
{
XmlAttributeCollection attributes = writingSystem.Attributes;
string sLocale = attributes.GetNamedItem("iculocale").Value;
int ws = m_cache.LanguageEncodings.GetWsFromIcuLocale(sLocale);
if (ws == 0)
{
// It is possible that the XML file contains more languages than the
// database. If so, just ignore this writing system.
continue;
}
short iBook = 0;
XmlNodeList WSBooks = writingSystem.SelectNodes("book");
foreach (XmlNode book in WSBooks)
{
XmlAttributeCollection bookAttributes = book.Attributes;
string sSilBookId = bookAttributes.GetNamedItem("SILBookId").Value;
Debug.Assert(sSilBookId != null);
// Make sure books are coming in canonical order.
Debug.Assert(ScrReference.BookToNumber(sSilBookId) == iBook + 1);
string sName = bookAttributes.GetNamedItem("Name").Value;
string sAbbrev = bookAttributes.GetNamedItem("Abbreviation").Value;
string sAltName = bookAttributes.GetNamedItem("AlternateName").Value;
progressDlg.Message = string.Format(
TeResourceHelper.GetResourceString("kstidCreatingBookNamesStatusMsg"), sName);
progressDlg.Step(0);
// check for the book id
ScrBookRef bookRef = null;
if (scr.BooksOS.Count > iBook)
{
bookRef = (ScrBookRef)scr.BooksOS[iBook];
Debug.Assert(bookRef != null);
}
else
{
// add this book to the list
bookRef = new ScrBookRef();
scr.BooksOS.Append(bookRef);
}
if (sName != null)
{
bookRef.BookName.SetAlternative(sName, ws);
}
if (sAbbrev != null)
{
bookRef.BookAbbrev.SetAlternative(sAbbrev, ws);
}
if (sAltName != null)
{
bookRef.BookNameAlt.SetAlternative(sAltName, ws);
}
iBook++;
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Load the Scr notes categories from the given XML document
/// </summary>
/// ------------------------------------------------------------------------------------
protected virtual void CreateScrNoteCategories()
{
// Save the previous categories for all of the notes.
Dictionary <int, List <string> > notesToCategories = CreateNoteToCategoryMap();
m_scr.NoteCategoriesOA = new CmPossibilityList();
m_scr.NoteCategoriesOA.ItemClsid = CmPossibility.kClassId;
m_scr.NoteCategoriesOA.WsSelector = LangProject.kwsAnals;
m_scr.NoteCategoriesOA.Name.SetAlternative(
TeResourceHelper.GetResourceString("kstidScrNoteCategoriesListName"),
m_scr.Cache.DefaultUserWs);
XmlNodeList scrNoteCategoriesList = m_categories.SelectNodes("category");
string message = null;
if (m_progressDlg != null)
{
m_progressDlg.Title = TeResourceHelper.GetResourceString("kstidLoadingNoteCategoriesCaption");
m_progressDlg.Message = string.Empty;
m_progressDlg.Position = 0;
m_progressDlg.SetRange(0, scrNoteCategoriesList.Count);
message = TeResourceHelper.GetResourceString("kstidLoadNoteCategoryInDBStatus");
}
string localeXpath = "name[@iculocale='" + m_userLocale + "']";
string fallbackLocaleXpath = "name[@iculocale='" + m_fallbackUserLocale + "']";
// Load all of the categories from the XML document
int index = 0;
foreach (XmlNode noteCategoryNode in scrNoteCategoriesList)
{
// Update dialog message.
if (m_progressDlg != null)
{
XmlNode node = noteCategoryNode.SelectSingleNode(localeXpath);
if (node == null)
{
node = noteCategoryNode.SelectSingleNode(fallbackLocaleXpath);
}
if (node != null)
{
m_progressDlg.Message = string.Format(message, node.InnerText);
}
}
CreateNoteCategory(m_scr.NoteCategoriesOAHvo,
(int)CmPossibilityList.CmPossibilityListTags.kflidPossibilities,
index++, noteCategoryNode);
if (m_progressDlg != null)
{
m_progressDlg.Step(1);
}
}
m_scr.NoteCategoriesOA.ListVersion =
new Guid(m_categories.Attributes.GetNamedItem("version").Value);
// Attempt to map the previous categories of any notes to the new categories.
ConnectNotesToNewCategories(notesToCategories);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Export a single book
/// </summary>
/// <param name="sCanon">The current section of the Bible ("ot" or "nt")</param>
/// <param name="book">The book.</param>
/// <param name="progressDlg">The progress dialog.</param>
/// ------------------------------------------------------------------------------------
private void ExportBook(ref string sCanon, IScrBook book, IAdvInd4 progressDlg)
{
// If we're using segmented backtranslations, load the segment information into the cache.
if (Options.UseInterlinearBackTranslation)
{
foreach (int ws in m_cache.LangProject.AnalysisWssRC.HvoArray)
{
if (book.TitleOA != null)
StTxtPara.LoadSegmentFreeTranslations(book.TitleOA.ParagraphsOS.HvoArray, m_cache, ws);
foreach (IStFootnote fn in book.FootnotesOS)
StTxtPara.LoadSegmentFreeTranslations(fn.ParagraphsOS.HvoArray, m_cache, ws);
}
}
//m_writer.WriteComment(String.Format(
// "Book has {0} title paragraphs and {1} sections",
// book.TitleOA.ParagraphsOS.Count, book.SectionsOS.Count));
if (book.CanonicalNum < 40) // First 39 books are in the Old Testament.
{
if (String.IsNullOrEmpty(sCanon))
{
sCanon = "ot";
m_writer.WriteStartElement("canon");
m_writer.WriteAttributeString("ID", sCanon);
}
}
else
{
if (sCanon != "nt")
{
if (!String.IsNullOrEmpty(sCanon))
m_writer.WriteEndElement();
sCanon = "nt";
m_writer.WriteStartElement("canon");
m_writer.WriteAttributeString("ID", sCanon);
}
}
if (progressDlg != null)
{
progressDlg.Message = string.Format(DlgResources.ResourceString(
"kstidExportBookStatus"), book.Name.UserDefaultWritingSystem);
}
m_iCurrentBook = book.CanonicalNum;
m_sCurrentBookId = book.BookId.Normalize();
m_sCurrentBookName = GetProperBookName(book.Name.BestVernacularAlternative);
m_iCurrentChapter = 0;
m_sCurrentChapterNumber = String.Empty;
m_iCurrentVerse = 0;
m_sCurrentVerseNumber = String.Empty;
m_writer.WriteStartElement("book");
m_writer.WriteAttributeString("ID", m_sCurrentBookId);
ExportBookTitle(book);
m_fInIntroduction = false;
int iFirst = 0;
int iLim = book.SectionsOS.Count;
if (m_what == ExportWhat.SingleBook)
{
iFirst = m_iFirstSection;
iLim = m_iLastSection + 1;
}
for (int i = iFirst; i < iLim; ++i)
{
IScrSection section = book.SectionsOS[i];
IScrSection nextSection = (i + 1) < book.SectionsOS.Count ? book.SectionsOS[i + 1] : null;
ExportBookSection(section, nextSection);
if (m_cancel)
break;
if (progressDlg != null)
progressDlg.Step(0);
}
if (m_fInIntroduction)
m_writer.WriteEndElement(); // </introduction>
FlushSectionElementStack(SectionLevel.Major);
m_writer.WriteEndElement(); // </book>
}
/// ------------------------------------------------------------------------------------
/// <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;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Export the heading and contents of the given section.
/// </summary>
/// <param name="progressDlg">The progress dialog.</param>
/// <param name="section">current section in the book</param>
/// <param name="outputImplicitChapter">if true, output implicit chapter number</param>
/// ------------------------------------------------------------------------------------
protected void ExportSection(IAdvInd4 progressDlg, IScrSection section,
bool outputImplicitChapter)
{
m_currentSectionIsIntro = section.IsIntro;
m_textOutputBegunInCurrentSection = false;
BCVRef sectionRefStart = section.VerseRefStart;
// Pre-process the first paragraph of the section. If this first paragraph begins with
// a chapter number, we need to export the chapter marker now, before the section marker.
RefElement runTypeFound;
ITsString tss = ((StTxtPara)section.ContentOA.ParagraphsOS[0]).Contents.UnderlyingTsString;
ProcessParaStart(tss, section.VerseRefStart, out runTypeFound);
// If m_currentChapterRef was not set during ProcessParaStart
// (i.e. the section does not begin with a chapter number run)...
if (m_currentChapterRef == 0)
{
// Set the current chapter & verse ref state from the section start ref,
// so the vref markers and annotation matching will be correct.
m_currentChapterRef = sectionRefStart.Chapter;
m_lastNumericBeginVerseNum = m_lastNumericEndVerseNum = sectionRefStart.Verse;
m_currentVerseNumString = null;
}
// Handle the special output needed if there is an implicit chapter 1.
// If the section ref start indicates chapter 1, and the section is not an introduction, and
// the first paragraph does not begin with a chapter run and no chapter has been written ...
if (runTypeFound != RefElement.Chapter && m_lastChapterWritten == 0 &&
sectionRefStart.Chapter == 1 && !m_currentSectionIsIntro)
{
// If we are to output implicit first chapter number...
if (outputImplicitChapter)
{
// output the "\c 1" and record marker.
// also see if the chapter we just wrote out needs to get an
// implicit first verse marker.
if (WriteChapterTag(1))
m_v1NeededForImplicitFirstVerse = ParaBeginsWithImplicitFirstVerse(tss, 0);
}
else
{
// book has only one chapter; output only the record marker, not a \c.
m_file.WriteLine(); //always start on new line
WriteRecordMark(m_currentBookCode, 1);
m_v1NeededForImplicitFirstVerse = ParaBeginsWithImplicitFirstVerse(tss, 0);
}
}
// Write out the section heading paragraphs
m_currentParaIsHeading = true;
foreach (StTxtPara para in section.HeadingOA.ParagraphsOS)
ExportParagraph(para);
// Write out the section contents
m_currentParaIsHeading = false;
foreach (StTxtPara para in section.ContentOA.ParagraphsOS)
ExportParagraph(para);
progressDlg.Step(0);
}
