private bool GetAll_Filter_nextTerminal(IVertex testVertex, IEdge nextTerminal)
{
if (nextTerminal == null)
{
return(true);
}
bool foundAll = true;
if (GeneralUtil.CompareStrings(nextTerminal.Meta, "{") ||
GeneralUtil.CompareStrings(nextTerminal.Meta, ","))
{
foreach (IEdge expressionEdge in nextTerminal.To)
{
if (GeneralUtil.CompareStrings(expressionEdge.Meta, ":") ||
GeneralUtil.CompareStrings(expressionEdge.Meta, "$Empty") ||
GeneralUtil.CompareStrings(expressionEdge.Meta, "$EmptyContainerTerminal"))
{
bool found = false;
foreach (IEdge testEdge in testVertex)
{
IEdge _nextTerminal = GetNextExpressionEdgeTerminal(expressionEdge);
if (_nextTerminal == null)
{
if (EdgeExpressionEdgeCompare(testEdge, expressionEdge))
{
found = true;
}
}
else
if (EdgeExpressionEdgeCompare(testEdge, expressionEdge) &&
GetAll_Filter_nextTerminal(testEdge.To, _nextTerminal))
{
found = true;
}
}
if (found == false)
{
foundAll = false;
}
}
if (GeneralUtil.CompareStrings(expressionEdge.Meta, ","))
{
if (!GetAll_Filter_nextTerminal(testVertex, expressionEdge))
{
foundAll = false;
}
}
// if(GeneralUtil.CompareStrings(expressionEdge.Meta,"$EmptyContainerTerminal"))
// if (!GetAll_Filter_nextTerminal(testVertex, expressionEdge))
// foundAll = false;
}
}
return(foundAll);
}
private void VertexUpdated()
{
if (Vertex.Get(@"Definition:Inheritence") != null) // not to display $Inherits
{
return;
}
if (Vertex.Get(@"BaseEdge:\Meta:\$VertexTarget:") != null &&
!GraphUtil.GetValueAndCompareStrings(Vertex.Get(@"Definition:\CreateEdgeOnly:"), "True"))
{
IVertex v = Vertex.Get(@"BaseEdge:\To:");
if (v.Value != null && !GeneralUtil.CompareStrings(v.Value, "$Empty"))
{
Label.Text = (string)v.Value;
}
}
else
{
IVertex v = Vertex.Get(@"BaseEdge:\Meta:");
if (v.Value != null && !GeneralUtil.CompareStrings(v.Value, "$Empty"))
{
Label.Text = (string)v.Value;
}
}
}
private NoInEdgeInOutVertexVertex GetAll_Iterate(NoInEdgeInOutVertexVertex currentSet, IVertex expression, bool isSingleResult)
{
foreach (IEdge e in expression)
{
if (GeneralUtil.CompareStrings(e.Meta.Value, "$Empty") ||
GeneralUtil.CompareStrings(e.Meta.Value, ":") ||
GeneralUtil.CompareStrings(e.Meta.Value, "$EmptyContainerTerminal"))
{
currentSet = GetAll_Filter(currentSet, e);
}
if (GeneralUtil.CompareStrings(e.Meta.Value, "\\"))
{
currentSet = GetAll_OneLevelDeeper(currentSet);
currentSet = GetAll_Iterate(currentSet, e.To, isSingleResult);
}
if (GeneralUtil.CompareStrings(e.Meta.Value, "*"))
{
//currentSet = GetAll_OneLevelDeeper(currentSet); // first, one level deeper - BUT NAH, WE DO NOT WANT. at lest for now
NoInEdgeInOutVertexVertex newCurrentSet = new NoInEdgeInOutVertexVertex(MinusZero.Instance.TempStore);
GetlAll_AllLevelsDeeper(newCurrentSet, currentSet);
currentSet = newCurrentSet;
currentSet = GetAll_Iterate(currentSet, e.To, isSingleResult);
}
}
return(currentSet);
}
private void FillNewVertexAndEdgeBySchemaMenu()
{
IVertex baseVertex = Edge.Get(@"To:");
IVertex r = baseVertex.GetAll(@"$Is:");
if (r.Count() == 0)
{
r = Edge.GetAll(@"Meta:");
}
;
if (r.Count() == 0 || r.FirstOrDefault().To.Value == null || GeneralUtil.CompareStrings(r.FirstOrDefault().To.Value, "$Empty"))
{
NewVertexBySchema.IsEnabled = false;
NewEdgeBySchema.IsEnabled = false;
return;
}
NewVertexBySchema.Items.Clear();
NewEdgeBySchema.Items.Clear();
foreach (IEdge e in r)
{
NewVertexAndEdgeBySchema_FillForMeta(baseVertex, e.To, VertexOperations.GetChildEdges(e.To));
}
NewVertexAndEdgeBySchema_FillForMeta(baseVertex, MinusZero.Instance.Root.Get(@"System\Meta\Base\Vertex"), MinusZero.Instance.Root.GetAll(@"System\Meta\Base\Vertex\"));
NewVertexBySchema.IsEnabled = true;
NewEdgeBySchema.IsEnabled = true;
}
private void VertexChange(object sender, VertexChangeEventArgs e)
{
if ((sender == Vertex.Get(@"BaseEdge:\To:") || sender == Vertex.Get(@"BaseEdge:\Meta:")) &&
e.Type == VertexChangeType.ValueChanged)
{
VertexUpdated();
}
if ((e.Type == VertexChangeType.EdgeAdded && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "IsDashed") || GeneralUtil.CompareStrings(e.Edge.Meta.Value, "LineWidth"))) ||
(e.Type == VertexChangeType.ValueChanged && (sender == Vertex.Get(@"IsDashed:") || sender == Vertex.Get(@"LineWidth:"))))
{
UpdateLine();
}
if ((e.Type == VertexChangeType.EdgeAdded && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "StartAnchor") || GeneralUtil.CompareStrings(e.Edge.Meta.Value, "EndAnchor"))) ||
(e.Type == VertexChangeType.ValueChanged && (sender == Vertex.Get(@"StartAnchor:") || sender == Vertex.Get(@"EndAnchor:"))))
{
UpdateLineEnds();
}
if ((e.Type == VertexChangeType.EdgeAdded && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BackgroundColor") || GeneralUtil.CompareStrings(e.Edge.Meta.Value, "ForegroundColor"))) ||
(e.Type == VertexChangeType.ValueChanged && (
sender == Vertex.Get(@"BackgroundColor:") || sender == Vertex.Get(@"BackgroundColor:\Red:") || sender == Vertex.Get(@"BackgroundColor:\Green:") || sender == Vertex.Get(@"BackgroundColor:\Blue:") || sender == Vertex.Get(@"BackgroundColor:\Opacity:") ||
sender == Vertex.Get(@"ForegroundColor:") || sender == Vertex.Get(@"ForegroundColor:\Red:") || sender == Vertex.Get(@"ForegroundColor:\Green:") || sender == Vertex.Get(@"ForegroundColor:\Blue:") || sender == Vertex.Get(@"ForegroundColor:\Opacity:")
)))
{
UpdateLineEnds();
}
}
public override void DeleteEdge(IEdge _edge)
{
IEdge edge = null;
foreach (IEdge e in OutEdgesRaw)
{
if (e.Meta == _edge.Meta && e.To == _edge.To)
{
edge = e;
}
}
if (edge != null)
{
OutEdgesRaw.Remove(edge);
UsageCounter--;
if (GeneralUtil.CompareStrings(edge.Meta.Value, "$Inherits"))
{
InheritanceCount--;
if (InheritanceCount == 0)
{
HasInheritance = false;
}
}
FireChange(new VertexChangeEventArgs(VertexChangeType.EdgeRemoved, edge));
edge.To.DeleteInEdge(edge);
}
//else // becouse of inheritance this may happen
//throw new Exception(_edge.Meta + " : " + _edge.To + " edge does not exist in given Vertex");
}
private IEdge GetNextExpressionEdgeTerminal(IEdge expressionEdge)
{
if (GeneralUtil.CompareStrings(expressionEdge.Meta.Value, ":"))
{
IList <IEdge> el = expressionEdge.To.OutEdges.ToList();
if (el.Count() > 1 &&
GeneralUtil.CompareStrings(el[0].Meta, "$Empty") &&
GeneralUtil.CompareStrings(el[1].Meta, "$Empty"))
{
if (el.Count() > 2)
{
return(el[2]);
}
}
else
if (el.Count() > 1)
{
return(el[1]);
}
}
else
if (expressionEdge.To.Count() > 0)
{
return(expressionEdge.To.FirstOrDefault());
}
else
{
return(null);
}
return(null); // will never hit this spot
}
public static IVertex GetChildEdges(IVertex metaVertex)
{
IVertex edgeTarget = metaVertex.Get("$EdgeTarget:");
if (edgeTarget != null && edgeTarget != metaVertex)
{
return(GetChildEdges(edgeTarget));
}
IVertex ret = m0.MinusZero.Instance.CreateTempVertex();
foreach (IEdge e in metaVertex)
{
if (GeneralUtil.CompareStrings(e.Meta, "$VertexTarget"))
{
ret.AddEdge(null, m0.MinusZero.Instance.Root.Get(@"System\Meta\Base\Vertex\$EdgeTarget"));
}
else
if ((e.To.Value != null) && ((string)e.To.Value != "") && (((string)e.To.Value)[0] != '$') &&
(GeneralUtil.CompareStrings(e.Meta, "$Empty") || ((string)e.Meta.Value)[0] != '$')) // is extanded
// if (e.To.Get("$VertexTarget:") != null || e.To.Get("$EdgeTarget:") != null)
{
ret.AddEdge(null, e.To);
}
}
return(ret);
}
public static void RegisterVertexChangeListeners(IVertex PlatformClassVertex, VertexChange action, string[] watchList)
{
PlatformClassVertexChangeListener listener = new PlatformClassVertexChangeListener(watchList);
listener.PlatformClassVertex = PlatformClassVertex;
listener.Change += action;
PlatformClassVertex.Change += new VertexChange(listener.Listener);
IVertex AttributeVertexes = PlatformClassVertex.GetAll(@"$Is:{$Inherits:$PlatformClass}\Selector:");
foreach (IEdge e in AttributeVertexes)
{
foreach (IEdge ee in PlatformClassVertex.GetAll(e.To.Value + ":"))
{
GraphUtil.AddHandlerIfDelegateListDoesNotContainsIt(ee.To, listener.Listener);
foreach (string metaFromWatchList in listener.WatchList)
{
if (GeneralUtil.CompareStrings(ee.Meta.Value, metaFromWatchList))
{
foreach (IEdge eee in ee.To)
{
GraphUtil.AddHandlerIfDelegateListDoesNotContainsIt(eee.To, listener.Listener);
}
}
}
}
}
}
public static IVertex Open(IVertex baseVertex, IVertex inputVertex)
{
IVertex DefaultVis;
DefaultVis = baseVertex.Get(@"Meta:\$DefaultOpenVisualiser:");
if (DefaultVis == null)
{
DefaultVis = baseVertex.Get(@"To:\$Is:\$Is:\$DefaultOpenVisualiser:"); // yes. bad but it is
}
if (DefaultVis == null)
{
DefaultVis = baseVertex.Get(@"Meta:\$EdgeTarget:\$DefaultEditVisualiser:");
}
if (DefaultVis == null)
{
DefaultVis = MinusZero.Instance.Root.Get(@"System\Meta\Visualiser\Form");
}
if (GeneralUtil.CompareStrings(DefaultVis.Value, "Diagram"))
{
return(OpenDiagram(baseVertex, DefaultVis));
}
return(OpenVisualiser(baseVertex, DefaultVis));
}
protected void AddEdge(IEdge e)
{
StackPanel p = new StackPanel();
p.Margin = new Thickness(Margin);
if (!GeneralUtil.CompareStrings(e.Meta.Value, "$Empty"))
{
TextBlock label = new TextBlock();
label.Foreground = (Brush)FindResource("0GrayBrush");
label.Text = e.Meta.Value.ToString();
label.LayoutTransform = new ScaleTransform(Scale, Scale);
p.Children.Add(label);
}
VisualiserEditWrapper w = new VisualiserEditWrapper();
w.LayoutTransform = new ScaleTransform(Scale, Scale);
w.BaseEdge = e;
p.Children.Add(w);
Children.Add(p);
}
protected void VertexChange(object sender, VertexChangeEventArgs e)
{
if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BaseEdge")))
{
UpdateBaseEdge();
}
if ((sender == Vertex.Get("BaseEdge:")) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "To")) ||
(sender == Vertex.Get(@"BaseEdge:\To:") && e.Type == VertexChangeType.ValueChanged))
{
UpdateBaseEdge();
}
if (sender == Vertex.Get("ZoomVisualiserContent:") && e.Type == VertexChangeType.ValueChanged)
{
ChangeZoomVisualiserContent();
}
if (sender == Vertex.Get("ShowWhiteSpace:") && e.Type == VertexChangeType.ValueChanged)
{
UpdateEditView();
}
if (sender == Vertex.Get("HighlightedLine:") && e.Type == VertexChangeType.ValueChanged)
{
UpdateEditView();
}
}
public override IEdge AddEdge(IVertex metaVertex, IVertex destVertex)
{
// LOG BEGIN
/*
* if(metaVertex==null)
* MinusZero.Instance.Log(3,"AddEdge", GeneralUtil.EmptyIfNull(this.Value) + " [NULL] " + GeneralUtil.EmptyIfNull(destVertex.Value));
* else
* MinusZero.Instance.Log(3,"AddEdge", GeneralUtil.EmptyIfNull(this.Value) + " [" + GeneralUtil.EmptyIfNull(metaVertex.Value) + "] " + GeneralUtil.EmptyIfNull(destVertex.Value));
*/
// LOG END
if (destVertex == null)
{
throw new Exception("target vertex can not be null");
}
EdgeBase ne = new EasyEdge(this, metaVertex, destVertex);
OutEdgesRaw.Add(ne);
UsageCounter++;
if (GeneralUtil.CompareStrings(ne.Meta.Value, "$Inherits"))
{
InheritanceCount++;
HasInheritance = true;
}
FireChange(new VertexChangeEventArgs(VertexChangeType.EdgeAdded, ne));
return(ne);
}
public void VertexChange(object sender, VertexChangeEventArgs e)
{
if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BaseEdge")) ||
(sender == Vertex.Get("BaseEdge:") && e.Type == VertexChangeType.ValueChanged) ||
((sender == Vertex.Get("BaseEdge:")) && (e.Type == VertexChangeType.EdgeAdded) && ((GeneralUtil.CompareStrings(e.Edge.Meta.Value, "To")))))
{
UpdateBaseEdge(); return;
}
if (sender == Vertex.Get(@"BaseEdge:\To:") && (e.Type == VertexChangeType.EdgeAdded || e.Type == VertexChangeType.EdgeRemoved))
{
UpdateBaseEdge(); return;
}
if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "SelectedEdges")))
{
SelectedVertexesUpdated(); return;
}
if ((sender == Vertex.Get("SelectedEdges:")) && ((e.Type == VertexChangeType.EdgeAdded) || (e.Type == VertexChangeType.EdgeRemoved)))
{
SelectedVertexesUpdated(); return;
}
if (sender is IVertex && GraphUtil.FindEdgeByToVertex(Vertex.GetAll(@"SelectedEdges:\"), (IVertex)sender) != null)
{
SelectedVertexesUpdated(); return;
}
if (sender == Vertex.Get("ZoomVisualiserContent:") && e.Type == VertexChangeType.ValueChanged)
{
ChangeZoomVisualiserContent(); return;
}
if (sender == Vertex.Get("VisualiserCircleSize:") && e.Type == VertexChangeType.ValueChanged)
{
PaintGraph(); return;
}
if (sender == Vertex.Get("NumberOfCircles:") && e.Type == VertexChangeType.ValueChanged)
{
PaintGraph(); return;
}
if (sender == Vertex.Get("FastMode:") && e.Type == VertexChangeType.ValueChanged)
{
PaintGraph(); return;
}
if (sender == Vertex.Get("MetaLabels:") && e.Type == VertexChangeType.ValueChanged)
{
PaintGraph(); return;
}
if (sender == Vertex.Get("ShowInEdges:") && e.Type == VertexChangeType.ValueChanged)
{
PaintGraph(); return;
}
}
public static IVertex Delete(IVertex baseVertex, IVertex inputVertex)
{
IVertex info = m0.MinusZero.Instance.CreateTempVertex();
info.Value = "DELETE vertex";
IVertex options = m0.MinusZero.Instance.CreateTempVertex();
options.AddVertex(null, "Edge delete");
options.AddVertex(null, "Remove from repository");
options.AddVertex(null, "Cancel");
IVertex option = MinusZero.Instance.DefaultShow.SelectDialogButton(info, options, null);
bool allEdgesDelete = false;
if (option == null || GeneralUtil.CompareStrings(option.Value, "Cancel"))
{
return(null);
}
if (GeneralUtil.CompareStrings(option.Value, "Remove from repository"))
{
allEdgesDelete = true;
}
if (inputVertex.Get("SelectedEdges:").Count() == 0)
{
if (allEdgesDelete)
{
VertexOperations.DeleteAllEdges(baseVertex.Get("To:"));
}
else
{
VertexOperations.DeleteOneEdge(baseVertex.Get("From:"), baseVertex.Get("Meta:"), baseVertex.Get("To:"));
}
}
else
{
IList <IEdge> selected = GeneralUtil.CreateAndCopyList(inputVertex.Get("SelectedEdges:"));
foreach (IEdge v in selected)
{
if (allEdgesDelete)
{
VertexOperations.DeleteAllEdges(v.To.Get("To:"));
}
else
{
VertexOperations.DeleteOneEdge(v.To.Get("From:"), v.To.Get("Meta:"), v.To.Get("To:"));
}
}
}
return(null);
}
public bool CompareMeta(IEdge vertex)
{
if (GeneralUtil.CompareStrings(Value, vertex.Meta.Value))
{
return(true);
}
return(false);
}
protected void VertexChange(object sender, VertexChangeEventArgs e)
{
if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BaseEdge")) ||
(sender == Vertex.Get("BaseEdge:") && e.Type == VertexChangeType.ValueChanged) ||
((sender == Vertex.Get("BaseEdge:")) && (e.Type == VertexChangeType.EdgeAdded) && ((GeneralUtil.CompareStrings(e.Edge.Meta.Value, "To")))) ||
(sender == Vertex.Get(@"BaseEdge:\To:") && e.Type == VertexChangeType.ValueChanged))
{
UpdateBaseEdge();
}
}
void GraphCreationCodeGenerateAsString_Reccurent(IVertex v, StringBuilder s, int level, List <IVertex> beenList)
{
if (v.OutEdges.Count() > 0)
{
// s.Append("{");
appendNewLine(s);
bool isFirst = true;
foreach (IEdge e in v.OutEdges)
{
if (!beenList.Contains(e.To))
{
beenList.Add(e.To);
if (isFirst)
{
isFirst = false;
}
else
{
// s.Append(",");
appendNewLine(s);
}
if (GeneralUtil.CompareStrings(e.Meta.Value, "$Empty"))
{
appendTabs(s, level + 1);
appendLiteral(s, e.To.Value.ToString());
}
else
{
appendTabs(s, level + 1);
appendLiteral(s, e.Meta.Value.ToString());
s.Append(":");
if (e.To.Value != null)
{
appendLiteral(s, e.To.Value.ToString());
}
}
GraphCreationCodeGenerateAsString_Reccurent(e.To, s, level + 1, beenList);
}
}
// appendNewLine(s);
appendTabs(s, level);
// s.Append("}");
}
}
protected override void CreateView()
{
if (GraphUtil.GetValueAndCompareStrings(Vertex.Get("AlternatingRows:"), "True"))
{
this.ThisDataGrid.AlternatingRowBackground = (Brush)FindResource("0AlternatingBackgroundBrush");
}
else
{
this.ThisDataGrid.AlternatingRowBackground = (Brush)FindResource("0BackgroundBrush");
}
ThisDataGrid.Columns.Clear();
AddInfoTemplateButton();
AddDeleteTemplateButton();
AddColumn("", ""); // Vertex level column
IVertex childs = null;
if (ToShowEdgesMeta != null)
{
childs = VertexOperations.GetChildEdges(ToShowEdgesMeta);
foreach (IEdge e in childs)
{
if (e.To.Get("$Hide:") == null)
{
AddColumn((string)e.To.Value, "To[" + (string)e.To.Value + "]");
}
}
if (ExpertMode)
{
foreach (IEdge e in MinusZero.Instance.Root.Get(@"System\Meta\Base\Vertex"))
{
bool contains = false;
foreach (IEdge ee in childs)
{
if (GeneralUtil.CompareStrings(ee.To, e.To))
{
contains = true;
}
}
if (contains == false && e.To.Get("$Hide:") == null)
{
AddColumn((string)e.To.Value, "To[" + (string)e.To.Value + "]");
}
}
}
}
}
static public IEdge FindEdgeByMetaValue(IVertex Vertex, string MetaValue)
{
foreach (IEdge e in Vertex)
{
if (GeneralUtil.CompareStrings(e.Meta.Value, MetaValue))
{
return(e);
}
}
return(null);
}
static public IEdge FindEdgeByToVertex(IEnumerable <IEdge> edges, string toVertexValue)
{
foreach (IEdge e in edges)
{
if (GeneralUtil.CompareStrings(e.To.Value, toVertexValue))
{
return(e);
}
}
return(null);
}
static public IVertex FindOneByMeta(IVertex findRoot, string value)
{
foreach (IEdge e in findRoot)
{
if (GeneralUtil.CompareStrings(e.Meta.Value, value))
{
return(e.To);
}
}
return(null);
}
public TreeViewItem GetTreeViewItem(IEdge e, bool generateDeeperLevel)
{
SimpleTreeVisualiserViewItem i = new SimpleTreeVisualiserViewItem();
i.TreeParent = this;
i.Tag = e.To;
StackPanel s = new StackPanel();
if (GeneralUtil.CompareStrings(e.Meta.Value, "$Empty") && HideMetaNameIfEmpty)
{
Label ll = new Label();
ll.Content = e.To.Value;// +":" + SimpleTreeVisualiserViewItem.cnt;
ll.Padding = new Thickness(0);
ll.FontWeight = FontWeight.FromOpenTypeWeight(999);
s.Children.Add(ll);
}
else
{
s.Orientation = Orientation.Horizontal;
Label l1 = new Label();
l1.Content = e.Meta.Value + " : ";
l1.Padding = new Thickness(0);
l1.Foreground = new SolidColorBrush(Colors.Gray);
Label l2 = new Label();
l2.Content = e.To.Value;// +":" + SimpleTreeVisualiserViewItem.cnt;
l2.Padding = new Thickness(0);
l2.FontWeight = FontWeight.FromOpenTypeWeight(999);
s.Children.Add(l1);
s.Children.Add(l2);
}
i.Header = s;
if (generateDeeperLevel)
{
foreach (IEdge ee in e.To)
{
i.Items.Add(GetTreeViewItem(ee, false));
}
}
return(i);
}
public void UpdateHeader()
{
StackPanel s = new StackPanel();
IEdge e = (IEdge)Tag;
if ((GeneralUtil.CompareStrings(e.Meta.Value, "$Empty") && HideMetaNameIfEmpty) || e.Meta.Value == null)
{
Label ll = new Label();
if (e.To.Value == null || GeneralUtil.CompareStrings(e.To.Value, ""))
{
ll.Content = "[$Empty]";
}
else
{
ll.Content = e.To.Value;
}
ll.Padding = new Thickness(0);
ll.Foreground = (Brush)FindResource("0ForegroundBrush");
ll.FontWeight = UIWpf.ValueWeight;
s.Children.Add(ll);
}
else
{
s.Orientation = Orientation.Horizontal;
Label l1 = new Label();
l1.Content = e.Meta.Value + " : ";
l1.Padding = new Thickness(0);
l1.Foreground = (Brush)FindResource("0GrayBrush");
l1.FontStyle = FontStyles.Italic;
l1.FontWeight = UIWpf.MetaWeight;
Label l2 = new Label();
l2.Content = e.To.Value;
l2.Padding = new Thickness(0);
l2.Foreground = (Brush)FindResource("0ForegroundBrush");
l2.FontWeight = UIWpf.ValueWeight;
s.Children.Add(l1);
s.Children.Add(l2);
}
Header = s;
}
public IVertex Execute(IVertex baseVertex, IVertex inputVertex, IVertex expression)
{
foreach (IEdge e in expression)
{
if (GeneralUtil.CompareStrings(e.Meta.Value, "$Empty"))
{
baseVertex.Value = DequoteString((string)e.To.Value);
}
Execute_exec(e.To, baseVertex, baseVertex, inputVertex, 0, false);
}
return(null);
}
private void Execute_exec(IVertex v, IVertex baseVertex, IVertex current, IVertex inputVertex, int skip, bool wasPreviousTokenComa)
{
int cnt = 0;
foreach (IEdge e in v)
{
if (skip > 0)
{
skip--;
}
else
{
cnt++;
if (GeneralUtil.CompareStrings(e.Meta.Value, "$Empty"))
{
current = baseVertex.AddVertex(null, DequoteString((string)e.To.Value));
}
if (GeneralUtil.CompareStrings(e.Meta.Value, "$EmptyContainerTerminal"))
{
current = baseVertex.AddVertex(null, "");
}
if (GeneralUtil.CompareStrings(e.Meta.Value, ":"))
{
current = Execute_colon(e.To, baseVertex, inputVertex);
}
else if (GeneralUtil.CompareStrings(e.Meta.Value, "{"))
{
baseVertex = current;
Execute_exec(e.To, baseVertex, current, inputVertex, 0, false);
}
else if (GeneralUtil.CompareStrings(e.Meta.Value, ","))
{
if (wasPreviousTokenComa && cnt == 1)
{
current = baseVertex.AddVertex(null, "");
}
Execute_exec(e.To, baseVertex, current, inputVertex, 0, true);
}
else
{
Execute_exec(e.To, baseVertex, current, inputVertex, 0, false);
}
}
}
}
public IVertex GetEdgeByLocation(Point p)
{
vertexByLocationToReturn = null;
GetVertexByLocation_Reccurent(this.Items, p);
// DO NOT WANT THIS FEATURE
if (vertexByLocationToReturn == null && GeneralUtil.CompareStrings(MinusZero.Instance.Root.Get(@"User\CurrentUser:\Settings:\AllowBlankAreaDragAndDrop:").Value, "StartAndEnd"))
{
vertexByLocationToReturn = Vertex.Get(@"BaseEdge:");
}
return(vertexByLocationToReturn);
}
private void dndDrop(object sender, DragEventArgs e)
{
IVertex v = GetEdgeByLocation(e.GetPosition(this));
if (v == null && GeneralUtil.CompareStrings(MinusZero.Instance.Root.Get(@"User\CurrentUser:\Settings:\AllowBlankAreaDragAndDrop:").Value, "OnlyEnd"))
{
v = Vertex.Get("BaseEdge:");
}
if (v != null)
{
Dnd.DoDrop(null, v.Get("To:"), e);
}
}
private void Button_Click_1(object sender, RoutedEventArgs e)
{
if (!GeneralUtil.CompareStrings(this.To.Vertex.Get(@"BaseEdge:\To:\To:").Value, "$Empty"))
{
if (GeneralUtil.CompareStrings(this.Meta.Vertex.Get(@"BaseEdge:\To:\To:").Value, "$Empty"))
{
Vertex.AddEdge(null, this.To.Vertex.Get(@"BaseEdge:\To:\To:"));
}
else
{
Vertex.AddEdge(this.Meta.Vertex.Get(@"BaseEdge:\To:\To:"), this.To.Vertex.Get(@"BaseEdge:\To:\To:"));
}
MinusZero.Instance.DefaultShow.CloseWindowByContent(this);
}
}
public static void DoDrop(object orgin, IVertex baseVertex, DragEventArgs e)
{
object sender = e.Data.GetData("DragSource");
if (sender == null || orgin == sender)
{
return;
}
bool doCopy = false;
if (GeneralUtil.CompareStrings(MinusZero.Instance.Root.Get(@"User\CurrentUser:\Settings:\CopyOnDragAndDrop:").Value, "True"))
{
doCopy = true;
}
if (e.Data.GetDataPresent("Vertex"))
{
IVertex dndVertex = e.Data.GetData("Vertex") as IVertex;
foreach (IEdge ee in dndVertex)
{
if (doCopy)
{
baseVertex.AddEdge(ee.To.Get("Meta:"), ee.To.Get("To:"));
}
else
{
if (ee.To.Get("To:") != baseVertex) // do not want to cut and paste to itself
{
GraphUtil.DeleteEdge(ee.To.Get("From:"), ee.To.Get("Meta:"), ee.To.Get("To:"));
baseVertex.AddEdge(ee.To.Get("Meta:"), ee.To.Get("To:"));
}
}
}
if (sender is IHasSelectableEdges)
{
((IHasSelectableEdges)sender).UnselectAllSelectedEdges();
}
GraphUtil.RemoveAllEdges(dndVertex);
}
MinusZero.Instance.IsGUIDragging = false;
}
