public void BeginAndEndUndoTask()
{
CheckDisposed();
ShowForm();
// we need a selection
m_basicView.RootBox.MakeSimpleSel(true, true, false, true);
// this should begin an outer undo task, so we will have only one undoable task!
using (new UndoTaskHelper(m_basicView, "kstidUndoStyleChanges"))
{
m_fdoCache.BeginUndoTask("", "");
StStyle style = new StStyle();
m_fdoCache.LangProject.StylesOC.Add(style);
m_fdoCache.EndUndoTask();
m_fdoCache.BeginUndoTask("", "");
style = new StStyle();
m_fdoCache.LangProject.StylesOC.Add(style);
m_fdoCache.EndUndoTask();
}
int nUndoTasks = 0;
while (m_fdoCache.Undo())
{
nUndoTasks++;
}
Assert.AreEqual(1, nUndoTasks);
}
//[Ignore("Has problems with new restore database approach")]
public void Transactions()
{
CheckDisposed();
if (!m_fdoCache.DatabaseAccessor.IsTransactionOpen())
{
m_fdoCache.DatabaseAccessor.BeginTrans();
}
StStyle newStyle = new StStyle();
m_fdoCache.LangProject.StylesOC.Add(newStyle);
int newStyleHvo = newStyle.Hvo;
m_fdoCache.DatabaseAccessor.RollbackTrans();
// A simple rollback will not clear the object from the cache,
// so do it here.
m_fdoCache.VwCacheDaAccessor.ClearInfoAbout(newStyleHvo, VwClearInfoAction.kciaRemoveAllObjectInfo);
if (newStyle.IsValidObject())
{
// Should not get here, as the create call should throw the exception.
// Just in case, however, delete the new object.
newStyle.DeleteUnderlyingObject();
Assert.Fail("Object is still valid.");
}
}
public void SaveToDB_NewInfo()
{
IStStyle realStyle = new StStyle();
Cache.LangProject.StylesOC.Add(realStyle);
realStyle.Context = ContextValues.Intro;
realStyle.Function = FunctionValues.Table;
realStyle.Structure = StructureValues.Heading;
StyleInfo basedOn = new StyleInfo(realStyle);
StyleInfo testInfo = new StyleInfo("New Style", basedOn,
StyleType.kstParagraph, Cache);
// simulate a save to the DB for the test style.
IStStyle style = new StStyle();
Cache.LangProject.StylesOC.Add(style);
testInfo.SaveToDB(style, false);
Assert.AreEqual(ContextValues.Intro, testInfo.Context);
Assert.AreEqual(StructureValues.Heading, testInfo.Structure);
Assert.AreEqual(FunctionValues.Table, testInfo.Function);
Assert.AreEqual(ContextValues.Intro, style.Context);
Assert.AreEqual(StructureValues.Heading, style.Structure);
Assert.AreEqual(FunctionValues.Table, style.Function);
}
/// ------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// ------------------------------------------------------------------------------------
protected override void CreateTestData()
{
m_style = new StStyle();
Cache.LangProject.StylesOC.Add(m_style);
m_style.Name = "Section Head Major";
m_style.UserLevel = -1;
}
public void CreateAndLoadOwnedObject()
{
CheckDisposed();
StStyle style = new StStyle();
Cache.LangProject.StylesOC.Add(style);
Guid guid = Cache.GetGuidFromId(style.Hvo);
Assert.IsTrue(guid != Guid.Empty);
}
public void SetGetSingleUnicode()
{
CheckDisposed();
StStyle st = new StStyle();
Cache.LangProject.StylesOC.Add(st);
string s = "NewName" + m_rand.Next().ToString();
st.Name = s;
Assert.AreEqual(s, st.Name);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Given a Scripture section, this method returns the index of the paragraph containing
/// the requested verse and the position of the character immediately following the
/// verse number in that paragraph. If an exact match isn't found, the closest
/// approximate place is found.
/// </summary>
/// <param name="section">The section whose paragraphs will be searched</param>
/// <param name="targetRef">The reference being sought</param>
/// <param name="ihvoPara"></param>
/// <param name="ichPosition"></param>
/// <remarks>Currently, this does NOT attempt to find a close match, but some day it
/// should</remarks>
/// ------------------------------------------------------------------------------------
protected void FindVerseNumber(ScrSection section, ScrReference targetRef,
out int ihvoPara, out int ichPosition)
{
ihvoPara = 0;
ichPosition = 0;
bool fChapterFound = ((ScrReference)section.VerseRefStart).Chapter == targetRef.Chapter;
foreach (StTxtPara para in section.ContentOA.ParagraphsOS)
{
TsStringAccessor contents = para.Contents;
TsRunInfo tsi;
ITsTextProps ttpRun;
int ich = 0;
while (ich < contents.Text.Length)
{
// Get props of current run.
ttpRun = contents.UnderlyingTsString.FetchRunInfoAt(ich, out tsi);
// See if it is our verse number style.
if (fChapterFound)
{
if (StStyle.IsStyle(ttpRun, ScrStyleNames.VerseNumber))
{
// The whole run is the verse number. Extract it.
string sVerseNum = contents.Text.Substring(tsi.ichMin,
tsi.ichLim - tsi.ichMin);
int startVerse, endVerse;
ScrReference.VerseToInt(sVerseNum, out startVerse, out endVerse);
if (targetRef.Verse >= startVerse && targetRef.Verse <= endVerse)
{
ihvoPara = para.OwnOrd - 1;
ichPosition = tsi.ichLim;
return;
}
// TODO: Currently, this does NOT attempt to detect when we have
// a close match
}
}
// See if it is our chapter number style.
else if (StStyle.IsStyle(ttpRun, ScrStyleNames.ChapterNumber))
{
// Assume the whole run is the chapter number. Extract it.
string sChapterNum = contents.Text.Substring(tsi.ichMin,
tsi.ichLim - tsi.ichMin);
int nChapter = ScrReference.ChapterToInt(sChapterNum);
fChapterFound = (nChapter == targetRef.Chapter);
}
ich = tsi.ichLim;
}
}
}
public void StyleCollectionWorksWithUpperAscii()
{
string styleName = "\u00e1bc";
StStyle style = new StStyle();
Cache.LangProject.StylesOC.Add(style);
style.Name = styleName;
FwStyleSheet.StyleInfoCollection styleCollection = new FwStyleSheet.StyleInfoCollection();
styleCollection.Add(new BaseStyleInfo(style));
Assert.IsTrue(styleCollection.Contains(styleName.Normalize(NormalizationForm.FormC)));
Assert.IsTrue(styleCollection.Contains(styleName.Normalize(NormalizationForm.FormD)));
Assert.IsTrue(styleCollection.Contains(styleName.Normalize(NormalizationForm.FormKC)));
Assert.IsTrue(styleCollection.Contains(styleName.Normalize(NormalizationForm.FormKD)));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Determines if paragraph has chapter or verse numbers in it.
/// </summary>
/// <returns><code>true</code> if either a chapter number or verse number is found
/// in the paragraph</returns>
/// ------------------------------------------------------------------------------------
public bool HasChapterOrVerseNumbers()
{
ITsString tss = Contents.UnderlyingTsString;
int cRun = tss.RunCount;
ITsTextProps ttpRun;
for (int i = 0; i < cRun; i++)
{
ttpRun = tss.get_Properties(i);
if (StStyle.IsStyle(ttpRun, ScrStyleNames.VerseNumber) ||
StStyle.IsStyle(ttpRun, ScrStyleNames.ChapterNumber))
{
return(true);
}
}
return(false);
}
public void SaveToDB_CopyOfStyleBasedOnNormal()
{
StyleInfoTable styleTable = new StyleInfoTable("Normal", Cache.LanguageWritingSystemFactoryAccessor);
IStStyle normalStyle = new StStyle();
Cache.LangProject.StylesOC.Add(normalStyle);
normalStyle.Name = "Normal";
normalStyle.Context = ContextValues.Internal;
normalStyle.Function = FunctionValues.Prose;
normalStyle.Structure = StructureValues.Undefined;
StyleInfo normal = new StyleInfo(normalStyle);
styleTable.Add("Normal", normal);
IStStyle realStyle = new StStyle();
Cache.LangProject.StylesOC.Add(realStyle);
realStyle.Name = "Paragraph";
realStyle.Context = ContextValues.Text;
realStyle.Function = FunctionValues.Prose;
realStyle.Structure = StructureValues.Body;
realStyle.BasedOnRA = normalStyle;
StyleInfo styleToCopyFrom = new StyleInfo(realStyle);
styleTable.Add("Paragraph", styleToCopyFrom);
StyleInfo testInfo = new StyleInfo(styleToCopyFrom, "Copy of Paragraph");
styleTable.Add("Copy of Paragraph", testInfo);
styleTable.ConnectStyles();
// simulate a save to the DB for the test style.
IStStyle style = new StStyle();
Cache.LangProject.StylesOC.Add(style);
testInfo.SaveToDB(style, false);
Assert.AreEqual(ContextValues.Text, testInfo.Context);
Assert.AreEqual(StructureValues.Body, testInfo.Structure);
Assert.AreEqual(FunctionValues.Prose, testInfo.Function);
Assert.AreEqual(ContextValues.Text, style.Context);
Assert.AreEqual(StructureValues.Body, style.Structure);
Assert.AreEqual(FunctionValues.Prose, style.Function);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Create a new style and add it to the Language Project stylesheet.
/// </summary>
/// <param name="name">style name</param>
/// <param name="context">style context</param>
/// <param name="structure">style structure</param>
/// <param name="function">style function</param>
/// <param name="isCharStyle">true if character style, otherwise false</param>
/// <param name="userLevel">The user level.</param>
/// <param name="styleCollection">The style collection.</param>
/// <returns>The style</returns>
/// ------------------------------------------------------------------------------------
public IStStyle AddTestStyle(string name, ContextValues context, StructureValues structure,
FunctionValues function, bool isCharStyle, int userLevel,
FdoOwningCollection <IStStyle> styleCollection)
{
CheckDisposed();
ITsPropsBldr bldr = TsPropsBldrClass.Create();
StStyle style = new StStyle();
styleCollection.Add(style);
style.Name = name;
style.Context = context;
style.Structure = structure;
style.Function = function;
style.Rules = bldr.GetTextProps();
style.Type = (isCharStyle ? StyleType.kstCharacter : StyleType.kstParagraph);
style.UserLevel = userLevel;
return(style);
}
/// <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_style = null;
base.Dispose(disposing);
}
public void SaveToDB_NewInfoAndBasedOnNewInfo()
{
IStStyle realStyle = new StStyle();
Cache.LangProject.StylesOC.Add(realStyle);
realStyle.Context = ContextValues.Intro;
realStyle.Function = FunctionValues.Table;
realStyle.Structure = StructureValues.Heading;
StyleInfo basedOn = new StyleInfo(realStyle);
StyleInfo testInfo1 = new StyleInfo("New Style 1", basedOn,
StyleType.kstParagraph, Cache);
StyleInfo testInfo2 = new StyleInfo("New Style 2", testInfo1,
StyleType.kstParagraph, Cache);
// simulate a save to the DB for the test styles. Save the second one first for
// a better test.
IStStyle style2 = new StStyle();
Cache.LangProject.StylesOC.Add(style2);
testInfo2.SaveToDB(style2, false);
IStStyle style = new StStyle();
Cache.LangProject.StylesOC.Add(style);
testInfo1.SaveToDB(style, false);
Assert.AreEqual(ContextValues.Intro, testInfo1.Context);
Assert.AreEqual(StructureValues.Heading, testInfo1.Structure);
Assert.AreEqual(FunctionValues.Table, testInfo1.Function);
Assert.AreEqual(ContextValues.Intro, style.Context);
Assert.AreEqual(StructureValues.Heading, style.Structure);
Assert.AreEqual(FunctionValues.Table, style.Function);
Assert.AreEqual(ContextValues.Intro, testInfo2.Context);
Assert.AreEqual(StructureValues.Heading, testInfo2.Structure);
Assert.AreEqual(FunctionValues.Table, testInfo2.Function);
Assert.AreEqual(ContextValues.Intro, style2.Context);
Assert.AreEqual(StructureValues.Heading, style2.Structure);
Assert.AreEqual(FunctionValues.Table, style2.Function);
}
public void UserDefinedCharacterStyle_ExplicitFontName()
{
// Create a style with an unspecified font name.
IStStyle charStyle = new StStyle();
Cache.LangProject.StylesOC.Add(charStyle);
charStyle.Context = ContextValues.Text;
charStyle.Function = FunctionValues.Prose;
charStyle.Structure = StructureValues.Body;
charStyle.Type = StyleType.kstCharacter;
StyleInfo basedOn = new StyleInfo(charStyle);
// Create a user-defined character style inherited from the previously-created character
// style, but this style has a font name specified.
StyleInfo charStyleInfo = new StyleInfo("New Char Style", basedOn,
StyleType.kstCharacter, Cache);
FontInfo charFontInfo = charStyleInfo.FontInfoForWs(Cache.DefaultVernWs);
m_fontTab.UpdateForStyle(charStyleInfo);
// Select a font name for the style (which will call the event handler
// m_cboFontNames_SelectedIndexChanged).
FwInheritablePropComboBox cboFontNames =
ReflectionHelper.GetField(m_fontTab, "m_cboFontNames") as FwInheritablePropComboBox;
Assert.IsNotNull(cboFontNames);
cboFontNames.AdjustedSelectedIndex = 2;
// Make sure we successfully set the font for this user-defined character style.
Assert.IsTrue(charStyleInfo.FontInfoForWs(-1).m_fontName.IsExplicit);
Assert.AreEqual("<default pub font>", charStyleInfo.FontInfoForWs(-1).m_fontName.Value,
"The font should have been set to the default publication font.");
cboFontNames.AdjustedSelectedIndex = 3;
// Make sure we successfully set the font for this user-defined character style.
Assert.IsTrue(charStyleInfo.FontInfoForWs(-1).m_fontName.IsExplicit);
Assert.AreEqual("<default sans serif>", charStyleInfo.FontInfoForWs(-1).m_fontName.Value,
"The font should have been set to the default heading font (i.e., sans-serif).");
}
public void ChangeParagraphToSectionHead_EndOfSection()
{
CheckDisposed();
IScrSection section = m_scrInMemoryCache.AddSectionToMockedBook(m_matthew.Hvo);
m_scrInMemoryCache.AddSectionHeadParaToSection(section.Hvo, "This is the heading",
ScrStyleNames.SectionHead);
m_scrInMemoryCache.AddParaToMockedSectionContent(section.Hvo, ScrStyleNames.NormalParagraph);
m_scrInMemoryCache.AddParaToMockedSectionContent(section.Hvo, ScrStyleNames.NormalParagraph);
StTxtPara para = m_scrInMemoryCache.AddParaToMockedSectionContent(section.Hvo,
ScrStyleNames.NormalParagraph);
m_scrInMemoryCache.AddRunToMockedPara(para, "6", ScrStyleNames.VerseNumber);
m_scrInMemoryCache.AddRunToMockedPara(para, "Content of paragraph 2", null);
section.AdjustReferences();
ScrSection secHelp = new ScrSection(Cache, section.Hvo);
IScrSection newSecHelp = secHelp.ChangeParagraphToSectionHead(2, 1);
// verify that the new section has one content paragraph and one heading paragraph.
Assert.AreEqual(1, newSecHelp.ContentOA.ParagraphsOS.Count);
Assert.AreEqual(1, newSecHelp.HeadingOA.ParagraphsOS.Count);
// verify that the text of the old paragraph is now in the new section head
// and that the new section content paragraph is empty and has normal paragraph
// style.
StTxtPara newSecPara = (StTxtPara)newSecHelp.ContentOA.ParagraphsOS[0];
Assert.IsTrue(StStyle.IsStyle(newSecPara.StyleRules, ScrStyleNames.NormalParagraph));
Assert.IsFalse(StStyle.IsStyle(newSecPara.Contents.UnderlyingTsString.get_Properties(0),
ScrStyleNames.NormalParagraph));
Assert.IsNull(newSecPara.Contents.Text);
StTxtPara newSecHeadPara = (StTxtPara)newSecHelp.HeadingOA.ParagraphsOS[0];
Assert.AreEqual(para.Contents.Text, newSecHeadPara.Contents.Text);
}
public void AddDeleteStyle()
{
CheckDisposed();
ITsPropsBldr tsPropsBldr = TsPropsBldrClass.Create();
ITsTextProps ttpFormattingProps = tsPropsBldr.GetTextProps(); // default properties
int nStylesOrig = m_styleSheet.CStyles;
// get an hvo for the new style
int hvoStyle = m_styleSheet.MakeNewStyle();
StStyle style = new StStyle(m_styleSheet.Cache, hvoStyle);
// PutStyle() adds the style to the stylesheet
m_styleSheet.PutStyle("MyNewStyle", "bla", hvoStyle, 0,
hvoStyle, 0, false, false, ttpFormattingProps);
Assert.AreEqual(nStylesOrig + 1, m_styleSheet.CStyles);
Assert.AreEqual(ttpFormattingProps, m_styleSheet.GetStyleRgch(0, "MyNewStyle"),
"Should get correct format props for the style added");
// Make style be based on section head and check context
IStStyle baseOnStyle = m_scr.FindStyle(ScrStyleNames.SectionHead);
m_styleSheet.PutStyle("MyNewStyle", "bla", hvoStyle, baseOnStyle.Hvo,
hvoStyle, 0, false, false, ttpFormattingProps);
Assert.AreEqual(baseOnStyle.Context, style.Context);
// Now delete the new style
m_styleSheet.Delete(hvoStyle);
// Verfiy the deletion
Assert.AreEqual(nStylesOrig, m_styleSheet.CStyles);
Assert.IsNull(m_styleSheet.GetStyleRgch(0, "MyNewStyle"),
"Should get null because style is not there");
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Check to see if section can be used as the starting section of the export. Must either
/// be an intro section or a section that begins with a chapter number run.
/// </summary>
/// <param name="sect">section to be checked</param>
/// <param name="prevSect">section previous to current section</param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
private bool ValidStartingSection(ScrSection sect, ScrSection prevSect)
{
if (sect.IsIntro || prevSect == null || prevSect.IsIntro)
{
return(true);
}
if (sect.ContentOA.ParagraphsOS.Count > 0)
{
StTxtPara para = (StTxtPara)sect.ContentOA.ParagraphsOS[0];
ITsString tss = para.Contents.UnderlyingTsString;
if (tss.RunCount > 0)
{
ITsTextProps ttpRun;
ttpRun = tss.get_Properties(0);
if (StStyle.IsStyle(ttpRun, ScrStyleNames.ChapterNumber))
{
return(true);
}
}
}
return(false);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Find the start and end reference, by searching backwards in the given ITsString
/// from the given position.
/// </summary>
/// <param name="tss">the given ITsString</param>
/// <param name="ichPos">Index of character in paragraph whose reference we want</param>
/// <param name="fAssocPrev">Consider this position to be associated with any preceding
/// text in the paragraph (in the case where ichPos is at a chapter boundary).</param>
/// <param name="refStart">[out] Start reference for the paragraph.</param>
/// <param name="refEnd">[out] End reference for the paragraph.</param>
/// <returns>A value of <see cref="ChapterVerseFound"/> that tells if a chapter and/or
/// verse number was found in this paragraph.</returns>
/// <remarks>If ichPos LT zero, we will not search this para, and simply return.
/// Be careful not to use this method to search the contents of paragraph using
/// character offsets from the BT!
/// </remarks>
/// ------------------------------------------------------------------------------------
static public ChapterVerseFound GetBCVRefAtPosWithinTss(ITsString tss, int ichPos,
bool fAssocPrev, out BCVRef refStart, out BCVRef refEnd)
{
refStart = new BCVRef();
refEnd = new BCVRef();
ChapterVerseFound retVal = ChapterVerseFound.None;
if (tss.Length <= 0)
{
return(retVal);
}
TsRunInfo tsi;
ITsTextProps ttpRun;
bool fGotVerse = false;
int ich = ichPos;
if (ich > tss.Length)
{
ich = tss.Length;
}
while (ich >= 0)
{
// Get props of current run.
ttpRun = tss.FetchRunInfoAt(ich, out tsi);
// If we're at (the front edge of) a C/V number boundary and the
// caller said to associate the position with the previous material, then
// ignore this run unless we're at the beginning of the para.
// The run is actually the *following* run, which we don't care about.
if (!fAssocPrev || ichPos <= 0 || ichPos != tsi.ichMin)
{
// See if it is our verse number style.
if (!fGotVerse && StStyle.IsStyle(ttpRun, ScrStyleNames.VerseNumber))
{
// The whole run is the verse number. Extract it.
string sVerseNum = tss.get_RunText(tsi.irun);
// string sVerseNum = tss.Text.Substring(tsi.ichMin,
// tsi.ichLim - tsi.ichMin);
int startVerse, endVerse;
ScrReference.VerseToInt(sVerseNum, out startVerse, out endVerse);
refStart.Verse = startVerse;
refEnd.Verse = endVerse;
fGotVerse = true;
retVal = ChapterVerseFound.Verse;
}
// See if it is our chapter number style.
else if (StStyle.IsStyle(ttpRun, ScrStyleNames.ChapterNumber))
{
try
{
// Assume the whole run is the chapter number. Extract it.
string sChapterNum = tss.get_RunText(tsi.irun);
int nChapter = ScrReference.ChapterToInt(sChapterNum);
refStart.Chapter = refEnd.Chapter = nChapter;
if (fGotVerse)
{
// Found a chapter number to go with the verse number we
// already found, so build the full reference using this
// chapter with the previously found verse (already set).
retVal |= ChapterVerseFound.Chapter;
}
else
{
// Found a chapter number but no verse number, so assume the
// edited text is in verse 1 of the chapter.
refStart.Verse = refEnd.Verse = 1;
fGotVerse = true;
retVal = ChapterVerseFound.Chapter | ChapterVerseFound.Verse;
}
break;
}
catch (ArgumentException)
{
// ignore runs with invalid Chapter numbers
}
}
}
// move index (going backwards) to the character just before the Min of the run
// we just looked at
ich = tsi.ichMin - 1;
}
return(retVal);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Given a Scripture section, this method returns the index of the paragraph containing
/// the requested verse and the position of the character immediately following the
/// verse number in that paragraph. If an exact match isn't found, the closest
/// approximate place is found.
/// </summary>
/// <param name="section">The section whose paragraphs will be searched</param>
/// <param name="targetRef">The reference being sought</param>
/// <param name="iPara">The index of the paragraph where the verse was found</param>
/// <param name="ichPosition">The index of the character immediately following the
/// verse number in that paragraph</param>
/// ------------------------------------------------------------------------------------
protected void FindVerseNumber(ScrSection section, ScrReference targetRef, out int iPara,
out int ichPosition)
{
iPara = 0;
ichPosition = 0;
bool fChapterFound = (BCVRef.GetChapterFromBcv(section.VerseRefMin) == targetRef.Chapter);
foreach (StTxtPara para in section.ContentOA.ParagraphsOS)
{
TsStringAccessor contents = para.Contents;
if (para.Contents.Text == null)
{
continue;
}
TsRunInfo tsi;
ITsTextProps ttpRun;
int ich = 0;
while (ich < contents.UnderlyingTsString.Length)
{
// Get props of current run.
ttpRun = contents.UnderlyingTsString.FetchRunInfoAt(ich, out tsi);
// See if it is our verse number style.
if (fChapterFound)
{
if (StStyle.IsStyle(ttpRun, ScrStyleNames.VerseNumber))
{
// The whole run is the verse number. Extract it.
string sVerseNum = contents.Text.Substring(tsi.ichMin,
tsi.ichLim - tsi.ichMin);
int startVerse, endVerse;
ScrReference.VerseToInt(sVerseNum, out startVerse, out endVerse);
if ((targetRef.Verse >= startVerse && targetRef.Verse <= endVerse) ||
targetRef.Verse < startVerse)
{
ichPosition = tsi.ichLim;
return;
}
}
}
// See if it is our chapter number style.
else if (StStyle.IsStyle(ttpRun, ScrStyleNames.ChapterNumber))
{
try
{
// Assume the whole run is the chapter number. Extract it.
string sChapterNum = contents.Text.Substring(tsi.ichMin,
tsi.ichLim - tsi.ichMin);
fChapterFound = (ScrReference.ChapterToInt(sChapterNum) == targetRef.Chapter);
}
catch (ArgumentException)
{
// ignore runs with invalid Chapter numbers
}
}
ich = tsi.ichLim;
}
iPara++;
}
iPara = 0; // Couldn't find it.
}
/// <summary>
/// Create a new style with a fixed guid.
/// </summary>
/// <param name="cache">project cache</param>
/// <param name="guid">the factory set guid</param>
/// <returns>A style interface</returns>
public IStStyle Create(FdoCache cache, Guid guid)
{
int hvo = ((IDataReader)cache.ServiceLocator.DataSetup).GetNextRealHvo();
var retval = new StStyle(cache, hvo, guid);
return retval;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Create a new style on the specified style list.
/// </summary>
/// <param name="styleList">The style list to add the style to</param>
/// <param name="name">style name</param>
/// <param name="context">style context</param>
/// <param name="structure">style structure</param>
/// <param name="function">style function</param>
/// <param name="isCharStyle">true if character style, otherwise false</param>
/// <param name="userLevel">User level</param>
/// <param name="isBuiltin">True for a builtin style, otherwise, false.</param>
/// <returns>The new created (and properly owned style.</returns>
/// ------------------------------------------------------------------------------------
public IStStyle Create(IFdoOwningCollection<IStStyle> styleList, string name,
ContextValues context, StructureValues structure, FunctionValues function,
bool isCharStyle, int userLevel, bool isBuiltin)
{
var retval = new StStyle();
styleList.Add(retval);
retval.Name = name;
retval.Context = context;
retval.Structure = structure;
retval.Function = function;
retval.Type = (isCharStyle ? StyleType.kstCharacter : StyleType.kstParagraph);
retval.UserLevel = userLevel;
retval.IsBuiltIn = isBuiltin;
return retval;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Advances the enumerator to the next verse in the paragraph.
/// </summary>
/// <returns>True if we successfully moved to the next ScrVerse; False if we reached
/// the end of the paragraph.</returns>
/// ------------------------------------------------------------------------------------
public bool MoveNext()
{
InitializeParaContents();
if (m_ich > m_paraLength)
{
return(false);
}
m_ichVerseStart = m_ichTextStart = m_ich;
TsRunInfo tsi;
ITsTextProps ttpRun;
string sPara = m_tssParaContents.Text;
int nChapter = -1; // This is used to see if we found a chapter later.
m_inVerseNum = false;
m_inChapterNum = false;
while (m_ich < m_paraLength)
{
ttpRun = m_tssParaContents.FetchRunInfoAt(m_ich, out tsi);
// If this run is our verse number style
if (StStyle.IsStyle(ttpRun, ScrStyleNames.VerseNumber))
{
// If there is already a verse in process, a new verse number run will terminate it.
if (m_ichVerseStart != m_ich)
{
break;
}
// Assume the whole run is the verse number
string sVerseNum = sPara.Substring(m_ich, tsi.ichLim - tsi.ichMin);
int nVerseStart, nVerseEnd;
ScrReference.VerseToInt(sVerseNum, out nVerseStart, out nVerseEnd);
m_startRef.Verse = nVerseStart;
m_endRef.Verse = nVerseEnd;
m_ichVerseStart = m_ich; //set VerseStart at beg of verse number
m_ich += sVerseNum.Length;
m_ichTextStart = m_ich;
m_inVerseNum = true;
}
// If this run is our chapter number style
else if (StStyle.IsStyle(ttpRun, ScrStyleNames.ChapterNumber))
{
// If there is already a verse being processed, then the chapter number
// run will end it
if (m_ichVerseStart != m_ich)
{
break;
}
try
{
// Assume the whole run is the chapter number
string sChapterNum = sPara.Substring(m_ich, tsi.ichLim - tsi.ichMin);
nChapter = ScrReference.ChapterToInt(sChapterNum);
m_startRef.Chapter = m_endRef.Chapter = nChapter;
// Set the verse number to 1, since the first verse number after a
// chapter is optional. If we happen to get a verse number in the
// next run, this '1' will be overridden (though it will probably
// still be a 1).
m_startRef.Verse = m_endRef.Verse = 1;
m_ichVerseStart = m_ich; //set VerseStart at beg of chapter number
m_ich += sChapterNum.Length;
m_ichTextStart = m_ich;
m_inChapterNum = true;
}
catch (ArgumentException)
{
// ignore runs with invalid Chapter numbers
m_ich += tsi.ichLim - tsi.ichMin;
}
}
else // Process a text run.
{
// If it comes after a chapter number, then just return the
// chapter number without adding the text.
if (nChapter > 0)
{
break;
}
// skip to the next run
m_ich += tsi.ichLim - tsi.ichMin;
}
}
// determine if this verse is a complete paragraph, an empty para and/or a stanza break.
m_isCompletePara = (m_ichVerseStart == 0 && m_ich == m_paraLength);
if (string.IsNullOrEmpty(sPara))
{
//m_isEmptyPara = true;
m_isStanzaBreak = string.Equals(ScrStyleNames.StanzaBreak,
ScrStyleNames.GetStyleName(m_para.Hvo, m_para.Cache));
}
try
{
return((m_ich > m_ichVerseStart) || FirstTimeAtStanzaBreak);
}
finally
{
// Update the previous paragraph for the next time (but we do the update
// in a 'finally' so that we can compare the current to the previous for
// the return value).
m_prevPara = m_para;
}
}
