internal void AddRail(Rail rail)
{
if (AddRailToDictionary(rail))
{
AddRailToRtree(rail);
}
}
internal void PutOffEdgesPassingThroughTheRail(Rail rail)
{
var railLevel = levels[(int)Math.Log(rail.ZoomLevel, 2)];
var passingEdges = railLevel.GetEdgesPassingThroughRail(rail);
PutOffEdges(passingEdges);
}
public object GetNodeOrRailUnderMouse(RectangleGeometry rect) {
_nodeUnderMouse = null;
_railUnderMouse = null;
VisualTreeHelper.HitTest(_graphCanvas, null,
NodeOrRailHitTestSelOnlyOneNodeCallback,
new GeometryHitTestParameters(rect));
return (object)_nodeUnderMouse ?? _railUnderMouse;
}
HitTestResultBehavior RailHitTestSelOneResultCallback(HitTestResult result) {
var frameworkElement = result.VisualHit as FrameworkElement;
if (frameworkElement == null || !(frameworkElement.Tag is Rail))
return HitTestResultBehavior.Continue;
_railUnderMouse = frameworkElement.Tag as Rail;
return HitTestResultBehavior.Stop;
}
/*
* void HiglightEdge(Edge edge) {
* Set<Rail> railsOfEdge = null;
* //adding highlight for edge rails in each level
* for (int i = levels.Count - 1; i >= 0; i--) {
* var level = levels[i];
*
* Set<Rail> railsOfEdgeOfLevelWithHigherZoom;
* if (level._railsOfEdges.TryGetValue(edge, out railsOfEdgeOfLevelWithHigherZoom)) {
* railsOfEdge = railsOfEdgeOfLevelWithHigherZoom;
* }
* else {
* //the edge is not represented at the level, so we are reusing the rails from the level above
* level._railsOfEdges[edge] = railsOfEdge;
* foreach (var rail1 in railsOfEdge)
* AddRailToRailTreeOfLowerLevel(rail1, level);
* }
* foreach (var rail1 in railsOfEdge) //highlight every rail: does not matter new or old
* rail1.HiglightCount ++;
* }
* }
*/
static void AddRailToRailTreeOfLowerLevel(Rail rail, LgLevel lowerLevel)
{
var pt = rail.PointTuple();
var box = new Rectangle(pt.Item1, pt.Item2);
if (!lowerLevel._railTree.Contains(box, rail))
{
lowerLevel._railTree.Add(box, rail);
}
}
/// <summary>
/// records the fact that the edge passes through the rail
/// </summary>
/// <param name="edge"></param>
/// <param name="rail"></param>
public void AssociateEdgeAndRail(Edge edge, Rail rail)
{
Set <Rail> railSet;
if (!_railsOfEdges.TryGetValue(edge, out railSet))
{
_railsOfEdges[edge] = railSet = new Set <Rail>();
}
railSet.Insert(rail);
}
public void RemoveRailFromDictionary(Rail rail)
{
Point p0, p1;
if (!rail.GetStartEnd(out p0, out p1))
{
return;
}
_railDictionary.Remove(new SymmetricSegment(p0, p1));
}
public void AddRailToRtree(Rail rail)
{
Point p0, p1;
if (!rail.GetStartEnd(out p0, out p1))
{
return;
}
if (_railTree.Contains(new Rectangle(p0, p1), rail))
{
return;
}
_railTree.Add(new Rectangle(p0, p1), rail);
}
void CreateStatisticsForRail(Rail rail)
{
var arrowhead = rail.Geometry as Arrowhead;
if (arrowhead != null)
{
CreateStatisticsForArrowhead(arrowhead);
}
else
{
foreach (var t in GetCurveTiles(rail.Geometry as ICurve))
{
t.rails++;
}
}
}
public Rail CreateRail(Point ep0, Point ep1)
{
var st = new SymmetricSegment(ep0, ep1);
Rail rail;
if (RailDictionary.TryGetValue(st, out rail))
{
return(rail);
}
var ls = new LineSegment(ep0, ep1);
rail = new Rail(ls, ZoomLevel);
RailTree.Add(rail.BoundingBox, rail);
RailDictionary.Add(st, rail);
return(rail);
}
/// <summary>
/// try adding single rail to dictionary
/// </summary>
/// <param name="rail"></param>
/// <returns>true iff the rail does not belong to _railDictionary</returns>
public bool AddRailToDictionary(Rail rail)
{
Point p0, p1;
if (!rail.GetStartEnd(out p0, out p1))
{
return(false);
}
var st = new SymmetricSegment(p0, p1);
if (!_railDictionary.ContainsKey(st))
{
_railDictionary.Add(st, rail);
return(true);
}
return(false);
}
void RegisterElementaryRail(LgEdgeInfo edgeInfo, ICurve seg)
{
Rail rail;
var tuple = new Tuple <Point, Point>(seg.Start, seg.End);
//was the seg registered before?
if (_railDictionary.TryGetValue(tuple, out rail))
{
if (rail.TopRankedEdgeInfoOfTheRail.Rank < edgeInfo.Rank) //newcoming edgeInfo is more important
{
rail.TopRankedEdgeInfoOfTheRail = edgeInfo;
}
}
else
{
_railDictionary[tuple] = new Rail(seg, edgeInfo, ZoomLevel);
}
}
void RegisterRailsForArrowheads(LgEdgeInfo edgeInfo)
{
var edgeGeom = edgeInfo.Edge.EdgeGeometry;
if (edgeGeom.SourceArrowhead != null)
{
var tuple = new Tuple <Point, Point>(edgeGeom.SourceArrowhead.TipPosition, edgeGeom.Curve.Start);
Rail rail;
if (_railDictionary.TryGetValue(tuple, out rail))
{
if (rail.TopRankedEdgeInfoOfTheRail.Rank < edgeInfo.Rank) //the newcoming edgeInfo is more important
{
rail.TopRankedEdgeInfoOfTheRail = edgeInfo;
}
}
else
{
_railDictionary[tuple] = new Rail(edgeGeom.SourceArrowhead, edgeGeom.Curve.Start, edgeInfo,
ZoomLevel);
}
}
if (edgeGeom.TargetArrowhead != null)
{
var tuple = new Tuple <Point, Point>(edgeGeom.TargetArrowhead.TipPosition, edgeGeom.Curve.End);
Rail rail;
if (_railDictionary.TryGetValue(tuple, out rail))
{
if (rail.TopRankedEdgeInfoOfTheRail.Rank < edgeInfo.Rank) //the newcoming edgeInfo is more important
{
_railDictionary[tuple] = new Rail(edgeGeom.TargetArrowhead, edgeGeom.Curve.End, edgeInfo,
ZoomLevel);
}
}
else
{
_railDictionary[tuple] = new Rail(edgeGeom.TargetArrowhead, edgeGeom.Curve.End, edgeInfo,
ZoomLevel);
}
}
}
HitTestResultBehavior NodeOrRailHitTestSelOnlyOneNodeCallback(HitTestResult result) {
var frameworkElement = result.VisualHit as FrameworkElement;
if (!(frameworkElement is Path))
return HitTestResultBehavior.Continue;
object tag = frameworkElement.Tag;
if (tag != null) {
GraphmapsNode graphmapsNode = tag as GraphmapsNode;
if (graphmapsNode != null) {
_nodeUnderMouse = graphmapsNode;
return HitTestResultBehavior.Stop;
}
else {
var rail = frameworkElement.Tag as Rail;
if (rail != null)
_railUnderMouse = rail;
}
}
return HitTestResultBehavior.Continue;
}
public Rail RemoveRailFromRtree(Rail rail) {
return _railTree.Remove(rail.BoundingBox, rail);
}
internal void AddRail(Rail rail) {
if (AddRailToDictionary(rail))
AddRailToRtree(rail);
}
public FrameworkElement CreateFrameworkElementForRailArrowhead(Rail rail, Arrowhead arrowhead, Point curveAttachmentPoint, byte edgeTransparency) {
var streamGeometry = new StreamGeometry();
using (StreamGeometryContext context = streamGeometry.Open()) {
AddArrow(context, curveAttachmentPoint, arrowhead.TipPosition,
PathStrokeThickness);
//arrowhead.BasePoint = curveAttachmentPoint;
}
var path=new Path
{
Data = streamGeometry,
Tag = this
};
SetPathStrokeToRailPath(rail, path);
return path;
}
/// <summary>
///
/// </summary>
/// <param name="rail"></param>
internal void HighlightEdgesPassingThroughTheRail(Rail rail)
{
lgData.HighlightEdgesPassingThroughRail(rail);
}
Brush SetStrokeColorForRail(Rail rail)
{
// road colors: Brushes.PaleVioletRed; Brushes.PaleGoldenrod; Brushes.White;
WpfColor brush;
//brush = rail.IsHighlighted == false
// ? new SolidColorBrush(new System.Windows.Media.Color {
// A = 255, //transparency,
// R = Edge.Attr.Color.R,
// G = Edge.Attr.Color.G,
// B = Edge.Attr.Color.B
// })
// : Brushes.Red;
brush = rail.IsHighlighted ? Brushes.Red.Color : Brushes.SlateGray.Color;
if (rail.TopRankedEdgeInfoOfTheRail == null) return new SolidColorBrush(brush);
if (lgSettings != null)
{
var col = lgSettings.GetColorForZoomLevel(rail.MinPassingEdgeZoomLevel);
brush = ((SolidColorBrush)(new BrushConverter().ConvertFrom(col))).Color;
}
else
{
if (rail.MinPassingEdgeZoomLevel <= 1) brush = Brushes.LightSkyBlue.Color; //Brushes.DimGray.Color;
else if (rail.MinPassingEdgeZoomLevel <= 2)
brush = Brushes.LightGoldenrodYellow.Color; //Brushes.SlateGray.Color;
else brush = Brushes.WhiteSmoke.Color; //Brushes.Gray.Color;
}
if (rail.IsHighlighted)
{
if (rail.MinPassingEdgeZoomLevel <= 1) brush = Brushes.Red.Color;
else if (rail.MinPassingEdgeZoomLevel <= 2) brush = new WpfColor{A = 255, R=235, G=48, B=68};
else brush = new WpfColor { A = 255, R = 229, G = 92, B = 127 };
}
return new SolidColorBrush(brush);
}
void UpdateRailZindex(FrameworkElement fe, Rail rail) {
var railZindex = 50 - (int) Math.Log(rail.MinPassingEdgeZoomLevel, 2);
if (rail.IsHighlighted)
railZindex += 50;
Panel.SetZIndex(fe, railZindex);
//if (rail.IsHighlighted)
//{
// Panel.SetZIndex(fe, 100);
//}
//else
//{
// Panel.SetZIndex(fe, 50);
//}
}
void CreateFrameworkElementForSkeletonRail(Rail rail) {
var iCurve = rail.Geometry as ICurve;
if (iCurve == null) return;
var path = new Path
{
Data = GraphmapsEdge.GetICurveWpfGeometry(iCurve),
};
InvalidateSkeletonRail(rail, path);
path.Tag = rail;
GraphCanvasChildrenAdd(path);
_visibleRailsToFrameworkElems[rail] = path;
}
/// <summary>
///
/// </summary>
/// <param name="rail"></param>
public void PutOffEdgesPassingThroughTheRail(Rail rail)
{
Algorithm.PutOffEdgesPassingThroughTheRail(rail);
}
internal bool TheRailLevelIsTooHigh(Rail rail)
{
return(lgData.GetRelevantEdgeLevel(rail.ZoomLevel) > lgData.GetRelevantEdgeLevel(GetZoomFactorToTheGraph()));
}
public Rail RemoveRailFromRtree(Rail rail)
{
return(_railTree.Remove(rail.BoundingBox, rail));
}
internal List <Edge> GetEdgesPassingThroughRail(Rail rail)
{
return((from kv in _railsOfEdges where kv.Value.Contains(rail) select kv.Key).ToList());
}
internal void PutOffEdgesPassingThroughTheRail(Rail rail)
{
lgData.PutOffEdgesPassingThroughTheRail(rail);
}
void CreateOrInvalidateFrameworksElementForVisibleRailWithoutChangingGeometry(Rail rail) {
FrameworkElement fe;
GraphmapsEdge vEdgeOfRail = GetVEdgeOfRail(rail);
if (vEdgeOfRail == null) {
CreateOrInvalidateFrameworkElementForSkeletonRail(rail);
return; // skeleton rails
}
if (_visibleRailsToFrameworkElems.TryGetValue(rail, out fe)) {
// added
fe.Visibility = Visibility.Visible;
vEdgeOfRail.Invalidate(fe, rail);
// added
UpdateRailZindex(fe, rail);
}
else {
fe = vEdgeOfRail.CreateFrameworkElementForRail(rail);
GraphCanvasChildrenAdd(fe);
_visibleRailsToFrameworkElems[rail] = fe;
// added
UpdateRailZindex(fe, rail);
}
}
GraphmapsEdge GetVEdgeOfRail(Rail rail) {
if (rail.TopRankedEdgeInfoOfTheRail == null) return null; // skeleton edge
var dEdge = (DrawingEdge) rail.TopRankedEdgeInfoOfTheRail.Edge.UserData;
IViewerObject vEdge;
if (_drawingObjectsToIViewerObjects.TryGetValue(dEdge, out vEdge))
return (GraphmapsEdge) vEdge;
return null;
}
void CreateOrInvalidateFrameworkElementForSkeletonRail(Rail rail) {
FrameworkElement fe;
if (_visibleRailsToFrameworkElems.TryGetValue(rail, out fe)) {
var path = fe as Path;
if (path == null) return;
InvalidateSkeletonRail(rail, path);
fe.Visibility = Visibility.Visible;
}
else {
CreateFrameworkElementForSkeletonRail(rail);
}
}
void HandleDoubleClickForRail(Rail rail) {
if (SelectedNodeInfos.Any()) {
_lgLayoutSettings.Interactor.SelectTopEdgePassingThroughRailWithEndpoint(rail, SelectedNodeInfos);
}
else if (rail.IsHighlighted) {}
//PutOffEdgesPassingThroughTheRail(rail);
//SelectAllRailsOfEdgesPassingThroughRail(rail, false);
else
//HighlightAllEdgesPassingThroughTheRail(rail);
//SelectAllRailsOfEdgesPassingThroughRail(rail, true);
{
if (rail.TopRankedEdgeInfoOfTheRail != null) {
_lgLayoutSettings.Interactor.SelectEdge(rail.TopRankedEdgeInfoOfTheRail);
}
}
ViewChangeEvent(null, null);
}
void InvalidateSkeletonRail(Rail rail, Path path) {
path.StrokeThickness = rail.IsUsedOnPreviousLevel ? 2*GetBorderPathThickness() : GetBorderPathThickness();
path.Stroke = (rail.IsHighlighted
? Brushes.Red
: (rail.IsUsedOnPreviousLevel ? Brushes.SeaGreen : Brushes.Blue));
UpdateRailZindex(path, rail);
}
internal void Invalidate(FrameworkElement fe, Rail rail) {
var path = fe as Path;
if (path != null)
SetPathStrokeToRailPath(rail, path);
}
void RemoveRail(Rail rail) {
_graphCanvas.Children.Remove(_visibleRailsToFrameworkElems[rail]);
_visibleRailsToFrameworkElems.Remove(rail);
}
public void RemoveRailFromDictionary(Rail rail) {
Point p0, p1;
if (!rail.GetStartEnd(out p0, out p1)) return;
_railDictionary.Remove(new SymmetricSegment(p0, p1));
}
void SetRailSelection(Rail rail, bool selected) {
if (selected) {
_selectedRails.Insert(rail);
}
else {
_selectedRails.Remove(rail);
}
rail.IsHighlighted = selected;
}
/*
void HiglightEdge(Edge edge) {
Set<Rail> railsOfEdge = null;
//adding highlight for edge rails in each level
for (int i = levels.Count - 1; i >= 0; i--) {
var level = levels[i];
Set<Rail> railsOfEdgeOfLevelWithHigherZoom;
if (level._railsOfEdges.TryGetValue(edge, out railsOfEdgeOfLevelWithHigherZoom)) {
railsOfEdge = railsOfEdgeOfLevelWithHigherZoom;
}
else {
//the edge is not represented at the level, so we are reusing the rails from the level above
level._railsOfEdges[edge] = railsOfEdge;
foreach (var rail1 in railsOfEdge)
AddRailToRailTreeOfLowerLevel(rail1, level);
}
foreach (var rail1 in railsOfEdge) //highlight every rail: does not matter new or old
rail1.HiglightCount ++;
}
}
*/
static void AddRailToRailTreeOfLowerLevel(Rail rail, LgLevel lowerLevel) {
var pt = rail.PointTuple();
var box = new Rectangle(pt.Item1, pt.Item2);
if (!lowerLevel._railTree.Contains(box, rail))
lowerLevel._railTree.Add(box, rail);
}
public void SetPathStrokeToRailPath(Rail rail, Path path) {
path.Stroke = SetStrokeColorForRail(rail);
double thickness = 1.0;
if (rail.TopRankedEdgeInfoOfTheRail != null)
{
thickness = Math.Max(5 - Math.Log(rail.MinPassingEdgeZoomLevel, 2), 1);
}
path.StrokeThickness = thickness * PathStrokeThickness / 2; // todo : figure out a way to do it nicer than dividing by 2
foreach (var style in Edge.Attr.Styles) {
if (style == Drawing.Style.Dotted) {
path.StrokeDashArray = new DoubleCollection {1, 1};
} else if (style == Drawing.Style.Dashed) {
var f = DashSize();
path.StrokeDashArray = new DoubleCollection {f, f};
//CurvePath.StrokeDashOffset = f;
}
}
}
public void AddRailToRtree(Rail rail) {
Point p0, p1;
if (!rail.GetStartEnd(out p0, out p1)) return;
if (_railTree.Contains(new Rectangle(p0, p1), rail))
return;
_railTree.Add(new Rectangle(p0, p1), rail);
}
public FrameworkElement CreateFrameworkElementForRail(Rail rail) {
var iCurve = rail.Geometry as ICurve;
Path fe = null;
if (iCurve != null) {
fe = (Path)CreateFrameworkElementForRailCurve(rail, iCurve);
// test: rounded ends
fe.StrokeEndLineCap = PenLineCap.Round;
fe.StrokeStartLineCap = PenLineCap.Round;
fe.Tag = rail;
}
return fe;
}
void WriteRail(Rail rail, int railId) {
WriteStartElement(GeometryToken.Rail);
WriteAttribute(GeometryToken.Id, railId);
WriteAttribute(GeometryToken.Zoomlevel, rail.ZoomLevel);
if (rail.MinPassingEdgeZoomLevel != Double.MaxValue)
WriteAttribute(GeometryToken.MinPassingEdgeZoomLevel, rail.MinPassingEdgeZoomLevel);
Arrowhead ah = rail.Geometry as Arrowhead;
if (ah != null) {
WriteStartElement(GeometryToken.Arrowhead);
WriteAttribute(GeometryToken.ArrowheadPosition, ah.TipPosition);
WriteAttribute(GeometryToken.CurveAttachmentPoint, rail.CurveAttachmentPoint);
WriteEndElement();
}
else {
ICurve curve = rail.Geometry as ICurve;
if (curve != null)
WriteICurve(curve);
else
throw new InvalidOperationException();
}
WriteEndElement();
}
FrameworkElement CreateFrameworkElementForRailCurve(Rail rail, ICurve iCurve) {
var path = new Path
{
Data = GetICurveWpfGeometry(iCurve),
};
SetPathStrokeToRailPath(rail, path);
return path;
}
/// <summary>
/// try adding single rail to dictionary
/// </summary>
/// <param name="rail"></param>
/// <returns>true iff the rail does not belong to _railDictionary</returns>
public bool AddRailToDictionary(Rail rail) {
Point p0, p1;
if (!rail.GetStartEnd(out p0, out p1)) return false;
var st = new SymmetricSegment(p0, p1);
if (!_railDictionary.ContainsKey(st)) {
_railDictionary.Add(st, rail);
return true;
}
return false;
}
internal void PutOffEdgesPassingThroughTheRail(Rail rail) {
var railLevel = _levels[(int)Math.Log(rail.ZoomLevel, 2)];
var passingEdges = railLevel.GetEdgesPassingThroughRail(rail);
UnselectEdges(passingEdges);
}
void CreateStatisticsForRail(Rail rail) {
var arrowhead = rail.Geometry as Arrowhead;
if (arrowhead != null)
CreateStatisticsForArrowhead(arrowhead);
else
foreach (var t in GetCurveTiles(rail.Geometry as ICurve))
t.rails++;
}
public Rail GetOneRailInsideRect(RectangleGeometry rect) {
_railUnderMouse = null;
VisualTreeHelper.HitTest(_graphCanvas, null,
RailHitTestSelOneResultCallback,
new GeometryHitTestParameters(rect));
return _railUnderMouse;
}
static bool RailBelongsToLevel(LgLevel level, Rail rail) {
return level.ZoomLevel >= rail.ZoomLevel;
}
/// <summary>
///
/// </summary>
/// <param name="rail"></param>
public void HighlightEdgesPassingThroughTheRail(Rail rail)
{
Algorithm.HighlightEdgesPassingThroughTheRail(rail);
}
/// <summary>
///
/// </summary>
/// <param name="rail"></param>
/// <returns></returns>
public bool TheRailLevelIsTooHigh(Rail rail)
{
return(Algorithm.TheRailLevelIsTooHigh(rail));
}
static bool RailBelongsToLevel(LgLevel level, Rail rail)
{
return(level.ZoomLevel >= rail.ZoomLevel);
}
internal List<Edge> GetEdgesPassingThroughRail(Rail rail) {
return (from kv in _railsOfEdges where kv.Value.Contains(rail) select kv.Key).ToList();
}
