public void PopulateData_LoadMode_ChainsToAddElementAndChildrenIntoList_CorrectParameters()
{
using (ShimsContext.Create())
{
const DataContextMode expectedDcMode = DataContextMode.Load;
const TreeViewMode expectedTreeViewMode = TreeViewMode.Control;
A11yElement expectedElement = new A11yElement();
ElementDataContext dataContext = new ElementDataContext(expectedElement, 1);
A11yElement actualElement = null;
BoundedCounter actualCounter = null;
Dictionary <int, A11yElement> actualDictionary = null;
ShimCaptureAction.AddElementAndChildrenIntoListA11yElementDictionaryOfInt32A11yElementBoundedCounter = (e, d, c) =>
{
actualElement = e;
actualDictionary = d;
actualCounter = c;
};
CaptureAction.PopulateData(dataContext, expectedDcMode, expectedTreeViewMode);
Assert.AreEqual(expectedDcMode, dataContext.Mode);
Assert.AreEqual(expectedTreeViewMode, dataContext.TreeMode);
Assert.AreSame(expectedElement, actualElement);
Assert.IsNotNull(actualDictionary);
Assert.IsFalse(actualDictionary.Any());
Assert.AreSame(dataContext.ElementCounter, actualCounter);
Assert.AreSame(dataContext.Elements, actualDictionary);
}
}
IHttpActionResult CaptureData(Guid id,
DataContextMode dm,
TreeViewMode tvm,
bool force)
{
try
{
if (CaptureAction.SetTestModeDataContext(id, dm, tvm, force))
{
if (dm == DataContextMode.Test)
{
var dc = GetDataAction.GetElementDataContext(id);
dc.PublishScanResults();
}
return(Ok());
}
else
{
return(StatusCode(HttpStatusCode.NotModified));
}
}
catch (Exception ex)
{
return(BadRequest(ex.ToString()));
}
}
/// <summary>
/// Constructor DesktopElementAncestry
/// Get Ancestry Tree elements up to Desktop(at best)
/// </summary>
/// <param name="walker"></param>
/// <param name="e"></param>
public DesktopElementAncestry(TreeViewMode mode, A11yElement e, bool setMem = false)
{
this.TreeWalker = A11yAutomation.GetTreeWalker(mode);
this.TreeWalkerMode = mode;
this.Items = new List <A11yElement>();
this.SetMembers = setMem;
SetParent(e, -1);
if (Items.Count != 0)
{
this.First = Items.Last();
this.Last = Items.First();
if (this.Last.IsRootElement() == false)
{
this.Last.Children.Clear();
this.NextId = PopulateSiblingTreeNodes(this.Last, e);
}
else
{
this.NextId = 1;
}
}
Marshal.ReleaseComObject(this.TreeWalker);
}
public void SetTestModeDataContext_ForLoadDataContextMode_WalksTheOriginAncestorsChildrenDirectly(
bool force,
bool startWithNullDataContext,
DataContextMode originalDataContextMode,
TreeViewMode originalDataContextTreeViewMode)
{
// Arrange
if (startWithNullDataContext)
{
mockElementContext.DataContext = null;
}
mockDataContext.Mode = originalDataContextMode;
mockDataContext.TreeMode = originalDataContextTreeViewMode;
TreeViewMode treeViewMode = TreeViewMode.Raw;
var mockOriginAncestor = mockElement;
mockOriginAncestor.UniqueId = 1;
var mockChild1 = new A11yElement();
mockChild1.UniqueId = 2;
var mockChild2 = new A11yElement();
mockChild2.UniqueId = 3;
var mockGrandChild1 = new A11yElement();
mockGrandChild1.UniqueId = 4;
mockOriginAncestor.Children = new List <A11yElement>()
{
mockChild1, mockChild2
};
mockChild2.Children = new List <A11yElement>()
{
mockGrandChild1
};
using (new CaptureActionTestHookOverrides(() => mockDataManager, null, null))
{
// Act
bool retVal = CaptureAction.SetTestModeDataContext(mockElementContext.Id, DataContextMode.Load, treeViewMode, force);
// Assert
Assert.IsTrue(retVal);
Assert.IsNotNull(mockElementContext.DataContext);
Assert.AreNotSame(mockDataContext, mockElementContext.DataContext);
var result = mockElementContext.DataContext;
Assert.AreSame(mockElement, result.Element);
Assert.AreEqual(20000, result.ElementCounter.UpperBound);
Assert.AreEqual(treeViewMode, result.TreeMode);
Assert.AreEqual(DataContextMode.Load, result.Mode);
Assert.AreEqual(mockOriginAncestor, result.RootElment);
Assert.AreEqual(4, result.Elements.Count);
Assert.AreSame(mockOriginAncestor, result.Elements[mockOriginAncestor.UniqueId]);
Assert.AreSame(mockChild1, result.Elements[mockChild1.UniqueId]);
Assert.AreSame(mockChild2, result.Elements[mockChild2.UniqueId]);
Assert.AreSame(mockGrandChild1, result.Elements[mockGrandChild1.UniqueId]);
}
}
/// <summary>
/// Populate Data Context for Live Mode.
/// </summary>
/// <param name="dc"></param>
/// <param name="mode"></param>
static void PopulateDataContextForLiveMode(ElementDataContext dc, TreeViewMode mode)
{
dc.TreeMode = mode;
dc.Mode = DataContextMode.Live;
var ltw = NewTreeWalkerForLive();
ltw.GetTreeHierarchy(dc.Element, mode);
dc.RootElment = ltw.RootElement;
dc.Elements = ltw.Elements.ToDictionary(i => i.UniqueId);
ltw.Elements.Clear();
}
private static void SetTreeViewModeOnSelectAction(TreeViewMode mode)
{
var selectAction = SelectAction.GetDefaultInstance();
if (selectAction == null)
{
return;
}
selectAction.TreeViewMode = mode;
}
/// <summary>
/// Update Data context in given ElementContext for Live Mode
/// if Data Context is already up to date based on parameters, just skip.
/// </summary>
/// <param name="ecId">Element Context Id</param>
/// <param name="mode"></param>
/// <param name="force">Force the update</param>
/// <returns></returns>
public static void SetLiveModeDataContext(Guid ecId, TreeViewMode mode, bool force = false)
{
var ec = GetDataManager().GetElementContext(ecId);
if (NeedNewDataContext(ec.DataContext, DataContextMode.Live, mode) || force)
{
var dc = new ElementDataContext(ec.Element, MaxElements);
PopulateDataContextForLiveMode(dc, mode);
ec.DataContext = dc;
}
}
/// <summary>
/// Request Refresh at Tree view mode change.
/// </summary>
/// <param name="mode"></param>
private void RequestRefreshBasedOnTreeViewChange(TreeViewMode mode)
{
Configuration.TreeViewMode = mode;
SetTreeViewModeOnSelectAction(mode);
SetFocusOnHierarchyTree();
if (this.SelectedElement != null)
{
// refresh tree automatically.
this.HierarchyActions.RefreshHierarchy(true);
}
}
/// <summary>
/// Normalize an element to the specified TreeViewMode
/// </summary>
/// <param name="element">A11yElement</param>
/// <param name="treeViewMode">mode to normalize to</param>
/// <returns></returns>
public static A11yElement GetNormalizedElement(A11yElement element, TreeViewMode treeViewMode)
{
if (element == null)
{
throw new ArgumentNullException(nameof(element));
}
var walker = GetTreeWalker(treeViewMode);
var normalizedElement = walker.NormalizeElement((IUIAutomationElement)element.PlatformObject);
Marshal.ReleaseComObject(walker);
return(new DesktopElement(normalizedElement, true));
}
public void SetTestModeDataContext_ForTestDataContextMode_UsesTreeWalkerForTestToCreateNewDataContext(
bool force,
bool startWithNullDataContext,
DataContextMode originalDataContextMode,
TreeViewMode originalDataContextTreeViewMode)
{
// Arrange
if (startWithNullDataContext)
{
mockElementContext.DataContext = null;
}
mockDataContext.Mode = originalDataContextMode;
mockDataContext.TreeMode = originalDataContextTreeViewMode;
TreeViewMode treeViewMode = TreeViewMode.Raw;
var mockTreeWalkerForTest = new Mock <ITreeWalkerForTest>();
var mockTopMostElement = new A11yElement();
var mockElementsItem1 = new A11yElement();
mockElementsItem1.UniqueId = 101;
var mockElementsItem2 = new A11yElement();
mockElementsItem2.UniqueId = 102;
mockTreeWalkerForTest.Setup(w => w.Elements).Returns(new List <A11yElement> {
mockElementsItem1, mockElementsItem2
});
mockTreeWalkerForTest.Setup(w => w.TopMostElement).Returns(mockTopMostElement);
using (new CaptureActionTestHookOverrides(() => mockDataManager, null, (_1, _2) => mockTreeWalkerForTest.Object))
{
// Act
bool retVal = CaptureAction.SetTestModeDataContext(mockElementContext.Id, DataContextMode.Test, treeViewMode, force);
// Assert
Assert.IsTrue(retVal);
Assert.IsNotNull(mockElementContext.DataContext);
Assert.AreNotSame(mockDataContext, mockElementContext.DataContext);
var result = mockElementContext.DataContext;
Assert.AreSame(mockElement, result.Element);
Assert.AreEqual(20000, result.ElementCounter.UpperBound);
Assert.AreEqual(treeViewMode, result.TreeMode);
Assert.AreEqual(DataContextMode.Test, result.Mode);
Assert.AreEqual(mockTopMostElement, result.RootElment);
mockTreeWalkerForTest.Verify(w => w.RefreshTreeData(treeViewMode));
Assert.AreEqual(2, result.Elements.Count);
Assert.AreSame(mockElementsItem1, result.Elements[mockElementsItem1.UniqueId]);
Assert.AreSame(mockElementsItem2, result.Elements[mockElementsItem2.UniqueId]);
}
}
public void ResetMocks()
{
mockDataManager = new DataManager();
mockElement = new A11yElement();
mockElement.UniqueId = 0;
mockElementContext = new ElementContext(mockElement);
irrelevantMaxElements = 10;
mockDataContext = new ElementDataContext(mockElement, irrelevantMaxElements);
mockTreeViewMode = (TreeViewMode)(-1);
mockElementContext.DataContext = mockDataContext;
mockDataContext.TreeMode = mockTreeViewMode;
mockDataContext.Mode = DataContextMode.Live;
mockDataManager.AddElementContext(mockElementContext);
}
/// <summary>
/// Refresh tree node data with all children at once.
/// <param name="mode">indicate the mode</param>
/// </summary>
public void RefreshTreeData(TreeViewMode mode)
{
this.WalkerMode = mode;
if (this.Elements.Count != 0)
{
this.Elements.Clear();
}
//Set parent of Root explicitly for testing.
var ancestry = new DesktopElementAncestry(this.WalkerMode, this.SelectedElement);
// Pre-count the ancestors in our bounded count, so that our count is accurate
_elementCounter.TryAdd(ancestry.Items.Count);
this.TopMostElement = ancestry.First;
// clear children
ListHelper.DisposeAllItemsAndClearList(this.SelectedElement.Children);
this.SelectedElement.UniqueId = 0;
PopulateChildrenTreeNode(this.SelectedElement, ancestry.Last, ancestry.NextId);
// do population of ancesters all togather with children
var list = new List <A11yElement>(this.Elements);
foreach (var item in ancestry.Items)
{
this.Elements.Add(item);
}
// populate Elements first
this.Elements.AsParallel().ForAll(e => e.PopulateAllPropertiesWithLiveData());
// check whether there is any elements which couldn't be updated in parallel, if so, update it in sequence.
var nuel = this.Elements.Where(e => e.Properties == null);
if (nuel.Any())
{
nuel.ToList().ForEach(e => e.PopulateAllPropertiesWithLiveData());
}
// run tests
list.AsParallel().ForAll(e =>
{
e.ScanResults?.Items.Clear();
RuleRunner.Run(e);
});
}
public void PopulateData_TestMode_ChainsToTreeWalkerRefreshTreeData_CorrectParameters()
{
using (ShimsContext.Create())
{
const DataContextMode expectedDcMode = DataContextMode.Test;
const TreeViewMode expectedTreeViewMode = TreeViewMode.Content;
A11yElement expectedElement = new A11yElement();
List <A11yElement> expectedElements = null;
ElementDataContext dataContext = new ElementDataContext(expectedElement, 1);
BoundedCounter actualCounter = null;
A11yElement actualElement = null;
TreeViewMode? actualTreeMode = null;
A11yElement rootElement = null;
ShimTreeWalkerForTest.ConstructorA11yElementBoundedCounter = (ktw, e, c) =>
{
actualCounter = c;
actualElement = e;
new ShimTreeWalkerForTest(ktw)
{
RefreshTreeDataTreeViewMode = (mode) =>
{
actualTreeMode = mode;
expectedElements = new List <A11yElement> {
expectedElement
};
rootElement = expectedElement;
Assert.IsTrue(dataContext.ElementCounter.TryIncrement());
},
ElementsGet = () => expectedElements,
TopMostElementGet = () => rootElement,
};
};
CaptureAction.PopulateData(dataContext, expectedDcMode, expectedTreeViewMode);
Assert.AreSame(dataContext.ElementCounter, actualCounter);
Assert.AreSame(expectedElement, actualElement);
Assert.AreEqual(expectedDcMode, dataContext.Mode);
Assert.AreEqual(expectedTreeViewMode, dataContext.TreeMode);
Assert.AreSame(expectedElement, dataContext.Elements.Values.First());
Assert.AreSame(expectedElement, dataContext.RootElment);
}
}
/// <summary>
/// Returns the right tree structure rule for the given viewmode
/// Throws InvalidEnumArgumentException if no rule id property exists
/// </summary>
/// <param name="viewMode">tree walker mode (content/control/raw)</param>
/// <returns>associated rule for typical tree structure</returns>
public static RuleId GetTreeStructureRule(TreeViewMode viewMode)
{
switch (viewMode)
{
case TreeViewMode.Content:
return(RuleId.TypicalTreeStructureContent);
case TreeViewMode.Control:
return(RuleId.TypicalTreeStructureControl);
case TreeViewMode.Raw:
return(RuleId.TypicalTreeStructureRaw);
default:
throw new InvalidEnumArgumentException(Invariant($"No rule id exists for the given view mode {viewMode}"));
}
}
public static MvcHtmlString TreeViewFor <VM, TItem>(
this HtmlHelper <VM> htmlHelper,
Expression <Func <VM, IEnumerable <TItem> > > expression,
Func <int, string> collection,
ExternalContainerType itemContainer = ExternalContainerType.span,
string rootClassDisplay = null,
object[] displayTemplates = null,
Func <object, int, int> itemTemplateSelectorDisplay = null,
string rootClassEdit = null,
object[] editTemplates = null,
Func <object, int, int> itemTemplateSelectorEdit = null,
TreeViewMode mode = TreeViewMode.InitializeDisplay,
Func <int, string> itemClassSelector = null,
Func <object, int, TreeViewItemStatus> itemStatus = null,
TreeViewOptions treeViewOptions = null)
{
if (expression == null)
{
throw(new ArgumentNullException("expression"));
}
if (collection == null)
{
throw(new ArgumentNullException("collection"));
}
if ((displayTemplates == null || displayTemplates.Length == 0) &&
(editTemplates == null || editTemplates.Length == 0))
{
throw (new ArgumentNullException("displayTemplates editTemplates"));
}
return(TreeViewFor
(htmlHelper,
htmlHelper.ExtractFromModel(expression),
collection,
itemContainer,
rootClassDisplay,
displayTemplates,
itemTemplateSelectorDisplay,
rootClassEdit,
editTemplates,
itemTemplateSelectorEdit,
mode,
itemClassSelector,
itemStatus,
treeViewOptions));
}
/// <summary>
/// Refresh tree node data with all children at once.
/// </summary>
/// <param name="e"></param>
/// <param name="mode"></param>
/// <param name="showAncestry"></param>
public void GetTreeHierarchy(A11yElement e, TreeViewMode mode)
{
if (e == null)
{
throw new ArgumentNullException(nameof(e));
}
var begin = DateTime.Now;
this.WalkerMode = mode;
//Set parent of Root explicitly for testing.
A11yElement parent = null;
var ancestry = new DesktopElementAncestry(this.WalkerMode, e);
parent = ancestry.Last;
this.RootElement = ancestry.First;
// clear children
ListHelper.DisposeAllItemsAndClearList(e.Children);
// populate selected element relationship and add it to list.
e.Parent = ancestry.Last;
e.TreeWalkerMode = this.WalkerMode; // set tree walker mode.
e.UniqueId = 0; // it is the selected element which should be id 0.
this.Elements.Add(e);
PopulateChildrenTreeNode(e, ancestry.NextId);
// populate decendent Elements first in parallel
this.Elements.AsParallel().ForAll(el =>
{
el.PopulateMinimumPropertiesForSelection();
});
// Add ancestry into Elements list.
foreach (var item in ancestry.Items)
{
this.Elements.Add(item);
}
this.LastWalkTime = DateTime.Now - begin;
}
/// <summary>
/// Update Data context in given ElementContext for Test Mode
/// if Data Context is already up to date based on parameters, just skip.
/// </summary>
/// <param name="ecId">ElementContext Id</param>
/// <param name="dm"></param>
/// <param name="tvm"></param>
/// <param name="force">Force the update</param>
/// <returns>boolean</returns>
public static bool SetTestModeDataContext(Guid ecId, DataContextMode dm, TreeViewMode tvm, bool force = false)
{
var ec = GetDataManager().GetElementContext(ecId);
// if Data context is set via Live Mode, set it to null.
if (ec.DataContext != null && ec.DataContext.Mode == DataContextMode.Live)
{
ec.DataContext = null;
}
if (NeedNewDataContext(ec.DataContext, dm, tvm) || force)
{
ec.DataContext = new ElementDataContext(ec.Element, MaxElements);
PopulateData(ec.DataContext, dm, tvm);
return(true);
}
return(false);
}
/// <summary>
/// Get a DesktopElement from x, y position, normalized to treeViewMode
/// </summary>
/// <param name="xPos"></param>
/// <param name="yPos"></param>
/// <param name="treeViewMode">current TreeViewMode</param>
/// <returns></returns>
public static A11yElement NormalizedElementFromPoint(int xPos, int yPos, TreeViewMode treeViewMode)
{
try
{
A11yElement element = ElementFromPoint(xPos, yPos);
if (element == null)
{
return(null);
}
if (treeViewMode == TreeViewMode.Raw)
{
return(element);
}
if (treeViewMode == TreeViewMode.Control && element.IsControlElement)
{
return(element);
}
if (treeViewMode == TreeViewMode.Content && element.IsContentElement)
{
return(element);
}
using (element)
{
return(GetNormalizedElement(element, treeViewMode));
}
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception e)
{
e.ReportException();
}
#pragma warning restore CA1031 // Do not catch general exception types
return(null);
}
/// <summary>
/// Update Data context in given ElementContext for Test Mode
/// if Data Context is already up to date based on parameters, just skip.
/// </summary>
/// <param name="ecId">ElementContext Id</param>
/// <param name="dm"></param>
/// <param name="tvm"></param>
/// <param name="force">Force the update</param>
/// <returns>boolean</returns>
public static bool SetTestModeDataContext(Guid ecId, DataContextMode dm, TreeViewMode tvm, bool force = false)
{
var ec = GetDataManager().GetElementContext(ecId);
// if Data context is set via Live Mode, set it to null.
if (ec.DataContext != null && ec.DataContext.Mode == DataContextMode.Live)
{
ec.DataContext = null;
// Re-register user-configured custom UIA data
Registrar.GetDefaultInstance().RestoreCustomPropertyRegistrations();
}
if (NeedNewDataContext(ec.DataContext, dm, tvm) || force)
{
ec.DataContext = new ElementDataContext(ec.Element, MaxElements);
PopulateData(ec.DataContext, dm, tvm);
return(true);
}
return(false);
}
/// <summary>
/// Get IUIAutomationTreeWalker based on inidcated mode.
/// </summary>
/// <param name="mode">TreeViewMode to get walker</param>
/// <returns></returns>
public static IUIAutomationTreeWalker GetTreeWalker(TreeViewMode mode)
{
IUIAutomationTreeWalker walker = null;
var uia = A11yAutomation.GetUIAutomationObject();
switch (mode)
{
case TreeViewMode.Content:
walker = uia.ContentViewWalker;
break;
case TreeViewMode.Control:
walker = uia.ControlViewWalker;
break;
case TreeViewMode.Raw:
walker = uia.RawViewWalker;
break;
}
return(walker);
}
/// <summary>
/// Refresh tree node data with all children at once.
/// </summary>
/// <param name="e"></param>
/// <param name="mode"></param>
/// <param name="showAncestry"></param>
public void GetTreeHierarchy(A11yElement e, TreeViewMode mode)
{
var begin = DateTime.Now;
this.WalkerMode = mode;
//Set parent of Root explicitly for testing.
A11yElement parent = null;
var ancestry = new DesktopElementAncestry(this.WalkerMode, e);
parent = ancestry.Last;
this.RootElement = ancestry.First;
// clear children
e.Children?.ForEach(c => c.Dispose());
e.Children?.Clear();
// populate selected element relationship and add it to list.
e.Parent = ancestry.Last;
e.TreeWalkerMode = this.WalkerMode; // set tree walker mode.
e.UniqueId = 0; // it is the selected element which should be id 0.
this.Elements.Add(e);
PopulateChildrenTreeNode(e, ancestry.NextId);
// populate decendent Elements first in parallel
this.Elements.AsParallel().ForAll(el =>
{
el.PopulateMinimumPropertiesForSelection();
});
// Add ancestry into Elements list.
this.Elements.AddRange(ancestry.Items);
this.LastWalkTime = DateTime.Now - begin;
}
/// <summary>
/// check whether it needs new DataContext
/// </summary>
/// <param name="sm"></param>
/// <param name="tm"></param>
/// <returns></returns>
public static bool NeedNewDataContext(this ElementDataContext dc, DataContextMode sm, TreeViewMode tm)
{
if (dc == null)
{
throw new ArgumentNullException(nameof(dc));
}
return(dc.Mode != DataContextMode.Load && (dc.Mode != sm || dc.TreeMode != tm));
}
private static bool NeedNewDataContext(ElementDataContext dc, DataContextMode sm, TreeViewMode tm)
{
return(dc == null || (dc.Mode != DataContextMode.Load && (dc.Mode != sm || dc.TreeMode != tm)));
}
/// <summary>
/// Populate Data
/// </summary>
/// <param name="dc"></param>
/// <param name="dcMode"></param>
/// <param name="tm"></param>
internal static void PopulateData(ElementDataContext dc, DataContextMode dcMode, TreeViewMode tm)
{
dc.TreeMode = tm;
dc.Mode = dcMode;
switch (dcMode)
{
case DataContextMode.Test:
var stw = NewTreeWalkerForTest(dc.Element, dc.ElementCounter);
stw.RefreshTreeData(tm);
dc.Elements = stw.Elements.ToDictionary(l => l.UniqueId);
dc.RootElment = stw.TopMostElement;
break;
case DataContextMode.Load:
dc.RootElment = dc.Element.GetOriginAncestor();
PopulateElementAndDescendentsListFromLoadedData(dc);
break;
}
}
public static MvcHtmlString TreeViewFor <VM, TItem>(
this HtmlHelper <VM> htmlHelper,
RenderInfo <IEnumerable <TItem> > renderInfo,
Func <int, string> collectionName,
ExternalContainerType itemContainer = ExternalContainerType.span,
string rootClassDisplay = null,
object[] displayTemplates = null,
Func <object, int, int> itemTemplateSelectorDisplay = null,
string rootClassEdit = null,
object[] editTemplates = null,
Func <object, int, int> itemTemplateSelectorEdit = null,
TreeViewMode mode = TreeViewMode.InitializeDisplay,
Func <int, string> itemClassSelector = null,
Func <object, int, TreeViewItemStatus> itemStatus = null,
TreeViewOptions treeViewOptions = null)
{
if (renderInfo == null)
{
throw(new ArgumentNullException("renderInfo"));
}
if (collectionName == null)
{
throw(new ArgumentNullException("collectionName"));
}
if ((displayTemplates == null || itemTemplateSelectorDisplay == null || displayTemplates.Length == 0) &&
(editTemplates == null || itemTemplateSelectorEdit == null || editTemplates.Length == 0))
{
throw (new ArgumentNullException("displayTemplates/itemTemplateSelectorDisplay or editTemplates/itemTemplateSelectorEdit"));
}
if (itemStatus == null)
{
itemStatus = (mbox, i) => TreeViewItemStatus.initializeShow;
}
if (treeViewOptions == null)
{
treeViewOptions = new TreeViewOptions();
}
if (MvcEnvironment.Validation(htmlHelper) == ValidationType.StandardClient)
{
treeViewOptions.CanAdd = false;
}
StringBuilder sb = new StringBuilder();
sb.Append(renderInfo.PartialRendering);
RenderInfo <IEnumerable <TItem> > renderInfoO = new RenderInfo <IEnumerable <TItem> >();
renderInfoO.Model = renderInfo.Model;
renderInfoO.PartialPrefix = renderInfo.PartialPrefix;
renderInfoO.Prefix = renderInfo.Prefix;
renderInfoO.PartialRendering = renderInfo.PartialRendering;
if (editTemplates == null || editTemplates.Length == 0)
{
TreeViewTop <VM, TItem>(
sb, false, htmlHelper, renderInfoO, collectionName, itemContainer,
rootClassDisplay, displayTemplates, itemTemplateSelectorDisplay,
itemClassSelector, itemStatus, treeViewOptions.Opacity, false, false, treeViewOptions);
}
else if (displayTemplates == null || displayTemplates.Length == 0)
{
TreeViewTop <VM, TItem>(
sb, true, htmlHelper, renderInfoO, collectionName, itemContainer,
rootClassEdit, editTemplates, itemTemplateSelectorEdit,
itemClassSelector, itemStatus, treeViewOptions.Opacity, treeViewOptions.CanMove, treeViewOptions.CanAdd, treeViewOptions);
}
else
{
bool isEdit = mode == TreeViewMode.Edit || mode == TreeViewMode.InitializeEdit;
if (mode == TreeViewMode.InitializeEdit || mode == TreeViewMode.InitializeDisplay)
{
IDictionary vars = htmlHelper.ViewContext.RequestContext.HttpContext.Items;
if (vars.Contains(renderInfo.Prefix))
{
isEdit = (bool)(vars[renderInfo.Prefix]);
}
}
string toggleScript = null;
if (isEdit)
{
toggleScript = string.Format(completeTreeScriptEdit,
BasicHtmlHelper.IdFromName(renderInfo.Prefix));
}
else
{
toggleScript = string.Format(completeTreeScriptDisplay,
BasicHtmlHelper.IdFromName(renderInfo.Prefix));
}
RenderInfo <TwoWayChoice <IEnumerable <TItem> > > toRender = htmlHelper.InvokeTransform(renderInfo, new TwoWayChoice <IEnumerable <TItem> >());
toRender.Model.IsChoice2 = isEdit;
sb.Append(toRender.PartialRendering);
sb.Append(htmlHelper.Hidden(BasicHtmlHelper.AddField(toRender.PartialPrefix, "IsChoice2"), toRender.Model.IsChoice2));
renderInfoO.Model = toRender.Model.Choice1;
renderInfoO.PartialPrefix = BasicHtmlHelper.AddField(toRender.PartialPrefix, "Choice1");
renderInfoO.Prefix = BasicHtmlHelper.AddField(toRender.Prefix, "Choice1");
renderInfoO.PartialRendering = string.Empty;
TreeViewTop <VM, TItem>(
sb, false, htmlHelper, renderInfoO, collectionName, itemContainer,
rootClassDisplay, displayTemplates, itemTemplateSelectorDisplay,
itemClassSelector, itemStatus, treeViewOptions.Opacity, false, false, treeViewOptions);
renderInfoO.Model = toRender.Model.Choice2;
renderInfoO.PartialPrefix = BasicHtmlHelper.AddField(toRender.PartialPrefix, "Choice2");
renderInfoO.Prefix = BasicHtmlHelper.AddField(toRender.Prefix, "Choice2");
TreeViewTop <VM, TItem>(
sb, true, htmlHelper, renderInfoO, collectionName, itemContainer,
rootClassEdit, editTemplates, itemTemplateSelectorEdit,
itemClassSelector, itemStatus, treeViewOptions.Opacity, treeViewOptions.CanMove, treeViewOptions.CanAdd, treeViewOptions);
sb.Append(toggleScript);
}
return(MvcHtmlString.Create(sb.ToString()));
}
public void SetTestModeDataContext_NoopsIfElementDoesNotNeedTestContextUpdate(DataContextMode originalMode, TreeViewMode originalTreeMode, DataContextMode newlySetMode, TreeViewMode newlySetTreeMode)
{
mockDataContext.Mode = originalMode;
mockDataContext.TreeMode = originalTreeMode;
using (new CaptureActionTestHookOverrides(() => mockDataManager, null, null))
{
bool retVal = CaptureAction.SetTestModeDataContext(mockElementContext.Id, newlySetMode, newlySetTreeMode, force: false);
Assert.IsFalse(retVal);
Assert.AreSame(mockDataContext, mockElementContext.DataContext);
}
}
/// <summary>
/// check whether it needs new DataContext
/// </summary>
/// <param name="sm"></param>
/// <param name="tm"></param>
/// <returns></returns>
public static bool NeedNewDataContext(this ElementDataContext dc, DataContextMode sm, TreeViewMode tm)
{
return(dc.Mode != DataContextMode.Load && (dc.Mode != sm || dc.TreeMode != tm));
}
