/// ------------------------------------------------------------------------------------
/// <summary>
/// Handles the CellValueNeeded event of the gridInspector control.
/// </summary>
/// ------------------------------------------------------------------------------------
protected override void OnCellValueNeeded(DataGridViewCellValueEventArgs e)
{
e.Value = null;
base.OnCellValueNeeded(e);
if (e.Value != null || m_list == null || m_list.Count <= e.RowIndex)
{
return;
}
IInspectorObject io = m_list[e.RowIndex];
if (io == null)
{
e.Value = "null";
}
else
{
if (e.ColumnIndex == 0)
{
e.Value = io.DisplayName;
}
else if (e.ColumnIndex == 1)
{
e.Value = io.DisplayValue;
}
else
{
e.Value = io.DisplayType;
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Handles the Click event of the m_tsbShowObjInNewWnd control.
/// </summary>
/// ------------------------------------------------------------------------------------
private void m_tsbShowObjInNewWnd_Click(object sender, EventArgs e)
{
InspectorWnd wnd = m_dockPanel.ActiveContent as InspectorWnd;
if (wnd == null)
{
return;
}
IInspectorObject io = wnd.CurrentInspectorObject;
if (io == null || io.Object == null)
{
return;
}
string text = io.DisplayName;
if (text.StartsWith("[") && text.EndsWith("]"))
{
text = text.Trim('[', ']');
int i;
if (int.TryParse(text, out i))
{
text = null;
}
}
if (text != null && text != io.DisplayType)
{
text += (": " + io.DisplayType);
}
m_InspectorWnd = ShowNewInspectorWindow(io.Object, text);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Handles the Opening event of the grid's context menu.
/// </summary>
/// ------------------------------------------------------------------------------------
protected virtual void HandleOpenObjectInNewWindowContextMenuClick(object sender, CancelEventArgs e)
{
InspectorWnd wnd = m_dockPanel.ActiveContent as InspectorWnd;
if (wnd != null)
{
IInspectorObject io = wnd.CurrentInspectorObject;
cmnuShowInNewWindow.Enabled = (io != null && io.Object != null);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Raises the <see cref="E:System.Windows.Forms.DataGridView.CellClick"/> event.
/// </summary>
/// ------------------------------------------------------------------------------------
protected override void OnCellClick(DataGridViewCellEventArgs e)
{
base.OnCellClick(e);
if (e.ColumnIndex != 0)
{
return;
}
IInspectorObject io = m_list[e.RowIndex];
Rectangle rc = GetCellDisplayRectangle(0, e.RowIndex, true);
Rectangle rcHotSpot = GetExpandCollapseRect(rc, io.Level);
if (rcHotSpot.Contains(PointToClient(MousePosition)))
{
ToggleExpand(e.RowIndex);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Create the reference collectiomn list for ther custom reference collection.,
/// </summary>
/// ------------------------------------------------------------------------------------
protected virtual List<IInspectorObject> GetInspectorObjectsForCustomRC(object obj, IInspectorObject ioParent, int level)
{
List<IInspectorObject> list = new List<IInspectorObject>();
int n = 0;
int hvoNum = 0;
;
if (obj == null)
return null;
// Inspectors for custom reference collections are supposed to be configured with
// obj being an array of the HVOs.
var collection = obj as ICollection;
if (collection == null)
{
MessageBox.Show("Custom Reference collection not properly configured with array of HVOs");
return null;
}
// Just like an ordinary reference collection, we want to make one inspector for each
// item in the collection, where the first argument to CreateInspectorObject is the
// cmObject. Keep this code in sync with BaseGetInspectorObjects.
foreach (int hvoItem in collection)
{
hvoNum = Int32.Parse(hvoItem.ToString());
var objItem = m_cache.ServiceLocator.GetObject(hvoNum);
IInspectorObject io = CreateInspectorObject(objItem, obj, ioParent, level);
io.DisplayName = string.Format("[{0}]", n++);
list.Add(io);
}
return list;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Condenses the 'Run' information for MultiUnicodeAccessor entries because
/// there will only be 1 run,
/// </summary>
/// ------------------------------------------------------------------------------------
protected virtual List<IInspectorObject> GetInspectorObjectsForUniRuns(ITsString obj, IInspectorObject ioParent, int level)
{
List<IInspectorObject> list = new List<IInspectorObject>();
if (obj != null)
{
IInspectorObject ino = CreateInspectorObject(obj, ioParent.OwningObject, ioParent, level);
ino.DisplayName = "Writing System";
ino.DisplayValue = obj.get_WritingSystemAt(0).ToString();
ino.HasChildren = false;
list.Add(ino);
TsStringRunInfo tss = new TsStringRunInfo(0, obj, m_cache);
ino = CreateInspectorObject(tss, obj, ioParent, level);
ino.DisplayName = "Text";
ino.DisplayValue = tss.Text;
ino.HasChildren = false;
list.Add(ino);
}
return list;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets a list of IInspectorObject objects representing all the properties for the
/// specified object, which is assumed to be at the specified level.
/// </summary>
/// ------------------------------------------------------------------------------------
protected virtual List<IInspectorObject> GetInspectorObjectsForValues(object obj, IInspectorObject ioParent, int level)
{
if (ioParent != null)
obj = ioParent.Object;
List<IInspectorObject> list = new List<IInspectorObject>();
IMultiAccessorBase multiStr = ioParent.OwningObject as IMultiAccessorBase;
if (multiStr != null)
{
foreach (int ws in multiStr.AvailableWritingSystemIds)
{
IWritingSystem wsObj = m_cache.ServiceLocator.WritingSystemManager.Get(ws);
IInspectorObject ino = CreateInspectorObject(multiStr.get_String(ws), obj, ioParent, level);
ino.DisplayName = wsObj.DisplayLabel;
list.Add(ino);
}
return list;
}
PropertyInfo[] props = GetPropsForObj(obj);
foreach (PropertyInfo pi in props)
{
try
{
object propObj = pi.GetValue(obj, null);
list.Add(CreateInspectorObject(pi, propObj, obj, ioParent, level));
}
catch (Exception e)
{
list.Add(CreateExceptionInspectorObject(e, obj, pi.Name, level, ioParent));
}
}
list.Sort(CompareInspectorObjectNames);
return list;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the inspector objects for the specified TextProps.
/// </summary>
/// ------------------------------------------------------------------------------------
private List<IInspectorObject> GetInspectorObjectsForTextProps(TextProps txp,
IInspectorObject ioParent, int level)
{
int saveIntPropCount = 0, saveStrPropCount = 0;
//IInspectorObject ioParent = txp as IInspectorObject;
if (ioParent != null)
txp = ioParent.Object as TextProps;
List<IInspectorObject> list = new List<IInspectorObject>();
IInspectorObject io;
ICollection txp1 = txp as ICollection;
if (txp1 != null)
{
int i = 0;
foreach (object item in txp1)
{
io = CreateInspectorObject(item, txp, ioParent, level);
io.DisplayName = string.Format("[{0}]", i++);
list.Add(io);
}
return list;
}
PropertyInfo[] props = GetPropsForObj(txp);
foreach (PropertyInfo pi in props)
{
if (pi.Name != "IntProps" && pi.Name != "StrProps" && pi.Name != "IntPropCount" && pi.Name != "StrPropCount")
continue;
else
switch (pi.Name)
{
case "IntProps":
object propObj = pi.GetValue(txp, null);
io = CreateInspectorObject(pi, propObj, txp, ioParent, level);
io.DisplayValue = "Count = " + saveIntPropCount.ToString();
io.HasChildren = (saveIntPropCount > 0);
list.Add(io);
break;
case "StrProps":
object propObj1 = pi.GetValue(txp, null);
io = CreateInspectorObject(pi, propObj1, txp, ioParent, level);
io.DisplayValue = "Count = " + saveStrPropCount.ToString();
io.HasChildren = (saveStrPropCount > 0);
list.Add(io);
break;
case "StrPropCount":
saveStrPropCount = (int)pi.GetValue(txp, null);
break;
case "IntPropCount":
saveIntPropCount = (int)pi.GetValue(txp, null);
break;
}
}
list.Sort(CompareInspectorObjectNames);
return list;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the inspector objects for the specified TsString.
/// </summary>
/// ------------------------------------------------------------------------------------
private List<IInspectorObject> GetInspectorObjectsForTsString(ITsString tss,
IInspectorObject ioParent, int level)
{
List<IInspectorObject> list = new List<IInspectorObject>();
int runCount = tss.RunCount;
List<TsStringRunInfo> tssriList = new List<TsStringRunInfo>();
for (int i = 0; i < runCount; i++)
tssriList.Add(new TsStringRunInfo(i, tss, m_cache));
IInspectorObject io = CreateInspectorObject(tssriList, tss, ioParent, level);
io.DisplayName = "Runs";
io.DisplayValue = FormatCountString(tssriList.Count);
io.HasChildren = (tssriList.Count > 0);
list.Add(io);
if (ObjectBrowser.m_virtualFlag == true)
{
io = CreateInspectorObject(tss.Length, tss, ioParent, level);
io.DisplayName = "Length";
list.Add(io);
io = CreateInspectorObject(tss.Text, tss, ioParent, level);
io.DisplayName = "Text";
list.Add(io);
}
return list;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Handles the CellPainting event of the dataGridView1 control.
/// </summary>
/// ------------------------------------------------------------------------------------
protected override void OnCellPainting(DataGridViewCellPaintingEventArgs e)
{
base.OnCellPainting(e);
if (e.Handled || e.RowIndex < 0 || e.ColumnIndex < 0 || m_list == null ||
m_list.Count == 0 || m_list[e.RowIndex] == null)
{
return;
}
e.Handled = true;
// Paint everything but the focus rectangle, foreground and background.
// I'm not sure what's left, but just in case...
DataGridViewPaintParts parts = e.PaintParts;
parts &= ~DataGridViewPaintParts.Focus;
parts &= ~DataGridViewPaintParts.Background;
parts &= ~DataGridViewPaintParts.ContentForeground;
e.Paint(e.CellBounds, parts);
e.PaintBackground(e.CellBounds, false);
IInspectorObject io = m_list[e.RowIndex];
Rectangle rcText = e.CellBounds;
Rectangle rcHotSpot = Rectangle.Empty;
bool isSelected = ((e.State & DataGridViewElementStates.Selected) > 0);
bool isInBlock = (!isSelected && e.RowIndex >= m_firstRowInShadind && e.RowIndex <= m_lastRowInShading);
bool isIndentedCell = (e.ColumnIndex == 0);
if (isIndentedCell)
{
// Calculate the location and size of the rectangle into which text will be drawn.
// Adjust the text rectangle to account for the +/- image and the proper indent level.
rcHotSpot = GetExpandCollapseRect(e.CellBounds, io.Level);
int dx = ((rcHotSpot.Right - rcText.X) + 5);
rcText.X += dx;
rcText.Width -= dx;
}
// Draw the background color for the cell.
using (SolidBrush br = new SolidBrush(DefaultCellStyle.BackColor))
{
if (isSelected)
{
br.Color = DefaultCellStyle.SelectionBackColor;
}
else if (isInBlock && m_clrShading != Color.Empty)
{
br.Color = m_clrShading;
}
e.Graphics.FillRectangle(br, rcText);
}
Color clrFore = (isSelected ? e.CellStyle.SelectionForeColor : e.CellStyle.ForeColor);
TextFormatFlags flags = TextFormatFlags.Left | TextFormatFlags.VerticalCenter |
TextFormatFlags.EndEllipsis | TextFormatFlags.SingleLine;
TextRenderer.DrawText(e.Graphics, e.FormattedValue as string,
e.CellStyle.Font, rcText, clrFore, flags);
DrawBorders(e, isIndentedCell,
(isInBlock && m_clrShading != Color.Empty ? m_clrShading : GridColor),
(isInBlock ? rcText.X: rcHotSpot.X));
if (!isIndentedCell)
{
return;
}
DrawTreeLines(e, rcHotSpot, io.Level);
if (io.HasChildren)
{
// Draw the expand or collapse (+/-) image.
e.Graphics.DrawImage(m_list.IsExpanded(e.RowIndex) ?
Properties.Resources.kimidCollapse : Properties.Resources.kimidExpand, rcHotSpot);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Process lines that have a DateTime type.
/// </summary>
/// ------------------------------------------------------------------------------------
private List<IInspectorObject> GetInspectorObjectForDateTime(DateTime tmpObj,
IInspectorObject ioParent, int level)
{
List<IInspectorObject> list = new List<IInspectorObject>();
IInspectorObject io = CreateInspectorObject(tmpObj, null, ioParent, level);
//io.DisplayName = tmpObj.;
//io.DisplayValue = FormatCountString(allStrings.Count);
io.HasChildren = false;
list.Add(io);
return list;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the inspector objects for the specified repository object;
/// </summary>
/// ------------------------------------------------------------------------------------
private List<IInspectorObject> GetInspectorObjectsForRepository(object obj,
IInspectorObject ioParent, int level)
{
int i = 0;
List<IInspectorObject> list = new List<IInspectorObject>();
foreach (object instance in GetRepositoryInstances(obj))
{
IInspectorObject io = CreateInspectorObject(instance, obj, ioParent, level);
if (ObjectBrowser.m_virtualFlag == false && obj.ToString().IndexOf("LexSenseRepository") > 0)
{
ILexSense tmpObj = io.Object as ILexSense;
io.DisplayValue = tmpObj.FullReferenceName.Text;
io.DisplayName = string.Format("[{0}]: {1}", i++, GetObjectOnly(tmpObj.ToString()));
}
else if (ObjectBrowser.m_virtualFlag == false && obj.ToString().IndexOf("LexEntryRepository") > 0 )
{
ILexEntry tmpObj = io.Object as ILexEntry;
io.DisplayValue = tmpObj.HeadWord.Text;
io.DisplayName = string.Format("[{0}]: {1}", i++, GetObjectOnly(tmpObj.ToString()));
}
else
io.DisplayName = string.Format("[{0}]", i++);
list.Add(io);
}
i = IndexOf(obj);
if (i >= 0)
{
this[i].DisplayValue = FormatCountString(list.Count);
this[i].HasChildren = (list.Count > 0);
}
return list;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Refreshes the view.
/// This overload specifies the type of action that triggered this method.
/// This is needed because the key changes during adds, updates, and moves.
/// </summary>
/// ------------------------------------------------------------------------------------
public void RefreshView(string type)
{
int mFirstDisplayIndex = 0, mCurrentDisplayIndex = 0;
// Get the object that's displayed in the first visible row of the grid.
mFirstDisplayIndex = gridInspector.FirstDisplayedScrollingRowIndex;
// Get the current, selected row in the grid.
IInspectorObject currSelectedObj = gridInspector.CurrentObject;
// If type is "Up", "Down", or "Delete", use parent as the selected/current row.
// If so, then save a reference to the selected object's parent object.
if (type == "Up" || type == "Down" || type == "Delete" && (currSelectedObj != null))
{
currSelectedObj = currSelectedObj.ParentInspectorObject;
}
if (currSelectedObj != null)
{
for (int i = 0; i < m_list.Count; i++)
{
if (m_list[i].Key == currSelectedObj.Key)
{
mCurrentDisplayIndex = i;
break;
}
}
}
// Save all the expanded objects.
List <int> expandedObjects = new List <int>();
for (int i = 0; i < m_list.Count; i++)
{
if (m_list.IsExpanded(i))
{
expandedObjects.Add(i);
}
}
if (type == "Add")
{
expandedObjects.Add(mCurrentDisplayIndex);
}
m_list.Initialize(m_list.TopLevelObject);
// Now that the list is rebuilt, go through the list of objects that
// were previously expanded and expand them again.
int firstRow = 0;
int currRow = 0;
int irow = 0;
for (irow = 0; irow < m_list.Count; irow++)
{
IInspectorObject io = m_list[irow];
int index = expandedObjects.IndexOf(irow);
if (index >= 0)
{
m_list.ExpandObject(irow);
expandedObjects.RemoveAt(index);
}
if (irow == mFirstDisplayIndex)
{
firstRow = irow;
}
if (irow == mCurrentDisplayIndex)
{
currRow = irow;
}
}
gridInspector.SuspendLayout();
gridInspector.List = m_list;
gridInspector.FirstDisplayedScrollingRowIndex = firstRow;
gridInspector.CurrentCell = gridInspector[0, currRow];
gridInspector.ResumeLayout();
}
///// ------------------------------------------------------------------------------------
///// <summary>
///// Handles the KeyPress event of the tstxtSearch control.
///// </summary>
///// <param name="sender">The source of the event.</param>
///// <param name="e">The <see cref="System.Windows.Forms.KeyPressEventArgs"/> instance containing the event data.</param>
///// ------------------------------------------------------------------------------------
//private void tstxtSearch_KeyPress(object sender, KeyPressEventArgs e)
//{
// if (e.KeyChar != (char)Keys.Enter)
// return;
// Guid guid = new Guid(tstxtSearch.Text.Trim());
// int i = m_list.GotoGuid(guid);
// if (i >= 0)
// {
// gridInspector.RowCount = m_list.Count;
// gridInspector.Invalidate();
// gridInspector.CurrentCell = gridInspector[0, i];
// }
//}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Refreshes the view.
/// </summary>
/// ------------------------------------------------------------------------------------
public void RefreshView()
{
// Get the object that's displayed in the first visible row of the grid.
IInspectorObject firstDisplayedObj =
m_list[gridInspector.FirstDisplayedScrollingRowIndex];
// Get the current, selected row in the grid.
IInspectorObject currSelectedObj = gridInspector.CurrentObject;
if (currSelectedObj != null && WillObjDisappearOnRefresh != null)
{
// Check if the selected object will disappear after refreshing the grid.
// If so, then save a reference to the selected object's parent object.
if (WillObjDisappearOnRefresh(this, currSelectedObj))
{
currSelectedObj = m_list.GetParent(gridInspector.CurrentCellAddress.Y);
}
}
int keyFirstDisplayedObj = (firstDisplayedObj != null ? firstDisplayedObj.Key : -1);
int keyCurrSelectedObj = (currSelectedObj != null ? currSelectedObj.Key : -1);
// Save all the expanded objects.
List <int> expandedObjects = new List <int>();
for (int i = 0; i < m_list.Count; i++)
{
if (m_list.IsExpanded(i))
{
expandedObjects.Add(m_list[i].Key);
}
}
m_list.Initialize(m_list.TopLevelObject);
// Now that the list is rebuilt, go through the list of objects that
// were previously expanded and expand them again.
int firstRow = 0;
int currRow = 0;
int irow = 0;
while (++irow < m_list.Count)
{
IInspectorObject io = m_list[irow];
int key = io.Key;
int index = expandedObjects.IndexOf(key);
if (index >= 0)
{
m_list.ExpandObject(irow);
expandedObjects.RemoveAt(index);
}
if (key == keyFirstDisplayedObj)
{
firstRow = irow;
}
if (key == keyCurrSelectedObj)
{
currRow = irow;
}
}
gridInspector.SuspendLayout();
gridInspector.List = m_list;
gridInspector.FirstDisplayedScrollingRowIndex = firstRow;
gridInspector.CurrentCell = gridInspector[0, currRow];
gridInspector.ResumeLayout();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Create InspectorObjects for the custom fields for the current object.
/// </summary>
/// ------------------------------------------------------------------------------------
private IInspectorObject CreateCustomInspectorObject(object obj, IInspectorObject ParentIo,
int level, CustomFields cf)
{
ICmObject to = obj as ICmObject;
var mdc = m_cache.ServiceLocator.GetInstance<IFwMetaDataCacheManaged>();
ICmPossibility fColl = null;
int mws = 0;
var iValue = "";
string className = mdc.GetClassName(cf.ClassID);
int Flid = cf.FieldID;
IInspectorObject io = null;
if (obj != null)
{
switch (cf.Type)
{
case "ITsString":
ITsString oValue = m_cache.DomainDataByFlid.get_StringProp(to.Hvo, Flid);
io = base.CreateInspectorObject(null, oValue, obj, ParentIo, level);
iValue = oValue.Text;
io.HasChildren = false;
io.DisplayName = cf.Name;
break;
case "System.Int32":
int sValue = m_cache.DomainDataByFlid.get_IntProp(to.Hvo, Flid);
io = base.CreateInspectorObject(null, sValue, obj, ParentIo, level);
iValue = sValue.ToString();
io.HasChildren = false;
io.DisplayName = cf.Name;
break;
case "SIL.FieldWorks.Common.FwUtils.GenDate":
// tried get_TimeProp, get_UnknowbProp, get_Prop
GenDate genObj = ((ISilDataAccessManaged)m_cache.DomainDataByFlid).get_GenDateProp(to.Hvo, Flid);
io = base.CreateInspectorObject(null, genObj, obj, ParentIo, level);
iValue = genObj.ToString();
io.HasChildren = true;
io.DisplayName = cf.Name;
break;
case "FdoReferenceCollection<ICmPossibility>": // ReferenceCollection
int count = m_cache.DomainDataByFlid.get_VecSize(to.Hvo, Flid);
iValue = "Count = " + count.ToString();
var objects = ((ISilDataAccessManaged) m_cache.DomainDataByFlid).VecProp(to.Hvo, Flid);
objects.Initialize();
//int rcHvo = m_cache.DomainDataByFlid.get_ObjectProp(to.Hvo, Flid);
//IFdoReferenceCollection<ICmPossibility> RCObj = (rcHvo == 0? null: (IFdoReferenceCollection<ICmPossibility>)m_cache.ServiceLocator.GetObject(rcHvo));
io = base.CreateInspectorObject(null, objects, obj, ParentIo, level);
io.HasChildren = (count > 0? true: false);
io.DisplayName = cf.Name+ "RC";
break;
case "ICmPossibility": // ReferenceAtomic
int rValue = m_cache.DomainDataByFlid.get_ObjectProp(to.Hvo, Flid);
ICmPossibility posObj = (rValue == 0? null: (ICmPossibility)m_cache.ServiceLocator.GetObject(rValue));
io = base.CreateInspectorObject(null, posObj, obj, ParentIo, level);
iValue = (posObj == null? "null": posObj.NameHierarchyString);
io.HasChildren = (posObj == null? false: true);
io.DisplayName = cf.Name+ "RA";
break;
case "IStText": // multi-paragraph text (OA) StText)
int mValue = m_cache.DomainDataByFlid.get_ObjectProp(to.Hvo, Flid);
IStText paraObj = (mValue == 0? null: (IStText)m_cache.ServiceLocator.GetObject(mValue));
io = base.CreateInspectorObject(null, paraObj, obj, ParentIo, level);
iValue = (paraObj == null? "null": "StText: " + paraObj.Hvo.ToString());
io.HasChildren = (mValue > 0? true: false);
io.DisplayName = cf.Name + "OA";
break;
default:
MessageBox.Show(string.Format("The type of the custom field is {0}", cf.Type));
break;
}
}
io.DisplayType = cf.Type;
io.DisplayValue = (iValue ?? "null");
io.Flid = cf.FieldID;
return io;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets an inspector object for the specified property info., checking for various
/// FDO interface types.
/// </summary>
/// ------------------------------------------------------------------------------------
protected override IInspectorObject CreateInspectorObject(PropertyInfo pi,
object obj, object owningObj, IInspectorObject ioParent, int level)
{
IInspectorObject io = base.CreateInspectorObject(pi, obj, owningObj, ioParent, level);
if (pi == null && io != null)
io.DisplayType = StripOffFDONamespace(io.DisplayType);
else if (pi != null && io == null)
io.DisplayType = pi.PropertyType.Name;
else if (pi != null && io != null)
io.DisplayType = (io.DisplayType == "System.__ComObject" ?
pi.PropertyType.Name : StripOffFDONamespace(io.DisplayType));
if (obj == null)
return io;
if (obj is char)
{
io.DisplayValue = string.Format("'{0}' (U+{1:X4})", io.DisplayValue, (int)((char)obj));
return io;
}
if (obj is IFdoVector)
{
MethodInfo mi = obj.GetType().GetMethod("ToArray");
try
{
ICmObject[] array = mi.Invoke(obj, null) as ICmObject[];
io.Object = array;
io.DisplayValue = FormatCountString(array.Length);
io.HasChildren = (array.Length > 0);
}
catch (Exception e)
{
io = CreateExceptionInspectorObject(e, obj, pi.Name, level, ioParent);
}
}
else if (obj is ICollection<ICmObject>)
{
var array = ((ICollection<ICmObject>)obj).ToArray();
io.Object = array;
io.DisplayValue = FormatCountString(array.Length);
io.HasChildren = array.Length > 0;
}
string fmtAppend = "{0}, {{{1}}}";
string fmtReplace = "{0}";
string fmtStrReplace = "\"{0}\"";
if (obj is ICmFilter)
{
ICmFilter filter = (ICmFilter)obj;
io.DisplayValue = string.Format(fmtAppend, io.DisplayValue, filter.Name);
}
else if (obj is IMultiAccessorBase)
{
IMultiAccessorBase str = (IMultiAccessorBase)obj;
io.DisplayValue = string.Format(fmtReplace,
str.AnalysisDefaultWritingSystem.Text);
}
else if (obj is ITsString)
{
ITsString str = (ITsString)obj;
io.DisplayValue = string.Format(fmtStrReplace, str.Text);
io.HasChildren = true;
}
else if (obj is ITsTextProps)
{
io.Object = new TextProps(obj as ITsTextProps, m_cache);
io.DisplayValue = string.Empty;
io.HasChildren = true;
}
else if (obj is IPhNCSegments)
{
IPhNCSegments seg = (IPhNCSegments)obj;
io.DisplayValue = string.Format(fmtAppend, io.DisplayValue,
seg.Name.AnalysisDefaultWritingSystem.Text);
}
else if (obj is IPhEnvironment)
{
IPhEnvironment env = (IPhEnvironment)obj;
io.DisplayValue = string.Format("{0}, {{Name: {1}, Pattern: {2}}}",
io.DisplayValue, env.Name.AnalysisDefaultWritingSystem.Text,
env.StringRepresentation.Text);
}
else if (obj is IMoEndoCompound)
{
IMoEndoCompound moendo = (IMoEndoCompound)obj;
io.DisplayValue = string.Format(fmtAppend, io.DisplayValue,
moendo.Name.AnalysisDefaultWritingSystem.Text);
}
else if (obj.GetType().GetInterface("IRepository`1") != null)
{
io.DisplayName = io.DisplayType;
}
return io;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the inspector objects for the specified MultiString.
/// </summary>
/// ------------------------------------------------------------------------------------
private List<IInspectorObject> GetInspectorObjectsForMultiString(IMultiAccessorBase msa,
IInspectorObject ioParent, int level)
{
List<IInspectorObject> list = new List<IInspectorObject>();
int ws;
if (ObjectBrowser.m_virtualFlag == false)
list = GetMultiStringInspectorObjects(msa, ioParent, level);
else
list = BaseGetInspectorObjects(msa, level);
Dictionary<int, string> allStrings = new Dictionary<int, string>();
try
{
// Put this in a try/catch because VirtualStringAccessor
// didn't implement StringCount when this was written.
for (int i = 0; i < msa.StringCount; i++)
{
ITsString tss = msa.GetStringFromIndex(i, out ws);
allStrings[ws] = tss.Text;
}
}
catch { }
if (ObjectBrowser.m_virtualFlag == true)
{
IInspectorObject io = CreateInspectorObject(allStrings, msa, ioParent, level);
io.DisplayName = "AllStrings";
io.DisplayValue = FormatCountString(allStrings.Count);
io.HasChildren = (allStrings.Count > 0);
list.Insert(0, io);
list.Sort((x, y) => x.DisplayName.CompareTo(y.DisplayName));
}
return list;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets a list of IInspectorObject objects (same as base), but includes s lot of
/// specifics if you choose not to see virtual fields.
/// </summary>
/// ------------------------------------------------------------------------------------
private List<IInspectorObject> GetMultiStringInspectorObjects(object obj, IInspectorObject ioParent, int level)
{
if (ioParent != null)
obj = ioParent.Object;
List<IInspectorObject> list = new List<IInspectorObject>();
ICollection collection = obj as ICollection;
if (collection != null)
{
int i = 0;
foreach (object item in collection)
{
IInspectorObject io = CreateInspectorObject(item, obj, ioParent, level);
io.DisplayName = string.Format("[{0}]", i++);
list.Add(io);
}
return list;
}
PropertyInfo[] props = GetPropsForObj(obj);
foreach (PropertyInfo pi in props)
{
try
{
object propObj = pi.GetValue(obj, null);
IInspectorObject Itmp = CreateInspectorObject(pi, propObj, obj, ioParent, level);
if ((obj.ToString().IndexOf("MultiUnicodeAccessor") > 0 && Itmp.DisplayName != "Values") ||
(obj.ToString().IndexOf("MultiStringAccessor") > 0 && Itmp.DisplayName != "Values"))
continue;
else
{
ICollection Itmp4 = Itmp.Object as ICollection;
if (Itmp4 != null)
{
Itmp.DisplayValue = "Count = " + Itmp4.Count;
Itmp.HasChildren = (Itmp4.Count > 0);
}
}
list.Add(Itmp);
}
catch (Exception e)
{
continue;
}
}
list.Sort(CompareInspectorObjectNames);
return list;
}
/// <summary>
/// Displays the specified object and all its public properties in the
/// inspector.
/// </summary>
/// <param name="obj">The object to display.</param>
public void Show(IInspectorObject obj)
{
Grid.SelectedObject = obj;
}
