/// <summary>
/// Try to find a WfiWordform object corresponding the the focus selection.
/// If successful return its guid, otherwise, return Guid.Empty.
/// </summary>
/// <returns></returns>
internal static Guid ActiveWordform(FdoCache cache, Mediator mediator)
{
IApp app = mediator.PropertyTable.GetValue("App") as IApp;
if (app == null)
return Guid.Empty;
IFwMainWnd window = app.ActiveMainWindow as IFwMainWnd;
if (window == null)
return Guid.Empty;
IRootSite activeView = window.ActiveView;
if (activeView == null)
return Guid.Empty;
List<IVwRootBox> roots = activeView.AllRootBoxes();
if (roots.Count < 1)
return Guid.Empty;
SelectionHelper helper = SelectionHelper.Create(roots[0].Site);
if (helper == null)
return Guid.Empty;
ITsString word = helper.SelectedWord;
if (word == null || word.Length == 0)
return Guid.Empty;
#if WANTPORT // FWR-2784
int hvoWordform = cache.LangProject.WordformInventoryOA.GetWordformId(word);
if (hvoWordform == 0 || cache.IsDummyObject(hvoWordform))
return Guid.Empty;
return cache.GetGuidFromId(hvoWordform);
#else
return Guid.Empty;
#endif
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Replaces all references to one paragraph in the footnote cache with another. Used to
/// update the cache when a paragraph is being merged with another.
/// </summary>
/// <param name="cache"></param>
/// <param name="oldParaHvo">id of paragraph being merged into another</param>
/// <param name="newParaHvo">id of paragraph surviving the merge</param>
/// ------------------------------------------------------------------------------------
public static void ReplaceReferencesToParagraph(FdoCache cache, int oldParaHvo, int newParaHvo)
{
int bookHvo = cache.GetOwnerOfObjectOfClass(oldParaHvo, (int)ScrBook.kclsidScrBook);
if (bookHvo <= 0)
{
Debug.Fail("Footnotes have to be contained in paragraphs owned by books.");
return;
}
Guid bookGuid = cache.GetGuidFromId(bookHvo);
Dictionary<int, FootnoteHashEntry> dict;
// Don't bother on empty cache - it will be created when needed. Need to use HVO to get
// GUID so we don't create the book and potentially cause the refresh routine to be called.
if (!cache.TryGetHashtable<int, FootnoteHashEntry>(bookGuid, out dict) || dict.Count == 0)
return;
foreach (FootnoteHashEntry entry in dict.Values)
{
if (entry.HvoPara == oldParaHvo)
entry.HvoPara = newParaHvo;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Create a new object, given a text representation (e.g., from the clipboard), unless
/// we are in a footnote or in back translation.
/// </summary>
/// <param name="cache">FDO cache representing the DB connection to use</param>
/// <param name="sTextRep">Text representation of object</param>
/// <param name="selDst">Provided for information in case it's needed to generate
/// the new object (E.g., footnotes might need it to generate the proper sequence
/// letter)</param>
/// <param name="kodt">The object data type to use for embedding the new object
/// </param>
/// <returns>The GUID of the new object, or <c>Guid.Empty</c> if it's illegal to
/// insert an object in this location.</returns>
/// ------------------------------------------------------------------------------------
public override Guid MakeObjFromText(FdoCache cache, string sTextRep,
IVwSelection selDst, out int kodt)
{
CheckDisposed();
kodt = 0;
Guid guid = Guid.Empty;
try
{
// Prevent objects from getting created in invalid locations: for example,
// we are in a footnote, a picture caption or the back translation
int tagSelection;
int hvoSelection;
GetSelectedScrElement(out tagSelection, out hvoSelection);
if (tagSelection == (int)ScrBook.ScrBookTags.kflidFootnotes ||
tagSelection == 0 || (m_viewType & TeViewType.FootnoteView) != 0 ||
IsPictureSelected || IsBackTranslation)
{
return guid;
}
IScrBook book = GetCurrentBook(cache);
if (!CmPicture.IsPicture(sTextRep))
{
if (m_lastFootnoteTextRepSelection == CurrentSelection)
m_newFootnoteIndex++; // same selection, increment footnote index
else
m_newFootnoteIndex = FindFootnotePosition(book, CurrentSelection);
// try to make footnote
StFootnote footnote = StFootnote.CreateFromStringRep((CmObject)book,
(int)ScrBook.ScrBookTags.kflidFootnotes, sTextRep, m_newFootnoteIndex,
ScrStyleNames.FootnoteMarker);
guid = cache.GetGuidFromId(footnote.Hvo);
kodt = (int)FwObjDataTypes.kodtOwnNameGuidHot;
//ScrFootnote.RecalculateFootnoteMarkers(book, 0);
m_lastFootnoteTextRepSelection = CurrentSelection;
}
}
catch
{
// try a different type
}
return guid == Guid.Empty ?
base.MakeObjFromText(cache, sTextRep, selDst, out kodt) : guid;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Refreshes cache for all footnotes in the StText containing the paragraph. We only
/// use this method when verses of a paragraph are changed - this will only happen on
/// content paragraphs of a ScrSection.
/// </summary>
/// <param name="cache"></param>
/// <param name="hvoObj"></param>
/// ------------------------------------------------------------------------------------
internal static void RefreshCacheForParagraph(FdoCache cache, int hvoObj)
{
int hvoPara = hvoObj;
if (cache.GetClassOfObject(hvoObj) == CmTranslation.kClassId)
hvoPara = cache.GetOwnerOfObject(hvoObj);
int hvoText = cache.GetOwnerOfObject(hvoPara);
IStText text = new StText(cache, hvoText);
ScrSection section = new ScrSection(cache, text.OwnerHVO);
BCVRef verseRef = new BCVRef(section.VerseRefStart);
Dictionary<int, FootnoteHashEntry> dict;
// Don't bother on empty cache - it will be created when needed. Need to use HVO to get GUID so we
// don't create the book and potentially cause the refresh routine to be called.
Guid bookGuid = cache.GetGuidFromId(section.OwnerHVO);
if (!cache.TryGetHashtable<int, FootnoteHashEntry>(bookGuid, out dict) ||
dict.Count == 0)
{
return;
}
AddFootnoteRefsInText(text, dict, ref verseRef);
}
/// <summary>
/// Determine whether the given object is a "suffix-ish" morph type.
/// </summary>
/// <param name="cache"></param>
/// <param name="hvoMorphType"></param>
/// <returns></returns>
public static bool IsSuffixishType(FdoCache cache, int hvoMorphType)
{
Guid guid = cache.GetGuidFromId(hvoMorphType);
switch (guid.ToString())
{
case kguidMorphSuffix:
case kguidMorphSuffixingInterfix:
return true;
default:
return false;
}
}
/// <summary>
/// Determine whether the given object is an affix type morph type.
/// </summary>
/// <param name="cache"></param>
/// <param name="hvoMorphType"></param>
/// <returns></returns>
public static bool IsAffixType(FdoCache cache, int hvoMorphType)
{
Guid guid = cache.GetGuidFromId(hvoMorphType);
switch (guid.ToString())
{
case kguidMorphCircumfix:
case kguidMorphInfix:
case kguidMorphPrefix:
case kguidMorphSimulfix:
case kguidMorphSuffix:
case kguidMorphSuprafix:
case kguidMorphInfixingInterfix:
case kguidMorphPrefixingInterfix:
case kguidMorphSuffixingInterfix:
return true;
default:
return false;
}
}
/// <summary>
/// Try to find a WfiWordform object corresponding the the focus selection.
/// If successful return its guid, otherwise, return Guid.Empty.
/// </summary>
/// <returns></returns>
internal static Guid ActiveWordform(FdoCache cache)
{
if (!(FwApp.App is FwXApp))
return Guid.Empty;
FwXWindow window = (FwApp.App as FwXApp).ActiveMainWindow as FwXWindow;
if (window == null)
return Guid.Empty;
IRootSite activeView = window.ActiveView;
if (activeView == null)
return Guid.Empty;
List<IVwRootBox> roots = activeView.AllRootBoxes();
if (roots.Count < 1)
return Guid.Empty;
SelectionHelper helper = SelectionHelper.Create(roots[0].Site);
if (helper == null)
return Guid.Empty;
ITsString word = helper.SelectedWord;
if (word == null || word.Length == 0)
return Guid.Empty;
int hvoWordform = cache.LangProject.WordformInventoryOA.GetWordformId(word);
if (hvoWordform == 0 || cache.IsDummyObject(hvoWordform))
return Guid.Empty;
return cache.GetGuidFromId(hvoWordform);
}
/// <summary>
/// Check whether the given entry (or entry owning the given sense) is either a bound
/// root or a bound stem. We don't want to use those as guesses for monomorphemic
/// words. See LT-10323.
/// </summary>
private static bool IsEntryBound(FdoCache cache, int hvoComponent, int clid)
{
int hvoTargetEntry;
if (clid == LexSense.kclsidLexSense)
{
ILexSense ls = LexSense.CreateFromDBObject(cache, hvoComponent);
hvoTargetEntry = ls.Entry.Hvo;
if (!(ls.MorphoSyntaxAnalysisRA is IMoStemMsa))
return true; // must be an affix, so it's bound by definition.
}
else
{
hvoTargetEntry = hvoComponent;
}
int hvoMorph = cache.MainCacheAccessor.get_ObjectProp(hvoTargetEntry,
(int)LexEntry.LexEntryTags.kflidLexemeForm);
if (hvoMorph != 0)
{
int hvoMorphType = cache.MainCacheAccessor.get_ObjectProp(hvoMorph,
(int)MoForm.MoFormTags.kflidMorphType);
if (hvoMorphType != 0)
{
if (MoMorphType.IsAffixType(cache, hvoMorphType))
return true;
Guid guid = cache.GetGuidFromId(hvoMorphType);
if (guid == new Guid(MoMorphType.kguidMorphBoundRoot) ||
guid == new Guid(MoMorphType.kguidMorphBoundStem))
{
return true;
}
}
}
return false;
}
