void ActionTree_DragDrop(object sender, DragEventArgs e)
{
copyAction = CopyPasteOperactions.Cut;
if ((e.KeyState & 4) > 0) // shift key
copyAction |= CopyPasteOperactions.IgnoreRoot;
if ((e.KeyState & 8) > 0) // ctrl key
copyAction |= CopyPasteOperactions.Copy;
if (e.Data.GetDataPresent("System.Windows.Forms.TreeNode", false))
{
Point pt = ((TreeView)sender).PointToClient(new Point(e.X, e.Y));
TreeNode dest = ((TreeView)sender).GetNodeAt(pt);
TreeNode newNode = (TreeNode)e.Data.GetData("System.Windows.Forms.TreeNode");
PasteAction(newNode, dest);
}
else if (e.Data.GetDataPresent("System.Windows.Forms.DataGridViewRow", false))
{
Point pt = ((TreeView)sender).PointToClient(new Point(e.X, e.Y));
TreeNode dest = ((TreeView)sender).GetNodeAt(pt);
DataGridViewRow row = (DataGridViewRow)e.Data.GetData("System.Windows.Forms.DataGridViewRow");
if (row.Tag.GetType().GetInterface("IPBComposite") != null)
{
IPBComposite pa = (IPBComposite)Activator.CreateInstance(row.Tag.GetType());
AddToActionTree(pa, dest);
}
}
}
virtual public void ReadXml(XmlReader reader)
{
SubRoutineName = reader["SubRoutineName"];
reader.MoveToAttribute("ChildrenCount");
int count = reader.ReadContentAsInt();
reader.ReadStartElement();
if (count > 0)
{
for (int i = 0; i < count; i++)
{
Type type = Type.GetType("HighVoltz.Composites." + reader.Name);
if (type != null)
{
IPBComposite comp = (IPBComposite)Activator.CreateInstance(type);
if (comp != null)
{
comp.ReadXml(reader);
AddChild((Composite)comp);
}
}
else
{
Logging.Write(System.Drawing.Color.Red, "Failed to load type {0}", type.Name);
}
}
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
}
}
virtual public void ReadXml(XmlReader reader)
{
SubRoutineName = reader["SubRoutineName"];
reader.ReadStartElement();
while (reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.Comment)
{
if (reader.NodeType == XmlNodeType.Comment)
{
AddChild(new Comment(reader.Value));
reader.Skip();
}
else
{
Type type = Type.GetType("HighVoltz.Composites." + reader.Name);
if (type != null)
{
IPBComposite comp = (IPBComposite)Activator.CreateInstance(type);
if (comp != null)
{
comp.ReadXml(reader);
AddChild((Composite)comp);
}
}
else
{
Logging.Write(System.Drawing.Color.Red, "Failed to load type {0}", type.Name);
}
}
}
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
}
public void ReadXml(XmlReader reader)
{
int count;
reader.MoveToContent();
int.TryParse(reader["ChildrenCount"], out count);
reader.ReadStartElement("Professionbuddy");
PrioritySelector ps = (PrioritySelector)DecoratedChild;
for (int i = 0; i < count; i++)
{
Type type = Type.GetType("HighVoltz.Composites." + reader.Name);
if (type != null)
{
IPBComposite comp = (IPBComposite)Activator.CreateInstance(type);
if (comp != null)
{
comp.ReadXml(reader);
ps.AddChild((Composite)comp);
}
}
else
{
Professionbuddy.Err("PB:Failed to load type {0}", type);
}
}
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
}
private void RefreshActionTreeCallback(IPBComposite pbComp, Type type)
{
ActionTree.SuspendLayout();
foreach (TreeNode node in ActionTree.Nodes)
{
UdateTreeNode(node, pbComp, type, true);
}
ActionTree.ResumeLayout();
}
private void ActionTree_AfterSelect(object sender, TreeViewEventArgs e)
{
if (!IsValid)
return;
IPBComposite comp = (IPBComposite)e.Node.Tag;
if (comp != null && comp.Properties != null)
{
MainForm.Instance.ActionGrid.SelectedObject = comp.Properties;
}
}
/// <summary>
/// Refreshes all actions of specified type in ActionTree or all if type is null
/// </summary>
/// <param name="type"></param>
public void RefreshActionTree(IPBComposite pbComp, Type type)
{
// Don't update ActionTree while PB is running to improve performance.
if (PB.IsRunning || !IsValid)
return;
if (ActionTree.InvokeRequired)
ActionTree.BeginInvoke(new refreshActionTreeDelegate(RefreshActionTreeCallback), pbComp, type);
else
RefreshActionTreeCallback(pbComp, type);
}
private void toolStripAddBtn_Click(object sender, EventArgs e)
{
List<IPBComposite> compositeList = new List<IPBComposite>();
// if the tradeskill tab is selected
if (MainTabControl.SelectedTab == TradeSkillTab)
{
TradeSkillListView tv = TradeSkillTabControl.SelectedTab as TradeSkillListView;
if (tv.TradeDataView.SelectedRows == null)
return;
DataGridViewSelectedRowCollection rowCollection = tv.TradeDataView.SelectedRows;
foreach (DataGridViewRow row in rowCollection)
{
TradeSkillRecipeCell cell = (TradeSkillRecipeCell)row.Cells[0].Value;
Recipe recipe = PB.TradeSkillList[tv.TradeIndex].Recipes[cell.RecipeID];
int repeat;
int.TryParse(toolStripAddNum.Text, out repeat);
CastSpellAction.RepeatCalculationType repeatType = CastSpellAction.RepeatCalculationType.Specific;
switch (toolStripAddCombo.SelectedIndex)
{
case 1:
repeatType = CastSpellAction.RepeatCalculationType.Craftable;
break;
case 2:
repeatType = CastSpellAction.RepeatCalculationType.Banker;
break;
}
CastSpellAction ca = new CastSpellAction(recipe, repeat, repeatType);
compositeList.Add(ca);
}
}
else if (MainTabControl.SelectedTab == ActionsTab)
{
if (ActionGridView.SelectedRows != null)
{
foreach (DataGridViewRow row in ActionGridView.SelectedRows)
{
IPBComposite pa = (IPBComposite)Activator.CreateInstance(row.Tag.GetType());
compositeList.Add(pa);
}
}
}
copyAction = CopyPasteOperactions.Copy;
foreach (IPBComposite composite in compositeList)
{
if (ActionTree.SelectedNode == null)
AddToActionTree(composite, null);
else
AddToActionTree(composite, ActionTree.SelectedNode);
}
// now update the CanRepeatCount.
PB.UpdateMaterials();
RefreshTradeSkillTabs();
}
void UdateTreeNode(TreeNode node, IPBComposite pbComp, Type type, bool recursive)
{
IPBComposite comp = (IPBComposite)node.Tag;
if ((pbComp == null && type == null) ||
(pbComp != null && pbComp == node.Tag) ||
(type != null && type.IsAssignableFrom(node.Tag.GetType()))
)
{
node.ForeColor = comp.Color;
node.Text = comp.Title;
}
if (node.Nodes != null && recursive)
{
foreach (TreeNode child in node.Nodes)
{
UdateTreeNode(child, pbComp, type, true);
}
}
}
private void UdateTreeNode(TreeNode node, IPBComposite pbComp, Type type, bool recursive)
{
var comp = (IPBComposite)node.Tag;
if ((pbComp == null && type == null) ||
(pbComp != null && pbComp == node.Tag) ||
(type != null && type.IsInstanceOfType(node.Tag))
)
{
node.ForeColor = comp.Color;
node.Text = comp.Title;
}
if (recursive)
{
foreach (TreeNode child in node.Nodes)
{
UdateTreeNode(child, pbComp, type, true);
}
}
}
void PopulateActionGridView()
{
ActionGridView.Rows.Clear();
Assembly asm = Assembly.GetExecutingAssembly();
foreach (Type type in asm.GetTypes())
{
if (type.GetInterface("IPBComposite") != null && !type.IsAbstract)
{
IPBComposite pa = (IPBComposite)Activator.CreateInstance(type);
DataGridViewRow row = new DataGridViewRow();
DataGridViewTextBoxCell cell = new DataGridViewTextBoxCell();
cell.Value = pa.Name;
row.Cells.Add(cell);
row.Tag = pa;
row.Height = 16;
ActionGridView.Rows.Add(row);
row.DefaultCellStyle.ForeColor = pa.Color;
//row.DefaultCellStyle.SelectionBackColor = pa.Color;
}
}
}
virtual public void ReadXml(XmlReader reader)
{
Condition = reader["Condition"];
bool boolVal;
bool.TryParse(reader["IgnoreCanRun"], out boolVal);
IgnoreCanRun = boolVal;
reader.ReadStartElement();
while (reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.Comment)
{
if (reader.NodeType == XmlNodeType.Comment)
{
AddChild(new Comment(reader.Value));
reader.Skip();
}
else
{
Type type = Type.GetType("HighVoltz.Composites." + reader.Name);
if (type != null)
{
IPBComposite comp = (IPBComposite)Activator.CreateInstance(type);
if (comp != null)
{
comp.ReadXml(reader);
AddChild((Composite)comp);
}
}
else
{
Logging.Write(System.Drawing.Color.Red, "Failed to load type {0}", type.Name);
}
}
}
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
}
TreeNode RecursiveCloning(TreeNode node)
{
IPBComposite newComp = (IPBComposite)(((IPBComposite)node.Tag).Clone());
TreeNode newNode = new TreeNode(newComp.Title);
newNode.ForeColor = newComp.Color;
newNode.Tag = newComp;
if (node.Nodes != null)
{
foreach (TreeNode child in node.Nodes)
{
GroupComposite gc = null;
// If, While and SubRoutine are Decorators.
if (newComp is GroupComposite)
{
gc = (GroupComposite)newComp;
TreeNode newChildNode = RecursiveCloning(child);
gc.AddChild((Composite)newChildNode.Tag);
newNode.Nodes.Add(newChildNode);
}
}
}
return newNode;
}
public void ReadXml(XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement("Professionbuddy");
PrioritySelector ps = (PrioritySelector)DecoratedChild;
while (reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.Comment)
{
if (reader.NodeType == XmlNodeType.Comment)
{
ps.AddChild(new Comment(reader.Value));
reader.Skip();
}
else
{
Type type = Type.GetType("HighVoltz.Composites." + reader.Name);
if (type != null)
{
IPBComposite comp = (IPBComposite)Activator.CreateInstance(type);
if (comp != null)
{
comp.ReadXml(reader);
ps.AddChild((Composite)comp);
}
}
else
{
Professionbuddy.Err("PB:Failed to load type {0}", type);
}
}
}
if (reader.NodeType == XmlNodeType.Element)
{
reader.ReadEndElement();
}
}
/// <summary>
/// Refreshes all actions of specified type in ActionTree or all if type is null
/// </summary>
/// <param name="type"></param>
public void RefreshActionTree(IPBComposite pbComp, Type type)
{
// Don't update ActionTree while PB is running to improve performance.
if (_pb.IsRunning || !IsValid)
return;
if (ActionTree.InvokeRequired)
ActionTree.BeginInvoke(new RefreshActionTreeDelegate(RefreshActionTreeCallback), pbComp, type);
else
RefreshActionTreeCallback(pbComp, type);
}
public void RefreshActionTree(IPBComposite pbComp)
{
RefreshActionTree(pbComp, null);
}
public DynamicProperty(IPBComposite parent, string code)
{
Code = code;
_expressionMethod = context => default(T);
AttachedComposite = parent;
}
private void RefreshActionTreeCallback(IPBComposite pbComp, Type type)
{
ActionTree.SuspendLayout();
foreach (TreeNode node in ActionTree.Nodes)
{
UdateTreeNode(node, pbComp, type, true);
}
ActionTree.ResumeLayout();
}
void AddToActionTree(object action, TreeNode dest)
{
bool ignoreRoot = (copyAction & CopyPasteOperactions.IgnoreRoot) == CopyPasteOperactions.IgnoreRoot ? true : false;
bool cloneActions = (copyAction & CopyPasteOperactions.Copy) == CopyPasteOperactions.Copy ? true : false;
TreeNode newNode = null;
if (action is TreeNode)
{
if (cloneActions)
{
newNode = RecursiveCloning(((TreeNode)action));
}
else
newNode = (TreeNode)((TreeNode)action).Clone();
}
else if (action.GetType().GetInterface("IPBComposite") != null)
{
IPBComposite composite = (IPBComposite)action;
newNode = new TreeNode(composite.Title);
newNode.ForeColor = composite.Color;
newNode.Tag = composite;
}
else
return;
ActionTree.SuspendLayout();
if (dest != null)
{
int treeIndex = action is TreeNode && ((TreeNode)action).Parent == dest.Parent &&
((TreeNode)action).Index <= dest.Index && !cloneActions ?
dest.Index + 1 : dest.Index;
GroupComposite gc = null;
// If, While and SubRoutines are Decorators...
if (!ignoreRoot && dest.Tag is GroupComposite)
gc = (GroupComposite)dest.Tag;
else
gc = (GroupComposite)((Composite)dest.Tag).Parent;
if ((dest.Tag is If || dest.Tag is SubRoutine) && !ignoreRoot)
{
dest.Nodes.Add(newNode);
gc.AddChild((Composite)newNode.Tag);
if (!dest.IsExpanded)
dest.Expand();
}
else
{
if (dest.Index >= gc.Children.Count)
gc.AddChild((Composite)newNode.Tag);
else
gc.InsertChild(dest.Index, (Composite)newNode.Tag);
if (dest.Parent == null)
{
if (treeIndex >= ActionTree.Nodes.Count)
ActionTree.Nodes.Add(newNode);
else
ActionTree.Nodes.Insert(treeIndex, newNode);
}
else
{
if (treeIndex >= dest.Parent.Nodes.Count)
dest.Parent.Nodes.Add(newNode);
else
dest.Parent.Nodes.Insert(treeIndex, newNode);
}
}
}
else
{
ActionTree.Nodes.Add(newNode);
PB.CurrentProfile.Branch.AddChild((Composite)newNode.Tag);
}
ActionTree.ResumeLayout();
}
public void RefreshActionTree(IPBComposite pbComp)
{
RefreshActionTree(pbComp, null);
}
private void UdateTreeNode(TreeNode node, IPBComposite pbComp, Type type, bool recursive)
{
var comp = (IPBComposite) node.Tag;
if ((pbComp == null && type == null) ||
(pbComp != null && pbComp == node.Tag) ||
(type != null && type.IsInstanceOfType(node.Tag))
)
{
node.ForeColor = comp.Color;
node.Text = comp.Title;
}
if (recursive)
{
foreach (TreeNode child in node.Nodes)
{
UdateTreeNode(child, pbComp, type, true);
}
}
}
