protected override void LoadChildren()
{
if (_coverageSession.CoveredModules != null)
{
Children.AddRange(_coverageSession.CoveredModules.Select(module => new ModuleNode(module)));
}
}
public Task LoadChildrenAsync()
{
_dispatcher.VerifyAccess();
if (_childrenTcs == null)
{
_childrenTcs = new TaskCompletionSource <IReadOnlyCollection <ITreeNode> >();
if (!HasDummyChild)
{
_childrenTcs.TrySetResult(Array <ITreeNode> .Empty);
}
}
if (HasDummyChild)
{
IsBeingExpanded = true;
Children.Remove(DummyChild);
DoLoadChildrenAsync().ContinueWith(t =>
{
var items = t.Result;
_dispatcher.BeginInvoke(() =>
{
Children.AddRange(items);
IsBeingExpanded = false;
_childrenTcs.TrySetResult(items);
});
});
}
return(_childrenTcs.Task);
}
protected override void LoadChildren()
{
var propertyMethodNodes = PropertyMethods.OrderBy(x => x.Name)
.Select(method => new PropertyMethodNode(method));
Children.AddRange(propertyMethodNodes);
}
/// <summary>
/// Converts it to a netmodule and returns the old <see cref="AssemblyTreeNode"/> child
/// </summary>
/// <returns></returns>
internal AssemblyTreeNode OnConvertedToNetModule()
{
bool b = !LazyLoading &&
!(Parent is AssemblyTreeNode) &&
Children.Count == 1 && Children[0] is AssemblyTreeNode &&
typeDict.Count == 0 && namespaces.Count == 0;
Debug.Assert(b);
if (!b)
{
throw new InvalidOperationException();
}
var modNode = (AssemblyTreeNode)Children[0];
Children.Clear();
LazyLoading = modNode.LazyLoading;
typeDict.AddRange(modNode.typeDict);
modNode.typeDict.Clear();
namespaces.AddRange(modNode.namespaces);
modNode.namespaces.Clear();
var oldChildren = modNode.Children.ToArray();
modNode.Children.Clear();
Children.AddRange(oldChildren);
RaiseUIPropsChanged();
return(modNode);
}
private void InitContainers()
{
// see FormulaViewer_OnLoaded
if (!IsLoaded)
{
return;
}
Children.Clear();
if (Tokens != null)
{
Children.AddRange(Tokens.Select(CreateContainer).Where(container => container != null));
foreach (var container in Containers)
{
InitContainer(container);
}
//UpdateStyles();
}
var caretIndex = Tokens == null ? 0 : Tokens.Count;
MoveCaret(-1, caretIndex);
CaretIndex = caretIndex;
UpdateFontSize();
}
public async Task Search()
{
if (!_folderType.Equals(File.MimeType))
{
return;
}
string token = null;
do
{
var request = _service.Files.List();
//API max
request.PageSize = 1000;
request.Q = $"'{File.Id}' in parents";
request.Fields = $"nextPageToken, files({FileFields})";
request.PageToken = token;
var result = await request.ExecuteAsync();
if (result.Files.Any())
{
Children.AddRange(result.Files.Select(x => new FileNode(_service, x)));
}
token = result.NextPageToken;
} while (token != null);
Console.WriteLine($"{File.Name} - {Children.Count} files/folders");
var tasks = Children.Select(x => x.Search());
await Task.WhenAll(tasks);
}
/// <summary>
/// We have just been deserialised. If from XML then load our model
/// from resource.
/// </summary>
public override void OnCreated()
{
// lookup the resource get the xml and then deserialise to a model.
if (ResourceName != null && ResourceName != "")
{
string contents = Properties.Resources.ResourceManager.GetString(ResourceName);
if (contents != null)
{
List <Exception> creationExceptions;
Model modelFromResource = ApsimFile.FileFormat.ReadFromString <Model>(contents, out creationExceptions);
if (this.GetType() != modelFromResource.GetType())
{
// Top-level model may be a simulations node. Search for a child of the correct type.
Model child = Apsim.Child(modelFromResource, this.GetType()) as Model;
if (child != null)
{
modelFromResource = child;
}
}
modelFromResource.Enabled = Enabled;
Children.Clear();
Children.AddRange(modelFromResource.Children);
CopyPropertiesFrom(modelFromResource);
SetNotVisible(modelFromResource);
Apsim.ParentAllChildren(this);
DoSerialiseChildren = false;
}
}
}
/// <summary>
/// Adds a range of nodes (with the given names) to the node
/// </summary>
/// <typeparam name="T">Type to remain implicit</typeparam>
/// <param name="names">Name of nodes</param>
/// <returns></returns>
public IEnumerable <HierarchyNode> AddRange <T>(IEnumerable <T> names)
{
var n = from i in names select new HierarchyNode(i);
Children.AddRange(n);
return(n);
}
/// <summary>
/// Carga los elementos hijo
/// </summary>
public override void LoadChildren()
{
// Carga los elementos hijo
Children.AddRange(new Helpers.OwnerNodeHelper().LoadOwnerNodes(this, File, OwnerChild));
// Llama al método base
base.LoadChildren();
}
/// <summary>
/// Loads the content.
/// </summary>
public override void LoadContent()
{
icon = new GuiImage();
images = new List <GuiImage>();
text = new GuiText();
for (int x = 0; x < ButtonSize.Width; x++)
{
GuiImage image = new GuiImage {
SourceRectangle = CalculateSourceRectangle(x)
};
images.Add(image);
}
Children.AddRange(images);
Children.Add(text);
if (!string.IsNullOrWhiteSpace(Icon))
{
Children.Add(icon);
}
base.LoadContent();
}
protected override void LoadChildren()
{
if (this.Node.GetChildren != null)
{
var process = WindowsDebugger.CurrentProcess;
process.EnqueueWork(Dispatcher.CurrentDispatcher, () => Children.AddRange(this.Node.GetChildren().Select(node => node.ToSharpTreeNode())));
}
}
protected override void LoadChildren()
{
if (Node.HasChildNodes)
{
((WindowsDebugger)DebuggerService.CurrentDebugger).DebuggedProcess
.EnqueueWork(Dispatcher.CurrentDispatcher, () => Children.AddRange(Node.ChildNodes.Select(node => node.ToSharpTreeNode())));
}
}
public WorkItemTreeViewModel(WorkItem workItem) : base(workItem)
{
if (workItem.ParentId.HasValue)
{
Parent = new WorkItemTreeParentViewModel(workItem.Parent);
}
Children.AddRange(workItem.Children.Select(x => new WorkItemTreeViewModel(x)));
Creater = new UserInfoViewModel(workItem.Creator);
}
internal AMChessOptionsModifier(string text, MChessOptions options = null, IEnumerable <AAction> children = null)
: base(text)
{
MChessOptions = options;
if (children != null)
{
Children.AddRange(children);
}
}
public TypeNode(CheckedNode parent, string name, IEnumerable <MethodNode> children = null)
: base(name, true)
{
Parent = parent;
if (children != null)
{
Children.AddRange(children);
}
}
public virtual void CopyFrom(MyClass other)
{
X = other.X;
Y = other.Y;
Children.Clear();
Children.AddRange(other.Children);
Ps = other.Ps;
P = other.P;
}
public T AddChildren(List <T> children)
{
foreach (var child in children)
{
child.Parent = (T)this;
}
Children.AddRange(children);
return((T)this);
}
public void AddRange(IEnumerable <ObjectModel> list)
{
if (Children == null)
{
Children = new List <ObjectModel>();
}
Children.AddRange(list);
}
private void AssignFrom(Term term)
{
var newTerm = Clone(term);
Children.Clear();
Children.AddRange(newTerm.Children);
Children.ForEach(c => c._parent = this);
Definition = newTerm.Definition;
}
public void AppendChildren(TreeNodeList <T> children)
{
if (children == null)
{
throw new ArgumentNullException("children");
}
Children.AddRange(children);
}
public App(AXmlController parent, VisualElement xmlElement) : base(parent, xmlElement)
{
m_menuPage = new MenuPage(this, PathManager.GetVisualElement("Pages/MenuPage/MenuPage"));
m_gamePage = new GamePage(this, PathManager.GetVisualElement("Pages/GamePage/GamePage"));
Children.AddRange(new List <AXmlController>()
{
m_menuPage, m_gamePage
});
}
public LibraryNode(LibraryNode node)
{
_capabilities = node._capabilities;
_contextMenuID = node._contextMenuID;
_name = node._name;
_tooltip = node._tooltip;
_type = node._type;
Children.AddRange(node.Children);
_filteredView = new Dictionary <LibraryNodeType, LibraryNode>();
}
// Define the event handlers.
private void OnChanged(object source, FileSystemEventArgs e)
{
//Console.WriteLine("File: " + e.FullPath + " " + e.ChangeType);
if (e.ChangeType == WatcherChangeTypes.Deleted || e.ChangeType == WatcherChangeTypes.Created || e.ChangeType == WatcherChangeTypes.Renamed)
{
//Console.WriteLine("Reloading children");
Children.Clear();
Children.AddRange(LoadChildren());
}
}
protected Annotation(Annotation <TOffset> ann)
: this(ann.Range, ann.FeatureStruct.Clone())
{
Optional = ann.Optional;
_data = ann._data;
if (ann._children != null && ann._children.Count > 0)
{
Children.AddRange(ann.Children.Select(node => node.Clone()));
}
}
private void OnRenamed(object source, RenamedEventArgs e)
{
//Console.WriteLine("File: {0} renamed to {1}", e.OldFullPath, e.FullPath);
if (e.ChangeType == WatcherChangeTypes.Renamed)
{
//Console.WriteLine("Reloading children");
Children.Clear();
Children.AddRange(LoadChildren());
}
}
public MutantGroup(string name, CheckedNode parent, IEnumerable <Mutant> mutants = null)
: base(name, true)
{
Parent = parent;
if (mutants != null)
{
Children.AddRange(mutants);
}
UpdateDisplayedText();
}
public TreeNode <T, V> AppendRange(IEnumerable <TreeNode <T, V> > nodes)
{
foreach (var item in nodes)
{
item.Parent = this;
}
Children.AddRange(nodes);
return(this);
}
protected override void LoadChildren()
{
LoadingChildrenTask = Task.Run(() =>
{
List <SharpTreeNode> nodes = getDriveNodes();
App.Current.Dispatcher.Invoke(() =>
{
Children.AddRange(nodes);
});
});
}
public SpawnField(Player player)
{
Player = player;
foreach (var pawn in player.Pawns)
{
pawn.StandingOn = this;
}
Children.AddRange(player.Pawns);
}
public void AddViews(IEnumerable <GtkShellDocumentViewItem> views)
{
Children.Clear();
Children.AddRange(views);
relativeSplitSizes.Clear();
for (int n = 0; n < Children.Count; n++)
{
relativeSplitSizes.Add(1 / (double)Children.Count);
}
Rebuild();
}
