コード例 #1
0
ファイル: StFootnoteTests.cs プロジェクト: sillsdev/WorldPad
		int m_wsUr; // Urdu writing system (used for Foreign style)
		#endregion

		#region Test setup
		/// ------------------------------------------------------------------------------------
		/// <summary>
		///
		/// </summary>
		/// ------------------------------------------------------------------------------------
		protected override void CreateTestData()
		{
			m_inMemoryCache.InitializeWritingSystemEncodings();

			// create footnote
			m_footnote = new StFootnote();
			m_book = (ScrBook)m_scrInMemoryCache.AddBookToMockedScripture(1, "Genesis");
			m_book.FootnotesOS.Append(m_footnote);
			m_footnote.FootnoteMarker.Text = "o";
			m_footnote.DisplayFootnoteMarker = true;
			m_footnote.DisplayFootnoteReference = false;

			// create one empty footnote para
			StTxtPara para = new StTxtPara();
			m_footnote.ParagraphsOS.Append(para);
			para.StyleRules = StyleUtils.ParaStyleTextProps(ScrStyleNames.NormalFootnoteParagraph);

			m_strFact = TsStrFactoryClass.Create();
			m_vernWs = Cache.LangProject.DefaultVernacularWritingSystem;
			para.Contents.UnderlyingTsString = m_strFact.MakeString(string.Empty, m_vernWs);
			m_footnotePara = (StTxtPara)m_footnote.ParagraphsOS[0];

			m_wsUr = InMemoryFdoCache.s_wsHvos.Ur; // used with 'foreign' character style
			m_wsDe = InMemoryFdoCache.s_wsHvos.De; // used for back translations
			m_wsEs = InMemoryFdoCache.s_wsHvos.Es;
		}
コード例 #2
0
ファイル: StVcTests.cs プロジェクト: sillsdev/WorldPad
		public void GetFootnoteMarkerFromGuid()
		{
			StFootnote footnote = new StFootnote();
			m_scr.ScriptureBooksOS[0].FootnotesOS.Append(footnote);
			footnote.FootnoteMarker.Text = "a";

			Guid guid = m_fdoCache.GetGuidFromId(footnote.Hvo);

			// Add the guid property so we can get it out as a string.
			ITsPropsBldr propsBldr = TsPropsBldrClass.Create();
			byte[] objData = MiscUtils.GetObjData(guid, 1);
			propsBldr.SetStrPropValueRgch(1, objData, objData.Length);

			// Get the guid property as a string.
			string sObjData;
			propsBldr.GetStrPropValue(1, out sObjData);

			using (StVc vc = new StVc())
			{
				vc.Cache = m_fdoCache;
				vc.DefaultWs = m_fdoCache.LanguageWritingSystemFactoryAccessor.UserWs;
				ITsString footnoteMarker = vc.GetStrForGuid(sObjData.Substring(1));

				Assert.AreEqual("2", footnoteMarker.Text);
			}
		}
コード例 #3
0
        /// ------------------------------------------------------------------------------------
        /// <summary>
        /// Constructor for the FootnoteInfo structure
        /// </summary>
        /// <param name="stFootnote">given footnote</param>
        /// ------------------------------------------------------------------------------------
        public FootnoteInfo(StFootnote stFootnote)
        {
            footnote = stFootnote;
            StPara para = (StPara)footnote.ParagraphsOS[0];

            if (para.StyleRules != null)
            {
                paraStylename = para.StyleRules.GetStrPropValue((int)FwTextPropType.ktptNamedStyle);
            }
            else
            {
                paraStylename = null;
                Debug.Fail("StyleRules should never be null.");
            }
        }
コード例 #4
0
ファイル: InMemoryFdoCache.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Add a back translation footnote ref ORC in the given translation for the given footnote
		/// </summary>
		/// <param name="trans">The given translation, usually a back translation</param>
		/// <param name="ichPos">The 0-based character offset into the translation string
		/// at which we will insert the reference ORC</param>
		/// <param name="ws">writing system of the ORC</param>
		/// <param name="footnote">The given footnote</param>
		/// ------------------------------------------------------------------------------------
		public void AddFootnoteORCtoTrans(ICmTranslation trans, int ichPos, int ws, StFootnote footnote)
		{
			CheckDisposed();
			// Insert a footnote reference ORC into the given translation string
			ITsStrBldr tsStrBldr = trans.Translation.GetAlternative(ws).UnderlyingTsString.GetBldr();
			footnote.InsertRefORCIntoTrans(tsStrBldr, ichPos, ws);
			trans.Translation.SetAlternative(tsStrBldr.GetString(), ws);
		}
コード例 #5
0
ファイル: DiffTestHelper.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// A helper method for book merger tests-
		/// Verifies the contents of the given sub-difference
		/// for a two-sided subDiff representing a text comparison. This overload does not
		/// check for the starting and ending references for sub-diffs that are created without
		/// that information.
		/// </summary>
		/// <param name="rootDiff">The root difference.</param>
		/// <param name="iSubDiff">The sub difference to verify.</param>
		/// <param name="subDiffType">Type of the sub difference.</param>
		/// <param name="footnoteCurr">The footnote curr.</param>
		/// <param name="ichMinCurr">The beginning character offset of the difference in the
		/// current.</param>
		/// <param name="ichLimCurr">The ending character offset of the difference in the
		/// current.</param>
		/// <param name="footnoteRev">The footnote rev.</param>
		/// <param name="ichMinRev">The beginning character offset of the difference in the
		/// revision.</param>
		/// <param name="ichLimRev">The ending character offset of the difference in the
		/// current.</param>
		/// <remarks>char styles are not verified here; test code should just check
		/// those directly if relevant</remarks>
		/// ------------------------------------------------------------------------------------
		public static void VerifySubDiffFootnote(Difference rootDiff, int iSubDiff,
			DifferenceType subDiffType,
			StFootnote footnoteCurr, int ichMinCurr, int ichLimCurr,
			StFootnote footnoteRev, int ichMinRev, int ichLimRev)
		{
			Difference subDiff = rootDiff.SubDiffsForORCs[iSubDiff];
			// the Current para stuff
			Assert.AreEqual((footnoteCurr != null) ? footnoteCurr.ParagraphsOS[0].Hvo : 0, subDiff.HvoCurr);
			Assert.AreEqual(ichMinCurr, subDiff.IchMinCurr);
			Assert.AreEqual(ichLimCurr, subDiff.IchLimCurr);

			// the Revision para stuff
			Assert.AreEqual((footnoteRev != null) ? footnoteRev.ParagraphsOS[0].Hvo : 0, subDiff.HvoRev);
			Assert.AreEqual(ichMinRev, subDiff.IchMinRev);
			Assert.AreEqual(ichLimRev, subDiff.IchLimRev);

			// section stuff should be null
			Assert.IsNull(subDiff.HvosSectionsRev);
			Assert.IsNull(subDiff.HvosSectionsCurr);

			// subDiffs may not have subDiffs, so far
			Assert.IsNull(subDiff.SubDiffsForORCs);
			Assert.IsNull(subDiff.SubDiffsForParas);

			Assert.AreEqual(subDiffType, subDiff.DiffType);
		}
コード例 #6
0
 /// ------------------------------------------------------------------------------------
 /// <summary>
 /// Constructor for the FootnoteInfo structure
 /// </summary>
 /// <param name="stFootnote">given footnote</param>
 /// <param name="sParaStylename">paragraph style of the footnote</param>
 /// ------------------------------------------------------------------------------------
 public FootnoteInfo(StFootnote stFootnote, string sParaStylename)
 {
     footnote      = stFootnote;
     paraStylename = sParaStylename;
 }
コード例 #7
0
ファイル: TeImport.cs プロジェクト: sillsdev/WorldPad
		/// <summary>
		/// Executes in two distinct scenarios.
		///
		/// 1. If disposing is true, the method has been called directly
		/// or indirectly by a user's code via the Dispose method.
		/// Both managed and unmanaged resources can be disposed.
		///
		/// 2. If disposing is false, the method has been called by the
		/// runtime from inside the finalizer and you should not reference (access)
		/// other managed objects, as they already have been garbage collected.
		/// Only unmanaged resources can be disposed.
		/// </summary>
		/// <param name="disposing"></param>
		/// <remarks>
		/// If any exceptions are thrown, that is fine.
		/// If the method is being done in a finalizer, it will be ignored.
		/// If it is thrown by client code calling Dispose,
		/// it needs to be handled by fixing the bug.
		///
		/// If subclasses override this method, they should call the base implementation.
		/// </remarks>
		protected override void Dispose(bool disposing)
		{
			//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
			// Must not be run more than once.
			if (m_isDisposed)
				return;

			if (disposing)
			{
				// Dispose managed resources here.
			}

			// Dispose unmanaged resources here, whether disposing is true or false.
			if (m_cpe != null && Marshal.IsComObject(m_cpe))
				Marshal.ReleaseComObject(m_cpe);
			m_cpe = null;
			m_settings = null;
			m_SOWrapper = null;
			m_sSegmentText = null;
			m_sMarker = null;
			m_styleProxy = null;
			m_vernParaStyleProxy = null;
			m_vernTextProps = null;
			m_analTextProps = null;
			m_styleProxies = null;
			m_notesStyleProxies = null;
			m_lastPara = null;
			m_BookTitleParaProxy = null;
			m_DefaultFootnoteParaProxy = null;
			m_TsStringFactory = null;
			m_BTFootnoteStrBldr = null;
			m_CurrParaPictures = null;
			m_CurrParaFootnotes = null;
			m_BTPendingPictures = null;
			m_CurrBTFootnote = null;
			m_sBtFootnoteParaStyle = null;
			m_BtFootnoteStrBldrs = null;
			m_PendingAnnotations = null;
			m_BTfootnoteIndex = null;
			m_sCharStyleEndMarker = null;
			m_sFootnoteEndMarker = null;
			m_sCharStyleBeginMarker = null;
			m_sFootnoteBeginMarker = null;
			m_scrTranslatorAnnotationDef = null;

			base.Dispose(disposing);
		}
コード例 #8
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Create a mindless footnote (i.e., it's marker, paragraph style, etc. won't be set).
		/// </summary>
		/// <param name="book">Book to insert footnote into</param>
		/// <param name="para">Paragraph to insert footnote into</param>
		/// <param name="iFootnotePos">The 0-based index of the new footnote in the collection
		/// of footnotes owned by the book</param>
		/// <param name="ichPos">The 0-based character offset into the paragraph</param>
		/// <returns></returns>
		/// ------------------------------------------------------------------------------------
		protected StFootnote InsertTestFootnote(IScrBook book, IStTxtPara para,
			int iFootnotePos, int ichPos)
		{
			// Create the footnote
			StFootnote footnote = new StFootnote();
			book.FootnotesOS.InsertAt(footnote, iFootnotePos);

			// Update the paragraph contents to include the footnote marker
			ITsStrBldr tsStrBldr = para.Contents.UnderlyingTsString.GetBldr();
			footnote.InsertOwningORCIntoPara(tsStrBldr, ichPos, 0); // Don't care about ws
			para.Contents.UnderlyingTsString = tsStrBldr.GetString();

			return footnote;
		}
コード例 #9
0
ファイル: FootnoteView.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Scrolls the requested footnote to the top of the view
		/// </summary>
		/// <param name="footnote">The target footnote</param>
		/// <param name="fPutInsertionPtAtEnd">if set to <c>true</c> and showing the view,
		/// the insertion point will be put at the end of the footnote text instead of at the
		/// beginning, as would be appropriate in the case of a newly inserted footnote that has
		/// Reference Text. This parameter is ignored if footnote is null.</param>
		/// ------------------------------------------------------------------------------------
		public void ScrollToFootnote(StFootnote footnote, bool fPutInsertionPtAtEnd)
		{
			CheckDisposed();

			// find book owning this footnote
			int iBook = m_bookFilter.GetBookIndex(footnote.OwnerHVO);
			ScrBook book = new ScrBook(Cache, footnote.OwnerHVO);

			// find index of this footnote
			int iFootnote = footnote.IndexInOwner;

			// create selection pointing to this footnote
			FootnoteEditingHelper.ScrollToFootnote(iBook, iFootnote, (fPutInsertionPtAtEnd ?
				((StTxtPara)footnote.ParagraphsOS[0]).Contents.Length: 0));
		}
コード例 #10
0
ファイル: TeImport.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Process a back translation segment (duh)
		/// </summary>
		/// ------------------------------------------------------------------------------------
		protected void ProcessBackTransSegment()
		{
			if (m_styleProxy.Function == FunctionValues.Chapter)
			{
				ProcessStartOfChapter();
				return;
			}

			if (!m_settings.ImportBackTranslation)
			{
				if (m_styleProxy.Function == FunctionValues.Verse)
					m_currentRef.Verse = SOWrapper.SegmentFirstRef.Verse;
				return;
			}

			if (CurrentBook == null)
			{
				// An interleaved BT paragraph is being imported for a book that
				// doesn't exist.
				throw new ScriptureUtilsException(SUE_ErrorCode.BackTransMissingVernBook,
					null, null, ScrReference.NumberToBookCode(m_nBookNumber), null, null, true);
			}

			// Any non-end marker ends a character style
			if (m_context != ContextValues.EndMarker)
				EndCharStyle();

			ITsTextProps ttpBtSeg;
			bool fThisSegmentEndsAFootnote = false;
			if (m_importDomain == ImportDomain.Main)
			{
				int wsBT = BackTransWS;
				ttpBtSeg = GetBTProps(wsBT);
				if (wsBT != m_wsCurrBtPara &&
					(m_styleProxy.Domain != MarkerDomain.Default ||
					 m_styleProxy.StyleType == StyleType.kstParagraph))
				{
					// We're about to change which WS is being processed, so end any open character
					// style and/or footnote.
					EndCharStyle();
					if (m_fInFootnote)
					{
						EndFootnote();
						fThisSegmentEndsAFootnote = (m_currDomain & MarkerDomain.Footnote) == 0;
					}
					m_wsCurrBtPara = wsBT;
				}
				else if (m_context == ContextValues.EndMarker)
					fThisSegmentEndsAFootnote = ProcessBTEndMarker();
				else if (m_fInFootnote && (m_currDomain & MarkerDomain.Footnote) != 0 &&
					m_styleProxy.StyleType == StyleType.kstParagraph)
				{
					EndFootnote();
					fThisSegmentEndsAFootnote = (m_currDomain & MarkerDomain.Footnote) == 0;
				}
			}
			else
			{
				ttpBtSeg = GetBTProps(m_wsCurrBtPara);
				if (m_context == ContextValues.EndMarker)
					fThisSegmentEndsAFootnote = ProcessBTEndMarker();
			}

			if (m_importDomain == ImportDomain.BackTrans && ProcessingParagraphStart)
			{
				if (m_fInFootnote)
				{
					EndFootnote();
					fThisSegmentEndsAFootnote = (m_currDomain & MarkerDomain.Footnote) == 0;
				}

				AddBackTranslations();
			}

			if (!m_fInScriptureText && m_styleProxy.Context == ContextValues.Text &&
				m_styleProxy.Structure == StructureValues.Body)
			{
				// If this BT segment is a scripture body segment and we don't already have
				// a paragraph started, this file must have an implicit paragraph start,
				// so we initialize the member that holds the para style proxy for the
				// corresponding vernacular para so we'll have something reasonable to
				// look for when we go to find the corresponding para.
				if (m_BTStrBldrs.Count == 0 && m_importDomain == ImportDomain.BackTrans)
					m_vernParaStyleProxy = m_DefaultScrParaProxy;
				m_fInScriptureText = true;
				m_iNextBtPara = 0;
			}

			ITsStrBldr strbldr;

			if (m_BTStrBldrs.ContainsKey(m_wsCurrBtPara))
			{
				// We continue to use the existing BT para builder (for this WS) until the
				// vernacular paragraph -- and hence any BT paragraph(s) -- get written.
				// This means that if the BT contains spurious paragraph markers, their
				// segments will just be appended to the one-and-only BT paragraph (for this
				// WS) already being built.
				// TODO: Generate an error annotation.
				Debug.Assert(m_wsCurrBtPara != 0);
				strbldr = m_BTStrBldrs[m_wsCurrBtPara];
			}
			else
			{
				if (ProcessingParagraphStart)
				{
					if (m_importDomain == ImportDomain.Main)
					{
						if (m_vernParaStyleProxy == null || m_vernParaStyleProxy.StyleId == null)
						{
							// Got an unexpected BT paragraph segment. A BT paragraph came before
							// any vernacular paragraph in the import stream.
							int verse = SOWrapper.SegmentFirstRef.Verse;
							throw new ScriptureUtilsException(SUE_ErrorCode.BackTransMissingVernPara,
								SOWrapper.CurrentFileName, SOWrapper.CurrentLineNumber,
								m_sMarker + " " + m_sSegmentText,
								m_fFoundABook ? CurrentBook.BookId : null,
								m_foundAChapter ? m_nChapter.ToString() : null,
								(verse > 0) ? verse.ToString() : null,
								true);
						}
						if (m_vernParaStyleProxy.StyleId != m_styleProxy.StyleId &&
							m_styleProxy.Style.Type != StyleType.kstCharacter)
						{
							// Got an unexpected BT paragraph segment. The paragraph style of the BT
							// paragraph doesn't match the style of the corresponding (i.e.,
							// preceding) vernacular paragraph.
							int verse = SOWrapper.SegmentFirstRef.Verse;
							throw new ScriptureUtilsException(SUE_ErrorCode.BackTransStyleMismatch,
								m_sMarker + " " + m_sSegmentText, string.Format(
								TeResourceHelper.GetResourceString("kstidBTStyleMismatchDetails"),
								m_styleProxy.StyleId, m_vernParaStyleProxy.StyleId),
								m_fFoundABook ? CurrentBook.BookId : null,
								m_foundAChapter ? m_nChapter.ToString() : null,
								(verse > 0) ? verse.ToString() : null, true);
						}
					}
					// Non-interleaved BT
					else
					{
						ProcessBtParaStart();
					}
				}
				strbldr  = TsStrBldrClass.Create();
				Debug.Assert(m_wsCurrBtPara != 0);
				m_BTStrBldrs[m_wsCurrBtPara] = strbldr;
			}

			if (m_context == ContextValues.Title)
			{
				SetBookName();
				if (m_fInBookTitle)
				{
					// We have another segment to add to the current title
					AddBookTitleSegment(strbldr, m_vernParaStyleProxy, ttpBtSeg);
					return;
				}
				m_fInBookTitle = true;
			}

			AddPendingVerseAndChapterNumsToBackTrans(GetVerseRefAsString(m_wsCurrBtPara), m_wsCurrBtPara, strbldr);

			if ((m_currDomain & MarkerDomain.Footnote) != 0 && !fThisSegmentEndsAFootnote)
			{
				if (m_BTFootnoteStrBldr == null)
				{
					if (m_fInFootnote)
					{
						// This BT footnote ends the vernacular footnote being built
						EndFootnote();
					}
					// remember that we are now processing a footnote
					SetInFootnote();
					CheckDataForFootnoteMarker();
					m_BTFootnoteStrBldr  = TsStrBldrClass.Create();
					m_sBtFootnoteParaStyle = (m_styleProxy.StyleType == StyleType.kstCharacter) ?
						m_DefaultFootnoteParaProxy.StyleId : m_styleProxy.StyleId;
					if (m_importDomain == ImportDomain.Main)
					{
						// If we aren't importing the vernacular... (TE-7445)
						if (!m_settings.ImportTranslation)
						{
							// attempt to find an existing vernacular paragraph that corresponds
							// to the back translation para.
							bool append;
							m_lastPara = FindCorrespondingVernParaForSegment(m_vernParaStyleProxy.Style,
								m_currentRef, out append);
							m_CurrParaFootnotes = (m_lastPara != null ?
								(m_lastPara as StTxtPara).GetFootnotes() : null);
						}

						m_CurrBTFootnote = FindCorrespondingFootnote(m_sBtFootnoteParaStyle);
						if (m_CurrBTFootnote == null)
						{
							int verse = SOWrapper.SegmentFirstRef.Verse;
							throw new ScriptureUtilsException(SUE_ErrorCode.BackTransMissingVernFootnote,
								SOWrapper.CurrentFileName, SOWrapper.CurrentLineNumber,
								m_sMarker + " " + m_sSegmentText,
								m_fFoundABook ? CurrentBook.BookId : null,
								m_foundAChapter ? m_nChapter.ToString(): null,
								(verse > 0) ? verse.ToString() : null,
								true);
						}
					}
					else
					{
						m_CurrBTFootnote = null;
					}
				}
				strbldr = m_BTFootnoteStrBldr;
				if (m_styleProxy.StyleType == StyleType.kstCharacter &&
					m_styleProxy.Context != ContextValues.EndMarker)
				{
					SetInCharacterStyle();
				}
			}
			else if (m_styleProxy.StyleType == StyleType.kstCharacter &&
				m_styleProxy.Function != FunctionValues.Verse)
			{
				SetInCharacterStyle();
			}

			// Add a line break between section head segments if we're processing
			// interleaved back translation section heading segments.
			if (m_fInSectionHeading && strbldr.Length > 0 &&
				ProcessingParagraphStart && m_importDomain == ImportDomain.Main)
			{
				AddTextToPara(kHardLineBreak, ttpBtSeg, strbldr);
			}

			AddTextToPara(m_sSegmentText, ttpBtSeg, strbldr);
		}
コード例 #11
0
ファイル: ScrFootnote.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Deletes the given footnote and recalculates the footnote markers of following
		/// footnotes. (Note: this does not delete the footnote marker from the text.)
		/// </summary>
		/// <param name="footnote"></param>
		/// ------------------------------------------------------------------------------------
		public static void DeleteFootnote(StFootnote footnote)
		{
			ScrBook book = new ScrBook(footnote.Cache, footnote.OwnerHVO);
			book.RemoveFootnote(footnote);
		}
コード例 #12
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Setup the selection in footnote.
		/// </summary>
		/// <param name="footnote">The footnote.</param>
		/// <param name="book">The book.</param>
		/// <param name="iBook">The 0-based index of the book.</param>
		/// <param name="ichStart">The 0-based starting character index.</param>
		/// <param name="ichEnd">The 0-based ending character index.</param>
		/// ------------------------------------------------------------------------------------
		public void SetupSelectionInFootnote(StFootnote footnote, IScrBook book,
			int iBook, int ichStart, int ichEnd)
		{
			CheckDisposed();

			DynamicMock fakeSelHelper = new DynamicMock(typeof(SelectionHelper));
			fakeSelHelper.SetupResult("NumberOfLevels", 3);
			// Setup the anchor
			SelLevInfo[] topInfo = new SelLevInfo[3];
			StTxtPara para = (StTxtPara)footnote.ParagraphsOS[0];
			topInfo[0].tag = (int)StText.StTextTags.kflidParagraphs;
			topInfo[0].ihvo = 0;	// only one para per footnote allowed
			topInfo[0].hvo = para.Hvo;

			topInfo[1].tag = (int)ScrBook.ScrBookTags.kflidFootnotes;
			topInfo[1].ihvo = footnote.IndexInOwner;
			topInfo[1].hvo = footnote.Hvo;

			topInfo[2].tag = BookFilter.Tag;
			topInfo[2].ihvo = iBook;
			topInfo[2].hvo = book.Hvo;

			// Setup the end
			SelLevInfo[] bottomInfo = new SelLevInfo[3];
			for(int i = 0; i < 3; i++)
				bottomInfo[i] = topInfo[i];

			fakeSelHelper.SetupResult("LevelInfo", topInfo);
			fakeSelHelper.SetupResult("IchAnchor", ichStart);
			fakeSelHelper.SetupResult("IchEnd", ichEnd);
			fakeSelHelper.SetupResultForParams("GetLevelInfo", topInfo,
				SelectionHelper.SelLimitType.Top);
			fakeSelHelper.SetupResultForParams("GetLevelInfo", topInfo,
				SelectionHelper.SelLimitType.Anchor);
			fakeSelHelper.SetupResultForParams("GetLevelInfo", bottomInfo,
				SelectionHelper.SelLimitType.Bottom);
			fakeSelHelper.SetupResultForParams("GetLevelInfo", bottomInfo,
				SelectionHelper.SelLimitType.End);
			fakeSelHelper.SetupResultForParams("GetIch", ichStart,
				SelectionHelper.SelLimitType.Top);
			fakeSelHelper.SetupResultForParams("GetIch", ichEnd,
				SelectionHelper.SelLimitType.Bottom);
			m_viewSelection = (SelectionHelper)fakeSelHelper.MockInstance;
		}
コード例 #13
0
ファイル: InMemoryFdoCache.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Add a mindless footnote (i.e., it's marker, paragraph style, etc. won't be set)
		/// to a paragraph.
		/// </summary>
		/// <param name="footnoteSequence">Sequence of footnotes into which to insert</param>
		/// <param name="para">the paragraph into which to insert the footnote ORC</param>
		/// <param name="ichPos">the zero-based character offset at which to insert the footnote
		/// ORC into the paragraph</param>
		/// <param name="footnoteText">text for the footnote (no footnote paragraph created if
		/// null)</param>
		/// <returns>the new footnote</returns>
		/// ------------------------------------------------------------------------------------
		public StFootnote AddFootnote(FdoOwningSequence<IStFootnote> footnoteSequence,
			IStTxtPara para, int ichPos, string footnoteText)
		{
			CheckDisposed();
			// Create the footnote
			StFootnote footnote = new StFootnote();
			footnoteSequence.Append(footnote);

			// Update the paragraph contents to include the footnote marker ORC
			ITsStrBldr tsStrBldr = para.Contents.UnderlyingTsString.GetBldr();
			footnote.InsertOwningORCIntoPara(tsStrBldr, ichPos, m_fdoCache.DefaultVernWs);
			para.Contents.UnderlyingTsString = tsStrBldr.GetString();

			if (footnoteText != null)
			{
				// Create the footnote paragraph with the given footnoteText
				StTxtParaBldr paraBldr = new StTxtParaBldr(m_fdoCache);
				paraBldr.ParaProps = StyleUtils.ParaStyleTextProps("Note General Paragraph");
				paraBldr.AppendRun(footnoteText, StyleUtils.CharStyleTextProps(null, m_fdoCache.DefaultVernWs));
				paraBldr.CreateParagraph(footnote.Hvo);
			}

			return footnote;
		}
コード例 #14
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Show the footnote view.
		/// </summary>
		/// <param name="footnote">Footnote to scroll to or null to just display the footnote view</param>
		/// <param name="fPutInsertionPtAtEnd">if set to <c>true</c> and showing the view,
		/// the insertion point will be put at the end of the footnote text instead of at the
		/// beginning, as would be appropriate in the case of a newly inserted footnote that has
		/// Reference Text. This parameter is ignored if footnote is null.</param>
		/// ------------------------------------------------------------------------------------
		internal override void ShowOrHideFootnoteView(StFootnote footnote, bool fPutInsertionPtAtEnd)
		{
			CheckDisposed();

			bool fBtActivated = IsBtActivated;

			if (!FootnoteViewShowing)
			{
				base.ShowOrHideFootnoteView(footnote, fPutInsertionPtAtEnd);
			}
			else if (footnote != null)
			{
				FootnoteView footnoteView = (FootnoteView)GetControl(kFootnoteRow,
					fBtActivated ? kBackTransColumn : kDraftViewColumn);
				footnoteView.ScrollToFootnote(footnote, fPutInsertionPtAtEnd);
			}

			SetFocus(fBtActivated);
		}
コード例 #15
0
ファイル: StVc.cs プロジェクト: sillsdev/WorldPad
		/// -----------------------------------------------------------------------------------
		/// <summary>
		/// This is the main interesting method of displaying objects and fragments of them.
		/// Here a text is displayed by displaying its paragraphs;
		/// and a paragraph is displayed by invoking its style rule, making a paragraph,
		/// and displaying its contents.
		/// </summary>
		/// <param name="vwenv">view environment</param>
		/// <param name="hvo">id of object to be displayed</param>
		/// <param name="frag">fragment of data</param>
		/// -----------------------------------------------------------------------------------
		public override void Display(IVwEnv vwenv, int hvo, int frag)
		{
			CheckDisposed();

			switch(frag)
			{
				case (int)StTextFrags.kfrFootnote:
				{
					if (HandleEmptyText(vwenv, hvo))
						break;
					vwenv.AddObjVecItems((int)StText.StTextTags.kflidParagraphs, this,
						(int)StTextFrags.kfrFootnotePara);
					break;
				}

				case (int)StTextFrags.kfrText:
				{
					if (HandleEmptyText(vwenv, hvo))
						break;
					if (m_fLazy)
					{
						vwenv.AddLazyVecItems((int)StText.StTextTags.kflidParagraphs, this,
							(int)StTextFrags.kfrPara);
					}
					else
					{
						vwenv.AddObjVecItems((int)StText.StTextTags.kflidParagraphs, this,
							(int)StTextFrags.kfrPara);
					}
					break;
				}
				case (int)StTextFrags.kfrFootnoteMarker:
				{
					StFootnote footnote = new StFootnote(Cache, hvo);
					if (footnote.DisplayFootnoteMarker)
						DisplayFootnoteMarker(vwenv);
					break;
				}
				case (int)StTextFrags.kfrLabel:
				{
					// The label is not editable.
					vwenv.set_IntProperty((int)FwTextPropType.ktptEditable,
						(int)FwTextPropVar.ktpvEnum,
						(int)TptEditable.ktptNotEditable);
					vwenv.AddString(m_tssLabel);
					break;
				}

				case (int)StTextFrags.kfrPara:
				case (int)StTextFrags.kfrFootnotePara:
				{
					InsertParagraphBody(vwenv, hvo, frag, true, ContentType, this);
					break;
				}

				case (int)StTextFrags.kfrTranslation:
				{
					vwenv.set_IntProperty((int)FwTextPropType.ktptEditable,
						(int)FwTextPropVar.ktpvEnum,
						Editable ? (int)TptEditable.ktptIsEditable
						: (int)TptEditable.ktptNotEditable);
					// Display the translation, or its user prompt
					if (!InsertTranslationUserPrompt(vwenv, hvo))
					{
						vwenv.AddStringAltMember((int)CmTranslation.CmTranslationTags.kflidTranslation,
							m_wsDefault, this);
					}
					break;
				}
				case (int)StTextFrags.kfrSegmentFreeTranslations:
					// Hvo is a CmBaseAnnotation of one segment of an StTxtPara.
					if (IsLabelSegment(hvo))
					{
						CmBaseAnnotation segment = (CmBaseAnnotation)CmBaseAnnotation.CreateFromDBObject(Cache, hvo, false);
						vwenv.AddString(GetBackTransLabelText(segment));
						vwenv.AddSimpleRect(ColorUtil.ConvertColorToBGR(this.BackColor), 1200, 0, 0); // a narrow space, font-neutral
					}
					else
					{
						vwenv.AddObjProp(StTxtPara.SegmentFreeTranslationFlid(Cache), this, (int)StTextFrags.kfrFreeTrans);
						vwenv.AddString(OneSpaceString);
					}
					break;
				case (int)StTextFrags.kfrFreeTrans:
					// Hvo is a CmIndirectAnnotation whose Contents are the free/back translation.
					vwenv.set_IntProperty((int)FwTextPropType.ktptBackColor, (int)FwTextPropVar.ktpvDefault,
						(int)ColorUtil.ConvertColorToBGR(SystemColors.Window));
					ITsString tssVal = vwenv.DataAccess.get_MultiStringAlt(hvo,
						(int) CmAnnotation.CmAnnotationTags.kflidComment, BackTranslationWS);
					if (tssVal.Length == 0 && !SuppressPrompt(hvo, (int)CmAnnotation.CmAnnotationTags.kflidComment))
					{
						vwenv.NoteDependency(new int[] {hvo}, new int[] {(int)CmAnnotation.CmAnnotationTags.kflidComment}, 1);
						vwenv.AddProp(SimpleRootSite.kTagUserPrompt, this, (int)CmAnnotation.CmAnnotationTags.kflidComment);
						// Almost invisibly narrow, but the Views code doesn't know it is invisible so it should prevent the prompts collapsing
						// into the margin.
						vwenv.AddSimpleRect(ColorUtil.ConvertColorToBGR(this.BackColor), 100, 0, 0);
					}
					else
					{
						ITsStrBldr bldr = tssVal.GetBldr();
						bldr.Replace(0, bldr.Length, "", null); // reduce to empty string in ws.
						// We want it to change back to the prompt if all is deleted.
						vwenv.NoteStringValDependency(hvo, (int) CmAnnotation.CmAnnotationTags.kflidComment, BackTranslationWS, bldr.GetString());
						vwenv.AddStringAltMember((int)CmAnnotation.CmAnnotationTags.kflidComment, BackTranslationWS, this);
						// This little separator is useful here, too. Temporarily the comment may be displayed this way even when empty,
						// and if there is ordinary text following, it is difficult to get an IP displayed in an empty run.
						vwenv.AddSimpleRect(ColorUtil.ConvertColorToBGR(this.BackColor), 100, 0, 0);
					}
					break;
			}
		}
コード例 #16
0
ファイル: DraftViewWrapper.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Show (or hide) the footnote view.
		/// </summary>
		/// <param name="footnote">Footnote to scroll to or <c>null</c> to just display or hide
		/// the footnote view. If a footnote is given the footnote view will always be shown.
		/// </param>
		/// <param name="fPutInsertionPtAtEnd">if set to <c>true</c> and showing the view,
		/// the insertion point will be put at the end of the footnote text instead of at the
		/// beginning, as would be appropriate in the case of a newly inserted footnote that has
		/// Reference Text. This parameter is ignored if footnote is null.</param>
		/// ------------------------------------------------------------------------------------
		internal override void ShowOrHideFootnoteView(StFootnote footnote, bool fPutInsertionPtAtEnd)
		{
			CheckDisposed();

			//toggle
			bool fShow = !m_grid.Rows[kFootnoteRow].Visible || footnote != null;

			base.ShowOrHideFootnoteView(footnote, fPutInsertionPtAtEnd);

			if (fShow)
			{
				// We don't want to show both draft view rows together with the footnotes
				m_fBothDraftViewsShowing = (m_grid.Rows[kUpperDraftRow].Visible &&
					m_grid.Rows[kLowerDraftRow].Visible);

				// Determine which of the draft view to collapse (if both are open)
				if (m_fBothDraftViewsShowing)
				{
					if (FocusedRootSite == GetControl(kUpperDraftRow, kDraftViewColumn))
						m_grid.Rows[kLowerDraftRow].Visible = false;
					else
						m_grid.Rows[kUpperDraftRow].Visible = false;
				}
			}
		}
コード例 #17
0
ファイル: StFootnote.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Constructor for the FootnoteInfo structure
		/// </summary>
		/// <param name="stFootnote">given footnote</param>
		/// <param name="sParaStylename">paragraph style of the footnote</param>
		/// ------------------------------------------------------------------------------------
		public FootnoteInfo(StFootnote stFootnote, string sParaStylename)
		{
			footnote = stFootnote;
			paraStylename = sParaStylename;
		}
コード例 #18
0
ファイル: ScrFootnote.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Creates the ScrFootnote in the given owning ScrBook.
		/// The caller must take care of inserting the proper ORC and the footnote's paragraph.
		/// </summary>
		/// <param name="book">The book that the footnote is being added to</param>
		/// <param name="iInsertAt">Zero-based index of the position in the book's sequence of
		/// footnotes where the new footnote is to be inserted</param>
		/// <param name="sMarker">ref: The marker to use (more or less)</param>
		/// <param name="cache">The cache.</param>
		/// <param name="ws">The writing system for the footnote marker.</param>
		/// <returns>The newly created Footnote object</returns>
		/// ------------------------------------------------------------------------------------
		private static ScrFootnote CreateScrFootnote(IScrBook book, int iInsertAt, ref string sMarker,
			FdoCache cache, int ws)
		{
			// Create StFootnote object and establish it in the database
			StFootnote foot = new StFootnote();
			book.FootnotesOS.InsertAt(foot, iInsertAt);
			// Construct a ScrFootnote so that its internal variables will get set correctly
			ScrFootnote footnote = new ScrFootnote(cache, foot.Hvo);

			// Create a default FootnoteMarker property in the StFootnote with
			// the correct text properties
			ITsTextProps markerProps =
				StyleUtils.CharStyleTextProps(ScrStyleNames.FootnoteMarker, ws);
			ITsStrBldr tsStrBldrFootnoteMkr = TsStrBldrClass.Create();

			// Mark the footnote marker style as being in use.
			IScripture scr = cache.LangProject.TranslatedScriptureOA;
			IStStyle markerStyle = scr.FindStyle(ScrStyleNames.FootnoteMarker);
			markerStyle.InUse = true;

			if (sMarker == null)
				sMarker = string.Empty;
			tsStrBldrFootnoteMkr.Replace(0, 0, sMarker, markerProps);
			footnote.FootnoteMarker = tsStrBldrFootnoteMkr.GetString();

			// Copy current value of default footnote options to the new footnote.
			footnote.DisplayFootnoteReference = scr.DisplayFootnoteReference;
			footnote.DisplayFootnoteMarker = scr.DisplayFootnoteMarker;
			return footnote;
		}
コード例 #19
0
ファイル: InMemoryFdoCache.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Add a back translation footnote in the given translation for the given footnote.
		/// Inserts a ref ORC in the translation and sets the the BT text in the footnote.
		/// </summary>
		/// <param name="trans">The given back translation of an StTxtPara</param>
		/// <param name="ichPos">The 0-based character offset into the back translation string
		/// at which we will insert the reference ORC</param>
		/// <param name="ws">writing system of the BT and ORC</param>
		/// <param name="footnote">The given footnote</param>
		/// <param name="footnoteBtText">text for the back translation of the footnote</param>
		/// <returns>the back translation of the given footnote</returns>
		/// ------------------------------------------------------------------------------------
		public ICmTranslation AddFootnoteORCtoTrans(ICmTranslation trans, int ichPos, int ws,
			StFootnote footnote, string footnoteBtText)
		// TODO: rename this method to AddBtFootnote(), so it reads similar to AddFootnote() in tests
		{
			CheckDisposed();
			AddFootnoteORCtoTrans(trans, ichPos, ws, footnote);

			// Add the given footnote BT text to the footnote.
			IStTxtPara para = (IStTxtPara)footnote.ParagraphsOS[0];
			ICmTranslation footnoteTrans = para.GetOrCreateBT();
			ITsStrBldr tssFootnoteBldr = footnoteTrans.Translation.GetAlternative(ws).UnderlyingTsString.GetBldr();
			tssFootnoteBldr.ReplaceRgch(0, 0, footnoteBtText, footnoteBtText.Length,
				StyleUtils.CharStyleTextProps(null, ws));
			footnoteTrans.Translation.SetAlternative(tssFootnoteBldr.GetString(), ws);
			return footnoteTrans;
		}
コード例 #20
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Creates a book with two footnotes.
		/// </summary>
		/// <param name="philemon">The book of philemon that will have one paragraph with two
		/// footnotes.</param>
		/// <param name="footnote1">first footnote to be inserted at character index 1</param>
		/// <param name="footnote2">second footnote to be inserted at character index 10</param>
		/// ------------------------------------------------------------------------------------
		private void CreateBookWithTwoFootnotes(out IScrBook philemon,
			out StFootnote footnote1, out StFootnote footnote2)
		{
			philemon = m_scrInMemoryCache.AddBookToMockedScripture(57, "Philemon");
			IScrSection section = m_scrInMemoryCache.AddSectionToMockedBook(philemon.Hvo);
			StTxtPara para = m_scrInMemoryCache.AddParaToMockedSectionContent(section.Hvo, ScrStyleNames.NormalParagraph);
			m_scrInMemoryCache.AddRunToMockedPara(para, "this is more text", null);
			footnote1 = m_scrInMemoryCache.AddFootnote(philemon, para, 1);
			StTxtPara footnotePara = new StTxtPara();
			footnote1.ParagraphsOS.Append(footnotePara);
			footnotePara.Contents.Text = "This is my first footnote";
			footnote2 = m_scrInMemoryCache.AddFootnote(philemon, para, 10);
			footnotePara = new StTxtPara();
			footnote2.ParagraphsOS.Append(footnotePara);
			footnotePara.Contents.Text = "This is my second footnote";
		}
コード例 #21
0
		public void ApplyParaStyle()
		{
			CheckDisposed();

			m_footnoteView.EditingHelper.ApplyStyle(ScrStyleNames.NormalFootnoteParagraph);
			int tag;
			int hvoSimple;
			bool fGotIt = m_footnoteView.GetSelectedFootnote(out tag, out hvoSimple);
			Assert.IsTrue(fGotIt);
			Assert.AreEqual((int)StText.StTextTags.kflidParagraphs, tag);
			StFootnote footnote = new StFootnote(Cache, hvoSimple);
			StTxtPara para = (StTxtPara)footnote.ParagraphsOS[0];
			Assert.AreEqual(ScrStyleNames.NormalFootnoteParagraph,
				para.StyleRules.GetStrPropValue((int)FwTextPropType.ktptNamedStyle));
		}
コード例 #22
0
ファイル: TeEditingHelper.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Apply style to selection
		/// </summary>
		/// ------------------------------------------------------------------------------------
		public override void ApplyStyle(string sStyleToApply)
		{
			CheckDisposed();

			// Make sure that the Chapter Number style is not applied to non-numeric data
			if (sStyleToApply == ScrStyleNames.ChapterNumber && CurrentSelection != null)
			{
				ITsString tssSelected;
				CurrentSelection.Selection.GetSelectionString(out tssSelected, string.Empty);
				if (tssSelected.Text != null)
				{
					foreach (char ch in tssSelected.Text)
					{
						if (!Char.IsDigit(ch))
						{
							MiscUtils.ErrorBeep();
							return;
						}
					}
				}
			}
			base.ApplyStyle(sStyleToApply);

			// Update the footnote markers if we changed the style of a footnote
			if ((sStyleToApply == ScrStyleNames.CrossRefFootnoteParagraph ||
				sStyleToApply == ScrStyleNames.NormalFootnoteParagraph) &&
				ParagraphHvo > 0)
			{
				// Save the selection
				SelectionHelper prevSelection = CurrentSelection;

				if (m_cache.MarkerIndexCache != null)
					m_cache.MarkerIndexCache.ClearCache();
				StTxtPara para = new StTxtPara(m_cache, ParagraphHvo);
				Debug.Assert(m_cache.GetClassOfObject(para.OwnerHVO) == StFootnote.kClassId);

				StFootnote footnote = new StFootnote(m_cache, para.OwnerHVO);
				ScrBook book = new ScrBook(m_cache, footnote.OwnerHVO);

				m_cache.PropChanged(null, PropChangeType.kpctNotifyAll,
					book.Hvo, (int)ScrBook.ScrBookTags.kflidFootnotes, 0,
					book.FootnotesOS.Count, book.FootnotesOS.Count);

				// restore the selection
				prevSelection.SetSelection(true);
			}
		}
コード例 #23
0
ファイル: StTxtPara.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Gets a List of all footnotes "owned" by this paragraph.
		/// </summary>
		/// ------------------------------------------------------------------------------------
		public List<FootnoteInfo> GetFootnotes()
		{
			ITsString contents = Contents.UnderlyingTsString;
			List<FootnoteInfo> footnotes = new List<FootnoteInfo>();

			for (int iRun = 0; iRun < contents.RunCount; iRun++)
			{
				Guid guidOfObj = StringUtils.GetGuidFromRun(contents, iRun,
					FwObjDataTypes.kodtOwnNameGuidHot);
				if (guidOfObj != Guid.Empty)
				{
					try
					{
						int hvo = m_cache.GetIdFromGuid(guidOfObj);
						if (hvo > 0)
						{
							StFootnote footnote = new StFootnote(m_cache, hvo);
							footnotes.Add(new FootnoteInfo(footnote));
						}
					}
					catch
					{
					}
				}
			}

			return footnotes;
		}
コード例 #24
0
ファイル: TeImport.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Finalize the BT of the footnote, if any.
		/// </summary>
		/// ------------------------------------------------------------------------------------
		protected void EndBTFootnote()
		{
			Debug.Assert(m_fInFootnote);
			Debug.Assert(m_BTFootnoteStrBldr != null);
			ITsStrBldr strbldr = m_BTStrBldrs[m_wsCurrBtPara];
			// No need to assert, since the dictionary will
			// throw an exception if the key is not present.
			//Debug.Assert(strbldr != null);
			TrimTrailingSpace(m_BTFootnoteStrBldr);
			// If the last character in the paragraph is a separator, then insert the footnote
			// marker before it. (see TE-2431)
			int ichMarker = strbldr.Length;
			if (ichMarker > 0)
			{
				string s = strbldr.GetChars(ichMarker - 1, ichMarker);
				if (UnicodeCharProps.get_IsSeparator(s[0]))
					ichMarker--;
			}
			if (m_CurrBTFootnote != null)
			{
				// Don't support importing multi-para footnotes
				StTxtPara para = (StTxtPara)m_CurrBTFootnote.ParagraphsOS[0];

				ICmTranslation transl = para.GetOrCreateBT();
				transl.Translation.GetAlternative(m_wsCurrBtPara).UnderlyingTsString =
					(m_BTFootnoteStrBldr.Length == 0) ?
					m_TsStringFactory.MakeString(string.Empty, m_wsCurrBtPara) :
					m_BTFootnoteStrBldr.GetString();
				m_CurrBTFootnote.InsertRefORCIntoTrans(strbldr, ichMarker, m_wsCurrBtPara);
				m_CurrBTFootnote = null;
			}
			else
			{
				m_BtFootnoteStrBldrs.Add(new BtFootnoteBldrInfo(m_wsCurrBtPara, m_BTFootnoteStrBldr,
					m_sBtFootnoteParaStyle, ichMarker, m_currentRef));
			}
			m_fInFootnote = false;
			m_BTFootnoteStrBldr = null;
			//m_BtFootnoteStrBldrs.Clear();
			//m_currDomain = MarkerDomain.Default; // TODO: Do like EndFootnote
			if ((m_styleProxy.Domain & MarkerDomain.Footnote) == 0)
				m_currDomain &= ~MarkerDomain.Footnote;
		}
コード例 #25
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Gets the displayed text for a footnote.
		/// </summary>
		/// <param name="iBook">Index of the book the footnote is in</param>
		/// <param name="iFootnote">Index of the footnote</param>
		/// <param name="footnote">The footnote object</param>
		/// <returns>The TsString representing the text of the footnote, including any displayed
		/// marker, reference, etc.</returns>
		/// ------------------------------------------------------------------------------------
		public ITsString GetDisplayedTextForFootnote(int iBook, int iFootnote,
			StFootnote footnote)
		{
			SelectionHelper helper = new SelectionHelper();

			// Create selection in footnote marker
			SelLevInfo[] anchorLevInfo = new SelLevInfo[4];
			anchorLevInfo[3].tag = BookFilter.Tag;
			anchorLevInfo[3].ihvo = iBook;
			anchorLevInfo[2].tag = (int)ScrBook.ScrBookTags.kflidFootnotes;
			anchorLevInfo[2].ihvo = iFootnote;
			anchorLevInfo[1].tag = (int)StText.StTextTags.kflidParagraphs;
			anchorLevInfo[1].ihvo = 0;
			anchorLevInfo[0].tag = -1;
			anchorLevInfo[0].ihvo = 0;
			helper.SetLevelInfo(SelectionHelper.SelLimitType.Anchor, anchorLevInfo);
			helper.SetTextPropId(SelectionHelper.SelLimitType.Anchor,
				(int)VwSpecialAttrTags.ktagGapInAttrs);
			helper.IchAnchor = 0;

			SelLevInfo[] endLevInfo = new SelLevInfo[3];
			endLevInfo[2].tag = BookFilter.Tag;
			endLevInfo[2].ihvo = iBook;
			endLevInfo[1].tag = (int)ScrBook.ScrBookTags.kflidFootnotes;
			endLevInfo[1].ihvo = iFootnote;
			endLevInfo[0].tag = (int)StText.StTextTags.kflidParagraphs;
			endLevInfo[0].ihvo = 0;
			helper.SetLevelInfo(SelectionHelper.SelLimitType.End, endLevInfo);
			helper.SetTextPropId(SelectionHelper.SelLimitType.End,
				(int)StTxtPara.StTxtParaTags.kflidContents);
			string footnoteText = ((StTxtPara)footnote.ParagraphsOS[0]).Contents.Text;
			helper.IchEnd = footnoteText.Length;

			helper.SetSelection(this, true, true);

			IVwSelection sel = RootBox.Selection;
			ITsString tss;
			sel.GetSelectionString(out tss, string.Empty);
			return tss;
		}
コード例 #26
0
ファイル: TeImport.cs プロジェクト: sillsdev/WorldPad
		/// <summary>
		/// Executes in two distinct scenarios.
		///
		/// 1. If disposing is true, the method has been called directly
		/// or indirectly by a user's code via the Dispose method.
		/// Both managed and unmanaged resources can be disposed.
		///
		/// 2. If disposing is false, the method has been called by the
		/// runtime from inside the finalizer and you should not reference (access)
		/// other managed objects, as they already have been garbage collected.
		/// Only unmanaged resources can be disposed.
		/// </summary>
		/// <param name="disposing"></param>
		/// <remarks>
		/// If any exceptions are thrown, that is fine.
		/// If the method is being done in a finalizer, it will be ignored.
		/// If it is thrown by client code calling Dispose,
		/// it needs to be handled by fixing the bug.
		///
		/// If subclasses override this method, they should call the base implementation.
		/// </remarks>
		protected virtual void Dispose(bool disposing)
		{
			//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
			// Must not be run more than once.
			if (m_isDisposed)
				return;

			if (disposing)
			{
				// Dispose managed resources here.
				if (m_ParaBldr != null)
					m_ParaBldr.Dispose();
			}

			// Dispose unmanaged resources here, whether disposing is true or false.
			m_ParaBldr = null;
			m_cache = null;
			m_styleSheet = null;
			m_scr = null;
			m_undoManager = null;
			m_importCallbacks = null;
			m_ScrSectionHeadParaProxy = null;
			m_DefaultIntroSectionHeadParaProxy = null;
			m_DefaultScrParaProxy = null;
			m_DefaultIntroParaProxy = null;
			m_BTStrBldrs = null;
			m_SavedParaBldr = null;
			m_CurrFootnote = null;
			m_ttpChapterNumber = null;
			m_sPrevBook = null;
			m_scrBook = null;
			m_currSection = null;

			m_isDisposed = true;
		}
コード例 #27
0
ファイル: FdoTestBase.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Create a footnote reference marker (ref orc)
		/// </summary>
		/// <param name="footnote">given footnote</param>
		/// <param name="para">paragraph owning the translation to insert footnote marker into</param>
		/// <param name="ws">given writing system for the back translation</param>
		/// <param name="ichPos">The 0-based character offset into the translation</param>
		/// ------------------------------------------------------------------------------------
		protected void InsertTestBtFootnote(StFootnote footnote, StTxtPara para, int ws, int ichPos)
		{
			ICmTranslation trans = para.GetOrCreateBT();
			ITsStrBldr bldr = trans.Translation.GetAlternative(ws).UnderlyingTsString.GetBldr();
			footnote.InsertRefORCIntoTrans(bldr, ichPos, ws);
			trans.Translation.SetAlternative(bldr.GetString(), ws);
		}
コード例 #28
0
ファイル: DiffTestHelper.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// A helper method for book merger tests-
		/// Verifies the contents of the given difference
		/// for a one-sided subDiff representing a footnote in the Revision.
		/// </summary>
		/// ------------------------------------------------------------------------------------
		public static void VerifySubDiffFootnoteRev(Difference rootDiff, int iSubDiff,
			StFootnote footnoteRev)
		{
			Difference subDiff = rootDiff.SubDiffsForORCs[iSubDiff];
			// verify the basics
			Assert.AreEqual(0, subDiff.RefStart);
			Assert.AreEqual(0, subDiff.RefEnd);
			Assert.AreEqual(DifferenceType.NoDifference, subDiff.DiffType);

			// the Current para stuff
			Assert.AreEqual(0, subDiff.HvoCurr);
			Assert.AreEqual(0, subDiff.IchMinCurr);
			Assert.AreEqual(0, subDiff.IchLimCurr);

			// the Revision para stuff
			Assert.AreEqual(((StTxtPara)footnoteRev.ParagraphsOS[0]).Hvo, subDiff.HvoRev);
			Assert.AreEqual(0, subDiff.IchMinRev);
			Assert.AreEqual(((StTxtPara)footnoteRev.ParagraphsOS[0]).Contents.Length, subDiff.IchLimRev);

			// style names should be null
			Assert.IsNull(subDiff.StyleNameCurr);
			Assert.IsNull(subDiff.StyleNameRev);

			// section stuff should be null
			Assert.IsNull(subDiff.HvosSectionsRev);
			Assert.IsNull(subDiff.HvosSectionsCurr);

			// subDiffs may not have subDiffs, so far
			Assert.IsNull(subDiff.SubDiffsForORCs);

			//check the root difference for consistency with this subDiff
			Assert.IsTrue(rootDiff.DiffType == DifferenceType.TextDifference ||
				rootDiff.DiffType == DifferenceType.FootnoteMissingInCurrent);
		}
コード例 #29
0
ファイル: DiffFootnoteView.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Scrolls a footnote paragraph into view.
		/// </summary>
		/// <param name="diff">The sub-diff, which contains the id of the paragraph in the
		/// footnote which is to be scrolled into view. Or null if no footnote is specified.</param>
		/// ------------------------------------------------------------------------------------
		public void ScrollToFootnotePara(Difference diff)
		{
			CheckDisposed();

// TODO:  TE-4610 temporary? ignore scrolling when no footnote in this diff
			//Debug.Assert(diff != null);
			if (diff == null)
				return;

			// Get the paragraph which contains the difference.
			StTxtPara para = new StTxtPara(Cache, diff.HvoCurr != 0 ? diff.HvoCurr : diff.HvoRev);

			// Get the footnote which contains the paragraph.
			StFootnote footnote = new StFootnote(Cache, para.OwnerHVO);

			// Find the index of the paragraph.
			int iPara = para.IndexInOwner;
			if (iPara < 0)
				return;

			// Find index of the footnote.
			int iFootnote = footnote.IndexInOwner;
			if (iFootnote < 0)
				return;

			// Create selection pointing to this footnote.
			SelectionHelper selHelper = new SelectionHelper();
			selHelper.AssocPrev = false;
			selHelper.NumberOfLevels = 2;
			selHelper.LevelInfo[0].tag = (int)StText.StTextTags.kflidParagraphs;
			selHelper.LevelInfo[0].ihvo = iPara;
			selHelper.LevelInfo[1].tag = (int)ScrBook.ScrBookTags.kflidFootnotes;
			selHelper.LevelInfo[1].ihvo = iFootnote;
			// note: We don't care about seting the ich stuff for this temporary selection.
			// (The view constructor takes care of highlighting the proper ich range.)
			// Our mission here is only to scroll to the paragraph.
			selHelper.IchAnchor = 0;
			selHelper.IchEnd = 0;

			// Set the selection.
			selHelper.SetSelection(this, true, true);
			ScrollSelectionIntoView(null, VwScrollSelOpts.kssoNearTop);
		}
コード例 #30
0
ファイル: StFootnoteTests.cs プロジェクト: sillsdev/WorldPad
		/// <summary>
		/// Executes in two distinct scenarios.
		///
		/// 1. If disposing is true, the method has been called directly
		/// or indirectly by a user's code via the Dispose method.
		/// Both managed and unmanaged resources can be disposed.
		///
		/// 2. If disposing is false, the method has been called by the
		/// runtime from inside the finalizer and you should not reference (access)
		/// other managed objects, as they already have been garbage collected.
		/// Only unmanaged resources can be disposed.
		/// </summary>
		/// <param name="disposing"></param>
		/// <remarks>
		/// If any exceptions are thrown, that is fine.
		/// If the method is being done in a finalizer, it will be ignored.
		/// If it is thrown by client code calling Dispose,
		/// it needs to be handled by fixing the bug.
		///
		/// If subclasses override this method, they should call the base implementation.
		/// </remarks>
		protected override void Dispose(bool disposing)
		{
			//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
			// Must not be run more than once.
			if (IsDisposed)
				return;

			if (disposing)
			{
				// Dispose managed resources here.
			}

			// Dispose unmanaged resources here, whether disposing is true or false.
			m_footnote = null;;
			m_book = null;
			if (m_strFact != null)
				Marshal.ReleaseComObject(m_strFact);
			m_strFact = null;;

			base.Dispose(disposing);
		}
コード例 #31
0
ファイル: ScrFootnote.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Starts recalculation of footnotes for a book at the given footnote.
		/// </summary>
		/// <param name="footnote">footnote to where recalculation starts</param>
		/// ------------------------------------------------------------------------------------
		public static void RecalculateFootnoteMarkers(StFootnote footnote)
		{
			int index = footnote.IndexInOwner;
			Debug.Assert(index >= 0);
			RecalculateFootnoteMarkers(new ScrBook(footnote.Cache, footnote.OwnerHVO), index);
		}
コード例 #32
0
ファイル: StFootnoteTests.cs プロジェクト: sillsdev/WorldPad
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Compares the given footnote with the values in m_footnote.
		/// </summary>
		/// <param name="footnote">The footnote to compare</param>
		/// ------------------------------------------------------------------------------------
		private void CompareFootnote(StFootnote footnote)
		{
			Assert.AreEqual(m_footnote.DisplayFootnoteMarker, footnote.DisplayFootnoteMarker,
				"Display footnote marker values did not match");
			Assert.AreEqual(m_footnote.DisplayFootnoteReference, footnote.DisplayFootnoteReference,
				"Display footnote reference values did not match");
			Assert.AreEqual(m_footnote.FootnoteMarker.Text, footnote.FootnoteMarker.Text);
			Assert.AreEqual(m_footnote.ParagraphsOS.Count, footnote.ParagraphsOS.Count,
				"Footnote paragraph count did not match");

			string diff = string.Empty;
			for (int i = 0; i < m_footnote.ParagraphsOS.Count; i++)
			{
				StTxtPara expectedPara = (StTxtPara)m_footnote.ParagraphsOS[i];
				StTxtPara actualPara = (StTxtPara)footnote.ParagraphsOS[i];
				bool result = TsTextPropsHelper.PropsAreEqual(expectedPara.StyleRules,
					actualPara.StyleRules, out diff);
				Assert.IsTrue(result, "paragraph " + i + " stylerules differed in: " + diff);

				result = TsStringHelper.TsStringsAreEqual(expectedPara.Contents.UnderlyingTsString,
					actualPara.Contents.UnderlyingTsString,	out diff);
				Assert.IsTrue(result, "paragraph " + i + " differed in: " + diff);

				CompareFootnoteTrans((CmTranslation)expectedPara.GetBT(), (CmTranslation)actualPara.GetBT(),
					actualPara.Hvo);
			}
		}
コード例 #33
0
        /// ------------------------------------------------------------------------------------
        /// <summary>
        /// Creates a new StFootnote owned by the given book created from the given string
        /// representation (Created from GetTextRepresentation())
        /// </summary>
        /// <param name="owner">The object that owns the sequence of footnotes into which the
        /// new footnote is to be inserted</param>
        /// <param name="flid">The field id of the property in which the footnotes are owned
        /// </param>
        /// <param name="sTextRepOfFootnote">The given string representation of a footnote
        /// </param>
        /// <param name="footnoteIndex">0-based index where the footnote will be inserted</param>
        /// <param name="footnoteMarkerStyleName">style name for footnote markers</param>
        /// <returns>An StFootnote with the properties set to the properties in the
        /// given string representation</returns>
        /// ------------------------------------------------------------------------------------
        public static StFootnote CreateFromStringRep(CmObject owner, int flid,
                                                     string sTextRepOfFootnote, int footnoteIndex, string footnoteMarkerStyleName)
        {
            StFootnote createdFootnote = new StFootnote(owner, flid, footnoteIndex);

            // create an XML reader to read in the string representation
            System.IO.StringReader reader = new System.IO.StringReader(sTextRepOfFootnote);
            XmlDocument            doc    = new XmlDocument();

            try
            {
                doc.Load(reader);
            }
            catch (XmlException)
            {
                throw new ArgumentException("Unrecognized XML format for footnote.");
            }

            XmlNodeList tagList = doc.SelectNodes("FN");

            foreach (XmlNode bla in tagList[0].ChildNodes)
            {
                // Footnote marker
                if (bla.Name == "M")
                {
                    ITsPropsBldr propBlr = TsPropsBldrClass.Create();
                    propBlr.SetStrPropValue((int)FwTextPropType.ktptNamedStyle,
                                            footnoteMarkerStyleName);
                    ITsStrBldr tss = TsStrBldrClass.Create();
                    tss.Replace(0, 0, bla.InnerText, propBlr.GetTextProps());
                    createdFootnote.FootnoteMarker.UnderlyingTsString = tss.GetString();
                }

                // Display footnote marker
                else if (bla.Name == "ShowMarker")
                {
                    createdFootnote.DisplayFootnoteMarker = true;
                }
                // display footnote scripture reference
                else if (bla.Name == "ShowReference")
                {
                    createdFootnote.DisplayFootnoteReference = true;
                }
                // start of a paragraph
                else if (bla.Name == "P")
                {
                    StTxtPara newPara = new StTxtPara();
                    createdFootnote.ParagraphsOS.Append(newPara);
                    ITsIncStrBldr paraBldr = TsIncStrBldrClass.Create();
                    CmTranslation trans    = null;
                    //ITsStrBldr paraBldr = TsStrBldrClass.Create();
                    foreach (XmlNode paraTextNode in bla.ChildNodes)
                    {
                        if (paraTextNode.Name == "PS")
                        {
                            // paragraph style
                            ITsPropsBldr propBldr =
                                TsPropsBldrClass.Create();
                            if (!String.IsNullOrEmpty(paraTextNode.InnerText))
                            {
                                propBldr.SetStrPropValue((int)FwTextPropType.ktptNamedStyle,
                                                         paraTextNode.InnerText);
                            }
                            else
                            {
                                Debug.Fail("Attempting to create a footnote paragraph with no paragraph style specified!");
                            }
                            newPara.StyleRules = propBldr.GetTextProps();
                        }
                        else if (paraTextNode.Name == "RUN")
                        {
                            CreateRunFromStringRep(owner, paraBldr, paraTextNode);
                            paraBldr.Append(paraTextNode.InnerText);
                        }
                        else if (paraTextNode.Name == "TRANS")
                        {
                            if (trans == null)
                            {
                                trans = (CmTranslation)newPara.GetOrCreateBT();
                            }

                            // Determine which writing system where the string run(s) will be added.
                            string iculocale = paraTextNode.Attributes.GetNamedItem("WS").Value;
                            if (iculocale == null || iculocale == string.Empty)
                            {
                                throw new ArgumentException(
                                          "Unknown ICU locale encountered: " + iculocale);
                            }
                            int transWS = owner.Cache.LanguageEncodings.GetWsFromIcuLocale(iculocale);
                            Debug.Assert(transWS != 0, "Unable to find ws from ICU Locale");

                            // Build a TsString from the run(s) description.
                            ITsIncStrBldr strBldr = TsIncStrBldrClass.Create();
                            foreach (XmlNode transTextNode in paraTextNode.ChildNodes)
                            {
                                if (transTextNode.Name != "RUN")
                                {
                                    throw new ArgumentException("Unexpected translation element '" +
                                                                transTextNode.Name + "' encountered for ws '" + iculocale + "'");
                                }

                                CreateRunFromStringRep(owner, strBldr, transTextNode);
                                strBldr.Append(transTextNode.InnerText);
                            }

                            trans.Translation.SetAlternative(strBldr.GetString(), transWS);
                        }
                    }
                    newPara.Contents.UnderlyingTsString = paraBldr.GetString();
                }
            }
            owner.Cache.PropChanged(null, PropChangeType.kpctNotifyAll, owner.Hvo, flid, footnoteIndex, 1, 0);
            return(createdFootnote);
        }