public void LoadLayers()
{
Overlays.Clear();
var previewResolution = 75;
var layers = LayerHelper.GetLayers().ToList();
//Ensure that the empty layer is the first option in the list.
var emptyLayer = layers.FirstOrDefault(i => i.Type == Layer.LayerType.Overlay && i.Name == "None");
if (emptyLayer != null)
{
Overlays.Add(new OverlayInfo
{
Image = BitmapHelper.ConvertBitmapToImageSource(ImageLoader.LoadBitmapFromFile(emptyLayer.File, previewResolution, 5)),
Info = emptyLayer
});
}
foreach (var layer in layers.Where(i => i.Type == Layer.LayerType.Overlay && i != emptyLayer))
{
Overlays.Add(new OverlayInfo
{
Image = BitmapHelper.ConvertBitmapToImageSource(ImageLoader.LoadBitmapFromFile(layer.File, previewResolution, previewResolution)),
Info = layer
});
}
}
public NetworkViewModel()
{
if (!Overlays.Contains(_overlay))
{
Overlays.Add(_overlay);
}
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
fCore.OnMapClose();
Overlays.CollectionChanged -= Overlays_CollectionChanged;
foreach (var o in Overlays)
{
o.Dispose();
}
Overlays.Clear();
#if DEBUG_CENTER
CenterPen.Dispose();
ScalePen.Dispose();
#endif
ScaleFont.Dispose();
CenterFormat.Dispose();
BottomFormat.Dispose();
CopyrightFont.Dispose();
EmptyTileBorders.Dispose();
EmptyTileBrush.Dispose();
ClearBackBuffer();
}
base.Dispose(disposing);
}
public override void Initialize(HostInterface CurrentHost, BaseOptions CurrentOptions)
{
base.Initialize(CurrentHost, CurrentOptions);
try
{
if (pickingShader == null)
{
pickingShader = new Shader(this, "default", "picking", true);
}
pickingShader.Activate();
pickingShader.Deactivate();
}
catch
{
Interface.AddMessage(MessageType.Error, false, "Initializing the touch shader failed- Falling back to legacy openGL.");
Interface.CurrentOptions.IsUseNewRenderer = false;
ForceLegacyOpenGL = true;
}
events = new Events(this);
overlays = new Overlays(this);
Touch = new Touch(this);
ObjectsSortedByStart = new int[] { };
ObjectsSortedByEnd = new int[] { };
Program.FileSystem.AppendToLogFile("Renderer initialised successfully.");
}
internal void OnControlRemoved(Control control)
{
if (control is Overlay overlay)
{
Overlays.Remove(overlay);
}
}
/// <summary>
/// Removes the given overlay from the list of <see cref="IClickableMenu"/>'s that should receive emulated events
/// </summary>
/// <param name="overlay">The <see cref="IClickableMenu"/> to remove</param>
public static void Remove(IClickableMenu overlay)
{
Overlays.Remove(overlay);
if (Overlays.Count == 0)
{
Uninit();
}
}
/// <summary>
/// Adds the given overlay to the list of <see cref="IClickableMenu"/>'s that should receive emulated events
/// </summary>
/// <param name="overlay">The <see cref="IClickableMenu"/> to add</param>
public static void Add(IClickableMenu overlay)
{
Overlays.Add(overlay);
if (Overlays.Count == 1)
{
Init();
}
}
private bool HasWork()
{
if (Overlays.Count == 0)
{
return(false);
}
return(Overlays.Any(ol => ol.HasWork));
}
public override void SetData(VectorLayer layer)
{
_visual.Children.Clear();
Features.Clear();
Overlays.Clear();
base.SetData(layer);
}
/// <summary>
/// Gets called when the control gets loaded
/// Sets up an initial state
/// </summary>
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
MapProvider = GMapProviders.GoogleMap;
Position = _centerOfTheMap;
Overlays.Add(_polygons);
Overlays.Add(_polygonRects);
Overlays.Add(_topLayer);
}
public override void Initialize(HostInterface CurrentHost, BaseOptions CurrentOptions)
{
base.Initialize(CurrentHost, CurrentOptions);
events = new Events(this);
overlays = new Overlays(this);
Touch = new Touch(this);
ObjectsSortedByStart = new int[] { };
ObjectsSortedByEnd = new int[] { };
}
public NetworkViewModel(IList <Reach> reaches, int wkid, bool showNodes = false)
{
_wkid = wkid;
if (!Overlays.Contains(_overlay))
{
Overlays.Add(_overlay);
}
CallLater(() => AddNetworkToMap(reaches, wkid, showNodes));
}
public bool Update()
{
IsInitializing = true;
_logger.Info("Updating vMix state.");
var _temp = Create();
if (_temp == null)
{
_logger.Info("vMix is offline");
_logger.Info("Firing \"updated\" event.");
if (OnStateUpdated != null)
{
OnStateUpdated(this, new StateUpdatedEventArgs()
{
Successfully = false
});
}
IsInitializing = false;
return(false);
}
_logger.Info("Calculating difference.");
Diff(this, _temp);
_logger.Info("Updating inputs.");
Inputs.Clear();
foreach (var item in _temp.Inputs)
{
Inputs.Add(item);
}
Overlays.Clear();
foreach (var item in _temp.Overlays)
{
Overlays.Add(item);
}
UpdateChangedInputs(_currentStateText, _temp._currentStateText);
if (_currentStateText != _temp._currentStateText)
{
_currentStateText = _temp._currentStateText;
}
_logger.Info("Firing \"updated\" event.");
OnStateUpdated?.Invoke(this, new StateUpdatedEventArgs()
{
Successfully = true, OldInputs = null, NewInputs = null
});
IsInitializing = false;
return(true);
}
private void AddPolyline(Polyline polyline)
{
if (Overlays.ContainsKey(polyline))
{
return;
}
MKPolyline naitivePolyline = MKPolyline.FromCoordinates(polyline.Points.Select(p => new CLLocationCoordinate2D(p.Latitude, p.Longitude)).ToArray());
Overlays.Add(polyline, naitivePolyline);
Control.InsertOverlay(naitivePolyline, (nuint)polyline.ZIndex, MKOverlayLevel.AboveLabels);
}
private void OverlayMessageEvent(object sender, SendMessageEventArgs e)
{
Task.Run(() =>
{
var targetOverlay = Overlays.FirstOrDefault(x => x.Name == e.Target);
if (targetOverlay != null)
{
targetOverlay.OverlayMessage(e.Message);
}
});
}
public BaseOverlay PopOverlay()
{
if (Overlays.Count == 0)
{
return(null);
}
BaseOverlay overlay = Overlays[0];
Overlays.Remove(overlay);
return(overlay);
}
private void dataGridViewScangrid_RowPostPaint(object sender, DataGridViewRowPostPaintEventArgs e)
{
var cur = dataGridViewScangrid.Rows[e.RowIndex];
Overlays overlays = cur.Cells[0].Tag as Overlays; // may be null
if (cur.Tag != null)
{
// we programatically draw the image because we have control over its pos/ size this way, which you can't do
// with a image column - there you can only draw a fixed image or stretch it to cell contents.. which we don't want to do
int vmid = (e.RowBounds.Top + e.RowBounds.Bottom) / 2;
int hmid = e.RowBounds.Left + cur.Cells[0].Size.Width / 2;
int icons = 0;
if (overlays != null)
{
icons = (overlays.mapped ? 1 : 0) + (overlays.volcanism ? 1 : 0) + (overlays.materials ? 1 : 0) + (overlays.landable ? 1 : 0);
}
int iconspacing = Font.ScalePixels(2);
Image img = cur.Tag as Image;
Rectangle body = new Rectangle(hmid - (iconsize + bodysize + iconspacing) / 2, vmid - bodysize / 2, bodysize, bodysize);
e.Graphics.DrawImage(img, body); // main icon
int right = body.Left + bodysize + iconspacing;
int vposoverlay = vmid - iconsize * icons / 2; // position it centrally vertically
if (overlays?.landable ?? false)
{
e.Graphics.DrawImage((Image)EDDiscovery.Icons.Controls.Scan_Bodies_Landable, new Rectangle(right, vposoverlay, iconsize, iconsize));
vposoverlay += iconsize + iconspacing;
}
if (overlays?.materials ?? false)
{
e.Graphics.DrawImage((Image)EDDiscovery.Icons.Controls.Scan_ShowAllMaterials, new Rectangle(right, vposoverlay, iconsize, iconsize));
vposoverlay += iconsize + iconspacing;
}
if (overlays?.volcanism ?? false)
{
e.Graphics.DrawImage((Image)EDDiscovery.Icons.Controls.Scan_Bodies_Volcanism, new Rectangle(right, vposoverlay, iconsize, iconsize));
vposoverlay += iconsize + iconspacing;
}
if (overlays?.mapped ?? false)
{
e.Graphics.DrawImage((Image)EDDiscovery.Icons.Controls.Scan_Bodies_Mapped, new Rectangle(right, vposoverlay, iconsize, iconsize));
}
}
}
public UserMapControl()
{
InitializeComponent();
makerOverlay = new GMapOverlay("makerOverlay");
Overlays.Add(makerOverlay);
MouseClick += MapControl_MouseClick;
MouseMove += MapControl_MouseMove;
MouseDown += MapControl_MouseDown;
MouseUp += MapControl_MouseUp;
}
public IconOverlay FindOverlay(string overlayName)
{
IconOverlay overlay = Overlays.FirstOrDefault(o => o.Title.Equals(overlayName));
if (overlay != null)
{
return(overlay);
}
overlay = new IconOverlay(overlayName);
Overlays.InsertSorted(overlay);
return(overlay);
}
public MapViewModel()
{
Overlays.Add(new GraphicsOverlay()
{
Renderer = new SimpleRenderer(new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Colors.CornflowerBlue, 5))
});
Overlays[0].SceneProperties.SurfacePlacement = SurfacePlacement.Relative;
Overlays.Add(new GraphicsOverlay()
{
Renderer = new SimpleRenderer(new SimpleMarkerSymbol(SimpleMarkerSymbolStyle.Circle, Colors.Red, 15))
});
Overlays[1].SceneProperties.SurfacePlacement = SurfacePlacement.Relative;
}
public void Update(BoardService boards, OpPost post)
{
Post = post; // editing a post will build a new header, create a new object
Text = boards.GetPostTitle(post);
if (post.Header.ParentID == 0 && post.Replies > 0)
{
Text += " (" + post.Replies.ToString() + ")";
}
SubItems[0].Text = boards.Core.GetName(post.Header.SourceID);
SubItems[1].Text = Utilities.FormatTime(post.Header.Time);
/*
* 0 - PostView.OverlayImages.Add(PostImages.higher);
* 1 - PostView.OverlayImages.Add(PostImages.lower);
* 2 - PostView.OverlayImages.Add(PostImages.high_scope);
* 3 - PostView.OverlayImages.Add(PostImages.low_scope);*/
ImageIndex = 0;
if (Position == ScopeType.High)
{
ImageIndex = 1;
}
if (Position == ScopeType.Low)
{
ImageIndex = 2;
}
if (Overlays == null)
{
Overlays = new List <int>();
}
if (Scope == ScopeType.High)
{
Overlays.Add(0);
}
if (Scope == ScopeType.Low)
{
Overlays.Add(1);
}
}
private void RemoveMarker(Marker marker)
{
marker.PropertyChanged -= Marker_PropertyChanged;
if (Markers.ContainsKey(marker))
{
Control.RemoveAnnotation(Markers[marker]);
Markers.Remove(marker);
}
if (Overlays.ContainsKey(marker))
{
Control.RemoveAnnotation(Overlays[marker]);
Overlays.Remove(marker);
}
}
internal IconLibrary(XElement eltLibrary)
{
Name = eltLibrary.Attribute("name")?.Value;
foreach (XElement eltOverlay in eltLibrary.Elements(MainModel.NSIconMaker + "Overlay"))
{
Overlays.Add(new IconOverlay(eltOverlay));
ProgressDialog.ProgressDialog.Current.Report(value: double.PositiveInfinity);
}
foreach (XElement eltCategory in eltLibrary.Elements(MainModel.NSIconMaker + "Category"))
{
Categories.Add(new Category(eltCategory, this));
}
}
public void Dispose()
{
if (Texture != null)
{
Texture.Dispose();
}
if (Overlays != null)
{
Overlays.Dispose();
}
if (Alphas != null)
{
Alphas.Dispose();
}
}
/// <summary>
/// Xóa tất cả các marker và Overlay trên bản đồ
/// </summary>
public void ClearAll()
{
foreach (GMapOverlay overlay in Overlays)
{
overlay.Markers.Clear();
}
Overlays.Clear();
_polygon = null;
OverlayPolygon_Auxiliary = null;
OverlayPolygon_Vertices = null;
OverlayCustom = null;
OverlayXeNhan = null;
OverlayXeDeCu = null;
}
private void MyGMAP_GestureHappened(object sender, GestureEventArgs e)
{
if (e.Operation == Gestures.Pan)
{
p1.Position = e.FirstPointLL;
p2.Position = e.SecondPointLL;
Overlays.First().Markers.Add(p1);
Overlays.First().Markers.Add(p2);
//Core.Position = e.FirstPointLL;
PointLatLng point = FromLocalToLatLng(e.SecondPoint.X, e.SecondPoint.Y);
double latdif = e.FirstPointLL.Lat - point.Lat;
double lngdif = e.FirstPointLL.Lng - point.Lng;
//Position = new PointLatLng(Position.Lat + latdif,
// Position.Lng + lngdif);
}
if (e.Operation == Gestures.Zoom)
{
// aim is to get the ll listed under the users finger
var startlocal = FromLatLngToLocal(e.FirstPointLL);
p1.Position = e.FirstPointLL;
p2.Position = e.SecondPointLL;
Overlays.First().Markers.Add(p1);
Overlays.First().Markers.Add(p2);
var scale = e.DistanceBetweenNow / (float)e.DistanceBetweenStart;
// use the start center as our center;
//Position = FromLocalToLatLng((int)startlocal.X, (int)startlocal.Y);
Core.Position = e.FirstPointLL;
//Core.mouseLastZoom.X = e.SecondPoint.X;
//Core.mouseLastZoom.Y = e.SecondPoint.Y;
Core.MouseWheelZooming = true;
Zoom += (scale - 1);
Core.MouseWheelZooming = false;
iArguments = e.DistanceBetweenNow;
Console.WriteLine("zoom " + e.FirstPoint + " " + e.SecondPoint + " ");
}
}
/// <summary>
/// Resets the values to their default.
/// </summary>
public void ResetValues()
{
HorizontalMargin = 30;
VerticalMargin = 30;
InfoText = string.Empty;
ScreenPosition = ScreenPositions.BottomRight;
BackgroundColor = SerializableColor.FromColor(Color.White);
OutputDepth = OutputDepths.CurrentDepth;
OutputDestination = OutputDestinations.TempFolder;
OtherFolder = string.Empty;
OutputFileName = "wpinfo.bmp";
IgnoreTaskBar = false;
Overlays.Clear();
SaveRelativeImagePaths = true;
ImageMode = ImageModes.Fit;
}
private void RemovePolyline(object o)
{
if (Overlays.Count == 0)
{
return;
}
var polyline = Overlays.LastOrDefault();
_allPolylines.AddLast(polyline);
Overlays.Remove(polyline);
_removePolylineCommand.ChangeCanExecute();
_addPolylineCommand.ChangeCanExecute();
}
private void AddPolyline(object o)
{
if (_allPolylines.Last == null)
{
return;
}
var polyline = _allPolylines.Last.Value;
_allPolylines.RemoveLast();
Overlays.Add(polyline);
_removePolylineCommand.ChangeCanExecute();
_addPolylineCommand.ChangeCanExecute();
}
private void MenuItemManageLayers_OnClick(object sender, RoutedEventArgs e)
{
var win = new ManageLayersWindow
{
Owner = this,
WindowStartupLocation = WindowStartupLocation.CenterOwner
};
win.Show();
win.Closing += (o, args) =>
{
Borders.RefreshLayers();
Overlays.RefreshLayers();
};
}
