public EntityMetadataHandler(MyPluginControl myPlugin, AlBackgroundWorkHandler backgroundWorkHandler, TreeViewAdv metadataTree, EntitySelectionHandler entitySelectionHandler)
{
this.myPlugin = myPlugin;
this.backgroundWorkHandler = backgroundWorkHandler;
this.metadataTree = metadataTree;
this.entitySelectionHandler = entitySelectionHandler;
}
public ModelLayerForm(ModelDiagramForm model)
: this()
{
layerTreeView = model.DiagramWrapper.get_layer_tree();
headerPanel1.Controls.Add(layerTreeView);
layerTreeView.Dock = System.Windows.Forms.DockStyle.Fill;
}
private static TaggedType RestoreSelection <TaggedType>(TreeViewAdv tree, Predicate <TaggedType> predicate) where TaggedType : class
{
TaggedType ret = null;
//Restore selection
TreeNodeAdv selectedNode = null;
foreach (var node in tree.AllNodes)
{
var tag = node.Tag as TaggedType;
if (tag != null && predicate(tag))
{
selectedNode = node;
ret = tag;
break;
}
}
if (selectedNode != null)
{
tree.SelectedNode = selectedNode;
}
return(ret);
}
public static void FillChannels(TreeViewAdv tree, Sequence4 seq, List <TreeNodeAdv>[] siNodes, bool selectedOnly, bool includeRGBchildren, int memberTypes)
{
//TODO: 'Selected' not implemented yet
tree.Nodes.Clear();
nodeIndex = 1;
int listSize = seq.Members.HighestSavedIndex + seq.Tracks.Count + seq.TimingGrids.Count + 1;
//Array.Resize(ref siNodes, listSize);
// const string ERRproc = " in FillChannels(";
// const string ERRtrk = "), in Track #";
// const string ERRitem = ", Items #";
// const string ERRline = ", Line #";
for (int n = 0; n < siNodes.Length; n++)
{
//siNodes[n] = null;
//siNodes[n] = new List<TreeNodeAdv>();
//siNodes.Add(new List<TreeNodeAdv>());
siNodes[n] = new List <TreeNodeAdv>();
}
for (int t = 0; t < seq.Tracks.Count; t++)
{
TreeNodeAdv trackNode = AddTrack(seq, tree.Nodes, t, siNodes, selectedOnly, includeRGBchildren, memberTypes);
}
}
private static void ExpandNode <TaggedType>(TreeViewAdv tree, Predicate <TaggedType> predicate) where TaggedType : class
{
//Restore selection
TreeNodeAdv selectedNode = null;
foreach (var node in tree.AllNodes)
{
var tag = node.Tag as TaggedType;
if (tag != null && predicate(tag))
{
selectedNode = node;
break;
}
}
if (selectedNode != null)
{
var n = selectedNode;
while (n != null)
{
n.Expand();
n = n.Parent;
}
}
}
public EntityGeneratorHandler(MyPluginControl myPlugin, AlBackgroundWorkHandler backgroundWorkHandler, TreeViewAdv metadataTree, RichTextBox output)
{
this.myPlugin = myPlugin;
this.backgroundWorkHandler = backgroundWorkHandler;
this.metadataTree = metadataTree;
this.output = output;
}
/// <summary>
/// Private form of SetContentRecursive. This form contains an extra parameter used by LoadChildren.
/// This adds the childNodes parameter, which can be set to the children of a particular child element.
/// </summary>
/// <param name="process"></param>
/// <param name="localVarList"></param>
/// <param name="childNodes"></param>
/// <param name="contentEnum"></param>
private static void SetContentRecursive(Process process, TreeViewAdv localVarList, IList <TreeNodeAdv> childNodes, IEnumerable <AbstractNode> contentEnum)
{
contentEnum = contentEnum ?? new AbstractNode[0];
int index = 0;
foreach (AbstractNode content in contentEnum)
{
// Add or overwrite existing items
if (index < childNodes.Count)
{
// Overwrite
((TreeViewVarNode)childNodes[index]).SetContentRecursive(content);
}
else
{
// Add
childNodes.Add(new TreeViewVarNode(process, localVarList, content));
}
index++;
}
int count = index;
// Delete other nodes
while (childNodes.Count > count)
{
childNodes.RemoveAt(count);
}
}
/// <summary>
/// Constructor that initializes the model with the given objects
/// </summary>
/// <param name="TreeView">The TreeViewAdv control this model belongs to</param>
/// <param name="GrtTree">The GRT tree this model belongs to</param>
public DbMysqlTableIndexColumnsListModel(TreeViewAdv ListView, IndexColumnsListWrapper GrtList,
MySQLTableColumnsListWrapper TableColumnGrtList,
NodeCheckBox EnabledNodeControl,
AdvNodeComboBox NameNodeControl,
AdvNodeComboBox OrderNodeControl,
AdvNodeComboBox StorageNodeControl,
AdvNodeTextBox LengthNodeControl)
: base(ListView, GrtList, false)
{
tableColumnGrtList = TableColumnGrtList;
enabledNodeControl = EnabledNodeControl;
nameNodeControl = NameNodeControl;
orderNodeControl = OrderNodeControl;
storageNodeControl = StorageNodeControl;
lengthNodeControl = LengthNodeControl;
// assign virtual value events for displaying and processing the edited value content
enabledNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
enabledNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
nameNodeControl.EditorInitialize += new EditorInitializeEventHandler(EditorInitialize);
nameNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
nameNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
orderNodeControl.EditorInitialize += new EditorInitializeEventHandler(EditorInitialize);
orderNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
orderNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
storageNodeControl.EditorInitialize += new EditorInitializeEventHandler(EditorInitialize);
storageNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
storageNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
lengthNodeControl.EditorInitialize += new EditorInitializeEventHandler(EditorInitialize);
lengthNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
lengthNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
}
//GuiUpdateHelper _updater;
public TreeViewAdvModel(ProjectVM treeVM, TreeViewAdv treeView)
{
_tree = treeVM;
_treeView = treeView;
_tree.ChildrenInvalidated += row => AutoRefresh(row, true);
_tree.RowInvalidated += row => AutoRefresh(row, false);
}
protected override void InitializeComponents()
{
localVarList = new TreeViewAdv();
localVarList.Columns.Add(nameColumn);
localVarList.Columns.Add(valColumn);
localVarList.Columns.Add(typeColumn);
localVarList.UseColumns = true;
localVarList.SelectionMode = TreeSelectionMode.Single;
localVarList.LoadOnDemand = true;
NodeIcon iconControl = new ItemIcon();
iconControl.ParentColumn = nameColumn;
localVarList.NodeControls.Add(iconControl);
NodeTextBox nameControl = new ItemName();
nameControl.ParentColumn = nameColumn;
localVarList.NodeControls.Add(nameControl);
NodeTextBox textControl = new ItemText();
textControl.ParentColumn = valColumn;
localVarList.NodeControls.Add(textControl);
NodeTextBox typeControl = new ItemType();
typeControl.ParentColumn = typeColumn;
localVarList.NodeControls.Add(typeControl);
localVarList.AutoRowHeight = true;
RedrawContent();
}
public ReorderColumnState(TreeViewAdv tree, TreeColumn column, Point initialMouseLocation)
: base(tree, column)
{
_location = new Point(initialMouseLocation.X + Tree.OffsetX, 0);
_dragOffset = tree.GetColumnX(column) - initialMouseLocation.X;
_ghostImage = column.CreateGhostImage(new Rectangle(0, 0, column.Width, tree.ColumnHeaderHeight), tree.Font);
}
internal RepositoryTreeModel(ServerConnectionManager connManager, TreeViewAdv tree, OpenResourceManager openResMgr, ClipboardService clip)
{
_connManager = connManager;
_tree = tree;
_openResMgr = openResMgr;
_clip = clip;
}
/// <summary>
/// The constructor that has to be overwritten in the derived model classes
/// </summary>
/// <param name="TreeView">The TreeViewAdv control this model is used for</param>
/// <param name="DisabledNames">the list of the nodes that shouldn't be shown</param>
/// <param name="GrtList">The GRT list this model is representing</param>
public DifferenceByNameGrtTreeModel(TreeViewAdv TreeView, List <String> DisabledNames,
MySQL.Grt.TreeModelWrapper GrtTree, bool DynamicContextMenu)
: base(TreeView, GrtTree, DynamicContextMenu)
{
model = GrtTree;
treeControl = TreeView;
disabledNames = DisabledNames;
}
public UndoHistoryForm(WbContext context)
: this()
{
historyTreeView = context.get_history_tree();
historyTreeView.BorderStyle = BorderStyle.None;
headerPanel1.Controls.Add(historyTreeView);
historyTreeView.Dock = DockStyle.Fill;
}
public static void RestoreNodesExpanded(this TreeViewAdv view, TreeNodeAdv node, HashSet <object> expandedNodes, Func <TreeNodeAdv, object> idFunc)
{
node.IsExpanded = expandedNodes.Contains(idFunc(node));
foreach (TreeNodeAdv child in node.Children)
{
RestoreNodesExpanded(view, child, expandedNodes, idFunc);
}
}
// ========================================================================
// Con- / Destructors
#region === Con- / Destructors
/// <summary>
/// Initializes a new instance of <see cref="TestCaseTreeModel"/>.
/// </summary>
/// <param name="treeView">The tree view this model belongs to.</param>
public TestCaseTreeModel(TreeViewAdv treeView)
{
this.treeView = treeView;
CoreData.Instance.TestCaseModel.TestCasesLoaded += TestCaseModel_TestCasesLoaded;
CoreData.Instance.TestCaseModel.TestCaseAdded += TestCaseModel_TestCaseAdded;
CoreData.Instance.TestCaseModel.TestCaseRemoved += TestCaseModel_TestCaseRemoved;
}
public EntitySelectionHandler(MyPluginControl myPlugin, AlBackgroundWorkHandler backgroundWorkHandler, TreeViewAdv metadataTree, AttributeMetadataHandler attributeMetadataHandler, RelationshipMetadataHandler relationshipMetadataHandler)
{
this.myPlugin = myPlugin;
this.backgroundWorkHandler = backgroundWorkHandler;
this.metadataTree = metadataTree;
this.attributeMetadataHandler = attributeMetadataHandler;
this.relationshipMetadataHandler = relationshipMetadataHandler;
}
public static List<ColumnData> GetColumnData(TreeViewAdv treeViewAdv)
{
Dictionary<int, ColumnData> columns = new Dictionary<int, ColumnData>();
foreach (TreeColumn col in treeViewAdv.Columns)
{
NamedTreeColumn column = col as NamedTreeColumn;
if (column == null)
continue;
columns.Add(column.Index, new ColumnData()
{
Name = column.Name,
Header = column.Header,
SortOrder = column.SortOrder,
TooltipText = column.TooltipText,
Width = column.Width
});
}
foreach (NodeControl nodeControl in treeViewAdv.NodeControls)
{
ColumnData column = columns[nodeControl.ParentColumn.Index];
var columnItem = new ColumnItemData();
if (nodeControl.GetType() == typeof(NodeCheckBox))
columnItem.Type = ColumnItemType.NodeCheckBox;
else if (nodeControl.GetType() == typeof(NodeIcon))
columnItem.Type = ColumnItemType.NodeIcon;
else if (nodeControl.GetType() == typeof(NodeTextBox))
columnItem.Type = ColumnItemType.NodeTextBox;
switch (columnItem.Type)
{
case ColumnItemType.NodeCheckBox:
columnItem.DataPropertyName = ((NodeCheckBox)nodeControl).DataPropertyName;
columnItem.EditEnabled = ((NodeCheckBox)nodeControl).EditEnabled;
columnItem.LeftMargin = ((NodeCheckBox)nodeControl).LeftMargin;
break;
case ColumnItemType.NodeIcon:
columnItem.DataPropertyName = ((NodeIcon)nodeControl).DataPropertyName;
columnItem.LeftMargin = ((NodeIcon)nodeControl).LeftMargin;
columnItem.ImageScaleMode = ((NodeIcon)nodeControl).ScaleMode;
break;
case ColumnItemType.NodeTextBox:
columnItem.DataPropertyName = ((NodeTextBox)nodeControl).DataPropertyName;
columnItem.IncrementalSearchEnabled = ((NodeTextBox)nodeControl).IncrementalSearchEnabled;
columnItem.LeftMargin = ((NodeTextBox)nodeControl).LeftMargin;
break;
}
column.Items.Add(columnItem);
}
return columns.Values.ToList();
}
internal virtual void AssignParent(TreeViewAdv parent)
{
if (_parent != null)
_parent.ColumnWidthChanged -= parent_ColumnWidthChanged;
_parent = parent;
if (_parent != null)
_parent.ColumnWidthChanged += parent_ColumnWidthChanged;
}
public ModelCatalogForm(ModelDiagramFormWrapper form)
: this()
{
TreeViewAdv catalogTree = form.get_catalog_tree();
catalogTree.ShowNodeToolTips = true;
headerPanel1.Controls.Add(catalogTree);
headerPanel1.Controls.SetChildIndex(catalogTree, 0);
catalogTree.Dock = DockStyle.Fill;
}
private void treeViewAdvControl_DragDrop(object sender, DragEventArgs e)
{
TreeViewAdv _tree = treeViewAdvControl;
_tree.BeginUpdate();
TreeNodeAdv[] nodes = (TreeNodeAdv[])e.Data.GetData(typeof(TreeNodeAdv[]));
Node dropNode = _tree.DropPosition.Node.Tag as Node;
if (_tree.DropPosition.Position == NodePosition.Inside)
{
Constant.NodeTypeDefine nodetype = (dropNode.Tag as PlistNodeData).nodeType;
if (nodetype == Constant.NodeTypeDefine.array ||
nodetype == Constant.NodeTypeDefine.dict)
{
foreach (TreeNodeAdv n in nodes)
{
(n.Tag as Node).Parent = dropNode;
}
_tree.DropPosition.Node.IsExpanded = true;
}
}
else
{
Node parent = dropNode.Parent;
Node nextItem = dropNode;
if (_tree.DropPosition.Position == NodePosition.After)
{
nextItem = dropNode.NextNode;
}
foreach (TreeNodeAdv node in nodes)
{
(node.Tag as Node).Parent = null;
}
int index = -1;
index = parent.Nodes.IndexOf(nextItem);
foreach (TreeNodeAdv node in nodes)
{
Node item = node.Tag as Node;
if (index == -1)
{
parent.Nodes.Add(item);
}
else
{
parent.Nodes.Insert(index, item);
index++;
}
}
}
_tree.EndUpdate();
}
public static void CenterNode(TreeNodeAdv node, int visibleLines)
{
// This function will only work properly if:
// 1) All TreeNodes have a fixed vertical height
// 2) The tree is fully collapsed except the ancestors
// of this node.
// 3) visibleLines is the actual number of nodes that can be
// displayed in the window vertically.
int paddingabove = (visibleLines - 1) / 2;
int paddingbelow = visibleLines - 1 - paddingabove;
TreeViewAdv tree = node.Tree;
TreeNodeAdv viewtop = node;
while (paddingabove > 0)
{
if (viewtop.PreviousNode != null)
{
viewtop = viewtop.PreviousNode;
}
else if (viewtop.Parent != null)
{
viewtop = viewtop.Parent;
}
else
{
break;
}
paddingabove--;
}
tree.EnsureVisible(viewtop);
TreeNodeAdv viewbottom = node;
node.Tree.EnsureVisible(node);
while (paddingbelow > 0)
{
if (viewbottom.NextNode != null)
{
viewbottom = viewbottom.NextNode;
}
else if ((viewbottom.Parent != null) && (viewbottom.Parent.NextNode != null))
{
viewbottom = viewbottom.Parent.NextNode;
}
else
{
break;
}
paddingbelow--;
}
tree.EnsureVisible(viewbottom);
tree.EnsureVisible(node);
}
public UserDatatypesForm(WbContext context)
: this()
{
TabText = "User Types";
Text = "User Types";
userTypesList = context.get_usertypes_tree();
userTypesList.BorderStyle = BorderStyle.None;
headerPanel1.Controls.Add(userTypesList);
userTypesList.Dock = DockStyle.Fill;
}
public static void SaveNodesExpanded(this TreeViewAdv view, TreeNodeAdv node, HashSet <object> expandedNodes, Func <TreeNodeAdv, object> idFunc)
{
if (node.IsExpanded)
{
expandedNodes.Add(idFunc(node));
}
foreach (TreeNodeAdv child in node.Children)
{
SaveNodesExpanded(view, child, expandedNodes, idFunc);
}
}
public NodeBuildInProgressIcon(TreeViewAdv parent)
{
this.parent = parent;
lock (lockObject) {
if (instances++ == 0)
{
Start();
}
}
IconChanged += inProgressIconIconChanged;
}
public IssueContextMenu(JiraIssueListModel model, StatusLabel status, TreeViewAdv tree, ToolStripMenuItem[] items)
{
this.model = model;
this.status = status;
this.tree = tree;
this.items = items;
Items.Add("dummy");
Opened += issueContextMenuOpened;
Opening += issueContextMenuOpening;
}
protected GrtListModel(TreeViewAdv ListView, MySQL.Grt.ListModelWrapper GrtList, NodeIcon NodeIcon,
bool DynamicContextMenu)
: this(ListView, GrtList, DynamicContextMenu)
{
nodeIcon = NodeIcon;
// Ensure that the VirtualMode is enabled
nodeIcon.VirtualMode = true;
// Assign virtual value events for displaying and processing the edited value content
nodeIcon.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(IconNeeded);
}
/// <summary>
/// The constructor that has to be overwritten in the derived model classes
/// </summary>
/// <param name="TreeView">The TreeViewAdv control this model is used for</param>
/// <param name="GrtList">The GRT list this model is representing</param>
/// <param name="DynamicContextMenu">Use context menu definition provided by backend</param>
protected GrtListModel(TreeViewAdv tree, MySQL.Grt.ListModelWrapper GrtList, bool DynamicContextMenu)
: this()
{
grtList = GrtList;
treeView = tree;
if (DynamicContextMenu)
{
tree.ContextMenuStrip = new System.Windows.Forms.ContextMenuStrip();
tree.ContextMenuStrip.Opening += new System.ComponentModel.CancelEventHandler(ContextMenuStrip_Opening);
}
}
/// <summary>
/// Инициализация колонки для дерева из Aga библиотеки.
/// </summary>
/// <param name="view">Дерево</param>
/// <param name="name">Имя колонки</param>
private static TreeColumn SetUpColumn(TreeViewAdv view, string name)
{
var column = new TreeColumn();
column.Sortable = false;
column.Header = name;
column.Width = 300;
view.Columns.Add(column);
return(column);
}
private void RestoreCollapsedNodeState(TreeViewAdv treeViewAdv)
{
var collapsedHwNodes = treeViewAdv.AllNodes
.Where(n => n.IsExpanded && n.Tag is IExpandPersistNode expandPersistNode && !expandPersistNode.Expanded)
.OrderByDescending(n => n.Level)
.ToList();
foreach (TreeNodeAdv node in collapsedHwNodes)
{
node.IsExpanded = false;
}
}
/// <summary>
/// Constructor that initializes the model with the given objects
/// </summary>
/// <param name="TreeView">The TreeViewAdv control this model belongs to</param>
/// <param name="GrtTree">The GRT tree this model belongs to</param>
/// <param name="NodeStateIcon">The NodeStateIcon NodeControl that displays the icon</param>
public DbMysqlTableColumnsListModel(IModelChangeListener listener, TreeViewAdv tree,
MySQLTableColumnsListWrapper grtList,
NodeIcon columnIconNodeControl, AdvNodeTextBox nameNodeControl, AdvNodeComboBox datatypeComboBoxNodeControl,
NodeCheckBox pkNodeControl, NodeCheckBox nnNodeControl, NodeCheckBox uqNodeControl, NodeCheckBox binNodeControl,
NodeCheckBox unNodeControl, NodeCheckBox zfNodeControl, NodeCheckBox aiNodeControl,
NodeCheckBox gNodeControl, AdvNodeTextBox defaultNodeControl, MySQLTableEditorWrapper wrapper)
: base(tree, grtList, columnIconNodeControl, true)
{
this.listener = listener;
this.nameNodeControl = nameNodeControl;
this.datatypeComboBoxNodeControl = datatypeComboBoxNodeControl;
this.pkNodeControl = pkNodeControl;
this.nnNodeControl = nnNodeControl;
this.uqNodeControl = uqNodeControl;
this.binNodeControl = binNodeControl;
this.unNodeControl = unNodeControl;
this.zfNodeControl = zfNodeControl;
this.aiNodeControl = aiNodeControl;
this.gNodeControl = gNodeControl;
this.defaultNodeControl = defaultNodeControl;
this.mySQLTableEditorWrapper = wrapper;
// assign virtual value events for displaying and processing the edited value content
nameNodeControl.EditorInitialize += new EditorInitializeEventHandler(EditorInitialize);
nameNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
nameNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
datatypeComboBoxNodeControl.EditorInitialize += new EditorInitializeEventHandler(EditorInitialize);
datatypeComboBoxNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
datatypeComboBoxNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
pkNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
pkNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
nnNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
nnNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
uqNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
uqNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
binNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
binNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
unNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
unNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
zfNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
zfNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
aiNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
aiNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
gNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
gNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
defaultNodeControl.EditorInitialize += new EditorInitializeEventHandler(EditorInitialize);
defaultNodeControl.ValueNeeded += new EventHandler <NodeControlValueEventArgs>(ValueNeeded);
defaultNodeControl.ValuePushed += new EventHandler <NodeControlValueEventArgs>(ValuePushed);
}
private void treeViewAdv_ItemDrag(object sender, System.Windows.Forms.ItemDragEventArgs e)
{
TreeViewAdv treeViewAdv = sender as TreeViewAdv;
// The TreeViewAdv always provides an array of selected nodes.
TreeNodeAdv[] nodes = e.Item as TreeNodeAdv[];
// Let us get only the first selected node.
TreeNodeAdv node = nodes[0];
// Only allow move
DragDropEffects result = treeViewAdv.DoDragDrop(nodes, DragDropEffects.Move);
}
protected virtual void OnDrawText(DrawEventArgs args)
{
TreeViewAdv tree = args.Node.Tree;
if (tree != null)
{
tree.FireDrawControl(args);
}
if (DrawText != null)
{
DrawText(this, args);
}
}
public NodePlusMinus(TreeViewAdv tree)
{
_tree = tree;
this.RefreshVisualStyles();
}
public InputState(TreeViewAdv tree)
{
_tree = tree;
}
public FixedHeaderHeightLayout(TreeViewAdv treeView, int headerHeight)
{
_treeView = treeView;
PreferredHeaderHeight = headerHeight;
}
protected ColumnState(TreeViewAdv tree, TreeColumn column)
: base(tree)
{
this.Column = column;
}
public ResizeColumnState(TreeViewAdv tree, TreeColumn column, Point p)
: base(tree, column)
{
_initLocation = p;
_initWidth = column.Width;
}
public ClickColumnState(TreeViewAdv tree, TreeColumn column, Point location)
: base(tree, column)
{
_location = location;
}
public InputWithShift(TreeViewAdv tree)
: base(tree)
{
}
internal virtual void AssignParent(TreeViewAdv parent)
{
_parent = parent;
}
public static void ColumnsToTreeViewAdv(TreeViewAdv treeViewAdv, List<ColumnData> columns)
{
treeViewAdv.Columns.Clear();
treeViewAdv.NodeControls.Clear();
foreach (ColumnData columnData in columns)
{
NamedTreeColumn treeColumn = new NamedTreeColumn();
treeColumn.Name = columnData.Name;
treeColumn.Header = columnData.Header;
treeColumn.SortOrder = columnData.SortOrder;
treeColumn.TooltipText = columnData.TooltipText;
treeColumn.Width = columnData.Width;
treeViewAdv.Columns.Add(treeColumn);
foreach (var columnItem in columnData.Items)
{
switch (columnItem.Type)
{
case ColumnItemType.NodeCheckBox:
NodeCheckBox nodeCheckBox = new NodeCheckBox();
nodeCheckBox.DataPropertyName = columnItem.DataPropertyName;
nodeCheckBox.EditEnabled = columnItem.EditEnabled;
nodeCheckBox.LeftMargin = columnItem.LeftMargin;
nodeCheckBox.HorizontalAlign = columnItem.HorizontalAlign;
nodeCheckBox.ParentColumn = treeColumn;
treeViewAdv.NodeControls.Add(nodeCheckBox);
break;
case ColumnItemType.NodeIcon:
NodeIcon nodeIcon = new NodeIcon();
nodeIcon.DataPropertyName = columnItem.DataPropertyName;
nodeIcon.LeftMargin = columnItem.LeftMargin;
nodeIcon.HorizontalAlign = columnItem.HorizontalAlign;
nodeIcon.ScaleMode = columnItem.ImageScaleMode;
nodeIcon.ParentColumn = treeColumn;
treeViewAdv.NodeControls.Add(nodeIcon);
break;
case ColumnItemType.NodeTextBox:
NodeTextBox nodeTextBox = new NodeTextBox();
nodeTextBox.DataPropertyName = columnItem.DataPropertyName;
nodeTextBox.IncrementalSearchEnabled = columnItem.IncrementalSearchEnabled;
nodeTextBox.LeftMargin = columnItem.LeftMargin;
nodeTextBox.ParentColumn = treeColumn;
nodeTextBox.UseCompatibleTextRendering = true;
treeViewAdv.NodeControls.Add(nodeTextBox);
break;
}
}
}
}
public ColumnState(TreeViewAdv tree, TreeColumn column)
: base(tree)
{
_column = column;
}
public InputWithControl(TreeViewAdv tree)
: base(tree)
{
}
public void DeserializeTreeView(TreeViewAdv treeView, string fileName)
{
XmlTextReader reader = null;
try
{
// disabling re-drawing of treeview till all nodes are added
treeView.BeginUpdate();
reader =
new XmlTextReader(fileName);
TreeNodeAdv parentNode = null;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name == XmlNodeTag)
{
var newNode = new TreeNodeAdv();
bool isEmptyElement = reader.IsEmptyElement;
// loading node attributes
int attributeCount = reader.AttributeCount;
if (attributeCount > 0)
{
for (int i = 0; i < attributeCount; i++)
{
reader.MoveToAttribute(i);
SetAttributeValue(newNode, reader.Name, reader.Value);
}
}
// add new node to Parent Node or TreeView
if (parentNode != null)
parentNode.Nodes.Add(newNode);
else
treeView.Nodes.Add(newNode);
// making current node 'ParentNode' if its not empty
if (!isEmptyElement)
{
parentNode = newNode;
}
}
}
// moving up to in TreeView if end tag is encountered
else if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.Name == XmlNodeTag)
{
if (parentNode != null) parentNode = parentNode.Parent;
}
}
else if (reader.NodeType == XmlNodeType.XmlDeclaration)
{
//Ignore Xml Declaration
}
else if (reader.NodeType == XmlNodeType.None)
{
return;
}
else if (reader.NodeType == XmlNodeType.Text)
{
if (parentNode != null) parentNode.Nodes.Add(reader.Value);
}
}
}
finally
{
// enabling redrawing of treeview after all nodes are added
treeView.EndUpdate();
if (reader != null) reader.Close();
}
}
// System.IO.StringWriter s;
public void SerializeTreeView(TreeViewAdv treeView, string fileName)
{
var textWriter = new XmlTextWriter(fileName, Encoding.UTF8);
// writing the xml declaration tag
textWriter.WriteStartDocument();
//textWriter.WriteRaw("\r\n");
// writing the main tag that encloses all node tags
textWriter.WriteStartElement("TreeView");
// save the nodes, recursive method
SaveNodes(treeView.Nodes, textWriter);
textWriter.WriteEndElement();
textWriter.Close();
}
