Ejemplo n.º 1
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="startRef">The start reference at the position where the footnote ORC is
		/// in the vernacular text</param>
		/// <param name="endRef">The end reference at the position where the footnote ORC is in
		/// the vernacular text (can be different from start ref because of verse bridges).
		/// </param>
		/// <param name="hvo">The ID of the paragraph containing the ORC for the footnote. This
		/// could also be the last paragraph where it was found if it is in the process of
		/// being deleted (in which case ORCs may still exist in the corresponding back
		/// translations).</param>
		/// ------------------------------------------------------------------------------------
		public FootnoteHashEntry(BCVRef startRef, BCVRef endRef, int hvo)
		{
			m_startRef = new BCVRef(startRef);
			m_endRef = new BCVRef(endRef);
			m_hvoPara = hvo;
			m_fFound = true;
		}
Ejemplo n.º 2
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Insert a new check result annotation at its correct position in the list.
		/// </summary>
		/// <param name="startRef">beginning reference note refers to</param>
		/// <param name="endRef">ending reference note refers to</param>
		/// <param name="beginObject">id of beginning object note refers to</param>
		/// <param name="endObject">id of ending object note refers to</param>
		/// <param name="checkId">The check id.</param>
		/// <param name="bldrQuote">Para builder to use for the cited text paragraph</param>
		/// <param name="bldrDiscussion">Para builder to use to build the Discussion
		/// paragraph</param>
		/// <returns>note inserted into annotation list</returns>
		/// ------------------------------------------------------------------------------------
		public IScrScriptureNote InsertErrorAnnotation(BCVRef startRef, BCVRef endRef,
			ICmObject beginObject, ICmObject endObject, Guid checkId,
			StTxtParaBldr bldrQuote, StTxtParaBldr bldrDiscussion)
		{
			return InsertNote(startRef, endRef, beginObject, endObject, checkId, -1,
				0, 0, bldrQuote, bldrDiscussion, null, null, GetInsertIndexForRef(startRef));
		}
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Notify all Santa Fe windows that a Scripture Reference focus change has occured.
		/// </summary>
		/// <param name="sRef">The string representation of the reference (e.g. MAT 1:1)</param>
		/// ------------------------------------------------------------------------------------
		public static void SendFocusMessage(string sRef)
		{
			BCVRef bcvRef = new BCVRef(sRef);
			if (!bcvRef.Valid)
				return;
			s_SantaFeRefKey.SetValue(null, sRef);
			PostMessage(new IntPtr(-1), s_FocusMsg, (uint)FocusTypes.ScriptureReferenceFocus, 0);
		}
Ejemplo n.º 4
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Get the first annotation in the list that covers the specified reference.
		/// </summary>
		/// <param name="reference">Scripture reference to seek</param>
		/// <returns>The first note for the specified reference, if any; otherwise null</returns>
		/// ------------------------------------------------------------------------------------
		public IScrScriptureNote GetFirstNoteForReference(BCVRef reference)
		{
			foreach (IScrScriptureNote note in NotesOS)
			{
				if (note.BeginRef <= reference && note.EndRef >= reference)
					return note;
			}
			return null;
		}
Ejemplo n.º 5
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Initializes a new instance of the <see cref="T:SegmentInfo"/> class.
		/// </summary>
		/// <param name="sMarker">The segment marker.</param>
		/// <param name="sText">The segment text.</param>
		/// <param name="domain">The import domain.</param>
		/// <param name="reference">The current Scripture reference.</param>
		/// <param name="ws">The writing system (-1 to indicate the default WS).</param>
		/// ------------------------------------------------------------------------------------
		internal SegmentInfo(string sMarker, string sText, ImportDomain domain,
			BCVRef reference, int ws)
		{
			m_sMarker = sMarker;
			m_sText = sText;
			m_domain = domain;
			m_ref = reference;
			m_ws = ws;
		}
Ejemplo n.º 6
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="ws"></param>
		/// <param name="bldr"></param>
		/// <param name="styleId"></param>
		/// <param name="ichOffset"></param>
		/// <param name="reference"></param>
		/// ------------------------------------------------------------------------------------
		public BtFootnoteBldrInfo(int ws, ITsStrBldr bldr, string styleId, int ichOffset,
			BCVRef reference)
		{
			this.ws = ws;
			this.bldr = bldr;
			this.styleId = styleId;
			this.ichOffset = ichOffset;
			this.reference = new BCVRef(reference);
		}
Ejemplo n.º 7
0
		/// <summary>overload for same end ref</summary>
		public static void VerifyParaDiff(Difference diff,
			BCVRef startAndEnd, DifferenceType type,
			StTxtPara paraCurr, int ichMinCurr, int ichLimCurr,
			StTxtPara paraRev, int ichMinRev, int ichLimRev)
		{
			VerifyParaDiff(diff, startAndEnd, startAndEnd, type,
				paraCurr, ichMinCurr, ichLimCurr,
				paraRev, ichMinRev, ichLimRev);
		}
Ejemplo n.º 8
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Initializes a new instance of the <see cref="SCTextSegment"/> class.
		/// </summary>
		/// ------------------------------------------------------------------------------------
		public SCTextSegment(string text, string marker, string literalVerse,
			BCVRef firstRef, BCVRef lastRef, string filename, int lineNumber)
		{
			m_marker = marker;
			m_text = text;
			m_firstRef = new BCVRef(firstRef);
			m_lastRef = new BCVRef(lastRef);
			m_filename = filename;
			m_lineNumber = lineNumber;
			m_literalVerse = literalVerse;
		}
Ejemplo n.º 9
0
		public DummyPictureCheckingToken(ICmObject obj, int ws, string icuLocale)
		{
			m_startRef = m_endRef = new BCVRef(1, 3, 34);
			m_fNoteStart = false;
			m_fParagraphStart = false;
			m_icuLocale = icuLocale;
			m_object = obj;
			m_sText = "La biblioteque in Monroe";
			m_paraStyleName = ScrStyleNames.Figure;
			m_textType = TextType.Other;
			Ws = ws;
			m_flid = CmPictureTags.kflidCaption;
		}
Ejemplo n.º 10
0
		/// ------------------------------------------------------------------------------------
		/// <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;
		}
Ejemplo n.º 11
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Initializes a new instance of the <see cref="DummyParaCheckingToken"/> class.
		/// </summary>
		/// <param name="obj">The obj.</param>
		/// <param name="ws">The writing system</param>
		/// <param name="paraOffset">The para offset.</param>
		/// <param name="startRef">The start reference.</param>
		/// <param name="endRef">The end reference.</param>
		/// ------------------------------------------------------------------------------------
		public DummyParaCheckingToken(ICmObject obj, int ws, int paraOffset,
			BCVRef startRef, BCVRef endRef)
		{
			m_startRef = startRef;
			m_endRef = endRef;
			m_fNoteStart = false;
			m_fParagraphStart = false;
			m_icuLocale = null;
			m_object = obj;
			m_sText = "This is lousy text and it is bad, it is";
			m_paraStyleName = ScrStyleNames.NormalParagraph;
			m_textType = TextType.Verse;
			Ws = ws;
			m_flid = (int)StTxtPara.StTxtParaTags.kflidContents;
			m_paraOffset = paraOffset;
		}
Ejemplo n.º 12
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Create a text segment enumerator for importing a project
		/// </summary>
		/// <param name="firstRef">start reference for importing</param>
		/// <param name="lastRef">end reference for importing</param>
		/// <returns></returns>
		/// ------------------------------------------------------------------------------------
		public ISCTextEnum TextEnum(BCVRef firstRef, BCVRef lastRef)
		{
			try
			{
				if (m_encConverters == null)
					m_encConverters = new EncConverters();
			}
			catch (DirectoryNotFoundException ex)
			{
				string message = string.Format(ScriptureUtilsException.GetResourceString(
						"kstidEncConverterInitError"), ex.Message);
				throw new EncodingConverterException(message,
					"/Beginning_Tasks/Import_Standard_Format/Unable_to_Import/Encoding_converter_not_found.htm");
			}

			// get the enumerator that will return text segments
			return new SCTextEnum(m_settings, m_domain, firstRef, lastRef, m_encConverters);
		}
Ejemplo n.º 13
0
		public override void Initialize()
		{
			base.Initialize();

			m_styleSheet = new FwStyleSheet();
			m_styleSheet.Init(Cache, m_scr.Hvo, (int)Scripture.ScriptureTags.kflidStyles);
			InitWsInfo();

			DummyTeImporter.s_translatorNoteDefn = m_scrInMemoryCache.m_translatorNoteDefn;
			DummyTeImporter.s_consultantNoteDefn = m_scrInMemoryCache.m_consultantNoteDefn;

			m_titus = new BCVRef(56001001);
			m_settings = new DummyScrImportSet();
			m_scr.ImportSettingsOC.Add(m_settings);
			m_settings.ImportTypeEnum = TypeOfImport.Other;
			m_settings.StartRef = m_titus;
			m_settings.EndRef = m_titus;
			m_settings.ImportTranslation = true;
			InitializeImportSettings();

			m_importer = new DummyTeImporter(m_settings, Cache, m_styleSheet, m_scrInMemoryCache);
			m_importer.Initialize();
		}
Ejemplo n.º 14
0
		public void ValidBCVRefs()
		{
			BCVRef bcvRef = new BCVRef(1, 2, 3, 0);
			Assert.IsTrue(bcvRef.Valid);
			Assert.AreEqual(1002003, (int)bcvRef);
			Assert.AreEqual(1, bcvRef.Book);
			Assert.AreEqual(2, bcvRef.Chapter);
			Assert.AreEqual(3, bcvRef.Verse);

			bcvRef = new BCVRef(4005006);
			Assert.IsTrue(bcvRef.Valid);
			Assert.AreEqual(4005006, (int)bcvRef);
			Assert.AreEqual(4, bcvRef.Book);
			Assert.AreEqual(5, bcvRef.Chapter);
			Assert.AreEqual(6, bcvRef.Verse);

			bcvRef = new BCVRef();
			Assert.IsFalse(bcvRef.Valid);
			Assert.AreEqual(0, (int)bcvRef);
			Assert.AreEqual(0, bcvRef.Book);
			Assert.AreEqual(0, bcvRef.Chapter);
			Assert.AreEqual(0, bcvRef.Verse);
		}
Ejemplo n.º 15
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Initializes a new instance of the <see cref="SCTextEnum"/> class.
		/// </summary>
		/// <param name="settings">The import settings</param>
		/// <param name="domain">The source domain</param>
		/// <param name="startRef">first reference to retrieve</param>
		/// <param name="endRef">last reference to retrieve</param>
		/// <param name="encConverters">The encoding converters repository</param>
		/// ------------------------------------------------------------------------------------
		public SCTextEnum(IScrImportSet settings, ImportDomain domain,
			BCVRef startRef, BCVRef endRef, IEncConverters encConverters)
		{
			m_settings = settings;
			m_domain = domain;
			m_startRef = new BCVRef(startRef);
			m_endRef = new BCVRef(endRef);
			m_mappingSet = m_settings.GetMappingSetForDomain(domain);

			// Gets the set of encoding converters
			m_encConverters = encConverters;

			// make a list of all of the begin and end markers for inline markers
			// Also build the map of encoding converters
			m_InlineBeginAndEndMarkers = new List<string>();
			foreach (ImportMappingInfo mapping in m_settings.GetMappingListForDomain(domain))
			{
				if (mapping.IsInline || m_settings.ImportTypeEnum == TypeOfImport.Paratext5)
				{
					m_InlineBeginAndEndMarkers.Add(mapping.BeginMarker);
					if (mapping.IsInline)
						m_InlineBeginAndEndMarkers.Add(mapping.EndMarker);
				}
			}

			m_InlineBeginAndEndMarkers.Sort(new StrLengthComparer(false));

			// Build a list of all of the characters that inline markers start with
			Set<char> tempCharList = new Set<char>();
			foreach (string marker in m_InlineBeginAndEndMarkers)
				tempCharList.Add(marker[0]); // Set ignores duplicates.

			m_InlineMarkerStartChars = tempCharList.ToArray();
			// Get the import file source that will provide the files to import.
			m_importSource = settings.GetImportFiles(domain);
			m_importSourceEnum = m_importSource.GetEnumerator();
		}
Ejemplo n.º 16
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// A helper method for book merger tests-
		/// Verifies the contents of the given difference
		/// for any types that deal with changes in a paragraph.
		/// </summary>
		/// <remarks>char styles and subDiffs are not verified here; test code should just check
		/// those directly if relevant</remarks>
		/// <param name="diff">the given Difference.</param>
		/// <param name="start">The verse ref start.</param>
		/// <param name="end">The verse ref end.</param>
		/// <param name="type">Type of the diff.</param>
		/// <param name="paraCurr">The Current paragraph.</param>
		/// <param name="ichMinCurr">The ich min in paraCurr.</param>
		/// <param name="ichLimCurr">The ich lim in paraCurr.</param>
		/// <param name="paraRev">The Revision paragraph.</param>
		/// <param name="ichMinRev">The ich min in paraRev.</param>
		/// <param name="ichLimRev">The ich lim in paraRev.</param>
		/// ------------------------------------------------------------------------------------
		public static void VerifyParaDiff(Difference diff,
			BCVRef start, BCVRef end, DifferenceType type,
			StTxtPara paraCurr, int ichMinCurr, int ichLimCurr,
			StTxtPara paraRev, int ichMinRev, int ichLimRev)
		{
			// verify the basics
			Assert.AreEqual(start, diff.RefStart);
			Assert.AreEqual(end, diff.RefEnd);
			Assert.AreEqual(type, diff.DiffType);

			// the Current para stuff
			Assert.AreEqual(paraCurr.Hvo, diff.HvoCurr);
			Assert.AreEqual(ichMinCurr, diff.IchMinCurr);
			Assert.AreEqual(ichLimCurr, diff.IchLimCurr);

			// the Revision para stuff
			Assert.AreEqual(paraRev.Hvo, diff.HvoRev);
			Assert.AreEqual(ichMinRev, diff.IchMinRev);
			Assert.AreEqual(ichLimRev, diff.IchLimRev);

			// section stuff should be null
			Assert.IsNull(diff.HvosSectionsRev);
			Assert.IsNull(diff.HvosSectionsCurr);
		}
Ejemplo n.º 17
0
		public void UndoImport_ReplaceBook()
		{
			FdoCache cache = m_firstMainWnd.Cache;
			Scripture scr = (Scripture)m_firstMainWnd.ScriptureObj;
			Set<int> origDrafts = new Set<int>(scr.ArchivedDraftsOC.HvoArray);

			// Create a settings object and set it to be a Paratext import of Philemon.
			ScrImportSet settings = new ScrImportSet();
			scr.ImportSettingsOC.Add(settings);
			settings.ImportTypeEnum = TypeOfImport.Paratext6;
			settings.ParatextScrProj = "TEV";
			settings.SetMapping(MappingSet.Main, new ImportMappingInfo(@"\it", @"\it*", false, MappingTargetType.TEStyle, MarkerDomain.Default, "Emphasis", null));
			cache.Save();

			// Setup the reference to import.
			BCVRef scrRef = new BCVRef(57001001);

			// Do the import.
			settings.ImportTranslation = true;
			settings.ImportBookIntros = true;
			settings.StartRef = scrRef;
			settings.EndRef = scrRef;
			m_firstMainWnd.Import(settings);

			IScrDraft importedDraft = GetImportedVersion(cache, origDrafts, 2);
			IScrBook importedPhm = importedDraft.FindBook(57);
			Assert.IsNotNull(importedPhm);
			Assert.IsTrue(cache.ActionHandlerAccessor.CanUndo());
			Assert.AreEqual(UndoResult.kuresRefresh, cache.ActionHandlerAccessor.Undo());
			IScrBook restoredPhm = scr.FindBook(57);
			Assert.IsNotNull(restoredPhm);
			Assert.AreNotEqual(restoredPhm.Hvo, importedPhm.Hvo);

			Set<int> finalDrafts = new Set<int>(scr.ArchivedDraftsOC.HvoArray);
			Assert.AreEqual(origDrafts.Count, finalDrafts.Count);

		}
Ejemplo n.º 18
0
		public void UndoImport_NewBook()
		{
			FdoCache cache = m_firstMainWnd.Cache;
			Scripture scr = (Scripture)m_firstMainWnd.ScriptureObj;
			Set<int> origDrafts = new Set<int>(scr.ArchivedDraftsOC.HvoArray);

			// Create a settings object and set it to be a Paratext import of Titus.
			ScrImportSet settings = new ScrImportSet();
			scr.ImportSettingsOC.Add(settings);
			settings.ImportTypeEnum = TypeOfImport.Paratext6;
			settings.ParatextScrProj = "TEV";
			settings.SetMapping(MappingSet.Main, new ImportMappingInfo(@"\it", @"\it*", false, MappingTargetType.TEStyle, MarkerDomain.Default, "Emphasis", null));
			cache.Save();

			// Setup the reference to import.
			BCVRef scrRef = new BCVRef(56001001);

			// Do the import.
			settings.ImportTranslation = true;
			settings.ImportBookIntros = true;
			settings.StartRef = scrRef;
			settings.EndRef = scrRef;
			m_firstMainWnd.Import(settings);

			IScrDraft importedDrafts = GetImportedVersion(cache, origDrafts, 1);
			Assert.IsNotNull(importedDrafts.FindBook(56));
			Assert.IsTrue(cache.ActionHandlerAccessor.CanUndo());
			Assert.AreEqual(UndoResult.kuresRefresh, cache.ActionHandlerAccessor.Undo());
			Assert.IsNull(scr.FindBook(56));
			// JohnT: no longer happens, and I can't think why it should, since Undo does not
			// change Scripture.

			Set<int> finalDrafts = new Set<int>(scr.ArchivedDraftsOC.HvoArray);
			Assert.AreEqual(origDrafts.Count, finalDrafts.Count);
		}
Ejemplo n.º 19
0
		public void VerifyStylesComboBoxAfterImport()
		{
			Unpacker.UnpackTEVTitusWithUnmappedStyle();

			try
			{
				// Move selection to a place in the text where the styles combo contents
				// are not restricted to exclude general paragraphs (Jud 1:10 will do).
				m_firstDraftView.GotoVerse(65001010);
				// Make sure the style combo box doesn't have the UnknownTEStyle in it.
				Assert.IsTrue(m_firstMainWnd.ParaStylesComboBox.FindString(@"\xx") < 0,
					@"'\xx' was found!");

				// Create a settings object and set it to be a Paratext import of the
				// TEV scripture project (containing Titus with an unmapped marker).
				IScripture scr = (Scripture)m_firstMainWnd.ScriptureObj;
				IScrImportSet settings = new ScrImportSet();
				scr.ImportSettingsOC.Add(settings);
				scr.DefaultImportSettings = settings;
				settings.ImportTypeEnum = TypeOfImport.Paratext6;
				settings.ParatextScrProj = "TEV";

				// Setup the reference to import.
				BCVRef scrRef = new BCVRef(56001001);

				// Do the import.
				settings.ImportTranslation = true;
				(settings as ScrImportSet).StartRef = scrRef;
				(settings as ScrImportSet).EndRef = scrRef;
				m_firstMainWnd.Import(settings);
				m_firstMainWnd.InitStyleComboBox();

				// Move selection back to Jud 1:10 because the selection seems to get messed
				// up in this test.
				m_firstDraftView.GotoVerse(65001010);

				// Make sure the styles combo now contains a new style for the unmapped marker
				// found in our test TEV style sheet and in the test Titus scripture data
				// (the style file and scripture data file contain the unmapped marker '\xx').
				Assert.IsTrue(m_firstMainWnd.ParaStylesComboBox.FindString(@"\xx") >= 0,
					@"'\xx' was not found!");
			}
			finally
			{
				Unpacker.UnPackParatextTestProjects();
			}
		}
Ejemplo n.º 20
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Convert a Scripture reference to a string (perhaps like this: 16:3, depending on the
		/// chapterVerseSeparator).  It will also handle script digits if necessary.
		/// </summary>
		/// <param name="reference">A ScrReference that holds the chapter and verse to format</param>
		/// <param name="hvoWs">The HVO of the writing system in which we are displaying this
		/// reference (used to determine whether to use script digits and whether to include
		/// right-to-left marks)</param>
		/// <returns>A formatted chapter/verse reference</returns>
		/// <remarks>See TeHeaderFooterVc for an example of how to format the full reference,
		/// including book name. The method BookName in that class could be moved somewhere
		/// more appropriate if it's ever needed.</remarks>
		/// ------------------------------------------------------------------------------------
		public string ChapterVerseRefAsString(BCVRef reference, int hvoWs)
		{
			bool fUseScriptDigits = (UseScriptDigits && hvoWs == Cache.DefaultVernWs);
			string sVerseRef = (reference.Verse > 0) ?
				ConvertToString(reference.Verse, fUseScriptDigits) : String.Empty;

			if (reference.Chapter > 0 && reference.Verse > 0)
				{
				return ConvertToString(reference.Chapter, fUseScriptDigits) +
					ChapterVerseSeparatorForWs(hvoWs) + sVerseRef;
				}
			return sVerseRef;
			}
Ejemplo n.º 21
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Convert a Scripture reference to a string (like this: 16:3).  It will also
		/// handle script digits if necessary.
		/// </summary>
		/// <param name="reference">A ScrReference that holds the chapter and verse to format</param>
		/// <returns>A formatted chapter/verse reference</returns>
		/// <remarks>See TeHeaderFooterVc for an example of how to format the full reference,
		/// including book name. The method BookName in that class could be moved somewhere
		/// more appropriate if it's ever needed.</remarks>
		/// ------------------------------------------------------------------------------------
		public string ChapterVerseRefAsString(BCVRef reference)
		{
			return ChapterVerseRefAsString(reference, m_cache.DefaultVernWs);
		}
Ejemplo n.º 22
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Parses a picture location range string.
		/// </summary>
		/// <param name="s">The string representation of a picture location range.</param>
		/// <param name="anchorLocation">The anchor location.</param>
		/// <param name="locType">The type of the location range. The incoming value tells us
		/// the assumed type for parsing. The out value can be set to a different type if we
		/// discover that the actual value is another type.</param>
		/// <param name="locationMin">The location min.</param>
		/// <param name="locationMax">The location max.</param>
		/// <remarks>This is implemented on Scripture because CmPicture's implementation does
		/// not handle Scripture reference ranges.</remarks>
		/// ------------------------------------------------------------------------------------
		public void ParsePictureLoc(string s, int anchorLocation,
			ref PictureLocationRangeType locType, out int locationMin, out int locationMax)
		{
			locationMin = locationMax = 0;
			if (BCVRef.GetChapterFromBcv(anchorLocation) == 1 &&
				BCVRef.GetVerseFromBcv(anchorLocation) == 0)
			{
				string[] pieces = s.Split(new char[] { '-' }, 2,
					StringSplitOptions.RemoveEmptyEntries);

				if (pieces.Length == 2 &&
					Int32.TryParse(pieces[0], out locationMin) &&
					Int32.TryParse(pieces[1], out locationMax))
				{
					locType = PictureLocationRangeType.ParagraphRange;
					return;
				}
				locType = PictureLocationRangeType.AfterAnchor;
				return;
			}
			BCVRef startRef = new BCVRef(anchorLocation);
			BCVRef endRef = new BCVRef(anchorLocation);
			if (ScrReference.ParseRefRange(s, ref startRef, ref endRef, Versification) &&
				startRef <= anchorLocation && endRef >= anchorLocation)
			{
				locationMin = startRef.BBCCCVVV;
				locationMax = endRef.BBCCCVVV;
				locType = PictureLocationRangeType.ReferenceRange;
			}
			else
				locType = PictureLocationRangeType.AfterAnchor;
		}
Ejemplo n.º 23
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Convert two Scripture references to a string (perhaps like this: 16:3-6), depending
		/// on the chapter/verse separator. It will also handle script digits if necessary.
		/// </summary>
		/// <param name="start">A BCVRef that holds the chapter and beginning verse to format</param>
		/// <param name="end">A BCVRef that holds the ending reference (if book and chapter
		/// don't match book and chapter of start ref, an argument exception is hurled</param>
		/// <param name="hvoWs">HVO of the writing system for which we are formatting this
		/// reference.</param>
		/// <returns>A formatted chapter/verse reference</returns>
		/// ------------------------------------------------------------------------------------
		public string ChapterVerseBridgeAsString(BCVRef start, BCVRef end, int hvoWs)
		{
			if (start.Book != end.Book)
				throw new ArgumentException("Books are different");
			if (start.Chapter != end.Chapter)
				throw new ArgumentException("Chapters are different");
			string sResult = ChapterVerseRefAsString(start, hvoWs);

			if (start.Verse != end.Verse)
			{
				bool fUseScriptDigits = (UseScriptDigits && hvoWs == Cache.DefaultVernWs);
				sResult = MakeBridgeAsString(sResult, ConvertToString(end.Verse, fUseScriptDigits), hvoWs);
			}

			return sResult;
		}
Ejemplo n.º 24
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Attempts to scroll to the first annotation whose beginning reference's book is
		/// the same as the specified book.
		/// </summary>
		/// ------------------------------------------------------------------------------------
		private bool ScrollToNonScrAnnotationByBook(int book, string selectedText)
		{
			int bookHvo = m_scr.BookAnnotationsOS[book - 1].Hvo;
			int[] annHvos = ((ISilDataAccessManaged)m_rootb.DataAccess).VecProp(bookHvo,
					kCurrentNotesTag);

			if (annHvos.Length == 0)
				return false;

			int ihvo = 0;
			IScrScriptureNote ann;
			BCVRef bcvRef;

			// Go through the annotations for the book and find the one whose
			// cited text is the same as the specified selected text.
			for (int i = 0; i < annHvos.Length; i++)
			{
				ann = Cache.ServiceLocator.GetInstance<IScrScriptureNoteRepository>().GetObject(annHvos[i]);
				bcvRef = new BCVRef(ann.BeginRef);
				if (ann.CitedText == selectedText && bcvRef.Chapter == 0)
				{
					ihvo = i;
					break;
				}
			}

			ann = Cache.ServiceLocator.GetInstance<IScrScriptureNoteRepository>().GetObject(annHvos[ihvo]);
			bcvRef = new BCVRef(ann.BeginRef);
			if (bcvRef.Chapter > 0)
				return false;

			NotesEditingHelper.MakeSelectionInNote(m_vc, book - 1, ihvo, this, m_vc.IsExpanded(ann.Hvo));
			return true;
		}
Ejemplo n.º 25
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Sets the start ref to first book available for import.
		/// </summary>
		/// ------------------------------------------------------------------------------------
		private void SetStartRefToFirstImportableBook()
		{
			StartRef = new BCVRef(FirstImportableBook, 1, 1);
		}
Ejemplo n.º 26
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Clears the starting and ending references in this dialog.
		/// </summary>
		/// ------------------------------------------------------------------------------------
		public static void ClearDialogReferences()
		{
			s_StartRef = null;
			s_EndRef = null;
		}
Ejemplo n.º 27
0
		///-------------------------------------------------------------------------------
		/// <summary>
		/// If the user didn't choose cancel, save the controls' values.
		/// </summary>
		/// <param name="e"></param>
		///-------------------------------------------------------------------------------
		protected override void OnClosing(CancelEventArgs e)
		{
			// If the scripture range is selected, then make sure both scripture references are
			// valid. Focus the incorrect one.
			if (this.DialogResult == DialogResult.OK && radImportRange.Checked)
			{
				if (!scrPsgFrom.Valid)
				{
					scrPsgFrom.Focus();
					e.Cancel = true;
					return;
				}
				if (!scrPsgTo.Valid)
				{
					scrPsgTo.Focus();
					e.Cancel = true;
					return;
				}
			}
			else if (DialogResult == DialogResult.OK && radImportEntire.Checked)
			{
				m_importSettings.StartRef = StartRef;
				m_importSettings.EndRef = EndRef;
				NonUndoableUnitOfWorkHelper.Do(ActionHandler, () => m_importSettings.SaveSettings());
			}

			base.OnClosing(e);

			if (this.DialogResult == DialogResult.OK)
			{
				ImportEntire = radImportEntire.Checked;
				ImportTranslation = chkTranslation.Checked;
				ImportBackTranslation = chkBackTranslation.Checked;
				ImportBookIntros = chkBookIntros.Checked;
				ImportAnnotations = chkOther.Checked;
				s_StartRef = scrPsgFrom.ScReference;
				s_EndRef = scrPsgTo.ScReference;
				if (m_importSettings != null)
				{
					m_importSettings.StartRef = StartRef;
					m_importSettings.EndRef = EndRef;
					m_importSettings.ImportTranslation = chkTranslation.Checked;
					m_importSettings.ImportBackTranslation = chkBackTranslation.Checked;
					m_importSettings.ImportBookIntros = chkBookIntros.Checked;
					m_importSettings.ImportAnnotations = chkOther.Checked;
				}
			}
		}
Ejemplo n.º 28
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Find a paragraph with the specified style id, containing the specified verse number,
		/// if specified, and having the correct sequence number.
		/// </summary>
		/// <param name="targetStyle">style of paragraph to find</param>
		/// <param name="targetRef">Reference to seek</param>
		/// <param name="iPara">0-based index of paragraph</param>
		/// <param name="iVernSection">0-based index of the section the corresponding
		/// vernacular paragraph is in. This will be 0 if no corresponding paragraph can be
		/// found.</param>
		/// <returns>The corresponding StTxtPara, or null if no matching para is found</returns>
		/// ------------------------------------------------------------------------------------
		public IScrTxtPara FindPara(IStStyle targetStyle, BCVRef targetRef, int iPara,
			ref int iVernSection)
		{
			// REVIEW: In production code, iPara is always passed as 0. Can we eliminate this parameter?
			// Do tests really need to be able to pass 1? Why are we testing something that can never happen in real life?
			Debug.Assert(targetRef.BookIsValid, "Invalid book number");
			IScrBook book = FindBook(targetRef.Book);
			if (book == null)
				return null;

			return book.FindPara(targetStyle, targetRef, iPara, ref iVernSection);
		}
Ejemplo n.º 29
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Sets the end ref to last book available for import.
		/// </summary>
		/// ------------------------------------------------------------------------------------
		private void SetEndRefToLastImportableBook()
		{
			EndRef = new BCVRef(LastImportableBook, 1, 1);
		}
Ejemplo n.º 30
0
		/// ------------------------------------------------------------------------------------
		/// <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);
		}