private void DisconnectFromServer(TreeNode serverNode)
{
if ((serverNode == null))
{
return;
}
NodeData data = NodeDataFactory.GetNodeData(serverNode.Tag);
if (data == null || data.Type != DBObjectType.Server)
{
return;
}
ConnectionParams cp = data.ConnParams;
if (!_connections.Keys.Contains(cp.Name))
{
return;
}
SqlConnection conn = _connections[cp.Name];
conn.Close();
conn.Dispose();
_connections.Remove(cp.Name);
serverNode.Nodes.Clear();
tv.Nodes.Remove(serverNode);
}
private bool IsSelectedObjectScriptable()
{
if (tv.SelectedNode == null)
{
return(false);
}
NodeData data = NodeDataFactory.GetNodeData(tv.SelectedNode.Tag);
if (data == null)
{
return(false);
}
if (data.Type == DBObjectType.View ||
data.Type == DBObjectType.Trigger ||
data.Type == DBObjectType.StoredProc ||
data.Type == DBObjectType.TableValuedFunction ||
data.Type == DBObjectType.ScalarValuedFunction
)
{
return(true);
}
else
{
return(false);
}
}
private TreeNode AddGroupingFolder(TreeNode parentNode, string name, int nodeType, string dbName, bool addFakeChild, int parentType)
{
if ((parentNode == null) || (nodeType != DBObjectType.GroupingFolderB && nodeType != DBObjectType.GroupingFolderY))
{
return(null);
}
NodeData parentData = NodeDataFactory.GetNodeData(parentNode.Tag);
if (parentData == null)
{
return(AddErrorNode(parentNode.Nodes, name, "Parent data is empty"));
}
TreeNode node = AddNode(parentNode.Nodes, name, nodeType);
if (addFakeChild)
{
node.Nodes.Add("...");
}
NodeData data = NodeDataFactory.Create(parentData.ConnParams, name, nodeType, dbName);
data.ConnParams = ((NodeData)parentNode.Tag).ConnParams;
data.ParentType = parentType;
data.ID = parentData.ID;
node.Tag = data;
return(node);
}
private void PopulateDatabase(TreeNode parentNode)
{
if (parentNode == null)
{
return;
}
NodeData parentData = NodeDataFactory.GetNodeData(parentNode.Tag);
if (parentData == null)
{
AddErrorNode(parentNode.Nodes, String.Empty, "Parent node data is null!");
return;
}
TreeNode tblsNode = AddGroupingFolderY(parentNode, FolderType.Tables, parentData.DBName, true, DBObjectType.Database);
tblsNode.Nodes.Clear();
AddGroupingFolderY(tblsNode, FolderType.SystemTables, parentData.DBName, true, DBObjectType.Database);
AddGroupingFolderY(tblsNode, FolderType.UserTables, parentData.DBName, true, DBObjectType.Database);
AddGroupingFolderY(parentNode, FolderType.Views, parentData.DBName, true, DBObjectType.Database);
AddGroupingFolderY(parentNode, FolderType.Procedures, parentData.DBName, true, DBObjectType.Database);
TreeNode fnNode = AddGroupingFolderY(parentNode, FolderType.Functions, parentData.DBName, true, DBObjectType.Database);
fnNode.Nodes.Clear();
AddGroupingFolderY(fnNode, FolderType.TableValuedFunctions, parentData.DBName, true, DBObjectType.Database);
AddGroupingFolderY(fnNode, FolderType.ScalarValuedFunctions, parentData.DBName, true, DBObjectType.Database);
}
private TreeNode AddServerNode(ConnectionParams cp)
{
if (cp == null)
{
return(null);
}
TreeNode node = AddNode(null, cp.Name, DBObjectType.Server);
NodeData data = NodeDataFactory.Create(cp, cp.Name, DBObjectType.Server, String.Empty);
node.Tag = data;
return(node);
}
private void OnHelpStatisticsClick(object sender, EventArgs e)
{
FireBeforeContextMenuActionExecuted(sender, ObjectExplorerAction.Statistics);
NodeData data = SelectedNode != null?NodeDataFactory.GetNodeData(SelectedNode.Tag) : null;
if (data == null)
{
return;
}
frmScriptEditor editor = CreateScriptEditorForObjectInfo("sp_statistics", "STATISTICS", true, data.Name, data.Owner);
editor.Icon = global::PragmaSQL.Properties.Resources.Help;
FireAfterContextMenuActionExecuted(sender, ObjectExplorerAction.Statistics);
}
private void OnHelpForeignKeysClick(object sender, EventArgs e)
{
FireBeforeContextMenuActionExecuted(sender, ObjectExplorerAction.ForeignKeys);
NodeData data = SelectedNode != null?NodeDataFactory.GetNodeData(SelectedNode.Tag) : null;
if (data == null)
{
return;
}
string[] parameters = new string[2] {
String.Format("@fktable_name = N'{0}'", data.Name), String.Format("@fktable_owner = N'{0}'", data.Owner)
};
frmScriptEditor editor = CreateScriptEditorForObjectInfo("sp_fkeys ", "FOREIGN_KEYS", true, true, parameters);
editor.Icon = global::PragmaSQL.Properties.Resources.Help;
FireAfterContextMenuActionExecuted(sender, ObjectExplorerAction.ForeignKeys);
}
private void PopulateUsers(ConnectionParams cp, TreeNode parentNode)
{
if (cp == null || parentNode == null)
{
return;
}
if (!_connections.Keys.Contains(cp.Name))
{
return;
}
SqlConnection conn = _connections[cp.Name];
if (conn.State != ConnectionState.Open)
{
throw new InvalidConnectionState("Can not populate users!");
}
TreeNode usersNode = AddNode(parentNode.Nodes, FolderType.Users, DBObjectType.UsersGroup);
usersNode.Nodes.Clear();
NodeData parentData = NodeDataFactory.GetNodeData(parentNode.Tag);
NodeData usersNodeData = NodeDataFactory.Create(parentData.ConnParams, FolderType.Users, DBObjectType.UsersGroup, parentData.DBName);
usersNodeData.Populated = true;
usersNode.Tag = usersNodeData;
DataTable users = conn.GetSchema("Users");
users.DefaultView.Sort = "user_name";
users = users.DefaultView.ToTable();
foreach (DataRow row in users.Rows)
{
string userName = (string)row["user_name"];
TreeNode node = AddNode(usersNode.Nodes, userName, DBObjectType.User);
NodeData userNodeData = NodeDataFactory.Create(parentData.ConnParams, userName, DBObjectType.User, parentData.DBName);
userNodeData.Populated = false;
node.Tag = userNodeData;
}
}
private frmScriptEditor CreateNewScriptEditor()
{
TreeNode node = tv.SelectedNode;
if (node == null)
{
CreateNewConnectionFromRepository(false);
}
node = tv.SelectedNode;
if (node == null)
{
return(null);
}
NodeData data = NodeDataFactory.GetNodeData(node.Tag);
if (data == null)
{
MessageBox.Show("Can not create connection!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(null);
}
frmScriptEditor editor = new frmScriptEditor();
editor.Text = "Script " + (++_scriptEditorCnt).ToString();
editor.TabText = editor.Text;
if (DockPanel.DocumentStyle == DocumentStyles.SystemMdi)
{
editor.MdiParent = this;
editor.Show();
}
else
{
editor.Show(DockPanel);
}
editor.InitializeScriptEditor(String.Empty, DBObjectType.None, data.ConnParams, data.DBName);
return(editor);
}
private TreeNode TryToAddTriggerGroupingFolder(TreeNode parentNode)
{
if (parentNode == null)
{
return(null);
}
NodeData parentData = NodeDataFactory.GetNodeData(parentNode.Tag);
if (parentData == null)
{
return(null);
}
if (!((parentData.Type == DBObjectType.UserTable) ||
(parentData.Type == DBObjectType.SystemTable) ||
(parentData.Type == DBObjectType.View))
)
{
return(null);
}
TreeNode node = AddGroupingFolderY(parentNode, FolderType.Triggers, parentData.DBName, false, parentData.Type);
NodeData nodeData = NodeDataFactory.Create(parentData.ConnParams, FolderType.Triggers, DBObjectType.GroupingFolderY, parentData.DBName);
nodeData.ID = parentData.ID;
node.Tag = nodeData;
if (!PopulateTriggers(node))
{
parentNode.Nodes.Remove(node);
return(null);
}
else
{
return(node);
}
}
private void ModifySelectedObjectInScriptWindow()
{
TreeNode node = tv.SelectedNode;
if (node == null)
{
return;
}
NodeData data = NodeDataFactory.GetNodeData(node.Tag);
if (data == null)
{
MessageBox.Show("Node data not assigned", "Application Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
frmScriptEditor editor = new frmScriptEditor();
editor.Text = data.Name;
editor.TabText = editor.Text;
if (DockPanel.DocumentStyle == DocumentStyles.SystemMdi)
{
editor.MdiParent = this;
editor.Show();
}
else
{
editor.Show(DockPanel);
}
ProgrammabilityHelper.SqlConn = _connections[data.ConnParams.Name];
string script = ProgrammabilityHelper.GetObjectCreateScript(data.ID);
script = ProgrammabilityHelper.ReplaceCreateWithAlter(data.Type, script);
editor.InitializeScriptEditor(script, data.Type, data.ConnParams, data.DBName);
}
private void OnAnyReferenceClick(object sender, EventArgs e)
{
FireBeforeContextMenuActionExecuted(sender, ObjectExplorerAction.References);
TreeNode node = SelectedNode;
if (node == null)
{
return;
}
node = SelectedNode;
if (node == null)
{
return;
}
NodeData data = NodeDataFactory.GetNodeData(node.Tag);
frmObjectReferencesViewer frm = ObjectReferenceViewerFactory.CreateObjectReferencesViewer("References {" + data.Name + "}", data.Name, data.ConnParams, data.DBName, RefDetail.Any, true);
ObjectReferenceViewerFactory.ShowViewer(frm);
FireAfterContextMenuActionExecuted(sender, ObjectExplorerAction.References);
}
private void OnAddSerlectedObjectsToGroup(object sender, EventArgs e)
{
if (tv.SelNodes.Count == 0)
{
return;
}
FireBeforeContextMenuActionExecuted(sender, ObjectExplorerAction.AddObjectsToGroup);
ConnectionParams cp = null;
IList <TreeNode> nodes = new List <TreeNode>();
foreach (MWTreeNodeWrapper nodeWrapper in tv.SelNodes.Values)
{
if (cp == null)
{
NodeData data = NodeDataFactory.GetNodeData(nodeWrapper.Node.Tag);
cp = data.ConnParams.CreateCopy();
cp.Database = data.DBName;
}
nodes.Add(nodeWrapper.Node);
}
frmObjGroupDlg.ShowObjectGroupingDlg(cp, nodes, "Add To Object Group");
FireAfterContextMenuActionExecuted(sender, ObjectExplorerAction.AddObjectsToGroup);
}
private void PopulateObjects(TreeNode parentNode, int nodeType)
{
if (parentNode == null)
{
return;
}
NodeData parentData = NodeDataFactory.GetNodeData(parentNode.Tag);
if (parentData == null)
{
AddErrorNode(parentNode.Nodes, String.Empty, "Parent data is null.");
return;
}
if (!_connections.Keys.Contains(parentData.ConnParams.Name))
{
return;
}
SqlConnection conn = _connections[parentData.ConnParams.Name];
if (conn.State != ConnectionState.Open)
{
throw new InvalidConnectionState("Can not populate table-valued function!");
}
string script = String.Empty;
switch (nodeType)
{
case DBObjectType.UserTable:
script = global::PragmaSQL.Properties.Resources.Script_GetUserTables;
break;
case DBObjectType.SystemTable:
script = global::PragmaSQL.Properties.Resources.Script_GetSystemTables;
break;
case DBObjectType.View:
script = global::PragmaSQL.Properties.Resources.Script_GetViews;
break;
case DBObjectType.StoredProc:
script = global::PragmaSQL.Properties.Resources.Script_GetStoredProcedures;
break;
case DBObjectType.TableValuedFunction:
script = global::PragmaSQL.Properties.Resources.Script_GetTableValuedFunctions;
break;
case DBObjectType.ScalarValuedFunction:
script = global::PragmaSQL.Properties.Resources.Script_GetScalarValuedFunctions;
break;
default:
AddErrorNode(parentNode.Nodes, String.Empty, String.Format("Invalid object type. \"{0}\" ", nodeType));
return;
}
if (conn.Database.ToLowerInvariant() != parentData.DBName.ToLowerInvariant())
{
try
{
conn.ChangeDatabase(parentData.DBName);
}
catch (Exception ex)
{
AddErrorNode(parentNode.Nodes, String.Empty, ex.Message);
return;
}
}
SqlCommand cmd = new SqlCommand(script, conn);
SqlDataReader reader = cmd.ExecuteReader();
int objCount = 0;
while (reader.Read())
{
string objName = (string)reader["name"];
TreeNode node = AddNode(parentNode.Nodes, objName, nodeType);
NodeData nodeData = NodeDataFactory.Create(parentData.ConnParams, objName, nodeType, parentData.DBName);
nodeData.ID = (int)reader["id"];
nodeData.HasParamsOrCols = true;
node.Tag = nodeData;
objCount++;
AddNode(node.Nodes, "...", -1);
}
reader.Close();
parentData.Populated = true;
parentNode.Text = parentData.Name + " (" + objCount.ToString() + ")";
}
private void PopulateDatabases(ConnectionParams cp, TreeNode parentNode)
{
if (cp == null || parentNode == null)
{
return;
}
if (!_connections.Keys.Contains(cp.Name))
{
return;
}
SqlConnection conn = _connections[cp.Name];
if (conn.State != ConnectionState.Open)
{
throw new InvalidConnectionState("Can not populate databases!");
}
NodeData parentData = NodeDataFactory.GetNodeData(parentNode);
TreeNode sysDbGroupNode = AddGroupingFolder(parentNode, "System Databases", DBObjectType.GroupingFolderB, true, DBObjectType.Server);
sysDbGroupNode.Nodes.Clear();
DataTable dbs = conn.GetSchema("Databases");
dbs.DefaultView.Sort = "database_name";
dbs = dbs.DefaultView.ToTable();
foreach (DataRow row in dbs.Rows)
{
string dbName = (string)row["database_name"];
TreeNode node = null;
if (DBConstants.SystemDbNames.Contains(dbName.ToLowerInvariant()))
{
node = AddNode(sysDbGroupNode.Nodes, dbName, DBObjectType.Database);
}
else
{
node = AddNode(parentNode.Nodes, dbName, DBObjectType.Database);
}
NodeData data = NodeDataFactory.Create(cp, dbName, DBObjectType.Database, dbName);
data.Populated = true;
node.Tag = data;
TreeNode tblsNode = AddGroupingFolderY(node, FolderType.Tables, dbName, true, DBObjectType.Database);
tblsNode.Nodes.Clear();
AddGroupingFolderY(tblsNode, FolderType.SystemTables, dbName, true, DBObjectType.Database);
AddGroupingFolderY(tblsNode, FolderType.UserTables, dbName, true, DBObjectType.Database);
AddGroupingFolderY(node, FolderType.Views, dbName, true, DBObjectType.Database);
AddGroupingFolderY(node, FolderType.Procedures, dbName, true, DBObjectType.Database);
TreeNode fnNode = AddGroupingFolderY(node, FolderType.Functions, dbName, true, DBObjectType.Database);
fnNode.Nodes.Clear();
AddGroupingFolderY(fnNode, FolderType.TableValuedFunctions, dbName, true, DBObjectType.Database);
AddGroupingFolderY(fnNode, FolderType.ScalarValuedFunctions, dbName, true, DBObjectType.Database);
if (cp.InitialCatalog.ToLowerInvariant() == dbName.ToLowerInvariant())
{
node.Expand();
tv.SelectedNode = node;
}
}
}
private void LoadNodeDataDynamically(TreeNode node, bool forceRefresh)
{
if (_tvInitializing)
{
return;
}
if (node == null)
{
return;
}
NodeData data = NodeDataFactory.GetNodeData(node.Tag);
if (data == null)
{
return;
}
bool oldExpandedState = node.IsExpanded;
try
{
Cursor = Cursors.AppStarting;
tv.BeginUpdate();
if (data.Type == DBObjectType.GroupingFolderB || data.Type == DBObjectType.GroupingFolderY)
{
if (data.Populated && !forceRefresh)
{
return;
}
if (data.Name == FolderType.SystemTables)
{
node.Nodes.Clear();
PopulateObjects(node, DBObjectType.SystemTable);
}
else if (data.Name == FolderType.UserTables)
{
node.Nodes.Clear();
PopulateObjects(node, DBObjectType.UserTable);
}
else if (data.Name == "Views")
{
node.Nodes.Clear();
PopulateObjects(node, DBObjectType.View);
}
else if (data.Name == FolderType.Procedures)
{
node.Nodes.Clear();
PopulateObjects(node, DBObjectType.StoredProc);
}
else if (data.Name == FolderType.TableValuedFunctions)
{
node.Nodes.Clear();
PopulateObjects(node, DBObjectType.TableValuedFunction);
}
else if (data.Name == FolderType.ScalarValuedFunctions)
{
node.Nodes.Clear();
PopulateObjects(node, DBObjectType.ScalarValuedFunction);
}
else if (data.Name == FolderType.Triggers)
{
node.Nodes.Clear();
PopulateTriggers(node);
}
else if (data.Name == FolderType.Columns)
{
node.Nodes.Clear();
PopulateParamsAndColumns(node, data.ParentType);
}
else if (data.Name == FolderType.Parameters)
{
node.Nodes.Clear();
PopulateParamsAndColumns(node, data.ParentType);
}
}
else if (data.HasParamsOrCols)
{
if (data.Populated && !forceRefresh)
{
return;
}
node.Nodes.Clear();
TryToAddTriggerGroupingFolder(node);
TryToAddObjectFolders(data.Type, node, data);
}
else if (data.Type == DBObjectType.Server)
{
if (data.Populated && !forceRefresh)
{
return;
}
node.Nodes.Clear();
PopulateDatabases(data.ConnParams, node);
PopulateUsers(data.ConnParams, node);
}
else if (data.Type == DBObjectType.Database)
{
if (data.Populated && !forceRefresh)
{
return;
}
node.Nodes.Clear();
PopulateDatabase(node);
}
if (oldExpandedState)
{
node.Expand();
}
}
finally
{
tv.EndUpdate();
Cursor = Cursors.Default;
}
}
public void AddObjectFromObjectExplorer(TreeNode source, TreeNode dropNode)
{
if (source == null)
{
return;
}
NodeData sourceData = NodeDataFactory.GetNodeData(source);
if (sourceData == null)
{
return;
}
try
{
tv.BeginUpdate();
ObjectGroupingItemData dropData = ObjectGroupingItemDataFactory.GetNodeData(dropNode);
int? parentID = null;
TreeNode parentNode = null;
if (dropNode != null && dropData != null)
{
if (dropData.Type == DBObjectType.GroupingFolderY)
{
parentID = dropData.ID;
parentNode = dropNode;
}
else
{
parentID = dropData.ParentID;
parentNode = dropNode.Parent;
}
}
string tableName = String.Empty;
if (sourceData.Type == DBObjectType.Trigger)
{
tableName = sourceData.ParentName;
}
ObjectGroupingItemData data = ObjectGroupingItemDataFactory.Create(sourceData.Name, sourceData.Type, null, tableName, parentID, _connParams.CurrentUsername);
try
{
_grpFacade.AddItem(data);
AddNode(parentNode, data);
if (parentNode != null && !parentNode.IsExpanded)
{
parentNode.Expand();
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
finally
{
tv.EndUpdate();
UpdateSelectedItemInfo();
}
}
private void PopulateParamsAndColumns(TreeNode parentNode, int nodeType)
{
if (parentNode == null)
{
return;
}
NodeData parentData = NodeDataFactory.GetNodeData(parentNode.Tag);
if (parentData == null)
{
AddErrorNode(parentNode.Nodes, String.Empty, "Parent data is null.");
return;
}
if (!_connections.Keys.Contains(parentData.ConnParams.Name))
{
return;
}
SqlConnection conn = _connections[parentData.ConnParams.Name];
if (conn.State != ConnectionState.Open)
{
throw new InvalidConnectionState("Can not populate table-valued function!");
}
string script = global::PragmaSQL.Properties.Resources.Script_GetColsAndParams;
if (conn.Database.ToLowerInvariant() != parentData.DBName.ToLowerInvariant())
{
try
{
conn.ChangeDatabase(parentData.DBName);
}
catch (Exception ex)
{
AddErrorNode(parentNode.Nodes, String.Empty, ex.Message);
return;
}
}
SqlCommand cmd = new SqlCommand(script, conn);
SqlParameter param = cmd.Parameters.Add("@id", SqlDbType.Int);
param.Value = parentData.ID;
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
string pName = (string)reader["name"];
pName = pName + " [ " + (string)reader["typename"] + " (" + ((short)reader["length"]).ToString() + ") " + "]";
int type = -1;
if ((int)reader["isoutparam"] == 1)
{
type = DBObjectType.ParameterOut;
}
else if (nodeType == DBObjectType.StoredProc || nodeType == DBObjectType.ScalarValuedFunction || nodeType == DBObjectType.TableValuedFunction)
{
if (nodeType == DBObjectType.TableValuedFunction)
{
if (parentData.Name == FolderType.Columns)
{
if (!pName.StartsWith("@"))
{
type = DBObjectType.ParameterOut;
}
else
{
continue;
}
}
else if (parentData.Name == FolderType.Parameters)
{
if (pName.StartsWith("@"))
{
type = DBObjectType.ParameterOut;
}
else
{
continue;
}
}
else
{
continue;
}
}
else
{
if (pName.StartsWith("@"))
{
type = DBObjectType.ParameterIn;
}
else
{
type = DBObjectType.ParameterOut;
}
}
}
else if (nodeType == DBObjectType.UserTable || nodeType == DBObjectType.SystemTable || nodeType == DBObjectType.View)
{
byte status = (byte)reader["status"];
if ((status & 128) == 128)
{
type = DBObjectType.IdentityCol;
}
else
{
type = DBObjectType.Column;
}
}
TreeNode node = AddNode(parentNode.Nodes, pName, type);
NodeData nodeData = NodeDataFactory.Create(parentData.ConnParams, pName, type, parentData.DBName);
nodeData.ID = parentData.ID;
node.Tag = nodeData;
}
reader.Close();
parentData.Populated = true;
}
private bool PopulateTriggers(TreeNode parentNode)
{
if (parentNode == null)
{
return(false);
}
NodeData parentData = NodeDataFactory.GetNodeData(parentNode.Tag);
if (parentData == null)
{
AddErrorNode(parentNode.Nodes, String.Empty, "Parent data is null.");
return(false);
}
if (!_connections.Keys.Contains(parentData.ConnParams.Name))
{
return(false);
}
SqlConnection conn = _connections[parentData.ConnParams.Name];
if (conn.State != ConnectionState.Open)
{
throw new InvalidConnectionState("Can not populate table-valued function!");
}
string script = global::PragmaSQL.Properties.Resources.Script_GetTriggers;
if (conn.Database.ToLowerInvariant() != parentData.DBName.ToLowerInvariant())
{
try
{
conn.ChangeDatabase(parentData.DBName);
}
catch (Exception ex)
{
AddErrorNode(parentNode.Nodes, String.Empty, ex.Message);
return(true);
}
}
SqlCommand cmd = new SqlCommand(script, conn);
SqlParameter param = cmd.Parameters.Add("@parentid", SqlDbType.Int);
param.Value = parentData.ID;
SqlDataReader reader = cmd.ExecuteReader();
int objCount = 0;
while (reader.Read())
{
string objName = (string)reader["name"];
TreeNode node = AddNode(parentNode.Nodes, objName, DBObjectType.Trigger);
NodeData nodeData = NodeDataFactory.Create(parentData.ConnParams, objName, DBObjectType.Trigger, parentData.DBName);
nodeData.ID = (int)reader["id"];
node.Tag = nodeData;
objCount++;
}
reader.Close();
parentData.Populated = true;
parentNode.Text = parentData.Name + " (" + objCount.ToString() + ")";
if (objCount == 0)
{
return(false);
}
else
{
return(true);
}
}
private void tv_DragOver(object sender, DragEventArgs e)
{
Hashtable sourceNodes = e.Data.GetData(typeof(Hashtable)) as Hashtable;
if (sourceNodes == null || sourceNodes.Count == 0)
{
e.Effect = DragDropEffects.None;
return;
}
TreeNode firstNode = null;
foreach (TreeNode node in sourceNodes.Values)
{
firstNode = node;
if (firstNode != null)
{
break;
}
}
if (firstNode == null)
{
e.Effect = DragDropEffects.None;
return;
}
Point pos = new Point();
pos.X = e.X;
pos.Y = e.Y;
pos = tv.PointToClient(pos);
TreeNode dropNode = tv.GetNodeAt(pos);
if (dropNode == null)
{
e.Effect = DragDropEffects.None;
return;
}
// This is an object from ObjectExplorer
if (firstNode.Tag is NodeData)
{
foreach (TreeNode node in sourceNodes.Values)
{
NodeData sourceData = NodeDataFactory.GetNodeData(node);
if (sourceData == null || sourceData.ConnParams == null || _connParams == null)
{
e.Effect = DragDropEffects.None;
return;
}
if (
(sourceData.ConnParams.Server.ToLowerInvariant() != _connParams.Server.ToLowerInvariant())
||
(sourceData.DBName.ToLowerInvariant() != _connParams.Database.ToLowerInvariant())
)
{
e.Effect = DragDropEffects.None;
return;
}
}
e.Effect = DragDropEffects.Copy;
}
// This is a node from own MWTreeView
else if (firstNode.Tag is ObjectGroupingItemData)
{
ObjectGroupingItemData dropData = ObjectGroupingItemDataFactory.GetNodeData(dropNode);
ObjectGroupingItemData firstNodeData = ObjectGroupingItemDataFactory.GetNodeData(firstNode);
if (dropData == null || (firstNodeData.ID == dropData.ParentID || firstNodeData.ID == dropData.ID))
{
e.Effect = DragDropEffects.None;
return;
}
if (dropData == null || dropData.Type != DBObjectType.GroupingFolderY)
{
e.Effect = DragDropEffects.None;
return;
}
e.Effect = DragDropEffects.Move;
}
// Unknown
else
{
e.Effect = DragDropEffects.None;
}
}
