public void DeleteConnection(MindNode node2)
{
if (this.connNodes.Contains(node2))
{
int index = this.connNodes.IndexOf(node2);
this.connNodes.RemoveAt(index);
this.connections.RemoveAt(index);
}
else if (node2.connNodes.Contains(this))
{
int index = node2.connNodes.IndexOf(this);
node2.connNodes.RemoveAt(index);
node2.connections.RemoveAt(index);
}
if (this.backconnNodes.Contains(node2))
{
int index = this.backconnNodes.IndexOf(node2);
this.backconnNodes.RemoveAt(index);
}
else if (node2.backconnNodes.Contains(this))
{
int index = node2.backconnNodes.IndexOf(this);
node2.backconnNodes.RemoveAt(index);
}
}
public MindNodeAction(int newid, String newName, MindNode node1, MindNode node2)
{
this.involvedNodes.Push(node1);
this.involvedNodes.Push(node2);
this.id = newid;
this.name = newName;
}
public bool AddChild(MindNode node, bool virtualCreate)
{
if (!CheckCollision(node) || virtualCreate)
{
if (!virtualCreate)
{
node.id = GlobalNodeHandler.id;
//if(!GlobalNodeHandler.copy && !GlobalNodeHandler.paste) does not change nodestyle while copying or pasting
node.NodeDrawingStyle = GlobalNodeHandler.nodeStyle;
if (GlobalNodeHandler.lighttext)
{
node.TextColor = Colors.White;
}
node.SetTextStyle(GlobalNodeHandler.standardtextFormat);
}
if (GetLastChild() != null)
{
//GetLastChild().AddConnection(node);
//GetLastChild().UpdateBridgesRepresentation();
}
node.parent = this;
childNodes.Add(node);
if (!virtualCreate)
{
GlobalNodeHandler.id++;
}
return(true);
}
return(false);
}
public bool AddChildNoStyle(MindNode node, bool virtualCreate)
{
if (!CheckCollision(node) || virtualCreate)
{
if (!virtualCreate)
{
node.id = GlobalNodeHandler.id;
//if(!GlobalNodeHandler.copy && !GlobalNodeHandler.paste) does not change nodestyle while copying or pasting
}
if (GetLastChild() != null)
{
//GetLastChild().AddConnection(node);
//GetLastChild().UpdateBridgesRepresentation();
}
node.parent = this;
childNodes.Add(node);
if (!virtualCreate)
{
GlobalNodeHandler.id++;
}
return(true);
}
return(false);
}
public void CopyToClipboard(MindNode copyNode)
{
DataPackage package = new DataPackage();
package.SetText(copyNode.GetRepresentationText());
Clipboard.SetContent(package);
}
public void Centerview(MindNode node, int imgHeight, int imgWidth)
{
Point centerPos = new Point(imgWidth / 2, imgHeight / 2);
Point move = node.GetDiff(centerPos);
this.MoveView(move, 1.0);
}
public MindNodeAction(int newid, String newName, MindNode node, String tex)
{
this.involvedNodes.Push(node);
this.id = newid;
this.name = newName;
this.text = tex;
}
public void viewPane_Released(MouseObject mousObj)
{
CalcPoint mousePos = mousObj.currentMousePos;
if (GlobalNodeHandler.TabletSelected)
{
if (GlobalNodeHandler.adding && tickcnt - clickstartcount < 10)
{
if (GlobalNodeHandler.clickedNode == null && GlobalNodeHandler.clickedLabel == null)
{
if (GlobalNodeHandler.CreateNewNode(mousePos.X, mousePos.Y, true))
{
CalcPoint CreatePoint;
CreatePoint = new CalcPoint(mousePos.X - GlobalNodeHandler.clickedNode.width,
mousePos.Y - GlobalNodeHandler.clickedNode.height);
GlobalNodeHandler.ShowTextBox(CreatePoint, activetext);
repaint(this, new EventArgs());
}
}
}
if (dragging)
{
dragging = false;
int x = mousePos.X;
int y = mousePos.Y;
if (selectedGroup.Count != 0)
{
diffPoints = new List <CalcPoint>();
}
else if (GlobalNodeHandler.clickedNode != null)
{
GlobalNodeHandler.clickedNode.SetPosition(mousePos.X, mousePos.Y, true);
GlobalNodeHandler.clickedNode.setHovered(false);
GlobalNodeHandler.clickedNode = null;
repaint(this, new EventArgs());
}
}
if (transformPoint.X != 0 || transformPoint.Y != 0)
{
transformPoint = new CalcPoint();
transformnode.SetScaled(true);
transformnode.UpdatePivots();
transformnode.UpdateTransformRec();
transformnode.updateRepresentation();
repaint(this, new EventArgs());
transformnode = null;
}
if (dragView)
{
dragView = false;
repaint(this, new EventArgs());
}
}
else if (GlobalNodeHandler.mouseSelected)
{
viewPane_MouseUp(mousObj);
}
}
public static void JumpOut()
{
//Resets the GlobalNodeHandler.viewNode to master node
//System.out.println("Try Jump out of:" + GlobalNodeHandler.viewNode.text);
//System.out.println("Parent:" + GlobalNodeHandler.viewNode.parent);
if (GlobalNodeHandler.viewNode.parent != null)
{
GlobalNodeHandler.viewNode = GlobalNodeHandler.viewNode.parent;
}
}
public void DeleteNode(MindNode node)
{
for (int i = childNodes.Count - 1; i >= 0; i--)
{
if (node.Equals(childNodes[i]))
{
childNodes.RemoveAt(i);
}
}
}
public bool CheckCollision(MindNode childnode)
{
for (int i = childNodes.Count - 1; i >= 0; i--)
{
if (childnode.collides(childNodes[i]) || childNodes[i].collides(childnode))
{
return(true);
}
}
return(false);
}
public static void ResetSelected()
{
if (clickedNode != null)
{
//clickedNode.setHovered(false);
//clickedNode.setSelected(false);
clickedNode = null;
}
clickedLabel = null;
rightNode = null;
}
public Bridge GetPivotPoints(MindNode node1, MindNode node2)
{
Point directionmdifier1 = (new Bridge(node1.GetCenter(), node2.GetCenter(), this.NodeColor)).PointDirection();
Point directionmdifier2 = (new Bridge(node2.GetCenter(), node1.GetCenter(), this.NodeColor)).PointDirection();
CalcPoint startpoint = new CalcPoint(node1.GetCenter().X + node1.width * directionmdifier1.X / 2,
node1.GetCenter().Y + node1.height * directionmdifier1.Y / 2);
CalcPoint endpoint = new CalcPoint(node2.GetCenter().X + node2.width * directionmdifier2.X / 2,
node2.GetCenter().Y + node2.height * directionmdifier2.Y / 2);
return(new Bridge(startpoint, endpoint, this.NodeColor));
}
public static void ResetSelection()
{
if (rightNode != null)
{
rightNode.setSelected(false);
}
if (clickedNode != null)
{
clickedNode.setSelected(false);
}
rightNode = null;
}
public int GetMinMaxSpanX()
{
int spanx = -1;
MindNode left = GetMinChildX();
MindNode right = GetMaxChildX();
if (left != null && right != null)
{
spanx = right.xpos + right.width - left.xpos;
}
return(spanx);
}
public int GetMinMaxSpanY()
{
int spany = -1;
MindNode up = GetMinChildY();
MindNode down = GetMaxChildY();
if (up != null && down != null)
{
spany = down.ypos + down.height - up.ypos;
}
return(spany);
}
private MindNode GetMinMaxChild(bool isMin, bool isXAxis)
{
MindNode minmaxNode = null;
if (childNodes.Count > 0)
{
minmaxNode = childNodes[0];
for (int i = 1; i < childNodes.Count; i++)
{
if (isXAxis)
{
if (isMin)
{
if (minmaxNode.xpos > childNodes[i].xpos)
{
minmaxNode = childNodes[i];
}
}
else
{
if (minmaxNode.xpos < childNodes[i].xpos)
{
minmaxNode = childNodes[i];
}
}
}
else
{
if (isMin)
{
if (minmaxNode.ypos > childNodes[i].ypos)
{
minmaxNode = childNodes[i];
}
}
else
{
if (minmaxNode.ypos < childNodes[i].ypos)
{
minmaxNode = childNodes[i];
}
}
}
}
}
return(minmaxNode);
}
public bool AddConnection(MindNode node2)
{
if (!this.connNodes.Contains(node2) && !node2.backconnNodes.Contains(this) && !node2.connNodes.Contains(this) && !this.backconnNodes.Contains(node2))
{
Bridge b = GetPivotPoints(this, node2);
b.textNode.UpdateWidth();
this.connections.Add(b);
//connNodes could be redundant
this.connNodes.Add(node2);
node2.backconnNodes.Add(this);
return(true);
}
return(false);
}
public static void JumpInto(MindNode jumpNode)
{
if (jumpNode.jumpable)
{
if (jumpNode.referenceNode == null)
{
GlobalNodeHandler.viewNode = jumpNode;
}
else
{
GlobalNodeHandler.viewNode = jumpNode.referenceNode;
}
}
if (clickedNode != null)
{
GlobalNodeHandler.clickedNode.setHovered(false);
}
}
public static bool CreateNewNode(int x, int y, bool mousepivot)
{
MindNode newnode = new MindNode(0, x, y, 40, 40, mousepivot);
if (viewNode.AddChild(newnode, false))
{
newnode.SetNodeScale(zoom);
newnode.NodeColor = ColorPicker.selectedcolor;
actionLog.AddAction(new MindNodeAction(0, "CreateNode", newnode));
typing = true;
clickedNode = newnode;
return(true);
}
return(false);
}
public bool collides(MindNode childnode)
{
if (new Rect(xpos, ypos, width, height).Contains(new Point(childnode.xpos, childnode.ypos)))
{
return(true);
}
if (new Rect(xpos, ypos, width, height).Contains(new Point(childnode.xpos, childnode.ypos + childnode.height)))
{
return(true);
}
if (new Rect(xpos, ypos, width, height).Contains(new Point(childnode.xpos + childnode.width, childnode.ypos)))
{
return(true);
}
if (new Rect(xpos, ypos, width, height).Contains(new Point(childnode.xpos + childnode.width, childnode.ypos + childnode.height)))
{
return(true);
}
return(false);
}
public void MakeViewPositive(int offset)
{
MindNode minx = GetMinChildX();
MindNode miny = GetMinChildY();
if (minx != null && miny != null)
{
Point moving = new Point(0 - minx.xpos, 0 - miny.ypos);
if (moving.X > 0)
{
moving.X += offset;
}
if (moving.Y > 0)
{
moving.Y += offset;
}
this.MoveView(moving, 1.0);
}
}
public void RestoreConnections(XContainer noderepresentation)
{
XContainer container = noderepresentation.Element("NODE");
if (container == null)
{
container = noderepresentation;
}
foreach (XElement xe in container.Element("CONNECTIONSLIST").Descendants("CONNECTION"))
{
Color connColor = FileManager.GetColorFromHexString(xe.Element("CONNNODECOLOR").Value);
String connText = xe.Element("CONNNODETEXT").Value;
int connNodeId = -1;
Int32.TryParse(xe.Element("NODECONNID").Value, out connNodeId);
MindNode connNode = GlobalNodeHandler.masterNode.GetExistingNode(connNodeId);
if (connNode != null)
{
this.AddConnection(connNode, connColor, connText);
}
}
}
public async Task RestoreFromClipboard(int posx, int posy)
{
DataPackageView dataPackage = Clipboard.GetContent();
if (dataPackage != null)
{
if (dataPackage.Contains(StandardDataFormats.Text))
{
String NodeText = await dataPackage.GetTextAsync();
MindNode clipNode = filemanager.RestoreNode(NodeText);
//string test = "";
if (clipNode.height > 0 && clipNode.width > 0)
{
clipNode.SetPosition(posx, posy, true);
clipNode.updateRepresentation();
clipNode.ReIDChilds();
GlobalNodeHandler.viewNode.AddChild(clipNode, false);
GlobalNodeHandler.actionLog.AddAction(new MindNodeAction(0, "CreateNode", clipNode));
}
}
}
}
//Restores the Project from an XContainer Representation
public void FromRepresentation(XContainer noderepresentation)
{
// Creates an Containers of all PROJECT ChildNodes
XContainer container = noderepresentation.Element("NODE");
if (container == null)
{
container = noderepresentation;
}
try
{
//System.Diagnostics.Debug.WriteLine(container.ToString());
Int32.TryParse(container.Element("ID").Value, out this.id);
double textpos = 0;
double.TryParse(container.Element("TEXTPOSX").Value, out textpos);
this.textpos.X = textpos;
double.TryParse(container.Element("TEXTPOSY").Value, out textpos);
this.textpos.Y = textpos;
float fontsize = 0;
float.TryParse(container.Element("TEXTSIZE").Value, out fontsize);
this.NodeTextStyle.FontSize = fontsize;
this.NodeTextStyle.FontFamily = container.Element("TEXTFONT").Value;
String fontstyle = container.Element("TEXTSTYLE").Value;
if (fontstyle.Equals("Italic"))
{
this.NodeTextStyle.FontStyle = Windows.UI.Text.FontStyle.Italic;
}
else
{
this.NodeTextStyle.FontStyle = Windows.UI.Text.FontStyle.Normal;
}
String fontweight = container.Element("TEXTFONT").Value;
if (fontweight.Equals("Bold"))
{
this.NodeTextStyle.FontWeight = Windows.UI.Text.FontWeights.Bold;
}
else
{
this.NodeTextStyle.FontWeight = Windows.UI.Text.FontWeights.Normal;
}
this.TextColor = FileManager.GetColorFromHexString(container.Element("TEXTCOLOR").Value);
this.text = container.Element("NODETEXT").Value;
String nodestyle = container.Element("NODESTYLE").Value;
this.NodeDrawingStyle = DrawingStyle.ELLIPSE;
if ((nodestyle).Equals(DrawingStyle.BUTTON.ToString()))
{
this.NodeDrawingStyle = DrawingStyle.BUTTON;
}
if ((nodestyle).Equals(DrawingStyle.CIRCLE.ToString()))
{
this.NodeDrawingStyle = DrawingStyle.CIRCLE;
}
if ((nodestyle).Equals(DrawingStyle.ELLIPSEEDGE.ToString()))
{
this.NodeDrawingStyle = DrawingStyle.ELLIPSEEDGE;
}
if ((nodestyle).Equals(DrawingStyle.RECTANGLE.ToString()))
{
this.NodeDrawingStyle = DrawingStyle.RECTANGLE;
}
this.BorderColor = FileManager.GetColorFromHexString(container.Element("COLORBORDER").Value);
this.NodeColor = FileManager.GetColorFromHexString(container.Element("COLORNODE").Value);
Int32.TryParse(container.Element("NODEBOUNDX").Value, out this.xpos);
Int32.TryParse(container.Element("NODEBOUNDY").Value, out this.ypos);
Int32.TryParse(container.Element("NODEBOUNDWIDTH").Value, out this.width);
Int32.TryParse(container.Element("NODEBOUNDHEIGHT").Value, out this.height);
Boolean.TryParse(container.Element("ISSCALED").Value, out this.scaled);
this.SetScaled(this.scaled);
childNodes.Clear();
//Restore all child nodes
foreach (XElement xe in container.Element("CHILDRENLIST").Descendants("NODE"))
{
//if (xe.Parent.Parent.Parent.Name != "PROJECTTEMPLATE")
MindNode ch = new MindNode(0, 0, 0, 0, 0, false);
ch.FromRepresentation(xe);
childNodes.Add(ch);
//ch.RestoreConnections(xe);
}
this.connNodes.Clear();
this.connections.Clear();
// Only Restore Connections after all Nodes were added to Masternode, because otherwise the nodes could not be found
for (int i = 0; i < this.childNodes.Count; i++)
{
if (i < container.Element("CHILDRENLIST").Descendants("NODE").Count())
{
this.childNodes[i].RestoreConnections(container.Element("CHILDRENLIST").Descendants("NODE").ElementAt(i));
}
}
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("There has been an error restoring Project XML file:" + e.Message);
}
}
public MindNode RestoreNode(String NodeText)
{
MindNode newMasterNode = new MindNode(0, 0, 0, 0, 0, false);
try
{
String[] FileLines = NodeText.Split('\n');
MindNode selectedNode = null;
Stack <MindNode> Selnodes = new Stack <MindNode>();
Stack <int> connIds = new Stack <int>();
Stack <Color> conncolors = new Stack <Color>();
Stack <String> connnames = new Stack <String>();
bool masterfound = false;
for (int i = 0; i < FileLines.Length; i++)
{
String[] atts = FileLines[i].Split(':', '/');
switch (atts[0])
{
case "ID":
selectedNode = newMasterNode.GetExistingNode(int.Parse(atts[1]));
if (selectedNode == null)
{
selectedNode = new MindNode(0, 0, 0, 0, 0, false);
}
break;
case "TextPos":
if (selectedNode != null)
{
selectedNode.textpos.X = int.Parse(atts[1]);
selectedNode.textpos.Y = int.Parse(atts[2]);
}
break;
case "TextFormat":
if (selectedNode != null)
{
CanvasTextFormat newFormat = new CanvasTextFormat();
newFormat.FontSize = int.Parse(atts[1]);
newFormat.FontFamily = atts[2];
if (atts[3].Equals("Italic"))
{
newFormat.FontStyle = Windows.UI.Text.FontStyle.Italic;
}
else
{
newFormat.FontStyle = Windows.UI.Text.FontStyle.Normal;
}
if (atts[4].Equals("Bold"))
{
newFormat.FontWeight = FontWeights.Bold;
}
else
{
newFormat.FontWeight = FontWeights.Normal;
}
selectedNode.SetTextStyle(newFormat);
selectedNode.TextColor = GetColorFromHexString(atts[5]);
}
break;
case "Name":
if (selectedNode != null)
{
selectedNode.SetText(atts[1]);
}
break;
case "NodeStyle":
if (selectedNode != null)
{
selectedNode.NodeDrawingStyle = DrawingStyle.ELLIPSE;
if ((atts[1]).Equals(DrawingStyle.BUTTON.ToString()))
{
selectedNode.NodeDrawingStyle = DrawingStyle.BUTTON;
}
if ((atts[1]).Equals(DrawingStyle.CIRCLE.ToString()))
{
selectedNode.NodeDrawingStyle = DrawingStyle.CIRCLE;
}
if ((atts[1]).Equals(DrawingStyle.ELLIPSEEDGE.ToString()))
{
selectedNode.NodeDrawingStyle = DrawingStyle.ELLIPSEEDGE;
}
if ((atts[1]).Equals(DrawingStyle.RECTANGLE.ToString()))
{
selectedNode.NodeDrawingStyle = DrawingStyle.RECTANGLE;
}
}
break;
case "Color":
if (selectedNode != null)
{
selectedNode.TextColor = GetColorFromHexString(atts[1]);
selectedNode.BorderColor = GetColorFromHexString(atts[2]);
selectedNode.NodeColor = GetColorFromHexString(atts[3]);
}
break;
case "Bounds":
if (selectedNode != null)
{
selectedNode.width = int.Parse(atts[3]);
selectedNode.height = int.Parse(atts[4]);
selectedNode.SetPosition(int.Parse(atts[1]), int.Parse(atts[2]), false);
}
break;
case "Scaled":
if (selectedNode != null)
{
selectedNode.SetScaled(true);
}
break;
case "ConnNodes":
for (int c = 1; c < atts.Length; c++)
{
if (atts[c].Length >= 1)
{
Selnodes.Push(selectedNode);
connIds.Push(int.Parse(atts[c]));
}
}
break;
case "ConnColors":
for (int c = 1; c < atts.Length; c++)
{
if (atts[c].Length >= 1)
{
conncolors.Push(GetColorFromHexString(atts[c]));
}
}
break;
case "ConnNames":
for (int c = 1; c < atts.Length; c++)
{
if (atts[c].Length >= 1)
{
connnames.Push(atts[c]);
}
}
break;
case "Childs":
for (int c = 1; c < atts.Length; c++)
{
if (atts[c].Length >= 1)
{
MindNode newNode = newMasterNode.GetExistingNode(int.Parse(atts[c]));
if (newNode == null)
{
newNode = new MindNode(int.Parse(atts[c]), 0, 0, 0, 0, false);
}
selectedNode.AddChild(newNode, true);
}
}
if (!masterfound)
{
newMasterNode = selectedNode;
masterfound = true;
}
break;
}
}
newMasterNode.DeleteAllConnections();
MindNode m;
String connText;
Color ncolor;
while (Selnodes.Count > 0)
{
m = newMasterNode.GetExistingNode(connIds.Pop());
connText = connnames.Pop();
ncolor = conncolors.Pop();
MindNode selectednode = Selnodes.Pop();
selectednode.AddConnection(m, ncolor, connText);
selectednode.UpdateBridgesRepresentation();
}
}
catch (Exception e)
{
}
return(newMasterNode);
}
public void timer1_Tick(object sender, object e)
{
int x = currentViewPanePosition.X;
int y = currentViewPanePosition.Y;
tickcnt++;
if (GlobalNodeHandler.typing)
{
FocusText(this, new EventArgs());
}
if (tickcnt - MainPage.startcnt > 10 && MainPage.scrolling)
{
MainPage.scrollcnt = 0;
MainPage.scrolling = false;
GlobalNodeHandler.viewNode.UpdateViewRepresentation();
repaint(this, new EventArgs());
}
if (transformPoint.X != 0)
{
transformnode.width = startWidth + transformPoint.X * (x - transformStart.X);
if (transformnode.width < 10)
{
transformnode.width = 10;
}
else if (transformPoint.X == -1)
{
transformnode.xpos = NodeStart.X - (transformStart.X - x);
}
repaint(this, new EventArgs());
}
if (transformPoint.Y != 0)
{
transformnode.height = startHeight + transformPoint.Y * (y - transformStart.Y);
if (transformnode.height < 10)
{
transformnode.height = 10;
}
else if (transformPoint.Y == -1)
{
transformnode.ypos = NodeStart.Y - (transformStart.Y - y);
}
repaint(this, new EventArgs());
}
if (selectedGroup.Count == 0 && !dragging)
{
if (tempNode == null)
{
tempNode = GlobalNodeHandler.viewNode.ContainsChildNode(x, y);
if (tempNode != null)
{
MainPage.status2 += "Hovered over child" + "\n";
}
}
else
{
if (!hoveractive)
{
MainPage.status2 += "Hovered is true" + "\n";
tempNode.setHovered(true);
repaint(this, new EventArgs());
}
hoveractive = true;
if (!tempNode.Contains(x, y))
{
hoveractive = false;
tempNode.setHovered(false);
tempNode = null;
repaint(this, new EventArgs());
}
}
}
else if (dragging)
{
if (selectedGroup.Count == 0)
{
GlobalNodeHandler.clickedNode.SetPosition(x, y, true);
GlobalNodeHandler.clickedNode.UpdatePivots();
GlobalNodeHandler.clickedNode.UpdateBridgesRepresentation();
GlobalNodeHandler.clickedNode.UpdateBridgesRepresentationInward();
GlobalNodeHandler.clickedNode.setHovered(true);
}
else
{
GlobalNodeHandler.clickedNode.SetPosition(x, y, true);
GlobalNodeHandler.clickedNode.UpdatePivots();
GlobalNodeHandler.clickedNode.setHovered(true);
if (selectedGroup.Contains(GlobalNodeHandler.clickedNode))
{
for (int i = 0; i < diffPoints.Count; i++)
{
selectedGroup.ElementAt(i).SetPosition(GlobalNodeHandler.clickedNode.xpos + diffPoints.ElementAt(i).X, GlobalNodeHandler.clickedNode.ypos + diffPoints.ElementAt(i).Y, false);
selectedGroup.ElementAt(i).UpdatePivots();
}
}
else if (diffPoints.Count != 0)
{
foreach (MindNode m in selectedGroup)
{
m.setHovered(false);
}
selectedGroup = new List <MindNode>();
diffPoints = new List <CalcPoint>();
}
}
repaint(this, new EventArgs());
}
if (dragRec)
{
mouseEndPoint = new CalcPoint(x, y);
if (mouseStartPoint.X < mouseEndPoint.X && mouseStartPoint.Y < mouseEndPoint.Y)
{
selectionRec = new Rect(mouseStartPoint.X, mouseStartPoint.Y, mouseEndPoint.X - mouseStartPoint.X, mouseEndPoint.Y - mouseStartPoint.Y);
}
else if (mouseStartPoint.X > mouseEndPoint.X && mouseStartPoint.Y > mouseEndPoint.Y)
{
selectionRec = new Rect(mouseEndPoint.X, mouseEndPoint.Y, mouseStartPoint.X - mouseEndPoint.X, mouseStartPoint.Y - mouseEndPoint.Y);
}
else if (mouseStartPoint.X > mouseEndPoint.X && mouseStartPoint.Y < mouseEndPoint.Y)
{
selectionRec = new Rect(mouseEndPoint.X, mouseStartPoint.Y, mouseStartPoint.X - mouseEndPoint.X, mouseEndPoint.Y - mouseStartPoint.Y);
}
else if (mouseStartPoint.X < mouseEndPoint.X && mouseStartPoint.Y > mouseEndPoint.Y)
{
selectionRec = new Rect(mouseStartPoint.X, mouseEndPoint.Y, mouseEndPoint.X - mouseStartPoint.X, mouseStartPoint.Y - mouseEndPoint.Y);
}
repaint(this, new EventArgs());;
}
else if (dragView)
{
mouseEndPoint = new CalcPoint(x, y);
CalcPoint relative = new CalcPoint(mouseStartPoint.X - mouseEndPoint.X, mouseStartPoint.Y - mouseEndPoint.Y);
mouseStartPoint = mouseEndPoint;
GlobalNodeHandler.viewNode.MoveViewRelativePix(relative);
repaint(this, new EventArgs());
}
}
public async void viewPane_Pressed(MouseObject mousObj)
{
CalcPoint mousePos = mousObj.currentMousePos;
if (GlobalNodeHandler.TabletSelected)
{
if (!GlobalNodeHandler.typing)
{
if (GlobalNodeHandler.pick1.BoxContains(mousePos.ToPoint()))
{
if (GlobalNodeHandler.pick1.ChangeColorTo(mousePos.ToPoint()))
{
repaint(this, new EventArgs());
}
}
else
{
if (GlobalNodeHandler.transforming)
{
if ((transformnode = GlobalNodeHandler.viewNode.ContainsTRecChild(mousePos.X, mousePos.Y)) != null)
{
MindNodeAction action = new MindNodeAction(6, "Transform", transformnode);
transformStart = mousePos;
startWidth = transformnode.width;
startHeight = transformnode.height;
action.sourceSize.X = startWidth;
action.sourceSize.Y = startHeight;
action.startpoint.Push(new CalcPoint(transformnode.xpos, transformnode.ypos));
dragView = false;
NodeStart = new CalcPoint(transformnode.xpos, transformnode.ypos);
if (mousePos.X < transformnode.xpos + transformInBorder)
{
transformPoint.X = -1;
}
else if (mousePos.X > transformnode.xpos + transformnode.width - transformInBorder)
{
transformPoint.X = 1;
}
if (mousePos.Y < transformnode.ypos + transformInBorder)
{
transformPoint.Y = -1;
}
else if (mousePos.Y > transformnode.ypos + transformnode.height - transformInBorder)
{
transformPoint.Y = 1;
}
GlobalNodeHandler.actionLog.AddAction(action);
}
}
if (GlobalNodeHandler.connecting)
{
if (GlobalNodeHandler.clickedNode != null)
{
GlobalNodeHandler.clickedNode.setSelected(false);
}
}
if ((GlobalNodeHandler.clickedNode = GlobalNodeHandler.viewNode.ContainsChildNode(mousePos.X, mousePos.Y)) == null)
{
GlobalNodeHandler.clickedLabel = GlobalNodeHandler.viewNode.ContainsChildLabel(mousePos.X, mousePos.Y);
GlobalNodeHandler.rightNode = null;
mouseStartPoint = mousePos;
if (transformnode == null)
{
dragView = true;
}
clickstartcount = tickcnt;
if (GlobalNodeHandler.coloring)
{
if (GlobalNodeHandler.clickedLabel != null)
{
GlobalNodeHandler.clickedLabel.NodeColor = ColorPicker.selectedcolor;
GlobalNodeHandler.clickedLabel.updateRepresentation();
repaint(this, new EventArgs());;
}
}
if (GlobalNodeHandler.paste)
{
await GlobalNodeHandler.settings.RestoreFromClipboard(mousePos.X, mousePos.Y);
}
}
else
{
if (mousObj.thisButton.Equals(MouseButton.LEFT))
{
if (GlobalNodeHandler.coloring)
{
if (GlobalNodeHandler.clickedNode != null)
{
GlobalNodeHandler.clickedNode.NodeColor = ColorPicker.selectedcolor;
GlobalNodeHandler.clickedNode.updateRepresentation();
repaint(this, new EventArgs());;
}
}
if (GlobalNodeHandler.jumping)
{
GlobalNodeHandler.JumpInto(GlobalNodeHandler.clickedNode);
repaint(this, new EventArgs());
}
if (GlobalNodeHandler.copy)
{
GlobalNodeHandler.settings.CopyToClipboard(GlobalNodeHandler.clickedNode);
}
else if (GlobalNodeHandler.cut)
{
GlobalNodeHandler.settings.CopyToClipboard(GlobalNodeHandler.clickedNode);
GlobalNodeHandler.actionLog.AddAction(new MindNodeAction(1, "DeleteNode", GlobalNodeHandler.clickedNode));
GlobalNodeHandler.clickedNode.DeleteAllConnections();
GlobalNodeHandler.clickedNode.DeleteNode();
repaint(this, new EventArgs());
}
else if (GlobalNodeHandler.connecting)
{
if (GlobalNodeHandler.rightNode == null)
{
GlobalNodeHandler.rightNode = GlobalNodeHandler.clickedNode;
GlobalNodeHandler.rightNode.setSelected(true);
}
else if (!GlobalNodeHandler.clickedNode.Equals(GlobalNodeHandler.rightNode))
{
GlobalNodeHandler.rightNode.setSelected(false);
if (GlobalNodeHandler.rightNode.AddConnection(GlobalNodeHandler.clickedNode))
{
GlobalNodeHandler.actionLog.AddAction(new MindNodeAction(3, "ConnectNodes", GlobalNodeHandler.rightNode, GlobalNodeHandler.clickedNode));
}
GlobalNodeHandler.rightNode.UpdateBridgesRepresentation();
GlobalNodeHandler.clickedNode = null;
GlobalNodeHandler.rightNode = null;
}
repaint(this, new EventArgs());
}
else if (GlobalNodeHandler.disconnecting)
{
if (GlobalNodeHandler.rightNode == null)
{
GlobalNodeHandler.rightNode = GlobalNodeHandler.clickedNode;
GlobalNodeHandler.rightNode.setSelected(true);
}
else
{
GlobalNodeHandler.rightNode.setSelected(false);
if (GlobalNodeHandler.rightNode.connNodes.Contains(GlobalNodeHandler.clickedNode))
{
GlobalNodeHandler.actionLog.AddAction(new MindNodeAction(4, "DeleteConnections", GlobalNodeHandler.rightNode, GlobalNodeHandler.clickedNode));
}
else
{
GlobalNodeHandler.actionLog.AddAction(new MindNodeAction(4, "DeleteConnections", GlobalNodeHandler.clickedNode, GlobalNodeHandler.rightNode));
}
GlobalNodeHandler.rightNode.DeleteConnection(GlobalNodeHandler.clickedNode);
GlobalNodeHandler.clickedNode.DeleteConnection(GlobalNodeHandler.rightNode);
GlobalNodeHandler.clickedNode = null;
GlobalNodeHandler.rightNode = null;
}
repaint(this, new EventArgs());
}
else if (GlobalNodeHandler.deleting)
{
MindNodeAction action = new MindNodeAction(3, "DeleteConnections");
action.involvedNodes.Push(GlobalNodeHandler.clickedNode);
foreach (MindNode m in GlobalNodeHandler.clickedNode.connNodes)
{
action.involvedNodes.Push(GlobalNodeHandler.clickedNode);
action.involvedNodes.Push(m);
}
foreach (MindNode m in GlobalNodeHandler.clickedNode.backconnNodes)
{
action.involvedNodes.Push(m);
action.involvedNodes.Push(GlobalNodeHandler.clickedNode);
}
GlobalNodeHandler.actionLog.AddAction(action);
GlobalNodeHandler.clickedNode.DeleteAllConnections();
GlobalNodeHandler.actionLog.AddAction(new MindNodeAction(1, "DeleteNode", GlobalNodeHandler.clickedNode));
GlobalNodeHandler.viewNode.DeleteNode(GlobalNodeHandler.clickedNode);
repaint(this, new EventArgs());
}
else if (GlobalNodeHandler.moving)
{
if (selectedGroup.Count != 0)
{
MindNodeAction moveaction = new MindNodeAction(2, "MoveNodes");
foreach (MindNode m in selectedGroup)
{
diffPoints.Add(new CalcPoint(m.xpos - GlobalNodeHandler.clickedNode.xpos, m.ypos - GlobalNodeHandler.clickedNode.ypos));
moveaction.startpoint.Push(new CalcPoint(m.xpos, m.ypos));
moveaction.involvedNodes.Push(m);
}
GlobalNodeHandler.actionLog.AddAction(moveaction);
}
else
{
MindNodeAction moveaction = new MindNodeAction(2, "MoveNodes", GlobalNodeHandler.clickedNode);
moveaction.startpoint.Push(new CalcPoint(GlobalNodeHandler.clickedNode.xpos, GlobalNodeHandler.clickedNode.ypos));
GlobalNodeHandler.actionLog.AddAction(moveaction);
}
dragging = true;
}
}
}
if (GlobalNodeHandler.placelabel)
{
if (GlobalNodeHandler.clickedNode != null)
{
activetext.Text = GlobalNodeHandler.clickedNode.text;
GlobalNodeHandler.ShowTextBox(mousObj.currentMousePos, activetext);
GlobalNodeHandler.actionLog.AddAction(new MindNodeAction(5, "ChangeText", GlobalNodeHandler.clickedNode, GlobalNodeHandler.clickedNode.text));
GlobalNodeHandler.typing = true;
}
else if (GlobalNodeHandler.clickedLabel != null)
{
activetext.Text = GlobalNodeHandler.clickedLabel.GetText();
GlobalNodeHandler.ShowTextBox(mousObj.currentMousePos, activetext);
GlobalNodeHandler.actionLog.AddAction(new MindNodeAction(5, "ChangeText", GlobalNodeHandler.clickedLabel, GlobalNodeHandler.clickedLabel.GetText()));
GlobalNodeHandler.typing = true;
}
}
}
}
}
else if (GlobalNodeHandler.mouseSelected)
{
viewPane_MouseDown(mousObj);
}
}
public async Task ReadFile(String path, IStorageFile fiel)
{
try
{
MindNode newMasterNode = new MindNode(0, 0, 0, 0, 0, false);
string fullText = await Windows.Storage.FileIO.ReadTextAsync(fiel, Windows.Storage.Streams.UnicodeEncoding.Utf8);
System.Xml.Linq.XDocument xmlFile = null;
try
{
xmlFile = System.Xml.Linq.XDocument.Parse(fullText);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("No valid XML File falling back to text parser!");
}
if (xmlFile == null)
{
IList <String> text = await Windows.Storage.FileIO.ReadLinesAsync(fiel, Windows.Storage.Streams.UnicodeEncoding.Utf8);
String[] FileLines = text.ToArray();
MindNode selectedNode = null;
Stack <MindNode> Selnodes = new Stack <MindNode>();
Stack <int> connIds = new Stack <int>();
Stack <Color> conncolors = new Stack <Color>();
Stack <String> connnames = new Stack <String>();
for (int i = 0; i < FileLines.Length; i++)
{
String[] atts = FileLines[i].Split(':', '/');
switch (atts[0])
{
case "ID":
selectedNode = newMasterNode.GetExistingNode(int.Parse(atts[1]));
break;
case "TextPos":
if (selectedNode != null)
{
selectedNode.textpos.X = int.Parse(atts[1]);
selectedNode.textpos.Y = int.Parse(atts[2]);
}
break;
case "TextFormat":
if (selectedNode != null)
{
CanvasTextFormat newFormat = new CanvasTextFormat();
newFormat.FontSize = int.Parse(atts[1]);
newFormat.FontFamily = atts[2];
if (atts[3].Equals("Italic"))
{
newFormat.FontStyle = Windows.UI.Text.FontStyle.Italic;
}
else
{
newFormat.FontStyle = Windows.UI.Text.FontStyle.Normal;
}
if (atts[4].Equals("Bold"))
{
newFormat.FontWeight = FontWeights.Bold;
}
else
{
newFormat.FontWeight = FontWeights.Normal;
}
selectedNode.SetTextStyle(newFormat);
selectedNode.TextColor = GetColorFromHexString(atts[5]);
}
break;
case "Name":
if (selectedNode != null)
{
selectedNode.SetText(atts[1]);
}
break;
case "NodeStyle":
if (selectedNode != null)
{
selectedNode.NodeDrawingStyle = DrawingStyle.ELLIPSE;
if ((atts[1]).Equals(DrawingStyle.BUTTON.ToString()))
{
selectedNode.NodeDrawingStyle = DrawingStyle.BUTTON;
}
if ((atts[1]).Equals(DrawingStyle.CIRCLE.ToString()))
{
selectedNode.NodeDrawingStyle = DrawingStyle.CIRCLE;
}
if ((atts[1]).Equals(DrawingStyle.ELLIPSEEDGE.ToString()))
{
selectedNode.NodeDrawingStyle = DrawingStyle.ELLIPSEEDGE;
}
if ((atts[1]).Equals(DrawingStyle.RECTANGLE.ToString()))
{
selectedNode.NodeDrawingStyle = DrawingStyle.RECTANGLE;
}
}
break;
case "Color":
if (selectedNode != null)
{
selectedNode.TextColor = GetColorFromHexString(atts[1]);
selectedNode.BorderColor = GetColorFromHexString(atts[2]);
selectedNode.NodeColor = GetColorFromHexString(atts[3]);
}
break;
case "Bounds":
if (selectedNode != null)
{
selectedNode.width = int.Parse(atts[3]);
selectedNode.height = int.Parse(atts[4]);
selectedNode.SetPosition(int.Parse(atts[1]), int.Parse(atts[2]), false);
}
break;
case "Scaled":
if (selectedNode != null)
{
selectedNode.SetScaled(true);
}
break;
case "ConnNodes":
for (int c = 1; c < atts.Length; c++)
{
if (atts[c].Length >= 1)
{
Selnodes.Push(selectedNode);
connIds.Push(int.Parse(atts[c]));
}
}
break;
case "ConnColors":
for (int c = 1; c < atts.Length; c++)
{
if (atts[c].Length >= 1)
{
conncolors.Push(GetColorFromHexString(atts[c]));
}
}
break;
case "ConnNames":
for (int c = 1; c < atts.Length; c++)
{
if (atts[c].Length >= 1)
{
connnames.Push(atts[c]);
}
}
break;
case "Childs":
for (int c = 1; c < atts.Length; c++)
{
if (atts[c].Length >= 1)
{
MindNode newNode = newMasterNode.GetExistingNode(int.Parse(atts[c]));
if (newNode == null)
{
newNode = new MindNode(int.Parse(atts[c]), 0, 0, 0, 0, false);
}
selectedNode.AddChild(newNode, true);
}
}
break;
}
}
MindNode m;
String connText;
Color ncolor;
while (Selnodes.Count > 0)
{
m = newMasterNode.GetExistingNode(connIds.Pop());
connText = connnames.Pop();
ncolor = conncolors.Pop();
MindNode selectednode = Selnodes.Pop();
selectednode.AddConnection(m, ncolor, connText);
}
}
GlobalNodeHandler.masterNode = newMasterNode;
if (xmlFile != null)
{
GlobalNodeHandler.masterNode.FromRepresentation(xmlFile);
}
GlobalNodeHandler.masterNode.UpdateAllWidths();
}
catch
{
}
}
public void UndoLast()
{
if (undoactions.Count >= 1)
{
MindNodeAction action = undoactions.Last();
undoactions.Remove(action);
switch (action.name)
{
case "CreateNode":
if (action.involvedNodes.Count >= 1)
{
MindNode createdNode = action.involvedNodes.Pop();
redoactions.Add(new MindNodeAction(1, "DeleteNode", createdNode));
createdNode.DeleteNode();
}
break;
case "DeleteNode":
if (action.involvedNodes.Count >= 1)
{
MindNode deletednode = action.involvedNodes.Pop();
redoactions.Add(new MindNodeAction(0, "CreateNode", deletednode));
if (deletednode.parent != null)
{
deletednode.parent.AddChildNoStyle(deletednode, false);
}
// Refresh Pivot Representation after reinstating node
deletednode.UpdatePivots();
}
break;
case "MoveNodes":
if (action.involvedNodes.Count >= 1)
{
MindNodeAction newaction = new MindNodeAction(2, "MoveNodes");
foreach (MindNode movedNode in action.involvedNodes)
{
newaction.involvedNodes.Push(movedNode);
newaction.startpoint.Push(new CalcPoint(movedNode.xpos, movedNode.ypos));
if (action.startpoint.Count > 0)
{
CalcPoint oldPos = action.startpoint.Pop();
movedNode.SetPosition(oldPos.X, oldPos.Y, false);
}
// Refresh Pivot Representation after moving node
movedNode.UpdatePivots();
}
redoactions.Add(newaction);
}
break;
case "ConnectNodes":
if (action.involvedNodes.Count >= 2)
{
MindNodeAction newAction = new MindNodeAction(3, "DeleteConnections");
for (int i = 0; i < action.involvedNodes.Count / 2; i++)
{
MindNode rightnode = action.involvedNodes.Pop();
MindNode leftnode = action.involvedNodes.Pop();
newAction.involvedNodes.Push(leftnode);
newAction.involvedNodes.Push(rightnode);
leftnode.DeleteConnection(rightnode);
}
redoactions.Add(newAction);
}
break;
case "DeleteConnections":
if (action.involvedNodes.Count >= 2)
{
MindNodeAction newAction = new MindNodeAction(3, "ConnectNodes");
for (int i = 0; i < action.involvedNodes.Count / 2; i++)
{
MindNode rightnode = action.involvedNodes.Pop();
MindNode leftnode = action.involvedNodes.Pop();
newAction.involvedNodes.Push(leftnode);
newAction.involvedNodes.Push(rightnode);
leftnode.AddConnection(rightnode);
// Refresh Pivot Representation after reinstating connection
leftnode.UpdatePivots();
}
redoactions.Add(newAction);
}
break;
case "ChangeText":
if (action.involvedNodes.Count >= 1)
{
MindNodeAction newaction = new MindNodeAction(4, "ChangeText");
MindNode changedNode = action.involvedNodes.Pop();
newaction.text = changedNode.text;
newaction.involvedNodes.Push(changedNode);
changedNode.SetText(action.text);
redoactions.Add(newaction);
}
else if (action.involvedLabel != null)
{
MindNodeAction newaction = new MindNodeAction(4, "ChangeText");
NodeLabel changedLabel = action.involvedLabel;
newaction.text = changedLabel.GetText();
newaction.involvedLabel = changedLabel;
changedLabel.SetText(action.text);
redoactions.Add(newaction);
}
break;
case "Transform":
if (action.involvedNodes.Count >= 1)
{
MindNodeAction newaction = new MindNodeAction(5, "Transform");
MindNode changedNode = action.involvedNodes.Pop();
newaction.sourceSize.X = changedNode.width;
newaction.sourceSize.Y = changedNode.height;
newaction.startpoint.Push(new CalcPoint(changedNode.xpos, changedNode.ypos));
newaction.involvedNodes.Push(changedNode);
if (action.sourceSize.X != -1)
{
changedNode.width = action.sourceSize.X;
changedNode.SetScaled(false);
}
if (action.sourceSize.Y != -1)
{
changedNode.height = action.sourceSize.Y;
changedNode.SetScaled(false);
}
CalcPoint oldPos = action.startpoint.Pop();
if (oldPos != null)
{
changedNode.SetPosition(oldPos.X, oldPos.Y, false);
}
// Refresh Pivot Representation after resetting transformation
changedNode.UpdatePivots();
changedNode.updateRepresentation();
redoactions.Add(newaction);
}
break;
}
}
}
