/// <summary>
/// Update the subgroups of this form group.
/// </summary>
/// <param name="order"></param>
/// <param name="formType"></param>
public void UpdateSubgroups(TraversalOptions order = TraversalOptions.Pre, FormNameType formType = FormNameType.Both)
{
foreach (var subnode in Subnodes.Values)
{
subnode.Update(order, formType);
}
}
public AbstractRenderTraversable(string name
, TraversalOptions options = TraversalOptions.Pre
, bool skipDuplicates = true)
{
Name = name;
Options = options;
SkipDuplicates = skipDuplicates;
}
public RenderLayer(string name
, TraversalOptions options = TraversalOptions.Pre
, bool skipDuplicates = true)
: base(name, options, skipDuplicates)
{
RenderType = RenderOrder.RenderType.Layer;
ActionType = RenderOrderActionType.RenderLayer;
}
/// <summary>
/// Render only the sublayers of this layer.
/// </summary>
/// <param name="order"></param>
public virtual void RenderSublayers(HashSet <AbstractRenderLayer> seenLayers
, TraversalOptions order = TraversalOptions.Pre
, bool skipDuplicates = true)
{
foreach (var layer in Subnodes.Values)
{
layer.Render(seenLayers, order, skipDuplicates);
}
}
/// <summary>
/// Set the render order to render the given layers with the given traversal option.
/// </summary>
/// <param name="order"></param>
/// <param name="traversal"></param>
public void SetRenderOrder(string[] order
, TraversalOptions traversal = TraversalOptions.Pre)
{
var actions = from name in order
select(RenderOrder.AbstractRenderOrderAction)
new RenderOrder.RenderLayer(name, traversal);
SetRenderOrder(new RenderOrder(actions.ToList()));
}
/// <summary>Execute a server-side traversal</summary>
/// <seealso><a href= "https://docs.arangodb.com/current/HTTP/Traversal/index.html#executes-a-traversal">API
/// * Documentation</a></seealso>
/// <param name="vertexClass">The type of the vertex documents (POJO class, VPackSlice or String for Json)
/// </param>
/// <param name="edgeClass">The type of the edge documents (POJO class, VPackSlice or String for Json)
/// </param>
/// <param name="options">Additional options</param>
/// <returns>Result of the executed traversal</returns>
/// <exception cref="ArangoDBException"/>
/// <exception cref="com.arangodb.ArangoDBException"/>
public virtual TraversalEntity <V, E> executeTraversal <V, E>(TraversalOptions
options)
{
System.Type vertexClass = typeof(V);
System.Type edgeClass = typeof(E);
Request request = this.executeTraversalRequest(options);
return(executor.execute(request, executeTraversalResponseDeserializer(vertexClass
, edgeClass)));
}
/// <summary>
/// Render all objects.
/// </summary>
/// <param name="options">The options determining which order the items and subgroups are rendered in.</param>
/// <param name="renderAction">The layer's RenderAction, which determines how each RenderableObject encountered is handled and rendered.</param>
/// <param name="seenRenderables">The list of RenderableObjects already seen by the layer in this render cycle.</param>
/// <param name="seenGroups">The list of RenderableGroups already seen by the layer in this render cycle.</param>
/// <param name="skipDuplicates">Whether or not to skip duplicate items/subgroups (if they're present in the seenRenderables/seenGroups lists).</param>
public virtual void Render(TraversalOptions options
, RenderableHandler renderAction
, HashSet <RenderableObject> seenRenderables
, HashSet <RenderableGroup> seenGroups
, bool skipDuplicates = true)
{
switch (options)
{
case TraversalOptions.Top:
if (!(skipDuplicates && seenGroups.Contains(this)))
{
RenderTop(renderAction, seenRenderables, skipDuplicates);
}
break;
case TraversalOptions.Pre:
foreach (var subgroup in Subnodes.Values)
{
subgroup.Render(options, renderAction, seenRenderables, seenGroups, skipDuplicates);
}
if (!(skipDuplicates && seenGroups.Contains(this)))
{
RenderTop(renderAction, seenRenderables, skipDuplicates);
}
break;
case TraversalOptions.Post:
if (!(skipDuplicates && seenGroups.Contains(this)))
{
RenderTop(renderAction, seenRenderables, skipDuplicates);
}
foreach (var subgroup in Subnodes.Values)
{
subgroup.Render(options, renderAction, seenRenderables, seenGroups, skipDuplicates);
}
break;
default:
throw new RenderOrderException(
String.Format(
"Unknown RenderOrder.RenderGroupOptions '{0}' supplied when rendering " +
"renderable group '{1}'.", options, FullName));
}
seenGroups.Add(this);
}
/// <summary>
/// Update all the Forms in this form group and it's subgroups, in the order
/// specified by the TraversalOptions.
///
/// You can specify to render only named forms, only anonymous forms, or both
/// using the FormType parameter.
/// </summary>
/// <param name="order"></param>
/// <param name="formType"></param>
public void Update(TraversalOptions order = TraversalOptions.Pre, FormNameType formType = FormNameType.Both)
{
switch (order)
{
case TraversalOptions.Pre:
UpdateSubgroups(order, formType);
UpdateTop(formType);
break;
case TraversalOptions.Post:
UpdateTop(formType);
UpdateSubgroups(order, formType);
break;
case TraversalOptions.Top:
UpdateTop(formType);
break;
default:
break;
}
}
public RenderLayer( string name
, TraversalOptions options = TraversalOptions.Pre
, bool skipDuplicates = true )
: base(name, options, skipDuplicates)
{
RenderType = RenderOrder.RenderType.Layer;
ActionType = RenderOrderActionType.RenderLayer;
}
/// <summary>
/// Set the next render order action to render the group with the given name.
/// </summary>
/// <param name="name"></param>
/// <param name="options"></param>
public void AddRenderGroup(
string name, TraversalOptions options = TraversalOptions.Pre, bool skipDuplicates = true)
{
Actions.Add(new RenderGroup(name, options, skipDuplicates));
}
/// <summary>
/// Set the next render order action to render the group with the given name.
/// </summary>
/// <param name="name"></param>
/// <param name="options"></param>
public void AddRenderGroup(
string name, TraversalOptions options = TraversalOptions.Pre, bool skipDuplicates = true)
{
Actions.Add(new RenderGroup(name, options, skipDuplicates));
}
public AbstractRenderTraversable( string name
, TraversalOptions options = TraversalOptions.Pre
, bool skipDuplicates = true )
{
Name = name;
Options = options;
SkipDuplicates = skipDuplicates;
}
/// <summary>
/// Render all items and sublayers on this layer.
/// </summary>
public void Render(HashSet <AbstractRenderLayer> seenLayers
, TraversalOptions order = TraversalOptions.Pre
, bool skipDuplicates = true)
{
MidRender = true;
switch (order)
{
case TraversalOptions.Pre:
RenderSublayers(seenLayers, order, skipDuplicates);
if (!(skipDuplicates && seenLayers.Contains(this)))
{
RenderTop();
}
break;
case TraversalOptions.Post:
if (!(skipDuplicates && seenLayers.Contains(this)))
{
RenderTop();
}
RenderSublayers(seenLayers, order, skipDuplicates);
break;
case TraversalOptions.Top:
if (!(skipDuplicates && seenLayers.Contains(this)))
{
RenderTop();
}
break;
default:
throw new RenderOrderException(
String.Format(
"Unknown RenderOrder.RenderGroupOptions '{0}' supplied when rendering " +
"layer '{1}'.", order, FullName));
}
MidRender = false;
seenLayers.Add(this);
// Add all the items that were added mid-render.
//
// Honestly, this is kind of an unnecessary buffer for user clumsiness. Their
// rendering code should NOT be adding anything to a layer, that SHOULD be happening
// in their update code. This is just in case there's some edge case where you're
// forced to add an item mid-render, or in case the user isn't astute enough to
// realize the error in their ways.
foreach (var item in renderablesToAdd)
{
if (item.Anonymous)
{
if (item.Name != null)
{
AddAnonymousItem(item.Name, item.Object);
}
else
{
AddAnonymousItem(item.Object);
}
}
else
{
AddItem(item.Name, item.Object);
}
}
renderablesToAdd.Clear();
}
public void UdpateForms(string groupName, TraversalOptions order = TraversalOptions.Pre)
{
_allForms.GetSubnode(groupName).Update(order);
}
public static IEnumerable <OpenXmlElement> Descendants(this OpenXmlElement element, FileFormatVersions version = FileFormatVersions.Office2007, TraversalOptions options = TraversalOptions.None)
{
if (element is null)
{
return(Cached.Array <OpenXmlElement>());
}
if ((options & TraversalOptions.SelectAlternateContent) == TraversalOptions.SelectAlternateContent)
{
return(ValidatingTraverse(element, new MCContext(false), version));
}
else
{
return(element.Descendants());
}
}
public TraversalOption(string label, string search, int pos)
{
option = label.GetLongestCommonPrefix(search, out commonPrefixLength, pos);
}
public AbstractOrderableRenderLayer(string fullName)
: base(UriUtilities.GetLastPart(fullName))
{
GlobalTraversalOptions = TraversalOptions.Pre;
}
public void UpdateForms(TraversalOptions order = TraversalOptions.Pre)
{
_allForms.Update(order);
}
public LayerManager()
{
GlobalTraversalOptions = TraversalOptions.Pre;
}
