public FetchNodeCapabilities(TreeNode node)
: base(node)
{
switch (Name)
{
case "fetch":
Comment = false;
ChildTypes.Add(new ChildNodeCapabilities("entity", false));
ChildTypes.Add(new ChildNodeCapabilities("-", true));
ChildTypes.Add(new ChildNodeCapabilities("#comment", true));
break;
case "entity":
case "link-entity":
Delete = true;
Attributes = true;
ChildTypes.Add(new ChildNodeCapabilities("-", true));
ChildTypes.Add(new ChildNodeCapabilities("all-attributes", false));
ChildTypes.Add(new ChildNodeCapabilities("attribute", true));
ChildTypes.Add(new ChildNodeCapabilities("filter", true));
ChildTypes.Add(new ChildNodeCapabilities("order", true));
ChildTypes.Add(new ChildNodeCapabilities("link-entity", true));
ChildTypes.Add(new ChildNodeCapabilities("-", true));
ChildTypes.Add(new ChildNodeCapabilities("#comment", true));
break;
case "all-attributes":
case "attribute":
case "order":
Delete = true;
ChildTypes.Add(new ChildNodeCapabilities("#comment", true));
break;
case "filter":
Delete = true;
ChildTypes.Add(new ChildNodeCapabilities("condition", true));
ChildTypes.Add(new ChildNodeCapabilities("filter", true));
ChildTypes.Add(new ChildNodeCapabilities("-", true));
ChildTypes.Add(new ChildNodeCapabilities("#comment", true));
break;
case "condition":
Delete = true;
ChildTypes.Add(new ChildNodeCapabilities("value", true));
ChildTypes.Add(new ChildNodeCapabilities("-", true));
ChildTypes.Add(new ChildNodeCapabilities("#comment", true));
break;
case "value":
Delete = true;
ChildTypes.Add(new ChildNodeCapabilities("#comment", true));
break;
case "#comment":
Delete = true;
Comment = false;
Uncomment = true;
break;
}
}
static IEnumerable <TreeNode> EnumerateUnsafe(ShellItem shellFolder, ChildTypes childFlags,
TreeNode node, IDictionary <TreeNode, ShellItem> nodesToFolders)
{
var numer = shellFolder.GetChildren(childFlags, false).GetEnumerator();
while (numer.MoveNext())
{
ShellItem child = numer.Current;
// Create a child node.
var childNode = new TreeNode
{
Text = child.DisplayName,
ImageIndex = child.IconIndex,
SelectedImageIndex = child.IconIndex,
};
// Map the node to the shell folder.
nodesToFolders[childNode] = child;
// If this item has children, add a child node as a placeholder.
if (child.HasSubFolders)
{
childNode.Nodes.Add(string.Empty);
}
// Add the child node.
node.Nodes.Add(childNode);
yield return(childNode);
}
}
private CSharpIdentifier GetPropertyType(string propertyName, OpenApiSchema?schema)
{
if (schema?.Type == "string" && schema.Enum.Count != 0)
{
var dtoEnum = new DtoEnumBuilder(propertyName, schema, Naming).BuildType();
ChildTypes.Add(dtoEnum);
return(dtoEnum.Identifier);
}
return(Naming.TypeFor(schema));
}
private void PopulateFields(DetailsStore store)
{
Logger.Trace($"Populating field details for type {rawTypeDefinition.QualifiedName}.");
FieldDetails = rawTypeDefinition.Fields
.Select(field => new UnityFieldDetails(field, store))
.Where(fieldDetail =>
{
var clashingChildEnums = ChildEnums
.Where(childEnum =>
{
// When field does not clash with child enum, return false
if (!fieldDetail.PascalCaseName.Equals(childEnum.Name))
{
return(false);
}
Logger.Error($"Error in type \"{Name}\". Field \"{fieldDetail.RawFieldDefinition.Name}\" clashes with child enum \"{childEnum.Name}\".");
return(true);
});
var clashingChildTypes = ChildTypes
.Where(childType =>
{
// When field does not clash with child type, return false
if (!fieldDetail.PascalCaseName.Equals(childType.Name))
{
return(false);
}
Logger.Error($"Error in type \"{Name}\". Field \"{fieldDetail.RawFieldDefinition.Name}\" clashes with child type \"{childType.CamelCaseName}\".");
return(true);
});
// Only return true if the field has no name clashes with child enums and types
return(!clashingChildEnums.Any() && !clashingChildTypes.Any());
})
.ToList()
.AsReadOnly();
}
/// <summary>
/// Sets up the child types.
/// </summary>
/// <returns>The concrete types found</returns>
private void SetupChildTypes()
{
Logger.Information("Setting up child type discovery for {Name:l}", Source.Name);
ConcreteTypes = DiscoverConcreteTypes.FindConcreteTypes(TypeGraphs);
for (var i = 0; i < ConcreteTypes.Length; i++)
{
var ConcreteType = ConcreteTypes[i];
if (ConcreteType is null)
{
continue;
}
var Types = TypeGraphs[ConcreteType]?.ToList();
if (Types is null)
{
continue;
}
for (var x = 0; x < Types.Count; x++)
{
ChildTypes.Add(Types[x], ConcreteType);
}
}
}
/// <summary>
/// Gets the child mappings.
/// </summary>
/// <param name="objectType">Type of the object.</param>
/// <returns>The IMapping list associated with the object type.</returns>
public IEnumerable <IMapping> GetChildMappings(Type objectType)
{
if (objectType is null)
{
yield break;
}
if (objectType.Namespace.StartsWith("AspectusGeneratedTypes", StringComparison.Ordinal))
{
objectType = objectType.BaseType;
}
if (!ChildTypes.ContainsKey(objectType))
{
yield break;
}
foreach (var Item in ChildTypes[objectType])
{
yield return(Mappings[Item]);
}
}
/// <summary>
/// Gets the children.
/// </summary>
/// <param name="childTypes">The child types.</param>
/// <returns>
/// The children.
/// </returns>
public IEnumerable <ShellItem> GetChildren(ChildTypes childTypes)
{
// We'll return a list of children.
var children = new List <ShellItem>();
// Create the enum flags from the childtypes.
SHCONTF enumFlags = 0;
if (childTypes.HasFlag(ChildTypes.Folders))
{
enumFlags |= SHCONTF.SHCONTF_FOLDERS;
}
if (childTypes.HasFlag(ChildTypes.Files))
{
enumFlags |= SHCONTF.SHCONTF_NONFOLDERS;
}
if (childTypes.HasFlag(ChildTypes.Hidden))
{
enumFlags |= SHCONTF.SHCONTF_INCLUDEHIDDEN;
}
try
{
// Create an enumerator for the children.
IEnumIDList pEnum;
var result = ShellFolderInterface.EnumObjects(IntPtr.Zero, enumFlags, out pEnum);
// Validate the result.
if (result != 0)
{
// Throw the failure as an exception.
Marshal.ThrowExceptionForHR((int)result);
}
// TODO: This logic should go in the pidl manager.
// Enumerate the children, ten at a time.
const int batchSize = 10;
var pidlArray = Marshal.AllocCoTaskMem(IntPtr.Size * 10);
uint itemsFetched;
result = WinError.S_OK;
do
{
result = pEnum.Next(batchSize, pidlArray, out itemsFetched);
// Get each pidl.
var pidls = new IntPtr[itemsFetched];
Marshal.Copy(pidlArray, pidls, 0, (int)itemsFetched);
foreach (var childPidl in pidls)
{
// Create a new shell folder.
var childShellFolder = new ShellItem();
// Initialize it.
try
{
childShellFolder.Initialise(childPidl, this);
}
catch (Exception exception)
{
throw new InvalidOperationException("Failed to initialise child.", exception);
}
// Add the child.
children.Add(childShellFolder);
// Free the PIDL, reset the result.
Marshal.FreeCoTaskMem(childPidl);
}
} while (result == WinError.S_OK);
Marshal.FreeCoTaskMem(pidlArray);
// Release the enumerator.
if (Marshal.IsComObject(pEnum))
{
Marshal.ReleaseComObject(pEnum);
}
}
catch (Exception exception)
{
throw new InvalidOperationException("Failed to enumerate children.", exception);
}
// Sort the children.
var sortedChildren = children.Where(c => c.IsFolder).ToList();
sortedChildren.AddRange(children.Where(c => !c.IsFolder));
// Return the children.
return(sortedChildren);
}
//public static int CreateViewObject(IShellFolder2 folder, IntPtr Handle, ref Guid shellViewGuid, out IntPtr iShellViewPtr)
//{
// folder.CreateViewObject
//}
public static IEnumerable <ShellItem> GetChildren(this ShellItem parent, ChildTypes childTypes, bool lThrow = true)
{
// We'll return a list of children.
var children = new List <ShellItem>();
// Create the enum flags from the childtypes.
SHCONTF enumFlags = 0;
if (childTypes.HasFlag(ChildTypes.Folders))
{
enumFlags |= SHCONTF.SHCONTF_FOLDERS;
}
if (childTypes.HasFlag(ChildTypes.Files))
{
enumFlags |= SHCONTF.SHCONTF_NONFOLDERS;
//enumFlags |= SHCONTF.SHCONTF_NAVIGATION_ENUM
// | SHCONTF.SHCONTF_FASTITEMS // The calling application is looking for resources that can be enumerated quickly.
// | SHCONTF.SHCONTF_FLATLIST; // Enumerate items as a simple list even if the folder itself is not structured in that way
}
if (childTypes.HasFlag(ChildTypes.Hidden))
{
enumFlags |= SHCONTF.SHCONTF_INCLUDEHIDDEN;
}
//| SHCONTF.SHCONTF_INCLUDESUPERHIDDEN;
try
{
// Create an enumerator for the children.
IEnumIDList pEnum;
var result = parent.ShellFolderInterface.EnumObjects(IntPtr.Zero, enumFlags, out pEnum);
// Validate the result.
if (result != 0)
{
if (!lThrow)
{
return(Enumerable.Empty <ShellItem>());
}
// Throw the failure as an exception.
Marshal.ThrowExceptionForHR((int)result);
}
// TODO: This logic should go in the pidl manager.
// Enumerate the children, ten at a time.
const int batchSize = 10;
var pidlArray = Marshal.AllocCoTaskMem(IntPtr.Size * 10);
uint itemsFetched;
result = WinError.S_OK;
do
{
result = pEnum.Next(batchSize, pidlArray, out itemsFetched);
// Get each pidl.
var pidls = new IntPtr[itemsFetched];
Marshal.Copy(pidlArray, pidls, 0, (int)itemsFetched);
foreach (var childPidl in pidls)
{
// Create a new shell folder.
var childShellFolder = new ShellItem();
// Initialize it.
try
{
childShellFolder.Initialise(childPidl, parent);
}
catch (Exception exception)
{
throw new InvalidOperationException("Failed to initialise child.", exception);
}
// Add the child.
children.Add(childShellFolder);
// Free the PIDL, reset the result.
Marshal.FreeCoTaskMem(childPidl);
}
} while (result == WinError.S_OK);
Marshal.FreeCoTaskMem(pidlArray);
// Release the enumerator.
if (Marshal.IsComObject(pEnum))
{
Marshal.ReleaseComObject(pEnum);
}
}
catch (Exception exception)
{
throw new InvalidOperationException("Failed to enumerate children.", exception);
}
// Sort the children.
var sortedChildren = children.Where(c => c.IsFolder).ToList();
sortedChildren.AddRange(children.Where(c => !c.IsFolder));
// Return the children.
return(sortedChildren);
}
/// <summary>
/// Gets the children.
/// </summary>
/// <param name="childTypes">The child types.</param>
public IEnumerable <ShellItem> GetChildren(ChildTypes childTypes, bool lThrow = true)
{
return(ShellObject.GetChildren(this, childTypes, lThrow));
}
public static void DoExpand(this ShellTreeView tree, TreeNode node)
{
// Clear children - which may in fact be the placeholder.
node.Nodes.Clear();
var nodesToFolders = tree.NodesToFolders;
// Get the shell folder.
ShellItem shellFolder = nodesToFolders[node];
// Create the enum flags.
ChildTypes childFlags = ChildTypes.Folders;
if (tree.ShowFiles)
{
childFlags |= ChildTypes.Files;
}
if (tree.ShowHiddenFilesAndFolders)
{
childFlags |= ChildTypes.Hidden;
}
// Disable update while adding children.
tree.BeginUpdate();
int count = 0;
try
{
// Go through each child.
foreach (var childNode in
EnumerateUnsafe(shellFolder, childFlags, node, nodesToFolders))
{
count++;
// Fire the shell item added event.
tree.FireOnShellItemAdded(childNode);
}
if (count == 0)
{
childFlags = ChildTypes.Files | ChildTypes.Hidden;
foreach (var childNode in
EnumerateUnsafe(shellFolder, childFlags, node, nodesToFolders))
{
count++;
// Fire the shell item added event.
tree.FireOnShellItemAdded(childNode);
}
if (count > 0)
{
}
}
}
catch (Exception ex)
{
if (ex.InnerException != null)
{
ex = ex.InnerException;
}
MessageBox.Show(ex.Message);
}
// Enable update now that we've added the children.
tree.EndUpdate();
}
/// <summary>
/// Gets the children.
/// </summary>
/// <param name="childTypes">The child types.</param>
/// <returns>
/// The children.
/// </returns>
public IEnumerable <ShellItem> GetChildren(ChildTypes childTypes)
{
// We'll return a list of children.
var children = new List <ShellItem>();
// Create the enum flags from the childtypes.
SHCONTF enumFlags = SHCONTF.None;
if (childTypes.HasFlag(ChildTypes.Folders))
{
enumFlags |= SHCONTF.SHCONTF_FOLDERS;
}
if (childTypes.HasFlag(ChildTypes.Files))
{
enumFlags |= SHCONTF.SHCONTF_NONFOLDERS;
}
if (childTypes.HasFlag(ChildTypes.Hidden))
{
enumFlags |= SHCONTF.SHCONTF_INCLUDEHIDDEN;
}
try
{
// Create an enumerator for the children.
IEnumIDList pEnum;
var result = ShellFolderInterface.EnumObjects(IntPtr.Zero, enumFlags, out pEnum);
// Validate the result.
if (result != 0)
{
// Throw the failure as an exception.
Marshal.ThrowExceptionForHR((int)result);
}
// Start going through children.
IntPtr childPIDL;
int enumResult;
pEnum.Next(1, out childPIDL, out enumResult);
// Now start enumerating.
while (childPIDL != IntPtr.Zero && enumResult == 1)
{
// Create a new shell folder.
var childShellFolder = new ShellItem();
// Initialize it.
try
{
childShellFolder.Initialise(childPIDL, this);
}
catch (Exception exception)
{
throw new InvalidOperationException("Failed to initialise child.", exception);
}
// Add the child.
children.Add(childShellFolder);
// Free the PIDL, reset the result.
Marshal.FreeCoTaskMem(childPIDL);
// Move onwards.
pEnum.Next(1, out childPIDL, out enumResult);
}
// Release the enumerator.
Marshal.ReleaseComObject(pEnum);
}
catch (Exception exception)
{
throw new InvalidOperationException("Failed to enumerate children.", exception);
}
// Sort the children.
var sortedChildren = children.Where(c => c.IsFolder).ToList();
sortedChildren.AddRange(children.Where(c => !c.IsFolder));
// Return the children.
return(sortedChildren);
}
/// <summary>
/// Gets the children.
/// </summary>
/// <param name="childTypes">The child types.</param>
/// <returns>
/// The children.
/// </returns>
public IEnumerable<ShellItem> GetChildren(ChildTypes childTypes)
{
// We'll return a list of children.
var children = new List<ShellItem>();
// Create the enum flags from the childtypes.
SHCONTF enumFlags = 0;
if (childTypes.HasFlag(ChildTypes.Folders))
enumFlags |= SHCONTF.SHCONTF_FOLDERS;
if (childTypes.HasFlag(ChildTypes.Files))
enumFlags |= SHCONTF.SHCONTF_NONFOLDERS;
if (childTypes.HasFlag(ChildTypes.Hidden))
enumFlags |= SHCONTF.SHCONTF_INCLUDEHIDDEN;
try
{
// Create an enumerator for the children.
IEnumIDList pEnum;
var result = ShellFolderInterface.EnumObjects(IntPtr.Zero, enumFlags, out pEnum);
// Validate the result.
if (result != 0)
{
// Throw the failure as an exception.
Marshal.ThrowExceptionForHR((int)result);
}
// TODO: This logic should go in the pidl manager.
// Enumerate the children, ten at a time.
const int batchSize = 10;
var pidlArray = Marshal.AllocCoTaskMem(IntPtr.Size * 10);
uint itemsFetched;
result = WinError.S_OK;
do
{
result = pEnum.Next(batchSize, pidlArray, out itemsFetched);
// Get each pidl.
var pidls = new IntPtr[itemsFetched];
Marshal.Copy(pidlArray, pidls, 0, (int) itemsFetched);
foreach (var childPidl in pidls)
{
// Create a new shell folder.
var childShellFolder = new ShellItem();
// Initialize it.
try
{
childShellFolder.Initialise(childPidl, this);
}
catch (Exception exception)
{
throw new InvalidOperationException("Failed to initialise child.", exception);
}
// Add the child.
children.Add(childShellFolder);
// Free the PIDL, reset the result.
Marshal.FreeCoTaskMem(childPidl);
}
} while (result == WinError.S_OK);
Marshal.FreeCoTaskMem(pidlArray);
// Release the enumerator.
if(Marshal.IsComObject(pEnum))
Marshal.ReleaseComObject(pEnum);
}
catch (Exception exception)
{
throw new InvalidOperationException("Failed to enumerate children.", exception);
}
// Sort the children.
var sortedChildren = children.Where(c => c.IsFolder).ToList();
sortedChildren.AddRange(children.Where(c => !c.IsFolder));
// Return the children.
return sortedChildren;
}
public DefinitionNodeCapabilities(TreeNode node) : base(node)
{
switch (Name.ToLowerInvariant())
{
case "shuffledefinition":
Comment = false;
Delete = false;
CutCopy = false;
ChildTypes.Add(new ChildNodeCapabilities("Blocks", false));
break;
case "blocks":
Delete = false;
CutCopy = false;
ChildTypes.Add(new ChildNodeCapabilities("DataBlock", true));
ChildTypes.Add(new ChildNodeCapabilities("SolutionBlock", true));
ChildTypes.Add(new ChildNodeCapabilities("#comment", true));
break;
case "datablock":
ChildTypes.Add(new ChildNodeCapabilities("Export", false));
ChildTypes.Add(new ChildNodeCapabilities("Import", false));
ChildTypes.Add(new ChildNodeCapabilities("Relation", true));
break;
case "solutionblock":
ChildTypes.Add(new ChildNodeCapabilities("Export", false));
ChildTypes.Add(new ChildNodeCapabilities("Import", false));
break;
case "export":
if (node.Parent.Name.ToLowerInvariant().StartsWith("datablock"))
{
if (!node.Nodes.Cast <TreeNode>().Any(n => n.Name == "FetchXML"))
{
ChildTypes.Add(new ChildNodeCapabilities("Filter", true));
ChildTypes.Add(new ChildNodeCapabilities("Sort", true));
ChildTypes.Add(new ChildNodeCapabilities("Attributes", false));
}
if (node.Nodes.Count == 0)
{
ChildTypes.Add(new ChildNodeCapabilities("-", false));
ChildTypes.Add(new ChildNodeCapabilities("FetchXML", false));
}
}
else if (node.Parent.Name.ToLowerInvariant().StartsWith("solutionblock"))
{
ChildTypes.Add(new ChildNodeCapabilities("Settings", false));
}
break;
case "import":
if (node.Parent.Name.ToLowerInvariant().StartsWith("datablock"))
{
ChildTypes.Add(new ChildNodeCapabilities("Match", false));
}
else if (node.Parent.Name.ToLowerInvariant().StartsWith("solutionblock"))
{
ChildTypes.Add(new ChildNodeCapabilities("PreRequisites", false));
}
break;
case "attributes":
//Delete = false;
ChildTypes.Add(new ChildNodeCapabilities("Attribute", true));
break;
case "match":
ChildTypes.Add(new ChildNodeCapabilities("Attribute", true));
break;
case "attribute":
Delete = node.Parent != null && node.Parent.Nodes.Count > 1;
break;
case "filter":
case "sort":
case "relation":
case "settings":
break;
case "prerequisites":
ChildTypes.Add(new ChildNodeCapabilities("Solution", true));
break;
case "solution":
Delete = node.Parent != null && node.Parent.Nodes.Count > 1;
break;
case "#comment":
Comment = false;
Uncomment = true;
break;
}
}
