/// <summary>
/// Draw the layer.
/// </summary>
/// <param name="renderTime">Time since last render.</param>
/// <remarks>include base.Render(renderTime); in overloads to preserve updating RenderTime field.</remarks>
public override void Render(RenderTime renderTime)
{
base.Render(renderTime);
if (MM_Repository.OverallDisplay.MapTiles == MM_MapTile.enumMapType.None)
{
return;
}
var tx = Surface.RenderTarget2D.Transform;
Surface.RenderTarget2D.Transform = SharpDX.Matrix3x2.Identity;
BaseMapTileProxy backgroundTile;
Point topLeftTile = MM_Coordinates.XYToTile(Surface.Coordinates.TopLeftXY);
Point bottomRightTile = MM_Coordinates.XYToTile(Surface.Coordinates.BottomRightXY);
Point topLeftTileShift = new Point(Surface.Coordinates.TopLeftXY.X % MM_Repository.OverallDisplay.MapTileSize.Width, Surface.Coordinates.TopLeftXY.Y % MM_Repository.OverallDisplay.MapTileSize.Height);
int extraRadius = 4;
SharpDX.RectangleF tileSourceRect = new SharpDX.RectangleF(0, 0, MM_Repository.OverallDisplay.MapTileSize.Width, MM_Repository.OverallDisplay.MapTileSize.Height);
if (MM_Repository.OverallDisplay.MapTiles != MM_MapTile.enumMapType.None)
{
int startX = topLeftTile.X - extraRadius;
int endX = bottomRightTile.X + extraRadius;
int startY = topLeftTile.Y - extraRadius;
int endY = bottomRightTile.Y + extraRadius;
foreach (var thisTile in Spiral(topLeftTile, bottomRightTile, extraRadius))
{
TileCoordinates tileCoord = new TileCoordinates(MM_Repository.OverallDisplay.MapTiles, thisTile, (int)Surface.Coordinates.ZoomLevel);
if (TryGetTile(tileCoord, out backgroundTile))
{
if (!backgroundTile.IsReady)
{
continue;
}
var targetRect = new SharpDX.RectangleF(((thisTile.X - topLeftTile.X) * MM_Repository.OverallDisplay.MapTileSize.Width) - topLeftTileShift.X, ((thisTile.Y - topLeftTile.Y) * MM_Repository.OverallDisplay.MapTileSize.Height) - topLeftTileShift.Y, MM_Repository.OverallDisplay.MapTileSize.Width, MM_Repository.OverallDisplay.MapTileSize.Height);
Surface.RenderTarget2D.DrawBitmap(backgroundTile.Bitmap, targetRect, MM_Repository.OverallDisplay.MapTransparency, BitmapInterpolationMode.NearestNeighbor, tileSourceRect);
}
}
//for (Point thisTile = new Point(topLeftTile.X - extraRadius, topLeftTile.Y - extraRadius); thisTile.X <= bottomRightTile.X + extraRadius; thisTile.X++, thisTile.Y = topLeftTile.Y)
//{
// for (; thisTile.Y <= bottomRightTile.Y + extraRadius; thisTile.Y++)
// {
// TileCoordinates tileCoord = new TileCoordinates(MM_Repository.OverallDisplay.MapTiles, thisTile, (int)Surface.Coordinates.ZoomLevel);
// if (TryGetTile(tileCoord, out backgroundTile))
// {
// if (!backgroundTile.IsReady) continue;
//
// var targetRect = new SharpDX.RectangleF(((thisTile.X - topLeftTile.X) * MM_Repository.OverallDisplay.MapTileSize.Width) - topLeftTileShift.X, ((thisTile.Y - topLeftTile.Y) * MM_Repository.OverallDisplay.MapTileSize.Height) - topLeftTileShift.Y, MM_Repository.OverallDisplay.MapTileSize.Width, MM_Repository.OverallDisplay.MapTileSize.Height);
// Surface.RenderTarget2D.DrawBitmap(backgroundTile.Bitmap, targetRect, MM_Repository.OverallDisplay.MapTransparency, BitmapInterpolationMode.NearestNeighbor, tileSourceRect);
// }
// }
//}
}
Surface.RenderTarget2D.Transform = tx;
}
/// <summary>
/// Initialize the Macomber Map
/// </summary>
/// <param name="Coordinates">The coordinates to be used in the map</param>
/// <param name="Starter">Our startup form</param>
public MacomberMap_Form(MM_Coordinates Coordinates, MM_Startup_Form Starter)
{
InitializeComponent();
var size = ClientSize;
this.Size = Screen.PrimaryScreen.WorkingArea.Size;
if (this.Size.Width >= 1900)
{
size = new Size(1900, this.Size.Height);
}
if (this.Size.Height >= 1200)
{
size = new Size(this.Size.Width, 1180);
}
this.ClientSize = new Size(size.Width - 10, size.Height - 10);
this.Size = ClientSize;
this.Title = "Main Map";
this.Starter = Starter;
MM_System_Interfaces.LogError("MM: Initializing network map/coordinates");
InitNetworkMap(Coordinates);
if (!Data_Integration.Permissions.ShowViolations)
{
SwitchMMView(false, false);
}
//Assign our integration layer, add the thread and form to it
Data_Integration.RunningForms.Add(this);
Data_Integration.RunningThreads.Add(System.Threading.Thread.CurrentThread);
System.Threading.Thread.Sleep(3000); // wait for model kv levels to load
//Assign our controls
MM_System_Interfaces.LogError("MM: Starting network map");
ctlNetworkMap.SetControls(ctlViolationViewer, 0);
MM_System_Interfaces.LogError("MM: Starting violation viewer");
ctlViolationViewer.SetControls(ctlNetworkMap);
MM_System_Interfaces.LogError("MM: Starting key indicators");
ctlKeyIndicators.SetControls(ctlNetworkMap, ctlViolationViewer, MM_Repository.xConfiguration.DocumentElement["DisplayParameters"]["KeyIndicators"]);
ResizeLeftSlider(this, null);
//Set up our results helper
ResultsHelper = new MM_Search_Results_Helper();
ResultsHelper.Visible = false;
Controls.Add(ResultsHelper);
ResultsHelper.BringToFront();
(this.FindForm() as MacomberMap_Form).ctlKeyIndicators.AssignResultsHelper(ResultsHelper);
//Set up our main timer
Program.MainFormChecker = new System.Threading.Timer(Program.ThreadChecker, System.Threading.Thread.CurrentThread, 15000, 15000);
StartRender();
}
private void DrawLasso()
{
if (_coordinates == null)
{
return;
}
if (_coordinates.LassoPoints.Count > 1)
{
var points = MM_Coordinates.ConvertPoints(_coordinates.LassoPoints, 4).Select(p => p * _scale).ToList();
RawRectangleF bounds;
var geometry = Surface.CreateRegionPathGeometry(points, out bounds, filled: true, closed: true, simplify: true);
_target.FillGeometry(geometry, Surface.Brushes.GetBrush(_coordinates.LassoColor, 0.5f));
_target.DrawGeometry(geometry, Surface.Brushes.GetBrush(Color4.White), 2f);
geometry.Dispose();
}
else if (!_coordinates.LassoEnd.IsEmpty)
{
var start = ConvertPoint(_coordinates.LassoStart);
var end = ConvertPoint(_coordinates.LassoEnd);
var rawRectangleF = new RawRectangleF(start.X, start.Y, end.X, end.Y);
_target.FillRectangle(rawRectangleF, Surface.Brushes.GetBrush(_coordinates.LassoColor, 0.5f));
_target.DrawRectangle(rawRectangleF, Surface.Brushes.GetBrush(Color4.White), 2f);
}
}
private void UpdateCoordinatesKDTree(IList <MM_Substation> subs, int zoomLevel)
{
foreach (var sub in subs)
{
var xy = MM_Coordinates.LngLatToXY(sub.LngLat, zoomLevel);
_kdTree.AddPoint(new double[] { xy.X, xy.Y }, sub);
}
}
internal void FixCoordinatesNull()
{
if (Coordinates == null)
{
// TODO: Fix this boundary issue
Coordinates = new MM_Coordinates(-105.589265200513f, 44.5322075f, -86.09185f, 29.2118549f, 4);
//Coordinates = new MM_Coordinates(MM_Repository.Counties["STATE"].Min, MM_Repository.Counties["STATE"].Max, Data_Integration.Permissions.MinZoom);
}
}
/// <summary>
/// Load in a new tile
/// </summary>
/// <param name="tileCoordinates"></param>
public MM_MapTile(TileCoordinates tileCoordinates)
{
this.TileCoordinates = tileCoordinates;
//Determine our tile's positioning
this.TopLeft = MM_Coordinates.TileTopLeft(tileCoordinates.TileXY, tileCoordinates.ZoomLevel);
this.BottomRight = MM_Coordinates.TileBottomRight(tileCoordinates.TileXY, tileCoordinates.ZoomLevel);
this.TopLeftXY = new Point(tileCoordinates.TileXY.X * MM_Repository.OverallDisplay.MapTileSize.Width, tileCoordinates.TileXY.Y * MM_Repository.OverallDisplay.MapTileSize.Height);
this.BottomRightXY = new Point(((tileCoordinates.TileXY.X + 1) * MM_Repository.OverallDisplay.MapTileSize.Width) - 1, ((tileCoordinates.TileXY.Y + 1) * MM_Repository.OverallDisplay.MapTileSize.Height) - 1);
this.Saving = false;
this.Failed = false;
}
/// <summary>
/// Create a new layer
/// </summary>
/// <param name="surface">The <see cref="Direct3DSurface"/> this layer belongs to.</param>
/// <param name="name">The name of the layer.</param>
/// <param name="order">The order of the layer</param>
public MinimapLayer(Direct3DSurface surface, MM_Violation_Viewer violationViewer) : base(surface, "Minimap", 99999)
{
_violationViewer = violationViewer;
var map = this.Surface as MM_Network_Map_DX;
_coordinates = map.Coordinates;
violationViewer.ViolationsChanged += (s, e) => _isDirty = true;
// Hook events to update render state
MM_Repository.ViewChanged += v => _isDirty = true;
_coordinates.Panned += (center, newCenter) => _isDirty = true;
_coordinates.Zoomed += (zoom, newZoom) => _isDirty = true;
_coordinates.LassoDrawing += () => _isDirty = true;
}
/// <summary>
/// Initialize the network map
/// </summary>
/// <param name="Coordinates">The coordinates to be used for the map</param>
private void InitNetworkMap(MM_Coordinates Coordinates)
{
this.ctlNetworkMap = new MM_Network_Map_DX(Coordinates);
this.ctlNetworkMap.Dock = System.Windows.Forms.DockStyle.Fill;
this.ctlNetworkMap.ForeColor = System.Drawing.Color.FromArgb(224, 224, 224);
this.ctlNetworkMap.Location = new System.Drawing.Point(0, 0);
this.ctlNetworkMap.Name = "ctlNetworkMap";
this.ctlNetworkMap.Padding = new System.Windows.Forms.Padding(0, 0, 10, 0);
this.ctlNetworkMap.Size = new System.Drawing.Size(1135, 544);
this.ctlNetworkMap.TabIndex = 0;
this.splHorizontal.Panel2.Controls.Add(this.ctlNetworkMap);
this.ViolationForm = new Form();
this.ViolationForm.Text = "Violation Viewer - " + Data_Integration.UserName.ToUpper() + " - Macomber Map®";
this.ViolationForm.FormBorderStyle = FormBorderStyle.SizableToolWindow;
this.ViolationForm.FormClosing += new FormClosingEventHandler(ViolationForm_FormClosing);
this.ViolationForm.Icon = this.Icon;
// ReloadModelTimer = new System.Threading.Timer(cb => { ReloadModel(); }, null, 60 * 1000, 2 * 60 * 1000);
}
/// <summary>
/// Perform calculations and update data.
/// </summary>
/// <param name="updateTime">Time since last update.</param>
/// <remarks>include base.Update(renderTime); in overloads to preserve updating UpdateTime field.</remarks>
public override void Update(RenderTime updateTime)
{
// if we don't have a data provider, don't update
if (MM_Repository.OverallDisplay.Contour == MM_Display.MM_Contour_Enum.None)
{
return;
}
if (!MM_Repository.ContourDataProviders.TryGetValue(MM_Repository.OverallDisplay.ContourData, out DataProvider))
{
return;
}
base.Update(updateTime);
bool contourChanged = _lastProvider != MM_Repository.OverallDisplay.ContourData;
if (Surface.Coordinates.ZoomLevel != _zoomLevel || _kdProxy == null || contourChanged || (updateTime.TotalTime - _lastUpdate).TotalSeconds > MM_Repository.OverallDisplay.ContourRefreshTime)
{
_lastUpdate = updateTime.TotalTime;
_lastProvider = MM_Repository.OverallDisplay.ContourData;
_kdProxy = new KDTree.KDTree <ContourData>(2);
_zoomLevel = Surface.Coordinates.ZoomLevel;
foreach (var item in DataProvider.GetData())
{
var coord = MM_Coordinates.LngLatToScreenVector2(item.LngLat, _zoomLevel);
item.XY = coord;
_kdProxy.AddPoint(new double[] { coord.X, coord.Y }, item);
}
if (_bmp != null)
{
_bmp.Dispose();
}
if (contourChanged)
{
Surface.AddOnscreenMessage("Contour layer changed: " + _lastProvider.ToString(), SharpDX.Color.Aqua);
}
}
}
/// <summary>
/// Perform calculations and update data.
/// </summary>
/// <param name="updateTime">Time since last update.</param>
/// <remarks>include base.Update(renderTime); in overloads to preserve updating UpdateTime field.</remarks>
public override void Update(RenderTime updateTime)
{
base.Update(updateTime);
if (!Surface.IsDirty && _lastZoom == Surface.Coordinates.ZoomLevel)
{
return;
}
_lastZoom = Surface.Coordinates.ZoomLevel;
foreach (var value in regions.Values)
{
value.Geometry.Dispose();
}
regions.Clear();
foreach (var boundary in MM_Repository.Counties.Values.ToList())
{
RawRectangleF bounds;
var geometry = Surface.CreateRegionPathGeometry(MM_Coordinates.ConvertPoints(boundary.Coordinates, Surface.Coordinates.ZoomLevel).ToList(), out bounds, filled: true, simplify: true);
var region = new RegionProxy(geometry, boundary.DisplayParameter.ForeColor, boundary.DisplayParameter.Width, bounds);
region.Boundary = boundary;
if (boundary.Name == "STATE")
{
state = region;
}
else
{
regions.Add(boundary, region);
}
}
foreach (MM_Boundary boundary in MM_Repository.Districts.Values.ToList())
{
RawRectangleF bounds;
var geometry = Surface.CreateRegionPathGeometry(MM_Coordinates.ConvertPoints(boundary.Coordinates, Surface.Coordinates.ZoomLevel).ToList(), out bounds, simplify: true);
var region = new RegionProxy(geometry, boundary.DisplayParameter.ForeColor, boundary.DisplayParameter.Width, bounds);
regions.Add(boundary, region);
}
}
/// <summary>
/// Load Content and initialize unmanaged resources.
/// </summary>
public override void LoadContent()
{
int width = 256;
int height = 256;
var size = Surface.RenderTarget2D.PixelSize;
var sizeV = new Vector2(size.Width, size.Height);
_start = sizeV - new Vector2(width, height) - new Vector2(10, 10);
_end = sizeV - new Vector2(10, 10);
_viewLocation = new SharpDX.RectangleF(_start.X, _start.Y, _end.X - _start.X, _end.Y - _start.Y);
base.LoadContent();
if (_font == null || _font.IsDisposed)
{
_font = Surface.Fonts.GetTextFormat(MM_Repository.OverallDisplay.NetworkMapFont, 5);
}
if (_target == null || _target.IsDisposed)
{
_target = Surface.CreateRenderTarget(width, height);
}
MM_Boundary State;
if (MM_Repository.Counties.TryGetValue("STATE", out State))
{
RawRectangleF bounds;
var geometry = Surface.CreateRegionPathGeometry(MM_Coordinates.ConvertPoints(State.Coordinates, 4).ToList(), out bounds, filled: true, simplify: true);
geometry.Dispose();
_scale = new Vector2(width / (bounds.Right - bounds.Left), height / (bounds.Bottom - bounds.Top));
var geometryScaled = Surface.CreateRegionPathGeometry(MM_Coordinates.ConvertPoints(State.Coordinates, 4).ToList(), out bounds, filled: true, compression: 0.001f, simplify: true, scaleX: _scale.X, scaleY: _scale.Y);
_location = new Vector2(bounds.Left, bounds.Top);
_state = new RegionProxy(geometryScaled, State.DisplayParameter.ForeColor, State.DisplayParameter.Width, bounds);
}
}
/// <summary>
/// Render our training layer
/// </summary>
/// <param name="renderTime"></param>
public override void Render(RenderTime renderTime)
{
base.Render(renderTime);
if (MM_Repository.Training == null || MM_Repository.Training.TrainingMode == Data_Elements.Training.MM_Training.enumTrainingMode.NotTraning)
{
return;
}
else
{
MM_Repository.Training.CheckTimes();
String TextToDraw;
Brush DrawBrush;
//Determine our question text and color
if (MM_Repository.Training.TrainingMode == MM_Training.enumTrainingMode.UserWon)
{
TextToDraw = "Congratulations! You won!";
DrawBrush = LightGreenBrush;
}
else if (MM_Repository.Training.TrainingMode == MM_Training.enumTrainingMode.UserFailed)
{
TextToDraw = "Sorry - please play again!";
DrawBrush = RedBrush;
}
else
{
TextToDraw = MM_Repository.Training.QuestionText;
DrawBrush = QuestionBrush;
}
//Now, draw all of our strings
DrawString(TextToDraw, VerticalAlignment.Top, HorizontalAlignment.Center, DrawBrush, QuestionFormat);
DrawString("Score: " + MM_Repository.Training.Score.ToString("#,##0"), VerticalAlignment.Top, HorizontalAlignment.Left, DrawBrush, QuestionFormat);
DrawString("[" + (MM_Repository.Training.CurrentLevel.ID + 1).ToString() + "]: " + MM_Repository.Training.CurrentLevel.Title, VerticalAlignment.Bottom, HorizontalAlignment.Left, DrawBrush, QuestionFormat);
//If we're in question mode, show our countdown timer
if (MM_Repository.Training.TrainingMode == MM_Training.enumTrainingMode.QuestionAsked)
{
double TimeLeft = MM_Repository.Training.CurrentLevel.QuestionTimeout - MM_Repository.Training.TimeSincePresentation;
DrawString("Time: " + TimeLeft.ToString("0"), VerticalAlignment.Top, HorizontalAlignment.Right, DrawBrush, QuestionFormat);
}
//If we have the incorrect answer, draw accordingly.
if (MM_Repository.Training.TrainingMode == MM_Training.enumTrainingMode.AnswerCorrect || MM_Repository.Training.TrainingMode == MM_Training.enumTrainingMode.AnswerWrong)
{
bool Correct = MM_Repository.Training.TrainingMode == MM_Training.enumTrainingMode.AnswerCorrect;
DrawBrush = Correct ? CorrectBrush : IncorrectBrush;
DrawString(MM_Repository.Training.AnswerText, VerticalAlignment.Top, HorizontalAlignment.Center, DrawBrush, QuestionFormat, 1, 2);
RawVector2 CorrectAnswerXY = MM_Coordinates.LngLatToScreenVector2(MM_Repository.Training.CorrectAnswer, Surface.Coordinates.ZoomLevel);
CorrectAnswerXY.X -= Surface.Coordinates.TopLeftXY.X;
CorrectAnswerXY.Y -= Surface.Coordinates.TopLeftXY.Y;
if (!MM_Repository.Training.UserAnswer.IsEmpty)
{
RawVector2 UserAnswerXY = MM_Coordinates.LngLatToScreenVector2(MM_Repository.Training.UserAnswer, Surface.Coordinates.ZoomLevel);
UserAnswerXY.X -= Surface.Coordinates.TopLeftXY.X;
UserAnswerXY.Y -= Surface.Coordinates.TopLeftXY.Y;
DrawCrosshairBackground(UserAnswerXY, 8f);
Surface.RenderTarget2D.DrawLine(CorrectAnswerXY, UserAnswerXY, BlackBrush, 5f);
DrawCrosshairBackground(CorrectAnswerXY, 15f);
Surface.RenderTarget2D.DrawLine(CorrectAnswerXY, UserAnswerXY, CorrectBrush, 3f);
DrawCrosshair(WhiteBrush, UserAnswerXY, 10, "");
}
if (MM_Repository.Training.TargetElement is MM_Substation)
{
DrawCrosshair(DrawBrush, CorrectAnswerXY, 20, ((MM_Substation)MM_Repository.Training.TargetElement).LongName);
}
else
{
DrawCrosshair(DrawBrush, CorrectAnswerXY, 20, MM_Repository.Training.TargetElement.Name);
}
}
}
}
public static void CalculateCoords(LineProxy proxy, MM_Line line, int zoomLevel)
{
proxy.Coordinates.Clear();
//Ignore invalid lines
if (float.IsNaN(line.CenterLngLat.X))
{
return;
}
// flip the line coords
if (line.Coordinates.Count > 0 && (line.Substation2.LngLat == line.Coordinates[0] || line.Substation1.LngLat == line.Coordinates[line.Coordinates.Count - 1]))
{
line.Coordinates.Reverse();
}
if (line.Coordinates.Count == 0)
{
line.Coordinates.Add(line.Substation1.LngLat);
line.Coordinates.Add(line.Substation2.LngLat);
}
//Determine if we need to flip coordinates because the substations have changed
if (line.Coordinates.Count > 0 && (line.Substation2.LngLat == line.Coordinates[0] || line.Substation1.LngLat == line.Coordinates[line.Coordinates.Count - 1]))
{
line.Coordinates.Reverse();
}
Vector2 lastPoint = Vector2.Zero;
Vector2 aggPoint = Vector2.Zero;
float minX = float.MaxValue;
float minY = float.MaxValue;
float maxY = float.MinValue;
float maxX = float.MinValue;
float length = 0;
if (proxy.Segments == null)
{
proxy.Segments = new List <LineSegment>();
}
else
{
proxy.Segments.Clear();
}
if (line.Coordinates.Count > 0)
{
for (int i = 0; i < line.Coordinates.Count; i++)
{
PointF Pt = line.Coordinates[i];
Vector2 currentPoint = MM_Coordinates.LngLatToScreenVector2(Pt, zoomLevel);
if (lastPoint.IsZero || lastPoint.X != currentPoint.X || lastPoint.Y != currentPoint.Y)
{
aggPoint.X += currentPoint.X;
aggPoint.Y += currentPoint.Y;
}
proxy.Coordinates.Add(currentPoint);
if (currentPoint.X < minX)
{
minX = currentPoint.X;
}
if (currentPoint.X > maxX)
{
maxX = currentPoint.X;
}
if (currentPoint.Y < minY)
{
minY = currentPoint.Y;
}
if (currentPoint.Y > maxY)
{
maxY = currentPoint.Y;
}
if (i > 0)
{
var segment = new LineSegment(lastPoint, currentPoint);
proxy.Segments.Add(segment);
length += segment.length;
}
lastPoint = currentPoint;
}
}
proxy.Length = length;
var bounds = new SharpDX.RectangleF(minX, minY, maxX - minX, maxY - minY);
proxy.Bounds = bounds;
lastPoint = proxy.Coordinates[proxy.Coordinates.Count - 1];
proxy.Center = new Vector2(aggPoint.X / (float)proxy.Coordinates.Count, aggPoint.Y / (float)proxy.Coordinates.Count);
var lineAngle = (float)Math.Atan2(proxy.Coordinates[0].Y - lastPoint.Y, proxy.Coordinates[0].X - lastPoint.X);
// if (lineAngle < 0)
// {
// lineAngle += (float)(Math.PI * 2);
// }
if (lineAngle > (float)Math.PI / 2f)
{
lineAngle = (float)lineAngle - (float)Math.PI;
proxy.FlipSides = true;
}
else if (lineAngle < (float)Math.PI / -2f)
{
lineAngle = (float)lineAngle - (float)Math.PI;
proxy.FlipSides = true;
}
else
{
proxy.FlipSides = false;
}
//lineAngle *= 180f / (float)Math.PI;
proxy.Angle = lineAngle;
}
/// <summary>
/// Hanlde our element selection on our mouse down. If no element has been selected, just make sure the element is highlighted.
/// </summary>
/// <param name="SelectedElement"></param>
/// <param name="Coordinates"></param>
/// <param name="PixelLocation"></param>
/// <param name="HighlightedElement"></param>
public MM_Coordinate_Suggestion HandleElementSelection(MM_Element SelectedElement, MM_Coordinates Coordinates, Point PixelLocation, ref MM_Element HighlightedElement)
{
MM_Coordinate_Suggestion FoundSuggestion = null;
//Update the status of our element
UpdateElement(SelectedElement);
//Now, if our selected element is also highlighted, let's activate it
if (HighlightedElement == SelectedElement)
{
if (!Suggestions.TryGetValue(SelectedElement, out FoundSuggestion))
{
Suggestions.Add(SelectedElement, FoundSuggestion = new MM_Coordinate_Suggestion(SelectedElement, Coordinates));
ActiveChanges.Rows.Add(SelectedElement.ElemType, SelectedElement.Name, SelectedElement.TEID);
}
//If we're a line, determine how we should handle things based on our pixel location
if (SelectedElement is MM_Line)
{
int HitThreshold = 3;
FoundSuggestion.LineIndex = -1;
//First, go through and check to see if we have a close match
for (int a = 0; a < FoundSuggestion.SuggestedCoordinatesXY.Length; a++)
{
if (Math.Abs(FoundSuggestion.SuggestedCoordinatesXY[a].X - PixelLocation.X) < HitThreshold && Math.Abs(FoundSuggestion.SuggestedCoordinatesXY[a].Y - PixelLocation.Y) < HitThreshold)
{
FoundSuggestion.LineIndex = a;
}
}
//If not, continue looking in between our points
if (FoundSuggestion.LineIndex == -1)
{
for (int a = 1; a < FoundSuggestion.SuggestedCoordinatesXY.Length; a++)
{
Point Pt1 = FoundSuggestion.SuggestedCoordinatesXY[a - 1];
Point Pt2 = FoundSuggestion.SuggestedCoordinatesXY[a];
float Slope = (Single)(Pt1.Y - Pt2.Y) / (Single)(Pt1.X - Pt2.X);
float YInt = Pt1.Y - (Slope * Pt1.X);
float TestY = (Slope * PixelLocation.X) + YInt;
if (Math.Abs(TestY - PixelLocation.Y) < HitThreshold)
{
if ((PixelLocation.X >= Pt1.X && PixelLocation.X <= Pt2.X) || (PixelLocation.X <= Pt1.X && PixelLocation.X >= Pt2.X))
{
if ((PixelLocation.Y >= Pt1.Y && PixelLocation.Y <= Pt2.Y) || (PixelLocation.Y <= Pt1.Y && PixelLocation.Y >= Pt2.Y))
{
List <PointF> UpdatedCoordinates = new List <PointF>(FoundSuggestion.SuggestedCoordinates);
UpdatedCoordinates.Insert(a, MM_Coordinates.XYToLngLat(PixelLocation, Coordinates.ZoomLevel));
(SelectedElement as MM_Line).Coordinates = FoundSuggestion.SuggestedCoordinates.ToList();
FoundSuggestion.SuggestedCoordinates = UpdatedCoordinates.ToArray();
List <Point> UpdatedCoordinateXY = new List <Point>(FoundSuggestion.SuggestedCoordinatesXY);
UpdatedCoordinateXY.Insert(a, PixelLocation);
FoundSuggestion.SuggestedCoordinatesXY = UpdatedCoordinateXY.ToArray();
FoundSuggestion.LineIndex = a;
break;
}
}
}
}
}
}
}
HighlightedElement = SelectedElement;
return(FoundSuggestion);
}
/// <summary>
/// Perform calculations and update data.
/// </summary>
/// <param name="updateTime">Time since last update.</param>
/// <remarks>include base.Update(renderTime); in overloads to preserve updating UpdateTime field.</remarks>
public override void Update(RenderTime updateTime)
{
base.Update(updateTime);
if (!Surface.IsDirty && _lastZoom == Surface.Coordinates.ZoomLevel)
{
return;
}
_lastZoom = Surface.Coordinates.ZoomLevel;
foreach (var substationKvp in MM_Repository.Substations)
{
var element = substationKvp.Value;
SubstationProxy proxy;
if (!_substationProxies.TryGetValue(element.TEID, out proxy))
{
proxy = new SubstationProxy()
{
Substation = element,
Coordinates = MM_Coordinates.LngLatToScreenVector2(element.LngLat, _lastZoom)
};
_substationProxies.Add(element.TEID, proxy);
}
proxy.Coordinates = MM_Coordinates.LngLatToScreenVector2(element.LngLat, _lastZoom);
proxy.BlackStartHidden = proxy.BlackStartDim = false;
// calculate blackstart parameters
if ((MM_Repository.OverallDisplay.BlackstartMode == MM_Display.enumBlackstartMode.HideNonOperatorElements || MM_Repository.OverallDisplay.BlackstartMode == MM_Display.enumBlackstartMode.DimNonOperatorElements) && (Array.IndexOf(proxy.Substation.Operators, MM_Repository.OverallDisplay.DisplayCompany) == -1))
{
if (MM_Repository.OverallDisplay.BlackstartMode == MM_Display.enumBlackstartMode.HideNonOperatorElements)
{
proxy.BlackStartHidden = true;
}
else
{
proxy.BlackStartDim = true;
}
}
else if ((MM_Repository.OverallDisplay.BlackstartMode == MM_Display.enumBlackstartMode.HideNonBlackstartElements || MM_Repository.OverallDisplay.BlackstartMode == MM_Display.enumBlackstartMode.DimNonBlackstartElements) && (!element.IsBlackstart || Array.IndexOf(proxy.Substation.Operators, MM_Repository.OverallDisplay.DisplayCompany) == -1))
{
if (MM_Repository.OverallDisplay.BlackstartMode == MM_Display.enumBlackstartMode.HideNonBlackstartElements)
{
proxy.BlackStartHidden = true;
}
else
{
proxy.BlackStartDim = true;
}
}
else if ((MM_Repository.OverallDisplay.BlackstartMode == MM_Display.enumBlackstartMode.HideExternalElements || MM_Repository.OverallDisplay.BlackstartMode == MM_Display.enumBlackstartMode.DimExternalElements) && !element.IsInternal)
{
if (MM_Repository.OverallDisplay.BlackstartMode == MM_Display.enumBlackstartMode.HideExternalElements)
{
proxy.BlackStartHidden = true;
}
else
{
proxy.BlackStartDim = true;
}
}
//Handle null line operator values to keep from breaking the rest
if ((element.Operators == null || element.Operators.Length == 0) &&
(MM_Repository.OverallDisplay.BlackstartMode == MM_Display.enumBlackstartMode.DimNonBlackstartElements ||
MM_Repository.OverallDisplay.BlackstartMode == MM_Display.enumBlackstartMode.DimNonOperatorElements))
{
proxy.BlackStartDim = true;
}
else if (MM_Repository.OverallDisplay.BlackstartMode == MM_Display.enumBlackstartMode.DimNonBlackstartElements &&
(!element.IsBlackstart || Array.IndexOf(proxy.Substation.Operators, MM_Repository.OverallDisplay.DisplayCompany) == -1))
{
proxy.BlackStartDim = true;
}
else if (MM_Repository.OverallDisplay.BlackstartMode == MM_Display.enumBlackstartMode.DimExternalElements && !element.IsInternal)
{
proxy.BlackStartDim = true;
}
else if (MM_Repository.OverallDisplay.BlackstartMode == MM_Display.enumBlackstartMode.DimNonOperatorElements && Array.IndexOf(proxy.Substation.Operators, MM_Repository.OverallDisplay.DisplayCompany) == -1)
{
proxy.BlackStartDim = true;
}
else
{
proxy.BlackStartDim = false;
}
}
}
static void Main(params string[] args)
{
// CreateModelXml user password filepath (Build thMM_System_Interfacesis as a console app for this job).
if (args.Length > 0 && args[0].Equals("CreateModelXml", StringComparison.OrdinalIgnoreCase))
{
try
{
System.Console.Error.WriteLine("Starting XML Model creator client");
MM_Server_Interface.LoadModelFromSql = true;
MM_System_Interfaces.Headless = true;
MM_Repository.OverallDisplay = new MM_Display();
MM_Coordinates coord = new MM_Coordinates(-109f, 29f, -86f, 51f, 1f);
System.Console.Error.WriteLine("Waiting for server...");
while (MM_Server_Interface.MMServers == null || MM_Server_Interface.MMServers.Count == 0)
{
Thread.Sleep(3000);
}
var list = MM_Server_Interface.MMServers.Values.ToList();
System.Console.Error.WriteLine("Connecting to server: " + list[0].ServerName);
string user = "******";
string password = "";
string file = "MacomberMap-Combined.MM_Model";
if (args.Length > 1)
{
if (args[1].EndsWith(".MM_Model"))
{
file = args[1];
}
else
{
user = args[1];
}
}
if (args.Length > 2)
{
if (args[2].EndsWith(".MM_Model"))
{
file = args[2];
}
else
{
password = args[2];
}
}
if (args.Length > 3)
{
file = args[3];
}
Exception exp = new Exception();
MM_Server_Interface.TryLogin(list[0].ServerName, list[0].ServerURI, user, password, out exp);
MM_Server_Interface.LoadMacomberMapConfiguration();
Data_Integration.InitializationComplete = false;
System.Console.Error.WriteLine("Starting SQL Model Loader...");
SqlModelLoader sqlModelLoader = new SqlModelLoader();
sqlModelLoader.ConnectionString = Settings.Default.ModelDatabase;
sqlModelLoader.LoadStaticRepository();
System.Console.Error.WriteLine("Rolling up Elements...");
Data_Integration.UseEstimates = false;
Data_Integration.RollUpElementsToSubstation();
Data_Integration.CommLoaded = true;
Data_Integration.ModelLoadCompletion = DateTime.Now;
Data_Integration.NetworkSource = new MM_Data_Source();
Data_Integration.NetworkSource.Estimates = false;
Data_Integration.NetworkSource.Database = "NETMOM";
Data_Integration.NetworkSource.Application = "RTNET";
Data_Integration.NetworkSource.BackColor = Color.Blue;
Data_Integration.NetworkSource.Telemetry = true;
Data_Integration.NetworkSource.Default = true;
Data_Integration.NetworkSource.Master = true;
Data_Integration.NetworkSource.ViolationApp = "RTCA";
Data_Integration.InitializationComplete = true;
// Data_Integration.RestartModel(MM_Server_Interface.Client);
Data_Integration.SaveXMLData(file, coord);
System.Console.WriteLine("Waiting for data...");
for (int i = 0; i < 60 * 8; i++)
{
System.Console.Write(".");
Thread.Sleep(1000); // wait for EMS data to flow in.
}
Data_Integration.SaveXMLData(file, coord);
}
catch (Exception ex)
{
System.Console.Error.WriteLine(ex.Message);
System.Console.Error.WriteLine(ex.StackTrace);
System.Environment.Exit(1);
}
System.Environment.Exit(0);
}
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.ThreadException += Application_ThreadException;
// Application.Run(new frmControlTester());
// return;
try
{
Microsoft.Win32.RegistryKey key;
key = Microsoft.Win32.Registry.LocalMachine.OpenSubKey("SOFTWARE").OpenSubKey("Policies", true);
if (!key.GetSubKeyNames().Contains("Chromium"))
{
key.CreateSubKey("Chromium");
}
key = key.OpenSubKey("Chromium", true);
if (!key.GetSubKeyNames().Contains("EnabledPlugins"))
{
key.CreateSubKey("EnabledPlugins");
}
key = key.OpenSubKey("EnabledPlugins", true);
if (!key.GetValueNames().Contains("1"))
{
key.SetValue("1", "Silverlight*");
key.SetValue("2", "npapi");
}
}
catch (Exception ex)
{
MM_System_Interfaces.LogError(ex);
}
if (Environment.CommandLine.IndexOf("/Test", StringComparison.CurrentCultureIgnoreCase) != -1)
{
Application.Run(new frmTest());
}
else
{
using (MM_Startup_Form Startup = new MM_Startup_Form())
if (Startup.ShowDialog(StartNetworkMap) == DialogResult.OK)
{
Application.Run();
}
else
{
Application.Exit();
}
}
}
private Vector2 ConvertPoint(Vector2 point)
{
return(MM_Coordinates.LngLatToScreenVector2(point, 4) * _scale);
}
