/// ------------------------------------------------------------------------------------
/// <summary>
/// Print method
/// </summary>
/// ------------------------------------------------------------------------------------
public override void Print(PrintDocument pd)
{
CheckDisposed();
ISilDataAccess oldSda = null;
bool fPrintSelection = (pd.PrinterSettings.PrintRange == PrintRange.Selection);
if (fPrintSelection)
{
oldSda = RootBox.DataAccess;
IVwSelection sel = RootBox.Selection;
int clev = sel.CLevels(true);
int hvoObj, tag, ihvoEnd, ihvoAnchor, cpropPrevious;
IVwPropertyStore vps;
sel.PropInfo(true, clev - 1, out hvoObj, out tag, out ihvoEnd, out cpropPrevious, out vps);
clev = sel.CLevels(false);
sel.PropInfo(false, clev - 1, out hvoObj, out tag, out ihvoAnchor, out cpropPrevious, out vps);
int[] originalObjects = m_sdaSource.VecProp(m_hvoRoot, m_mainFlid);
int ihvoMin = Math.Min(ihvoEnd, ihvoAnchor);
int ihvoLim = Math.Max(ihvoEnd, ihvoAnchor) + 1;
var selectedObjects = new int[ihvoLim - ihvoMin];
for (int i = 0; i < selectedObjects.Length; i++)
{
selectedObjects[i] = originalObjects[i + ihvoMin];
}
RootBox.DataAccess = CachePrintDecorator(m_sdaSource, m_hvoRoot, m_mainFlid, selectedObjects);
}
base.Print(pd);
if (fPrintSelection)
{
RootBox.DataAccess = oldSda;
}
}
public void OnFwRightMouseClick(SimpleRootSite sender, FwRightMouseClickEventArgs e)
{
CheckDisposed();
var browseView = sender as XmlBrowseView;
if (browseView != null)
{
IVwSelection sel = e.Selection;
int clev = sel.CLevels(false); // anchor
int hvoRoot, tag, ihvo, cpropPrevious;
IVwPropertyStore vps;
sel.PropInfo(false, clev - 1, out hvoRoot, out tag, out ihvo, out cpropPrevious, out vps);
// First make the selection so it will be highlighted before the context menu popup.
if (browseView.SelectedIndex != ihvo) // No sense in waking up the beast for no reason.
{
browseView.SelectedIndex = ihvo;
}
int hvo = browseView.HvoAt(ihvo);
if (Cache.ServiceLocator.IsValidObjectId(hvo)) // may be fake one from decorator.
{
CmObjectUi ui = CmObjectUi.MakeUi(Cache, hvo); // Disposes of itself when menu closes since true passed in lext line.
if (ui != null)
{
ui.Mediator = m_mediator;
ui.PropTable = m_propertyTable;
e.EventHandled = ui.HandleRightClick(m_mediator, m_propertyTable, sender, true, "mnuBrowseView");
}
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Level 0 returns the same object as Hvo(fEndPoint).
/// Level 1 returns the object which contains the display of ContainingObject(0, fEndPoint).
/// Level n returns the object which contains the display of ContainingObject(n-1, fEndPoint).
/// Returns 0 if there was no selection or level is too large.
/// </summary>
/// <param name="level"></param>
/// <param name="fEndPoint"></param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
public int ContainingObject(int level, bool fEndPoint)
{
if (m_sel == null)
{
return(0);
}
if (level >= m_sel.CLevels(fEndPoint))
{
return(0);
}
int hvoObj, tag, ihvo, cpropPrevious;
IVwPropertyStore vps;
m_sel.PropInfo(fEndPoint, level, out hvoObj, out tag, out ihvo, out cpropPrevious, out vps);
return(hvoObj);
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// Notifies the site that something about the selection has changed.
/// </summary>
/// <param name="prootb"></param>
/// <param name="vwselNew">Selection</param>
/// <remarks>When overriding you should call the base class first.</remarks>
/// -----------------------------------------------------------------------------------
public override void SelectionChanged(IVwRootBox prootb, IVwSelection vwselNew)
{
CheckDisposed();
base.SelectionChanged(prootb, vwselNew);
if (vwselNew == null)
{
return;
}
int clev = vwselNew.CLevels(false); // anchor
int hvoRoot, tag, ihvo, cpropPrevious;
IVwPropertyStore vps;
vwselNew.PropInfo(false, clev - 1, out hvoRoot, out tag, out ihvo,
out cpropPrevious, out vps);
Debug.Assert(hvoRoot == m_hvoRoot);
int hvoObjNewSel = m_fdoCache.MainCacheAccessor.get_VecItem(hvoRoot, tag, ihvo);
if (hvoObjNewSel != 0)
{
// Notify any delegates that the selection of the main object in the vector
// may have changed.
if (SelectionChangedEvent != null)
{
SelectionChangedEvent(this, new FwObjectSelectionEventArgs(hvoObjNewSel, ihvo));
}
}
}
public void OnFwRightMouseClick(SimpleRootSite sender, FwRightMouseClickEventArgs e)
{
CheckDisposed();
XmlBrowseView browseView = sender as XmlBrowseView;
if (browseView != null)
{
IVwSelection sel = e.Selection;
int clev = sel.CLevels(false); // anchor
int hvoRoot, tag, ihvo, cpropPrevious;
IVwPropertyStore vps;
sel.PropInfo(false, clev - 1, out hvoRoot, out tag, out ihvo, out cpropPrevious, out vps);
// First make the selection so it will be highlighted before the context menu popup.
if (browseView.SelectedIndex != ihvo) // No sense in waking up the beast for no reason.
{
browseView.SelectedIndex = ihvo;
}
int hvo = browseView.HvoAt(ihvo);
CmObjectUi ui = CmObjectUi.MakeUi(Cache, hvo);
if (ui != null)
{
e.EventHandled = ui.HandleRightClick(m_mediator, sender, true, "mnuBrowseView");
}
}
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// Notifies the site that something about the selection has changed.
/// </summary>
/// <param name="prootb"></param>
/// <param name="vwselNew">Selection</param>
/// <remarks>When overriding you should call the base class first.</remarks>
/// -----------------------------------------------------------------------------------
protected override void HandleSelectionChange(IVwRootBox prootb, IVwSelection vwselNew)
{
CheckDisposed();
base.HandleSelectionChange(prootb, vwselNew);
if (vwselNew == null)
{
return;
}
int clev = vwselNew.CLevels(false); // anchor
int clevEnd = vwselNew.CLevels(true);
if (clev < 2 || clevEnd < 2)
{
return; // paranoia
}
int hvoRoot, tag, ihvo, ihvoEnd, cpropPrevious;
IVwPropertyStore vps;
vwselNew.PropInfo(true, clevEnd - 1, out hvoRoot, out tag, out ihvoEnd,
out cpropPrevious, out vps);
vwselNew.PropInfo(false, clev - 1, out hvoRoot, out tag, out ihvo,
out cpropPrevious, out vps);
// Give up if the selection doesn't indicate any top-level object; I think this can happen with pictures.
// selection larger than a top-level object, maybe select all, side effects are confusing.
if (ihvo != ihvoEnd || ihvo < 0)
{
return;
}
if (hvoRoot == 0)
{
return;
}
Debug.Assert(hvoRoot == m_hvoRoot);
int hvoObjNewSel = m_sdaSource.get_VecItem(hvoRoot, tag, ihvo);
if (hvoObjNewSel != 0)
{
// Notify any delegates that the selection of the main object in the vector
// may have changed.
if (SelectionChangedEvent != null)
{
SelectionChangedEvent(this, new FwObjectSelectionEventArgs(hvoObjNewSel, ihvo));
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Print method
/// </summary>
/// ------------------------------------------------------------------------------------
public override void Print(PrintDocument pd)
{
CheckDisposed();
bool fPrintSelection = (pd.PrinterSettings.PrintRange == PrintRange.Selection);
int[] originalObjects = null;
if (fPrintSelection)
{
IVwSelection sel = RootBox.Selection;
int clev = sel.CLevels(true);
int hvoObj, tag, ihvoEnd, ihvoAnchor, cpropPrevious;
IVwPropertyStore vps;
sel.PropInfo(true, clev - 1, out hvoObj, out tag, out ihvoEnd, out cpropPrevious, out vps);
clev = sel.CLevels(false);
sel.PropInfo(false, clev - 1, out hvoObj, out tag, out ihvoAnchor, out cpropPrevious, out vps);
ISilDataAccess sda = m_fdoCache.MainCacheAccessor;
int chvoReal = sda.get_VecSize(m_hvoRoot, m_mainFlid);
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative(chvoReal, typeof(int)))
{
sda.VecProp(m_hvoRoot, m_mainFlid, chvoReal, out chvoReal, arrayPtr);
originalObjects = (int[])MarshalEx.NativeToArray(arrayPtr, chvoReal, typeof(int));
}
int ihvoMin = Math.Min(ihvoEnd, ihvoAnchor);
int ihvoLim = Math.Max(ihvoEnd, ihvoAnchor) + 1;
int[] selectedObjects = new int[ihvoLim - ihvoMin];
for (int i = 0; i < selectedObjects.Length; i++)
{
selectedObjects[i] = originalObjects[i + ihvoMin];
}
m_fdoCache.VwCacheDaAccessor.CacheVecProp(m_hvoRoot, m_mainFlid, selectedObjects, selectedObjects.Length);
}
try
{
base.Print(pd);
}
finally
{
if (fPrintSelection)
{
m_fdoCache.VwCacheDaAccessor.CacheVecProp(m_hvoRoot, m_mainFlid, originalObjects, originalObjects.Length);
}
}
}
protected override bool DoContextMenu(IVwSelection sel, Point pt, Rectangle rcSrcRoot, Rectangle rcDstRoot)
{
int hvo, tag, ihvo, cpropPrevious;
IVwPropertyStore propStore;
sel.PropInfo(false, 0, out hvo, out tag, out ihvo, out cpropPrevious, out propStore);
string nodePath = null;
if (propStore != null)
{
nodePath = propStore.get_StringProperty((int)FwTextPropType.ktptBulNumTxtBef);
}
if (string.IsNullOrEmpty(nodePath))
{
if (sel.SelType == VwSelType.kstPicture)
{
return(true);
}
// may be a literal string, where we can get it from the string itself.
ITsString tss;
int ich, ws;
bool fAssocPrev;
sel.TextSelInfo(false, out tss, out ich, out fAssocPrev, out hvo, out tag, out ws);
nodePath = tss.get_Properties(0).GetStrPropValue((int)FwTextPropType.ktptBulNumTxtBef);
}
if (m_configObjectName == null)
{
m_configObjectName = XmlUtils.GetLocalizedAttributeValue(
Mediator.StringTbl, m_xnSpec, "configureObjectName", null);
}
string label;
if (string.IsNullOrEmpty(nodePath))
{
label = String.Format(xWorksStrings.ksConfigure, m_configObjectName);
}
else
{
label = String.Format(xWorksStrings.ksConfigureIn, nodePath.Split(':')[3], m_configObjectName);
}
m_contextMenu = new ContextMenuStrip();
var item = new ToolStripMenuItem(label);
m_contextMenu.Items.Add(item);
item.Click += RunConfigureDialogAt;
item.Tag = nodePath;
m_contextMenu.Show(this, pt);
m_contextMenu.Closed += m_contextMenu_Closed;
return(true);
}
/// <summary>
/// Determine whether the current selection is at a place suitable for type-ahead. If not, answer 0.
/// (In this case the values of hvoParent and ihvo should not be relied on.)
/// If so, indicate the object whose property may be set by type-ahead (hvoParent), the object
/// in the relevant property that is selected (return result), and its index within the property
/// (0 if atomic).
/// </summary>
/// <param name="rootb"></param>
/// <param name="sel"></param>
/// <param name="hvoParent"></param>
/// <param name="ihvo"></param>
/// <returns></returns>
private int SelectedObject(IVwRootBox rootb, IVwSelection sel, out int hvoParent, out int ihvo)
{
hvoParent = 0;
ihvo = 0;
if (rootb == null) // If we don't have a root box, can't do anything interesting.
{
return(0);
}
if (sel == null) // nothing interesting to do without a selection, either.
{
return(0);
}
ITsString tssA, tssE;
int ichA, ichE, hvoObjA, hvoObjE, tagA, tagE, ws;
bool fAssocPrev;
// Enhance JohnT: what we're really trying to do here is confirm that the selection is
// all in one string property. We could readily have a method in the selection interface to tell us that.
sel.TextSelInfo(false, out tssA, out ichA, out fAssocPrev, out hvoObjA, out tagA, out ws);
if (tagA != m_taTagName && tagA != m_snTagName)
{
return(0); // selection not anchored in any sort of type-ahead name property.
}
sel.TextSelInfo(true, out tssE, out ichE, out fAssocPrev, out hvoObjE, out tagE, out ws);
int cch = tssA.Length;
// To do our type-ahead trick, both ends of the seleciton must be in the same string property.
// Also, we want the selection to extend to the end of the name.
// Enhance JohnT: if we do a popup window, it may not matter whether the selection extends
// to the end; just show items that match.
if (tagE != tagA || hvoObjE != hvoObjA || cch != tssE.Length || Math.Max(ichA, ichE) != cch)
{
return(0); // not going to attempt type-ahead behavior
}
int clev = sel.CLevels(false);
if (clev < 2)
{
return(0); // can't be our property.
}
int tagParent, cpropPrevious;
IVwPropertyStore vps;
sel.PropInfo(false, 1, out hvoParent, out tagParent, out ihvo, out cpropPrevious, out vps);
if (tagParent != m_virtualTagObj)
{
return(0); // not our virtual property!
}
return(hvoObjA);
}
protected override bool OnRightMouseDown(Point pt, Rectangle rcSrcRoot, Rectangle rcDstRoot)
{
IVwSelection vwsel = m_rootb.MakeSelAt(pt.X, pt.Y, rcSrcRoot, rcDstRoot, false);
if (vwsel != null)
{
int clevels = vwsel.CLevels(false);
// Figure which paragraph we clicked. The last level (clevels-1) is our top-level
// list: hvoObj would be khvoBook. (clevels-2) is next: hvoObj is a section.
// (clevels-3) gives us a paragraph object.
int hvoObj, tag, ihvo, cpropPrevious;
IVwPropertyStore vps;
vwsel.PropInfo(false, clevels - 3, out hvoObj, out tag, out ihvo, out cpropPrevious, out vps);
Parse(hvoObj);
}
return(true);
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// Retrieves the flid and hvo corresponding to the current Scripture element (e.g., section
/// heading, section contents, or title) selected.
/// </summary>
/// <param name="vwsel">The current selection</param>
/// <param name="tag">The flid of the selected footnote</param>
/// <param name="hvoSel">The hvo of the selected footnote</param>
/// <returns>True, if a footnote is found at the current selection</returns>
/// -----------------------------------------------------------------------------------
protected bool GetSelectedFootnote(IVwSelection vwsel, out int tag, out int hvoSel)
{
hvoSel = 0;
tag = 0;
int hvoPrevLevel = 0;
int tagPrev = 0;
try
{
if (vwsel != null)
{
// If we look more than 10 levels then something is wrong.
for (int ilev = 0; ilev < 10; ilev++)
{
int ihvo, cpropPrev;
IVwPropertyStore qvps;
hvoPrevLevel = hvoSel;
tagPrev = tag;
vwsel.PropInfo(false, ilev, out hvoSel, out tag, out ihvo,
out cpropPrev, out qvps);
switch (tag)
{
case ScrBookTags.kflidFootnotes:
{
hvoSel = hvoPrevLevel;
tag = tagPrev;
return(true);
}
default:
break;
}
}
}
}
catch
{
// REVIEW (TimS): Why are we catching all exceptions here?
}
return(false);
}
public override void SelectionChanged(IVwRootBox rootb, IVwSelection vwselNew)
{
CheckDisposed();
if (vwselNew == null)
return;
base.SelectionChanged(rootb, vwselNew);
ITsString tss;
int ichAnchor;
bool fAssocPrev;
int hvoObj;
int tag;
int ws;
vwselNew.TextSelInfo(false, out tss, out ichAnchor, out fAssocPrev, out hvoObj, out tag, out ws);
int ichEnd;
int hvoObjEnd;
vwselNew.TextSelInfo(true, out tss, out ichEnd, out fAssocPrev, out hvoObjEnd, out tag, out ws);
if (hvoObjEnd != hvoObj)
{
// Can't do much with a multi-object selection.
CheckHeight();
return;
}
// The next level out in the view should be the entry in the index.
int hvoIndex, ihvoEntry, cpropPrevious, tagEntry;
IVwPropertyStore vps;
vwselNew.PropInfo(false, 1, out hvoIndex, out tagEntry, out ihvoEntry, out cpropPrevious, out vps);
// And the next one is the relevant index.
int hvoSense, tagIndex, ihvoIndex;
vwselNew.PropInfo(false, 2, out hvoSense, out tagIndex, out ihvoIndex, out cpropPrevious, out vps);
int count = m_silCache.get_VecSize(hvoIndex, kFlidEntries);
int lastEntryHvo = m_silCache.get_VecItem(hvoIndex, kFlidEntries, count - 1);
//string oldForm = m_silCache.get_UnicodeProp(m_hvoOldSelection, (int)ReversalIndexEntry.ReversalIndexEntryTags.kflidForm);
string oldForm = null;
int wsIndex = m_silCache.get_IntProp(hvoIndex, (int)ReversalIndex.ReversalIndexTags.kflidWritingSystem);
ITsString tssEntry = m_silCache.get_MultiStringAlt(m_hvoOldSelection,
(int)ReversalIndexEntry.ReversalIndexEntryTags.kflidReversalForm, wsIndex);
if (tssEntry != null)
oldForm = tssEntry.Text;
if (m_hvoOldSelection != 0
&& hvoObj != m_hvoOldSelection
&& (oldForm == null || oldForm.Length == 0))
{
// Remove the old string from the dummy cache, since its length is 0.
for (int i = 0; i < count; ++i)
{
if (m_hvoOldSelection == m_silCache.get_VecItem(hvoIndex, kFlidEntries, i))
{
RemoveFromDummyCache(hvoIndex, i);
break;
}
}
}
// If it's not the last index in the list, we can just go on editing it.
if (hvoObj != lastEntryHvo)
{
m_hvoOldSelection = hvoObj;
CheckHeight();
return;
}
// Even if it's the last object, if it's empty we don't need to do anything.
if (tss.Length == 0)
{
CheckHeight();
return;
}
// Create a new object, and recreate a new empty object.
count = m_silCache.get_VecSize(hvoIndex, kFlidEntries);
// Assign a new dummy ID.
m_dummyId--;
// Insert it at the end of the list.
m_vwCache.CacheReplace(hvoIndex, kFlidEntries, count, count, new int[] {m_dummyId}, 1);
Cache.EnableUndo = false; // Things have changed in a way we can't Undo.
// Set its 'form' to be an empty string in the appropriate writing system.
ITsTextProps props = tss.get_PropertiesAt(0);
int nVar;
ws = props.GetIntPropValues((int)FwTextPropType.ktptWs, out nVar);
//m_vwCache.CacheUnicodeProp(m_dummyId, (int)ReversalIndexEntry.ReversalIndexEntryTags.kflidForm, String.Empty, 0);
//m_vwCache.CacheIntProp(m_dummyId, (int)ReversalIndexEntry.ReversalIndexEntryTags.kflidWritingSystem, ws);
ITsString tssEmpty = m_tsf.MakeString("", ws);
m_vwCache.CacheStringAlt(m_dummyId, (int)ReversalIndexEntry.ReversalIndexEntryTags.kflidReversalForm,
ws, tssEmpty);
// Refresh
m_silCache.PropChanged(null, (int)PropChangeType.kpctNotifyAll,
hvoIndex, kFlidEntries, count, 1, 0);
// Reset selection.
SelLevInfo[] rgvsli = new SelLevInfo[2];
rgvsli[0].cpropPrevious = 0;
rgvsli[0].tag = kFlidEntries;
rgvsli[0].ihvo = count - 1;
rgvsli[1].cpropPrevious = 0;
rgvsli[1].tag = kFlidIndices;
rgvsli[1].ihvo = ihvoIndex;
try
{
m_rootb.MakeTextSelection(0, rgvsli.Length, rgvsli, tag, 0, ichAnchor, ichEnd, ws, fAssocPrev, -1, null, true);
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
throw;
}
m_hvoOldSelection = hvoObj;
CheckHeight();
}
/// <summary>
/// Determine whether the current selection is at a place suitable for type-ahead. If not, answer 0.
/// (In this case the values of hvoParent and ihvo should not be relied on.)
/// If so, indicate the object whose property may be set by type-ahead (hvoParent), the object
/// in the relevant property that is selected (return result), and its index within the property
/// (0 if atomic).
/// </summary>
/// <param name="rootb"></param>
/// <param name="sel"></param>
/// <param name="hvoParent"></param>
/// <param name="ihvo"></param>
/// <returns></returns>
private int SelectedObject(IVwRootBox rootb, IVwSelection sel, out int hvoParent, out int ihvo)
{
hvoParent = 0;
ihvo = 0;
if (rootb == null) // If we don't have a root box, can't do anything interesting.
return 0;
if (sel == null) // nothing interesting to do without a selection, either.
return 0;
ITsString tssA, tssE;
int ichA, ichE, hvoObjA, hvoObjE, tagA, tagE, ws;
bool fAssocPrev;
// Enhance JohnT: what we're really trying to do here is confirm that the selection is
// all in one string property. We could readily have a method in the selection interface to tell us that.
sel.TextSelInfo(false, out tssA, out ichA, out fAssocPrev, out hvoObjA, out tagA, out ws);
if (tagA != m_taTagName && tagA != m_snTagName)
return 0; // selection not anchored in any sort of type-ahead name property.
sel.TextSelInfo(true, out tssE, out ichE, out fAssocPrev, out hvoObjE, out tagE, out ws);
int cch = tssA.Length;
// To do our type-ahead trick, both ends of the seleciton must be in the same string property.
// Also, we want the selection to extend to the end of the name.
// Enhance JohnT: if we do a popup window, it may not matter whether the selection extends
// to the end; just show items that match.
if (tagE != tagA || hvoObjE != hvoObjA || cch != tssE.Length || Math.Max(ichA, ichE) != cch)
return 0; // not going to attempt type-ahead behavior
int clev = sel.CLevels(false);
if (clev < 2)
return 0; // can't be our property.
int tagParent, cpropPrevious;
IVwPropertyStore vps;
sel.PropInfo(false, 1, out hvoParent, out tagParent, out ihvo, out cpropPrevious, out vps);
if (tagParent != m_virtualTagObj)
return 0; // not our virtual property!
return hvoObjA;
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// Notifies the site that something about the selection has changed.
/// </summary>
/// <param name="prootb"></param>
/// <param name="vwselNew">Selection</param>
/// <remarks>When overriding you should call the base class first.</remarks>
/// -----------------------------------------------------------------------------------
public override void SelectionChanged(IVwRootBox prootb, IVwSelection vwselNew)
{
CheckDisposed();
base.SelectionChanged(prootb, vwselNew);
if (vwselNew == null)
return;
int clev = vwselNew.CLevels(false); // anchor
int hvoRoot, tag, ihvo, cpropPrevious;
IVwPropertyStore vps;
vwselNew.PropInfo(false, clev - 1, out hvoRoot, out tag, out ihvo,
out cpropPrevious, out vps);
Debug.Assert(hvoRoot == m_hvoRoot);
int hvoObjNewSel = m_fdoCache.MainCacheAccessor.get_VecItem(hvoRoot, tag, ihvo);
if (hvoObjNewSel != 0)
{
// Notify any delegates that the selection of the main object in the vector
// may have changed.
if (SelectionChangedEvent != null)
SelectionChangedEvent(this, new FwObjectSelectionEventArgs(hvoObjNewSel, ihvo));
}
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// Notifies the site that something about the selection has changed.
/// </summary>
/// <param name="prootb"></param>
/// <param name="vwselNew">Selection</param>
/// <remarks>When overriding you should call the base class first.</remarks>
/// -----------------------------------------------------------------------------------
protected override void HandleSelectionChange(IVwRootBox prootb, IVwSelection vwselNew)
{
CheckDisposed();
base.HandleSelectionChange(prootb, vwselNew);
if (vwselNew == null)
return;
int clev = vwselNew.CLevels(false); // anchor
int clevEnd = vwselNew.CLevels(true);
if (clev < 2 || clevEnd < 2)
return; // paranoia
int hvoRoot, tag, ihvo, ihvoEnd, cpropPrevious;
IVwPropertyStore vps;
vwselNew.PropInfo(true, clevEnd - 1, out hvoRoot, out tag, out ihvoEnd,
out cpropPrevious, out vps);
vwselNew.PropInfo(false, clev - 1, out hvoRoot, out tag, out ihvo,
out cpropPrevious, out vps);
// Give up if the selection doesn't indicate any top-level object; I think this can happen with pictures.
// selection larger than a top-level object, maybe select all, side effects are confusing.
if (ihvo != ihvoEnd || ihvo < 0)
return;
if (hvoRoot == 0)
return;
Debug.Assert(hvoRoot == m_hvoRoot);
int hvoObjNewSel = m_sdaSource.get_VecItem(hvoRoot, tag, ihvo);
if (hvoObjNewSel != 0)
{
// Notify any delegates that the selection of the main object in the vector
// may have changed.
if (SelectionChangedEvent != null)
SelectionChangedEvent(this, new FwObjectSelectionEventArgs(hvoObjNewSel, ihvo));
}
}
protected override bool DoContextMenu(IVwSelection sel, Point pt, Rectangle rcSrcRoot, Rectangle rcDstRoot)
{
int hvo, tag, ihvo, cpropPrevious;
IVwPropertyStore propStore;
sel.PropInfo(false, 0, out hvo, out tag, out ihvo, out cpropPrevious, out propStore);
string nodePath = null;
if (propStore != null)
{
nodePath = propStore.get_StringProperty((int) FwTextPropType.ktptBulNumTxtBef);
}
if (string.IsNullOrEmpty(nodePath))
{
if (sel.SelType == VwSelType.kstPicture)
return true;
// may be a literal string, where we can get it from the string itself.
ITsString tss;
int ich, ws;
bool fAssocPrev;
sel.TextSelInfo(false, out tss, out ich, out fAssocPrev, out hvo, out tag, out ws);
nodePath = tss.get_Properties(0).GetStrPropValue((int) FwTextPropType.ktptBulNumTxtBef);
}
if (m_configObjectName == null)
m_configObjectName = XmlUtils.GetLocalizedAttributeValue(
Mediator.StringTbl, m_xnSpec, "configureObjectName", null);
string label;
if (string.IsNullOrEmpty(nodePath))
label = String.Format(xWorksStrings.ksConfigure, m_configObjectName);
else
label = String.Format(xWorksStrings.ksConfigureIn, nodePath.Split(':')[3], m_configObjectName);
m_contextMenu = new ContextMenuStrip();
var item = new ToolStripMenuItem(label);
m_contextMenu.Items.Add(item);
item.Click += RunConfigureDialogAt;
item.Tag = nodePath;
m_contextMenu.Show(this, pt);
m_contextMenu.Closed += m_contextMenu_Closed;
return true;
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// Retrieves the flid and hvo corresponding to the current Scripture element (e.g., section
/// heading, section contents, or title) selected.
/// </summary>
/// <param name="vwsel">The current selection</param>
/// <param name="tag">The flid of the selected footnote</param>
/// <param name="hvoSel">The hvo of the selected footnote</param>
/// <returns>True, if a footnote is found at the current selection</returns>
/// -----------------------------------------------------------------------------------
protected bool GetSelectedFootnote(IVwSelection vwsel, out int tag, out int hvoSel)
{
hvoSel = 0;
tag = 0;
int hvoPrevLevel = 0;
int tagPrev = 0;
try
{
if (vwsel != null)
{
// If we look more than 10 levels then something is wrong.
for (int ilev = 0; ilev < 10; ilev++)
{
int ihvo, cpropPrev;
IVwPropertyStore qvps;
hvoPrevLevel = hvoSel;
tagPrev = tag;
vwsel.PropInfo(false, ilev, out hvoSel, out tag, out ihvo,
out cpropPrev, out qvps);
switch (tag)
{
case (int)ScrBook.ScrBookTags.kflidFootnotes:
{
hvoSel = hvoPrevLevel;
tag = tagPrev;
return true;
}
default:
break;
}
}
}
}
catch
{
}
return false;
}
/// <summary>
/// Given a selection in the view, return the row index. Rarely may return -1 if unable to
/// identify a row.
/// </summary>
/// <param name="sel"></param>
/// <param name="fEndPoint">true to get index based on end of selection, false based on anchor.
/// deafault is true, so in a long drag we get the mouse-up row.</param>
/// <returns></returns>
internal int GetRowIndexFromSelection(IVwSelection sel, bool fEndPoint)
{
if (sel == null)
return -1;
try
{
int clev = sel.CLevels(fEndPoint);
int hvoRoot, tag, ihvo, cpropPrevious;
IVwPropertyStore vps;
sel.PropInfo(fEndPoint, clev - 1, out hvoRoot, out tag, out ihvo, out cpropPrevious, out vps);
if (tag != m_fakeFlid) // not sure how this could happen, but the precaution was in an earlier version.
return -1;
return ihvo;
}
catch (System.Runtime.InteropServices.COMException)
{
// This shouldn't happen, but don't let it be catastrophic if it does.
}
return -1;
}
/// <summary>
/// This is the real guts of type-ahead. It is called by the client whenever a key is pressed.
/// It returns true if it handled the key press, which it does if the current selection
/// is in a type-ahead name property.
/// </summary>
/// <param name="ehelp"></param>
/// <param name="e"></param>
/// <param name="modifiers"></param>
/// <param name="vwGraphics"></param>
/// <returns></returns>
public virtual bool OnKeyPress(EditingHelper ehelp, KeyPressEventArgs e, Keys modifiers, IVwGraphics vwGraphics)
{
IVwRootBox rootb = ehelp.Callbacks.EditedRootBox;
if (rootb == null) // If we don't have a root box, can't do anything interesting.
{
return(false);
}
IVwSelection sel = rootb.Selection;
if (sel == null) // nothing interesting to do without a selection, either.
{
return(false);
}
ITsString tssA, tssE;
int ichA, ichE, hvoObjA, hvoObjE, tagA, tagE, ws;
bool fAssocPrev;
// Enhance JohnT: what we're really trying to do here is confirm that the selection is
// all in one string property. We could readily have a method in the selection interface to tell us that.
sel.TextSelInfo(false, out tssA, out ichA, out fAssocPrev, out hvoObjA, out tagA, out ws);
if (tagA != m_taTagName)
{
return(false); // selection not anchored in a type-ahead name property.
}
sel.TextSelInfo(true, out tssE, out ichE, out fAssocPrev, out hvoObjE, out tagE, out ws);
int cch = tssA.Length;
// To do our type-ahead trick, both ends of the seleciton must be in the same string property.
// Also, we want the selection to extend to the end of the name.
// Enhance JohnT: poupu list may not depend on selection extending to end.
if (tagE != m_taTagName || hvoObjE != hvoObjA || cch != tssE.Length || Math.Max(ichA, ichE) != cch)
{
return(false); // not going to attempt type-ahead behavior
}
// if the key pressed is a backspace or del, prevent smart completion,
// otherwise we are likely to put back what the user deleted.
// Review JohnT: do arrow keys come through here? What do we do if so?
int charT = Convert.ToInt32(e.KeyChar);
if (charT == (int)Keys.Back || charT == (int)Keys.Delete)
{
return(false); // normal key handling will just delete selection. // Review: should backspace delete one more?
}
// OK, we're in a type-ahead situation. First step is to let normal editing take place.
ehelp.OnKeyPress(e, modifiers);
e.Handled = true;
// Now see what we have. Note that our old selection is no longer valid.
sel = rootb.Selection;
if (sel == null)
{
return(true); // can't be smart, but we already did the keypress.
}
int cvsli = sel.CLevels(false);
// CLevels includes the string prop itself, but AllTextSelInfo does not need it.
cvsli--;
// Get selection information to determine where the user is typing.
int ihvoObj;
int tagTextProp;
int cpropPrevious, ichAnchor, ichEnd, ihvoEnd;
ITsTextProps ttp;
SelLevInfo[] rgvsli = SelLevInfo.AllTextSelInfo(sel, cvsli,
out ihvoObj, out tagTextProp, out cpropPrevious, out ichAnchor, out ichEnd,
out ws, out fAssocPrev, out ihvoEnd, out ttp);
if (tagTextProp != m_taTagName || ichAnchor != ichEnd || ihvoEnd != -1 || cvsli < 1)
{
return(true); // something bizarre happened, but keypress is done.
}
int hvoLeaf = rgvsli[0].hvo;
// Get the parent object we will modify.
// (This would usually work, but not if the parent object is the root of the whole display,
// as in a simple atomic ref type ahead slice.
//int hvoParent = rgvsli[1].hvo; // object whose reference property we are setting.)
int tagParent, cpropPreviousDummy, ihvo;
IVwPropertyStore vps;
int hvoParent;
sel.PropInfo(false, 1, out hvoParent, out tagParent, out ihvo, out cpropPreviousDummy, out vps);
if (hvoParent != m_hvoParent)
{
return(true); // another bizarre unexpected event.
}
// This is what the name looks like after the keypress.
ITsString tssTyped = m_sda.get_StringProp(hvoLeaf, m_taTagName);
// Get the substitute. This is where the actual type-ahead behavior happens. Sets hvoNewRef to 0 if no match.
ICmObject objNewRef;
ITsString tssLookup = Lookup(tssTyped, out objNewRef);
int hvoNewRef = (objNewRef != null) ? objNewRef.Hvo : 0;
IVwCacheDa cda = m_sda as IVwCacheDa;
if (hvoNewRef == 0 && tssTyped.Length > 0)
{
// No match...underline string in red squiggle.
ITsStrBldr bldr = tssLookup.GetBldr();
bldr.SetIntPropValues(0, tssLookup.Length, (int)FwTextPropType.ktptUnderline,
(int)FwTextPropVar.ktpvEnum, (int)FwUnderlineType.kuntSquiggle);
bldr.SetIntPropValues(0, tssLookup.Length, (int)FwTextPropType.ktptUnderColor,
(int)FwTextPropVar.ktpvDefault, (int)ColorUtil.ConvertColorToBGR(Color.Red));
tssLookup = bldr.GetString();
}
// Don't rely on sel from here on.
if (hvoNewRef != hvoLeaf)
{
m_hvoTa = hvoNewRef; // Before we replace in the prop, so it gets displayed using special ta prop.
switch (m_type)
{
case CellarPropertyType.ReferenceAtomic:
if (m_hvoParent != 0) // I think it always is, except when loss of focus during debugging causes problems.
{
// If nothing matched, set the real property to null and the fake one to kbaseFakeObj.
// Otherwise set both to the indicated object.
m_sda.SetObjProp(m_hvoParent, m_tag, hvoNewRef); // Review: do we want to set the real thing yet?
m_sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll, m_hvoParent, m_tag, 0, 1, 1);
if (hvoNewRef == 0)
{
hvoNewRef = m_hvoTa = kBaseFakeObj; // use in fake so we can display something.
}
cda.CacheObjProp(m_hvoParent, m_virtualTagObj, hvoNewRef); // Change the fake property
m_sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll, m_hvoParent, m_virtualTagObj, 0, 1, 1);
}
break;
case CellarPropertyType.ReferenceSequence:
case CellarPropertyType.ReferenceCollection:
// Several cases, depending on whether we got a match and whether hvoLeaf is the dummy object
// 1. match on dummy: insert appropriate real object, change dummy name to empty.
// 2. match on non-dummy: replace old object with new
// 3: non-match: do nothing. (Even if not looking at the fake object, we'll go on using the
// actual object as a base for the fake name, since it's displayed only for the active position.)
if (hvoNewRef == 0)
{
break; // case 3
}
if (hvoLeaf == kBaseFakeObj)
{ // case 1
// The fake object goes back to being an empty name at the end of the list.
ITsStrBldr bldr = tssLookup.GetBldr();
bldr.ReplaceTsString(0, bldr.Length, null); // makes an empty string in correct ws.
cda.CacheStringProp(kBaseFakeObj, m_taTagName, bldr.GetString());
// Insert the new object before the fake one in fake prop and at end of real seq.
// Include the fake object in the replace to get it redisplayed also.
cda.CacheReplace(m_hvoParent, m_virtualTagObj, m_ihvoTa, m_ihvoTa + 1, new int[] { hvoNewRef, kBaseFakeObj }, 2);
m_sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll, m_hvoParent, m_virtualTagObj, m_ihvoTa, 2, 1);
m_sda.Replace(m_hvoParent, m_tag, m_ihvoTa, m_ihvoTa, new int[] { hvoNewRef }, 1);
m_sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll, m_hvoParent, m_tag, m_ihvoTa, 1, 0);
}
else
{ // case 2
// Replace the object being edited with the indicated one in both props.
cda.CacheReplace(m_hvoParent, m_virtualTagObj, m_ihvoTa, m_ihvoTa + 1, new int[] { hvoNewRef }, 1);
m_sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll, m_hvoParent, m_virtualTagObj, m_ihvoTa, 1, 1);
m_sda.Replace(m_hvoParent, m_tag, m_ihvoTa, m_ihvoTa + 1, new int[] { hvoNewRef }, 1);
m_sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll, m_hvoParent, m_tag, m_ihvoTa, 1, 1);
}
break;
default:
throw new Exception("unsupported property type for type-ahead chooser");
}
}
cda.CacheStringProp(hvoNewRef, m_taTagName, tssLookup);
m_sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll, hvoNewRef, m_taTagName, 0, tssLookup.Length, tssTyped.Length);
// Make a new selection, typically the range that is the bit added to the typed string.
// no change is needed to rgvsli because it's the same object index in the same property of the same parent.
sel = rootb.MakeTextSelection(ihvoObj, cvsli, rgvsli, m_taTagName, cpropPrevious, ichAnchor,
tssLookup.Length, ws, true, -1, null, true);
return(true);
}
/// <summary>
/// Given a selection (typically from a click), determine the object that should be the target for jumping to,
/// and return the property that was clicked (which in the case of a right-click may generate a spelling menu instead).
/// </summary>
/// <param name="sel"></param>
/// <param name="hvoReal"></param>
/// <returns></returns>
private int GetInfoForJumpToTool(IVwSelection sel, out int hvoReal)
{
int ws;
int tagRightClickTextProp;
bool fAssocPrev;
ITsString tss;
int ichAnchorDum;
int hvoRightClickObject = 0;
sel.TextSelInfo(false, out tss, out ichAnchorDum, out fAssocPrev,
out hvoRightClickObject, out tagRightClickTextProp, out ws);
switch (tagRightClickTextProp)
{
case ktagSbMorphPrefix:
case ktagSbMorphPostfix:
m_hvoRightClickMorph = hvoRightClickObject;
// Pretend we clicked on the morph form. (See LT-7590.)
hvoRightClickObject = Caches.DataAccess.get_ObjectProp(hvoRightClickObject, ktagSbMorphForm);
break;
case ktagSbNamedObjName:
if (sel.CLevels(false) < 2)
break;
int hvoOuterObj, tagOuter, ihvoOuter, cpropPreviousOuter;
IVwPropertyStore vpsDummy;
sel.PropInfo(false, 1, out hvoOuterObj, out tagOuter, out ihvoOuter, out cpropPreviousOuter, out vpsDummy);
if (tagOuter == ktagSbMorphGloss || tagOuter == ktagSbMorphPos || tagOuter == ktagSbMorphForm
|| tagOuter == ktagSbMorphEntry)
{
m_hvoRightClickMorph = hvoOuterObj;
}
break;
default:
m_hvoRightClickMorph = 0;
break;
}
hvoReal = m_caches.RealHvo(hvoRightClickObject);
return tagRightClickTextProp;
}
private bool DeleteFreeform(IVwSelection sel)
{
int hvoAnnotation;
if (!CanDeleteFF(sel, out hvoAnnotation))
return false;
int hvoSeg, tagFF, ihvoFF, cpropPrevious;
IVwPropertyStore vps;
// NOTE: Do not use ihvoFF for updating the cache directly, because the display vector indices
// does not necessarily correspond to the cache vector indices.
sel.PropInfo(false, 1, out hvoSeg, out tagFF, out ihvoFF, out cpropPrevious, out vps);
CmBaseAnnotation seg = new CmBaseAnnotation(Cache, hvoSeg);
CmIndirectAnnotation ft = new CmIndirectAnnotation(Cache, hvoAnnotation);
bool wasFt = ft.AnnotationTypeRAHvo == Cache.GetIdFromGuid(LangProject.kguidAnnFreeTranslation);
StTxtPara para = seg.BeginObjectRA as StTxtPara;
m_fdoCache.DeleteObject(hvoAnnotation);
m_fdoCache.PropChanged(null, PropChangeType.kpctNotifyAll, hvoSeg, tagFF, ihvoFF, 0, 1);
if (wasFt && para != null)
FreeTransEditMonitor.UpdateMainTransFromSegmented(para, Cache.LangProject.CurAnalysisWssRS.HvoArray);
return true; // handled
}