/// ------------------------------------------------------------------------------------
/// <summary>
/// Determine where in the annotation list to insert a new annotation having the
/// specified startRef, beginning object and beginning offset.
/// </summary>
/// <param name="startRef">The start ref.</param>
/// <param name="beginObject">The begin object.</param>
/// <param name="begOffset">The beg offset.</param>
/// ------------------------------------------------------------------------------------
private int GetNewNotesInsertIndex(BCVRef startRef, ICmObject beginObject, int begOffset)
{
// Get the index within the book of the section containing the paragraph
// containing the reference to which the new annotation corresponds.
int iNewNoteSection;
int iNewNotePara;
GetLocationInfoForObj(beginObject, out iNewNoteSection, out iNewNotePara);
FdoOwningSequence <IScrScriptureNote> notes = NotesOS;
int insertIndex = notes.Count;
// Go backward through the list of existing annotations.
for (int i = notes.Count - 1; i >= 0; i--)
{
IScrScriptureNote note = notes[i];
int iSect, iPara;
GetLocationInfoForObj(note.BeginObjectRA, out iSect, out iPara);
// If the annotation is for text that follows the text associated
// with the new annotation we're adding, then decrement the index
// of where to insert the new annotation.
if (note.BeginRef > startRef || iSect > iNewNoteSection ||
(iSect == iNewNoteSection && iPara > iNewNotePara) ||
(iSect == iNewNoteSection && iPara == iNewNotePara && note.BeginOffset > begOffset))
{
insertIndex--;
}
}
return(insertIndex);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Writes this category to the the specified annotation, creating a new category if
/// needed.
/// </summary>
/// ------------------------------------------------------------------------------------
internal void WriteToCache(IScrScriptureNote ann)
{
int ws = (string.IsNullOrEmpty(IcuLocale) ? ann.Cache.DefaultAnalWs :
ScrNoteImportManager.GetWsForLocale(IcuLocale));
ICmPossibility category;
if (CategoryPath.IndexOf(StringUtils.kChObject) != -1)
{
// The category specified the full path of the category possibility.
category = ann.Cache.LangProject.TranslatedScriptureOA.NoteCategoriesOA.FindOrCreatePossibility(
CategoryPath, ws);
}
else
{
// The category does not contain a delimiter, so we may need to search
// the entire possibility tree for a matching category in case it is a
// sub-possibility.
category = ann.Cache.LangProject.TranslatedScriptureOA.NoteCategoriesOA.FindOrCreatePossibility(
CategoryPath, ws, false);
}
IFdoReferenceSequence <ICmPossibility> categoryList = ann.CategoriesRS;
if (!categoryList.Contains(category))
{
categoryList.Add(category);
}
}
public void ExportNotationParagraphs_WritingSystems()
{
IScrSection section = m_scrInMemoryCache.AddSectionToMockedBook(m_book.Hvo);
StTxtPara para = m_scrInMemoryCache.AddParaToMockedSectionContent(section.Hvo,
ScrStyleNames.NormalParagraph);
IScrScriptureNote note = m_scrInMemoryCache.AddAnnotation(para, new BCVRef(01001001),
NoteType.Translator, "This is some text with espa\u00F1ol.");
TsStringAccessor tssaDisc = ((StTxtPara)note.DiscussionOA.ParagraphsOS[0]).Contents;
ITsStrBldr bldr = tssaDisc.UnderlyingTsString.GetBldr();
bldr.SetProperties(bldr.Length - 8, bldr.Length - 1,
StyleUtils.CharStyleTextProps(null, InMemoryFdoCache.s_wsHvos.Es));
tssaDisc.UnderlyingTsString = bldr.GetString();
StringWriter stream = new StringWriter();
XmlTextWriter writer = new XmlTextWriter(stream);
m_exporter = new ExportXml(null, Cache, null, ExportWhat.AllBooks, 0, 0, 0,
"ExportNotationParagraphs_WritingSystems");
ReflectionHelper.SetField(m_exporter, "m_writer", writer);
ReflectionHelper.CallMethod(m_exporter, "ExportNotationParagraphs", note.DiscussionOA,
"notationDiscussion");
Assert.AreEqual("<notationDiscussion><para xml:lang=\"en\">" +
"<span>This is some text with </span>" +
"<span xml:lang=\"es\">espa\u00F1ol</span>" +
"<span>.</span>" +
"</para></notationDiscussion>", stream.ToString());
}
public void ExportNotationParagraphs_Hyperlink()
{
IScrSection section = m_scrInMemoryCache.AddSectionToMockedBook(m_book.Hvo);
StTxtPara para = m_scrInMemoryCache.AddParaToMockedSectionContent(section.Hvo,
ScrStyleNames.NormalParagraph);
IScrScriptureNote note = m_scrInMemoryCache.AddAnnotation(para, new BCVRef(01001001),
NoteType.Translator, "This is some text with a hyperlink!");
TsStringAccessor tssaDisc = ((StTxtPara)note.DiscussionOA.ParagraphsOS[0]).Contents;
tssaDisc.MarkTextAsHyperlink(tssaDisc.Length - 10, tssaDisc.Length - 1,
"http://www.myspace.com", m_stylesheet);
StringWriter stream = new StringWriter();
XmlTextWriter writer = new XmlTextWriter(stream);
m_exporter = new ExportXml(null, Cache, null, ExportWhat.AllBooks, 0, 0, 0,
"ExportNotationParagraphs_Hyperlink");
ReflectionHelper.SetField(m_exporter, "m_writer", writer);
ReflectionHelper.CallMethod(m_exporter, "ExportNotationParagraphs", note.DiscussionOA,
"notationDiscussion");
Assert.AreEqual("<notationDiscussion><para xml:lang=\"en\">" +
"<span>This is some text with a </span>" +
"<a href=\"http://www.myspace.com\">hyperlink</a>" +
"<span>!</span>" +
"</para></notationDiscussion>", stream.ToString());
}
public static bool Serialize(XmlTextWriter writer, IScrScriptureNote ann,
string languageInFocus)
{
if (writer == null || ann == null)
{
return(false);
}
try
{
FdoCache cache = ann.Cache;
ILgWritingSystemFactory lgwsf = cache.LanguageWritingSystemFactoryAccessor;
XmlScrNote xmlNote = new XmlScrNote(ann, cache.DefaultAnalWs, lgwsf);
if (!string.IsNullOrEmpty(xmlNote.Type))
{
if (!string.IsNullOrEmpty(languageInFocus))
{
xmlNote.LanguageInFocus = languageInFocus;
}
xmlNote.m_serializingForOxes = true;
return(XmlSerializationHelper.SerializeDataAndWriteAsNode(writer, xmlNote));
}
}
catch
{
// TODO: Report something useful.
}
return(false);
}
public void ExistingAnnotation_WithResponses()
{
IScrScriptureNote existingAnn =
AddAnnotation(null, 02002008, NoteType.Translator, "This is my discussion");
existingAnn.ResolutionStatus = NoteStatus.Open;
IStJournalText exisingResponse1 = Cache.ServiceLocator.GetInstance <IStJournalTextFactory>().Create();
existingAnn.ResponsesOS.Add(exisingResponse1);
AddParasTo(exisingResponse1, "This is my first response");
IStJournalText exisingResponse2 = Cache.ServiceLocator.GetInstance <IStJournalTextFactory>().Create();
existingAnn.ResponsesOS.Add(exisingResponse2);
AddParasTo(exisingResponse2, "This is my second response");
DateTime now = DateTime.Now;
DateTime utcNow = now.ToUniversalTime();
XmlScrNote ann = CreateNote();
ann.BeginScrRef = "EXO 2:8";
ann.ResolutionStatus = NoteStatus.Open;
ann.AnnotationTypeGuid = CmAnnotationDefnTags.kguidAnnTranslatorNote.ToString();
ann.DateTimeCreated = utcNow.ToString();
ann.DateTimeModified = utcNow.AddDays(1).ToString();
AddParasTo(ann.Discussion, "This is my discussion");
XmlNoteResponse firstResponse = new XmlNoteResponse();
AddParasTo(firstResponse.Paragraphs, "This is my first response");
ann.Responses.Add(firstResponse);
XmlNoteResponse secondResponse = new XmlNoteResponse();
AddParasTo(secondResponse.Paragraphs, "This is my second response");
ann.Responses.Add(secondResponse);
DummyXmlScrAnnotationsList list = new DummyXmlScrAnnotationsList();
list.Annotations.Add(ann);
list.CallWriteToCache(Cache, m_stylesheet);
IScrBookAnnotations annotations = m_scr.BookAnnotationsOS[1];
Assert.AreEqual(1, annotations.NotesOS.Count);
IScrScriptureNote note = annotations.NotesOS[0];
Assert.AreEqual(NoteType.Translator, note.AnnotationType);
Assert.IsTrue(AreDateTimesClose(now, note.DateCreated));
Assert.IsTrue(AreDatesClose(now.AddDays(1), note.DateModified));
Assert.AreEqual(DateTime.MinValue, note.DateResolved);
IFdoOwningSequence <IStJournalText> responses = note.ResponsesOS;
Assert.AreEqual(2, responses.Count);
TestAnnotationField(responses[0], "This is my first response");
TestAnnotationField(responses[1], "This is my second response");
}
private IScrScriptureNote FindOrCreateAnnotation(FwStyleSheet styleSheet)
{
FdoCache cache = styleSheet.Cache;
ParagraphCollection parasQuote = new ParagraphCollection(Quote, styleSheet, cache.DefaultVernWs);
ParagraphCollection parasDiscussion = new ParagraphCollection(Discussion, styleSheet);
ParagraphCollection parasRecommendation = new ParagraphCollection(Suggestion, styleSheet);
ParagraphCollection parasResolution = new ParagraphCollection(Resolution, styleSheet);
if (m_guidType == Guid.Empty)
{
m_guidType = CmAnnotationDefnTags.kguidAnnConsultantNote;
}
ScrAnnotationInfo info = new ScrAnnotationInfo(m_guidType, parasDiscussion,
parasQuote, parasRecommendation, parasResolution, BeginOffset,
BeginScrBCVRef, EndScrBCVRef, m_createdDate);
IScrScriptureNote scrNote =
ScrNoteImportManager.FindOrCreateAnnotation(info, m_guidBegObj);
parasQuote.WriteToCache(scrNote.QuoteOA);
parasDiscussion.WriteToCache(scrNote.DiscussionOA);
parasRecommendation.WriteToCache(scrNote.RecommendationOA);
parasResolution.WriteToCache(scrNote.ResolutionOA);
return(scrNote);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Attaches the annotated objects to the specifed annotation.
/// </summary>
/// ------------------------------------------------------------------------------------
private static void AttachAnnotatedObjects(IScripture scr, int bookNum,
IScrScriptureNote scrNote)
{
int iSection, iPara, ichStart, ichEnd;
ScrReference scrRef = new ScrReference(scrNote.BeginRef, scr.Versification);
if (TeEditingHelper.FindTextInVerse(scr, scrNote.CitedTextTss,
scrRef, true, out iSection, out iPara, out ichStart, out ichEnd))
{
IScrBook book = scr.FindBook(bookNum);
Debug.Assert(book != null);
scrNote.BeginOffset = ichStart;
scrNote.EndOffset = ichEnd;
if (iSection == -1)
{
scrNote.BeginObjectRA = scrNote.EndObjectRA = book.TitleOA.ParagraphsOS[iPara];
}
else
{
scrNote.BeginObjectRA = scrNote.EndObjectRA =
book.SectionsOS[iSection].ContentOA.ParagraphsOS[iPara];
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Shows the category chooser dialog to let the user set the category for the
/// specified annotation.
/// </summary>
/// ------------------------------------------------------------------------------------
private void SetAnnotationCategory(IScrScriptureNote ann)
{
if (ann == null)
{
return; // Not much we can do
}
m_rootb.DestroySelection();
string sUndo, sRedo;
TeResourceHelper.MakeUndoRedoLabels("kstidSetAnnotationCategory", out sUndo, out sRedo);
using (new WaitCursor(this))
using (CategoryChooserDlg dlg = new CategoryChooserDlg(m_scr.NoteCategoriesOA,
ann.CategoriesRS.ToHvoArray(), m_helpTopicProvider, TheMainWnd.App))
{
if (dlg.ShowDialog(ParentForm) == DialogResult.OK)
{
using (UndoTaskHelper undoHelper = new UndoTaskHelper(this, sUndo, sRedo))
{
dlg.GetPossibilities(ann.CategoriesRS);
ann.DateModified = DateTime.Now;
undoHelper.RollBack = false;
}
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the Scripture reference of the specified annotation as string.
/// </summary>
/// <param name="ann">The specified annotation.</param>
/// ------------------------------------------------------------------------------------
private string GetRefAsString(IScrScriptureNote ann)
{
BCVRef startRef = new BCVRef(ann.BeginRef);
IScrBook book = m_scr.FindBook(startRef.Book);
string bookName;
// Book for note may not be in the project.
if (book != null)
{
bookName = book.BestUIName;
}
else
{
IScrBookRef bookRef = Cache.ServiceLocator.GetInstance <IScrRefSystemRepository>().Singleton.BooksOS[startRef.Book - 1];
ITsString tsName = bookRef.BookName.get_String(Cache.DefaultUserWs);
if (tsName.Length == 0)
{
tsName = bookRef.BookName.BestAnalysisAlternative;
}
bookName = tsName.Text;
}
string titleText = ResourceHelper.GetResourceString("kstidScriptureTitle");
string introText = ResourceHelper.GetResourceString("kstidScriptureIntro");
return(BCVRef.MakeReferenceString(bookName, startRef, new BCVRef(ann.EndRef),
m_scr.ChapterVerseSepr, m_scr.Bridge, titleText, introText));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Writes this response to the the specified annotation
/// </summary>
/// ------------------------------------------------------------------------------------
public void WriteToCache(IScrScriptureNote ann, FwStyleSheet styleSheet)
{
ParagraphCollection parasResponse = new ParagraphCollection(Paragraphs, styleSheet);
ParagraphCollection.ParaMatchType type;
int matchIndex = FindMatchingResponse(parasResponse, ann.ResponsesOS, out type);
switch (type)
{
case ParagraphCollection.ParaMatchType.Exact:
case ParagraphCollection.ParaMatchType.Contains:
break; // we can ignore the new response -- it's a subset of the old.
case ParagraphCollection.ParaMatchType.IsContained:
IStJournalText oldText = ann.ResponsesOS[matchIndex];
oldText.ParagraphsOS.Clear();
parasResponse.WriteToCache(oldText);
break;
case ParagraphCollection.ParaMatchType.None:
IStJournalText newText = ann.Cache.ServiceLocator.GetInstance <IStJournalTextFactory>().Create();
ann.ResponsesOS.Add(newText);
parasResponse.WriteToCache(newText);
break;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Create and Check an Annotation
/// </summary>
/// <param name="hvoParaStart">The hvo para start.</param>
/// <param name="hvoParaEnd">The hvo para end.</param>
/// <param name="startRef">The start ref.</param>
/// <param name="endRef">The end ref.</param>
/// <param name="startOffset">The start offset.</param>
/// <param name="endOffset">The end offset.</param>
/// <param name="tssQuote">The text in the quote.</param>
/// <param name="sel">selection in main window</param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
private IScrScriptureNote CreateAndCheckAnnotation(int hvoObjStart, int hvoObjEnd,
int startRef, int endRef, int startOffset, int endOffset, string strQuote)
{
ILangProject lp = Cache.LangProject;
CmAnnotationDefn transNoteAnnDefn = new CmAnnotationDefn(Cache,
LangProject.kguidAnnTranslatorNote);
// Get information from the selection about the location of the annotation.
CmObject topObj = (CmObject)CmObject.CreateFromDBObject(m_inMemoryCache.Cache, hvoObjStart);
CmObject bottomObj = (CmObject)CmObject.CreateFromDBObject(m_inMemoryCache.Cache, hvoObjEnd);
int wsSelector = -1;
ITsStrBldr tssBldrQuote = TsStrBldrClass.Create();
tssBldrQuote.Replace(0, 0, strQuote, StyleUtils.ParaStyleTextProps(ScrStyleNames.Remark));
IScrScriptureNote ann =
m_notesEditingHelper.InsertNote(transNoteAnnDefn, startRef, endRef,
topObj, bottomObj, wsSelector, startOffset, endOffset, tssBldrQuote.GetString());
Assert.IsNotNull(ann);
Assert.AreEqual(transNoteAnnDefn.Hvo, ann.AnnotationTypeRAHvo, "Wrong type of note created");
Assert.AreEqual(hvoObjStart, ann.BeginObjectRAHvo, "Wrong paragraph annotated");
Assert.AreEqual(hvoObjEnd, ann.EndObjectRAHvo, "Wrong paragraph annotated");
Assert.AreEqual(startRef, ann.BeginRef, "Should have the correct start para reference");
Assert.AreEqual(endRef, ann.EndRef, "Should have the correct end para reference");
Assert.AreEqual(startOffset, ann.BeginOffset, "Should have the correct starting char offset");
Assert.AreEqual(endOffset, ann.EndOffset, "Should have the correct ending char offset");
Assert.AreEqual(lp.DefaultUserAgent.Hvo, ann.SourceRAHvo, "Wrong agent");
VerifyInitializedText(ann.DiscussionOA, "Discussion");
Assert.AreEqual(tssBldrQuote.Text, ((StTxtPara)ann.QuoteOA.ParagraphsOS[0]).Contents.Text);
VerifyInitializedText(ann.RecommendationOA, "Recommendation");
VerifyInitializedText(ann.ResolutionOA, "Resolution");
return(ann);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Create and Check an Annotation
/// </summary>
/// <param name="hvoParaStart">The hvo para start.</param>
/// <param name="hvoParaEnd">The hvo para end.</param>
/// <param name="startRef">The start ref.</param>
/// <param name="endRef">The end ref.</param>
/// <param name="startOffset">The start offset.</param>
/// <param name="endOffset">The end offset.</param>
/// <param name="tssQuote">The text in the quote.</param>
/// <param name="sel">selection in main window</param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
private IScrScriptureNote CreateAndCheckAnnotation(ICmObject topObj, ICmObject bottomObj,
int startRef, int endRef, int startOffset, int endOffset, string strQuote)
{
ILangProject lp = Cache.LangProject;
ICmAnnotationDefn transNoteAnnDefn =
Cache.ServiceLocator.GetInstance <ICmAnnotationDefnRepository>().TranslatorAnnotationDefn;
// Get information from the selection about the location of the annotation.
ITsStrBldr tssBldrQuote = TsStrBldrClass.Create();
tssBldrQuote.Replace(0, 0, strQuote, StyleUtils.CharStyleTextProps(null, Cache.DefaultVernWs));
IScrScriptureNote ann =
m_notesEditingHelper.InsertNote(transNoteAnnDefn, startRef, endRef,
topObj, bottomObj, startOffset, endOffset, tssBldrQuote.GetString());
Assert.IsNotNull(ann);
Assert.AreEqual(transNoteAnnDefn, ann.AnnotationTypeRA, "Wrong type of note created");
Assert.AreEqual(topObj, ann.BeginObjectRA, "Wrong paragraph annotated");
Assert.AreEqual(bottomObj, ann.EndObjectRA, "Wrong paragraph annotated");
Assert.AreEqual(startRef, ann.BeginRef, "Should have the correct start para reference");
Assert.AreEqual(endRef, ann.EndRef, "Should have the correct end para reference");
Assert.AreEqual(startOffset, ann.BeginOffset, "Should have the correct starting char offset");
Assert.AreEqual(endOffset, ann.EndOffset, "Should have the correct ending char offset");
Assert.AreEqual(lp.DefaultUserAgent, ann.SourceRA, "Wrong agent");
VerifyInitializedText(ann.DiscussionOA, "Discussion");
Assert.AreEqual(tssBldrQuote.Text, ((IStTxtPara)ann.QuoteOA.ParagraphsOS[0]).Contents.Text);
VerifyInitializedText(ann.RecommendationOA, "Recommendation");
VerifyInitializedText(ann.ResolutionOA, "Resolution");
return(ann);
}
public void MakeLabelFromText_AnnotationOnFootnote()
{
IScrScriptureNote note = Cache.ServiceLocator.GetInstance <IScrScriptureNoteFactory>().Create();
m_scr.BookAnnotationsOS[0].NotesOS.Add(note);
note.BeginRef = 01001011;
note.EndRef = 01001011;
IStFootnote footnote = AddFootnote(m_gen,
(IStTxtPara)m_gen.SectionsOS[1].ContentOA.ParagraphsOS[0], 0);
note.BeginObjectRA = AddParaToMockedText(footnote, "Whatever");
ITsString tss = m_vc.CallMakeLabelFromText("GEN 1:11", "WhoCares", note);
Assert.AreEqual(3, tss.RunCount);
#if __MonoCS__
const string fontname = "OpenSymbol";
const string symbol = "\u2042";
#else
const string fontname = "Marlett";
const string symbol = "\u0032";
#endif
Assert.AreEqual(symbol, tss.get_RunText(0));
Assert.AreEqual("GEN 1:11", tss.get_RunText(1));
Assert.AreEqual(fontname,
tss.get_Properties(0).GetStrPropValue((int)FwTextPropType.ktptFontFamily));
Assert.AreEqual("WhoCares",
tss.get_Properties(1).GetStrPropValue((int)FwTextPropType.ktptNamedStyle));
CheckFinalSpaceInReferenceLabel(tss);
}
public void ExportBookSection_IntroWithNotes()
{
IScrSection introSection = m_scrInMemoryCache.AddIntroSectionToMockedBook(m_book.Hvo);
m_scrInMemoryCache.AddSectionHeadParaToSection(introSection.Hvo, "Introduction",
ScrStyleNames.IntroSectionHead);
StTxtPara introPara = AddPara(introSection, ScrStyleNames.NormalParagraph);
AddVerse(introPara, 0, 0, "Some intro text");
IScrScriptureNote note = m_scrInMemoryCache.AddAnnotation(introPara, new BCVRef(01001000),
NoteType.Consultant, "This is a basic note about the intro.");
note.ResolutionStatus = NoteStatus.Open;
note.BeginOffset = 5;
note.EndOffset = 10;
DateTime now = DateTime.Now;
string strNow = now.ToUniversalTime().ToString("yyyy-MM-dd HH:mm:ss.ff");
note.DateCreated = now;
note.DateModified = now;
StringWriter stream = new StringWriter();
XmlTextWriter writer = new XmlTextWriter(stream);
writer.Formatting = Formatting.None;
m_exporter = new ExportXml(null, Cache, null, ExportWhat.AllBooks, 0, 0, 0,
"ExportBookSection_IntroWithNotes");
ReflectionHelper.SetField(m_exporter, "m_writer", writer);
string sCanon = "ot";
ReflectionHelper.CallMethod(m_exporter, "ExportBook", sCanon, m_book, null);
XmlDocument actual = new XmlDocument();
actual.Load(new StringReader(stream.ToString()));
string strExpected = "<book ID=\"GEN\"><titleGroup short=\"Genesis\"><title type=\"main\">" +
"<trGroup><tr>Genesis</tr></trGroup></title></titleGroup>" +
"<introduction><section><sectionHead><trGroup><tr>Introduction</tr></trGroup></sectionHead>" +
"<p><annotation type=\"consultantNote\" status=\"0\" oxesRef=\"GEN.1.0\" beginOffset=\"5\" endOffset=\"10\">" +
"<created>" + strNow + "</created><modified>" + strNow + "</modified>" +
"<resolved /><notationDiscussion><para xml:lang=\"en\">" +
"<run>This is a basic note about the intro.</run></para></notationDiscussion></annotation>" +
"<trGroup><tr><userCS type=\"Paragraph\">Some intro text</userCS></tr></trGroup>" +
"<chapterEnd ID=\"GEN.0\"/></p></section></introduction></book>";
XmlDocument expected = new XmlDocument();
expected.Load(new StringReader(strExpected));
string strDifference;
if (!XmlHelper.CompareXmlNodes(expected.ChildNodes, actual.ChildNodes, out strDifference))
{
Assert.Fail(strDifference);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Inserts a Scriture annotation for the book currently being imported.
/// </summary>
/// <param name="bcvStartReference">The starting BCV reference.</param>
/// <param name="bcvEndReference">The ending BCV reference.</param>
/// <param name="obj">The object being annotated (either a paragraph or a ScrBook)</param>
/// <param name="bldr">The paragraph builder containing the guts of the annotation
/// description</param>
/// <param name="guidNoteType">The GUID representing the CmAnnotationDefn to use for
/// the type</param>
/// <returns>The newly created annotation</returns>
/// ------------------------------------------------------------------------------------
public IScrScriptureNote InsertNote(int bcvStartReference, int bcvEndReference,
ICmObject obj, StTxtParaBldr bldr, Guid guidNoteType)
{
IScrScriptureNote note = m_annotations.InsertImportedNote(
bcvStartReference, bcvEndReference, obj, obj, guidNoteType, bldr);
return(note);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Creates an instance of a CheckingError object if the hvo is for an annotation
/// that really is a CheckingError.
/// </summary>
/// ------------------------------------------------------------------------------------
internal static CheckingError Create(IScrScriptureNote error)
{
if (error == null)
{
throw new ArgumentNullException("Null note cannot be used");
}
return(error.AnnotationType != NoteType.CheckingError ? null : new CheckingError(error));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Attempts to scroll to an annotation whose BeginObjectRAHvo is the same as the hvo
/// of the paragraph where the anchor is in the specified editing helper's selection.
/// </summary>
/// <param name="editingHelper">The TE editing helper with information about the
/// selection in the Scripture pane.</param>
/// <param name="selectedText">The selected text or the word containing the IP if the
/// selection is not a range.</param>
/// <param name="fExactMatchOnly">if set to <c>true</c> then only scroll to a found
/// note if the cited text is an exact match.</param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
private bool ScrollToAnnotationByPara(TeEditingHelper editingHelper,
string selectedText, bool fExactMatchOnly)
{
if (editingHelper == null || editingHelper.CurrentSelection == null)
{
return(false);
}
ScrReference scrRef = editingHelper.CurrentStartRef;
SelLevInfo[] info = editingHelper.CurrentSelection.GetLevelInfo(
SelectionHelper.SelLimitType.Anchor);
if (info.Length == 0)
{
return(false);
}
int bookHvo = m_scr.BookAnnotationsOS[scrRef.Book - 1].Hvo;
int[] annHvos = ((ISilDataAccessManaged)m_rootb.DataAccess).VecProp(bookHvo,
kCurrentNotesTag);
if (annHvos.Length == 0)
{
return(false);
}
int ich = editingHelper.CurrentSelection.IchAnchor;
// Go through the annotations for the book and find the one whose
// begin object is in the same as the selection's paragraph.
for (int i = 0; i < annHvos.Length; i++)
{
IScrScriptureNote ann = Cache.ServiceLocator.GetInstance <IScrScriptureNoteRepository>().GetObject(annHvos[i]);
if (ann.BeginObjectRA != null && ann.BeginObjectRA.Hvo == info[0].hvo)
{
// When matching on the cited text, allow for the possibility that the
// begin offset is off by a little bit since leading spaces and/or ORCs
// may have been trimmed and subsequent editing may have messed up the
// offsets a little.
int adjustedBeginOffset = ann.BeginOffset -
(string.IsNullOrEmpty(ann.CitedText) ? 1 : ann.CitedText.Length);
if ((!fExactMatchOnly && ich >= ann.BeginOffset && ich <= ann.EndOffset) ||
(ich >= adjustedBeginOffset && selectedText == ann.CitedText))
{
m_vc.SelectedNoteHvo = ann.Hvo;
NotesEditingHelper.MakeSelectionInNote(m_vc, scrRef.Book - 1, i, this,
m_vc.IsExpanded(ann.Hvo));
return(true);
}
}
}
return(false);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Writes this annotation to the specified cache.
/// </summary>
/// <param name="scr">The scripture.</param>
/// <param name="styleSheet">The style sheet.</param>
/// <returns>The created annotation</returns>
/// ------------------------------------------------------------------------------------
internal IScrScriptureNote WriteToCache(IScripture scr, FwStyleSheet styleSheet)
{
if (AnnotationTypeGuid == Guid.Empty.ToString())
{
return(null);
}
Debug.Assert(scr.Cache == styleSheet.Cache, "This can't end well");
int bookNum = BeginScrBCVRef.Book;
IScrBookAnnotations sba = scr.BookAnnotationsOS[bookNum - 1];
if (sba == null)
{
sba = scr.Cache.ServiceLocator.GetInstance <IScrBookAnnotationsFactory>().Create();
scr.BookAnnotationsOS.Insert(bookNum - 1, sba);
}
IScrScriptureNote scrNote = FindOrCreateAnnotation(styleSheet);
scrNote.BeginOffset = BeginOffset;
scrNote.EndOffset = EndOffset;
scrNote.ResolutionStatus = ResolutionStatus;
if (m_createdDate > DateTime.MinValue)
{
scrNote.DateCreated = m_createdDate;
}
if (m_modifiedDate > DateTime.MinValue)
{
scrNote.DateModified = m_modifiedDate;
}
if (m_resolvedDate > DateTime.MinValue)
{
scrNote.DateResolved = m_resolvedDate;
}
foreach (XmlNoteCategory category in Categories)
{
category.WriteToCache(scrNote);
}
foreach (XmlNoteResponse response in Responses)
{
response.WriteToCache(scrNote, styleSheet);
}
//((Scripture)scr).AttachAnnotatedObjects(bookNum, scrNote);
if (scrNote.BeginObjectRA == null && scrNote.CitedTextTss != null)
{
AttachAnnotatedObjects(scr, bookNum, scrNote);
}
return(scrNote);
}
public void ExcludeUnignoredErrors()
{
Assert.AreEqual(string.Empty, m_filter.Name);
IScrScriptureNote note = m_scrInMemoryCache.AddAnnotation(
(StTxtPara)m_genesis.SectionsOS[0].ContentOA.ParagraphsOS[0], 01001001,
NoteType.CheckingError);
note.ResolutionStatus = NoteStatus.Open;
Assert.IsFalse(m_filter.MatchesCriteria(note.Hvo));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Looks for any annotations in the curtrently filtered set whose reference range
/// covers the given Scripture reference. Any such annotations are expanded and the
/// first on is scrolled to near the top of the view.
/// </summary>
/// ------------------------------------------------------------------------------------
internal void ScrollRefIntoView(ScrReference reference, string quotedText)
{
CheckDisposed();
if (reference.Book <= 0)
{
return;
}
bool fSaveSendSyncScrollMsg = m_fSendSyncScrollMsg;
try
{
m_fSendSyncScrollMsg = false;
int bookHvo = m_scr.BookAnnotationsOS[reference.Book - 1].Hvo;
int[] annHvos = ((ISilDataAccessManaged)m_rootb.DataAccess).VecProp(bookHvo,
kCurrentNotesTag);
int exactMatchingAnnotation = -1;
int firstMatchingAnnotation = -1;
for (int i = 0; i < annHvos.Length; i++)
{
IScrScriptureNote ann =
Cache.ServiceLocator.GetInstance <IScrScriptureNoteRepository>().GetObject(annHvos[i]);
if (ann.BeginRef <= reference && ann.EndRef >= reference)
{
if (firstMatchingAnnotation < 0)
{
firstMatchingAnnotation = i;
}
string qtext = ((IStTxtPara)ann.QuoteOA[0]).Contents.Text;
if (!string.IsNullOrEmpty(qtext) && !string.IsNullOrEmpty(quotedText) &&
qtext == quotedText && exactMatchingAnnotation < 0)
{
exactMatchingAnnotation = i;
}
}
else if (firstMatchingAnnotation >= 0)
{
break;
}
}
int idx = Math.Max(exactMatchingAnnotation, firstMatchingAnnotation);
if (idx >= 0)
{
NotesEditingHelper.MakeSelectionInNote(m_vc, reference.Book - 1, idx, this, m_vc.IsExpanded(annHvos[idx]));
}
}
finally
{
m_fSendSyncScrollMsg = fSaveSendSyncScrollMsg;
}
}
public void IncludeNormalNotes()
{
IScrScriptureNote note1 = m_scrInMemoryCache.AddAnnotation(
(StTxtPara)m_genesis.SectionsOS[0].ContentOA.ParagraphsOS[0], 01001001,
NoteType.Consultant);
IScrScriptureNote note2 = m_scrInMemoryCache.AddAnnotation(
(StTxtPara)m_genesis.SectionsOS[0].ContentOA.ParagraphsOS[0], 01001002,
NoteType.Translator);
Assert.IsTrue(m_filter.MatchesCriteria(note1.Hvo));
Assert.IsTrue(m_filter.MatchesCriteria(note2.Hvo));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets a list of all the categories assigned to the specified annotation.
/// </summary>
/// ------------------------------------------------------------------------------------
public static List <XmlNoteCategory> GetCategoryList(IScrScriptureNote ann,
ILgWritingSystemFactory lgwsf)
{
List <XmlNoteCategory> list = new List <XmlNoteCategory>();
foreach (ICmPossibility category in ann.CategoriesRS)
{
list.Add(new XmlNoteCategory(category, lgwsf));
}
return(list.Count == 0 ? null : list);
}
public void SavingDeserializedAnnotationsToCache_WithResponses()
{
DateTime now = DateTime.Now;
DateTime utcNow = now.ToUniversalTime();
XmlScrNote ann = CreateNote();
ann.BeginScrRef = "EXO 2:8";
ann.ResolutionStatus = NoteStatus.Open;
ann.AnnotationTypeGuid = LangProject.kguidAnnTranslatorNote.ToString();
ann.DateTimeCreated = utcNow.ToString();
ann.DateTimeModified = utcNow.AddDays(1).ToString();
AddParasTo(ann.Discussion, "This is my discussion");
AddParasTo(ann.Resolution, "This is my resolution for the note");
AddParasTo(ann.Quote, "This is the quoted text");
AddParasTo(ann.Suggestion, "This is my suggestion");
XmlNoteResponse firstResponse = new XmlNoteResponse();
AddParasTo(firstResponse.Paragraphs, "This is", "my", "first", "response");
ann.Responses.Add(firstResponse);
XmlNoteResponse secondResponse = new XmlNoteResponse();
AddParasTo(secondResponse.Paragraphs, "This is", "my second response");
ann.Responses.Add(secondResponse);
DummyXmlScrAnnotationsList list = new DummyXmlScrAnnotationsList();
list.Annotations.Add(ann);
list.CallWriteToCache(Cache, m_stylesheet);
IScrBookAnnotations annotations = m_scr.BookAnnotationsOS[1];
Assert.AreEqual(1, annotations.NotesOS.Count);
IScrScriptureNote note = annotations.NotesOS[0];
Assert.AreEqual(NoteType.Translator, note.AnnotationType);
Assert.IsTrue(AreDateTimesClose(now, note.DateCreated));
Assert.IsTrue(AreDateTimesClose(now.AddDays(1), note.DateModified));
Assert.AreEqual(DateTime.MinValue, note.DateResolved);
TestAnnotationField(note.QuoteOA, "This is the quoted text");
TestAnnotationField(note.DiscussionOA, "This is my discussion");
TestAnnotationField(note.ResolutionOA, "This is my resolution for the note");
TestAnnotationField(note.RecommendationOA, "This is my suggestion");
FdoOwningSequence <IStJournalText> responses = note.ResponsesOS;
Assert.AreEqual(2, responses.Count);
TestAnnotationField(responses[0], "This is", "my", "first", "response");
TestAnnotationField(responses[1], "This is", "my second response");
}
public void ExportScriptureNote_IgnoredCheckingError()
{
IScrSection section = m_scrInMemoryCache.AddSectionToMockedBook(m_book.Hvo);
StTxtPara para = AddPara(section, ScrStyleNames.NormalParagraph);
IScrScriptureNote note = m_scrInMemoryCache.AddAnnotation(para, new BCVRef(01001001),
NoteType.CheckingError, "This is some basic text.");
note.AnnotationTypeRA.Name.SetAlternative("Repeated Words", Cache.DefaultAnalWs);
note.AnnotationTypeRA.Guid = new Guid(StandardCheckIds.kguidRepeatedWords.ToString());
note.ResolutionStatus = NoteStatus.Closed;
DateTime now = DateTime.Now;
string strNow = now.ToUniversalTime().ToString("yyyy-MM-dd HH:mm:ss.ff");
note.DateCreated = now;
note.DateModified = now;
note.DateResolved = now;
StringWriter stream = new StringWriter();
XmlTextWriter writer = new XmlTextWriter(stream);
m_exporter = new ExportXml(null, Cache, null, ExportWhat.AllBooks, 0, 0, 0,
"ExportScriptureNote_Resolved");
ReflectionHelper.SetField(m_exporter, "m_writer", writer);
ReflectionHelper.CallMethod(m_exporter, "ExportScriptureNote", note);
string strExpected = "<annotation subType=\"repeatedWordsCheck\" status=\"1\" oxesRef=\"GEN.1.1\" " +
"beginOffset=\"0\" endOffset=\"0\" type=\"pre-typesettingCheck\">" +
"<created>" + strNow + "</created>" +
"<modified>" + strNow + "</modified>" +
"<resolved>" + strNow + "</resolved>" +
"<notationDiscussion>" +
"<para xml:lang=\"en\">" +
"<span>This is some basic text.</span>" +
"</para>" +
"</notationDiscussion>" +
"</annotation>";
XmlDocument actual = new XmlDocument();
actual.Load(new StringReader(stream.ToString()));
XmlDocument expected = new XmlDocument();
expected.Load(new StringReader(strExpected));
string strDifference;
if (!XmlHelper.CompareXmlNodes(expected.ChildNodes, actual.ChildNodes, out strDifference))
{
Assert.Fail(strDifference);
}
}
public void FindOrCreateAnnotation_GuidNotFound()
{
StTxtParaBldr bldr = new StTxtParaBldr(Cache);
ScrAnnotationInfo annInfo = new ScrAnnotationInfo(CmAnnotationDefnTags.kguidAnnConsultantNote,
bldr, 0, 01001001, 01001002);
IScrScriptureNote newNote = ScrNoteImportManager.FindOrCreateAnnotation(annInfo, Guid.NewGuid());
Assert.IsNotNull(newNote);
Assert.IsNull(newNote.BeginObjectRA);
Assert.IsNull(newNote.EndObjectRA);
Assert.AreEqual(01001001, newNote.BeginRef);
Assert.AreEqual(01001002, newNote.EndRef);
}
public void SavingDeserializedAnnotationsToCache_WithHyperlink()
{
DateTime now = DateTime.Now;
DateTime utcNow = now.ToUniversalTime();
XmlScrNote ann = CreateNote();
ann.BeginScrRef = "GEN 2:8";
ann.ResolutionStatus = NoteStatus.Closed;
ann.AnnotationTypeGuid = CmAnnotationDefnTags.kguidAnnTranslatorNote.ToString();
ann.DateTimeCreated = utcNow.ToString(CultureInfo.InvariantCulture);
ann.DateTimeModified = utcNow.AddDays(1).ToString(CultureInfo.InvariantCulture);
ann.DateTimeResolved = utcNow.AddDays(2).ToString(CultureInfo.InvariantCulture);
AddParasTo(ann.Discussion, "This is my", "discussion");
AddParasTo(ann.Resolution, "This is my", "resolution for", "the note");
AddParasTo(ann.Quote, "This is the", "quoted text");
AddParasTo(ann.Suggestion, "This is", "my", "suggestion");
AddHyperTo(ann.Suggestion[1], "http://www.tim.david.com/cooldudes.html");
DummyXmlScrAnnotationsList list = new DummyXmlScrAnnotationsList();
list.Annotations.Add(ann);
list.CallWriteToCache(Cache, m_stylesheet);
IScrBookAnnotations annotations = m_scr.BookAnnotationsOS[0];
Assert.AreEqual(1, annotations.NotesOS.Count);
IScrScriptureNote note = annotations.NotesOS[0];
Assert.AreEqual(NoteType.Translator, note.AnnotationType);
Assert.IsTrue(AreDateTimesClose(now, note.DateCreated));
Assert.IsTrue(AreDatesClose(now.AddDays(1), note.DateModified));
Assert.IsTrue(AreDatesClose(now.AddDays(2), note.DateResolved));
TestAnnotationField(note.QuoteOA, "This is the", "quoted text");
TestAnnotationField(note.DiscussionOA, "This is my", "discussion");
TestAnnotationField(note.ResolutionOA, "This is my", "resolution for", "the note");
TestAnnotationField(note.RecommendationOA, "This is", "mymy link", "suggestion");
// Check the hyperlink location
ITsTextProps props = ((IStTxtPara)note.RecommendationOA.ParagraphsOS[1]).Contents.get_Properties(1);
string href = TsStringUtils.GetURL(props.GetStrPropValue((int)FwTextPropType.ktptObjData));
Assert.AreEqual("http://www.tim.david.com/cooldudes.html", href);
Assert.AreEqual(0, note.ResponsesOS.Count);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the insert index where a new annotation is inserted when the annotation's
/// reference is that specified. The index will be at the end of those for the
/// specified reference.
/// </summary>
/// ------------------------------------------------------------------------------------
private int GetInsertIndexForRef(BCVRef startRef)
{
IFdoOwningSequence <IScrScriptureNote> notes = NotesOS;
for (int i = notes.Count - 1; i >= 0; i--)
{
IScrScriptureNote note = notes[i];
if (note.BeginRef <= startRef)
{
return(i + 1);
}
}
return(0);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Connects the notes to new categories using a map created before the new categories
/// were loaded. If the note category does not already exist, it will create the
/// category.
/// </summary>
/// <param name="map">The map (for each writing system) from the note id to the
/// full string path of the category name.</param>
/// <remarks>Limitation: If any category is renamed, any notes that used the previous
/// name will continue to use the old category. To fix this problem, we would need to
/// specify in the category file (for each category with a changed name) how the old
/// category maps to its renamed/relocated category).</remarks>
/// ------------------------------------------------------------------------------------
private void ConnectNotesToNewCategories(Dictionary <int, List <string> > map)
{
foreach (int noteHvo in map.Keys)
{
IScrScriptureNote note = m_scr.Cache.ServiceLocator.GetInstance <IScrScriptureNoteRepository>().GetObject(noteHvo);
note.CategoriesRS.Clear(); // Just in case
List <string> strCategories = map[noteHvo];
foreach (string strCategory in strCategories)
{
note.CategoriesRS.Add(m_scr.NoteCategoriesOA.FindOrCreatePossibility(
strCategory, m_scr.Cache.DefaultAnalWs));
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Scroll new note into view.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="fromUndoRedo">True if the event was fired from an undo (or rollback) or
/// redo, false otherwise.</param>
/// ------------------------------------------------------------------------------------
private void ScrollAfterPropChangedCompleted(object sender, bool fromUndoRedo)
{
// In test teardown, cache may already have been cleared
if (Cache == null)
{
return;
}
((IActionHandlerExtensions)Cache.ActionHandlerAccessor).PropChangedCompleted -= ScrollAfterPropChangedCompleted;
IScrBookAnnotations annotations = m_scr.BookAnnotationsOS[m_bookNewNote - 1];
IScrScriptureNote annotation = annotations.NotesOS[m_indexNewNote];
TeNotesVc notesVc = CurrentNotesVc;
if (notesVc != null)
{
// tell the VC that the newly inserted item should be expanded. That will cause
// the view to be updated to show the new note.
notesVc.ExpandItem(annotation.Hvo, EditedRootBox);
notesVc.ExpandItem(annotation.DiscussionOA.Hvo, EditedRootBox);
}
if (Control != null)
{
Control.Focus();
}
// Make a selection in the discussion so the user can start to type
int iPos = m_indexNewNote;
if (notesVc != null)
{
// Get the corresponding index in the virtual property.
iPos = ((FilteredDomainDataByFlidDecorator)EditedRootBox.DataAccess).
GetFilteredIndexOfItem(annotations.Hvo, iPos);
// New note doesn't match current filter - need to turn it off
if (iPos < 0)
{
// Turn off the filter so the new note will show
((NotesDataEntryView)Control).OnChangeFilter(null);
iPos = ((FilteredDomainDataByFlidDecorator)EditedRootBox.DataAccess).
GetFilteredIndexOfItem(annotations.Hvo, m_indexNewNote);
Debug.Assert(iPos >= 0);
}
}
IVwRootSite rootSite = Control as IVwRootSite;
MakeSelectionInNote(notesVc, m_bookNewNote - 1, iPos, rootSite, true);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Implement CreateTestData, called by InMemoryFdoTestBase set up.
/// </summary>
/// ------------------------------------------------------------------------------------
protected override void CreateTestData()
{
m_mockedChooserDlg = new DynamicMock(typeof(ICmPossibilitySupplier));
m_mockedDataAccess = new DynamicMock(typeof(IVwCacheDa));
m_scrInMemoryCache.InitializeAnnotationDefs();
m_scrInMemoryCache.InitializeScrAnnotationCategories();
CreateTestUserView();
// Create some Scripture annotations
m_annotationsGen = (ScrBookAnnotations)m_scr.BookAnnotationsOS[0];
ScrReference ref1 = new ScrReference(1, 1, 1, Paratext.ScrVers.English);
ScrReference ref2 = new ScrReference(1, 1, 2, Paratext.ScrVers.English);
ScrReference ref3 = new ScrReference(1, 1, 3, Paratext.ScrVers.English);
// Insert notes for Genesis 1:1, 1:2, and 1:3
m_note1 = m_annotationsGen.InsertNote(ref1, ref1, null, null, LangProject.kguidAnnConsultantNote);
m_note2a = m_annotationsGen.InsertNote(ref2, ref2, null, null, LangProject.kguidAnnConsultantNote);
m_note2b = m_annotationsGen.InsertNote(ref2, ref2, null, null, LangProject.kguidAnnConsultantNote);
m_note3 = m_annotationsGen.InsertNote(ref3, ref3, null, null, LangProject.kguidAnnConsultantNote);
m_note1.AnnotationTypeRA = m_inMemoryCache.m_consultantNoteDefn;
m_note2a.AnnotationTypeRA = m_inMemoryCache.m_consultantNoteDefn;
m_note2b.AnnotationTypeRA = m_inMemoryCache.m_translatorNoteDefn;
m_note3.AnnotationTypeRA = m_inMemoryCache.m_translatorNoteDefn;
m_note1.ResolutionStatus = NoteStatus.Open;
m_note2a.ResolutionStatus = NoteStatus.Closed;
m_note2b.ResolutionStatus = NoteStatus.Open;
m_note3.ResolutionStatus = NoteStatus.Closed;
m_note1.CategoriesRS.Append(m_inMemoryCache.m_categoryDiscourse);
m_note2a.CategoriesRS.Append(m_inMemoryCache.m_categoryGrammar);
m_note2b.CategoriesRS.Append(m_inMemoryCache.m_categoryGrammar_PronominalRef);
m_note3.CategoriesRS.Append(m_inMemoryCache.m_categoryGrammar_PronominalRef_ExtendedUse);
m_note3.CategoriesRS.Append(m_inMemoryCache.m_categoryDiscourse); // This note has 2 categories
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Writes this response to the the specified annotation
/// </summary>
/// ------------------------------------------------------------------------------------
public void WriteToCache(IScrScriptureNote ann, FwStyleSheet styleSheet)
{
ParagraphCollection parasResponse = new ParagraphCollection(Paragraphs, styleSheet);
ParagraphCollection.ParaMatchType type;
int matchIndex = FindMatchingResponse(parasResponse, ann.ResponsesOS, out type);
switch (type)
{
case ParagraphCollection.ParaMatchType.Exact:
case ParagraphCollection.ParaMatchType.Contains:
break; // we can ignore the new response -- it's a subset of the old.
case ParagraphCollection.ParaMatchType.IsContained:
IStJournalText oldText = ann.ResponsesOS[matchIndex];
oldText.ParagraphsOS.RemoveAll();
parasResponse.WriteToCache(oldText);
break;
case ParagraphCollection.ParaMatchType.None:
IStJournalText newText = new StJournalText();
ann.ResponsesOS.Append(newText);
parasResponse.WriteToCache(newText);
break;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Searches given StText for quoted text.
/// </summary>
/// <param name="text">Text to be searche</param>
/// <param name="note">Note containing quote</param>
/// <param name="quote">Quote</param>
/// <returns>
/// Paragraph that contains quote if quote is found; otherwise <c>null</c> will be returned.
/// </returns>
/// ------------------------------------------------------------------------------------
private ICmObject SearchStTextForQuote(IStText text, IScrScriptureNote note, string quote)
{
foreach (IStTxtPara para in text.ParagraphsOS)
{
if (para.Contents.Length == 0)
continue;
// Remove chapter/verse numbers and footnotes from paragraph contents - this is done when
// quote is created for the note.
ITsString tssQuote = TsStringUtils.GetCleanTsString(para.Contents, ScrStyleNames.ChapterAndVerse);
if (tssQuote == null || tssQuote.Length == 0)
return null;
string paraContent = tssQuote.Text;
int offset = paraContent.IndexOf(quote);
if (offset >= 0)
{
// offsets may be off slightly because of removed characters
note.BeginOffset = offset;
note.EndOffset = offset + quote.Length;
return para;
}
}
return null;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Finds replacement reference in current book for missing object reference.
/// </summary>
/// ------------------------------------------------------------------------------------
private void FindMissingReference(IScrBook book, IScrScriptureNote note)
{
if (!note.QuoteOA.IsEmpty)
note.BeginObjectRA = note.EndObjectRA = FindQuoteInTitleOrIntro(book, note);
if (note.BeginObjectRA == null)
note.BeginObjectRA = note.EndObjectRA = book.FirstSection.IsIntro ? book.FirstSection.FirstContentParagraph : null;
if (note.BeginObjectRA == null)
note.BeginObjectRA = note.EndObjectRA = (IStTxtPara)book.TitleOA.ParagraphsOS[0];
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Attaches the annotated objects, if they're not already attached.
/// </summary>
/// ------------------------------------------------------------------------------------
public void AttachAnnotatedObjects(int bookNum, IScrScriptureNote note)
{
IScrBook book = FindBook(bookNum);
if (book != null)
AttachAnnotatedObjects(book, note);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Updates the highlighted note to be the specified note.
/// </summary>
/// <param name="ann">The note to highlight.</param>
/// ------------------------------------------------------------------------------------
private void UpdateNoteHighlight(IScrScriptureNote ann)
{
if (ann == null || m_prevHightlightedNote == ann || m_suspendHighlightChange)
return;
SelectionHelper sel = EditingHelper.CurrentSelection;
// Only selection that can get updated is a re-install of a previous selection so
// don't bother with any selection update handling.
m_ignoreSelChanged = true;
try
{
// Need to user real object index when doing a prop change - the GetDisplayIndex method on the filter will change
// this to the filtered index.
m_vc.SelectedNoteHvo = ann.Hvo;
if (m_prevHightlightedNote != null && m_prevHightlightedNote.IsValidObject)
{
int ownerHvo = m_prevHightlightedNote.Owner.Hvo;
RootBox.PropChanged(ownerHvo, ScrBookAnnotationsTags.kflidNotes, m_prevHightlightedNote.IndexInOwner, 1, 1);
}
RootBox.PropChanged(ann.Owner.Hvo, ScrBookAnnotationsTags.kflidNotes, ann.IndexInOwner, 1, 1);
m_prevHightlightedNote = ann;
if (sel != null)
sel.SetSelection(false); // restore selection taken from PropChange
}
finally
{
m_ignoreSelChanged = false;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Shows the category chooser dialog to let the user set the category for the
/// specified annotation.
/// </summary>
/// ------------------------------------------------------------------------------------
private void SetAnnotationCategory(IScrScriptureNote ann)
{
if (ann == null)
return; // Not much we can do
m_rootb.DestroySelection();
string sUndo, sRedo;
TeResourceHelper.MakeUndoRedoLabels("kstidSetAnnotationCategory", out sUndo, out sRedo);
using (new WaitCursor(this))
using (CategoryChooserDlg dlg = new CategoryChooserDlg(m_scr.NoteCategoriesOA,
ann.CategoriesRS.ToHvoArray(), m_helpTopicProvider, TheMainWnd.App))
{
if (dlg.ShowDialog(ParentForm) == DialogResult.OK)
{
using (UndoTaskHelper undoHelper = new UndoTaskHelper(this, sUndo, sRedo))
{
dlg.GetPossibilities(ann.CategoriesRS);
ann.DateModified = DateTime.Now;
undoHelper.RollBack = false;
}
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Selects the given note's cited text in a picture caption.
/// </summary>
/// <param name="iBook">The index of the book in the filter (this is passed as a
/// convenience -- it could be recalculated).</param>
/// <param name="note">The note.</param>
/// ------------------------------------------------------------------------------------
private void SelectCitedTextInPictureCaption(int iBook, IScrScriptureNote note)
{
try
{
CmPicture picture = new CmPicture(Cache, note.BeginObjectRAHvo);
int iSection, iPara, ichOrcPos;
ITsString citedText = note.CitedTextTss;
if (!FindPictureInVerse(new ScrReference(note.BeginRef, m_scr.Versification),
picture.Hvo, out iSection, out iPara, out ichOrcPos))
{
throw new Exception("Picture ORC not found in verse"); // See catch
}
int ichStart, ichEnd;
ITsString sCaptionText = picture.Caption.VernacularDefaultWritingSystem.UnderlyingTsString;
if (sCaptionText.Length >= note.EndOffset &&
StringUtils.Substring(sCaptionText, note.BeginOffset,
note.EndOffset - note.BeginOffset) == citedText)
{
ichStart = note.BeginOffset;
ichEnd = note.EndOffset;
}
else
{
// Search for word form in caption
if (!StringUtils.FindWordFormInString(citedText, sCaptionText,
m_cache.LanguageWritingSystemFactoryAccessor, out ichStart, out ichEnd))
{
ichStart = ichEnd = 0;
}
}
MakeSelectionInPictureCaption(iBook, iSection,
(int)ScrSection.ScrSectionTags.kflidContent, iPara,
ichOrcPos, ichStart, ichEnd);
}
catch
{
// Picture or caption no longer exists. Go to the start of the specified verse.
GotoVerse(new ScrReference(note.BeginRef, m_scr.Versification));
return;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Displays an annotation expanded or contracted
/// </summary>
/// <param name="vwenv"></param>
/// <param name="ann"></param>
/// <param name="expanded"></param>
/// ------------------------------------------------------------------------------------
private void DisplayAnnotation(IVwEnv vwenv, IScrScriptureNote ann, bool expanded)
{
#region First row has status, ref, category, & quote
SetBackgroundColorForNote(ann, vwenv);
OpenTableRow(vwenv, ann);
// Display expand box (+/-) in the first cell
//InsertNoteSeparator(vwenv);
vwenv.OpenTableCell(1, 1);
vwenv.AddObj(ann.Hvo, this, (int)NotesFrags.kfrExpansion);
vwenv.CloseTableCell();
// Display status in the second cell
vwenv.OpenTableCell(1, 1);
vwenv.set_IntProperty((int)FwTextPropType.ktptPadTop,
(int)FwTextPropVar.ktpvMilliPoint, 1000);
if (ann.AnnotationType == NoteType.CheckingError)
{
// When the annotation is a checking error, we don't want clicking on the status
// to change the status. Therefore, make the min and max the same.
vwenv.AddIntPropPic((int)ScrScriptureNoteTags.kflidResolutionStatus,
this, (int)NotesFrags.kfrStatus, 0, 0);
}
else
{
vwenv.AddIntPropPic((int)ScrScriptureNoteTags.kflidResolutionStatus,
this, (int)NotesFrags.kfrStatus, (int)NoteStatus.Open, (int)NoteStatus.Closed);
}
vwenv.CloseTableCell();
// Display reference in the third cell and make it readonly.
vwenv.OpenTableCell(1, 1);
vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvDefault, 0);
vwenv.OpenParagraph();
vwenv.AddProp((int)CmBaseAnnotationTags.kflidBeginRef, this, (int)NotesFrags.kfrScrRef);
vwenv.CloseParagraph();
vwenv.CloseTableCell();
// Display CONNOT category in the fourth (and possibly fifth and sixth) cell(s)
vwenv.OpenTableCell(1, expanded ? 3 : 1);
IStTxtPara quotePara = ann.QuoteOA[0];
bool fQuoteParaRtoL = IsParaRightToLeft(quotePara);
// Conc paragraphs don't work well for R-to-L: If the text doesn't fit, it will
// show the trailing text rather than the leading text.
if (fQuoteParaRtoL || expanded)
vwenv.OpenParagraph();
else
vwenv.OpenConcPara(0, 0, 0, 0);
vwenv.AddObjVec((int)ScrScriptureNoteTags.kflidCategories, this,
(int)NotesFrags.kfrConnotCategory);
vwenv.CloseParagraph();
vwenv.CloseTableCell();
// Display CONNOT category chooser button in the penultimate or last cell
vwenv.OpenTableCell(1, 1);
vwenv.set_IntProperty((int)FwTextPropType.ktptPadTop,
(int)FwTextPropVar.ktpvMilliPoint, 1000);
vwenv.set_IntProperty((int)FwTextPropType.ktptPadLeading,
(int)FwTextPropVar.ktpvMilliPoint, 2000);
vwenv.AddPicture(m_picChooser, -(int)NotesFrags.kfrConnotCategory, 0, 0);
vwenv.CloseTableCell();
// If not expanded, display the quote in the last cell
if (!expanded)
{
vwenv.OpenTableCell(1, 1);
SetupWsAndDirectionForPara(vwenv, quotePara.Hvo);
if (fQuoteParaRtoL)
vwenv.OpenParagraph(); // Conc paragraphs don't work well for R-to-L
else
vwenv.OpenConcPara(0, 0, 0, 0);
vwenv.AddString(quotePara.Contents);
vwenv.CloseParagraph();
vwenv.CloseTableCell();
}
CloseTableRow(vwenv, ann);
#endregion
if (!expanded)
return;
#region Second through fifth rows
bool fRegularAnnotation = ann.AnnotationType != NoteType.CheckingError;
//Second row has quote
DisplayExpandableAnnotation(vwenv, ann,
(int)ScrScriptureNoteTags.kflidQuote,
ann.QuoteOA.Hvo, ann.QuoteOA,
fRegularAnnotation ? m_quoteLabel : m_detailsLabel, !fRegularAnnotation);
// Third row has discussion
DisplayExpandableAnnotation(vwenv, ann,
ScrScriptureNoteTags.kflidDiscussion,
ann.DiscussionOA.Hvo, ann.DiscussionOA,
fRegularAnnotation ? m_discussionLabel : m_messageLabel, !fRegularAnnotation);
// Fourth row has recommendation (i.e. suggestion)
DisplayExpandableAnnotation(vwenv, ann,
ScrScriptureNoteTags.kflidRecommendation,
ann.RecommendationOA.Hvo, ann.RecommendationOA, m_suggestionLabel);
// Fifth row has resolution
DisplayExpandableAnnotation(vwenv, ann,
ScrScriptureNoteTags.kflidResolution,
ann.ResolutionOA.Hvo, ann.ResolutionOA, m_resolutionLabel);
#endregion
#region Sixth row has author
SetBackgroundColorForNote(ann, vwenv);
OpenTableRow(vwenv, ann);
// Display empty first and second cell
vwenv.OpenTableCell(1, 2);
vwenv.CloseTableCell();
// Display author in third cell
vwenv.OpenTableCell(1, 3);
vwenv.OpenParagraph();
SetDisabledColorForNote(vwenv);
vwenv.AddString(m_authorLabel);
vwenv.CloseParagraph();
vwenv.CloseTableCell();
CloseTableRow(vwenv, ann);
#endregion
#region Seventh row has dates
SetBackgroundColorForNote(ann, vwenv);
OpenTableRow(vwenv, ann);
// Display empty first and second cell
vwenv.OpenTableCell(1, 2);
vwenv.CloseTableCell();
// Display date created in third cell
vwenv.OpenTableCell(1, 1);
vwenv.OpenParagraph();
vwenv.AddString(m_createdLabel);
vwenv.AddTimeProp(CmAnnotationTags.kflidDateCreated, 0);
vwenv.CloseParagraph();
vwenv.CloseTableCell();
// Display date modified in fourth/fifth cells
vwenv.OpenTableCell(1, 2);
vwenv.OpenParagraph();
vwenv.AddString(m_modifiedLabel);
vwenv.AddTimeProp(CmAnnotationTags.kflidDateModified, 0);
vwenv.CloseParagraph();
vwenv.CloseTableCell();
// Display date resolved in last two cells
vwenv.OpenTableCell(1, 2);
vwenv.OpenParagraph();
if (ann.ResolutionStatus == NoteStatus.Closed)
{
SetDisabledColorForNote(vwenv);
vwenv.AddString(m_resolvedLabel);
// TODO (TE-4039) This date is incorrect
//vwenv.AddTimeProp(ScrScriptureNote.ScrScriptureNoteTags.kflidDateResolved, 0);
}
vwenv.CloseParagraph();
vwenv.CloseTableCell();
CloseTableRow(vwenv, ann);
#endregion
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Displays an expandable annotation of the specified type.
/// </summary>
/// ------------------------------------------------------------------------------------
private void DisplayExpandableAnnotation(IVwEnv vwenv, IScrScriptureNote ann,
int tag, int hvo, IStJournalText paras, ITsString label)
{
DisplayExpandableAnnotation(vwenv, ann, tag, hvo, paras, label, false);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Displays an expandable annotation of the specified type.
/// </summary>
/// ------------------------------------------------------------------------------------
private void DisplayExpandableAnnotation(IVwEnv vwenv, IScrScriptureNote ann,
int tag, int hvo, IStJournalText paras, ITsString label, bool readOnly)
{
vwenv.NoteDependency(new int[] { hvo }, new int[] { m_expansionTag }, 1);
SetBackgroundColorForNote(ann, vwenv);
OpenTableRow(vwenv, ann);
// Display empty first cell
vwenv.OpenTableCell(1, 1);
vwenv.CloseTableCell();
// Display +/- in the second cell, unless this is read-only
vwenv.OpenTableCell(1, 1);
if (!readOnly)
vwenv.AddObjProp(tag, this, (int)NotesFrags.kfrExpansion);
vwenv.CloseTableCell();
// Display text in the remaining cells
vwenv.OpenTableCell(1, 5);
vwenv.OpenConcPara(0, 0, 0, 0);
vwenv.AddString(label);
if (!m_expandTable.ContainsKey(hvo))
vwenv.AddString(paras[0].Contents);
vwenv.CloseParagraph();
vwenv.CloseTableCell();
CloseTableRow(vwenv, ann);
if (!m_expandTable.ContainsKey(hvo))
return;
SetBackgroundColorForNote(ann, vwenv);
OpenTableRow(vwenv, ann);
// Display empty first and second cell
vwenv.OpenTableCell(1, 2);
vwenv.CloseTableCell();
// Display text in cells 3-7
vwenv.OpenTableCell(1, 5);
if (!readOnly)
SetEditBackground(vwenv);
vwenv.AddObjProp(tag, this, (int)StTextFrags.kfrText);
vwenv.CloseTableCell();
CloseTableRow(vwenv, ann);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Notifies anyone who cares to synchronize to the specified annotation's begin
/// reference.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="annotation">The annotation.</param>
/// <param name="scr">The IScrScripture to which the annotation belongs.</param>
/// ------------------------------------------------------------------------------------
public void SyncToAnnotation(object sender, IScrScriptureNote annotation, IScripture scr)
{
Debug.Assert(annotation != null);
if (m_fIgnoreAnySyncMessages || m_fProcessingSyncMessage)
return;
if (AnnotationChanged != null)
AnnotationChanged(sender, annotation);
ScrReference scrRef = new ScrReference(annotation.BeginRef, scr.Versification);
if (scrRef.Valid || scrRef.IsBookTitle)
{
SyncUsfmBrowser(new ScrReference(scrRef));
SendExternalSyncMessage(scrRef);
}
}
// /// ------------------------------------------------------------------------------------
// /// <summary>
// /// Find out how this text matches up to the paragraph strings in bldrs.
// /// </summary>
// /// <param name="text">The journal text.</param>
// /// <param name="paragraphs">The list of paragraphs.</param>
// /// <returns></returns>
// /// <remarks>THIS NEEDS SOME THOROUGH TESTING, INCLUDING A UNIT TEST!!</remarks>
// /// ------------------------------------------------------------------------------------
// private static ParaMatchType DoesTextMatch(IStJournalText text, ParagraphCollection paragraphs)
// {
// ParaMatchType bestType = ParaMatchType.None;
//#if MATCHTEXTS
// ParaMatchType type = ParaMatchType.None;
// if (text.ParagraphsOS.Count >= bldrs.Count)
// {
// if (text.ParagraphsOS.Count == 0 && rgtss.Count == 0)
// return ParaMatchType.Exact;
// int iPrevMatch = -1;
// for (int i = 0; i < text.ParagraphsOS.Count; ++i)
// {
// int iMatch = FindMatchingParagraph(text.ParagraphsOS[i] as IStTxtPara, rgtss, out type);
// switch (type)
// {
// case ParaMatchType.None:
// return type;
// case ParaMatchType.Exact:
// if (iMatch == i)
// {
// if (bestType != ParaMatchType.Exact)
// {
// if (bestType == ParaMatchType.None)
// bestType = type;
// // else it stays the same. Exact is subsumed by both Contains and IsContained
// }
// }
// else if (iMatch > iPrevMatch)
// {
// if (bestType == ParaMatchType.Contains)
// return ParaMatchType.None;
// else
// bestType = ParaMatchType.IsContained;
// }
// else
// {
// return ParaMatchType.None;
// }
// break;
// case ParaMatchType.Contains:
// if (iMatch == i)
// {
// if (bestType != ParaMatchType.IsContained)
// bestType = type;
// else
// return ParaMatchType.None;
// }
// else
// {
// return ParaMatchType.None;
// }
// break;
// case ParaMatchType.IsContained:
// if (iMatch == i || iMatch > iPrevMatch)
// {
// if (bestType != ParaMatchType.Contains)
// bestType = type;
// else
// return ParaMatchType.None;
// }
// else
// {
// return ParaMatchType.None;
// }
// break;
// }
// iPrevMatch = iMatch;
// }
// }
// else
// {
// }
//#endif
// return bestType;
// }
#endregion
#region static methods
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="XmlNoteResponse"/> class based on the
/// specified category.
/// </summary>
/// ------------------------------------------------------------------------------------
public static List<XmlNoteResponse> GetResponsesList(IScrScriptureNote ann, int wsDefault,
ILgWritingSystemFactory lgwsf)
{
if (ann == null)
return null;
List<XmlNoteResponse> responses = new List<XmlNoteResponse>();
foreach (IStJournalText txt in ann.ResponsesOS)
responses.Add(new XmlNoteResponse(txt, wsDefault, lgwsf));
return (responses.Count == 0 ? null : responses);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Set the background color based on the type of annotation
/// </summary>
/// <param name="ann">annotation</param>
/// <param name="vwenv"></param>
/// ------------------------------------------------------------------------------------
private void SetBackgroundColorForNote(IScrScriptureNote ann, IVwEnv vwenv)
{
int color = (int)ColorUtil.ConvertColorToBGR(GetNoteBackgroundColor(ann));
switch (ann.AnnotationType)
{
case NoteType.Consultant:
vwenv.set_IntProperty((int)FwTextPropType.ktptBackColor,
(int)FwTextPropVar.ktpvDefault, color);
break;
case NoteType.Translator:
vwenv.set_IntProperty((int)FwTextPropType.ktptBackColor,
(int)FwTextPropVar.ktpvDefault, color);
break;
case NoteType.CheckingError:
vwenv.set_IntProperty((int)FwTextPropType.ktptBackColor,
(int)FwTextPropVar.ktpvDefault, color);
break;
default:
throw new Exception("Unexpected annotation type");
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Goes to the text referenced in the ScrScriptureNote. If it does not find the text,
/// it makes the closest selection to the referenced text that it can.
/// </summary>
/// <param name="note">the note containing the Scripture reference to find</param>
/// <param name="sendSyncMsg"><c>true</c> to not send a focus sychronization message
/// when the selection is changed by going to the scripture ref.</param>
/// ------------------------------------------------------------------------------------
public void GoToScrScriptureNoteRef(IScrScriptureNote note, bool sendSyncMsg)
{
// TODO (TE-1729): Use this method correctly from Annotations view.
ScrReference scrRef = new ScrReference(note.BeginRef, m_scr.Versification);
ScrBook book = BookFilter.GetBookByOrd(scrRef.Book);
if (book == null)
return;
int iBook = BookFilter.GetBookIndex(book.Hvo);
bool fOrigIgnoreAnySyncMessages = false;
if (m_syncHandler != null)
{
fOrigIgnoreAnySyncMessages = m_syncHandler.IgnoreAnySyncMessages;
m_syncHandler.IgnoreAnySyncMessages = true;
}
try
{
if (note.Flid == (int)CmPicture.CmPictureTags.kflidCaption)
{
SelectCitedTextInPictureCaption(iBook, note);
return;
}
int ichStart, ichEnd;
string citedText = note.CitedText;
ITsString citedTextTss = note.CitedTextTss;
StTxtPara para = note.BeginObjectRA as StTxtPara;
if (para != null && m_cache.GetOwnerOfObjectOfClass(para.Hvo, ScrDraft.kClassId) == 0)
{
if (para.Owner is StFootnote)
{
// Make selection in footnote.
if (TextAtExpectedLoc(para.Contents.Text, citedText, note.BeginOffset, note.EndOffset))
{
// Select text in footnote.
StFootnote footnote = para.Owner as StFootnote;
if (footnote == null)
return;
SelectionHelper selHelper = new SelectionHelper();
selHelper.AssocPrev = false;
selHelper.NumberOfLevels = 3;
selHelper.LevelInfo[2].tag = BookFilter.Tag;
selHelper.LevelInfo[2].ihvo = iBook;
selHelper.LevelInfo[1].tag = (int)ScrBook.ScrBookTags.kflidFootnotes;
selHelper.LevelInfo[1].ihvo = footnote.IndexInOwner;
selHelper.LevelInfo[0].ihvo = 0;
// Prepare to move the IP to the specified character in the paragraph.
selHelper.IchAnchor = note.BeginOffset;
selHelper.IchEnd = note.EndOffset;
// Now that all the preparation to set the IP is done, set it.
selHelper.SetSelection(Callbacks.EditedRootBox.Site, true, true);
}
return;
}
// Make selection in Scripture text
if (TextAtExpectedLoc(para.Contents.Text, citedText, note.BeginOffset, note.EndOffset))
{
SelectRangeOfChars(iBook, para, note.BeginOffset, note.EndOffset);
return;
}
if (scrRef.Verse == 0)
{
// Either a missing chapter number or something in intro material.
// Not much chance of finding it by reference (even if the chapter number
// has been added, we never find the 0th verse, and 99% of the time that
// chapter number would have been added to the same paragraph where it
// was missing in the first place), so just try to find the text in the
// paragraph, if it still exists.
if (string.IsNullOrEmpty(citedText))
{
SelectRangeOfChars(iBook, para, note.BeginOffset, note.BeginOffset);
return;
}
// The text may be null if the paragraph only contains the prompt. TE-8315
if (para.Contents.Text != null)
{
int i = para.Contents.Text.IndexOf(citedText);
if (i >= 0)
{
SelectRangeOfChars(iBook, para, i, i + citedText.Length);
return;
}
}
}
}
// A selection could not be made at the specified location. Attempt to go to
// the specified verse and then try to find the text.
// REVIEW (TimS): Why do we call GotoVerse here when we select the characters
// down below? We might consider doing this only if we fail down below.
if (sendSyncMsg)
GotoVerse(scrRef);
else
GotoVerse_WithoutSynchMsg(scrRef);
int iSection, iPara;
if (citedText != null && FindTextInVerse(m_scr, citedTextTss, scrRef, false, out iSection,
out iPara, out ichStart, out ichEnd))
{
// We found the text in the verse at a different character offset.
SelectRangeOfChars(iBook, iSection, iPara, ichStart, ichEnd);
}
else if (note.BeginOffset > 0 && para != null &&
IsOffsetValidLoc(para.Contents.Text, note.BeginOffset))
{
// We couldn't find the cited text at the specified offset, nor anywhere
// in the paragraph. Therefore, just set the IP at the begin offset.
SelectRangeOfChars(iBook, para, note.BeginOffset, note.BeginOffset);
}
}
finally
{
if (m_syncHandler != null)
m_syncHandler.IgnoreAnySyncMessages = fOrigIgnoreAnySyncMessages;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Closes the table row.
/// </summary>
/// <param name="vwenv">The view environment.</param>
/// <param name="ann">The annotation being displayed.</param>
/// ------------------------------------------------------------------------------------
private void CloseTableRow(IVwEnv vwenv, IScrScriptureNote ann)
{
if (ann.Hvo != SelectedNoteHvo)
{
// Display cell used for padding (to right-indent unselected annotations by
// the width of the frame used to highlight the selected annotation).
vwenv.OpenTableCell(1, 1);
vwenv.AddString(m_tssEmpty);
vwenv.CloseTableCell();
}
vwenv.CloseTableRow();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// We override this method to make a selection in all of the views that are in a
/// snynced group. This fixes problems where the user changes the selection in one of
/// the slaves, but the master is not updated. Thus the view is not scrolled as the
/// groups scroll position only scrolls the master's selection into view. (TE-3380)
/// </summary>
/// <param name="prootb"></param>
/// <param name="vwselNew"></param>
/// ------------------------------------------------------------------------------------
protected override void HandleSelectionChange(IVwRootBox prootb, IVwSelection vwselNew)
{
CheckDisposed();
base.HandleSelectionChange(prootb, vwselNew);
if (m_ignoreSelChanged || EditingHelper.CurrentSelection == null)
return;
SelLevInfo noteInfo = EditingHelper.CurrentSelection.GetLevelInfoForTag(kCurrentNotesTag);
if (m_prevNote != null && noteInfo.hvo == m_prevNote.Hvo)
return;
// Set text of caption to indicate which annotation is selected
IScrScriptureNote ann = Cache.ServiceLocator.GetInstance<IScrScriptureNoteRepository>().GetObject(noteInfo.hvo);
// Remove highlighting on previously selected annotation, and add highlighting to selected annotation.
UpdateNoteHighlight(ann);
m_notesMainWnd.InformationBarText = BaseInfoBarCaption + " - " + GetRefAsString(ann) + " " +
GetQuotedText(ann.QuoteOA, 30);
m_prevNote = ann;
if (!m_fSendSyncScrollMsg)
return;
NotesMainWnd notesMainWnd = TheMainWnd as NotesMainWnd;
if (notesMainWnd != null && notesMainWnd.SyncHandler != null)
{
Trace.WriteLine("Calling SyncToAnnotation from NotesDataEntryView: " + ann.CitedText);
notesMainWnd.SyncHandler.SyncToAnnotation(this, ann, m_scr);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="T:CheckingError"/> class.
/// </summary>
/// <param name="note">The note being decorated</param>
/// ------------------------------------------------------------------------------------
private CheckingError(IScrScriptureNote note)
{
m_note = note;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the Scripture reference of the specified annotation as string.
/// </summary>
/// <param name="ann">The specified annotation.</param>
/// ------------------------------------------------------------------------------------
private string GetRefAsString(IScrScriptureNote ann)
{
BCVRef startRef = new BCVRef(ann.BeginRef);
IScrBook book = m_scr.FindBook(startRef.Book);
string bookName;
// Book for note may not be in the project.
if (book != null)
bookName = book.BestUIName;
else
{
IScrBookRef bookRef = Cache.ServiceLocator.GetInstance<IScrRefSystemRepository>().Singleton.BooksOS[startRef.Book - 1];
ITsString tsName = bookRef.BookName.get_String(Cache.DefaultUserWs);
if (tsName.Length == 0)
tsName = bookRef.BookName.BestAnalysisAlternative;
bookName = tsName.Text;
}
string titleText = ResourceHelper.GetResourceString("kstidScriptureTitle");
string introText = ResourceHelper.GetResourceString("kstidScriptureIntro");
return BCVRef.MakeReferenceString(bookName, startRef, new BCVRef(ann.EndRef),
m_scr.ChapterVerseSepr, m_scr.Bridge, titleText, introText);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Provides access to the "MakeLabelFromText" method.
/// </summary>
/// <param name="labelText">text to put in the label</param>
/// <param name="styleName">style name to use for the character style on the text</param>
/// <param name="ann">The annotation.</param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
public ITsString CallMakeLabelFromText(string labelText, string styleName,
IScrScriptureNote ann)
{
return base.MakeLabelFromText(labelText, styleName, ann);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Resets the prev note hvo.
/// </summary>
/// ------------------------------------------------------------------------------------
public void ResetPrevNoteHvo()
{
CheckDisposed();
m_prevNote = null;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Make a label string to use in the view.
/// </summary>
/// <param name="labelText">text to put in the label</param>
/// <param name="styleName">style name to use for the character style on the text</param>
/// <param name="ann">The annotation</param>
/// <returns>An ITsString</returns>
/// ------------------------------------------------------------------------------------
protected ITsString MakeLabelFromText(string labelText, string styleName,
IScrScriptureNote ann)
{
ITsTextProps ttpLabel = StyleUtils.CharStyleTextProps(styleName,
m_cache.WritingSystemFactory.UserWs);
ITsStrBldr bldr = TsStrBldrClass.Create();
if (ann != null && ann.BeginObjectRA != null && ann.BeginObjectRA.IsValidObject)
{
IStTxtPara startPara = ann.BeginObjectRA as IStTxtPara;
if (startPara != null)
{
int ownerOwnFlid = startPara.Owner.OwningFlid;
if (ownerOwnFlid == ScrBookTags.kflidFootnotes)
{
#if __MonoCS__
const string fontname = "OpenSymbol";
const string symbol = "\u2042";
#else
const string fontname = "Marlett";
const string symbol = "\u0032";
#endif
ITsPropsBldr propsBldr = TsPropsBldrClass.Create();
propsBldr.SetStrPropValue((int)FwTextPropType.ktptFontFamily, fontname);
propsBldr.SetIntPropValues((int)FwTextPropType.ktptWs, 0, m_cache.WritingSystemFactory.UserWs);
bldr.Replace(0, 0, symbol, propsBldr.GetTextProps());
}
}
}
bldr.Replace(bldr.Length, bldr.Length, labelText, ttpLabel);
// Add a space with default paragraph characters. This prevents style bleed-through
// from the label when the user types in the text with (part of) the label selected.
bldr.Replace(bldr.Length, bldr.Length, " ", StyleUtils.CharStyleTextProps(null,
m_cache.WritingSystemFactory.UserWs));
return bldr.GetString();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Attaches the annotated objects, if they're not already attached.
/// </summary>
/// ------------------------------------------------------------------------------------
public void AttachAnnotatedObjects(IScrBook book, IScrScriptureNote note)
{
if (note.BeginObjectRA == null)
FindMissingReference(book, note);
else if (note.BeginObjectRA.OwnerOfClass<IScrBook>() != book)
{
note.BeginObjectRA = note.EndObjectRA = FindCorrespondingParagraph(book, note.BeginObjectRA);
if (note.BeginObjectRA == null)
FindMissingReference(book, note);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Make a label string to use in the view.
/// </summary>
/// <param name="labelText">text to put in the label</param>
/// <param name="ann">The annotation</param>
/// <returns>An ITsString</returns>
/// ------------------------------------------------------------------------------------
private ITsString MakeLabelFromText(string labelText, IScrScriptureNote ann)
{
return MakeLabelFromText(labelText, ScrStyleNames.NotationTag, ann);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Finds paragraph int the title or introduction of the passed book that contains the
/// passed quote.
/// </summary>
/// <param name="book">Current version of book</param>
/// <param name="note">Note containing quote</param>
/// <returns>
/// Paragraph in title or intro that contains quote if quote is found;
/// otherwise <c>null</c> will be returned.
/// </returns>
/// ------------------------------------------------------------------------------------
private ICmObject FindQuoteInTitleOrIntro(IScrBook book, IScrScriptureNote note)
{
string quote = note.QuoteOA[0].Contents.Text;
ICmObject result = SearchStTextForQuote(book.TitleOA, note, quote);
if (result == null)
{
IScrSection section = book.SectionsOS[0];
int sectionIndex = 0;
while (section.IsIntro)
{
result = SearchStTextForQuote(section.HeadingOA, note, quote);
if (result != null)
break;
result = SearchStTextForQuote(section.ContentOA, note, quote);
if (result != null)
break;
sectionIndex++;
if (sectionIndex >= book.SectionsOS.Count)
break;
section = book.SectionsOS[sectionIndex];
}
}
return result;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the color of the note background.
/// </summary>
/// <param name="ann">The ann.</param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
private Color GetNoteBackgroundColor(IScrScriptureNote ann)
{
switch (ann.AnnotationType)
{
case NoteType.Consultant: return Color.PaleGoldenrod;
case NoteType.Translator: return Color.LightBlue;
case NoteType.CheckingError: return Color.PaleGreen;
default: return Color.Red;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="XmlScrNote"/> class based on
/// the given Scripture note.
/// </summary>
/// <param name="ann">The Scripture annotation.</param>
/// <param name="wsDefault">The default (analysis) writing system.</param>
/// <param name="lgwsf">The writing system factory.</param>
/// ------------------------------------------------------------------------------------
public XmlScrNote(IScrScriptureNote ann, int wsDefault, ILgWritingSystemFactory lgwsf)
: this()
{
m_wsDefault = wsDefault;
m_lgwsf = lgwsf;
ResolutionStatus = ann.ResolutionStatus;
m_typeName = ann.AnnotationTypeRA.Name.get_String(WritingSystemServices.FallbackUserWs(ann.Cache)).Text;
m_guidType = ann.AnnotationTypeRA.Guid;
SetNoteType(ann);
m_startRef = ann.BeginRef;
if (ann.BeginRef != ann.EndRef)
m_endRef = ann.EndRef;
if (ann.BeginObjectRA != null)
m_guidBegObj = ann.BeginObjectRA.Guid;
if (ann.BeginObjectRA != ann.EndObjectRA && ann.EndObjectRA != null)
m_guidEndObj = ann.EndObjectRA.Guid;
BeginOffset = ann.BeginOffset;
EndOffset = ann.EndOffset;
m_createdDate = ann.DateCreated;
m_modifiedDate = ann.DateModified;
m_resolvedDate = ann.DateResolved;
Quote = XmlNotePara.GetParagraphList(ann.QuoteOA, m_wsDefault, m_lgwsf);
Discussion = XmlNotePara.GetParagraphList(ann.DiscussionOA, m_wsDefault, m_lgwsf);
Suggestion = XmlNotePara.GetParagraphList(ann.RecommendationOA, m_wsDefault, m_lgwsf);
Resolution = XmlNotePara.GetParagraphList(ann.ResolutionOA, m_wsDefault, m_lgwsf);
Categories = XmlNoteCategory.GetCategoryList(ann, m_lgwsf);
Responses = XmlNoteResponse.GetResponsesList(ann, m_wsDefault, m_lgwsf);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Scrolls to cited text.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="annotation">The annotation whose reference and cited text we should
/// sync. to.</param>
/// ------------------------------------------------------------------------------------
void ScrollToCitedText(object sender, IScrScriptureNote annotation)
{
CheckDisposed();
if (sender != this && annotation != null)
GoToScrScriptureNoteRef(annotation, false);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Creates an instance of a CheckingError object if the hvo is for an annotation
/// that really is a CheckingError.
/// </summary>
/// ------------------------------------------------------------------------------------
internal static CheckingError Create(IScrScriptureNote error)
{
if (error == null)
throw new ArgumentNullException("Null note cannot be used");
return (error.AnnotationType != NoteType.CheckingError ? null : new CheckingError(error));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Goes to the text referenced in the ScrScriptureNote. If it does not find the text,
/// it makes the closest selection to the referenced text that it can.
/// </summary>
/// <param name="note">the note containing the Scripture reference to find</param>
/// ------------------------------------------------------------------------------------
public void GoToScrScriptureNoteRef(IScrScriptureNote note)
{
GoToScrScriptureNoteRef(note, true);
}
