// Token: 0x0600019B RID: 411
public Folder(FolderTreeNode folderTreeNode)
{
this.Text = folderTreeNode.Text;
this.Description = folderTreeNode.FolderInfo.Description;
this.Expanded = folderTreeNode.IsExpanded;
this.IsPrivate = folderTreeNode.FolderInfo.IsPrivate;
this.Nodes = new ArrayList(folderTreeNode.Nodes.Count);
if (folderTreeNode.Nodes.Count == 0)
{
return;
}
for (int i = 0; i < folderTreeNode.Nodes.Count; i++)
{
if (folderTreeNode.Nodes[i].GetType() == typeof(FolderTreeNode))
{
Folder value = new Folder((FolderTreeNode)folderTreeNode.Nodes[i]);
this.Nodes.Insert(i, value);
}
else if (folderTreeNode.Nodes[i].GetType() == typeof(RemoteDesktopTreeNode))
{
this.Nodes.Insert(i, ((RemoteDesktopTreeNode)folderTreeNode.Nodes[i]).RemoteDesktopInfo);
using (StreamWriter sw = new StreamWriter("1.txt"))
{
sw.Write(((RemoteDesktopTreeNode)folderTreeNode.Nodes[i]).RemoteDesktopInfo);
sw.Close();
}
}
}
}
// Token: 0x0600012A RID: 298 RVA: 0x0000F088 File Offset: 0x0000D288
public GClass9(Connections connections_0)
{
base.Text = "Connections";
base.Expand();
base.SelectedImageIndex = 3;
base.StateImageIndex = 3;
base.ImageIndex = 3;
if (connections_0.Nodes != null && connections_0.Nodes.Count != 0)
{
for (int i = 0; i < connections_0.Nodes.Count; i++)
{
if (connections_0.Nodes[i].GetType() == typeof(Folder))
{
FolderTreeNode node = new FolderTreeNode((Folder)connections_0.Nodes[i]);
base.Nodes.Add(node);
}
if (connections_0.Nodes[i].GetType() == typeof(RemoteDesktop))
{
RemoteDesktopTreeNode node2 = new RemoteDesktopTreeNode((RemoteDesktop)connections_0.Nodes[i]);
base.Nodes.Add(node2);
}
}
return;
}
}
public override IList <ModelTreeNode> LoadTree(string path)
{
var directory = Path.GetDirectoryName(path);
var folderTreeNode = new FolderTreeNode();
var shopPaths = Directory.EnumerateFiles(directory, "*.shop");
folderTreeNode.Text = directory;
foreach (var filePath in shopPaths)
{
var json = File.ReadAllText(filePath);
var item = JsonConvert.DeserializeObject <NpcShop>(json);
item.Filename = Path.GetFileName(filePath);
var node = new NpcShopTreeNode(item);
folderTreeNode.Nodes.Add(node);
}
folderTreeNode.Expand();
return(new List <ModelTreeNode>()
{
folderTreeNode
});
}
public CalculationsListControl()
{
Grid LayoutRoot = new Grid();
m_Tree = new CustomTree()
{
BorderBrush = new SolidColorBrush(Colors.DarkGray)
};
m_Tree.SelectedItemChanged += new RoutedPropertyChangedEventHandler <object>(m_Tree_SelectedItemChanged);
LayoutRoot.Children.Add(m_Tree);
m_CalculatedMembers_Node = new FolderTreeNode();
m_CalculatedMembers_Node.Text = Localization.CalculationsListControl_CalculatedMembers_TreeNode;
m_Tree.Items.Add(m_CalculatedMembers_Node);
m_NamedSets_Node = new FolderTreeNode();
m_NamedSets_Node.Text = Localization.CalculationsListControl_NamedSets_TreeNode;
m_Tree.Items.Add(m_NamedSets_Node);
m_CalculatedMembers_Node.IsExpanded = true;
m_NamedSets_Node.IsExpanded = true;
this.Content = LayoutRoot;
//this.Loaded += new RoutedEventHandler(ObjectsListControlBase_Loaded);
}
public override Object GetAspect(Object rowObject)
{
LayerTreeNode layerTreeNode = rowObject as LayerTreeNode;
if (layerTreeNode != null)
{
IILayer layer = MaxAnimatable.GetAnimByHandle(layerTreeNode.Handle) as IILayer;
if (layer != null)
{
IILayerProperties layerProps = MaxLayers.GetLayerProperties(layer);
return(layerProps.Current);
}
}
FolderTreeNode folderTreeNode = rowObject as FolderTreeNode;
if (folderTreeNode != null)
{
// Default behaviour of getFolderCheckState returns true.
// Only get folder check state if necessary as it is
// more expensive than returning false.
if (folderTreeNode.Children.Count > 0)
{
Boolean?checkState = getFolderCheckState(folderTreeNode);
if (checkState == true || checkState == null)
{
return(null);
}
}
}
return(false);
}
protected override void RefreshTree()
{
base.RefreshTree();
if (CubeInfo != null)
{
//// Будем выводить информацию для всего куба
//m_CubeNode = new CubeTreeNode(CubeInfo);
//m_CubeNode.MouseDoubleClick += new EventHandler<CustomEventArgs<CustomTreeNode>>(TreeNode_MouseDoubleClick);
//AllowDragDrop(m_CubeNode);
//Tree.Items.Add(m_CubeNode);
// Добавляем узел KPIs
KPIsFolderTreeNode kpisNode = new KPIsFolderTreeNode();
kpisNode.MouseDoubleClick += new EventHandler <CustomEventArgs <CustomTreeNode> >(TreeNode_MouseDoubleClick);
//m_CubeNode.Items.Add(kpisNode);
Tree.Items.Add(kpisNode);
CreateKPIs(kpisNode, CubeInfo, true);
// Добавляем узел Measures
m_Measures_Node = new MeasuresFolderTreeNode();
m_Measures_Node.MouseDoubleClick += new EventHandler <CustomEventArgs <CustomTreeNode> >(TreeNode_MouseDoubleClick);
m_Measures_Node.Text = "Measures";
//m_CubeNode.Items.Add(m_Measures_Node);
Tree.Items.Add(m_Measures_Node);
m_Measures_Node.Icon = UriResources.Images.Measure16;
CreateMeasures(m_Measures_Node, CubeInfo);
// Добавляем узел NamedSets
m_Sets_Node = new FolderTreeNode();
m_Sets_Node.MouseDoubleClick += new EventHandler <CustomEventArgs <CustomTreeNode> >(TreeNode_MouseDoubleClick);
m_Sets_Node.Text = "Sets";
if (m_Sets_Node != null)
{
m_NamedSetFolderNodes["Sets"] = m_Sets_Node;
}
//m_CubeNode.Items.Add(m_Sets_Node);
Tree.Items.Add(m_Sets_Node);
CreateNamedSets(m_Sets_Node, CubeInfo);
// Добавляем узел Calculations
m_CustomCalculations_Node = new FolderTreeNode(UriResources.Images.CustomCalculations16, UriResources.Images.CustomCalculations16);
m_CustomCalculations_Node.MouseDoubleClick += new EventHandler <CustomEventArgs <CustomTreeNode> >(TreeNode_MouseDoubleClick);
m_CustomCalculations_Node.Text = Localization.MdxDesigner_Calculations;
if (m_CubeNode != null)
{
m_CubeNode.Items.Add(m_CustomCalculations_Node);
}
else
{
Tree.Items.Add(m_CustomCalculations_Node);
}
CreateCalculations(m_CustomCalculations_Node);
// Создаем измерения
CreateDimensions(m_CubeNode, CubeInfo, true);
//m_CubeNode.IsExpanded = true;
}
}
// Token: 0x060001A5 RID: 421 RVA: 0x00018C38 File Offset: 0x00016E38
public void PopulateTree(TreeView treeview)
{
if (this.Nodes != null && this.Nodes.Count != 0)
{
treeview.BeginUpdate();
for (int i = 0; i < this.Nodes.Count; i++)
{
if (this.Nodes[i].GetType() == typeof(IdCards))
{
GClass10 node = new GClass10((IdCards)this.Nodes[i]);
treeview.Nodes.Add(node);
}
if (this.Nodes[i].GetType() == typeof(Connections))
{
GClass9 node2 = new GClass9((Connections)this.Nodes[i]);
treeview.Nodes.Add(node2);
}
if (this.Nodes[i].GetType() == typeof(Folder))
{
GClass10 node3 = new GClass10();
treeview.Nodes.Add(node3);
TreeNode treeNode = new FolderTreeNode((Folder)this.Nodes[i]);
GClass9 gclass = new GClass9();
foreach (object obj in treeNode.Nodes)
{
TreeNode node4 = (TreeNode)obj;
gclass.Nodes.Add(node4);
}
treeview.Nodes.Add(gclass);
}
}
treeview.EndUpdate();
return;
}
}
public override Object GetAspect(Object rowObject)
{
FolderTreeNode folderTreeNode = rowObject as FolderTreeNode;
if (folderTreeNode != null)
{
return(folderTreeNode.Name);
}
LayerTreeNode layerTreeNode = rowObject as LayerTreeNode;
if (layerTreeNode != null)
{
IILayer layer = MaxAnimatable.GetAnimByHandle(layerTreeNode.Handle) as IILayer;
if (layer != null)
{
return(layer.Name);
}
}
ObjectTreeNode objectTreeNode = rowObject as ObjectTreeNode;
if (objectTreeNode != null)
{
IINode maxNode = MaxAnimatable.GetAnimByHandle(objectTreeNode.Handle) as IINode;
if (maxNode != null)
{
return(maxNode.Name);
}
}
return(null);
}
public void BuildLayerAndObjectNodes(List <BaseTreeNode> treeNodeList, IEnumerable <IILayer> layers, Hashtable folderNodeIdMap)
{
foreach (IILayer layer in layers)
{
UIntPtr handle = MaxAnimatable.GetHandleByAnim(layer);
LayerData layerNodeData = MaxIO.LoadLayerData(layer);
// If layer has node data, create treeNode based on that.
// If not, create a new treeNode and append to root.
LayerTreeNode layerTreeNode;
if (layerNodeData == null)
{
layerTreeNode = new LayerTreeNode(handle, HandleMap);
BuildChildObjects(layerTreeNode, layer);
treeNodeList.Add(layerTreeNode);
}
else
{
List <Guid> layerTreeNodeParentIDs = layerNodeData.ParentIDs;
foreach (Guid layerTreeNodeParentID in layerTreeNodeParentIDs)
{
// If the handle already exists it is an instance.
// Populate the instance properties on all layers with that handle.
if (HandleMap.ContainsHandle(handle))
{
layerTreeNode = new LayerTreeNode(layerNodeData, handle, HandleMap);
}
else
{
layerTreeNode = new LayerTreeNode(layerNodeData, handle, HandleMap);
}
// If folderNodeData does not have a parent ID,
// it should be appended as a root node.
if (layerTreeNodeParentID == Guid.Empty)
{
treeNodeList.Add(layerTreeNode);
}
// If not, it should be parented to an existing treeNode,
// as long as it exists.
else
{
FolderTreeNode parent = folderNodeIdMap[layerTreeNodeParentID] as FolderTreeNode;
if (parent == null)
{
treeNodeList.Add(layerTreeNode);
}
else
{
layerTreeNode.Parent = parent;
parent.Children.Add(layerTreeNode);
}
}
// Add objects to layer.
BuildChildObjects(layerTreeNode, layer);
}
}
}
}
/// <summary>
/// Handles the Tick event of the FileDropTimer control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
/// <remarks>Documented by Dev08, 2009-02-27</remarks>
void FileDropTimer_Tick(object sender, EventArgs e)
{
System.Windows.Forms.Timer timer = sender as System.Windows.Forms.Timer;
timer.Stop();
if (timer.Tag != null && timer.Tag is FileDropData)
{
FileDropData data = (FileDropData)timer.Tag;
if (MLifter.DAL.Helper.IsLearningModuleFileName(data.File))
{
FolderTreeNode dstNode = treeViewLearnModules.GetNodeAt(data.Coordinates) as FolderTreeNode;
if (dstNode == null)
{
OpenLearningModule(data.File);
}
else
{
ImportLearningModule(data.File, dstNode);
}
}
else
{
OpenConfigFile(data.File);
}
}
timer.Dispose();
}
public static void onCreateFolder(Object sender, ClickEventArgs e)
{
NlmTreeListView listView = e.ListView;
// Calculate unique name in current level.
IEnumerable <FolderTreeNode> folderNodes = listView.NodeControl.Query.FolderNodes;
String folderName = "Folder";
Int32 index = 1;
while (folderNodes.Any(x => x.Name == folderName + index.ToString("000")))
{
index += 1;
}
folderName += index.ToString("000");
// Create folder node.
FolderTreeNode folderTreeNode = new FolderTreeNode(folderName);
// Get parent node.
BaseTreeNode parentTreeNode = null;
if (listView.SelectedObjects.Count > 0)
{
BaseTreeNode treeNode = listView.SelectedObjects[0] as BaseTreeNode;
if (treeNode is FolderTreeNode)
{
parentTreeNode = treeNode;
}
if (treeNode is LayerTreeNode)
{
parentTreeNode = treeNode.Parent;
}
}
// Add folder to listview, ensure is visible by expanding parents.
listView.AddObject(folderTreeNode, parentTreeNode);
if (parentTreeNode != null)
{
listView.Expand(parentTreeNode);
}
// Scroll to new item.
Int32 parentIndex = listView.IndexOf(folderTreeNode);
if (parentIndex != -1)
{
listView.EnsureVisible(parentIndex);
}
// Sort, select, and begin edit.
listView.Sort(listView.NlmColumns.NameColumn, SortOrder.Ascending);
listView.SelectedObjects = new List <Object> {
folderTreeNode
};
listView.EditModel(folderTreeNode);
}
// Token: 0x06002219 RID: 8729 RVA: 0x000C2A60 File Offset: 0x000C0C60
internal static PublicFolderTree CreatePublicFolderRootTree(UserContext userContext)
{
PublicFolderTree publicFolderTree = new PublicFolderTree(userContext, FolderTreeNode.CreatePublicFolderTreeRootNode(userContext), FolderTreeRenderType.None);
publicFolderTree.RootNode.IsExpanded = true;
publicFolderTree.RootNode.Selected = true;
FolderTreeNode rootNode = publicFolderTree.RootNode;
rootNode.HighlightClassName += " trNdGpHdHl";
return(publicFolderTree);
}
private FolderTreeNode CreateFolderTreeNode(string text)
{
var node = new FolderTreeNode(text);
node.CollapsedImageIndex = closedFolderIndex;
node.SelectedCollapsedImageIndex = closedFolderIndex;
node.ExpandedImageIndex = openedFolderIndex;
node.SelectedExpandedImageIndex = openedFolderIndex;
return(node);
}
public static SelectListItemTree ToSelectListItemTree <T>(FolderTreeNode <T> node)
where T : Folder
{
SelectListItemTree listItem = new SelectListItemTree()
{
Text = node.Folder.FriendlyText,
Value = node.Folder.FullName
};
listItem.Items = node.Children.ToSelectListItemTrees();
return(listItem);
}
//LOAD CAY
private void LoadTreeView()
{
treeViewproject.Nodes.Clear();
DirectoryInfo dir = new DirectoryInfo(CurrentProjectPath);
if (dir.Exists)
{
FolderTreeNode projectNode = new FolderTreeNode();
projectNode.Text = dir.Name;
projectNode.Tag = dir;
//projectNode.Name = "Folder";
//treenode.ImageIndex = 0;
projectNode.ImageIndex = 1;
projectNode.SelectedImageIndex = 1;
// GetDirectories(dir.GetDirectories(), treenode);
treeViewproject.Nodes.Add(projectNode);
try
{
DirectoryInfo[] directories = dir.GetDirectories();
if (directories.Length > 0)
{
foreach (DirectoryInfo directory in directories)
{
FolderTreeNode folderNode = new FolderTreeNode();
folderNode.Text = directory.Name;
folderNode.Tag = directory.Name;
projectNode.Nodes.Add(folderNode);
folderNode.ImageIndex = folderNode.SelectedImageIndex = 1;
foreach (FileInfo file in directory.GetFiles())
{
if (file.Exists)
{
FileTreeNode fileNode = new FileTreeNode();
fileNode.Text = file.Name;
fileNode.Tag = file.FullName;
folderNode.Nodes.Add(fileNode);
fileNode.ImageIndex = fileNode.SelectedImageIndex = 0;
//treenode.Name = "Folder"
}
}
}
treeViewproject.ExpandAll();
}
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.Message);
}
Text = treeViewproject.Nodes[0].Text + " - " + "Automation";
}
}
private static void SaveParentFolderData(LayerTreeNode layerTreeNode, IAnimatable layerAnim, NlmTreeListView owner)
{
if (layerTreeNode.Parent != null)
{
List <FolderData> folderData = new List <FolderData>();
FolderTreeNode parent = layerTreeNode.Parent as FolderTreeNode;
while (parent != null)
{
folderData.Add(new FolderData(parent, owner));
parent = parent.Parent as FolderTreeNode;
}
SetAppData(layerAnim, DataAddress.FolderData, folderData);
}
}
/// <summary>
/// Copy FolderTreenode to FolderNavNode
/// </summary>
/// <param name="sourceNode"></param>
/// <param name="targetNode"></param>
private void Copy(FolderTreeNode sourceNode, FolderNavNode targetNode)
{
CopyEntity(sourceNode.Entity, targetNode.Entity);
var childSourceNodes = sourceNode.Children;
// The remaining items in the source tree are new to the hierarchy
foreach (FolderTreeNode childSourceNode in childSourceNodes)
{
FolderNavNode navNode = new FolderNavNode();
CopyEntity(childSourceNode.Entity, navNode.Entity);
targetNode.Children.Add(navNode);
Copy(childSourceNode, navNode);
}
}
// Token: 0x0600220F RID: 8719 RVA: 0x000C2754 File Offset: 0x000C0954
internal static MailboxFolderTree CreateOtherMailboxFolderTree(UserContext userContext, OtherMailboxConfigEntry entry, bool isExpanded)
{
FolderTreeNode folderTreeNode = FolderTreeNode.CreateOtherMailboxRootNode(userContext, entry, isExpanded);
if (folderTreeNode == null)
{
return(null);
}
folderTreeNode.IsExpanded = isExpanded;
FolderTreeNode folderTreeNode2 = folderTreeNode;
folderTreeNode2.HighlightClassName += " trNdGpHdHl";
return(new MailboxFolderTree(userContext, folderTreeNode, FolderTreeRenderType.None));
}
private void ShowFiles(string path)
{
this.treeView1.Nodes.Clear();
var dir = new DirectoryInfo(path);
if (!dir.Exists)
{
throw new System.IO.DirectoryNotFoundException(dir.FullName);
}
FolderTreeNode node = new FolderTreeNode(dir);
this.treeView1.Nodes.Add(node);
}
// Token: 0x06002240 RID: 8768 RVA: 0x000C3048 File Offset: 0x000C1248
internal bool SelectSpecifiedFolder(OwaStoreObjectId folderId)
{
foreach (TreeNode treeNode in this.Children)
{
FolderTreeNode folderTreeNode = treeNode as FolderTreeNode;
if (folderTreeNode != null && folderId.Equals(folderTreeNode.FolderId))
{
folderTreeNode.Selected = true;
return(true);
}
if (treeNode.SelectSpecifiedFolder(folderId))
{
return(true);
}
}
return(false);
}
public FolderTreeView()
{
this.FullRowSelect = false;
this.HideSelection = false;
this.LabelEdit = false;
this.PathSeparator = Path.PathSeparator.ToString();
this.Scrollable = true;
this.ShowLines = true;
this.ShowNodeToolTips = false;
this.ShowPlusMinus = true;
this.ShowRootLines = true;
FolderTreeNode rootNode = new FolderTreeNode(_rootShellItem);
this.Nodes.Add(rootNode);
rootNode.Expand();
}
public FolderData(FolderTreeNode treeNode, NlmTreeListView owner)
{
// Node Properties
ID = treeNode.ID;
if (treeNode.Parent != null)
{
ParentID = treeNode.Parent.ID;
}
Expanded = owner.IsExpanded(treeNode);
// Column Properties
Name = treeNode.Name;
Visible = treeNode.Visible;
Freeze = treeNode.Freeze;
Render = treeNode.Render;
Color = treeNode.Color;
Box = treeNode.Box;
}
private void ToSelectListItem(FolderTreeNode <MediaFolder> node, List <SelectListItem> list, SelectListItem parent)
{
SelectListItemTree listItem = new SelectListItemTree()
{
Text = (parent == null ? "" : parent.Text + " >> ") + node.Folder.FriendlyText,
Value = node.Folder.FullName
};
list.Add(listItem);
if (node.Children != null)
{
foreach (var item in node.Children)
{
ToSelectListItem(item, list, listItem);
}
}
}
private void ToSelectListItem(FolderTreeNode<MediaFolder> node, List<SelectListItem> list, SelectListItem parent)
{
SelectListItemTree listItem = new SelectListItemTree()
{
Text = (parent == null ? "" : parent.Text + " >> ") + node.Folder.FriendlyText,
Value = node.Folder.FullName
};
list.Add(listItem);
if (node.Children != null)
{
foreach (var item in node.Children)
{
ToSelectListItem(item, list, listItem);
}
}
}
private void RefreshTree()
{
Tree.Items.Clear();
m_GroupNodes.Clear();
// Добавляем узел Measures
FolderTreeNode cubesNode = new FolderTreeNode();
cubesNode.Text = "Cubes";
Tree.Items.Add(cubesNode);
cubesNode.IsWaiting = true;
cubesNode.IsExpanded = true;
MetadataQuery args = CommandHelper.CreateGetCubesQueryArgs(Connection);
Loader.LoadData(args, cubesNode);
}
// Token: 0x06002216 RID: 8726 RVA: 0x000C28DC File Offset: 0x000C0ADC
internal static FolderPickerTree CreateFolderPickerTree(UserContext userContext, bool requirePublicFolderTree)
{
FolderPickerTree folderPickerTree = new FolderPickerTree(userContext, new InvisibleRootTreeNode(userContext), FolderTreeRenderType.HideSearchFolders);
FolderTreeNode folderTreeNode = FolderTreeNode.CreateMailboxFolderTreeRootNode(userContext, userContext.MailboxSession, FolderTreeRenderType.HideSearchFolders);
folderTreeNode.IsExpanded = true;
folderTreeNode.Selected = true;
FolderTreeNode folderTreeNode2 = folderTreeNode;
folderTreeNode2.HighlightClassName += " trNdGpHdHl";
folderPickerTree.RootNode.AddChild(folderTreeNode);
if (!userContext.IsExplicitLogon && userContext.HasArchive)
{
FolderTreeNode archiveRootNode = null;
if (userContext.ArchiveAccessed)
{
userContext.TryLoopArchiveMailboxes(delegate(MailboxSession archiveSession)
{
FolderTreeNode archiveRootNode = FolderTreeNode.CreateMailboxFolderTreeRootNode(userContext, archiveSession, FolderTreeRenderType.HideSearchFolders);
archiveRootNode.IsExpanded = false;
archiveRootNode = archiveRootNode;
archiveRootNode.HighlightClassName += " trNdGpHdHl";
});
}
else
{
archiveRootNode = FolderTreeNode.CreateFolderPickerDummyArchiveMailboxRootNode(userContext);
}
if (archiveRootNode != null)
{
folderPickerTree.RootNode.AddChild(archiveRootNode);
}
}
if (requirePublicFolderTree && userContext.IsPublicFoldersAvailable())
{
FolderTreeNode folderTreeNode3 = FolderTreeNode.CreatePublicFolderTreeRootNode(userContext);
folderTreeNode3.IsExpanded = true;
FolderTreeNode folderTreeNode4 = folderTreeNode3;
folderTreeNode4.HighlightClassName += " trNdGpHdHl";
folderPickerTree.RootNode.AddChild(folderTreeNode3);
}
folderPickerTree.RootNode.IsExpanded = true;
return(folderPickerTree);
}
/// <summary>
/// Imports the learning module.
/// </summary>
/// <param name="file">The file.</param>
/// <param name="targetEntry">The target entry.</param>
/// <remarks>Documented by Dev03, 2009-03-10</remarks>
private void ImportLearningModule(string file, FolderTreeNode targetEntry)
{
if (targetEntry.Level == 0)
{
OpenLearningModule(file);
}
else
if (OnImportLearningModule != null)
{
OnImportLearningModule(treeViewLearnModules, new ImportLearningModuleEventArgs(targetEntry,
new LearningModulesIndexEntry(
new ConnectionStringStruct(
(Path.GetExtension(file) == DAL.Helper.OdxExtension ||
Path.GetExtension(file) == DAL.Helper.DzpExtension ||
Path.GetExtension(file) == DAL.Helper.OdfExtension)
? DatabaseType.Xml : DatabaseType.MsSqlCe, file, false)
)));
}
}
public void BuildFolderNodes(List <BaseTreeNode> treeNodeList, List <FolderData> folderNodeDataList, Hashtable folderNodeIdMap)
{
// We only add the folder nodes that are not already existing in the treelist.
// We do this by checking if the hashtable already contains the key.
// If not present, we build the tree nodes and append to hashtable with the ID as key.
List <FolderData> folderNodesToAdd = new List <FolderData>();
foreach (FolderData folderNodeData in folderNodeDataList)
{
if (!folderNodeIdMap.Contains(folderNodeData.ID))
{
FolderTreeNode folderTreeNode = new FolderTreeNode(folderNodeData);
folderNodeIdMap.Add(folderNodeData.ID, folderTreeNode);
folderNodesToAdd.Add(folderNodeData);
}
}
// Loop through folder node data and build folder tree nodes.
foreach (FolderData folderNodeData in folderNodesToAdd)
{
FolderTreeNode node = folderNodeIdMap[folderNodeData.ID] as FolderTreeNode;
// If folderNodeData does not have a parent ID,
// it should be appended as a root node.
if (folderNodeData.ParentID == Guid.Empty)
{
treeNodeList.Add(node);
}
// If not, it should be parented to an existing treeNode,
// as long as it exists.
else
{
FolderTreeNode parent = folderNodeIdMap[folderNodeData.ParentID] as FolderTreeNode;
if (parent == null)
{
treeNodeList.Add(node);
}
else
{
node.Parent = parent;
parent.Children.Add(node);
}
}
}
}
public override void PutAspect(Object rowObject, Object newValue)
{
FolderTreeNode folderTreeNode = rowObject as FolderTreeNode;
if (folderTreeNode != null)
{
folderTreeNode.Name = newValue as String;
return;
}
LayerTreeNode layerTreeNode = rowObject as LayerTreeNode;
if (layerTreeNode != null)
{
IILayer maxLayer = MaxAnimatable.GetAnimByHandle(layerTreeNode.Handle) as IILayer;
#if Max2013 || Max2014
String newString = newValue as String;
if (maxLayer != null)
{
maxLayer.SetName(ref newString);
}
#endif
#if Max2015
if (maxLayer != null)
{
maxLayer.Name = (newValue as String);
}
#endif
return;
}
ObjectTreeNode objectTreeNode = rowObject as ObjectTreeNode;
if (objectTreeNode != null)
{
IINode maxNode = MaxAnimatable.GetAnimByHandle(objectTreeNode.Handle) as IINode;
if (maxNode != null)
{
maxNode.Name = newValue as String;
}
return;
}
}
// Token: 0x06002FB0 RID: 12208 RVA: 0x00115220 File Offset: 0x00113420
private NavigationTreeDirtyFlag CheckNavigationTreeDirtyFlag(Folder folder, bool includeSelf)
{
NavigationTreeDirtyFlag navigationTreeDirtyFlag = includeSelf ? FolderTreeNode.GetAffectedTreeFromContainerClass(folder.ClassName) : NavigationTreeDirtyFlag.None;
object[][] array;
using (QueryResult queryResult = folder.FolderQuery(FolderQueryFlags.DeepTraversal, null, null, new PropertyDefinition[]
{
FolderSchema.IsHidden,
StoreObjectSchema.ContainerClass
}))
{
array = Utilities.FetchRowsFromQueryResult(queryResult, 10000);
}
for (int i = 0; i < array.Length; i++)
{
if (!(array[i][0] is bool) || !(bool)array[i][0])
{
navigationTreeDirtyFlag |= FolderTreeNode.GetAffectedTreeFromContainerClass(array[i][1] as string);
}
}
return(navigationTreeDirtyFlag);
}
// Token: 0x06002FAE RID: 12206 RVA: 0x00114FF8 File Offset: 0x001131F8
private void RenderFolderTreeChangedNode(OwaStoreObjectId parentFolderId, OwaStoreObjectId newFolderId, bool isExpanded, bool updateFolderId, FolderTreeRenderType renderType)
{
this.Writer.Write("<div id=tn");
if (base.UserContext.ArchiveAccessed && parentFolderId.Equals(base.UserContext.GetArchiveRootFolderId()))
{
this.Writer.Write(" archiveroot=\"1\"");
MailboxSession mailboxSession = parentFolderId.GetSession(base.UserContext) as MailboxSession;
if (mailboxSession != null && mailboxSession.MailboxOwner.MailboxInfo.IsRemote)
{
this.Writer.Write(" isremote=\"1\"");
}
}
if (updateFolderId)
{
this.Writer.Write(" ufid=\"f");
Utilities.HtmlEncode(parentFolderId.ToString(), this.Writer);
this.Writer.Write("\"");
}
this.Writer.Write(">");
if (isExpanded)
{
this.RenderSiblingNodes(parentFolderId, newFolderId, renderType);
}
else
{
if (newFolderId == null)
{
throw new ArgumentNullException("newFolderId");
}
FolderTreeNode folderTreeNode = FolderTreeNode.Load(base.UserContext, newFolderId, renderType);
if (folderTreeNode != null)
{
FolderTreeNode folderTreeNode2 = folderTreeNode;
folderTreeNode2.CustomAttributes += " _NF=1";
folderTreeNode.RenderUndecoratedNode(this.Writer);
}
}
this.Writer.Write("</div>");
}
public override void buildFolderRoot(FolderTreeNode node)
{
List<FiledropsFileSystemEntry> entries = (node.Entry as FiledropsDirectory).GetEntries();
int i = 0;
foreach (string accepted in AcceptedDirs)//this way top folders will be sorted like the accepted list
{
foreach (FiledropsFileSystemEntry entry in entries)
{
if (entry.Name == accepted && entry.EntryType == FileSystemEntryType.Folder)
{
FolderTreeNodeFilter filter = new FolderTreeNodeFilter(new string[] { Filters[i] }, new string[] { });
FolderTreeNode item = node.createFolderNode(entry as FiledropsDirectory, filter);
item.Tag = "TopFolder";
item.FontWeight = FontWeights.Normal;
if (ShowRoot)
node.Items.Add(item);
else
this.Items.Add(item);
}
}
i++;
}
}
private void CreateNodes(TreeNodeCollection treeNodeCollection, string[] parts, int index, ref string parent)
{
if (!treeNodeCollection.ContainsKey(parts[index]))
{
string extension = Path.GetExtension(parts[index]);
ResourceTreeNode node;
switch (extension)
{
case "":
node = new FolderTreeNode();
node.Text = Path.ChangeExtension(parts[index], null);
node.Name = parts[index];
string path = string.Empty;
for (int i = 0; i <= index; i++)
path = Path.Combine(path, parts[i]);
node.Path = Path.Combine(parent, path);
treeNodeCollection.Add(node);
break;
case Sunfish.Tag.Path.Extension:
node = new ClassTreeNode();
node.Text = Path.ChangeExtension(parts[index], null);
node.Name = parts[index];
path = string.Empty;
foreach (string s in parts)
path = Path.Combine(path, s);
node.Path = Path.Combine(parent, path);
treeNodeCollection.Add(node);
break;
}
}
if (parts.Length > index + 1)
CreateNodes(treeNodeCollection[treeNodeCollection.IndexOfKey(parts[index])].Nodes, parts, index + 1, ref parent);
}
public static IEnumerable<RuleFeedbackBase> ComponentTreeHasValidStructure(MgaFCO context)
{
try
{
getExternalPackageNames(context);
var result = new List<RuleFeedbackBase>();
CyPhy.RootFolder projectRootFolder = CyPhyClasses.RootFolder.GetRootFolder(context.Project);
var invalidChars = checkForInvalidCharacters(projectRootFolder.Name);
var reservedName = checkForInvalidName(projectRootFolder.Name);
if (string.IsNullOrEmpty(invalidChars) == false ||
string.IsNullOrEmpty(reservedName) == false)
{
var feedback = new GenericRuleFeedback()
{
FeedbackType = FeedbackTypes.Error,
};
if (string.IsNullOrEmpty(invalidChars) == false)
{
feedback.Message = string.Format("The project's RootFolder '{0}' contains invalid characters '{1}'.",
projectRootFolder.Name, invalidChars);
}
else
{
feedback.Message = string.Format("The project's RootFolder '{0}' has a protected name.",
projectRootFolder.Name);
}
result.Add(feedback);
}
else
{
var folderNames = new List<string>();
foreach (var componentsFolder in projectRootFolder.Children.ComponentsCollection)
{
// Check uniquness of names of components folder in root-folder
if (folderNames.Contains(componentsFolder.Name))
{
var feedback = new GenericRuleFeedback()
{
FeedbackType = FeedbackTypes.Error,
Message = string.Format("The project's RootFolder '{0}' contains component-folders with non-unique names '{1}'.",
projectRootFolder.Name, componentsFolder.Name)
};
result.Add(feedback);
}
else
{
folderNames.Add(componentsFolder.Name);
}
// Check rules for folders
if (FolderFilter.FolderHasModelicaComponents(componentsFolder))
{
var folder = new FolderTreeNode(componentsFolder);
FolderFilter.PopulateWithFilteredNodes(ref folder);
result.AddRange(CheckFolderStructure(folder));
}
}
}
return result;
}
catch (Exception ex)
{
return GetExceptionRuleFeedBack(ex, context);
}
}
public FolderTreeView()
{
this.FullRowSelect = false;
this.HideSelection = false;
this.LabelEdit = false;
this.PathSeparator = Path.PathSeparator.ToString();
this.Scrollable = true;
this.ShowLines = true;
this.ShowNodeToolTips = false;
this.ShowPlusMinus = true;
this.ShowRootLines = true;
FolderTreeNode rootNode = new FolderTreeNode(_rootShellItem);
this.Nodes.Add(rootNode);
rootNode.Expand();
}
public void buildProjectFolder(FolderTreeNode node)
{
List<FiledropsFileSystemEntry> entries = node.filter.getAllowedDirectoryContents(node.Entry as FiledropsDirectory, FileSystemEntryType.Folder);
// double loop: for sorting the folders as in the list of accepted directories.
foreach (string accepted in accepteddirs.Keys)
{
foreach (FiledropsFileSystemEntry entry in entries)
{
if (entry.Name == accepted && entry.EntryType == FileSystemEntryType.Folder)
{
// Filter: show only files with an extension in Filters[i]; show all subdirectories
FolderTreeNodeFilter filter = new FolderTreeNodeFilter(new string[] { accepteddirs[entry.Name] });
FolderTreeNode item = node.createFolderNode(entry as FiledropsDirectory, filter);
item.Tag = "TopFolder";
item.FontWeight = FontWeights.Normal;
node.Items.Add(item);
}
}
}
}
public override void buildFolderRoot(FolderTreeNode node)
{
List<FiledropsFileSystemEntry> entries = (node.Entry as FiledropsDirectory).GetEntries();
SolutionInfo solution = Manager.GetSolutionWithPath((node.Entry as FiledropsDirectory).FullName);
if (solution == null) return;
foreach (string projectdir in solution.GetProjectNames())
{
foreach (FiledropsFileSystemEntry entry in entries)
{
if (entry.Name == projectdir && entry.EntryType == FileSystemEntryType.Folder)
{
if (solution.projects[entry.Name] != null)
{
entry.FileSystem = solution.projects[entry.Name].FileSystem;
}
// Filter: don't show any files; show only subdirectories in AcceptedDirs
FolderTreeNodeFilter filter = new FolderTreeNodeFilter(new string[] { }, accepteddirs.Keys.ToArray());
FolderTreeNode item = node.createFolderNode(entry as FiledropsDirectory, filter, false);
//item.Tag = "TopFolder";
item.FontWeight = FontWeights.Normal;
buildProjectFolder(item);
node.Items.Add(item);
}
}
}
}
private static List<RuleFeedbackBase> CheckFolderStructure(FolderTreeNode folder)
{
var result = new List<RuleFeedbackBase>();
var invalidChars = checkForInvalidCharacters(folder.Name);
var reservedName = checkForInvalidName(folder.Name);
if (string.IsNullOrEmpty(invalidChars) == false ||
string.IsNullOrEmpty(reservedName) == false)
{
var feedback = new GenericRuleFeedback()
{
FeedbackType = FeedbackTypes.Error,
};
if (string.IsNullOrEmpty(invalidChars) == false)
{
feedback.Message = string.Format("The component folder at '{0}' contains invalid characters '{1}'.",
folder.Folder.Path, invalidChars);
}
else
{
feedback.Message = string.Format("The component folder at '{0}' has a protected name '{1}'.",
folder.Folder.Path, folder.Name);
}
result.Add(feedback);
}
if (string.IsNullOrEmpty(folder.Name))
{
var feedback = new GenericRuleFeedback()
{
FeedbackType = FeedbackTypes.Error,
Message = string.Format("The component folder at '{0}' has an empty name.", folder.Folder.Path)
};
result.Add(feedback);
}
else if (char.IsDigit(folder.Name.First()))
{
var feedback = new GenericRuleFeedback()
{
FeedbackType = FeedbackTypes.Error,
Message = string.Format("The component folder at '{0}' name starts with a digit.", folder.Folder.Path)
};
result.Add(feedback);
}
var names = folder.Children.Select(c => c.Name).ToList();
var distinctNames = folder.Children.Select(c => c.Name).Distinct();
if (names.Count() != distinctNames.Count())
{
foreach (var uniqueName in distinctNames)
{
if (names.Contains(uniqueName))
{
names.Remove(uniqueName);
}
}
var feedback = new GenericRuleFeedback()
{
FeedbackType = FeedbackTypes.Error,
Message = string.Format("The component folder at '{0}' contains components/component-folders with non-unique names: {1}.",
folder.Folder.Path, string.Join(", ", names))
};
result.Add(feedback);
}
foreach (var subFolder in folder.Children.Where(c => c is FolderTreeNode))
{
result.AddRange(CheckFolderStructure(subFolder as FolderTreeNode));
}
return result;
}
//LOAD CAY
private void LoadTreeView()
{
treeViewproject.Nodes.Clear();
DirectoryInfo dir = new DirectoryInfo(CurrentProjectPath);
if (dir.Exists)
{
FolderTreeNode projectNode = new FolderTreeNode();
projectNode.Text = dir.Name;
projectNode.Tag = dir;
//projectNode.Name = "Folder";
//treenode.ImageIndex = 0;
projectNode.ImageIndex = 1;
projectNode.SelectedImageIndex = 1;
// GetDirectories(dir.GetDirectories(), treenode);
treeViewproject.Nodes.Add(projectNode);
try
{
DirectoryInfo[] directories = dir.GetDirectories();
if (directories.Length > 0)
{
foreach (DirectoryInfo directory in directories)
{
FolderTreeNode folderNode = new FolderTreeNode();
folderNode.Text = directory.Name;
folderNode.Tag = directory.Name;
projectNode.Nodes.Add(folderNode);
folderNode.ImageIndex = folderNode.SelectedImageIndex = 1;
foreach (FileInfo file in directory.GetFiles())
{
if (file.Exists)
{
FileTreeNode fileNode = new FileTreeNode();
fileNode.Text = file.Name;
fileNode.Tag = file.FullName;
folderNode.Nodes.Add(fileNode);
fileNode.ImageIndex = fileNode.SelectedImageIndex = 0;
//treenode.Name = "Folder"
}
}
}
treeViewproject.ExpandAll();
}
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.Message);
}
Text = treeViewproject.Nodes[0].Text + " - " + "Automation";
}
}
/// <summary>
/// Recursive call for BuildUpAllComponents
/// </summary>
/// <param name="folder">Folder at the current depth.</param>
/// <param name="package_mo">modelica package at the current depth</param>
/// <param name="lvl">depth (used for indentation).</param>
private void BuildUpAllComponentsRec(FolderTreeNode folder, Package package_mo, int lvl = 1)
{
foreach (var component in folder.Children.OfType<ComponentTreeNode>().Select(c => c.Component))
{
var isInDesign = string.IsNullOrEmpty((component.Impl as GME.MGA.IMgaFCO).RegistryNode["IsInDesign"].Value) == false;
if (isInDesign == false && this.GenerateUnusedComponents == false)
{
continue;
}
var modelicaModel = this.GetModelicaModelFromComponent(component);
if (modelicaModel == null)
{
continue;
}
// Don't check the rules twice for components in the design
if (isInDesign == false)
{
if (this.CheckRulesOnComponent(component, modelicaModel) == false)
{
this.Logger.WriteDebug("Component, {0}, will not be generated in package.", component.Name);
continue;
}
}
var component_mo = new Component(component)
{
FullName = package_mo.FullName + "." + component.Name,
Extends = modelicaModel.Attributes.Class
};
// Add all defined Parameters at the component-level
foreach (var cyPhyParameter in component.Children.ParameterCollection)
{
// META-3622
if (String.IsNullOrWhiteSpace(cyPhyParameter.Attributes.Dimension) || cyPhyParameter.Attributes.Dimension.Trim() == "1")
{
var parameter_mo = new UnitParameter()
{
Name = CodeGenerator.ParameterPrefix + cyPhyParameter.Name,
Value = this.GetParameterModelicaValue(cyPhyParameter),
Modifier = this.GetParameterModifier(cyPhyParameter)
};
component_mo.CyPhyParameters.Add(parameter_mo);
}
}
// Add all modelicaParameter from the ModelicaModel
foreach (var parameter in modelicaModel.Children.ModelicaParameterCollection)
{
var value = this.GetModelicaParameterValue(parameter, true);
if (string.IsNullOrWhiteSpace(value) == false)
{
component_mo.Parameters.Add(
new UnitParameter()
{
Name = parameter.Name,
Value = new ModelicaValue(value)
});
}
}
// Add all modelicaRedeclares from the ModelicaModel
foreach (var redeclareParameter in modelicaModel.Children.ModelicaRedeclareCollection)
{
var value = redeclareParameter.Attributes.Value;
if (string.IsNullOrWhiteSpace(value) == false)
{
component_mo.Parameters.Add(
new UnitRedeclareParameter(redeclareParameter)
{
Value = new ModelicaValue(value)
});
}
}
this.treeComponents.Add(component.ID, component_mo);
package_mo.Models.Add(component_mo);
}
lvl += 1;
foreach (var subFolder in folder.Children.OfType<FolderTreeNode>())
{
var subPackage_mo = new Package
{
Name = subFolder.Name,
FullName = package_mo.FullName + "." + subFolder.Name,
IndentLevel = lvl,
};
package_mo.Children.Add(subPackage_mo);
this.BuildUpAllComponentsRec(subFolder as FolderTreeNode, subPackage_mo, lvl);
}
}
/// <summary>
/// Builds an abstract tree with info about the packages and models in the component sub-package.
/// </summary>
/// <param name="rootFolder">rootFolder of the project.</param>
private void BuildUpAllComponets(CyPhy.RootFolder rootFolder)
{
this.componentsPackage_mo = new Package()
{
Name = rootFolder.Name,
FullName = string.Format("{0}.{1}.{2}", MainPackage, "Components", rootFolder.Name)
};
foreach (var componentsFolder in rootFolder.Children.ComponentsCollection)
{
if (FolderFilter.FolderHasModelicaComponents(componentsFolder))
{
var folder = new FolderTreeNode(componentsFolder);
FolderFilter.PopulateWithFilteredNodes(ref folder);
var subPackage_mo = new Package
{
Name = folder.Name,
FullName = this.componentsPackage_mo.FullName + "." + folder.Name,
IndentLevel = 1,
};
this.componentsPackage_mo.Children.Add(subPackage_mo);
this.BuildUpAllComponentsRec(folder as FolderTreeNode, subPackage_mo);
}
}
}
private void OpenProject()
{
treeViewproject.Nodes.Clear();
tabControl1.TabPages.Clear();
FolderBrowserDialog fbd = new FolderBrowserDialog();
fbd.ShowNewFolderButton = false;
fbd.Description = "Mời bạn chọn thư mục";
fbd.RootFolder = Environment.SpecialFolder.MyComputer;
if (fbd.ShowDialog() == DialogResult.OK)
{
TreeNode treenode;
CurrentProjectPath = fbd.SelectedPath;
//string path1 = fbd.SelectedPath + treeViewproject.SelectedNode.Tag;
//doc = CompoundDocument.Open(path);
DirectoryInfo dir = new DirectoryInfo(CurrentProjectPath);
if (dir.Exists)
{
FolderTreeNode projectNode = new FolderTreeNode();
projectNode.Text = dir.Name;
projectNode.Tag = dir;
//projectNode.Name = "Folder";
//treenode.ImageIndex = 0;
projectNode.ImageIndex = 1;
projectNode.SelectedImageIndex = 1;
// GetDirectories(dir.GetDirectories(), treenode);
treeViewproject.Nodes.Add(projectNode);
try
{
DirectoryInfo[] directories = dir.GetDirectories();
if (directories.Length > 0)
{
foreach (DirectoryInfo directory in directories)
{
FolderTreeNode folderNode =new FolderTreeNode();
folderNode.Text = directory.Name;
folderNode.Tag = directory.Name;
projectNode.Nodes.Add(folderNode);
folderNode.ImageIndex = folderNode.SelectedImageIndex = 1;
foreach (FileInfo file in directory.GetFiles())
{
if (file.Exists)
{
FileTreeNode fileNode = new FileTreeNode();
fileNode.Text = file.Name;
fileNode.Tag = file.FullName;
folderNode.Nodes.Add(fileNode);
fileNode.ImageIndex = fileNode.SelectedImageIndex = 0;
//treenode.Name = "Folder"
}
}
}
treeViewproject.ExpandAll();
}
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.Message);
}
Text = treeViewproject.Nodes[0].Text + " - " + "Automation";
}
}
}
