private void Gviewer_MouseClick(object sender, MouseEventArgs e)
{
if (!(selectedObjectMouseHover?.DrawingObject is Node))
{
return;
}
RestoreSelectedNodeColor();
clickedNode = selectedObjectMouseHover;
(clickedNode.DrawingObject as Node).Attr.Color = Color.Red;
string entityName = (selectedObjectMouseHover.DrawingObject as Node).Attr.Id;
IEnumerable <ERRelation> relations = entityRelations.GetERRelationsForSpecificEntity(entityName);
IEnumerable <EREntityAttribute> attributes = entityRelations.GetEREntitieAttributesByEntityName(entityName);
string description = attributes?.FirstOrDefault <EREntityAttribute>()?.Description;
if (description == null)
{
description = "no entity description (sample data)";
}
StatusText = $"{entityName} - {description}";
if (!entityViewerEnabled)
{
return;
}
PrepareEntityViewer();
entityViewer.ShowEntity(entityName, relations, attributes);
}
private Set <object> GetSetOfAffectedObjs(IViewerObject draggableObj)
{
Set <object> ret = new Set <object>();
ret.Insert(draggableObj);
IViewerNode node = draggableObj as IViewerNode;
if (node != null)
{
foreach (IViewerEdge edge in Edges(node))
{
ret.Insert(edge);
}
}
else
{
IViewerEdge edge = draggableObj as IViewerEdge;
if (edge != null)
{
ret += GetSetOfAffectedObjs(edge.Source);
ret += GetSetOfAffectedObjs(edge.Target);
}
else
{
IViewerObject label = draggableObj as IViewerObject;
if (label != null)
{
ret.Insert(draggableObj);
}
}
}
return(ret);
}
private void AnalyzeLeftMouseButtonClick()
{
bool modifierKeyIsPressed = ModifierKeyIsPressed();
IViewerObject obj = viewer.ObjectUnderMouseCursor;
if (obj != null)
{
IViewerEdge editableEdge = obj as IViewerEdge;
if (editableEdge != null)
{
SwitchToEdgeEditing(editableEdge);
}
else
{
if (obj.MarkedForDragging)
{
UnselectObjectForDragging(obj);
}
else
{
if (!modifierKeyIsPressed)
{
UnselectEverything();
}
SelectObjectForDragging(obj);
}
UnselectEdge();
}
}
}
void AnaylyzeLeftButtonClick(IViewerObject obj)
{
if (obj is DNode dNode)
{
NodeSelected?.Invoke(this, new NodeEventArgs(dNode.DrawingNode, new GeometryPoint(0, 0)));
}
}
private void ResetNodeStyles(IViewerObject obj)
{
bool ctrlPressed = ModifierKeys == Keys.Control;
foreach (IViewerObject viewerObj in gViewer.Entities)
{
if (viewerObj is DNode dNod)
{
if (viewerObj != obj)
{
if (!ctrlPressed)
{
viewerObj.MarkedForDragging = false;
dNod.DrawingNode.Attr.Color = Styles.NODE_LINE_COLOR.ToMsAgl();
gViewer.Invalidate(obj);
}
}
else
{
viewerObj.MarkedForDragging = true;
dNod.DrawingNode.Attr.Color = Styles.SELECTED_NODE_LINE_COLOR.ToMsAgl();
gViewer.Invalidate(viewerObj);
}
if (dNod.DrawingNode.Attr.Color == Styles.SELECTED_NODE_LINE_COLOR.ToMsAgl())
{
viewerObj.MarkedForDragging = true;
}
}
}
}
/// <summary>
/// create a tight bounding box for the graph
/// </summary>
/// <param name="graphToFit"></param>
public void FitGraphBoundingBox(IViewerObject graphToFit)
{
if (graphToFit != null)
{
geomGraphEditor.FitGraphBoundingBox(graphToFit, graphToFit.DrawingObject.GeometryObject as GeometryGraph);
this.viewer.Invalidate();
}
}
private void SelectObjectForDragging(IViewerObject obj)
{
if (obj.MarkedForDragging == false)
{
obj.MarkedForDragging = true;
dragGroup.Insert(obj);
this.DecorateObjectForDragging(obj);
}
}
/// <summary>
/// deletes the polyline corner
/// </summary>
/// <param name="edge"></param>
/// <param name="site"></param>
/// <param name="userData">an object to be stored in the unde action</param>
public void DeleteSite(GeomEdge edge, Site site, IViewerObject userData)
{
EditedEdge = edge;
PrepareForPolylineCornerRemoval(userData, site);
site.Previous.Next = site.Next; //removing the site from the list
site.Next.Previous = site.Previous;
//just to recalc everything in a correct way
DragEdgeWithSite(new Point(0, 0), edge,
site.Previous);
}
public UndoRedoAction PrepareForPolylineCornerRemoval(IViewerObject affectedEdge, Site site)
{
var action = new SiteRemoveUndoAction(EditedEdge)
{
RemovedSite = site,
};
action.AddAffectedObject(affectedEdge);
return(InsertToListAndSetTheBoxBefore(action));
}
/// <summary>
/// prepare for polyline corner insertion
/// </summary>
/// <param name="affectedObj">edited objects</param>
/// <param name="site">the site to insert</param>
/// <returns></returns>
internal UndoRedoAction PrepareForPolylineCornerInsertion(IViewerObject affectedObj, Site site)
{
var action = new SiteInsertUndoAction(EditedEdge)
{
InsertedSite = site,
};
action.AddAffectedObject(affectedObj);
return(InsertToListAndSetTheBoxBefore(action));
}
void RemoveDragDecorator(IViewerObject obj)
{
if (obj is DNode dNode)
{
dNode.DrawingNode.Attr.Color = Styles.NODE_LINE_COLOR.ToMsAgl();
selectedNodeAttr.Color = Styles.NODE_LINE_COLOR.ToMsAgl();
gViewer.Invalidate(obj);
}
NoneSelected?.Invoke(this, EventArgs.Empty);
}
void SetDragDecorator(IViewerObject obj)
{
var dNode = obj as DNode;
if (dNode != null)
{
draggedObjectOriginalColors[dNode] = dNode.DrawingNode.Attr.Color;
dNode.DrawingNode.Attr.Color = Color.Magenta;
gViewer.Invalidate(obj);
}
}
void RemoveDragDecorator(IViewerObject obj)
{
var dNode = obj as DNode;
if (dNode != null)
{
dNode.DrawingNode.Attr.Color = draggedObjectOriginalColors[dNode];
draggedObjectOriginalColors.Remove(obj);
gViewer.Invalidate(obj);
}
}
void SetDragDecorator(IViewerObject obj)
{
ResetNodeStyles(obj);
if (obj is DNode dNode)
{
dNode.DrawingNode.Attr.Color = Styles.SELECTED_NODE_LINE_COLOR.ToMsAgl();
gViewer.Invalidate(obj);
}
AnaylyzeLeftButtonClick(obj);
}
private void getValueFromViewerObject_prev(IViewerObject newObject)
{
var ob = newObject.DrawingObject;
_editingObj = newObject;
var node = ob as Node;
if (node != null)
{
var att = node.Attr;
id_box.Text = att.Id;
label_box.Text = node.LabelText;
_iset_ShapeStyle = true;
//SelectionChanged will not fire when hidden
shapeStyle_cmb.SelectedValue = att.Shape;
_iset_ShapeStyle = false;
nodeAttrGroup.Visibility = Visibility.Visible;
}
else
{
var edge = ob as Edge;
if (edge == null)
{
return;
}
var att = edge.Attr;
id_box.Text = att.Id;
label_box.Text = edge.LabelText;
edgeEditor.SetAttr(att);
edgeEditor.Visibility = Visibility.Visible;
////_iset_edgeDecrate = true;
//_iset_edgeLineStyle = true;
//lineStyle_cmb.SelectedValue = att.FirstStyle;
//_iset_edgeLineStyle = false;
//_iset_edgeDecrate = true;
//decSymbol_cmb.SelectedValue = edge.UserData==null? "": edge.UserData ;
//_iset_edgeDecrate = false;
//_iset_edgeSrcArrow = true;
//srcArrowStyle_cmb.SelectedValue = att.ArrowheadAtSource;
//_iset_edgeSrcArrow = false;
//_iset_edgeDstArrow = true;
//dstArrowStyle_cmb.SelectedValue = att.ArrowheadAtTarget;
//_iset_edgeDstArrow = false;
//edgeAttrGroup.Visibility = Visibility.Visible;
}
}
/// <summary>
/// insert a polyline corner
/// </summary>
/// <param name="edge"></param>
/// <param name="point">the point to insert the corner</param>
/// <param name="siteBeforeInsertion"></param>
/// <param name="affectedEntity">an object to be stored in the undo action</param>
public void InsertSite(GeomEdge edge, Point point, Site siteBeforeInsertion, IViewerObject affectedEntity)
{
EditedEdge = edge;
//creating the new site
Site first = siteBeforeInsertion;
Site second = first.Next;
var s = new Site(first, point, second);
PrepareForPolylineCornerInsertion(affectedEntity, s);
//just to recalc everything in a correct way
DragEdgeWithSite(new Point(0, 0), edge, s);
}
private void GViewer_ObjectUnderMouseCursorChanged(object sender, ObjectUnderMouseCursorChangedEventArgs e)
{
selectedObject = e.OldObject?.DrawingObject;
if (selectedObject != null)
{
RestoreSelectedObjAttr();
gViewer.Invalidate(e.OldObject);
selectedObject = null;
}
IViewerObject objectUnderMouseCursor = gViewer.ObjectUnderMouseCursor;
if (objectUnderMouseCursor == null)
{
gViewer.SetToolTip(toolTip, "");
}
else
{
selectedObject = objectUnderMouseCursor.DrawingObject;
if (selectedObject is Edge edge)
{
selectedObjectAttr = edge.Attr.Clone();
edge.Attr.Color = DrawingColor.Blue;
if (e.NewObject != null)
{
gViewer.Invalidate(e.NewObject);
}
if (edge.UserData is Relationship relationship)
{
gViewer.SetToolTip(toolTip, relationship.Type);
}
}
else if (selectedObject is DrawingNode dNode)
{
selectedNodeAttr = dNode.Attr.Clone();
dNode.Attr.Color = DrawingColor.LimeGreen;
gViewer.SetToolTip(toolTip, "Drag me");
if (e.NewObject != null)
{
gViewer.Invalidate(e.NewObject);
}
}
}
}
void DObject_MouseMove(object sender, MouseEventArgs e)
{
if (e != m_CurrentEvent)
{
m_CurrentEvent = e;
m_LastObjectSet = null;
}
if (m_LastObjectSet == null)
{
DObject obj = this;
if (obj is DLabel && !(obj.ParentObject is DEdge))
obj = obj.ParentObject;
if (obj is DGraph)
obj = null;
m_LastObjectSet = ParentGraph.ObjectUnderMouseCursor = obj;
}
}
private void UpdateHoveredObjects(IViewerObject hoveredObject)
{
// Update hovered node.
var dNode = hoveredObject as DNode;
if (mHoveredDNode != dNode)
{
if (mHoveredDNode != null)
{
SetBranchHighlighted(mHoveredDNode, false);
mHoveredDNode = null;
}
if (dNode != null)
{
GameMasterNode nodeData = GameMasterDataManager.GetInstance().GetGameMasterNode(dNode.DrawingNode.Id);
if (nodeData != null)
{
mHoveredDNode = dNode;
SetBranchHighlighted(mHoveredDNode, true);
}
}
}
// Update hovered edge.
var dEdge = hoveredObject as DEdge;
if (mHoveredDEdge != dEdge)
{
if (mHoveredDEdge != null)
{
mHoveredDEdge.DrawingEdge.Attr.LineWidth -= 2;
graphViewer.Invalidate(mHoveredDEdge);
mHoveredDEdge = null;
graphViewer.SetToolTip(mHoveredEdgeTooltip, "");
}
if (dEdge != null)
{
dEdge.DrawingEdge.Attr.LineWidth += 2;
graphViewer.Invalidate(dEdge);
mHoveredDEdge = dEdge;
graphViewer.SetToolTip(mHoveredEdgeTooltip, mHoveredDEdge.Edge.UserData as string);
}
}
}
// Return the result of the hit test to the callback.
private FrameworkElement GetFrameworkElementFromIViewerObject(IViewerObject viewerObject)
{
FrameworkElement ret;
var vNode = viewerObject as KosmographViewerNode;
if (vNode != null)
{
ret = (FrameworkElement)(vNode.NodeLabel) ?? (FrameworkElement)(vNode.NodeBoundaryPath);
}
else
{
var vLabel = viewerObject as VLabel;
if (vLabel != null)
{
ret = vLabel.FrameworkElement;
}
else
{
var vEdge = viewerObject as KosmographViewerEdge;
if (vEdge != null)
{
ret = vEdge.EdgePath;
}
else
{
throw new InvalidOperationException(
#if DEBUG
"Unexpected object type in GraphViewer"
#endif
);
}
}
}
if (ret == null)
{
throw new InvalidOperationException(
#if DEBUG
"did not find a framework element!"
#endif
);
}
return(ret);
}
private void RestorePreviouslyHoverObjectColor(IViewerObject previousViewerObject)
{
if (previousViewerObject == null)
{
return;
}
DrawingObject previousObject = previousViewerObject.DrawingObject;
if (previousObject is Edge)
{
var edge = previousObject as Edge;
edge.Attr.Color = Color.Black;
}
else if (previousObject is Node)
{
var node = previousObject as Node;
node.Attr.Color = Color.Black;
}
}
private void getValueFromViewerObject(IViewerObject newObject)
{
var objs = _graphViewer.LayoutEditor.dragGroup;
var obj = objs.First();
var vnode = obj as VNode;
if (vnode != null)
{
if (objs.Count() == 1)
{
var att = vnode.Node.Attr;
id_box.Text = att.Id;
label_box.Text = vnode.Node.LabelText;
_iset_ShapeStyle = true;
//SelectionChanged will not fire when hidden
shapeStyle_cmb.SelectedValue = att.Shape;
_iset_ShapeStyle = false;
nodeAttrGroup.Visibility = Visibility.Visible;
}
else
{
_iset_ShapeStyle = true;
shapeStyle_cmb.SelectedIndex = 0;
_iset_ShapeStyle = false;
nodeAttrGroup.Visibility = Visibility.Visible;
}
}
else
{
var vedge = obj as VEdge;
if (vedge == null)
{
return;
}
var att = vedge.Edge.Attr;
id_box.Text = att.Id;
label_box.Text = vedge.Edge.LabelText;
edgeEditor.SetAttr(att);
edgeEditor.Visibility = Visibility.Visible;
}
}
private void viewer_MouseDown(object sender, MsaglMouseEventArgs e)
{
if (e.RightButtonIsPressed)
{
IViewerObject ob = gv.ObjectUnderMouseCursor;
if (ob == null)
{
Microsoft.Msagl.Core.Geometry.Point p = gv.ScreenToSource(e.X, e.Y);
Node n = new Node(this.FindNewId());
IViewerNode iwn = gv.CreateIViewerNode(n, p, true);
gv.AddNode(iwn, true);
gv.ResizeNodeToLabel(n);
}
else if (ob is IViewerNode)
{
IViewerNode existingNode = ob as IViewerNode;
gv.RemoveNode(existingNode, true);
}
}
}
void GViewerObjectUnderMouseCursorChanged(object sender, ObjectUnderMouseCursorChangedEventArgs e)
{
IViewerObject underCursor = gViewer.ObjectUnderMouseCursor;
object sel = underCursor == null ? null : underCursor.DrawingObject;
if (sel is Node)
{
var n = sel as Node;
selection.Text = n.Id;
}
else if (sel is Edge)
{
var edge = sel as Edge;
selection.Text = edge.Source + "->" + edge.Target;
}
else
{
selection.Text = "";
}
}
private void Gviewer_ObjectUnderMouseCursorChanged(object sender, ObjectUnderMouseCursorChangedEventArgs e)
{
RestorePreviouslyHoverObjectColor(e.OldObject);
if (e.OldObject != null)
{
gviewer.Invalidate(e.OldObject);
}
if (gviewer.ObjectUnderMouseCursor == null)
{
gviewer.SetToolTip(viewerToolTip, "");
return;
}
selectedObjectMouseHover = gviewer.ObjectUnderMouseCursor;
DrawingObject currentDrawingObject = selectedObjectMouseHover.DrawingObject;
string selectedObjetLabel = null;
if (currentDrawingObject is Edge)
{
var edge = currentDrawingObject as Edge;
edge.Attr.Color = Color.Blue;
selectedObjetLabel = edge.Attr.Id; // Attr.Id holds the relationship information
}
else if (currentDrawingObject is Node)
{
var node = currentDrawingObject as Node;
node.Attr.Color = Color.Green;
string entityName = node.Attr.Id;
selectedObjetLabel = entityRelations.GetEREntitieAttributesByEntityName(entityName)?.FirstOrDefault <EREntityAttribute>()?.Description;
}
else
{
return;
}
gviewer.SetToolTip(viewerToolTip, selectedObjetLabel);
if (e.NewObject != null)
{
gviewer.Invalidate(e.NewObject);
}
}
void DObject_MouseMove(object sender, MouseEventArgs e)
{
if (e != m_CurrentEvent)
{
m_CurrentEvent = e;
m_LastObjectSet = null;
}
if (m_LastObjectSet == null)
{
DObject obj = this;
if (obj is DLabel && !(obj.ParentObject is DEdge))
{
obj = obj.ParentObject;
}
if (obj is DGraph)
{
obj = null;
}
m_LastObjectSet = ParentGraph.ObjectUnderMouseCursor = obj;
}
}
void GViewerOnMouseMove(object sender, MouseEventArgs mouseEventArgs)
{
if (labelToChange == null)
{
return;
}
labelToChange.Text = MousePosition.ToString();
if (viewerEntityCorrespondingToLabelToChange == null)
{
foreach (var e in gViewer.Entities)
{
if (e.DrawingObject == labelToChange)
{
viewerEntityCorrespondingToLabelToChange = e;
break;
}
}
}
if (viewerEntityCorrespondingToLabelToChange == null)
{
return;
}
var rect = labelToChange.BoundingBox;
var font = new Font(labelToChange.FontName, (int)labelToChange.FontSize);
double width;
double height;
StringMeasure.MeasureWithFont(labelToChange.Text, font, out width, out height);
if (width <= 0)
{
//this is a temporary fix for win7 where Measure fonts return negative lenght for the string " "
StringMeasure.MeasureWithFont("a", font, out width, out height);
}
labelToChange.Width = width;
labelToChange.Height = height;
rect.Add(labelToChange.BoundingBox);
gViewer.Invalidate(gViewer.MapSourceRectangleToScreenRectangle(rect));
}
/// <summary>
/// creates a "tight" bounding box
/// </summary>
/// <param name="affectedEntity">the object corresponding to the graph</param>
/// <param name="geometryGraph"></param>
public void FitGraphBoundingBox(IViewerObject affectedEntity, GeometryGraph geometryGraph)
{
if (geometryGraph != null)
{
var uAction = new UndoRedoAction(geometryGraph)
{
Graph = geometryGraph
};
UndoRedoActionsList.AddAction(uAction);
var r = new Rectangle();
foreach (GeomNode n in geometryGraph.Nodes)
{
r = n.BoundingBox;
break;
}
foreach (GeomNode n in geometryGraph.Nodes)
{
r.Add(n.BoundingBox);
}
foreach (GeomEdge e in geometryGraph.Edges)
{
r.Add(e.BoundingBox);
if (e.Label != null)
{
r.Add(e.Label.BoundingBox);
}
}
r.Left -= geometryGraph.Margins;
r.Top += geometryGraph.Margins;
r.Bottom -= geometryGraph.Margins;
r.Right += geometryGraph.Margins;
uAction.ClearAffectedObjects();
uAction.AddAffectedObject(affectedEntity);
uAction.GraphBoundingBoxAfter = geometryGraph.BoundingBox = r;
}
}
public UndoRedoAction PrepareForPolylineCornerRemoval(IViewerObject affectedEdge, Site site) {
var action = new SiteRemoveUndoAction(EditedEdge) {
RemovedSite = site,
};
action.AddAffectedObject(affectedEdge);
return InsertToListAndSetTheBoxBefore(action);
}
internal void RemoveAffectedObject(IViewerObject o)
{
lock (affectedObjects)
affectedObjects.Remove(o);
}
/// <summary>
/// prepare for polyline corner insertion
/// </summary>
/// <param name="affectedObj">edited objects</param>
/// <param name="site">the site to insert</param>
/// <returns></returns>
internal UndoRedoAction PrepareForPolylineCornerInsertion(IViewerObject affectedObj, Site site) {
var action = new SiteInsertUndoAction(EditedEdge) {
InsertedSite = site,
};
action.AddAffectedObject(affectedObj);
return InsertToListAndSetTheBoxBefore(action);
}
/// <summary>
/// constructor
/// </summary>
/// <param name="oldObject"></param>
/// <param name="newObject"></param>
public ObjectUnderMouseCursorChangedEventArgs(IViewerObject oldObject, IViewerObject newObject) {
OldObject = oldObject;
NewObject = newObject;
}
public void Invalidate(IViewerObject objectToInvalidate) {
((IInvalidatable) objectToInvalidate).Invalidate();
var lgSettings = Graph.LayoutAlgorithmSettings as LgLayoutSettings;
if (lgSettings != null) {
var vnode = objectToInvalidate as GraphmapsNode;
if (vnode != null)
SetNodeAppearence(vnode);
}
}
static void TheDefaultEdgeLabelDecoratorStub(IViewerObject label) {}
void TheDefaultObjectDecoratorRemover(IViewerObject obj) {
VoidDelegate decoratorRemover;
if (decoratorRemovalsDict.TryGetValue(obj, out decoratorRemover)) {
decoratorRemover();
decoratorRemovalsDict.Remove(obj);
viewer.Invalidate(obj);
}
var node=obj as IViewerNode;
if (node != null)
foreach (var edge in Edges(node))
RemoveObjDraggingDecorations(edge);
}
internal bool ContainsAffectedObject(IViewerObject o)
{
return affectedObjects.Contains(o);
}
/// <summary>
/// deletes the polyline corner
/// </summary>
/// <param name="edge"></param>
/// <param name="site"></param>
/// <param name="userData">an object to be stored in the unde action</param>
public void DeleteSite(GeomEdge edge, Site site, IViewerObject userData) {
EditedEdge = edge;
PrepareForPolylineCornerRemoval(userData, site);
site.Previous.Next = site.Next; //removing the site from the list
site.Next.Previous = site.Previous;
//just to recalc everything in a correct way
DragEdgeWithSite(new Point(0, 0), edge,
site.Previous);
}
/// <summary>
///
/// </summary>
/// <param name="viewerObject"></param>
public void AttachLayoutChangeEvent(IViewerObject viewerObject) {
var dre = viewerObject.DrawingObject;
if (dre != null) {
var geom = dre.GeometryObject;
if (geom != null)
geom.BeforeLayoutChangeEvent += (a, b) => ReportBeforeChange(viewerObject);
var cluster = geom as Cluster;
if (cluster != null) {
var iViewerNode =(IViewerNode) viewerObject;
iViewerNode.IsCollapsedChanged += RelayoutOnIsCollapsedChanged;
}
dre.IsVisibleChanged += a => ReportBeforeChange(viewerObject);
}
}
/// <summary>
/// create a tight bounding box for the graph
/// </summary>
/// <param name="graphToFit"></param>
public void FitGraphBoundingBox(IViewerObject graphToFit) {
if (graphToFit != null) {
geomGraphEditor.FitGraphBoundingBox(graphToFit, graphToFit.DrawingObject.GeometryObject as GeometryGraph);
viewer.Invalidate();
}
}
internal void AddAffectedObject(IViewerObject o) {
lock(affectedObjects)
affectedObjects.Insert(o);
}
/// <summary>
/// creates a "tight" bounding box
/// </summary>
/// <param name="affectedEntity">the object corresponding to the graph</param>
/// <param name="geometryGraph"></param>
public void FitGraphBoundingBox(IViewerObject affectedEntity, GeometryGraph geometryGraph) {
if (geometryGraph != null) {
var uAction = new UndoRedoAction(geometryGraph) {Graph = geometryGraph};
UndoRedoActionsList.AddAction(uAction);
var r = new Rectangle();
foreach (GeomNode n in geometryGraph.Nodes) {
r = n.BoundingBox;
break;
}
foreach (GeomNode n in geometryGraph.Nodes) {
r.Add(n.BoundingBox);
}
foreach (GeomEdge e in geometryGraph.Edges) {
r.Add(e.BoundingBox);
if (e.Label != null)
r.Add(e.Label.BoundingBox);
}
r.Left -= geometryGraph.Margins;
r.Top += geometryGraph.Margins;
r.Bottom -= geometryGraph.Margins;
r.Right += geometryGraph.Margins;
uAction.ClearAffectedObjects();
uAction.AddAffectedObject(affectedEntity);
uAction.GraphBoundingBoxAfter = geometryGraph.BoundingBox = r;
}
}
void SelectObjectForDragging(IViewerObject obj) {
if (obj.MarkedForDragging == false) {
obj.MarkedForDragging = true;
dragGroup.Insert(obj);
DecorateObjectForDragging(obj);
}
}
public void Invalidate(IViewerObject objectToInvalidate)
{
((IInvalidatable)objectToInvalidate).Invalidate(ZoomFactor * FitFactor);
}
void UnselectObjectForDragging(IViewerObject obj) {
UnselectWithoutRemovingFromDragGroup(obj);
dragGroup.Remove(obj);
}
/// <summary>
/// insert a polyline corner
/// </summary>
/// <param name="edge"></param>
/// <param name="point">the point to insert the corner</param>
/// <param name="siteBeforeInsertion"></param>
/// <param name="affectedEntity">an object to be stored in the undo action</param>
public void InsertSite(GeomEdge edge, Point point, Site siteBeforeInsertion, IViewerObject affectedEntity) {
EditedEdge = edge;
//creating the new site
Site first = siteBeforeInsertion;
Site second = first.Next;
var s = new Site(first, point, second);
PrepareForPolylineCornerInsertion(affectedEntity, s);
//just to recalc everything in a correct way
DragEdgeWithSite(new Point(0, 0), edge, s);
}
void UnselectWithoutRemovingFromDragGroup(IViewerObject obj) {
obj.MarkedForDragging = false;
RemoveObjDraggingDecorations(obj);
}
internal void AddAffectedObject(IViewerObject o)
{
lock (affectedObjects)
affectedObjects.Insert(o);
}
static Cluster GetActiveObjectCluster(IViewerObject viewerObject) {
var node = viewerObject.DrawingObject.GeometryObject as GeometryNode;
return node != null ? node.ClusterParents.FirstOrDefault() : null;
}
/// <summary>
/// constructor
/// </summary>
/// <param name="lastObject"></param>
/// <param name="newObject"></param>
public ObjectUnderPointerChangedEventArgs(IViewerObject lastObject, IViewerObject newObject)
{
LastObject = lastObject;
NewObject = newObject;
}
protected void DecorateObjectForDragging(IViewerObject obj)
{
if (m_DecoratorRemovalsDict.ContainsKey(obj))
return;
InvalidateBeforeTheChange(obj);
var node = obj as DNode;
if (node != null)
{
var w = node.LineWidth;
m_DecoratorRemovalsDict[node] = (delegate() { node.LineWidth = w; });
node.LineWidth = (int)Math.Max(LineThicknessForEditing, w * 2);
}
else
{
var edge = obj as DEdge;
if (edge != null)
{
var w = edge.LineWidth;
m_DecoratorRemovalsDict[edge] = (delegate() { edge.LineWidth = w; });
edge.LineWidth = (int)Math.Max(LineThicknessForEditing, w * 2);
}
}
Invalidate(obj);
}
public void Invalidate(IViewerObject objectToInvalidate) {
((IInvalidatable) objectToInvalidate).Invalidate();
}
protected void RemoveObjDraggingDecorations(IViewerObject obj)
{
InvalidateBeforeTheChange(obj);
Action decoratorRemover;
if (m_DecoratorRemovalsDict.TryGetValue(obj, out decoratorRemover))
{
decoratorRemover();
m_DecoratorRemovalsDict.Remove(obj);
Invalidate(obj);
}
var node = obj as DNode;
if (node != null)
foreach (var edge in node.Edges)
RemoveObjDraggingDecorations(edge);
}
FrameworkElement GetFrameworkElementFromIViewerObject(IViewerObject viewerObject) {
FrameworkElement ret;
var vNode = viewerObject as VNode;
if (vNode != null) ret = vNode.FrameworkElementOfNodeForLabel ?? vNode.BoundaryPath;
else {
var vLabel = viewerObject as VLabel;
if (vLabel != null) ret = vLabel.FrameworkElement;
else {
var vEdge = viewerObject as VEdge;
if (vEdge != null) ret = vEdge.CurvePath;
else {
throw new InvalidOperationException(
#if DEBUG
"Unexpected object type in GraphViewer"
#endif
);
}
}
}
if (ret == null)
throw new InvalidOperationException(
#if DEBUG
"did not find a framework element!"
#endif
);
return ret;
}
public void Invalidate(IViewerObject editObj)
{
if (editObj is DObject)
{
(editObj as DObject).MakeVisual();
if (editObj is IHavingDLabel && (editObj as IHavingDLabel).Label != null)
(editObj as IHavingDLabel).Label.MakeVisual();
}
//PopulateChildren();
//SetRenderTransform();
}
internal void RemoveAffectedObject(IViewerObject o)
{
lock(affectedObjects)
affectedObjects.Remove(o);
}
public void InvalidateBeforeTheChange(IViewerObject editObj)
{
Invalidate(editObj);
}
/*
bool IsUnderCluster(GeometryNode node, Cluster cluster) {
foreach(var parent in node.AllClusterAncestors)
if (parent == cluster) return true;
return false;
}
*/
void ReportBeforeChange(IViewerObject viewerObject) {
if (CurrentUndoAction==null || CurrentUndoAction.ContainsAffectedObject(viewerObject)) return;
CurrentUndoAction.AddAffectedObject(viewerObject);
CurrentUndoAction.AddRestoreData(viewerObject.DrawingObject.GeometryObject,
RestoreHelper.GetRestoreData(viewerObject.DrawingObject.GeometryObject));
}
/// <summary>
/// Forces redraw of objectToInvalidate
/// </summary>
/// <param name="objectToInvalidate"></param>
public void Invalidate(IViewerObject objectToInvalidate)
{
var dObject = (DObject) objectToInvalidate;
dObject.Invalidate();
ClearBoundingBoxHierarchy();
Core.Geometry.Rectangle box = dObject.RenderedBox; //copying aside he previous rendering box
dObject.UpdateRenderedBox();
box.Add(dObject.RenderedBox);
//this is now the box to invalidate; to erase the old object and to render the new one
panel.Invalidate(MapSourceRectangleToScreenRectangle(box));
}
void TheDefaultObjectDecorator(IViewerObject obj) {
var node = obj as IViewerNode;
if (node != null) {
var drawingNode = node.Node;
var w = drawingNode.Attr.LineWidth;
decoratorRemovalsDict[node] = (() => drawingNode.Attr.LineWidth = w);
drawingNode.Attr.LineWidth = (int) Math.Max(viewer.LineThicknessForEditing, w*2);
} else {
var edge = obj as IViewerEdge;
if (edge != null) {
var drawingEdge = edge.Edge;
var w = drawingEdge.Attr.LineWidth;
decoratorRemovalsDict[edge] = (() => drawingEdge.Attr.LineWidth = w);
drawingEdge.Attr.LineWidth = (int) Math.Max(viewer.LineThicknessForEditing, w*2);
}
}
viewer.Invalidate(obj);
}
void SetDragDecorator(IViewerObject obj)
{
var dNode = obj as DNode;
if (dNode != null) {
draggedObjectOriginalColors[dNode] = dNode.DrawingNode.Attr.Color;
dNode.DrawingNode.Attr.Color = Color.Magenta;
gViewer.Invalidate(obj);
}
}
