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));
}
public static IVertex OpenVisualiserSelectedBase(IVertex baseVertex, IVertex inputVertex)
{
IPlatformClass pc = (IPlatformClass)PlatformClass.CreatePlatformObject(inputVertex.Get("VisualiserClass:"));
GraphUtil.ReplaceEdge(pc.Vertex.Get("BaseEdge:"), "Meta", baseVertex.Get("Meta:"));
GraphUtil.ReplaceEdge(pc.Vertex.Get("BaseEdge:"), "To", baseVertex.Get("To:"));
IVertex synchronisedVisualiser = inputVertex.Get("SynchronisedVisualiser:");
BaseSelectedSynchronisedHelper helper = new BaseSelectedSynchronisedHelper(pc.Vertex, synchronisedVisualiser);
PlatformClass.RegisterVertexChangeListeners(synchronisedVisualiser, new VertexChange(helper.SynchronisedVisualiserChange), new string[] { "BaseEdge", "SelectedEdges" });
IVertex firstSelectedVertex = synchronisedVisualiser.Get(@"SelectedEdges:\");
if (firstSelectedVertex != null)
{
GraphUtil.ReplaceEdge(pc.Vertex, "BaseEdge", firstSelectedVertex);
}
MinusZero.Instance.DefaultShow.ShowContent(pc);
return(null);
}
public static IVertex GetMostInheritedMeta(IVertex baseVertex, IVertex startMeta)
{
IVertex _startMeta = startMeta;
if (startMeta.Get("$EdgeTarget") != null)
{
_startMeta = startMeta.Get("$EdgeTarget:");
}
IVertex highestInheritanceLevel = null;
int highestInheritanceLevel_level = 0;
int tempLevel;
foreach (IEdge e in baseVertex.GetAll("$Is:"))
{
tempLevel = getInheritanceLevel(e.To, _startMeta, 0);
if (tempLevel >= highestInheritanceLevel_level)
{
highestInheritanceLevel_level = tempLevel;
highestInheritanceLevel = e.To;
}
}
return(highestInheritanceLevel); // if highestInheritanceLevel_level==0 then startMeta was not found
}
public static IVertex AddInstanceByEdgeVertex(IVertex baseVertex, IVertex edgeVertex) // by EdgeTarget or VertexTarget or by iself
{
// $EdgeTarget
IVertex edgeVertexEdgeTarget = edgeVertex.Get("$EdgeTarget:");
if (edgeVertexEdgeTarget != null)
{
return(AddInstance(baseVertex, edgeVertexEdgeTarget, edgeVertex));
}
// $VertexTarget
IVertex edgeVertexVertexTarget = edgeVertex.Get("$VertexTarget:");
if (edgeVertexVertexTarget != null)
{
IVertex ret = AddInstance(baseVertex, edgeVertex, edgeVertex);
// GraphUtil.CreateOrReplaceEdge(ret, MinusZero.Instance.Root.Get(@"System\Meta\Base\Vertex\$EdgeTarget"), edgeVertexVertexTarget);
//
// ???? this is not working like this
return(ret);
}
// EMPTY (edge+vertex one)
AddInstance(baseVertex, edgeVertex, edgeVertex);
return(null);
}
protected override void OnSelectionChanged(SelectionChangedEventArgs _e)
{
if (DoingSelectionChanged == false)
{
DoingSelectionChanged = true;
if (this.SelectedItem != null && ((ComboBoxItem)this.SelectedItem).Tag is IVertex)
{
IVertex tag = (IVertex)((ComboBoxItem)this.SelectedItem).Tag;
IVertex bev = Vertex.Get("BaseEdge:");
if (bev != null)
{
IVertex fromv = bev.Get("From:");
IVertex metav = bev.Get("Meta:");
IVertex tov = bev.Get("To:");
if (tov != tag) // is there any change ?
{
//GraphUtil.ReplaceEdge(fromv, metav, tag);
GraphUtil.CreateOrReplaceEdge(fromv, metav, tag);
GraphUtil.CreateOrReplaceEdge(bev, MinusZero.Instance.Root.Get(@"System\Meta\ZeroTypes\Edge\To"), tag);
}
}
}
DoingSelectionChanged = false;
}
base.OnSelectionChanged(_e);
}
public static void DoDropForVertexVisualiser(object orgin, IVertex baseEdge, DragEventArgs e)
{
IVertex r = MinusZero.Instance.Root;
object sender = e.Data.GetData("DragSource");
if (sender == null || orgin == sender)
{
return;
}
if (e.Data.GetDataPresent("Vertex"))
{
IVertex dndVertex = e.Data.GetData("Vertex") as IVertex;
IEdge ee = dndVertex.FirstOrDefault();
if (ee != null)
{
IVertex toMeta = r.Get(@"System\Meta\ZeroTypes\Edge\To");
GraphUtil.CreateOrReplaceEdge(baseEdge.Get("From:"), baseEdge.Get("Meta:"), ee.To.Get("To:"));
GraphUtil.CreateOrReplaceEdge(baseEdge, toMeta, ee.To.Get("To:")); // this is needed for some update scenarios
}
if (sender is IHasSelectableEdges)
{
((IHasSelectableEdges)sender).UnselectAllSelectedEdges();
}
GraphUtil.RemoveAllEdges(dndVertex);
}
MinusZero.Instance.IsGUIDragging = false;
}
private void UpdateBaseEdge()
{
IVertex bev = Vertex.Get("BaseEdge:");
if (bev == null)
{
return;
}
IVertex fromv = bev.Get("From:");
IVertex metav = bev.Get("Meta:");
IVertex tov = bev.Get("To:");
if (fromv != null && metav != null && tov != null)
{
this.Items.Clear();
ComboBoxItem SelectedItem = null;
foreach (IEdge e in metav.GetAll(@"$EdgeTarget:\EnumValue:"))
{
ComboBoxItem i = new ComboBoxItem();
i.Content = e.To.Value;
i.Tag = e.To;
this.Items.Add(i);
if (tov.Value == e.To.Value)
{
SelectedItem = i;
}
}
this.SelectedItem = SelectedItem;
}
}
public void MoveAndResizeItem(double left, double top, double width, double height)
{
if (width < 0 || height < 0)
{
return;
}
Vertex.Get("PositionX:").Value = left;
Vertex.Get("PositionY:").Value = top;
Canvas.SetLeft(this, left);
Canvas.SetTop(this, top);
IVertex r = m0.MinusZero.Instance.Root;
GraphUtil.SetVertexValue(this.Vertex, r.Get(@"System\Meta\Visualiser\Diagram\SizeX"), width);
GraphUtil.SetVertexValue(this.Vertex, r.Get(@"System\Meta\Visualiser\Diagram\SizeY"), height);
Width = width;
Height = height;
UpdateAnchors(left, top, width, height);
UpdateDiagramLines();
}
static public void AddEdgeEdgesOnlyTo(IVertex baseVertex, IVertex toVertex)
{
IVertex r = MinusZero.Instance.Root;
baseVertex.AddVertex(r.Get(@"System\Meta\ZeroTypes\Edge\From"), null);
baseVertex.AddEdge(r.Get(@"System\Meta\ZeroTypes\Edge\Meta"), MinusZero.Instance.Empty);
baseVertex.AddEdge(r.Get(@"System\Meta\ZeroTypes\Edge\To"), toVertex);
}
static public void AddEdgeEdgesOnlyMetaTo(IVertex baseVertex, IVertex edgeMeta, IVertex edgeTo)
{
IVertex r = MinusZero.Instance.Root;
baseVertex.AddVertex(r.Get(@"System\Meta\ZeroTypes\Edge\From"), null);
baseVertex.AddEdge(r.Get(@"System\Meta\ZeroTypes\Edge\Meta"), edgeMeta);
baseVertex.AddEdge(r.Get(@"System\Meta\ZeroTypes\Edge\To"), edgeTo);
}
static public void AddEdgeEdges(IVertex baseVertex, IEdge edge)
{
IVertex r = MinusZero.Instance.Root;
baseVertex.AddEdge(r.Get(@"System\Meta\ZeroTypes\Edge\From"), edge.From);
baseVertex.AddEdge(r.Get(@"System\Meta\ZeroTypes\Edge\Meta"), edge.Meta);
baseVertex.AddEdge(r.Get(@"System\Meta\ZeroTypes\Edge\To"), edge.To);
}
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);
}
private static void AddNewLineOption(IVertex v, IEdge def, IEdge e)
{
IVertex r = m0.MinusZero.Instance.Root;
IVertex vv = v.AddVertex(null, e.To.Value + " (" + def.To.Value + ")");//def.To.Value + " for " + e.To.Value);
vv.AddEdge(r.Get(@"System\Meta\Visualiser\DiagramInternal\DiagramItemBase\OptionEdge"), e.To);
vv.AddEdge(r.Get(@"System\Meta\Visualiser\DiagramInternal\DiagramItemBase\OptionDiagramLineDefinition"), def.To);
}
public static void StartNonAtomProcess()
{
IVertex r = MinusZero.Instance.Root;
IVertex process = ZeroTypes.VertexOperations.AddInstance(r.Get(@"User\CurrentUser:\CurrentSession:"), r.Get(@"System\Meta\User\NonAtomProcess"), r.Get(@"System\Meta\User\Session\Process"));
process.AddEdge(r.Get(@"System\Meta\User\NonAtomProcess\StartTimeStamp"), MinusZero.Instance.Empty);
ZeroTypes.DateTime.FillDateTime(process.Get("StartTimeStamp:"), DateTime.Now);
}
void OnOpenVisualiserSelectedSelected(object sender, System.Windows.RoutedEventArgs e)
{
IVertex input = MinusZero.Instance.CreateTempVertex();
IVertex root = MinusZero.Instance.Root;
input.AddEdge(root.Get(@"System\Meta\Commands*VisualiserClass"), ((IVertex)((MenuItem)sender).Tag));
input.AddEdge(root.Get(@"System\Meta\Commands*SynchronisedVisualiser"), PlatformClass.Vertex);
BaseCommands.OpenVisualiserSelectedSelected(this.Edge, input);
}
static public IVertex AddEdge(IVertex baseVertex, IVertex fromEdge, IVertex metaEdge, IVertex toVertex)
{
IVertex r = MinusZero.Instance.Root;
IVertex ev = baseVertex.AddVertex(r.Get(@"System\Meta\ZeroTypes\Edge"), null);
ev.AddEdge(r.Get(@"System\Meta\ZeroTypes\Edge\From"), fromEdge);
ev.AddEdge(r.Get(@"System\Meta\ZeroTypes\Edge\Meta"), metaEdge);
ev.AddEdge(r.Get(@"System\Meta\ZeroTypes\Edge\To"), toVertex);
return(ev);
}
public static IVertex OpenVisualiserSelectedSelected(IVertex baseVertex, IVertex inputVertex)
{
IPlatformClass pc = (IPlatformClass)PlatformClass.CreatePlatformObject(inputVertex.Get("VisualiserClass:"));
GraphUtil.ReplaceEdge(pc.Vertex, "BaseEdge", baseVertex);
GraphUtil.ReplaceEdge(pc.Vertex, "SelectedEdges", inputVertex.Get(@"SynchronisedVisualiser:\SelectedEdges:"));
MinusZero.Instance.DefaultShow.ShowContent(pc);
return(null);
}
public static IVertex TestIfNewEdgeValid(IVertex baseVertex, IVertex metaVertex, IVertex toVertex)
{
int MaxCardinality = GraphUtil.GetIntegerValue(metaVertex.Get(@"$MaxCardinality:"));
if (MaxCardinality != -1 && MaxCardinality != GraphUtil.NullInt)
{
int cnt = 0;
foreach (IEdge e in baseVertex)
{
if (e.Meta == metaVertex)
{
cnt++;
}
}
if ((cnt + 1) > MaxCardinality)
{
IVertex v = MinusZero.Instance.CreateTempVertex();
v.Value = "Source vertex allready contains $MaxCardinality count of edges of desired meta.";
return(v);
}
}
int MaxTargetCardinality = GraphUtil.GetIntegerValue(metaVertex.Get(@"$MaxTargetCardinality:"));
if (MaxTargetCardinality != -1 && MaxTargetCardinality != GraphUtil.NullInt && toVertex != null)
{
int cnt = 0;
foreach (IEdge e in toVertex.InEdges)
{
if (e.Meta == metaVertex)
{
cnt++;
}
}
if ((cnt + 1) > MaxCardinality)
{
IVertex v = MinusZero.Instance.CreateTempVertex();
v.Value = "Target vertex allready contains $MaxTargetCardinality count of in edges of desired meta.";
return(v);
}
}
return(null);
}
public static IVertex GetUserChoice(IVertex question)
{
IVertex r = MinusZero.Instance.Root;
IVertex answer = r.Get(@"User\CurrentUser:\CurrentSession:\Process:\" + question.Value + ":");
if (answer == null)
{
answer = r.Get(@"User\CurrentUser:\CurrentSession:\" + question.Value + ":");
}
return(answer);
}
private string getGroup(IVertex meta)
{
if (SectionsAsTabs)
{
if (meta == null)
{
return(" | ");
}
string _section = (string)GraphUtil.GetValue(meta.Get("$Section:"));
string _group = (string)GraphUtil.GetValue(meta.Get("$Group:"));
if (_group == null && _section == null)
{
return("");
}
if (_group == null)
{
return("| " + _section);
}
if (_section == null)
{
return(_group);
}
return(_group + " | " + _section);
}
else
{
if (meta == null)
{
return("");
}
string _group = (string)GraphUtil.GetValue(meta.Get("$Group:"));
if (_group == null)
{
return("");
}
else
{
return(_group);
}
}
}
protected override void OnToggle()
{
base.OnToggle();
if (IsNull)
{
IVertex r = MinusZero.Instance.Root;
IVertex from = Vertex.Get(@"BaseEdge:\From:");
IVertex meta = Vertex.Get(@"BaseEdge:\Meta:");
IVertex toMeta = r.Get(@"System\Meta\ZeroTypes\Edge\To");
if (from != null && meta != null)
{
//GraphUtil.ReplaceEdge(Vertex.Get("BaseEdge:"), "To", GraphUtil.SetVertexValue(from, meta, "True")); // NOT
//GraphUtil.SetVertexValue(Vertex.Get("BaseEdge:"), toMeta, GraphUtil.SetVertexValue(from, meta, "True")); // NOT!!!!
GraphUtil.CreateOrReplaceEdge(Vertex.Get("BaseEdge:"), toMeta, GraphUtil.SetVertexValue(from, meta, "True"));
IsNull = false;
}
}
if (Vertex.Get(@"BaseEdge:\To:") != null)
{
if (this.IsChecked == true)
{
Vertex.Get(@"BaseEdge:\To:").Value = "True";
}
else
{
Vertex.Get(@"BaseEdge:\To:").Value = "False";
}
}
}
public NewDiagramItem(IVertex _baseedge, bool isSet, Point mousePos)
{
InitializeComponent();
_mousePosition = mousePos;
baseedge = _baseedge;
IsSet = isSet;
if (IsSet)
{
Remember.Content = "Remember choice, for current set";
}
else
{
Remember.Content = "Remember choice, for current session";
}
BaseEdge = baseedge;
//Owner = m0Main.Instance;
this.Loaded += new RoutedEventHandler(OnLoad);
ItemName.Content = baseedge.Get("To:").Value;
if (!CheckIfThereIChoiceRemembered())
{
BaseEdgeSet();
ShowDialog();
}
}
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;
}
public static IVertex AddInstance(IVertex baseVertex, IVertex metaVertex, IVertex edgeVertex)
{
IVertex nv = baseVertex.AddVertex(edgeVertex, null);
nv.AddEdge(MinusZero.Instance.Root.Get(@"System\Meta\Base\Vertex\$Is"), metaVertex);
///
if (metaVertex.Get("$IsAggregation:") != null)
{
nv.AddVertex(MinusZero.Instance.Root.Get(@"System\Meta\Base\Vertex\$IsAggregation"), MinusZero.Instance.Root.Get(@"System\Meta\Base\$Empty"));
}
///
//IVertex children = metaVertex.GetAll("{$MinCardinality:1}");
IVertex children = metaVertex; // can use VertexOperations.GetChildEdges, but $DefaultValue: should be OK
foreach (IEdge child in children)
{
if (child.To.Get("$DefaultValue:") != null)
{
nv.AddEdge(child.To, child.To.Get("$DefaultValue:"));
}
// else
// nv.AddVertex(child.To, null);
}
return(nv);
}
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 IVertex Query(IVertex baseVertex, IVertex inputVertex)
{
QueryDialog d = new QueryDialog(baseVertex.Get("To:"));
MinusZero.Instance.DefaultShow.ShowContentFloating(d);
return(null);
}
public static void AddIsClassAndAllAttributesAndAssociations(IVertex ObjectVertex, IVertex ClassVertex)
{
IVertex smuv = MinusZero.Instance.Root.Get(@"System\Meta\Base\Vertex");
ObjectVertex.AddEdge(smuv.Get("$Is"), ClassVertex);
AddAllAttributesAndAssociationsVertexes(ObjectVertex);
}
public static string GetStringCardinalities(IVertex baseVertex)
{
string min = GetStringCardinality(baseVertex.Get("$MinCardinality:"));
string max = GetStringCardinality(baseVertex.Get("$MaxCardinality:"));
if (min == "1" && max == "1")
{
return("");
}
if (min == max)
{
return("[" + min + "]");
}
return("[" + min + ".." + max + "]");
}
public static void AddUserChoice(IVertex question, IVertex answer, bool toSession)
{
IVertex r = MinusZero.Instance.Root;
IVertex toAdd;
if (toSession)
{
toAdd = r.Get(@"User\CurrentUser:\CurrentSession:");
}
else
{
toAdd = r.Get(@"User\CurrentUser:\CurrentSession:\Process:");
}
toAdd.AddEdge(question, answer);
}
public static IVertex NewEdge(IVertex baseVertex, IVertex inputVertex)
{
NewEdge d = new NewEdge(baseVertex.Get("To:"));
MinusZero.Instance.DefaultShow.ShowContentFloating(d);
return(null);
}