/// ------------------------------------------------------------------------------------
/// <summary>
/// Write all the paragraphs in the given footnote.
/// </summary>
/// ------------------------------------------------------------------------------------
private void ExportFootnote(ScrFootnote scrFootnote)
{
m_fInFootnote = true;
// TE allows only one paragraph in a footnote!
Debug.Assert(scrFootnote.ParagraphsOS.Count < 2);
foreach (IStTxtPara para in scrFootnote.ParagraphsOS)
ExportParagraph(para, null, false);
m_fInFootnote = false;
}
// this code was added back when we were trying to display some special UI for editing
// verse numbers, rather than allowing normal editing.
///// ------------------------------------------------------------------------------------
///// <summary>
///// Changes the mouse cursor if we are over a verse number
///// </summary>
///// <param name="sel">The selection</param>
///// <returns>True if we set a cursor, false otherwise</returns>
///// ------------------------------------------------------------------------------------
//protected override bool SetCustomCursor(IVwSelection sel)
//{
// if (Callbacks.EditedRootBox == null)
// return false;
// SelectionHelper helper = SelectionHelper.Create(sel, Callbacks.EditedRootBox.Site);
// if (helper == null || helper.SelProps == null)
// return false;
// string styleName =
// helper.SelProps.GetStrPropValue((int)FwTextPropType.ktptNamedStyle);
// if (styleName == ScrStyleNames.VerseNumber)
// {
// Control.Cursor = Cursors.Arrow;
// return true;
// }
// return false;
//}
/// ------------------------------------------------------------------------------------
/// <summary>
/// This method is used to get a notification when an owning object-replacement character
/// (ORC) is deleted. ORCs are used to mark locations in the text of things like pictures
/// or footnotes. In the case of footnotes, when an owning footnote ORC is deleted, we
/// need to find the corresponding footnote and delete it.
/// </summary>
/// <param name="guid">The GUID of the footnote being deleted.</param>
/// ------------------------------------------------------------------------------------
public override void ObjDeleted(ref Guid guid)
{
CheckDisposed();
if (PreventObjDeletions)
return;
// This is a check to avoid fallout from a time when we incorrectly imported BT
// footnote ORCs as owning.
if (IsBackTranslation)
return;
int footnoteHvo = m_cache.GetIdFromGuid(guid);
if (footnoteHvo == 0)
return;
int clsid = m_cache.GetClassOfObject(footnoteHvo);
if (clsid == 0)
return;
// Delete the footnote.
if (clsid == StFootnote.kClassId)
{
using (new WaitCursor(Control))
{
ScrFootnote footnote = new ScrFootnote(m_cache, footnoteHvo);
int paraHvo = footnote.ContainingParagraphHvo;
// If there's no (vernacular) paragraph with an ORC that references this footnote,
// there can't be a translation either.
if (paraHvo > 0)
{
StTxtPara para = new StTxtPara(m_cache, paraHvo);
para.DeleteAnyBtMarkersForFootnote(guid);
}
ScrFootnote.DeleteFootnote(footnote);
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Delete all footnotes between firstFootnoteToDelete and lastFootnoteToDelete. Clean
/// up BT ORCs for the paragraphs specified.
/// </summary>
/// <param name="book">Book that contains the sections to delete</param>
/// <param name="firstFootnoteToDelete">First footnote that will be deleted
/// (might be null).</param>
/// <param name="lastFootnoteToDelete">Last footnote that will be deleted
/// (might be null).</param>
/// <param name="hvoFirstPara">First (possibly partial) paragraph being deleted that
/// might contain ORCs for the first footnotes. Any footnotes being deleted whose ORCs
/// are in this paragraph will have their corresponding BT ORCs removed as well.
/// If zero, we don't bother to remove any corresponding BT ORCs in the first para.</param>
/// <param name="hvoLastPara">Last (possibly partial) paragraph being deleted that
/// might contain ORCs for the last footnotes. Any footnotes being deleted whose ORCs
/// are in this paragraph will have their corresponding BT ORCs removed as well.
/// If zero, we don't bother to remove any corresponding BT ORCs in the last para.</param>
/// ------------------------------------------------------------------------------------
private void DeleteFootnotes(IScrBook book, ScrFootnote firstFootnoteToDelete,
ScrFootnote lastFootnoteToDelete, int hvoFirstPara, int hvoLastPara)
{
Debug.Assert((firstFootnoteToDelete == null && lastFootnoteToDelete == null)
|| (firstFootnoteToDelete != null && lastFootnoteToDelete != null));
if (firstFootnoteToDelete != null)
{
bool fDeleteFootnote = false;
int[] hvos = book.FootnotesOS.HvoArray;
for (int i = hvos.Length - 1; i >= 0; i--)
{
if (hvos[i] == lastFootnoteToDelete.Hvo)
fDeleteFootnote = true; // we are now in the range of footnotes to delete
if (fDeleteFootnote)
{
// This code fixes TE-4882.
ScrFootnote footnote = new ScrFootnote(m_cache, hvos[i]);
int hvoPara = footnote.ContainingParagraphHvo;
Debug.Assert(hvoPara > 0);
if ((hvoPara == hvoFirstPara || hvoPara == hvoLastPara) && hvoPara > 0)
{
StTxtPara para = new StTxtPara(m_cache, hvoPara);
para.DeleteAnyBtMarkersForFootnote(footnote.Guid);
}
m_cache.DeleteObject(hvos[i]);
}
if (hvos[i] == firstFootnoteToDelete.Hvo)
break;
}
}
}
public void GetMarkerForCrossRef_Scripture_AutoNumbered()
{
CheckDisposed();
ScrFootnote footnote = new ScrFootnote(Cache, m_genesis.FootnotesOS.HvoArray[0]);
StTxtPara para = new StTxtPara();
footnote.ParagraphsOS.Append(para);
para.StyleRules = StyleUtils.ParaStyleTextProps(ScrStyleNames.CrossRefFootnoteParagraph);
footnote = new ScrFootnote(Cache, m_genesis.FootnotesOS.HvoArray[1]);
para = new StTxtPara();
footnote.ParagraphsOS.Append(para);
para.StyleRules = StyleUtils.ParaStyleTextProps(ScrStyleNames.CrossRefFootnoteParagraph);
footnote = new ScrFootnote(Cache, m_genesis.FootnotesOS.HvoArray[2]);
para = new StTxtPara();
footnote.ParagraphsOS.Append(para);
para.StyleRules = StyleUtils.ParaStyleTextProps(ScrStyleNames.CrossRefFootnoteParagraph);
ITsString expectedMarker = MakeMarker("c");
m_scr.CrossRefMarkerType = FootnoteMarkerTypes.AutoFootnoteMarker;
m_scr.FootnoteMarkerType = FootnoteMarkerTypes.NoFootnoteMarker; // Just to make sure it's not using this by mistake
AssertEx.AreTsStringsEqual(expectedMarker, footnote.FootnoteMarker);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Deletes a footnote
/// </summary>
/// <param name="args"></param>
/// <returns><c>true</c> if we handle this</returns>
/// ------------------------------------------------------------------------------------
protected bool OnDeleteFootnote(object args)
{
if (DataUpdateMonitor.IsUpdateInProgress(DataAccess))
return true; //discard this event
if (!ValidFootnoteSelection)
return true;
string undo;
string redo;
TeResourceHelper.MakeUndoRedoLabels("kstidUndoDelFootnote", out undo, out redo);
using (new UndoTaskHelper(this, undo, redo, false))
using (new DataUpdateMonitor(this, RootBox.DataAccess, this, "DeleteFootnote"))
{
SelectionHelper helper = SelectionHelper.Create(this);
int fnLevel = helper.GetLevelForTag((int)ScrBook.ScrBookTags.kflidFootnotes);
if (helper.Selection.IsRange)
DeleteFootnoteRange(helper);
else
{
// There's no range selection, so delete only one footnote
ScrFootnote footnote = new ScrFootnote(m_fdoCache, helper.LevelInfo[fnLevel].hvo);
ScrFootnote.DeleteFootnoteAndMarker(footnote);
}
if (RootBox.Height <= 0)
DraftView.Focus();
else
{
int iBook = helper.LevelInfo[fnLevel + 1].ihvo;
ScrBook book = m_bookFilter.GetBook(iBook);
int iFootnote = helper.LevelInfo[fnLevel].ihvo;
// If the last footnote in the book was deleted find a footnote to move to
if (iFootnote >= book.FootnotesOS.Count)
FindNearestFootnote(ref iBook, ref iFootnote);
FootnoteEditingHelper.ScrollToFootnote(iBook, iFootnote, 0);
}
}
return true;
}
public void DeleteFootnoteFromContextMenuRangeSelection()
{
CheckDisposed();
SelectionHelper selHelper = new SelectionHelper();
selHelper.AssocPrev = true;
selHelper.NumberOfLevels = 3;
SelLevInfo[] anchorLevInfo = new SelLevInfo[3];
anchorLevInfo[2].tag = m_footnoteView.BookFilter.Tag;
anchorLevInfo[2].ihvo = 1;
anchorLevInfo[1].tag = (int)ScrBook.ScrBookTags.kflidFootnotes;
anchorLevInfo[1].ihvo = 2;
anchorLevInfo[0].tag = (int)StText.StTextTags.kflidParagraphs;
anchorLevInfo[0].ihvo = 0;
selHelper.SetLevelInfo(SelectionHelper.SelLimitType.Anchor, anchorLevInfo);
selHelper.IchAnchor = 1;
SelLevInfo[] endLevInfo = new SelLevInfo[3];
endLevInfo[2].tag = m_footnoteView.BookFilter.Tag;
endLevInfo[2].ihvo = 1;
endLevInfo[1].tag = (int)ScrBook.ScrBookTags.kflidFootnotes;
endLevInfo[1].ihvo = 6;
endLevInfo[0].tag = (int)StText.StTextTags.kflidParagraphs;
endLevInfo[0].ihvo = 0;
selHelper.SetLevelInfo(SelectionHelper.SelLimitType.End, endLevInfo);
selHelper.IchEnd = 7;
// Now that all the preparation to set the selection is done, set it.
selHelper.SetSelection(m_footnoteView, true, true);
Application.DoEvents();
// First get the footnotes we're deleting.
ScrFootnote[] footnotes = new ScrFootnote[5];
Guid[] guidFootnotes = new Guid[5];
int[] hvoParas = new int[5];
for (int i = 0; i < 5; i++)
{
footnotes[i] = new ScrFootnote(Cache, m_Jude.FootnotesOS.HvoArray[i + 2]);
guidFootnotes[i] = Cache.GetGuidFromId(footnotes[i].Hvo);
hvoParas[i] = footnotes[i].ContainingParagraphHvo;
}
m_footnoteView.DeleteFootnote();
foreach (ScrFootnote footnote in footnotes)
Assert.IsFalse(Cache.IsRealObject(footnote.Hvo, StFootnote.kClassId));
// now make sure that we don't find the footnote markers
for (int i = 0; i < 5; i++)
{
VerifyRemovedFootnoteMarker(hvoParas[i], guidFootnotes[i]);
VerifyRemovedFootnoteMarker(hvoParas[i], guidFootnotes[i], InMemoryFdoCache.s_wsHvos.En);
VerifyRemovedFootnoteMarker(hvoParas[i], guidFootnotes[i], InMemoryFdoCache.s_wsHvos.De);
}
}
public void GetRefForFootnote_IntroPara()
{
CheckDisposed();
ScrFootnote footnote = new ScrFootnote(Cache, m_genesis.FootnotesOS.HvoArray[0]);
StTxtPara para = new StTxtPara();
footnote.ParagraphsOS.Append(para);
para.StyleRules = StyleUtils.ParaStyleTextProps(ScrStyleNames.NormalFootnoteParagraph);
m_scr.DisplayFootnoteReference = true;
Assert.AreEqual("", footnote.RefAsString, "Intro footnotes don't have Scripture references.");
}
public void DeleteFootnote()
{
CheckDisposed();
IScrBook book;
InsertTestFootnote(20, out book);
InsertTestFootnote(60, out book);
InsertTestFootnote(100, out book);
// First get the guid for the footnote we're deleting.
IScrSection section = book.SectionsOS[0];
IStTxtPara para = (IStTxtPara)section.ContentOA.ParagraphsOS[0];
ITsString tssOrig = para.Contents.UnderlyingTsString;
ITsTextProps props = para.Contents.UnderlyingTsString.get_Properties(1);
string sGuid = props.GetStrPropValue((int)FwTextPropType.ktptObjData);
// Send the objData string without the first character because the first character
// is the object replacement character and the rest of the string is the GUID.
Guid guid = MiscUtils.GetGuidFromObjData(sGuid.Substring(1));
// Verify the footnote object is in the DB.
ICmObject obj = CmObject.CreateFromDBObject(Cache, Cache.GetIdFromGuid(guid));
Assert.IsTrue(obj is StFootnote, "Oops! Footnote isn't in the DB so it cannot be deleted.");
// Delete text including the first footnote from the first para in Exodus.
m_draftView.SelectRangeOfChars(0, 0, 0, 2, 20);
m_draftView.OnKeyDown(new KeyEventArgs(Keys.Delete));
// Now verify the footnote object has been removed from the DB.
Assert.AreEqual(0, Cache.GetIdFromGuid(guid), "Footnote was not deleted from DB.");
// Verify that all footnote markers have been updated
string expectedMarker = "a";
foreach (int hvo in book.FootnotesOS.HvoArray)
{
ScrFootnote footnote = new ScrFootnote(Cache, hvo);
Assert.AreEqual(expectedMarker, footnote.FootnoteMarker.Text);
expectedMarker = new string((char) (expectedMarker[0] + 1), 1);
}
// Verify the expected paragraph contents (removing characters 2 to 20).
ITsStrBldr tssBldr = tssOrig.GetBldr();
tssBldr.ReplaceRgch(2, 20, "", 0, null);
ITsString tssExpected = tssBldr.GetString();
Assert.AreEqual(tssExpected.Text, para.Contents.UnderlyingTsString.Text);
}
public void InsertFootnote_AfterEmptyParaWithChapterNumberStyle()
{
CheckDisposed();
IScrBook book;
ScrFootnote footnote0 = InsertTestFootnote(0, out book);
ScrFootnote footnote1 = InsertTestFootnote(3, out book);
ScrFootnote scrFootnote1 = new ScrFootnote(Cache, footnote1.Hvo);
ScrFootnote.DeleteFootnoteAndMarker(scrFootnote1);
int iSection = book.SectionsOS.Count - 1;
IScrSection section = book.SectionsOS[iSection];
IStTxtPara emptyChapterPara = new StTxtPara();
section.ContentOA.ParagraphsOS.InsertAt(emptyChapterPara, 0);
ITsStrBldr bldr = emptyChapterPara.Contents.UnderlyingTsString.GetBldr();
ITsTextProps ttpChapterNumber = TsPropsFactoryClass.Create().MakeProps(
ScrStyleNames.ChapterNumber, Cache.DefaultVernWs, 0);
bldr.SetProperties(0, 0, ttpChapterNumber);
emptyChapterPara.Contents.UnderlyingTsString = bldr.GetString();
Assert.AreEqual(1, book.FootnotesOS.Count);
// Insert a footnote later in the section.
m_draftView.SetInsertionPoint(0, iSection, 1, 3, false);
SelectionHelper helper = SelectionHelper.Create(m_draftView);
m_scr.DisplayFootnoteReference = true; // Why is this line here?
ScrFootnote footnote2 = m_draftView.InsertFootnote(helper);
// Verify the footnote is added to the book.
Assert.AreEqual(footnote2.Hvo, book.FootnotesOS.HvoArray[1]);
// Verify the footnotes were given the proper marker.
Assert.AreEqual("b", footnote2.FootnoteMarker.Text);
}
public void DeleteFootnoteInRangeSelectionAcrossMultipleBooks()
{
SetupSelectionForRangeAcrossBooks();
IScripture scr = m_cache.LangProject.TranslatedScriptureOA;
ScrFootnote[] footnotes = new ScrFootnote[4];
Guid[] guidFootnotes = new Guid[4];
int[] hvoParas = new int[4];
// First get the footnotes we're deleting from JAMES.
IScrBook book = (IScrBook)scr.ScriptureBooksOS[1];
footnotes[0] = new ScrFootnote(m_cache, book.FootnotesOS.HvoArray[31]);
footnotes[1] = new ScrFootnote(m_cache, book.FootnotesOS.HvoArray[32]);
// First get the footnotes we're deleting from JUDE.
book = (IScrBook)scr.ScriptureBooksOS[2];
footnotes[2] = new ScrFootnote(m_cache, book.FootnotesOS.HvoArray[0]);
footnotes[3] = new ScrFootnote(m_cache, book.FootnotesOS.HvoArray[1]);
for (int i = 0; i < 4; i++)
{
guidFootnotes[i] = m_cache.GetGuidFromId(footnotes[i].Hvo);
hvoParas[i] = footnotes[i].ContainingParagraphHvo;
}
m_footnoteView.DeleteFootnote();
foreach (IStFootnote footnote in footnotes)
Assert.IsFalse(m_cache.IsRealObject(footnote.Hvo, StFootnote.kClassId));
// now make sure that we don't find the footnote markers
for (int i = 0; i < 4; i++)
{
Assert.IsFalse(IsFootnoteMarkerInText(hvoParas[i], guidFootnotes[i]),
"Footnote marker didn't get deleted from text");
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Get the start and end reference of the specified position <paramref name="ivPos"/>
/// in the paragraph. Section reference could be used, if available, to fill in missing
/// information, but (at least for now) we will not search back into previous sections.
/// </summary>
/// <param name="wsBT">HVO of the writing system of the BT to search, or -1 to search
/// the vernacular.</param>
/// <param name="ivPos">Character offset in the paragraph.</param>
/// <param name="fAssocPrev">Consider this position to be associated with any preceding
/// text in the paragraph (in the case where ichPos is at a chapter boundary).</param>
/// <param name="refStart">[out] Start reference</param>
/// <param name="refEnd">[out] End reference</param>
/// <remarks><p><paramref name="refStart"/> and <paramref name="refEnd"/> are only
/// different if we have bridged verse numbers.</p>
/// <p>May return incomplete or invalid reference if, for example, the section
/// object does not have a valid start reference.</p>
/// <p>If ivPos LT zero, we will not search this para, but look only in previous
/// paragraphs</p></remarks>
/// ------------------------------------------------------------------------------------
public void GetBCVRefAtPosition(int wsBT, int ivPos, bool fAssocPrev,
out BCVRef refStart, out BCVRef refEnd)
{
refStart = new BCVRef();
refEnd = new BCVRef();
// Might be trying to get the BCVRef in a footnote
int ownerOwnFlid = m_cache.GetOwningFlidOfObject(OwnerHVO);
if (ownerOwnFlid == (int)ScrBook.ScrBookTags.kflidFootnotes)
{
ScrFootnote footnote = new ScrFootnote(m_cache, OwnerHVO);
refStart = footnote.StartRef;
refEnd = footnote.StartRef;
return;
}
BCVRef refStartT = new BCVRef();
BCVRef refEndT = new BCVRef();
ChapterVerseFound found = ChapterVerseFound.None;
bool fGotVerse = false;
ScrTxtPara para = this; // curent paragraph being examined for reference
int chvoParas = 0; // count of paragraphs in the section
int ihvoPara = 0; // index of the paragraph within the section
BCVRef sectRefStart;
BCVRef sectRefEnd;
GetSectionStartAndEndRefs(out sectRefStart, out sectRefEnd);
while (true)
{
if (para == this)
{
found = para.GetBCVRefAtPosWithinPara(wsBT, ivPos, fAssocPrev, out refStartT,
out refEndT);
}
else
found = para.GetBCVRefAtEndOfPara(out refStartT, out refEndT);
// if we found a verse, remember it
if (!fGotVerse && ((found & ChapterVerseFound.Verse) != 0))
{
refStart.Verse = refStartT.Verse;
refEnd.Verse = refEndT.Verse;
fGotVerse = true;
}
// if we found a chapter, process it
if ((found & ChapterVerseFound.Chapter) != 0)
{
if (sectRefStart != null && !sectRefStart.IsEmpty)
refStart.Book = refEnd.Book = sectRefStart.Book; //may not exist
refStart.Chapter = refEnd.Chapter = refStartT.Chapter;
// GetBCVwithinPara always returns a verse if it finds a chapter number
// so we have already built the full reference
Debug.Assert(fGotVerse);
return;
}
// We got to the beginning of the paragraph being edited and still haven't
// found a decent reference for our edited text, so keep looking back to
// get it from a previous paragraph.
// First time thru, figure out which paragraph we are in
if (chvoParas == 0)
{
// REVIEW (EberhardB): does this work if not all paragraphs are
// loaded in the cache?
chvoParas = m_cache.GetVectorSize(OwnerHVO,
(int)StText.StTextTags.kflidParagraphs);
// Go forward through vector of paragraphs to find the one being parsed
for (ihvoPara = 0; ihvoPara < chvoParas; ihvoPara++)
{
int hvoPara = m_cache.GetVectorItem(OwnerHVO,
(int)StText.StTextTags.kflidParagraphs, ihvoPara);
if (hvoPara == Hvo)
break; // found our current para
}
}
// Move to the previous paragraph
ihvoPara--;
if (ihvoPara < 0)
{
// We are at the beginning of the section. We can't look back any further.
// ENHANCE TomB: If we search all the way through to the beginning of the
// section and never get a valid reference, this section begins in the
// middle of a verse or chapter (unlikely in the case of a verse, but
// quite likely in the case of a chapter). OR (most likely) this edit
// happened at the very beginning of the section, and when we start
// parsing, the first thing we'll get is a decent reference.
// REVIEW: we're using the section reference, but since they don't get
// updated, a change (like removing a chapter) in a previous section
// could mess up this section.
if (fGotVerse)
{
// Use the verse we got previously (already set), along with the
// first chapter for the section and the book, if available.
if (sectRefStart != 0)
{
refStart.Chapter = refEnd.Chapter = sectRefStart.Chapter;
refStart.Book = refEnd.Book = sectRefStart.Book;
}
}
else
{
// REVIEW:
// For now, we're just using the first verse for the section, but this
// could be wrong if the section begins in the middle of a verse bridge
// or misleading if the section just doesn't yet have verse numbers
// marked.
if (sectRefStart != 0)
{
refStart = new BCVRef(sectRefStart);
refEnd = new BCVRef(sectRefStart);
}
// If we are looking for a negative position in the first para of a section
// the needed result is not precisely defined yet,
// but this is where you could set it
// if (para == this && ivPos < 0)
// refStart.Verse = refEnd.Verse = ????;
}
return;
}
// Set up for the previous paragraph in this section, and we'll try again
int hvoNewPara = m_cache.GetVectorItem(OwnerHVO,
(int)StText.StTextTags.kflidParagraphs, ihvoPara);
// use a special constructor since we already know the section refs
para = new ScrTxtPara(m_cache, hvoNewPara, false, false);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Get full reference (BCV-CV) of the given StText. Returns an empty string if we can't find a book name
/// with the given 'ws'.
/// </summary>
/// <param name="stText"></param>
/// <param name="ws"></param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
public ITsString BookChapterVerseBridgeAsTss(StText stText, int ws)
{
ITsString tssTitle = null;
Debug.Assert(Scripture.IsResponsibleFor(stText), "given StText should belong to scripture.");
int owningFlid = stText.OwningFlid;
if (owningFlid == (int)ScrBook.ScrBookTags.kflidFootnotes)
{
ScrFootnote footnote = new ScrFootnote(Cache, stText.Hvo);
string footnoteRefStr = ContainingRefAsString(footnote);
ScrBook book = footnote.Owner as ScrBook;
ITsString tssBook = book.Name.GetAlternativeTss(ws);
if (tssBook.Length > 0)
{
ITsStrBldr bldr = tssBook.GetBldr();
int cch = bldr.Length;
bldr.Replace(cch, cch, " " + footnoteRefStr, null);
tssTitle = bldr.GetString();
}
}
else if (owningFlid == (int)ScrSection.ScrSectionTags.kflidContent ||
owningFlid == (int)ScrSection.ScrSectionTags.kflidHeading)
{
ScrSection section = stText.Owner as ScrSection;
ITsString tssBookChapterVerseBridge = this.BookChapterVerseBridgeAsTss(section, ws);
tssTitle = tssBookChapterVerseBridge;
}
else if (owningFlid == (int)FDO.Scripture.ScrBook.ScrBookTags.kflidTitle)
{
ScrBook book = stText.Owner as ScrBook;
ITsString tssBookName = book.Name.GetAlternativeTss(ws);
if (tssBookName.Length > 0)
{
ITsStrBldr bldr = tssBookName.GetBldr();
int cch = bldr.Length;
bldr.Replace(cch, cch, String.Format(" ({0})",
ResourceHelper.GetResourceString("kstidScriptureTitle")), null);
tssTitle = bldr.GetString();
}
}
else
{
// throw.
}
if (tssTitle == null)
{
// return an empty string.
ITsStrFactory isf = TsStrFactoryClass.Create();
tssTitle = isf.MakeString("", ws);
}
return tssTitle;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Get the Chapter Verse Reference representation for a footnote (ie. sectionCV-CV Footnote(footnoteCV))
/// Or Title representation (ie. Title Footnote(OwnOrd))
/// </summary>
/// <param name="footnote"></param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
public string ContainingRefAsString(ScrFootnote footnote)
{
footnote.IgnoreDisplaySettings = true; // so we can access GetReference.
string parentContext = "";
string footnoteRef = "";
int hvoContainingObj;
if (footnote.TryGetContainingSectionHvo(out hvoContainingObj))
{
ScrSection section = new ScrSection(Cache, hvoContainingObj);
parentContext = ChapterVerseBridgeAsString(section);
footnoteRef = footnote.GetReference(m_cache.DefaultUserWs).Trim();
}
else if (footnote.TryGetContainingTitle(out hvoContainingObj))
{
parentContext = ResourceHelper.GetResourceString("kstidScriptureTitle");
footnoteRef = footnote.OwnOrd.ToString();
}
return String.Format("{0} {1}({2})", parentContext,
ResourceHelper.GetResourceString("kstidScriptureFootnote"), footnoteRef);
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// Get the string that should be displayed in place of an object character associated
/// with the specified GUID.
/// </summary>
/// <param name="bstrGuid"></param>
/// <returns></returns>
/// -----------------------------------------------------------------------------------
public override ITsString GetStrForGuid(string bstrGuid)
{
CheckDisposed();
Debug.Assert(Cache != null);
Debug.Assert(bstrGuid.Length == 8);
Guid guid = MiscUtils.GetGuidFromObjData(bstrGuid);
int hvoObj = Cache.GetIdFromGuid(guid);
if (hvoObj != 0)
{
if (Cache.GetClassOfObject(hvoObj) == StFootnote.kclsidStFootnote)
{
ScrFootnote footnote = new ScrFootnote(Cache, hvoObj);
ITsStrBldr bldr = footnote.MakeFootnoteMarker(DefaultWs);
if (bldr.Length == 0 && Options.ShowMarkerlessIconsSetting)
{
// Use the restore window icon character from Marlett as the
// footnote marker.
ITsPropsBldr propsBldr = bldr.get_Properties(0).GetBldr();
propsBldr.SetStrPropValue((int) FwTextPropType.ktptFontFamily,
"Marlett");
if (PrintLayout) // don't display markerless icon in print layout view
bldr.Replace(0, 0, string.Empty, propsBldr.GetTextProps());
else
bldr.Replace(0, 0, "\u0032", propsBldr.GetTextProps());
}
else if (bldr.Length > 0)
{
// This is to prevent the word-wrap from wrapping at the beginning of
// a footnote marker.
// REVIEW (TimS): \uFEFF is deprecated as a non-break character in Unicode now. Should
// use \u2060 but no fonts/renderers seem to have it defined. Should
// maybe change this eventually.
string directionIndicator = (RightToLeft) ? "\u200F" : "\u200E";
bldr.Replace(0, 0, directionIndicator + "\uFEFF" + directionIndicator, null);
}
bldr.SetIntPropValues(0, bldr.Length,
(int)FwTextPropType.ktptEditable,
(int)FwTextPropVar.ktpvEnum,
(int)TptEditable.ktptNotEditable);
return bldr.GetString();
}
}
// If the GUID was not found then return a missing object string
ITsStrFactory tsf = TsStrFactoryClass.Create();
return tsf.MakeString("<missing object>", Cache.DefaultUserWs);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Creates the ScrFootnote in the given owning ScrBook.
/// The caller must take care of inserting the proper ORC and the footnote's paragraph.
/// </summary>
/// <param name="book">The book that the footnote is being added to</param>
/// <param name="iInsertAt">Zero-based index of the position in the book's sequence of
/// footnotes where the new footnote is to be inserted</param>
/// <param name="sMarker">ref: The marker to use (more or less)</param>
/// <param name="cache">The cache.</param>
/// <param name="ws">The writing system for the footnote marker.</param>
/// <returns>The newly created Footnote object</returns>
/// ------------------------------------------------------------------------------------
private static ScrFootnote CreateScrFootnote(IScrBook book, int iInsertAt, ref string sMarker,
FdoCache cache, int ws)
{
// Create StFootnote object and establish it in the database
StFootnote foot = new StFootnote();
book.FootnotesOS.InsertAt(foot, iInsertAt);
// Construct a ScrFootnote so that its internal variables will get set correctly
ScrFootnote footnote = new ScrFootnote(cache, foot.Hvo);
// Create a default FootnoteMarker property in the StFootnote with
// the correct text properties
ITsTextProps markerProps =
StyleUtils.CharStyleTextProps(ScrStyleNames.FootnoteMarker, ws);
ITsStrBldr tsStrBldrFootnoteMkr = TsStrBldrClass.Create();
// Mark the footnote marker style as being in use.
IScripture scr = cache.LangProject.TranslatedScriptureOA;
IStStyle markerStyle = scr.FindStyle(ScrStyleNames.FootnoteMarker);
markerStyle.InUse = true;
if (sMarker == null)
sMarker = string.Empty;
tsStrBldrFootnoteMkr.Replace(0, 0, sMarker, markerProps);
footnote.FootnoteMarker = tsStrBldrFootnoteMkr.GetString();
// Copy current value of default footnote options to the new footnote.
footnote.DisplayFootnoteReference = scr.DisplayFootnoteReference;
footnote.DisplayFootnoteMarker = scr.DisplayFootnoteMarker;
return footnote;
}
/// ------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="hvoBook">The hvo of the book containing the footnotes</param>
/// <param name="ivMin">The index in the vector of the change</param>
/// <param name="cvIns">the number of footnotes inserted</param>
/// <param name="cvDel">the number of footnotes deleted</param>
/// ------------------------------------------------------------------------------------
protected override void DoEffectsOfPropChange(int hvoBook, int ivMin, int cvIns, int cvDel)
{
bool fNeedToRecalculate = true;
ScrBook book = new ScrBook(m_cache, hvoBook);
if (cvIns > 0)
{
// if we inserted, we only need to recalculate the markers if the inserted footnote
// offset the auto-lettering.
Debug.Assert(ivMin < book.FootnotesOS.Count);
ScrFootnote footnoteIns = new ScrFootnote(m_cache, book.FootnotesOS.HvoArray[ivMin]);
fNeedToRecalculate = (footnoteIns.FootnoteType == FootnoteMarkerTypes.AutoFootnoteMarker);
}
if (fNeedToRecalculate)
ScrFootnote.RecalculateFootnoteMarkers(book, ivMin);
}
public void DeleteFootnoteFromContextMenuIPSelection()
{
CheckDisposed();
MakeFootnoteSelection(1, 1, 1);
// First get the footnote we're deleting.
ScrFootnote footnote = new ScrFootnote(Cache, m_Jude.FootnotesOS.HvoArray[1]);
Guid guidFootnote = Cache.GetGuidFromId(footnote.Hvo);
// Find the paragraph that this footnote is in
int hvoPara = footnote.ContainingParagraphHvo;
m_footnoteView.DeleteFootnote();
Assert.IsFalse(Cache.IsRealObject(footnote.Hvo, StFootnote.kClassId));
// Now make sure that we don't find the footnote marker in the vern or either BT of
// the para that used to contain it.
VerifyRemovedFootnoteMarker(hvoPara, guidFootnote);
VerifyRemovedFootnoteMarker(hvoPara, guidFootnote, InMemoryFdoCache.s_wsHvos.En);
VerifyRemovedFootnoteMarker(hvoPara, guidFootnote, InMemoryFdoCache.s_wsHvos.De);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Write the first paragraph in the given footnote. (TE allows only 1 paragraph in
/// footnotes!)
/// </summary>
/// ------------------------------------------------------------------------------------
private void ExportFootnote(ScrFootnote foot)
{
IStTxtPara para = foot.ParagraphsOS[0] as IStTxtPara;
string sStyle = para.StyleName;
if (String.IsNullOrEmpty(sStyle))
sStyle = "scrFootnote";
else
sStyle = m_xhtml.GetValidCssClassName(sStyle);
ITsStrBldr bldr = foot.MakeFootnoteMarker(m_cache.DefaultVernWs);
string sFootnoteMarker = bldr.Text;
ITsString tssPara = para.Contents.UnderlyingTsString;
m_writer.WriteLine("<span class=\"{0}\" id=\"{1}\" title=\"{2}\">",
sStyle, "F" + foot.Guid.ToString().ToUpperInvariant(), sFootnoteMarker);
m_xhtml.MapCssToLang(sStyle, LanguageCode(StringUtils.GetWsAtOffset(tssPara, 0)));
WriteTsStringAsXml(tssPara, 4);
m_writer.WriteLine("</span>");
// The following class is inserted by the XSLT processing.
m_xhtml.MapCssToLang("scrFootnoteMarker", LanguageCode(m_cache.DefaultVernWs));
}
public void GetRefForCrossRef_Scripture_DontDisplay()
{
CheckDisposed();
ScrFootnote footnote = new ScrFootnote(Cache, m_genesis.FootnotesOS.HvoArray[1]);
StTxtPara para = new StTxtPara();
footnote.ParagraphsOS.Append(para);
para.StyleRules = StyleUtils.ParaStyleTextProps(ScrStyleNames.CrossRefFootnoteParagraph);
m_scr.DisplayFootnoteReference = true; // Just to make sure it's not using this by mistake
m_scr.CrossRefsCombinedWithFootnotes = false;
m_scr.DisplayCrossRefReference = false;
Assert.AreEqual(string.Empty, footnote.RefAsString);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Display the footnote marker.
/// </summary>
/// <param name="vwenv">View environment</param>
/// <param name="footnote">The footnote.</param>
/// ------------------------------------------------------------------------------------
private void DisplayFootnoteMarker(IVwEnv vwenv, ScrFootnote footnote)
{
vwenv.NoteDependency(new int[] { footnote.Hvo },
new int[] { (int)StFootnote.StFootnoteTags.kflidFootnoteMarker }, 1);
// The footnote marker is not editable.
vwenv.set_IntProperty((int)FwTextPropType.ktptEditable,
(int)FwTextPropVar.ktpvEnum,
(int)TptEditable.ktptNotEditable);
ITsStrBldr strBldr = footnote.MakeFootnoteMarker(DefaultWs);
strBldr.Replace(strBldr.Length, strBldr.Length, " ", null);
vwenv.AddString(strBldr.GetString());
}
public void FootnoteRefVerseBridge()
{
CheckDisposed();
ScrFootnote footnote = new ScrFootnote(Cache, m_genesis.FootnotesOS.HvoArray[2]);
StTxtPara footnotePara = new StTxtPara();
footnote.ParagraphsOS.Append(footnotePara);
footnotePara.StyleRules = StyleUtils.ParaStyleTextProps(ScrStyleNames.NormalFootnoteParagraph);
m_scr.DisplayFootnoteReference = true;
// Add a new verse bridge
IScrSection section = m_genesis.SectionsOS[1];
StTxtPara para = (StTxtPara) section.ContentOA.ParagraphsOS[1];
ITsStrBldr bldr = para.Contents.UnderlyingTsString.GetBldr();
bldr.Replace(1, 1, "-9", StyleUtils.CharStyleTextProps(ScrStyleNames.VerseNumber,
Cache.DefaultVernWs));
para.Contents.UnderlyingTsString = bldr.GetString();
// Give property change event related to verse insert.
Cache.PropChanged(null, PropChangeType.kpctNotifyAll,
para.Hvo, StTxtPara.ktagVerseNumbers, 0, 1, 1); // char positions and counts are ignored
// Verify that reference for footnote is now correct
Assert.AreEqual("1:5-9 ", footnote.RefAsString);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// This is the main interesting method of displaying objects and fragments of them.
/// Scripture Footnotes are displayed by displaying each footnote's reference and text.
/// The text is displayed using the standard view constructor for StText.
/// </summary>
/// <param name="vwenv"></param>
/// <param name="hvo"></param>
/// <param name="frag"></param>
/// ------------------------------------------------------------------------------------
public override void Display(IVwEnv vwenv, int hvo, int frag)
{
CheckDisposed();
switch (frag)
{
case (int)FootnoteFrags.kfrScripture:
{
vwenv.NoteDependency(new int[] { m_cache.LangProject.TranslatedScriptureOAHvo },
new int[] { (int)Scripture.ScriptureTags.kflidScriptureBooks }, 1);
vwenv.AddLazyVecItems(BooksTag, this, (int)FootnoteFrags.kfrBook);
break;
}
case (int)FootnoteFrags.kfrRootInPageSeq:
{
int tag = DummyVirtualHandler.InstallDummyHandler(m_cache.VwCacheDaAccessor,
"Scripture", "FootnotesOnPage",
(int)CellarModuleDefns.kcptReferenceSequence).Tag;
// Get the list of footnotes to display
int[] hvos = m_cache.GetVectorProperty(hvo, tag, true);
if (hvos.Length > 0)
{
int ownerHvo = m_cache.GetOwnerOfObject(hvos[0]);
// The ownerHvo should be the HVO of the book
vwenv.NoteDependency(new int[] { ownerHvo },
new int[] { (int)ScrBook.ScrBookTags.kflidFootnotes }, 1);
}
vwenv.AddObjVec(tag, this, (int)FootnoteFrags.kfrAllFootnotesWithinPagePara);
break;
}
case (int)FootnoteFrags.kfrFootnoteWithinPagePara:
{
// Note a dependency on the footnote options so that the footnote will
// be refreshed when these are changed.
int[] depHvos = { hvo };
int[] depTags = { StFootnote.ktagFootnoteOptions };
vwenv.NoteDependency(depHvos, depTags, 1);
// Insert the marker and reference
vwenv.AddObj(hvo, this, (int)StTextFrags.kfrFootnoteMarker);
vwenv.AddObj(hvo, this,(int)StTextFrags.kfrFootnoteReference);
// Insert (we hope only one) paragraph contents.
vwenv.AddObjVecItems((int)StText.StTextTags.kflidParagraphs, this,
(int)FootnoteFrags.kfrFootnoteParaWithinPagePara);
break;
}
case (int) FootnoteFrags.kfrFootnoteParaWithinPagePara:
{
if (!InsertParaContentsUserPrompt(vwenv, hvo))
{
// Display the text paragraph contents, or its user prompt.
vwenv.AddStringProp((int)StTxtPara.StTxtParaTags.kflidContents, null);
}
break;
}
case (int)FootnoteFrags.kfrBook:
{
vwenv.OpenDiv();
vwenv.AddObjVecItems((int)ScrBook.ScrBookTags.kflidFootnotes, this,
(int)StTextFrags.kfrFootnote);
vwenv.CloseDiv();
break;
}
case (int)StTextFrags.kfrFootnoteMarker:
{
ScrFootnote footnote = new ScrFootnote(Cache, hvo);
if (footnote.DisplayFootnoteMarker)
DisplayFootnoteMarker(vwenv, footnote);
break;
}
case (int)StTextFrags.kfrFootnoteReference:
{
ITsStrFactory tsStrFactory = TsStrFactoryClass.Create();
ITsPropsFactory tpf = TsPropsFactoryClass.Create();
ITsTextProps ttp = tpf.MakeProps(ScrStyleNames.FootnoteTargetRef, m_wsDefault, 0);
ScrFootnote footnote = new ScrFootnote(m_cache, hvo);
string footnoteRef = footnote.GetReference(m_wsDefault);
ITsString tssRef = tsStrFactory.MakeStringWithPropsRgch(footnoteRef,
footnoteRef.Length, ttp);
vwenv.set_IntProperty((int)FwTextPropType.ktptEditable,
(int)FwTextPropVar.ktpvEnum,
(int)TptEditable.ktptNotEditable);
vwenv.AddString(tssRef);
break;
}
default:
base.Display(vwenv, hvo, frag);
break;
}
}
public void GetMarkerForCrossRef_Scripture_LiteralSymbol()
{
CheckDisposed();
ScrFootnote footnote = new ScrFootnote(Cache, m_genesis.FootnotesOS.HvoArray[1]);
StTxtPara para = new StTxtPara();
footnote.ParagraphsOS.Append(para);
para.StyleRules = StyleUtils.ParaStyleTextProps(ScrStyleNames.CrossRefFootnoteParagraph);
ITsStrFactory factory = TsStrFactoryClass.Create();
m_scr.CrossRefMarkerType = FootnoteMarkerTypes.SymbolicFootnoteMarker;
m_scr.CrossRefMarkerSymbol = "$";
m_scr.FootnoteMarkerType = FootnoteMarkerTypes.AutoFootnoteMarker; // Just to make sure it's not using this by mistake
AssertEx.AreTsStringsEqual(MakeMarker("$"), footnote.FootnoteMarker);
}
public void AboutToDelete_CorrectFootnoteOwner()
{
CheckDisposed();
IScrBook philemon = m_scrInMemoryCache.AddBookToMockedScripture(57, "Philemon");
IScrSection section = m_scrInMemoryCache.AddSectionToMockedBook(philemon.Hvo);
section.VerseRefStart = section.VerseRefEnd = 57001001;
StTxtPara para1 = m_scrInMemoryCache.AddParaToMockedSectionContent(section.Hvo, ScrStyleNames.NormalParagraph);
m_scrInMemoryCache.AddRunToMockedPara(para1, "this is some text", null);
StTxtPara para2 = m_scrInMemoryCache.AddParaToMockedSectionContent(section.Hvo, ScrStyleNames.NormalParagraph);
m_scrInMemoryCache.AddRunToMockedPara(para2, "this is some more text", null);
StFootnote fn = m_scrInMemoryCache.AddFootnote(philemon, para2, 12);
// force the footnote cache to be built now if it wasn't earlier.
philemon = new ScrBook(m_scrInMemoryCache.Cache, philemon.Hvo);
ScrFootnote footnote = new ScrFootnote(m_scrInMemoryCache.Cache, fn.Hvo);
Assert.AreEqual(para2.Hvo, footnote.ContainingParagraphHvo, "Footnote containing paragraph not setup correctly");
// check the normal case - fMergeNext is false
m_editingHelper.SetupSelectionInPara(para2, 1, section, 0, philemon, 0, 0, false);
m_editingHelper.AboutToDelete(m_editingHelper.CurrentSelection, para2.Hvo, para2.OwnerHVO,
(int)StText.StTextTags.kflidParagraphs, 1, false);
Assert.AreEqual(para1.Hvo, footnote.ContainingParagraphHvo, "Footnote containing paragraph not updated on paragraph merge - fMergeNext = false");
// check the special case for an empty paragraph - fMergeNext is true
m_editingHelper.SetupSelectionInPara(para1, 0, section, 0, philemon, 0, 0, false);
m_editingHelper.AboutToDelete(m_editingHelper.CurrentSelection, para1.Hvo, para1.OwnerHVO,
(int)StText.StTextTags.kflidParagraphs, 0, true);
Assert.AreEqual(para2.Hvo, footnote.ContainingParagraphHvo, "Footnote containing paragraph not updated on paragraph merge - fMergeNext = true");
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Deletes footnotes when there is a range selection.
/// </summary>
/// <param name="helper"></param>
/// ------------------------------------------------------------------------------------
private void DeleteFootnoteRange(SelectionHelper helper)
{
int nTopLevels = helper.GetNumberOfLevels(SelectionHelper.SelLimitType.Top);
int nBottomLevels = helper.GetNumberOfLevels(SelectionHelper.SelLimitType.Bottom);
// Get the index of the book containing the first footnote in the selection.
// Then get the index of the footnote within that book.
int iFirstBook =
helper.GetLevelInfo(SelectionHelper.SelLimitType.Top)[nTopLevels-1].ihvo;
int iFirstFootnote =
helper.GetLevelInfo(SelectionHelper.SelLimitType.Top)[nTopLevels-2].ihvo;
// Get the index of the book containing the last footnote in the selection.
// Then get the index of the footnote within that book.
int iLastBook =
helper.GetLevelInfo(SelectionHelper.SelLimitType.Bottom)[nBottomLevels-1].ihvo;
int iLastFootnote =
helper.GetLevelInfo(SelectionHelper.SelLimitType.Bottom)[nBottomLevels-2].ihvo;
// Loop through the books containing footnotes in the selection.
for (int iBook = iFirstBook; iBook <= iLastBook; iBook++)
{
ScrBook book = BookFilter.GetBook(iBook);
int iBeg = iFirstFootnote;
if (iFirstBook != iLastBook && iBook > iFirstBook)
iBeg = 0;
int iEnd = iLastFootnote;
if (iFirstBook != iLastBook && iBook < iLastBook)
iEnd = book.FootnotesOS.Count - 1;
// Loop through the footnotes from the selection that are in the
// current book. Go in reverse order through the collection.
for (int i = iEnd; i >= iBeg; i--)
{
// TODO: check filter for each HVO
ScrFootnote footnote = new ScrFootnote(m_fdoCache, book.FootnotesOS[i].Hvo);
ScrFootnote.DeleteFootnoteAndMarker(footnote);
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Deletes a footnote along with its marker in the text. This also recalculates the
/// footnote markers of following footnotes.
/// </summary>
/// <param name="footnote"></param>
/// ------------------------------------------------------------------------------------
public static void DeleteFootnoteAndMarker(ScrFootnote footnote)
{
// Paragraph changes are not monitored by cache - refresh cache for book before
// doing deletion
IScrBook book = new ScrBook(footnote.Cache, footnote.OwnerHVO);
// REVIEW: Probably not needed now??? ((ScrBook)book).RefreshFootnoteRefs();
// Get paragraph containing footnote and search for run having footnote ref.
int hvoPara = footnote.ContainingParagraphHvo;
if (hvoPara != 0)
{
StTxtPara para = new StTxtPara(footnote.Cache, hvoPara);
para.DeleteAnyBtMarkersForFootnote(footnote.Guid);
ITsString tssContent = para.Contents.UnderlyingTsString;
TsRunInfo runInfo = new TsRunInfo();
int i;
for (i = 0; i < tssContent.RunCount; i++)
{
ITsTextProps textProps = tssContent.FetchRunInfo(i, out runInfo);
string strGuid =
textProps.GetStrPropValue((int)FwTextPropType.ktptObjData);
if (strGuid != null)
{
Guid guid = MiscUtils.GetGuidFromObjData(strGuid.Substring(1));
if (footnote.Guid == guid)
break;
}
}
System.Diagnostics.Debug.Assert(i < tssContent.RunCount, "Footnote marker not found in text");
// Remove footnote ref from paragraph - then delete the footnote
ITsStrBldr bldr = tssContent.GetBldr();
bldr.Replace(runInfo.ichMin, runInfo.ichLim, string.Empty, null);
para.Contents.UnderlyingTsString = bldr.GetString();
}
DeleteFootnote(footnote);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Delete all footnotes between firstFootnoteToDelete and lastFootnoteToDelete.
/// </summary>
/// <remarks>Use this version of DeleteFootnotes() when there is no need to clean up
/// ORCs in corresponding BTs, such as when the deletion being performed is deleting
/// only entire paragraphs.</remarks>
/// <param name="book">Book that contains the sections to delete</param>
/// <param name="firstFootnoteToDelete">First footnote that will be deleted
/// (might be null).</param>
/// <param name="lastFootnoteToDelete">Last footnote that will be deleted
/// (might be null).</param>
/// ------------------------------------------------------------------------------------
private void DeleteFootnotes(IScrBook book, ScrFootnote firstFootnoteToDelete,
ScrFootnote lastFootnoteToDelete)
{
DeleteFootnotes(book, firstFootnoteToDelete, lastFootnoteToDelete, 0, 0);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Recalculates footnote markers for all footnotes in book starting at the given
/// footnote index.
/// </summary>
/// <param name="book"></param>
/// <param name="iStartAt"></param>
/// ------------------------------------------------------------------------------------
public static void RecalculateFootnoteMarkers(IScrBook book, int iStartAt)
{
FdoCache cache = book.Cache;
IScripture scr = cache.LangProject.TranslatedScriptureOA;
// Paragraph changes are not monitored by cache - refresh cache for book before
// doing recalculation
((ScrBook)book).RefreshFootnoteRefs();
if (cache.MarkerIndexCache == null)
cache.MarkerIndexCache = new FootnoteMarkerIndexCache(cache);
int hvoPrevPara = 0;
ScrFootnote footnote = null;
FdoOwningSequence<IStFootnote> footnotes = book.FootnotesOS;
for (int i = iStartAt; i < footnotes.Count; i++)
{
footnote = new ScrFootnote(cache, footnotes.HvoArray[i]);
bool refreshFootnote =
cache.MarkerIndexCache.GetDirtyFlagForFootnote(footnote.Hvo);
if (refreshFootnote && footnote != null)
{
cache.MarkerIndexCache.ClearDirtyFlagForFootnote(footnote.Hvo);
cache.PropChanged(null, PropChangeType.kpctNotifyAll,
footnote.Hvo, (int)StFootnote.StFootnoteTags.kflidFootnoteMarker, 0, 1, 1);
// Give a notification to the paragraph when all markers have been
// updated so that it will display the updated footnote markers.
if (footnote.HasORCInVernacular)
{
int hvoPara = footnote.ContainingParagraphHvo;
if (hvoPara != hvoPrevPara && hvoPrevPara != 0)
{
using (new IgnorePropChanged(cache, PropChangedHandling.SuppressChangeWatcher))
{
cache.PropChanged(null, PropChangeType.kpctNotifyAll,
hvoPrevPara, (int)StTxtPara.StTxtParaTags.kflidContents,
0, 1, 1);
}
}
hvoPrevPara = hvoPara;
}
}
}
// Give a notification for the last paragraph so that it will display
// the updated footnote markers.
if (hvoPrevPara != 0)
{
using (new IgnorePropChanged(cache, PropChangedHandling.SuppressChangeWatcher))
{
cache.PropChanged(null, PropChangeType.kpctNotifyAll,
hvoPrevPara, (int)StTxtPara.StTxtParaTags.kflidContents, 0, 1, 1);
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Adds the overrides to highlight a footnote diff.
/// </summary>
/// <param name="hvo">The hvo of the footnote paragraph.</param>
/// ------------------------------------------------------------------------------------
private void AddOverridesToHighlightFootnoteDiff(int hvo)
{
Difference diff = FindSubDiffForFootnote(hvo);
if (diff == null)
return;
StTxtPara para = new StTxtPara(Cache, hvo);
// Get the footnote which contains the paragraph.
int ownerHvo = para.OwnerHVO;
Debug.Assert(m_cache.GetClassOfObject(ownerHvo) == StFootnote.kClassId);
if (m_cache.GetClassOfObject(ownerHvo) != StFootnote.kClassId)
return; //don't override the props for this para; continue on gracefully
ScrFootnote footnote = new ScrFootnote(Cache, ownerHvo);
// Only add offset to first paragraph in footnote (should only be one para)
int offset = 0;
if (footnote.ParagraphsOS[0].Hvo == hvo)
{
int refLength = footnote.GetReference(m_wsDefault).Length;
int markerLength = footnote.FootnoteMarker.Length;
//add one for the space in between (added in StVc)
offset = refLength + markerLength + 1;
}
const uint knNinch = 0x80000000;
// Now add appropriate properties.
// Need to add override properties for each run in the
// range to be highlighted.
int ichOverrideMin = diff.GetIchMin(m_fRev);
ITsString tss = para.Contents.UnderlyingTsString;
TsRunInfo runInfo;
int ichOverrideLim;
int prevLim = 0;
do
{
tss.FetchRunInfoAt(ichOverrideMin, out runInfo);
ichOverrideLim = Math.Min(diff.GetIchLim(m_fRev), runInfo.ichLim);
// Prevent infinite loop in case of bad data in difference
if (ichOverrideLim == prevLim)
break;
prevLim = ichOverrideLim;
DispPropOverride prop = new DispPropOverride();
prop.chrp.clrBack = DiffViewVc.kHighlightColor;
prop.chrp.clrFore = knNinch;
prop.chrp.clrUnder = knNinch;
prop.chrp.dympOffset = -1;
prop.chrp.ssv = -1;
prop.chrp.unt = -1;
prop.chrp.ttvBold = -1;
prop.chrp.ttvItalic = -1;
prop.chrp.dympHeight = -1;
prop.chrp.szFaceName = null;
prop.chrp.szFontVar = null;
prop.ichMin = ichOverrideMin + offset;
prop.ichLim = ichOverrideLim + offset;
m_DispPropOverrides.Add(prop);
ichOverrideMin = ichOverrideLim;
}
while (ichOverrideLim < diff.GetIchLim(m_fRev));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Loads the footnotes.
/// </summary>
/// <param name="footnoteHvo">The footnote hvo.</param>
/// ------------------------------------------------------------------------------------
private void LoadFootnotes(int footnoteHvo)
{
Debug.Assert(m_cache.GetClassOfObject(footnoteHvo) == StFootnote.kClassId);
StFootnote foot = new StFootnote(m_cache, footnoteHvo);
IScrBook book = new ScrBook(m_cache, foot.OwnerHVO);
int footnoteCount = GetBookFootnoteCount(book.Hvo);
FdoOwningSequence<IStFootnote> footnotes = book.FootnotesOS;
// If the information we want is already in the cache, then do nothing
if (footnotes.Count == footnoteCount && m_htFootnoteIndex.ContainsKey(footnoteHvo))
return;
ScrFootnote footnote = null;
int index = 0;
for (int i = 0; i < footnotes.Count; i++)
{
footnote = new ScrFootnote(m_cache, footnotes.HvoArray[i]);
if (footnote.FootnoteType == FootnoteMarkerTypes.AutoFootnoteMarker)
{
int oldIndex = GetFootnoteIndex(footnote.Hvo);
if (oldIndex != index)
m_htFootnoteIndex[footnote.Hvo] = new FootnoteIndexCacheInfo(index, true);
index++;
}
}
m_htBookFootnoteCount[book.Hvo] = footnotes.Count;
}