| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/GMap.NET.WindowsPresentation/GMapControl.cs |
|---|
| 0,0 → 1,2366 |
| |
| namespace GMap.NET.WindowsPresentation |
| { |
| using System; |
| using System.Collections.Generic; |
| using System.Collections.ObjectModel; |
| using System.ComponentModel; |
| using System.Globalization; |
| using System.Linq; |
| using System.Windows; |
| using System.Windows.Controls; |
| using System.Windows.Data; |
| using System.Windows.Input; |
| using System.Windows.Media; |
| using System.Windows.Media.Effects; |
| using System.Windows.Media.Imaging; |
| using System.Windows.Shapes; |
| using System.Windows.Threading; |
| using GMap.NET; |
| using GMap.NET.Internals; |
| using System.Diagnostics; |
| using GMap.NET.MapProviders; |
| using System.Windows.Media.Animation; |
| using GMap.NET.Projections; |
| /// <summary> |
| /// GMap.NET control for Windows Presentation |
| /// </summary> |
| public partial class GMapControl : ItemsControl, Interface, IDisposable |
| { |
| #region DependencyProperties and related stuff |
| public System.Windows.Point MapPoint |
| { |
| get |
| { |
| return (System.Windows.Point)GetValue(MapPointProperty); |
| } |
| set |
| { |
| SetValue(MapPointProperty, value); |
| } |
| } |
| // Using a DependencyProperty as the backing store for point. This enables animation, styling, binding, etc... |
| public static readonly DependencyProperty MapPointProperty = |
| DependencyProperty.Register("MapPoint", typeof(System.Windows.Point), typeof(GMapControl), new PropertyMetadata(new Point(), OnMapPointPropertyChanged)); |
| private static void OnMapPointPropertyChanged(DependencyObject source, |
| DependencyPropertyChangedEventArgs e) |
| { |
| Point temp = (Point)e.NewValue; |
| (source as GMapControl).Position = new PointLatLng(temp.X, temp.Y); |
| } |
| public static readonly DependencyProperty MapProviderProperty = DependencyProperty.Register("MapProvider", typeof(GMapProvider), typeof(GMapControl), new UIPropertyMetadata(EmptyProvider.Instance, new PropertyChangedCallback(MapProviderPropertyChanged))); |
| /// <summary> |
| /// type of map |
| /// </summary> |
| [Browsable(false)] |
| public GMapProvider MapProvider |
| { |
| get |
| { |
| return GetValue(MapProviderProperty) as GMapProvider; |
| } |
| set |
| { |
| SetValue(MapProviderProperty, value); |
| } |
| } |
| private static void MapProviderPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) |
| { |
| GMapControl map = (GMapControl)d; |
| if(map != null && e.NewValue != null) |
| { |
| Debug.WriteLine("MapType: " + e.OldValue + " -> " + e.NewValue); |
| RectLatLng viewarea = map.SelectedArea; |
| if(viewarea != RectLatLng.Empty) |
| { |
| map.Position = new PointLatLng(viewarea.Lat - viewarea.HeightLat / 2, viewarea.Lng + viewarea.WidthLng / 2); |
| } |
| else |
| { |
| viewarea = map.ViewArea; |
| } |
| map.Core.Provider = e.NewValue as GMapProvider; |
| map.Copyright = null; |
| if(!string.IsNullOrEmpty(map.Core.Provider.Copyright)) |
| { |
| map.Copyright = new FormattedText(map.Core.Provider.Copyright, CultureInfo.CurrentUICulture, FlowDirection.LeftToRight, new Typeface("GenericSansSerif"), 9, Brushes.Navy); |
| } |
| if(map.Core.IsStarted && map.Core.zoomToArea) |
| { |
| // restore zoomrect as close as possible |
| if(viewarea != RectLatLng.Empty && viewarea != map.ViewArea) |
| { |
| int bestZoom = map.Core.GetMaxZoomToFitRect(viewarea); |
| if(bestZoom > 0 && map.Zoom != bestZoom) |
| { |
| map.Zoom = bestZoom; |
| } |
| } |
| } |
| } |
| } |
| public static readonly DependencyProperty ZoomProperty = DependencyProperty.Register("Zoom", typeof(double), typeof(GMapControl), new UIPropertyMetadata(0.0, new PropertyChangedCallback(ZoomPropertyChanged), new CoerceValueCallback(OnCoerceZoom))); |
| /// <summary> |
| /// map zoom |
| /// </summary> |
| [Category("GMap.NET")] |
| public double Zoom |
| { |
| get |
| { |
| return (double)(GetValue(ZoomProperty)); |
| } |
| set |
| { |
| SetValue(ZoomProperty, value); |
| } |
| } |
| private static object OnCoerceZoom(DependencyObject o, object value) |
| { |
| GMapControl map = o as GMapControl; |
| if(map != null) |
| { |
| double result = (double)value; |
| if(result > map.MaxZoom) |
| { |
| result = map.MaxZoom; |
| } |
| if(result < map.MinZoom) |
| { |
| result = map.MinZoom; |
| } |
| return result; |
| } |
| else |
| { |
| return value; |
| } |
| } |
| private ScaleModes scaleMode = ScaleModes.Integer; |
| /// <summary> |
| /// Specifies, if a floating map scale is displayed using a |
| /// stretched, or a narrowed map. |
| /// If <code>ScaleMode</code> is <code>ScaleDown</code>, |
| /// then a scale of 12.3 is displayed using a map zoom level of 13 |
| /// resized to the lower level. If the parameter is <code>ScaleUp</code> , |
| /// then the same scale is displayed using a zoom level of 12 with an |
| /// enlarged scale. If the value is <code>Dynamic</code>, then until a |
| /// remainder of 0.25 <code>ScaleUp</code> is applied, for bigger |
| /// remainders <code>ScaleDown</code>. |
| /// </summary> |
| [Category("GMap.NET")] |
| [Description("map scale type")] |
| public ScaleModes ScaleMode |
| { |
| get |
| { |
| return scaleMode; |
| } |
| set |
| { |
| scaleMode = value; |
| InvalidateVisual(); |
| } |
| } |
| private static void ZoomPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) |
| { |
| GMapControl map = (GMapControl)d; |
| if(map != null && map.MapProvider.Projection != null) |
| { |
| double value = (double)e.NewValue; |
| Debug.WriteLine("Zoom: " + e.OldValue + " -> " + value); |
| double remainder = value % 1; |
| if(map.ScaleMode != ScaleModes.Integer && remainder != 0 && map.ActualWidth > 0) |
| { |
| bool scaleDown; |
| switch(map.ScaleMode) |
| { |
| case ScaleModes.ScaleDown: |
| scaleDown = true; |
| break; |
| case ScaleModes.Dynamic: |
| scaleDown = remainder > 0.25; |
| break; |
| default: |
| scaleDown = false; |
| break; |
| } |
| if(scaleDown) |
| remainder--; |
| double scaleValue = Math.Pow(2d, remainder); |
| { |
| if(map.MapScaleTransform == null) |
| { |
| map.MapScaleTransform = map.lastScaleTransform; |
| } |
| map.MapScaleTransform.ScaleX = scaleValue; |
| map.MapScaleTransform.ScaleY = scaleValue; |
| map.Core.scaleX = 1 / scaleValue; |
| map.Core.scaleY = 1 / scaleValue; |
| map.MapScaleTransform.CenterX = map.ActualWidth / 2; |
| map.MapScaleTransform.CenterY = map.ActualHeight / 2; |
| } |
| map.Core.Zoom = Convert.ToInt32(scaleDown ? Math.Ceiling(value) : value - remainder); |
| } |
| else |
| { |
| map.MapScaleTransform = null; |
| map.Core.scaleX = 1; |
| map.Core.scaleY = 1; |
| map.Core.Zoom = (int)Math.Floor(value); |
| } |
| if(map.IsLoaded) |
| { |
| map.ForceUpdateOverlays(); |
| map.InvalidateVisual(true); |
| } |
| } |
| } |
| readonly ScaleTransform lastScaleTransform = new ScaleTransform(); |
| #endregion |
| readonly Core Core = new Core(); |
| //GRect region; |
| delegate void MethodInvoker(); |
| PointLatLng selectionStart; |
| PointLatLng selectionEnd; |
| Typeface tileTypeface = new Typeface("Arial"); |
| bool showTileGridLines = false; |
| FormattedText Copyright; |
| /// <summary> |
| /// enables filling empty tiles using lower level images |
| /// </summary> |
| [Browsable(false)] |
| public bool FillEmptyTiles |
| { |
| get |
| { |
| return Core.fillEmptyTiles; |
| } |
| set |
| { |
| Core.fillEmptyTiles = value; |
| } |
| } |
| /// <summary> |
| /// max zoom |
| /// </summary> |
| [Category("GMap.NET")] |
| [Description("maximum zoom level of map")] |
| public int MaxZoom |
| { |
| get |
| { |
| return Core.maxZoom; |
| } |
| set |
| { |
| Core.maxZoom = value; |
| } |
| } |
| /// <summary> |
| /// min zoom |
| /// </summary> |
| [Category("GMap.NET")] |
| [Description("minimum zoom level of map")] |
| public int MinZoom |
| { |
| get |
| { |
| return Core.minZoom; |
| } |
| set |
| { |
| Core.minZoom = value; |
| } |
| } |
| /// <summary> |
| /// pen for empty tile borders |
| /// </summary> |
| public Pen EmptyTileBorders = new Pen(Brushes.White, 1.0); |
| /// <summary> |
| /// pen for Selection |
| /// </summary> |
| public Pen SelectionPen = new Pen(Brushes.Blue, 2.0); |
| /// <summary> |
| /// background of selected area |
| /// </summary> |
| public Brush SelectedAreaFill = new SolidColorBrush(Color.FromArgb(33, Colors.RoyalBlue.R, Colors.RoyalBlue.G, Colors.RoyalBlue.B)); |
| /// <summary> |
| /// /// <summary> |
| /// pen for empty tile background |
| /// </summary> |
| public Brush EmptytileBrush = Brushes.Navy; |
| /// <summary> |
| /// text on empty tiles |
| /// </summary> |
| public FormattedText EmptyTileText = new FormattedText("We are sorry, but we don't\nhave imagery at this zoom\n level for this region.", System.Globalization.CultureInfo.CurrentUICulture, FlowDirection.LeftToRight, new Typeface("Arial"), 16, Brushes.Blue); |
| /// <summary> |
| /// map zooming type for mouse wheel |
| /// </summary> |
| [Category("GMap.NET")] |
| [Description("map zooming type for mouse wheel")] |
| public MouseWheelZoomType MouseWheelZoomType |
| { |
| get |
| { |
| return Core.MouseWheelZoomType; |
| } |
| set |
| { |
| Core.MouseWheelZoomType = value; |
| } |
| } |
| /// <summary> |
| /// enable map zoom on mouse wheel |
| /// </summary> |
| [Category("GMap.NET")] |
| [Description("enable map zoom on mouse wheel")] |
| public bool MouseWheelZoomEnabled |
| { |
| get |
| { |
| return Core.MouseWheelZoomEnabled; |
| } |
| set |
| { |
| Core.MouseWheelZoomEnabled = value; |
| } |
| } |
| /// <summary> |
| /// map dragg button |
| /// </summary> |
| [Category("GMap.NET")] |
| public MouseButton DragButton = MouseButton.Right; |
| /// <summary> |
| /// use circle for selection |
| /// </summary> |
| public bool SelectionUseCircle = false; |
| /// <summary> |
| /// shows tile gridlines |
| /// </summary> |
| [Category("GMap.NET")] |
| public bool ShowTileGridLines |
| { |
| get |
| { |
| return showTileGridLines; |
| } |
| set |
| { |
| showTileGridLines = value; |
| InvalidateVisual(); |
| } |
| } |
| /// <summary> |
| /// retry count to get tile |
| /// </summary> |
| [Browsable(false)] |
| public int RetryLoadTile |
| { |
| get |
| { |
| return Core.RetryLoadTile; |
| } |
| set |
| { |
| Core.RetryLoadTile = value; |
| } |
| } |
| /// <summary> |
| /// how many levels of tiles are staying decompresed in memory |
| /// </summary> |
| [Browsable(false)] |
| public int LevelsKeepInMemmory |
| { |
| get |
| { |
| return Core.LevelsKeepInMemmory; |
| } |
| set |
| { |
| Core.LevelsKeepInMemmory = value; |
| } |
| } |
| /// <summary> |
| /// current selected area in map |
| /// </summary> |
| private RectLatLng selectedArea; |
| [Browsable(false)] |
| public RectLatLng SelectedArea |
| { |
| get |
| { |
| return selectedArea; |
| } |
| set |
| { |
| selectedArea = value; |
| InvalidateVisual(); |
| } |
| } |
| /// <summary> |
| /// is touch control enabled |
| /// </summary> |
| public bool TouchEnabled = true; |
| /// <summary> |
| /// map boundaries |
| /// </summary> |
| public RectLatLng? BoundsOfMap = null; |
| /// <summary> |
| /// occurs when mouse selection is changed |
| /// </summary> |
| public event SelectionChange OnSelectionChange; |
| /// <summary> |
| /// list of markers |
| /// </summary> |
| public readonly ObservableCollection<GMapMarker> Markers = new ObservableCollection<GMapMarker>(); |
| /// <summary> |
| /// current markers overlay offset |
| /// </summary> |
| internal readonly TranslateTransform MapTranslateTransform = new TranslateTransform(); |
| internal readonly TranslateTransform MapOverlayTranslateTransform = new TranslateTransform(); |
| internal ScaleTransform MapScaleTransform = new ScaleTransform(); |
| internal RotateTransform MapRotateTransform = new RotateTransform(); |
| protected bool DesignModeInConstruct |
| { |
| get |
| { |
| return System.ComponentModel.DesignerProperties.GetIsInDesignMode(this); |
| } |
| } |
| Canvas mapCanvas = null; |
| /// <summary> |
| /// markers overlay |
| /// </summary> |
| internal Canvas MapCanvas |
| { |
| get |
| { |
| if(mapCanvas == null) |
| { |
| if(this.VisualChildrenCount > 0) |
| { |
| Border border = VisualTreeHelper.GetChild(this, 0) as Border; |
| ItemsPresenter items = border.Child as ItemsPresenter; |
| DependencyObject target = VisualTreeHelper.GetChild(items, 0); |
| mapCanvas = target as Canvas; |
| mapCanvas.RenderTransform = MapTranslateTransform; |
| } |
| } |
| return mapCanvas; |
| } |
| } |
| public GMaps Manager |
| { |
| get |
| { |
| return GMaps.Instance; |
| } |
| } |
| static DataTemplate DataTemplateInstance; |
| static ItemsPanelTemplate ItemsPanelTemplateInstance; |
| static Style StyleInstance; |
| public GMapControl() |
| { |
| if(!DesignModeInConstruct) |
| { |
| #region -- templates -- |
| #region -- xaml -- |
| // <ItemsControl Name="figures"> |
| // <ItemsControl.ItemTemplate> |
| // <DataTemplate> |
| // <ContentPresenter Content="{Binding Path=Shape}" /> |
| // </DataTemplate> |
| // </ItemsControl.ItemTemplate> |
| // <ItemsControl.ItemsPanel> |
| // <ItemsPanelTemplate> |
| // <Canvas /> |
| // </ItemsPanelTemplate> |
| // </ItemsControl.ItemsPanel> |
| // <ItemsControl.ItemContainerStyle> |
| // <Style> |
| // <Setter Property="Canvas.Left" Value="{Binding Path=LocalPositionX}"/> |
| // <Setter Property="Canvas.Top" Value="{Binding Path=LocalPositionY}"/> |
| // </Style> |
| // </ItemsControl.ItemContainerStyle> |
| //</ItemsControl> |
| #endregion |
| if(DataTemplateInstance == null) |
| { |
| DataTemplateInstance = new DataTemplate(typeof(GMapMarker)); |
| { |
| FrameworkElementFactory fef = new FrameworkElementFactory(typeof(ContentPresenter)); |
| fef.SetBinding(ContentPresenter.ContentProperty, new Binding("Shape")); |
| DataTemplateInstance.VisualTree = fef; |
| } |
| } |
| ItemTemplate = DataTemplateInstance; |
| if(ItemsPanelTemplateInstance == null) |
| { |
| var factoryPanel = new FrameworkElementFactory(typeof(Canvas)); |
| { |
| factoryPanel.SetValue(Canvas.IsItemsHostProperty, true); |
| ItemsPanelTemplateInstance = new ItemsPanelTemplate(); |
| { |
| ItemsPanelTemplateInstance.VisualTree = factoryPanel; |
| } |
| } |
| } |
| ItemsPanel = ItemsPanelTemplateInstance; |
| if(StyleInstance == null) |
| { |
| StyleInstance = new Style(); |
| { |
| StyleInstance.Setters.Add(new Setter(Canvas.LeftProperty, new Binding("LocalPositionX"))); |
| StyleInstance.Setters.Add(new Setter(Canvas.TopProperty, new Binding("LocalPositionY"))); |
| StyleInstance.Setters.Add(new Setter(Canvas.ZIndexProperty, new Binding("ZIndex"))); |
| } |
| } |
| ItemContainerStyle = StyleInstance; |
| #endregion |
| ClipToBounds = true; |
| SnapsToDevicePixels = true; |
| Core.SystemType = "WindowsPresentation"; |
| Core.RenderMode = GMap.NET.RenderMode.WPF; |
| Core.OnMapZoomChanged += new MapZoomChanged(ForceUpdateOverlays); |
| Loaded += new RoutedEventHandler(GMapControl_Loaded); |
| Dispatcher.ShutdownStarted += new EventHandler(Dispatcher_ShutdownStarted); |
| SizeChanged += new SizeChangedEventHandler(GMapControl_SizeChanged); |
| // by default its internal property, feel free to use your own |
| if(ItemsSource == null) |
| { |
| ItemsSource = Markers; |
| } |
| Core.Zoom = (int)((double)ZoomProperty.DefaultMetadata.DefaultValue); |
| } |
| } |
| static GMapControl() |
| { |
| GMapImageProxy.Enable(); |
| #if !PocketPC |
| GMaps.Instance.SQLitePing(); |
| #endif |
| } |
| void invalidatorEngage(object sender, ProgressChangedEventArgs e) |
| { |
| base.InvalidateVisual(); |
| } |
| /// <summary> |
| /// enque built-in thread safe invalidation |
| /// </summary> |
| public new void InvalidateVisual() |
| { |
| if(Core.Refresh != null) |
| { |
| Core.Refresh.Set(); |
| } |
| } |
| /// <summary> |
| /// Invalidates the rendering of the element, and forces a complete new layout |
| /// pass. System.Windows.UIElement.OnRender(System.Windows.Media.DrawingContext) |
| /// is called after the layout cycle is completed. If not forced enques built-in thread safe invalidation |
| /// </summary> |
| /// <param name="forced"></param> |
| public void InvalidateVisual(bool forced) |
| { |
| if(forced) |
| { |
| lock(Core.invalidationLock) |
| { |
| Core.lastInvalidation = DateTime.Now; |
| } |
| base.InvalidateVisual(); |
| } |
| else |
| { |
| InvalidateVisual(); |
| } |
| } |
| protected override void OnItemsChanged(System.Collections.Specialized.NotifyCollectionChangedEventArgs e) |
| { |
| base.OnItemsChanged(e); |
| if(e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add) |
| { |
| ForceUpdateOverlays(e.NewItems); |
| } |
| else |
| { |
| InvalidateVisual(); |
| } |
| } |
| /// <summary> |
| /// inits core system |
| /// </summary> |
| /// <param name="sender"></param> |
| /// <param name="e"></param> |
| void GMapControl_Loaded(object sender, RoutedEventArgs e) |
| { |
| if(!Core.IsStarted) |
| { |
| if(lazyEvents) |
| { |
| lazyEvents = false; |
| if(lazySetZoomToFitRect.HasValue) |
| { |
| SetZoomToFitRect(lazySetZoomToFitRect.Value); |
| lazySetZoomToFitRect = null; |
| } |
| } |
| Core.OnMapOpen().ProgressChanged += new ProgressChangedEventHandler(invalidatorEngage); |
| ForceUpdateOverlays(); |
| if(Application.Current != null) |
| { |
| loadedApp = Application.Current; |
| loadedApp.Dispatcher.Invoke(DispatcherPriority.ApplicationIdle, |
| new Action(delegate() |
| { |
| loadedApp.SessionEnding += new SessionEndingCancelEventHandler(Current_SessionEnding); |
| } |
| )); |
| } |
| } |
| } |
| Application loadedApp; |
| void Current_SessionEnding(object sender, SessionEndingCancelEventArgs e) |
| { |
| GMaps.Instance.CancelTileCaching(); |
| } |
| void Dispatcher_ShutdownStarted(object sender, EventArgs e) |
| { |
| Dispose(); |
| } |
| /// <summary> |
| /// recalculates size |
| /// </summary> |
| /// <param name="sender"></param> |
| /// <param name="e"></param> |
| void GMapControl_SizeChanged(object sender, SizeChangedEventArgs e) |
| { |
| System.Windows.Size constraint = e.NewSize; |
| // 50px outside control |
| //region = new GRect(-50, -50, (int)constraint.Width + 100, (int)constraint.Height + 100); |
| Core.OnMapSizeChanged((int)constraint.Width, (int)constraint.Height); |
| if(Core.IsStarted) |
| { |
| if(IsRotated) |
| { |
| UpdateRotationMatrix(); |
| } |
| ForceUpdateOverlays(); |
| } |
| } |
| void ForceUpdateOverlays() |
| { |
| ForceUpdateOverlays(ItemsSource); |
| } |
| void ForceUpdateOverlays(System.Collections.IEnumerable items) |
| { |
| using(Dispatcher.DisableProcessing()) |
| { |
| UpdateMarkersOffset(); |
| foreach(GMapMarker i in items) |
| { |
| if(i != null) |
| { |
| i.ForceUpdateLocalPosition(this); |
| if(i is IShapable) |
| { |
| (i as IShapable).RegenerateShape(this); |
| } |
| } |
| } |
| } |
| InvalidateVisual(); |
| } |
| /// <summary> |
| /// updates markers overlay offset |
| /// </summary> |
| void UpdateMarkersOffset() |
| { |
| if(MapCanvas != null) |
| { |
| if(MapScaleTransform != null) |
| { |
| var tp = MapScaleTransform.Transform(new System.Windows.Point(Core.renderOffset.X, Core.renderOffset.Y)); |
| MapOverlayTranslateTransform.X = tp.X; |
| MapOverlayTranslateTransform.Y = tp.Y; |
| // map is scaled already |
| MapTranslateTransform.X = Core.renderOffset.X; |
| MapTranslateTransform.Y = Core.renderOffset.Y; |
| } |
| else |
| { |
| MapTranslateTransform.X = Core.renderOffset.X; |
| MapTranslateTransform.Y = Core.renderOffset.Y; |
| MapOverlayTranslateTransform.X = MapTranslateTransform.X; |
| MapOverlayTranslateTransform.Y = MapTranslateTransform.Y; |
| } |
| } |
| } |
| public Brush EmptyMapBackground = Brushes.WhiteSmoke; |
| /// <summary> |
| /// render map in WPF |
| /// </summary> |
| /// <param name="g"></param> |
| void DrawMap(DrawingContext g) |
| { |
| if(MapProvider == EmptyProvider.Instance || MapProvider == null) |
| { |
| return; |
| } |
| Core.tileDrawingListLock.AcquireReaderLock(); |
| Core.Matrix.EnterReadLock(); |
| try |
| { |
| foreach(var tilePoint in Core.tileDrawingList) |
| { |
| Core.tileRect.Location = tilePoint.PosPixel; |
| Core.tileRect.OffsetNegative(Core.compensationOffset); |
| //if(region.IntersectsWith(Core.tileRect) || IsRotated) |
| { |
| bool found = false; |
| Tile t = Core.Matrix.GetTileWithNoLock(Core.Zoom, tilePoint.PosXY); |
| if(t.NotEmpty) |
| { |
| foreach(GMapImage img in t.Overlays) |
| { |
| if(img != null && img.Img != null) |
| { |
| if(!found) |
| found = true; |
| var imgRect = new Rect(Core.tileRect.X + 0.6, Core.tileRect.Y + 0.6, Core.tileRect.Width + 0.6, Core.tileRect.Height + 0.6); |
| if(!img.IsParent) |
| { |
| g.DrawImage(img.Img, imgRect); |
| } |
| else |
| { |
| // TODO: move calculations to loader thread |
| var geometry = new RectangleGeometry(imgRect); |
| var parentImgRect = new Rect(Core.tileRect.X - Core.tileRect.Width * img.Xoff + 0.6, Core.tileRect.Y - Core.tileRect.Height * img.Yoff + 0.6, Core.tileRect.Width * img.Ix + 0.6, Core.tileRect.Height * img.Ix + 0.6); |
| g.PushClip(geometry); |
| g.DrawImage(img.Img, parentImgRect); |
| g.Pop(); |
| geometry = null; |
| } |
| } |
| } |
| } |
| else if(FillEmptyTiles && MapProvider.Projection is MercatorProjection) |
| { |
| #region -- fill empty tiles -- |
| int zoomOffset = 1; |
| Tile parentTile = Tile.Empty; |
| long Ix = 0; |
| while(!parentTile.NotEmpty && zoomOffset < Core.Zoom && zoomOffset <= LevelsKeepInMemmory) |
| { |
| Ix = (long)Math.Pow(2, zoomOffset); |
| parentTile = Core.Matrix.GetTileWithNoLock(Core.Zoom - zoomOffset++, new GMap.NET.GPoint((int)(tilePoint.PosXY.X / Ix), (int)(tilePoint.PosXY.Y / Ix))); |
| } |
| if(parentTile.NotEmpty) |
| { |
| long Xoff = Math.Abs(tilePoint.PosXY.X - (parentTile.Pos.X * Ix)); |
| long Yoff = Math.Abs(tilePoint.PosXY.Y - (parentTile.Pos.Y * Ix)); |
| var geometry = new RectangleGeometry(new Rect(Core.tileRect.X + 0.6, Core.tileRect.Y + 0.6, Core.tileRect.Width + 0.6, Core.tileRect.Height + 0.6)); |
| var parentImgRect = new Rect(Core.tileRect.X - Core.tileRect.Width * Xoff + 0.6, Core.tileRect.Y - Core.tileRect.Height * Yoff + 0.6, Core.tileRect.Width * Ix + 0.6, Core.tileRect.Height * Ix + 0.6); |
| // render tile |
| { |
| foreach(GMapImage img in parentTile.Overlays) |
| { |
| if(img != null && img.Img != null && !img.IsParent) |
| { |
| if(!found) |
| found = true; |
| g.PushClip(geometry); |
| g.DrawImage(img.Img, parentImgRect); |
| g.DrawRectangle(SelectedAreaFill, null, geometry.Bounds); |
| g.Pop(); |
| } |
| } |
| } |
| geometry = null; |
| } |
| #endregion |
| } |
| // add text if tile is missing |
| if(!found) |
| { |
| lock(Core.FailedLoads) |
| { |
| var lt = new LoadTask(tilePoint.PosXY, Core.Zoom); |
| if(Core.FailedLoads.ContainsKey(lt)) |
| { |
| g.DrawRectangle(EmptytileBrush, EmptyTileBorders, new Rect(Core.tileRect.X, Core.tileRect.Y, Core.tileRect.Width, Core.tileRect.Height)); |
| var ex = Core.FailedLoads[lt]; |
| FormattedText TileText = new FormattedText("Exception: " + ex.Message, System.Globalization.CultureInfo.CurrentUICulture, FlowDirection.LeftToRight, tileTypeface, 14, Brushes.Red); |
| TileText.MaxTextWidth = Core.tileRect.Width - 11; |
| g.DrawText(TileText, new System.Windows.Point(Core.tileRect.X + 11, Core.tileRect.Y + 11)); |
| g.DrawText(EmptyTileText, new System.Windows.Point(Core.tileRect.X + Core.tileRect.Width / 2 - EmptyTileText.Width / 2, Core.tileRect.Y + Core.tileRect.Height / 2 - EmptyTileText.Height / 2)); |
| } |
| } |
| } |
| if(ShowTileGridLines) |
| { |
| g.DrawRectangle(null, EmptyTileBorders, new Rect(Core.tileRect.X, Core.tileRect.Y, Core.tileRect.Width, Core.tileRect.Height)); |
| if(tilePoint.PosXY == Core.centerTileXYLocation) |
| { |
| FormattedText TileText = new FormattedText("CENTER:" + tilePoint.ToString(), System.Globalization.CultureInfo.CurrentUICulture, FlowDirection.LeftToRight, tileTypeface, 16, Brushes.Red); |
| TileText.MaxTextWidth = Core.tileRect.Width; |
| g.DrawText(TileText, new System.Windows.Point(Core.tileRect.X + Core.tileRect.Width / 2 - EmptyTileText.Width / 2, Core.tileRect.Y + Core.tileRect.Height / 2 - TileText.Height / 2)); |
| } |
| else |
| { |
| FormattedText TileText = new FormattedText("TILE: " + tilePoint.ToString(), System.Globalization.CultureInfo.CurrentUICulture, FlowDirection.LeftToRight, tileTypeface, 16, Brushes.Red); |
| TileText.MaxTextWidth = Core.tileRect.Width; |
| g.DrawText(TileText, new System.Windows.Point(Core.tileRect.X + Core.tileRect.Width / 2 - EmptyTileText.Width / 2, Core.tileRect.Y + Core.tileRect.Height / 2 - TileText.Height / 2)); |
| } |
| } |
| } |
| } |
| } |
| finally |
| { |
| Core.Matrix.LeaveReadLock(); |
| Core.tileDrawingListLock.ReleaseReaderLock(); |
| } |
| } |
| /// <summary> |
| /// gets image of the current view |
| /// </summary> |
| /// <returns></returns> |
| public ImageSource ToImageSource() |
| { |
| FrameworkElement obj = this; |
| // Save current canvas transform |
| Transform transform = obj.LayoutTransform; |
| obj.LayoutTransform = null; |
| // fix margin offset as well |
| Thickness margin = obj.Margin; |
| obj.Margin = new Thickness(0, 0, |
| margin.Right - margin.Left, margin.Bottom - margin.Top); |
| // Get the size of canvas |
| Size size = new Size(obj.ActualWidth, obj.ActualHeight); |
| // force control to Update |
| obj.Measure(size); |
| obj.Arrange(new Rect(size)); |
| RenderTargetBitmap bmp = new RenderTargetBitmap( |
| (int)size.Width, (int)size.Height, 96, 96, PixelFormats.Pbgra32); |
| bmp.Render(obj); |
| if(bmp.CanFreeze) |
| { |
| bmp.Freeze(); |
| } |
| // return values as they were before |
| obj.LayoutTransform = transform; |
| obj.Margin = margin; |
| return bmp; |
| } |
| /// <summary> |
| /// creates path from list of points, for performance set addBlurEffect to false |
| /// </summary> |
| /// <param name="pl"></param> |
| /// <returns></returns> |
| public virtual Path CreateRoutePath(List<Point> localPath) |
| { |
| return CreateRoutePath(localPath, true); |
| } |
| /// <summary> |
| /// creates path from list of points, for performance set addBlurEffect to false |
| /// </summary> |
| /// <param name="pl"></param> |
| /// <returns></returns> |
| public virtual Path CreateRoutePath(List<Point> localPath, bool addBlurEffect) |
| { |
| // Create a StreamGeometry to use to specify myPath. |
| StreamGeometry geometry = new StreamGeometry(); |
| using(StreamGeometryContext ctx = geometry.Open()) |
| { |
| ctx.BeginFigure(localPath[0], false, false); |
| // Draw a line to the next specified point. |
| ctx.PolyLineTo(localPath, true, true); |
| } |
| // Freeze the geometry (make it unmodifiable) |
| // for additional performance benefits. |
| geometry.Freeze(); |
| // Create a path to draw a geometry with. |
| Path myPath = new Path(); |
| { |
| // Specify the shape of the Path using the StreamGeometry. |
| myPath.Data = geometry; |
| if (addBlurEffect) |
| { |
| BlurEffect ef = new BlurEffect(); |
| { |
| ef.KernelType = KernelType.Gaussian; |
| ef.Radius = 3.0; |
| ef.RenderingBias = RenderingBias.Performance; |
| } |
| myPath.Effect = ef; |
| } |
| myPath.Stroke = Brushes.Navy; |
| myPath.StrokeThickness = 5; |
| myPath.StrokeLineJoin = PenLineJoin.Round; |
| myPath.StrokeStartLineCap = PenLineCap.Triangle; |
| myPath.StrokeEndLineCap = PenLineCap.Square; |
| myPath.Opacity = 0.6; |
| myPath.IsHitTestVisible = false; |
| } |
| return myPath; |
| } |
| /// <summary> |
| /// creates path from list of points, for performance set addBlurEffect to false |
| /// </summary> |
| /// <param name="pl"></param> |
| /// <returns></returns> |
| public virtual Path CreatePolygonPath(List<Point> localPath) |
| { |
| return CreatePolygonPath(localPath, false); |
| } |
| /// <summary> |
| /// creates path from list of points, for performance set addBlurEffect to false |
| /// </summary> |
| /// <param name="pl"></param> |
| /// <returns></returns> |
| public virtual Path CreatePolygonPath(List<Point> localPath, bool addBlurEffect) |
| { |
| // Create a StreamGeometry to use to specify myPath. |
| StreamGeometry geometry = new StreamGeometry(); |
| using(StreamGeometryContext ctx = geometry.Open()) |
| { |
| ctx.BeginFigure(localPath[0], true, true); |
| // Draw a line to the next specified point. |
| ctx.PolyLineTo(localPath, true, true); |
| } |
| // Freeze the geometry (make it unmodifiable) |
| // for additional performance benefits. |
| geometry.Freeze(); |
| // Create a path to draw a geometry with. |
| Path myPath = new Path(); |
| { |
| // Specify the shape of the Path using the StreamGeometry. |
| myPath.Data = geometry; |
| if (addBlurEffect) |
| { |
| BlurEffect ef = new BlurEffect(); |
| { |
| ef.KernelType = KernelType.Gaussian; |
| ef.Radius = 3.0; |
| ef.RenderingBias = RenderingBias.Performance; |
| } |
| myPath.Effect = ef; |
| } |
| myPath.Stroke = Brushes.MidnightBlue; |
| myPath.StrokeThickness = 5; |
| myPath.StrokeLineJoin = PenLineJoin.Round; |
| myPath.StrokeStartLineCap = PenLineCap.Triangle; |
| myPath.StrokeEndLineCap = PenLineCap.Square; |
| myPath.Fill = Brushes.AliceBlue; |
| myPath.Opacity = 0.6; |
| myPath.IsHitTestVisible = false; |
| } |
| return myPath; |
| } |
| /// <summary> |
| /// sets zoom to max to fit rect |
| /// </summary> |
| /// <param name="rect">area</param> |
| /// <returns></returns> |
| public bool SetZoomToFitRect(RectLatLng rect) |
| { |
| if(lazyEvents) |
| { |
| lazySetZoomToFitRect = rect; |
| } |
| else |
| { |
| int maxZoom = Core.GetMaxZoomToFitRect(rect); |
| if(maxZoom > 0) |
| { |
| PointLatLng center = new PointLatLng(rect.Lat - (rect.HeightLat / 2), rect.Lng + (rect.WidthLng / 2)); |
| Position = center; |
| if(maxZoom > MaxZoom) |
| { |
| maxZoom = MaxZoom; |
| } |
| if(Core.Zoom != maxZoom) |
| { |
| Zoom = maxZoom; |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
| RectLatLng? lazySetZoomToFitRect = null; |
| bool lazyEvents = true; |
| /// <summary> |
| /// sets to max zoom to fit all markers and centers them in map |
| /// </summary> |
| /// <param name="ZIndex">z index or null to check all</param> |
| /// <returns></returns> |
| public bool ZoomAndCenterMarkers(int? ZIndex) |
| { |
| RectLatLng? rect = GetRectOfAllMarkers(ZIndex); |
| if(rect.HasValue) |
| { |
| return SetZoomToFitRect(rect.Value); |
| } |
| return false; |
| } |
| /// <summary> |
| /// gets rectangle with all objects inside |
| /// </summary> |
| /// <param name="ZIndex">z index or null to check all</param> |
| /// <returns></returns> |
| public RectLatLng? GetRectOfAllMarkers(int? ZIndex) |
| { |
| RectLatLng? ret = null; |
| double left = double.MaxValue; |
| double top = double.MinValue; |
| double right = double.MinValue; |
| double bottom = double.MaxValue; |
| IEnumerable<GMapMarker> Overlays; |
| if(ZIndex.HasValue) |
| { |
| Overlays = ItemsSource.Cast<GMapMarker>().Where(p => p != null && p.ZIndex == ZIndex); |
| } |
| else |
| { |
| Overlays = ItemsSource.Cast<GMapMarker>(); |
| } |
| if(Overlays != null) |
| { |
| foreach(var m in Overlays) |
| { |
| if(m.Shape != null && m.Shape.Visibility == System.Windows.Visibility.Visible) |
| { |
| // left |
| if(m.Position.Lng < left) |
| { |
| left = m.Position.Lng; |
| } |
| // top |
| if(m.Position.Lat > top) |
| { |
| top = m.Position.Lat; |
| } |
| // right |
| if(m.Position.Lng > right) |
| { |
| right = m.Position.Lng; |
| } |
| // bottom |
| if(m.Position.Lat < bottom) |
| { |
| bottom = m.Position.Lat; |
| } |
| } |
| } |
| } |
| if(left != double.MaxValue && right != double.MinValue && top != double.MinValue && bottom != double.MaxValue) |
| { |
| ret = RectLatLng.FromLTRB(left, top, right, bottom); |
| } |
| return ret; |
| } |
| /// <summary> |
| /// offset position in pixels |
| /// </summary> |
| /// <param name="x"></param> |
| /// <param name="y"></param> |
| public void Offset(int x, int y) |
| { |
| if(IsLoaded) |
| { |
| if(IsRotated) |
| { |
| Point p = new Point(x, y); |
| p = rotationMatrixInvert.Transform(p); |
| x = (int)p.X; |
| y = (int)p.Y; |
| Core.DragOffset(new GPoint(x, y)); |
| ForceUpdateOverlays(); |
| } |
| else |
| { |
| Core.DragOffset(new GPoint(x, y)); |
| UpdateMarkersOffset(); |
| InvalidateVisual(true); |
| } |
| } |
| } |
| readonly RotateTransform rotationMatrix = new RotateTransform(); |
| GeneralTransform rotationMatrixInvert = new RotateTransform(); |
| /// <summary> |
| /// updates rotation matrix |
| /// </summary> |
| void UpdateRotationMatrix() |
| { |
| System.Windows.Point center = new System.Windows.Point(ActualWidth / 2.0, ActualHeight / 2.0); |
| rotationMatrix.Angle = -Bearing; |
| rotationMatrix.CenterY = center.Y; |
| rotationMatrix.CenterX = center.X; |
| rotationMatrixInvert = rotationMatrix.Inverse; |
| } |
| /// <summary> |
| /// returs true if map bearing is not zero |
| /// </summary> |
| public bool IsRotated |
| { |
| get |
| { |
| return Core.IsRotated; |
| } |
| } |
| /// <summary> |
| /// bearing for rotation of the map |
| /// </summary> |
| [Category("GMap.NET")] |
| public float Bearing |
| { |
| get |
| { |
| return Core.bearing; |
| } |
| set |
| { |
| if(Core.bearing != value) |
| { |
| bool resize = Core.bearing == 0; |
| Core.bearing = value; |
| UpdateRotationMatrix(); |
| if(value != 0 && value % 360 != 0) |
| { |
| Core.IsRotated = true; |
| if(Core.tileRectBearing.Size == Core.tileRect.Size) |
| { |
| Core.tileRectBearing = Core.tileRect; |
| Core.tileRectBearing.Inflate(1, 1); |
| } |
| } |
| else |
| { |
| Core.IsRotated = false; |
| Core.tileRectBearing = Core.tileRect; |
| } |
| if(resize) |
| { |
| Core.OnMapSizeChanged((int)ActualWidth, (int)ActualHeight); |
| } |
| if(Core.IsStarted) |
| { |
| ForceUpdateOverlays(); |
| } |
| } |
| } |
| } |
| /// <summary> |
| /// apply transformation if in rotation mode |
| /// </summary> |
| System.Windows.Point ApplyRotation(double x, double y) |
| { |
| System.Windows.Point ret = new System.Windows.Point(x, y); |
| if(IsRotated) |
| { |
| ret = rotationMatrix.Transform(ret); |
| } |
| return ret; |
| } |
| /// <summary> |
| /// apply transformation if in rotation mode |
| /// </summary> |
| System.Windows.Point ApplyRotationInversion(double x, double y) |
| { |
| System.Windows.Point ret = new System.Windows.Point(x, y); |
| if(IsRotated) |
| { |
| ret = rotationMatrixInvert.Transform(ret); |
| } |
| return ret; |
| } |
| #region UserControl Events |
| protected override void OnRender(DrawingContext drawingContext) |
| { |
| if(!Core.IsStarted) |
| return; |
| drawingContext.DrawRectangle(EmptyMapBackground, null, new Rect(RenderSize)); |
| if(IsRotated) |
| { |
| drawingContext.PushTransform(rotationMatrix); |
| if(MapScaleTransform != null) |
| { |
| drawingContext.PushTransform(MapScaleTransform); |
| drawingContext.PushTransform(MapTranslateTransform); |
| { |
| DrawMap(drawingContext); |
| } |
| drawingContext.Pop(); |
| drawingContext.Pop(); |
| } |
| else |
| { |
| drawingContext.PushTransform(MapTranslateTransform); |
| { |
| DrawMap(drawingContext); |
| } |
| drawingContext.Pop(); |
| } |
| drawingContext.Pop(); |
| } |
| else |
| { |
| if(MapScaleTransform != null) |
| { |
| drawingContext.PushTransform(MapScaleTransform); |
| drawingContext.PushTransform(MapTranslateTransform); |
| { |
| DrawMap(drawingContext); |
| #if DEBUG |
| drawingContext.DrawLine(VirtualCenterCrossPen, new Point(-20, 0), new Point(20, 0)); |
| drawingContext.DrawLine(VirtualCenterCrossPen, new Point(0, -20), new Point(0, 20)); |
| #endif |
| } |
| drawingContext.Pop(); |
| drawingContext.Pop(); |
| } |
| else |
| { |
| drawingContext.PushTransform(MapTranslateTransform); |
| { |
| DrawMap(drawingContext); |
| #if DEBUG |
| drawingContext.DrawLine(VirtualCenterCrossPen, new Point(-20, 0), new Point(20, 0)); |
| drawingContext.DrawLine(VirtualCenterCrossPen, new Point(0, -20), new Point(0, 20)); |
| #endif |
| } |
| drawingContext.Pop(); |
| } |
| } |
| // selection |
| if(!SelectedArea.IsEmpty) |
| { |
| GPoint p1 = FromLatLngToLocal(SelectedArea.LocationTopLeft); |
| GPoint p2 = FromLatLngToLocal(SelectedArea.LocationRightBottom); |
| long x1 = p1.X; |
| long y1 = p1.Y; |
| long x2 = p2.X; |
| long y2 = p2.Y; |
| if(SelectionUseCircle) |
| { |
| drawingContext.DrawEllipse(SelectedAreaFill, SelectionPen, new System.Windows.Point(x1 + (x2 - x1) / 2, y1 + (y2 - y1) / 2), (x2 - x1) / 2, (y2 - y1) / 2); |
| } |
| else |
| { |
| drawingContext.DrawRoundedRectangle(SelectedAreaFill, SelectionPen, new Rect(x1, y1, x2 - x1, y2 - y1), 5, 5); |
| } |
| } |
| if(ShowCenter) |
| { |
| drawingContext.DrawLine(CenterCrossPen, new System.Windows.Point((ActualWidth / 2) - 5, ActualHeight / 2), new System.Windows.Point((ActualWidth / 2) + 5, ActualHeight / 2)); |
| drawingContext.DrawLine(CenterCrossPen, new System.Windows.Point(ActualWidth / 2, (ActualHeight / 2) - 5), new System.Windows.Point(ActualWidth / 2, (ActualHeight / 2) + 5)); |
| } |
| if(renderHelperLine) |
| { |
| var p = Mouse.GetPosition(this); |
| drawingContext.DrawLine(HelperLinePen, new Point(p.X, 0), new Point(p.X, ActualHeight)); |
| drawingContext.DrawLine(HelperLinePen, new Point(0, p.Y), new Point(ActualWidth, p.Y)); |
| } |
| #region -- copyright -- |
| if(Copyright != null) |
| { |
| drawingContext.DrawText(Copyright, new System.Windows.Point(5, ActualHeight - Copyright.Height - 5)); |
| } |
| #endregion |
| base.OnRender(drawingContext); |
| } |
| public Pen CenterCrossPen = new Pen(Brushes.Red, 1); |
| public bool ShowCenter = true; |
| #if DEBUG |
| readonly Pen VirtualCenterCrossPen = new Pen(Brushes.Blue, 1); |
| #endif |
| HelperLineOptions helperLineOption = HelperLineOptions.DontShow; |
| /// <summary> |
| /// draw lines at the mouse pointer position |
| /// </summary> |
| [Browsable(false)] |
| public HelperLineOptions HelperLineOption |
| { |
| get |
| { |
| return helperLineOption; |
| } |
| set |
| { |
| helperLineOption = value; |
| renderHelperLine = (helperLineOption == HelperLineOptions.ShowAlways); |
| if(Core.IsStarted) |
| { |
| InvalidateVisual(); |
| } |
| } |
| } |
| public Pen HelperLinePen = new Pen(Brushes.Blue, 1); |
| bool renderHelperLine = false; |
| protected override void OnKeyUp(KeyEventArgs e) |
| { |
| base.OnKeyUp(e); |
| if(HelperLineOption == HelperLineOptions.ShowOnModifierKey) |
| { |
| renderHelperLine = !(e.IsUp && (e.Key == Key.LeftShift || e.SystemKey == Key.LeftAlt)); |
| if(!renderHelperLine) |
| { |
| InvalidateVisual(); |
| } |
| } |
| } |
| protected override void OnKeyDown(KeyEventArgs e) |
| { |
| base.OnKeyDown(e); |
| if(HelperLineOption == HelperLineOptions.ShowOnModifierKey) |
| { |
| renderHelperLine = e.IsDown && (e.Key == Key.LeftShift || e.SystemKey == Key.LeftAlt); |
| if(renderHelperLine) |
| { |
| InvalidateVisual(); |
| } |
| } |
| } |
| /// <summary> |
| /// reverses MouseWheel zooming direction |
| /// </summary> |
| public bool InvertedMouseWheelZooming = false; |
| /// <summary> |
| /// lets you zoom by MouseWheel even when pointer is in area of marker |
| /// </summary> |
| public bool IgnoreMarkerOnMouseWheel = false; |
| protected override void OnMouseWheel(MouseWheelEventArgs e) |
| { |
| base.OnMouseWheel(e); |
| if(MouseWheelZoomEnabled && (IsMouseDirectlyOver || IgnoreMarkerOnMouseWheel) && !Core.IsDragging) |
| { |
| System.Windows.Point p = e.GetPosition(this); |
| if(MapScaleTransform != null) |
| { |
| p = MapScaleTransform.Inverse.Transform(p); |
| } |
| p = ApplyRotationInversion(p.X, p.Y); |
| if(Core.mouseLastZoom.X != (int)p.X && Core.mouseLastZoom.Y != (int)p.Y) |
| { |
| if(MouseWheelZoomType == MouseWheelZoomType.MousePositionAndCenter) |
| { |
| Core.position = FromLocalToLatLng((int)p.X, (int)p.Y); |
| } |
| else if(MouseWheelZoomType == MouseWheelZoomType.ViewCenter) |
| { |
| Core.position = FromLocalToLatLng((int)ActualWidth / 2, (int)ActualHeight / 2); |
| } |
| else if(MouseWheelZoomType == MouseWheelZoomType.MousePositionWithoutCenter) |
| { |
| Core.position = FromLocalToLatLng((int)p.X, (int)p.Y); |
| } |
| Core.mouseLastZoom.X = (int)p.X; |
| Core.mouseLastZoom.Y = (int)p.Y; |
| } |
| // set mouse position to map center |
| if(MouseWheelZoomType != MouseWheelZoomType.MousePositionWithoutCenter) |
| { |
| System.Windows.Point ps = PointToScreen(new System.Windows.Point(ActualWidth / 2, ActualHeight / 2)); |
| Stuff.SetCursorPos((int)ps.X, (int)ps.Y); |
| } |
| Core.MouseWheelZooming = true; |
| if(e.Delta > 0) |
| { |
| if(!InvertedMouseWheelZooming) |
| { |
| Zoom = ((int)Zoom) + 1; |
| } |
| else |
| { |
| Zoom = ((int)(Zoom + 0.99)) - 1; |
| } |
| } |
| else |
| { |
| if(InvertedMouseWheelZooming) |
| { |
| Zoom = ((int)Zoom) + 1; |
| } |
| else |
| { |
| Zoom = ((int)(Zoom + 0.99)) - 1; |
| } |
| } |
| Core.MouseWheelZooming = false; |
| } |
| } |
| bool isSelected = false; |
| protected override void OnMouseDown(MouseButtonEventArgs e) |
| { |
| base.OnMouseDown(e); |
| if(CanDragMap && e.ChangedButton == DragButton) |
| { |
| Point p = e.GetPosition(this); |
| if(MapScaleTransform != null) |
| { |
| p = MapScaleTransform.Inverse.Transform(p); |
| } |
| p = ApplyRotationInversion(p.X, p.Y); |
| Core.mouseDown.X = (int)p.X; |
| Core.mouseDown.Y = (int)p.Y; |
| InvalidateVisual(); |
| } |
| else |
| { |
| if(!isSelected) |
| { |
| Point p = e.GetPosition(this); |
| isSelected = true; |
| SelectedArea = RectLatLng.Empty; |
| selectionEnd = PointLatLng.Empty; |
| selectionStart = FromLocalToLatLng((int)p.X, (int)p.Y); |
| } |
| } |
| } |
| int onMouseUpTimestamp = 0; |
| protected override void OnMouseUp(MouseButtonEventArgs e) |
| { |
| base.OnMouseUp(e); |
| if(isSelected) |
| { |
| isSelected = false; |
| } |
| if(Core.IsDragging) |
| { |
| if(isDragging) |
| { |
| onMouseUpTimestamp = e.Timestamp & Int32.MaxValue; |
| isDragging = false; |
| Debug.WriteLine("IsDragging = " + isDragging); |
| Cursor = cursorBefore; |
| Mouse.Capture(null); |
| } |
| Core.EndDrag(); |
| if(BoundsOfMap.HasValue && !BoundsOfMap.Value.Contains(Position)) |
| { |
| if(Core.LastLocationInBounds.HasValue) |
| { |
| Position = Core.LastLocationInBounds.Value; |
| } |
| } |
| } |
| else |
| { |
| if(e.ChangedButton == DragButton) |
| { |
| Core.mouseDown = GPoint.Empty; |
| } |
| if(!selectionEnd.IsEmpty && !selectionStart.IsEmpty) |
| { |
| bool zoomtofit = false; |
| if(!SelectedArea.IsEmpty && Keyboard.Modifiers == ModifierKeys.Shift) |
| { |
| zoomtofit = SetZoomToFitRect(SelectedArea); |
| } |
| if(OnSelectionChange != null) |
| { |
| OnSelectionChange(SelectedArea, zoomtofit); |
| } |
| } |
| else |
| { |
| InvalidateVisual(); |
| } |
| } |
| } |
| Cursor cursorBefore = Cursors.Arrow; |
| protected override void OnMouseMove(MouseEventArgs e) |
| { |
| if (CanDragMap) |
| { |
| base.OnMouseMove(e); |
| // wpf generates to many events if mouse is over some visual |
| // and OnMouseUp is fired, wtf, anyway... |
| // http://greatmaps.codeplex.com/workitem/16013 |
| if ((e.Timestamp & Int32.MaxValue) - onMouseUpTimestamp < 55) |
| { |
| Debug.WriteLine("OnMouseMove skipped: " + ((e.Timestamp & Int32.MaxValue) - onMouseUpTimestamp) + "ms"); |
| return; |
| } |
| if (!Core.IsDragging && !Core.mouseDown.IsEmpty) |
| { |
| Point p = e.GetPosition(this); |
| if (MapScaleTransform != null) |
| { |
| p = MapScaleTransform.Inverse.Transform(p); |
| } |
| p = ApplyRotationInversion(p.X, p.Y); |
| // cursor has moved beyond drag tolerance |
| if (Math.Abs(p.X - Core.mouseDown.X) * 2 >= SystemParameters.MinimumHorizontalDragDistance || Math.Abs(p.Y - Core.mouseDown.Y) * 2 >= SystemParameters.MinimumVerticalDragDistance) |
| { |
| Core.BeginDrag(Core.mouseDown); |
| } |
| } |
| if (Core.IsDragging) |
| { |
| if (!isDragging) |
| { |
| isDragging = true; |
| Debug.WriteLine("IsDragging = " + isDragging); |
| cursorBefore = Cursor; |
| Cursor = Cursors.SizeAll; |
| Mouse.Capture(this); |
| } |
| if (BoundsOfMap.HasValue && !BoundsOfMap.Value.Contains(Position)) |
| { |
| // ... |
| } |
| else |
| { |
| Point p = e.GetPosition(this); |
| if (MapScaleTransform != null) |
| { |
| p = MapScaleTransform.Inverse.Transform(p); |
| } |
| p = ApplyRotationInversion(p.X, p.Y); |
| Core.mouseCurrent.X = (int)p.X; |
| Core.mouseCurrent.Y = (int)p.Y; |
| { |
| Core.Drag(Core.mouseCurrent); |
| } |
| if (IsRotated || scaleMode != ScaleModes.Integer) |
| { |
| ForceUpdateOverlays(); |
| } |
| else |
| { |
| UpdateMarkersOffset(); |
| } |
| } |
| InvalidateVisual(true); |
| } |
| else |
| { |
| if (isSelected && !selectionStart.IsEmpty && (Keyboard.Modifiers == ModifierKeys.Shift || Keyboard.Modifiers == ModifierKeys.Alt || DisableAltForSelection)) |
| { |
| System.Windows.Point p = e.GetPosition(this); |
| selectionEnd = FromLocalToLatLng((int)p.X, (int)p.Y); |
| { |
| GMap.NET.PointLatLng p1 = selectionStart; |
| GMap.NET.PointLatLng p2 = selectionEnd; |
| double x1 = Math.Min(p1.Lng, p2.Lng); |
| double y1 = Math.Max(p1.Lat, p2.Lat); |
| double x2 = Math.Max(p1.Lng, p2.Lng); |
| double y2 = Math.Min(p1.Lat, p2.Lat); |
| SelectedArea = new RectLatLng(y1, x1, x2 - x1, y1 - y2); |
| } |
| } |
| if (renderHelperLine) |
| { |
| InvalidateVisual(true); |
| } |
| } |
| } |
| } |
| /// <summary> |
| /// if true, selects area just by holding mouse and moving |
| /// </summary> |
| public bool DisableAltForSelection = false; |
| protected override void OnStylusDown(StylusDownEventArgs e) |
| { |
| base.OnStylusDown(e); |
| if(TouchEnabled && CanDragMap && !e.InAir) |
| { |
| Point p = e.GetPosition(this); |
| if(MapScaleTransform != null) |
| { |
| p = MapScaleTransform.Inverse.Transform(p); |
| } |
| p = ApplyRotationInversion(p.X, p.Y); |
| Core.mouseDown.X = (int)p.X; |
| Core.mouseDown.Y = (int)p.Y; |
| InvalidateVisual(); |
| } |
| } |
| protected override void OnStylusUp(StylusEventArgs e) |
| { |
| base.OnStylusUp(e); |
| if(TouchEnabled) |
| { |
| if(isSelected) |
| { |
| isSelected = false; |
| } |
| if(Core.IsDragging) |
| { |
| if(isDragging) |
| { |
| onMouseUpTimestamp = e.Timestamp & Int32.MaxValue; |
| isDragging = false; |
| Debug.WriteLine("IsDragging = " + isDragging); |
| Cursor = cursorBefore; |
| Mouse.Capture(null); |
| } |
| Core.EndDrag(); |
| if(BoundsOfMap.HasValue && !BoundsOfMap.Value.Contains(Position)) |
| { |
| if(Core.LastLocationInBounds.HasValue) |
| { |
| Position = Core.LastLocationInBounds.Value; |
| } |
| } |
| } |
| else |
| { |
| Core.mouseDown = GPoint.Empty; |
| InvalidateVisual(); |
| } |
| } |
| } |
| protected override void OnStylusMove(StylusEventArgs e) |
| { |
| base.OnStylusMove(e); |
| if(TouchEnabled && CanDragMap) |
| { |
| // wpf generates to many events if mouse is over some visual |
| // and OnMouseUp is fired, wtf, anyway... |
| // http://greatmaps.codeplex.com/workitem/16013 |
| if((e.Timestamp & Int32.MaxValue) - onMouseUpTimestamp < 55) |
| { |
| Debug.WriteLine("OnMouseMove skipped: " + ((e.Timestamp & Int32.MaxValue) - onMouseUpTimestamp) + "ms"); |
| return; |
| } |
| if(!Core.IsDragging && !Core.mouseDown.IsEmpty) |
| { |
| Point p = e.GetPosition(this); |
| if(MapScaleTransform != null) |
| { |
| p = MapScaleTransform.Inverse.Transform(p); |
| } |
| p = ApplyRotationInversion(p.X, p.Y); |
| // cursor has moved beyond drag tolerance |
| if(Math.Abs(p.X - Core.mouseDown.X) * 2 >= SystemParameters.MinimumHorizontalDragDistance || Math.Abs(p.Y - Core.mouseDown.Y) * 2 >= SystemParameters.MinimumVerticalDragDistance) |
| { |
| Core.BeginDrag(Core.mouseDown); |
| } |
| } |
| if(Core.IsDragging) |
| { |
| if(!isDragging) |
| { |
| isDragging = true; |
| Debug.WriteLine("IsDragging = " + isDragging); |
| cursorBefore = Cursor; |
| Cursor = Cursors.SizeAll; |
| Mouse.Capture(this); |
| } |
| if(BoundsOfMap.HasValue && !BoundsOfMap.Value.Contains(Position)) |
| { |
| // ... |
| } |
| else |
| { |
| Point p = e.GetPosition(this); |
| if(MapScaleTransform != null) |
| { |
| p = MapScaleTransform.Inverse.Transform(p); |
| } |
| p = ApplyRotationInversion(p.X, p.Y); |
| Core.mouseCurrent.X = (int)p.X; |
| Core.mouseCurrent.Y = (int)p.Y; |
| { |
| Core.Drag(Core.mouseCurrent); |
| } |
| if(IsRotated) |
| { |
| ForceUpdateOverlays(); |
| } |
| else |
| { |
| UpdateMarkersOffset(); |
| } |
| } |
| InvalidateVisual(); |
| } |
| } |
| } |
| #endregion |
| #region IGControl Members |
| /// <summary> |
| /// Call it to empty tile cache & reload tiles |
| /// </summary> |
| public void ReloadMap() |
| { |
| Core.ReloadMap(); |
| } |
| /// <summary> |
| /// sets position using geocoder |
| /// </summary> |
| /// <param name="keys"></param> |
| /// <returns></returns> |
| public GeoCoderStatusCode SetPositionByKeywords(string keys) |
| { |
| GeoCoderStatusCode status = GeoCoderStatusCode.Unknow; |
| GeocodingProvider gp = MapProvider as GeocodingProvider; |
| if(gp == null) |
| { |
| gp = GMapProviders.OpenStreetMap as GeocodingProvider; |
| } |
| if(gp != null) |
| { |
| var pt = gp.GetPoint(keys, out status); |
| if(status == GeoCoderStatusCode.G_GEO_SUCCESS && pt.HasValue) |
| { |
| Position = pt.Value; |
| } |
| } |
| return status; |
| } |
| public PointLatLng FromLocalToLatLng(int x, int y) |
| { |
| if(MapScaleTransform != null) |
| { |
| var tp = MapScaleTransform.Inverse.Transform(new System.Windows.Point(x, y)); |
| x = (int)tp.X; |
| y = (int)tp.Y; |
| } |
| if(IsRotated) |
| { |
| var f = rotationMatrixInvert.Transform(new System.Windows.Point(x, y)); |
| x = (int)f.X; |
| y = (int)f.Y; |
| } |
| return Core.FromLocalToLatLng(x, y); |
| } |
| public GPoint FromLatLngToLocal(PointLatLng point) |
| { |
| GPoint ret = Core.FromLatLngToLocal(point); |
| if(MapScaleTransform != null) |
| { |
| var tp = MapScaleTransform.Transform(new System.Windows.Point(ret.X, ret.Y)); |
| ret.X = (int)tp.X; |
| ret.Y = (int)tp.Y; |
| } |
| if(IsRotated) |
| { |
| var f = rotationMatrix.Transform(new System.Windows.Point(ret.X, ret.Y)); |
| ret.X = (int)f.X; |
| ret.Y = (int)f.Y; |
| } |
| return ret; |
| } |
| public bool ShowExportDialog() |
| { |
| var dlg = new Microsoft.Win32.SaveFileDialog(); |
| { |
| dlg.CheckPathExists = true; |
| dlg.CheckFileExists = false; |
| dlg.AddExtension = true; |
| dlg.DefaultExt = "gmdb"; |
| dlg.ValidateNames = true; |
| dlg.Title = "GMap.NET: Export map to db, if file exsist only new data will be added"; |
| dlg.FileName = "DataExp"; |
| dlg.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments); |
| dlg.Filter = "GMap.NET DB files (*.gmdb)|*.gmdb"; |
| dlg.FilterIndex = 1; |
| dlg.RestoreDirectory = true; |
| if(dlg.ShowDialog() == true) |
| { |
| bool ok = GMaps.Instance.ExportToGMDB(dlg.FileName); |
| if(ok) |
| { |
| MessageBox.Show("Complete!", "GMap.NET", MessageBoxButton.OK, MessageBoxImage.Information); |
| } |
| else |
| { |
| MessageBox.Show(" Failed!", "GMap.NET", MessageBoxButton.OK, MessageBoxImage.Warning); |
| } |
| return ok; |
| } |
| } |
| return false; |
| } |
| public bool ShowImportDialog() |
| { |
| var dlg = new Microsoft.Win32.OpenFileDialog(); |
| { |
| dlg.CheckPathExists = true; |
| dlg.CheckFileExists = false; |
| dlg.AddExtension = true; |
| dlg.DefaultExt = "gmdb"; |
| dlg.ValidateNames = true; |
| dlg.Title = "GMap.NET: Import to db, only new data will be added"; |
| dlg.FileName = "DataImport"; |
| dlg.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments); |
| dlg.Filter = "GMap.NET DB files (*.gmdb)|*.gmdb"; |
| dlg.FilterIndex = 1; |
| dlg.RestoreDirectory = true; |
| if(dlg.ShowDialog() == true) |
| { |
| Cursor = Cursors.Wait; |
| bool ok = GMaps.Instance.ImportFromGMDB(dlg.FileName); |
| if(ok) |
| { |
| MessageBox.Show("Complete!", "GMap.NET", MessageBoxButton.OK, MessageBoxImage.Information); |
| ReloadMap(); |
| } |
| else |
| { |
| MessageBox.Show(" Failed!", "GMap.NET", MessageBoxButton.OK, MessageBoxImage.Warning); |
| } |
| Cursor = Cursors.Arrow; |
| return ok; |
| } |
| } |
| return false; |
| } |
| /// <summary> |
| /// current coordinates of the map center |
| /// </summary> |
| [Browsable(false)] |
| public PointLatLng Position |
| { |
| get |
| { |
| return Core.Position; |
| } |
| set |
| { |
| Core.Position = value; |
| if(Core.IsStarted) |
| { |
| ForceUpdateOverlays(); |
| } |
| } |
| } |
| [Browsable(false)] |
| public GPoint PositionPixel |
| { |
| get |
| { |
| return Core.PositionPixel; |
| } |
| } |
| [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] |
| [Browsable(false)] |
| public string CacheLocation |
| { |
| get |
| { |
| return CacheLocator.Location; |
| } |
| set |
| { |
| CacheLocator.Location = value; |
| } |
| } |
| bool isDragging = false; |
| [Browsable(false)] |
| public bool IsDragging |
| { |
| get |
| { |
| return isDragging; |
| } |
| } |
| [Browsable(false)] |
| public RectLatLng ViewArea |
| { |
| get |
| { |
| if(!IsRotated) |
| { |
| return Core.ViewArea; |
| } |
| else if(Core.Provider.Projection != null) |
| { |
| var p = FromLocalToLatLng(0, 0); |
| var p2 = FromLocalToLatLng((int)Width, (int)Height); |
| return RectLatLng.FromLTRB(p.Lng, p.Lat, p2.Lng, p2.Lat); |
| } |
| return RectLatLng.Empty; |
| } |
| } |
| [Category("GMap.NET")] |
| public bool CanDragMap |
| { |
| get |
| { |
| return Core.CanDragMap; |
| } |
| set |
| { |
| Core.CanDragMap = value; |
| } |
| } |
| public GMap.NET.RenderMode RenderMode |
| { |
| get |
| { |
| return GMap.NET.RenderMode.WPF; |
| } |
| } |
| #endregion |
| #region IGControl event Members |
| public event PositionChanged OnPositionChanged |
| { |
| add |
| { |
| Core.OnCurrentPositionChanged += value; |
| } |
| remove |
| { |
| Core.OnCurrentPositionChanged -= value; |
| } |
| } |
| public event TileLoadComplete OnTileLoadComplete |
| { |
| add |
| { |
| Core.OnTileLoadComplete += value; |
| } |
| remove |
| { |
| Core.OnTileLoadComplete -= value; |
| } |
| } |
| public event TileLoadStart OnTileLoadStart |
| { |
| add |
| { |
| Core.OnTileLoadStart += value; |
| } |
| remove |
| { |
| Core.OnTileLoadStart -= value; |
| } |
| } |
| public event MapDrag OnMapDrag |
| { |
| add |
| { |
| Core.OnMapDrag += value; |
| } |
| remove |
| { |
| Core.OnMapDrag -= value; |
| } |
| } |
| public event MapZoomChanged OnMapZoomChanged |
| { |
| add |
| { |
| Core.OnMapZoomChanged += value; |
| } |
| remove |
| { |
| Core.OnMapZoomChanged -= value; |
| } |
| } |
| /// <summary> |
| /// occures on map type changed |
| /// </summary> |
| public event MapTypeChanged OnMapTypeChanged |
| { |
| add |
| { |
| Core.OnMapTypeChanged += value; |
| } |
| remove |
| { |
| Core.OnMapTypeChanged -= value; |
| } |
| } |
| /// <summary> |
| /// occurs on empty tile displayed |
| /// </summary> |
| public event EmptyTileError OnEmptyTileError |
| { |
| add |
| { |
| Core.OnEmptyTileError += value; |
| } |
| remove |
| { |
| Core.OnEmptyTileError -= value; |
| } |
| } |
| #endregion |
| #region IDisposable Members |
| public virtual void Dispose() |
| { |
| if(Core.IsStarted) |
| { |
| Core.OnMapZoomChanged -= new MapZoomChanged(ForceUpdateOverlays); |
| Loaded -= new RoutedEventHandler(GMapControl_Loaded); |
| Dispatcher.ShutdownStarted -= new EventHandler(Dispatcher_ShutdownStarted); |
| SizeChanged -= new SizeChangedEventHandler(GMapControl_SizeChanged); |
| if(loadedApp != null) |
| { |
| loadedApp.SessionEnding -= new SessionEndingCancelEventHandler(Current_SessionEnding); |
| } |
| Core.OnMapClose(); |
| } |
| } |
| #endregion |
| } |
| public enum HelperLineOptions |
| { |
| DontShow = 0, |
| ShowAlways = 1, |
| ShowOnModifierKey = 2 |
| } |
| public enum ScaleModes |
| { |
| /// <summary> |
| /// no scaling |
| /// </summary> |
| Integer, |
| /// <summary> |
| /// scales to fractional level using a stretched tiles, any issues -> http://greatmaps.codeplex.com/workitem/16046 |
| /// </summary> |
| ScaleUp, |
| /// <summary> |
| /// scales to fractional level using a narrowed tiles, any issues -> http://greatmaps.codeplex.com/workitem/16046 |
| /// </summary> |
| ScaleDown, |
| /// <summary> |
| /// scales to fractional level using a combination both stretched and narrowed tiles, any issues -> http://greatmaps.codeplex.com/workitem/16046 |
| /// </summary> |
| Dynamic |
| } |
| public delegate void SelectionChange(RectLatLng Selection, bool ZoomToFit); |
| } |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/GMap.NET.WindowsPresentation/GMapImage.cs |
|---|
| 0,0 → 1,284 |
| |
| namespace GMap.NET.WindowsPresentation |
| { |
| using System.Collections.Generic; |
| using System.Collections.ObjectModel; |
| using System.Diagnostics; |
| using System.Windows; |
| using System.Windows.Media; |
| using System.Windows.Media.Imaging; |
| using GMap.NET.Internals; |
| using GMap.NET.MapProviders; |
| /// <summary> |
| /// image abstraction |
| /// </summary> |
| public class GMapImage : PureImage |
| { |
| public ImageSource Img; |
| public override void Dispose() |
| { |
| if(Img != null) |
| { |
| Img = null; |
| } |
| if(Data != null) |
| { |
| Data.Dispose(); |
| Data = null; |
| } |
| } |
| } |
| /// <summary> |
| /// image abstraction proxy |
| /// </summary> |
| public class GMapImageProxy : PureImageProxy |
| { |
| GMapImageProxy() |
| { |
| } |
| public static void Enable() |
| { |
| GMapProvider.TileImageProxy = Instance; |
| } |
| public static readonly GMapImageProxy Instance = new GMapImageProxy(); |
| //static readonly byte[] pngHeader = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A }; |
| //static readonly byte[] jpgHeader = { 0xFF, 0xD8, 0xFF }; |
| //static readonly byte[] gifHeader = { 0x47, 0x49, 0x46 }; |
| //static readonly byte[] bmpHeader = { 0x42, 0x4D }; |
| public override PureImage FromStream(System.IO.Stream stream) |
| { |
| GMapImage ret = null; |
| if(stream != null) |
| { |
| var type = stream.ReadByte(); |
| stream.Position = 0; |
| ImageSource m = null; |
| switch(type) |
| { |
| // PNG: 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A |
| case 0x89: |
| { |
| var bitmapDecoder = new PngBitmapDecoder(stream, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.OnLoad); |
| m = bitmapDecoder.Frames[0]; |
| bitmapDecoder = null; |
| } |
| break; |
| // JPG: 0xFF, 0xD8, 0xFF |
| case 0xFF: |
| { |
| var bitmapDecoder = new JpegBitmapDecoder(stream, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.OnLoad); |
| m = bitmapDecoder.Frames[0]; |
| bitmapDecoder = null; |
| } |
| break; |
| // GIF: 0x47, 0x49, 0x46 |
| case 0x47: |
| { |
| var bitmapDecoder = new GifBitmapDecoder(stream, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.OnLoad); |
| m = bitmapDecoder.Frames[0]; |
| bitmapDecoder = null; |
| } |
| break; |
| // BMP: 0x42, 0x4D |
| case 0x42: |
| { |
| var bitmapDecoder = new BmpBitmapDecoder(stream, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.OnLoad); |
| m = bitmapDecoder.Frames[0]; |
| bitmapDecoder = null; |
| } |
| break; |
| // TIFF: 0x49, 0x49 || 0x4D, 0x4D |
| case 0x49: |
| case 0x4D: |
| { |
| var bitmapDecoder = new TiffBitmapDecoder(stream, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.OnLoad); |
| m = bitmapDecoder.Frames[0]; |
| bitmapDecoder = null; |
| } |
| break; |
| default: |
| { |
| Debug.WriteLine("WindowsPresentationImageProxy: unknown image format: " + type); |
| } |
| break; |
| } |
| if(m != null) |
| { |
| ret = new GMapImage(); |
| ret.Img = m; |
| if(ret.Img.CanFreeze) |
| { |
| ret.Img.Freeze(); |
| } |
| } |
| } |
| return ret; |
| } |
| public override bool Save(System.IO.Stream stream, PureImage image) |
| { |
| GMapImage ret = (GMapImage)image; |
| if(ret.Img != null) |
| { |
| try |
| { |
| PngBitmapEncoder e = new PngBitmapEncoder(); |
| e.Frames.Add(BitmapFrame.Create(ret.Img as BitmapSource)); |
| e.Save(stream); |
| e = null; |
| } |
| catch |
| { |
| return false; |
| } |
| } |
| else |
| { |
| return false; |
| } |
| return true; |
| } |
| } |
| //internal class TileVisual : FrameworkElement |
| //{ |
| // public readonly ObservableCollection<ImageSource> Source; |
| // public readonly RawTile Tile; |
| // public TileVisual(IEnumerable<ImageSource> src, RawTile tile) |
| // { |
| // Opacity = 0; |
| // Tile = tile; |
| // Source = new ObservableCollection<ImageSource>(src); |
| // Source.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(Source_CollectionChanged); |
| // this.Loaded += new RoutedEventHandler(ImageVisual_Loaded); |
| // this.Unloaded += new RoutedEventHandler(ImageVisual_Unloaded); |
| // } |
| // void Source_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) |
| // { |
| // if (IsLoaded) |
| // { |
| // switch (e.Action) |
| // { |
| // case System.Collections.Specialized.NotifyCollectionChangedAction.Add: |
| // case System.Collections.Specialized.NotifyCollectionChangedAction.Move: |
| // case System.Collections.Specialized.NotifyCollectionChangedAction.Remove: |
| // case System.Collections.Specialized.NotifyCollectionChangedAction.Replace: |
| // { |
| // UpdateVisual(); |
| // } |
| // break; |
| // case System.Collections.Specialized.NotifyCollectionChangedAction.Reset: |
| // { |
| // Child = null; |
| // } |
| // break; |
| // } |
| // } |
| // } |
| // void ImageVisual_Unloaded(object sender, RoutedEventArgs e) |
| // { |
| // Child = null; |
| // } |
| // void ImageVisual_Loaded(object sender, RoutedEventArgs e) |
| // { |
| // UpdateVisual(); |
| // } |
| // Visual _child; |
| // public virtual Visual Child |
| // { |
| // get |
| // { |
| // return _child; |
| // } |
| // set |
| // { |
| // if (_child != value) |
| // { |
| // if (_child != null) |
| // { |
| // RemoveLogicalChild(_child); |
| // RemoveVisualChild(_child); |
| // } |
| // if (value != null) |
| // { |
| // AddVisualChild(value); |
| // AddLogicalChild(value); |
| // } |
| // // cache the new child |
| // _child = value; |
| // InvalidateVisual(); |
| // } |
| // } |
| // } |
| // public void UpdateVisual() |
| // { |
| // Child = Create(); |
| // } |
| // static readonly Pen gridPen = new Pen(Brushes.White, 2.0); |
| // private DrawingVisual Create() |
| // { |
| // var dv = new DrawingVisual(); |
| // using (DrawingContext dc = dv.RenderOpen()) |
| // { |
| // foreach (var img in Source) |
| // { |
| // var rect = new Rect(0, 0, img.Width + 0.6, img.Height + 0.6); |
| // dc.DrawImage(img, rect); |
| // dc.DrawRectangle(null, gridPen, rect); |
| // } |
| // } |
| // return dv; |
| // } |
| // #region Necessary Overrides -- Needed by WPF to maintain bookkeeping of our hosted visuals |
| // protected override int VisualChildrenCount |
| // { |
| // get |
| // { |
| // return (Child == null ? 0 : 1); |
| // } |
| // } |
| // protected override Visual GetVisualChild(int index) |
| // { |
| // Debug.Assert(index == 0); |
| // return Child; |
| // } |
| // #endregion |
| //} |
| } |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/GMap.NET.WindowsPresentation/GMapMarker.cs |
|---|
| 0,0 → 1,252 |
| |
| namespace GMap.NET.WindowsPresentation |
| { |
| using System.Collections.Generic; |
| using System.ComponentModel; |
| using System.Windows; |
| using System.Windows.Controls; |
| using GMap.NET; |
| using System.Windows.Media; |
| using System.Diagnostics; |
| using System.Windows.Shapes; |
| using System; |
| /// <summary> |
| /// GMap.NET marker |
| /// </summary> |
| public class GMapMarker : INotifyPropertyChanged |
| { |
| public event PropertyChangedEventHandler PropertyChanged; |
| protected void OnPropertyChanged(string name) |
| { |
| if(PropertyChanged != null) |
| { |
| PropertyChanged(this, new PropertyChangedEventArgs(name)); |
| } |
| } |
| protected void OnPropertyChanged(PropertyChangedEventArgs name) |
| { |
| if(PropertyChanged != null) |
| { |
| PropertyChanged(this, name); |
| } |
| } |
| UIElement shape; |
| static readonly PropertyChangedEventArgs Shape_PropertyChangedEventArgs = new PropertyChangedEventArgs("Shape"); |
| /// <summary> |
| /// marker visual |
| /// </summary> |
| public UIElement Shape |
| { |
| get |
| { |
| return shape; |
| } |
| set |
| { |
| if(shape != value) |
| { |
| shape = value; |
| OnPropertyChanged(Shape_PropertyChangedEventArgs); |
| UpdateLocalPosition(); |
| } |
| } |
| } |
| private PointLatLng position; |
| /// <summary> |
| /// coordinate of marker |
| /// </summary> |
| public PointLatLng Position |
| { |
| get |
| { |
| return position; |
| } |
| set |
| { |
| if(position != value) |
| { |
| position = value; |
| UpdateLocalPosition(); |
| } |
| } |
| } |
| GMapControl map; |
| /// <summary> |
| /// the map of this marker |
| /// </summary> |
| public GMapControl Map |
| { |
| get |
| { |
| if(Shape != null && map == null) |
| { |
| DependencyObject visual = Shape; |
| while(visual != null && !(visual is GMapControl)) |
| { |
| visual = VisualTreeHelper.GetParent(visual); |
| } |
| map = visual as GMapControl; |
| } |
| return map; |
| } |
| internal set |
| { |
| map = value; |
| } |
| } |
| /// <summary> |
| /// custom object |
| /// </summary> |
| public object Tag; |
| System.Windows.Point offset; |
| /// <summary> |
| /// offset of marker |
| /// </summary> |
| public System.Windows.Point Offset |
| { |
| get |
| { |
| return offset; |
| } |
| set |
| { |
| if(offset != value) |
| { |
| offset = value; |
| UpdateLocalPosition(); |
| } |
| } |
| } |
| int localPositionX; |
| static readonly PropertyChangedEventArgs LocalPositionX_PropertyChangedEventArgs = new PropertyChangedEventArgs("LocalPositionX"); |
| /// <summary> |
| /// local X position of marker |
| /// </summary> |
| public int LocalPositionX |
| { |
| get |
| { |
| return localPositionX; |
| } |
| internal set |
| { |
| if(localPositionX != value) |
| { |
| localPositionX = value; |
| OnPropertyChanged(LocalPositionX_PropertyChangedEventArgs); |
| } |
| } |
| } |
| int localPositionY; |
| static readonly PropertyChangedEventArgs LocalPositionY_PropertyChangedEventArgs = new PropertyChangedEventArgs("LocalPositionY"); |
| /// <summary> |
| /// local Y position of marker |
| /// </summary> |
| public int LocalPositionY |
| { |
| get |
| { |
| return localPositionY; |
| } |
| internal set |
| { |
| if(localPositionY != value) |
| { |
| localPositionY = value; |
| OnPropertyChanged(LocalPositionY_PropertyChangedEventArgs); |
| } |
| } |
| } |
| int zIndex; |
| static readonly PropertyChangedEventArgs ZIndex_PropertyChangedEventArgs = new PropertyChangedEventArgs("ZIndex"); |
| /// <summary> |
| /// the index of Z, render order |
| /// </summary> |
| public int ZIndex |
| { |
| get |
| { |
| return zIndex; |
| } |
| set |
| { |
| if(zIndex != value) |
| { |
| zIndex = value; |
| OnPropertyChanged(ZIndex_PropertyChangedEventArgs); |
| } |
| } |
| } |
| public GMapMarker(PointLatLng pos) |
| { |
| Position = pos; |
| } |
| internal GMapMarker() |
| { |
| } |
| /// <summary> |
| /// calls Dispose on shape if it implements IDisposable, sets shape to null and clears route |
| /// </summary> |
| public virtual void Clear() |
| { |
| var s = (Shape as IDisposable); |
| if(s != null) |
| { |
| s.Dispose(); |
| s = null; |
| } |
| Shape = null; |
| } |
| /// <summary> |
| /// updates marker position, internal access usualy |
| /// </summary> |
| void UpdateLocalPosition() |
| { |
| if(Map != null) |
| { |
| GPoint p = Map.FromLatLngToLocal(Position); |
| p.Offset(-(long)Map.MapTranslateTransform.X, -(long)Map.MapTranslateTransform.Y); |
| LocalPositionX = (int)(p.X + (long)(offset.X)); |
| LocalPositionY = (int)(p.Y + (long)(offset.Y)); |
| } |
| } |
| /// <summary> |
| /// forces to update local marker position |
| /// dot not call it if you don't really need to ;} |
| /// </summary> |
| /// <param name="m"></param> |
| internal void ForceUpdateLocalPosition(GMapControl m) |
| { |
| if(m != null) |
| { |
| map = m; |
| } |
| UpdateLocalPosition(); |
| } |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/GMap.NET.WindowsPresentation/GMapPolygon.cs |
|---|
| 0,0 → 1,62 |
| |
| namespace GMap.NET.WindowsPresentation |
| { |
| using System.Collections.Generic; |
| using System.Windows.Shapes; |
| public class GMapPolygon : GMapMarker, IShapable |
| { |
| public readonly List<PointLatLng> Points = new List<PointLatLng>(); |
| public GMapPolygon(IEnumerable<PointLatLng> points) |
| { |
| Points.AddRange(points); |
| RegenerateShape(null); |
| } |
| public override void Clear() |
| { |
| base.Clear(); |
| Points.Clear(); |
| } |
| /// <summary> |
| /// regenerates shape of polygon |
| /// </summary> |
| public virtual void RegenerateShape(GMapControl map) |
| { |
| if(map != null) |
| { |
| this.Map = map; |
| if(Points.Count > 1) |
| { |
| Position = Points[0]; |
| var localPath = new List<System.Windows.Point>(Points.Count); |
| var offset = Map.FromLatLngToLocal(Points[0]); |
| foreach(var i in Points) |
| { |
| var p = Map.FromLatLngToLocal(i); |
| localPath.Add(new System.Windows.Point(p.X - offset.X, p.Y - offset.Y)); |
| } |
| var shape = map.CreatePolygonPath(localPath); |
| if(this.Shape is Path) |
| { |
| (this.Shape as Path).Data = shape.Data; |
| } |
| else |
| { |
| this.Shape = shape; |
| } |
| } |
| else |
| { |
| this.Shape = null; |
| } |
| } |
| } |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/GMap.NET.WindowsPresentation/GMapRoute.cs |
|---|
| 0,0 → 1,67 |
| |
| namespace GMap.NET.WindowsPresentation |
| { |
| using System.Collections.Generic; |
| using System.Windows.Shapes; |
| public interface IShapable |
| { |
| void RegenerateShape(GMapControl map); |
| } |
| public class GMapRoute : GMapMarker, IShapable |
| { |
| public readonly List<PointLatLng> Points = new List<PointLatLng>(); |
| public GMapRoute(IEnumerable<PointLatLng> points) |
| { |
| Points.AddRange(points); |
| RegenerateShape(null); |
| } |
| public override void Clear() |
| { |
| base.Clear(); |
| Points.Clear(); |
| } |
| /// <summary> |
| /// regenerates shape of route |
| /// </summary> |
| public virtual void RegenerateShape(GMapControl map) |
| { |
| if (map != null) |
| { |
| this.Map = map; |
| if(Points.Count > 1) |
| { |
| Position = Points[0]; |
| var localPath = new List<System.Windows.Point>(Points.Count); |
| var offset = Map.FromLatLngToLocal(Points[0]); |
| foreach(var i in Points) |
| { |
| var p = Map.FromLatLngToLocal(i); |
| localPath.Add(new System.Windows.Point(p.X - offset.X, p.Y - offset.Y)); |
| } |
| var shape = map.CreateRoutePath(localPath); |
| if(this.Shape is Path) |
| { |
| (this.Shape as Path).Data = shape.Data; |
| } |
| else |
| { |
| this.Shape = shape; |
| } |
| } |
| else |
| { |
| this.Shape = null; |
| } |
| } |
| } |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/GMap.NET.WindowsPresentation/TilePrefetcher.xaml |
|---|
| 0,0 → 1,10 |
| <Window x:Class="GMap.NET.WindowsPresentation.TilePrefetcher" |
| xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" |
| xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" |
| Title="GMap.NET - esc to cancel fetching" Height="104" Width="423" Background="AliceBlue" ResizeMode="NoResize" ShowInTaskbar="False" WindowStartupLocation="CenterScreen" WindowStyle="SingleBorderWindow" Margin="5"> |
| <Grid HorizontalAlignment="Stretch" VerticalAlignment="Stretch"> |
| <TextBlock Name="label1" Height="25" VerticalAlignment="Top" Padding="0" Margin="11,17,9,0" Text="ready" /> |
| <ProgressBar Height="22" Name="progressBar1" Value="0" VerticalAlignment="Bottom" Margin="10,0,0,10" HorizontalAlignment="Left" Width="302" /> |
| <TextBlock Text="please wait..." Height="19" Margin="316,0,12,10" Name="label2" Padding="0" VerticalAlignment="Bottom" FontWeight="Bold" /> |
| </Grid> |
| </Window> |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/GMap.NET.WindowsPresentation/TilePrefetcher.xaml.cs |
|---|
| 0,0 → 1,260 |
| |
| namespace GMap.NET.WindowsPresentation |
| { |
| using System; |
| using System.Collections.Generic; |
| using System.ComponentModel; |
| using System.Windows; |
| using System.Windows.Input; |
| using GMap.NET.Internals; |
| using GMap.NET; |
| using GMap.NET.MapProviders; |
| using System.Threading; |
| using System.Windows.Threading; |
| /// <summary> |
| /// form helping to prefetch tiles on local db |
| /// </summary> |
| public partial class TilePrefetcher : Window |
| { |
| BackgroundWorker worker = new BackgroundWorker(); |
| List<GPoint> list = new List<GPoint>(); |
| int zoom; |
| GMapProvider provider; |
| int sleep; |
| int all; |
| public bool ShowCompleteMessage = false; |
| RectLatLng area; |
| GMap.NET.GSize maxOfTiles; |
| public TilePrefetcher() |
| { |
| InitializeComponent(); |
| GMaps.Instance.OnTileCacheComplete += new TileCacheComplete(OnTileCacheComplete); |
| GMaps.Instance.OnTileCacheStart += new TileCacheStart(OnTileCacheStart); |
| GMaps.Instance.OnTileCacheProgress += new TileCacheProgress(OnTileCacheProgress); |
| worker.WorkerReportsProgress = true; |
| worker.WorkerSupportsCancellation = true; |
| worker.ProgressChanged += new ProgressChangedEventHandler(worker_ProgressChanged); |
| worker.DoWork += new DoWorkEventHandler(worker_DoWork); |
| worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted); |
| } |
| readonly AutoResetEvent done = new AutoResetEvent(true); |
| void OnTileCacheComplete() |
| { |
| if(IsVisible) |
| { |
| done.Set(); |
| Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() => |
| { |
| label2.Text = "all tiles saved"; |
| })); |
| } |
| } |
| void OnTileCacheStart() |
| { |
| if(IsVisible) |
| { |
| done.Reset(); |
| Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() => |
| { |
| label2.Text = "saving tiles..."; |
| })); |
| } |
| } |
| void OnTileCacheProgress(int left) |
| { |
| if(IsVisible) |
| { |
| Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() => |
| { |
| label2.Text = left + " tile to save..."; |
| })); |
| } |
| } |
| public void Start(RectLatLng area, int zoom, GMapProvider provider, int sleep) |
| { |
| if(!worker.IsBusy) |
| { |
| this.label1.Text = "..."; |
| this.progressBar1.Value = 0; |
| this.area = area; |
| this.zoom = zoom; |
| this.provider = provider; |
| this.sleep = sleep; |
| GMaps.Instance.UseMemoryCache = false; |
| GMaps.Instance.CacheOnIdleRead = false; |
| GMaps.Instance.BoostCacheEngine = true; |
| worker.RunWorkerAsync(); |
| this.ShowDialog(); |
| } |
| } |
| volatile bool stopped = false; |
| public void Stop() |
| { |
| GMaps.Instance.OnTileCacheComplete -= new TileCacheComplete(OnTileCacheComplete); |
| GMaps.Instance.OnTileCacheStart -= new TileCacheStart(OnTileCacheStart); |
| GMaps.Instance.OnTileCacheProgress -= new TileCacheProgress(OnTileCacheProgress); |
| done.Set(); |
| if(worker.IsBusy) |
| { |
| worker.CancelAsync(); |
| } |
| GMaps.Instance.CancelTileCaching(); |
| stopped = true; |
| done.Close(); |
| } |
| void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) |
| { |
| if(ShowCompleteMessage) |
| { |
| if(!e.Cancelled) |
| { |
| MessageBox.Show("Prefetch Complete! => " + ((int)e.Result).ToString() + " of " + all); |
| } |
| else |
| { |
| MessageBox.Show("Prefetch Canceled! => " + ((int)e.Result).ToString() + " of " + all); |
| } |
| } |
| list.Clear(); |
| GMaps.Instance.UseMemoryCache = true; |
| GMaps.Instance.CacheOnIdleRead = true; |
| GMaps.Instance.BoostCacheEngine = false; |
| this.Close(); |
| } |
| bool CacheTiles(int zoom, GPoint p) |
| { |
| foreach(var type in provider.Overlays) |
| { |
| Exception ex; |
| PureImage img; |
| // tile number inversion(BottomLeft -> TopLeft) for pergo maps |
| if(type is TurkeyMapProvider) |
| { |
| img = GMaps.Instance.GetImageFrom(type, new GPoint(p.X, maxOfTiles.Height - p.Y), zoom, out ex); |
| } |
| else // ok |
| { |
| img = GMaps.Instance.GetImageFrom(type, p, zoom, out ex); |
| } |
| if(img != null) |
| { |
| img.Dispose(); |
| img = null; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| return true; |
| } |
| void worker_DoWork(object sender, DoWorkEventArgs e) |
| { |
| if(list != null) |
| { |
| list.Clear(); |
| list = null; |
| } |
| list = provider.Projection.GetAreaTileList(area, zoom, 0); |
| maxOfTiles = provider.Projection.GetTileMatrixMaxXY(zoom); |
| all = list.Count; |
| int countOk = 0; |
| int retry = 0; |
| Stuff.Shuffle<GPoint>(list); |
| for(int i = 0; i < all; i++) |
| { |
| if(worker.CancellationPending) |
| break; |
| GPoint p = list[i]; |
| { |
| if(CacheTiles(zoom, p)) |
| { |
| countOk++; |
| retry = 0; |
| } |
| else |
| { |
| if(++retry <= 1) // retry only one |
| { |
| i--; |
| System.Threading.Thread.Sleep(1111); |
| continue; |
| } |
| else |
| { |
| retry = 0; |
| } |
| } |
| } |
| worker.ReportProgress((int)((i + 1) * 100 / all), i + 1); |
| System.Threading.Thread.Sleep(sleep); |
| } |
| e.Result = countOk; |
| if(!stopped) |
| { |
| done.WaitOne(); |
| } |
| } |
| void worker_ProgressChanged(object sender, ProgressChangedEventArgs e) |
| { |
| this.label1.Text = "Fetching tile at zoom (" + zoom + "): " + ((int)e.UserState).ToString() + " of " + all + ", complete: " + e.ProgressPercentage.ToString() + "%"; |
| this.progressBar1.Value = e.ProgressPercentage; |
| } |
| protected override void OnPreviewKeyDown(KeyEventArgs e) |
| { |
| if(e.Key == Key.Escape) |
| { |
| this.Close(); |
| } |
| base.OnPreviewKeyDown(e); |
| } |
| protected override void OnClosed(EventArgs e) |
| { |
| this.Stop(); |
| base.OnClosed(e); |
| } |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/GMap.NET.WindowsPresentation.csproj |
|---|
| 0,0 → 1,136 |
| <?xml version="1.0" encoding="utf-8"?> |
| <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
| <PropertyGroup> |
| <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> |
| <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> |
| <ProductVersion>9.0.30729</ProductVersion> |
| <SchemaVersion>2.0</SchemaVersion> |
| <ProjectGuid>{644FE7D4-0184-400F-B2D7-99CB41360658}</ProjectGuid> |
| <OutputType>library</OutputType> |
| <AppDesignerFolder>Properties</AppDesignerFolder> |
| <RootNamespace>GMap.NET.WindowsPresentation</RootNamespace> |
| <AssemblyName>GMap.NET.WindowsPresentation</AssemblyName> |
| <FileAlignment>512</FileAlignment> |
| <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> |
| <WarningLevel>4</WarningLevel> |
| <SignAssembly>true</SignAssembly> |
| <AssemblyOriginatorKeyFile>sn.snk</AssemblyOriginatorKeyFile> |
| <FileUpgradeFlags> |
| </FileUpgradeFlags> |
| <OldToolsVersion>3.5</OldToolsVersion> |
| <UpgradeBackupLocation /> |
| </PropertyGroup> |
| <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'"> |
| <TargetFrameworkVersion>v3.5</TargetFrameworkVersion> |
| <DebugSymbols>true</DebugSymbols> |
| <OutputPath>bin\Debug\</OutputPath> |
| <DefineConstants>TRACE;DEBUG</DefineConstants> |
| <DebugType>full</DebugType> |
| <PlatformTarget>AnyCPU</PlatformTarget> |
| <CodeAnalysisLogFile>bin\x86\Debug\GMap.NET.WindowsPresentation.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile> |
| <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression> |
| <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile> |
| <ErrorReport>prompt</ErrorReport> |
| <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet> |
| <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories> |
| <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets> |
| <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories> |
| <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules> |
| <CodeAnalysisFailOnMissingRules>false</CodeAnalysisFailOnMissingRules> |
| </PropertyGroup> |
| <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|AnyCPU'"> |
| <TargetFrameworkVersion>v3.5</TargetFrameworkVersion> |
| <OutputPath>bin\Release\</OutputPath> |
| <DefineConstants>TRACE</DefineConstants> |
| <DocumentationFile>bin\x86\Release\GMap.NET.WindowsPresentation.XML</DocumentationFile> |
| <Optimize>true</Optimize> |
| <PlatformTarget>AnyCPU</PlatformTarget> |
| <CodeAnalysisLogFile>bin\x86\Release\GMap.NET.WindowsPresentation.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile> |
| <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression> |
| <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile> |
| <ErrorReport>prompt</ErrorReport> |
| <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet> |
| <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories> |
| <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories> |
| </PropertyGroup> |
| <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'v4.0-Debug|AnyCPU'"> |
| <TargetFrameworkVersion>v4.0</TargetFrameworkVersion> |
| <DebugSymbols>true</DebugSymbols> |
| <OutputPath>bin\v4.0-Debug\</OutputPath> |
| <DefineConstants>NET40;TRACE;DEBUG</DefineConstants> |
| <DebugType>full</DebugType> |
| <PlatformTarget>AnyCPU</PlatformTarget> |
| <ErrorReport>prompt</ErrorReport> |
| <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet> |
| </PropertyGroup> |
| <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'v4.0-Release|AnyCPU'"> |
| <TargetFrameworkVersion>v4.0</TargetFrameworkVersion> |
| <OutputPath>bin\v4.0-Release\</OutputPath> |
| <DefineConstants>NET40;TRACE</DefineConstants> |
| <DocumentationFile>$(OutputPath)GMap.NET.WindowsPresentation.XML</DocumentationFile> |
| <Optimize>true</Optimize> |
| <PlatformTarget>AnyCPU</PlatformTarget> |
| <ErrorReport>prompt</ErrorReport> |
| <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet> |
| </PropertyGroup> |
| <ItemGroup> |
| <Reference Include="System" /> |
| <Reference Include="System.Core"> |
| <RequiredTargetFramework>3.5</RequiredTargetFramework> |
| </Reference> |
| <Reference Include="PresentationCore"> |
| <RequiredTargetFramework>3.0</RequiredTargetFramework> |
| </Reference> |
| <Reference Include="PresentationFramework"> |
| <RequiredTargetFramework>3.0</RequiredTargetFramework> |
| </Reference> |
| <Reference Include="WindowsBase"> |
| <RequiredTargetFramework>3.0</RequiredTargetFramework> |
| </Reference> |
| <Reference Include="System.Xaml" Condition="'$(TargetFrameworkVersion)' == 'v4.0'"> |
| <RequiredTargetFramework>4.0</RequiredTargetFramework> |
| </Reference> |
| </ItemGroup> |
| <ItemGroup> |
| <Compile Include="..\GMap.NET.Core\Properties\VersionInfo.cs"> |
| <Link>Properties\VersionInfo.cs</Link> |
| </Compile> |
| <Compile Include="GMap.NET.WindowsPresentation\GMapMarker.cs" /> |
| <Compile Include="GMap.NET.WindowsPresentation\GMapPolygon.cs" /> |
| <Compile Include="GMap.NET.WindowsPresentation\GMapRoute.cs" /> |
| <Compile Include="GMap.NET.WindowsPresentation\GMapImage.cs" /> |
| <Compile Include="GMap.NET.WindowsPresentation\GMapControl.cs" /> |
| <Compile Include="Properties\AssemblyInfo.cs"> |
| <SubType>Code</SubType> |
| </Compile> |
| <Compile Include="GMap.NET.WindowsPresentation\TilePrefetcher.xaml.cs"> |
| <DependentUpon>TilePrefetcher.xaml</DependentUpon> |
| </Compile> |
| <AppDesigner Include="Properties\" /> |
| </ItemGroup> |
| <ItemGroup> |
| <ProjectReference Include="..\GMap.NET.Core\GMap.NET.Core.csproj"> |
| <Project>{D0C39D9D-BED0-418B-9A5E-713176CAF40C}</Project> |
| <Name>GMap.NET.Core</Name> |
| </ProjectReference> |
| </ItemGroup> |
| <ItemGroup> |
| <None Include="sn.snk" /> |
| </ItemGroup> |
| <ItemGroup> |
| <Page Include="GMap.NET.WindowsPresentation\TilePrefetcher.xaml"> |
| <SubType>Designer</SubType> |
| <Generator>MSBuild:Compile</Generator> |
| <Generator>MSBuild:Compile</Generator> |
| <SubType>Designer</SubType> |
| </Page> |
| </ItemGroup> |
| <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> |
| <!-- To modify your build process, add your task inside one of the targets below and uncomment it. |
| Other similar extension points exist, see Microsoft.Common.targets. |
| <Target Name="BeforeBuild"> |
| </Target> |
| <Target Name="AfterBuild"> |
| </Target> |
| --> |
| </Project> |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/Properties/AssemblyInfo.cs |
|---|
| 0,0 → 1,53 |
| using System.Reflection; |
| using System.Resources; |
| using System.Runtime.CompilerServices; |
| using System.Runtime.InteropServices; |
| using System.Windows; |
| // General Information about an assembly is controlled through the following |
| // set of attributes. Change these attribute values to modify the information |
| // associated with an assembly. |
| [assembly: AssemblyTitle("GMap.NET.WindowsPresentation")] |
| [assembly: AssemblyDescription("GMap.NET - Great Maps for Windows Presentation")] |
| [assembly: AssemblyProduct("GMap.NET.WindowsPresentation")] |
| // Setting ComVisible to false makes the types in this assembly not visible |
| // to COM components. If you need to access a type in this assembly from |
| // COM, set the ComVisible attribute to true on that type. |
| [assembly: ComVisible(true)] |
| // The following GUID is for the ID of the typelib if this project is exposed to COM |
| [assembly: Guid("BB3E880B-18D8-4843-A2C1-47DC7CCC054C")] |
| //In order to begin building localizable applications, set |
| //<UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file |
| //inside a <PropertyGroup>. For example, if you are using US english |
| //in your source files, set the <UICulture> to en-US. Then uncomment |
| //the NeutralResourceLanguage attribute below. Update the "en-US" in |
| //the line below to match the UICulture setting in the project file. |
| //[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)] |
| [assembly: ThemeInfo( |
| ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located |
| //(used if a resource is not found in the page, |
| // or application resource dictionaries) |
| ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located |
| //(used if a resource is not found in the page, |
| // app, or any theme specific resource dictionaries) |
| )] |
| // Version information for an assembly consists of the following four values: |
| // |
| // Major Version |
| // Minor Version |
| // Build Number |
| // Revision |
| // |
| // You can specify all the values or you can default the Build and Revision Numbers |
| // by using the '*' as shown below: |
| // [assembly: AssemblyVersion("1.0.*")] |
| //[assembly: AssemblyVersion("1.0.0.0")] |
| //[assembly: AssemblyFileVersion("1.0.0.0")] |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/bin/Debug/GMap.NET.Core.dll |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/bin/Debug/GMap.NET.Core.pdb |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/bin/Debug/GMap.NET.WindowsPresentation.dll |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/bin/Debug/GMap.NET.WindowsPresentation.pdb |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/bin/Release/GMap.NET.Core.dll |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/bin/Release/GMap.NET.WindowsPresentation.XML |
|---|
| 0,0 → 1,425 |
| <?xml version="1.0"?> |
| <doc> |
| <assembly> |
| <name>GMap.NET.WindowsPresentation</name> |
| </assembly> |
| <members> |
| <member name="T:GMap.NET.WindowsPresentation.GMapMarker"> |
| <summary> |
| GMap.NET marker |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapMarker.Shape"> |
| <summary> |
| marker visual |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapMarker.Position"> |
| <summary> |
| coordinate of marker |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapMarker.Map"> |
| <summary> |
| the map of this marker |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapMarker.Tag"> |
| <summary> |
| custom object |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapMarker.Offset"> |
| <summary> |
| offset of marker |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapMarker.LocalPositionX"> |
| <summary> |
| local X position of marker |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapMarker.LocalPositionY"> |
| <summary> |
| local Y position of marker |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapMarker.ZIndex"> |
| <summary> |
| the index of Z, render order |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapMarker.Clear"> |
| <summary> |
| calls Dispose on shape if it implements IDisposable, sets shape to null and clears route |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapMarker.UpdateLocalPosition"> |
| <summary> |
| updates marker position, internal access usualy |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapMarker.ForceUpdateLocalPosition(GMap.NET.WindowsPresentation.GMapControl)"> |
| <summary> |
| forces to update local marker position |
| dot not call it if you don't really need to ;} |
| </summary> |
| <param name="m"></param> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapPolygon.RegenerateShape(GMap.NET.WindowsPresentation.GMapControl)"> |
| <summary> |
| regenerates shape of polygon |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapRoute.RegenerateShape(GMap.NET.WindowsPresentation.GMapControl)"> |
| <summary> |
| regenerates shape of route |
| </summary> |
| </member> |
| <member name="T:GMap.NET.WindowsPresentation.GMapImage"> |
| <summary> |
| image abstraction |
| </summary> |
| </member> |
| <member name="T:GMap.NET.WindowsPresentation.GMapImageProxy"> |
| <summary> |
| image abstraction proxy |
| </summary> |
| </member> |
| <member name="T:GMap.NET.WindowsPresentation.GMapControl"> |
| <summary> |
| GMap.NET control for Windows Presentation |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.MapProvider"> |
| <summary> |
| type of map |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.Zoom"> |
| <summary> |
| map zoom |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.ScaleMode"> |
| <summary> |
| Specifies, if a floating map scale is displayed using a |
| stretched, or a narrowed map. |
| If <code>ScaleMode</code> is <code>ScaleDown</code>, |
| then a scale of 12.3 is displayed using a map zoom level of 13 |
| resized to the lower level. If the parameter is <code>ScaleUp</code> , |
| then the same scale is displayed using a zoom level of 12 with an |
| enlarged scale. If the value is <code>Dynamic</code>, then until a |
| remainder of 0.25 <code>ScaleUp</code> is applied, for bigger |
| remainders <code>ScaleDown</code>. |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.FillEmptyTiles"> |
| <summary> |
| enables filling empty tiles using lower level images |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.MaxZoom"> |
| <summary> |
| max zoom |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.MinZoom"> |
| <summary> |
| min zoom |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.EmptyTileBorders"> |
| <summary> |
| pen for empty tile borders |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.SelectionPen"> |
| <summary> |
| pen for Selection |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.SelectedAreaFill"> |
| <summary> |
| background of selected area |
| </summary> |
| </member> |
| <!-- Ungültiger XML-Kommentar wurde für den Member "F:GMap.NET.WindowsPresentation.GMapControl.EmptytileBrush" ignoriert --> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.EmptyTileText"> |
| <summary> |
| text on empty tiles |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.MouseWheelZoomType"> |
| <summary> |
| map zooming type for mouse wheel |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.MouseWheelZoomEnabled"> |
| <summary> |
| enable map zoom on mouse wheel |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.DragButton"> |
| <summary> |
| map dragg button |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.SelectionUseCircle"> |
| <summary> |
| use circle for selection |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.ShowTileGridLines"> |
| <summary> |
| shows tile gridlines |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.RetryLoadTile"> |
| <summary> |
| retry count to get tile |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.LevelsKeepInMemmory"> |
| <summary> |
| how many levels of tiles are staying decompresed in memory |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.selectedArea"> |
| <summary> |
| current selected area in map |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.TouchEnabled"> |
| <summary> |
| is touch control enabled |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.BoundsOfMap"> |
| <summary> |
| map boundaries |
| </summary> |
| </member> |
| <member name="E:GMap.NET.WindowsPresentation.GMapControl.OnSelectionChange"> |
| <summary> |
| occurs when mouse selection is changed |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.Markers"> |
| <summary> |
| list of markers |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.MapTranslateTransform"> |
| <summary> |
| current markers overlay offset |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.MapCanvas"> |
| <summary> |
| markers overlay |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.InvalidateVisual"> |
| <summary> |
| enque built-in thread safe invalidation |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.InvalidateVisual(System.Boolean)"> |
| <summary> |
| Invalidates the rendering of the element, and forces a complete new layout |
| pass. System.Windows.UIElement.OnRender(System.Windows.Media.DrawingContext) |
| is called after the layout cycle is completed. If not forced enques built-in thread safe invalidation |
| </summary> |
| <param name="forced"></param> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.GMapControl_Loaded(System.Object,System.Windows.RoutedEventArgs)"> |
| <summary> |
| inits core system |
| </summary> |
| <param name="sender"></param> |
| <param name="e"></param> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.GMapControl_SizeChanged(System.Object,System.Windows.SizeChangedEventArgs)"> |
| <summary> |
| recalculates size |
| </summary> |
| <param name="sender"></param> |
| <param name="e"></param> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.UpdateMarkersOffset"> |
| <summary> |
| updates markers overlay offset |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.DrawMap(System.Windows.Media.DrawingContext)"> |
| <summary> |
| render map in WPF |
| </summary> |
| <param name="g"></param> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.ToImageSource"> |
| <summary> |
| gets image of the current view |
| </summary> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.CreateRoutePath(System.Collections.Generic.List{System.Windows.Point})"> |
| <summary> |
| creates path from list of points, for performance set addBlurEffect to false |
| </summary> |
| <param name="pl"></param> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.CreateRoutePath(System.Collections.Generic.List{System.Windows.Point},System.Boolean)"> |
| <summary> |
| creates path from list of points, for performance set addBlurEffect to false |
| </summary> |
| <param name="pl"></param> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.CreatePolygonPath(System.Collections.Generic.List{System.Windows.Point})"> |
| <summary> |
| creates path from list of points, for performance set addBlurEffect to false |
| </summary> |
| <param name="pl"></param> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.CreatePolygonPath(System.Collections.Generic.List{System.Windows.Point},System.Boolean)"> |
| <summary> |
| creates path from list of points, for performance set addBlurEffect to false |
| </summary> |
| <param name="pl"></param> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.SetZoomToFitRect(GMap.NET.RectLatLng)"> |
| <summary> |
| sets zoom to max to fit rect |
| </summary> |
| <param name="rect">area</param> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.ZoomAndCenterMarkers(System.Nullable{System.Int32})"> |
| <summary> |
| sets to max zoom to fit all markers and centers them in map |
| </summary> |
| <param name="ZIndex">z index or null to check all</param> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.GetRectOfAllMarkers(System.Nullable{System.Int32})"> |
| <summary> |
| gets rectangle with all objects inside |
| </summary> |
| <param name="ZIndex">z index or null to check all</param> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.Offset(System.Int32,System.Int32)"> |
| <summary> |
| offset position in pixels |
| </summary> |
| <param name="x"></param> |
| <param name="y"></param> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.UpdateRotationMatrix"> |
| <summary> |
| updates rotation matrix |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.IsRotated"> |
| <summary> |
| returs true if map bearing is not zero |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.Bearing"> |
| <summary> |
| bearing for rotation of the map |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.ApplyRotation(System.Double,System.Double)"> |
| <summary> |
| apply transformation if in rotation mode |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.ApplyRotationInversion(System.Double,System.Double)"> |
| <summary> |
| apply transformation if in rotation mode |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.HelperLineOption"> |
| <summary> |
| draw lines at the mouse pointer position |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.InvertedMouseWheelZooming"> |
| <summary> |
| reverses MouseWheel zooming direction |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.IgnoreMarkerOnMouseWheel"> |
| <summary> |
| lets you zoom by MouseWheel even when pointer is in area of marker |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.DisableAltForSelection"> |
| <summary> |
| if true, selects area just by holding mouse and moving |
| </summary> |
| </member> |
| <!-- Ungültiger XML-Kommentar wurde für den Member "M:GMap.NET.WindowsPresentation.GMapControl.ReloadMap" ignoriert --> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.SetPositionByKeywords(System.String)"> |
| <summary> |
| sets position using geocoder |
| </summary> |
| <param name="keys"></param> |
| <returns></returns> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.Position"> |
| <summary> |
| current coordinates of the map center |
| </summary> |
| </member> |
| <member name="E:GMap.NET.WindowsPresentation.GMapControl.OnMapTypeChanged"> |
| <summary> |
| occures on map type changed |
| </summary> |
| </member> |
| <member name="E:GMap.NET.WindowsPresentation.GMapControl.OnEmptyTileError"> |
| <summary> |
| occurs on empty tile displayed |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.ScaleModes.Integer"> |
| <summary> |
| no scaling |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.ScaleModes.ScaleUp"> |
| <summary> |
| scales to fractional level using a stretched tiles, any issues -> http://greatmaps.codeplex.com/workitem/16046 |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.ScaleModes.ScaleDown"> |
| <summary> |
| scales to fractional level using a narrowed tiles, any issues -> http://greatmaps.codeplex.com/workitem/16046 |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.ScaleModes.Dynamic"> |
| <summary> |
| scales to fractional level using a combination both stretched and narrowed tiles, any issues -> http://greatmaps.codeplex.com/workitem/16046 |
| </summary> |
| </member> |
| <member name="T:GMap.NET.WindowsPresentation.TilePrefetcher"> |
| <summary> |
| form helping to prefetch tiles on local db |
| </summary> |
| <summary> |
| TilePrefetcher |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.TilePrefetcher.InitializeComponent"> |
| <summary> |
| InitializeComponent |
| </summary> |
| </member> |
| </members> |
| </doc> |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/bin/Release/GMap.NET.WindowsPresentation.dll |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/bin/x86/Release/GMap.NET.WindowsPresentation.XML |
|---|
| 0,0 → 1,425 |
| <?xml version="1.0"?> |
| <doc> |
| <assembly> |
| <name>GMap.NET.WindowsPresentation</name> |
| </assembly> |
| <members> |
| <member name="T:GMap.NET.WindowsPresentation.GMapMarker"> |
| <summary> |
| GMap.NET marker |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapMarker.Shape"> |
| <summary> |
| marker visual |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapMarker.Position"> |
| <summary> |
| coordinate of marker |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapMarker.Map"> |
| <summary> |
| the map of this marker |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapMarker.Tag"> |
| <summary> |
| custom object |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapMarker.Offset"> |
| <summary> |
| offset of marker |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapMarker.LocalPositionX"> |
| <summary> |
| local X position of marker |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapMarker.LocalPositionY"> |
| <summary> |
| local Y position of marker |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapMarker.ZIndex"> |
| <summary> |
| the index of Z, render order |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapMarker.Clear"> |
| <summary> |
| calls Dispose on shape if it implements IDisposable, sets shape to null and clears route |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapMarker.UpdateLocalPosition"> |
| <summary> |
| updates marker position, internal access usualy |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapMarker.ForceUpdateLocalPosition(GMap.NET.WindowsPresentation.GMapControl)"> |
| <summary> |
| forces to update local marker position |
| dot not call it if you don't really need to ;} |
| </summary> |
| <param name="m"></param> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapPolygon.RegenerateShape(GMap.NET.WindowsPresentation.GMapControl)"> |
| <summary> |
| regenerates shape of polygon |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapRoute.RegenerateShape(GMap.NET.WindowsPresentation.GMapControl)"> |
| <summary> |
| regenerates shape of route |
| </summary> |
| </member> |
| <member name="T:GMap.NET.WindowsPresentation.GMapImage"> |
| <summary> |
| image abstraction |
| </summary> |
| </member> |
| <member name="T:GMap.NET.WindowsPresentation.GMapImageProxy"> |
| <summary> |
| image abstraction proxy |
| </summary> |
| </member> |
| <member name="T:GMap.NET.WindowsPresentation.GMapControl"> |
| <summary> |
| GMap.NET control for Windows Presentation |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.MapProvider"> |
| <summary> |
| type of map |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.Zoom"> |
| <summary> |
| map zoom |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.ScaleMode"> |
| <summary> |
| Specifies, if a floating map scale is displayed using a |
| stretched, or a narrowed map. |
| If <code>ScaleMode</code> is <code>ScaleDown</code>, |
| then a scale of 12.3 is displayed using a map zoom level of 13 |
| resized to the lower level. If the parameter is <code>ScaleUp</code> , |
| then the same scale is displayed using a zoom level of 12 with an |
| enlarged scale. If the value is <code>Dynamic</code>, then until a |
| remainder of 0.25 <code>ScaleUp</code> is applied, for bigger |
| remainders <code>ScaleDown</code>. |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.FillEmptyTiles"> |
| <summary> |
| enables filling empty tiles using lower level images |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.MaxZoom"> |
| <summary> |
| max zoom |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.MinZoom"> |
| <summary> |
| min zoom |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.EmptyTileBorders"> |
| <summary> |
| pen for empty tile borders |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.SelectionPen"> |
| <summary> |
| pen for Selection |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.SelectedAreaFill"> |
| <summary> |
| background of selected area |
| </summary> |
| </member> |
| <!-- Ungültiger XML-Kommentar wurde für den Member "F:GMap.NET.WindowsPresentation.GMapControl.EmptytileBrush" ignoriert --> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.EmptyTileText"> |
| <summary> |
| text on empty tiles |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.MouseWheelZoomType"> |
| <summary> |
| map zooming type for mouse wheel |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.MouseWheelZoomEnabled"> |
| <summary> |
| enable map zoom on mouse wheel |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.DragButton"> |
| <summary> |
| map dragg button |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.SelectionUseCircle"> |
| <summary> |
| use circle for selection |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.ShowTileGridLines"> |
| <summary> |
| shows tile gridlines |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.RetryLoadTile"> |
| <summary> |
| retry count to get tile |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.LevelsKeepInMemmory"> |
| <summary> |
| how many levels of tiles are staying decompresed in memory |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.selectedArea"> |
| <summary> |
| current selected area in map |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.TouchEnabled"> |
| <summary> |
| is touch control enabled |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.BoundsOfMap"> |
| <summary> |
| map boundaries |
| </summary> |
| </member> |
| <member name="E:GMap.NET.WindowsPresentation.GMapControl.OnSelectionChange"> |
| <summary> |
| occurs when mouse selection is changed |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.Markers"> |
| <summary> |
| list of markers |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.MapTranslateTransform"> |
| <summary> |
| current markers overlay offset |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.MapCanvas"> |
| <summary> |
| markers overlay |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.InvalidateVisual"> |
| <summary> |
| enque built-in thread safe invalidation |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.InvalidateVisual(System.Boolean)"> |
| <summary> |
| Invalidates the rendering of the element, and forces a complete new layout |
| pass. System.Windows.UIElement.OnRender(System.Windows.Media.DrawingContext) |
| is called after the layout cycle is completed. If not forced enques built-in thread safe invalidation |
| </summary> |
| <param name="forced"></param> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.GMapControl_Loaded(System.Object,System.Windows.RoutedEventArgs)"> |
| <summary> |
| inits core system |
| </summary> |
| <param name="sender"></param> |
| <param name="e"></param> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.GMapControl_SizeChanged(System.Object,System.Windows.SizeChangedEventArgs)"> |
| <summary> |
| recalculates size |
| </summary> |
| <param name="sender"></param> |
| <param name="e"></param> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.UpdateMarkersOffset"> |
| <summary> |
| updates markers overlay offset |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.DrawMap(System.Windows.Media.DrawingContext)"> |
| <summary> |
| render map in WPF |
| </summary> |
| <param name="g"></param> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.ToImageSource"> |
| <summary> |
| gets image of the current view |
| </summary> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.CreateRoutePath(System.Collections.Generic.List{System.Windows.Point})"> |
| <summary> |
| creates path from list of points, for performance set addBlurEffect to false |
| </summary> |
| <param name="pl"></param> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.CreateRoutePath(System.Collections.Generic.List{System.Windows.Point},System.Boolean)"> |
| <summary> |
| creates path from list of points, for performance set addBlurEffect to false |
| </summary> |
| <param name="pl"></param> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.CreatePolygonPath(System.Collections.Generic.List{System.Windows.Point})"> |
| <summary> |
| creates path from list of points, for performance set addBlurEffect to false |
| </summary> |
| <param name="pl"></param> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.CreatePolygonPath(System.Collections.Generic.List{System.Windows.Point},System.Boolean)"> |
| <summary> |
| creates path from list of points, for performance set addBlurEffect to false |
| </summary> |
| <param name="pl"></param> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.SetZoomToFitRect(GMap.NET.RectLatLng)"> |
| <summary> |
| sets zoom to max to fit rect |
| </summary> |
| <param name="rect">area</param> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.ZoomAndCenterMarkers(System.Nullable{System.Int32})"> |
| <summary> |
| sets to max zoom to fit all markers and centers them in map |
| </summary> |
| <param name="ZIndex">z index or null to check all</param> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.GetRectOfAllMarkers(System.Nullable{System.Int32})"> |
| <summary> |
| gets rectangle with all objects inside |
| </summary> |
| <param name="ZIndex">z index or null to check all</param> |
| <returns></returns> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.Offset(System.Int32,System.Int32)"> |
| <summary> |
| offset position in pixels |
| </summary> |
| <param name="x"></param> |
| <param name="y"></param> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.UpdateRotationMatrix"> |
| <summary> |
| updates rotation matrix |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.IsRotated"> |
| <summary> |
| returs true if map bearing is not zero |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.Bearing"> |
| <summary> |
| bearing for rotation of the map |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.ApplyRotation(System.Double,System.Double)"> |
| <summary> |
| apply transformation if in rotation mode |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.ApplyRotationInversion(System.Double,System.Double)"> |
| <summary> |
| apply transformation if in rotation mode |
| </summary> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.HelperLineOption"> |
| <summary> |
| draw lines at the mouse pointer position |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.InvertedMouseWheelZooming"> |
| <summary> |
| reverses MouseWheel zooming direction |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.IgnoreMarkerOnMouseWheel"> |
| <summary> |
| lets you zoom by MouseWheel even when pointer is in area of marker |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.GMapControl.DisableAltForSelection"> |
| <summary> |
| if true, selects area just by holding mouse and moving |
| </summary> |
| </member> |
| <!-- Ungültiger XML-Kommentar wurde für den Member "M:GMap.NET.WindowsPresentation.GMapControl.ReloadMap" ignoriert --> |
| <member name="M:GMap.NET.WindowsPresentation.GMapControl.SetPositionByKeywords(System.String)"> |
| <summary> |
| sets position using geocoder |
| </summary> |
| <param name="keys"></param> |
| <returns></returns> |
| </member> |
| <member name="P:GMap.NET.WindowsPresentation.GMapControl.Position"> |
| <summary> |
| current coordinates of the map center |
| </summary> |
| </member> |
| <member name="E:GMap.NET.WindowsPresentation.GMapControl.OnMapTypeChanged"> |
| <summary> |
| occures on map type changed |
| </summary> |
| </member> |
| <member name="E:GMap.NET.WindowsPresentation.GMapControl.OnEmptyTileError"> |
| <summary> |
| occurs on empty tile displayed |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.ScaleModes.Integer"> |
| <summary> |
| no scaling |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.ScaleModes.ScaleUp"> |
| <summary> |
| scales to fractional level using a stretched tiles, any issues -> http://greatmaps.codeplex.com/workitem/16046 |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.ScaleModes.ScaleDown"> |
| <summary> |
| scales to fractional level using a narrowed tiles, any issues -> http://greatmaps.codeplex.com/workitem/16046 |
| </summary> |
| </member> |
| <member name="F:GMap.NET.WindowsPresentation.ScaleModes.Dynamic"> |
| <summary> |
| scales to fractional level using a combination both stretched and narrowed tiles, any issues -> http://greatmaps.codeplex.com/workitem/16046 |
| </summary> |
| </member> |
| <member name="T:GMap.NET.WindowsPresentation.TilePrefetcher"> |
| <summary> |
| form helping to prefetch tiles on local db |
| </summary> |
| <summary> |
| TilePrefetcher |
| </summary> |
| </member> |
| <member name="M:GMap.NET.WindowsPresentation.TilePrefetcher.InitializeComponent"> |
| <summary> |
| InitializeComponent |
| </summary> |
| </member> |
| </members> |
| </doc> |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Debug/GMap.NET.WindowsPresentation/CustomMarkers/CustomMarkerCopter.g.i.cs |
|---|
| 0,0 → 1,99 |
| #pragma checksum "..\..\..\..\GMap.NET.WindowsPresentation\CustomMarkers\CustomMarkerCopter.xaml" "{406ea660-64cf-4c82-b6f0-42d48172a799}" "E9585AE00E8D65D861CCFFF4BF07524B" |
| //------------------------------------------------------------------------------ |
| // <auto-generated> |
| // Dieser Code wurde von einem Tool generiert. |
| // Laufzeitversion:4.0.30319.42000 |
| // |
| // Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn |
| // der Code erneut generiert wird. |
| // </auto-generated> |
| //------------------------------------------------------------------------------ |
| using System; |
| using System.Diagnostics; |
| using System.Windows; |
| using System.Windows.Automation; |
| using System.Windows.Controls; |
| using System.Windows.Controls.Primitives; |
| using System.Windows.Data; |
| using System.Windows.Documents; |
| using System.Windows.Ink; |
| using System.Windows.Input; |
| using System.Windows.Markup; |
| using System.Windows.Media; |
| using System.Windows.Media.Animation; |
| using System.Windows.Media.Effects; |
| using System.Windows.Media.Imaging; |
| using System.Windows.Media.Media3D; |
| using System.Windows.Media.TextFormatting; |
| using System.Windows.Navigation; |
| using System.Windows.Shapes; |
| namespace MKLiveView.GMapCustomMarkers { |
| /// <summary> |
| /// CustomMarkerCopter |
| /// </summary> |
| public partial class CustomMarkerCopter : System.Windows.Controls.UserControl, System.Windows.Markup.IComponentConnector { |
| #line 7 "..\..\..\..\GMap.NET.WindowsPresentation\CustomMarkers\CustomMarkerCopter.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.Image icon; |
| #line default |
| #line hidden |
| #line 8 "..\..\..\..\GMap.NET.WindowsPresentation\CustomMarkers\CustomMarkerCopter.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.Label lbl; |
| #line default |
| #line hidden |
| private bool _contentLoaded; |
| /// <summary> |
| /// InitializeComponent |
| /// </summary> |
| [System.Diagnostics.DebuggerNonUserCodeAttribute()] |
| [System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")] |
| public void InitializeComponent() { |
| if (_contentLoaded) { |
| return; |
| } |
| _contentLoaded = true; |
| System.Uri resourceLocater = new System.Uri("/GMap.NET.WindowsPresentation;component/gmap.net.windowspresentation/custommarker" + |
| "s/custommarkercopter.xaml", System.UriKind.Relative); |
| #line 1 "..\..\..\..\GMap.NET.WindowsPresentation\CustomMarkers\CustomMarkerCopter.xaml" |
| System.Windows.Application.LoadComponent(this, resourceLocater); |
| #line default |
| #line hidden |
| } |
| [System.Diagnostics.DebuggerNonUserCodeAttribute()] |
| [System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")] |
| [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes")] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")] |
| void System.Windows.Markup.IComponentConnector.Connect(int connectionId, object target) { |
| switch (connectionId) |
| { |
| case 1: |
| this.icon = ((System.Windows.Controls.Image)(target)); |
| return; |
| case 2: |
| this.lbl = ((System.Windows.Controls.Label)(target)); |
| return; |
| } |
| this._contentLoaded = true; |
| } |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Debug/GMap.NET.WindowsPresentation/GMapCustomMarkers/CustomMarkerCopter.g.i.cs |
|---|
| 0,0 → 1,99 |
| #pragma checksum "..\..\..\..\GMap.NET.WindowsPresentation\GMapCustomMarkers\CustomMarkerCopter.xaml" "{406ea660-64cf-4c82-b6f0-42d48172a799}" "E9585AE00E8D65D861CCFFF4BF07524B" |
| //------------------------------------------------------------------------------ |
| // <auto-generated> |
| // Dieser Code wurde von einem Tool generiert. |
| // Laufzeitversion:4.0.30319.42000 |
| // |
| // Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn |
| // der Code erneut generiert wird. |
| // </auto-generated> |
| //------------------------------------------------------------------------------ |
| using System; |
| using System.Diagnostics; |
| using System.Windows; |
| using System.Windows.Automation; |
| using System.Windows.Controls; |
| using System.Windows.Controls.Primitives; |
| using System.Windows.Data; |
| using System.Windows.Documents; |
| using System.Windows.Ink; |
| using System.Windows.Input; |
| using System.Windows.Markup; |
| using System.Windows.Media; |
| using System.Windows.Media.Animation; |
| using System.Windows.Media.Effects; |
| using System.Windows.Media.Imaging; |
| using System.Windows.Media.Media3D; |
| using System.Windows.Media.TextFormatting; |
| using System.Windows.Navigation; |
| using System.Windows.Shapes; |
| namespace MKLiveView.GMapCustomMarkers { |
| /// <summary> |
| /// CustomMarkerCopter |
| /// </summary> |
| public partial class CustomMarkerCopter : System.Windows.Controls.UserControl, System.Windows.Markup.IComponentConnector { |
| #line 7 "..\..\..\..\GMap.NET.WindowsPresentation\GMapCustomMarkers\CustomMarkerCopter.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.Image icon; |
| #line default |
| #line hidden |
| #line 8 "..\..\..\..\GMap.NET.WindowsPresentation\GMapCustomMarkers\CustomMarkerCopter.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.Label lbl; |
| #line default |
| #line hidden |
| private bool _contentLoaded; |
| /// <summary> |
| /// InitializeComponent |
| /// </summary> |
| [System.Diagnostics.DebuggerNonUserCodeAttribute()] |
| [System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")] |
| public void InitializeComponent() { |
| if (_contentLoaded) { |
| return; |
| } |
| _contentLoaded = true; |
| System.Uri resourceLocater = new System.Uri("/GMap.NET.WindowsPresentation;component/gmap.net.windowspresentation/gmapcustomma" + |
| "rkers/custommarkercopter.xaml", System.UriKind.Relative); |
| #line 1 "..\..\..\..\GMap.NET.WindowsPresentation\GMapCustomMarkers\CustomMarkerCopter.xaml" |
| System.Windows.Application.LoadComponent(this, resourceLocater); |
| #line default |
| #line hidden |
| } |
| [System.Diagnostics.DebuggerNonUserCodeAttribute()] |
| [System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")] |
| [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes")] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")] |
| void System.Windows.Markup.IComponentConnector.Connect(int connectionId, object target) { |
| switch (connectionId) |
| { |
| case 1: |
| this.icon = ((System.Windows.Controls.Image)(target)); |
| return; |
| case 2: |
| this.lbl = ((System.Windows.Controls.Label)(target)); |
| return; |
| } |
| this._contentLoaded = true; |
| } |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Debug/GMap.NET.WindowsPresentation/TilePrefetcher.baml |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Debug/GMap.NET.WindowsPresentation/TilePrefetcher.g.cs |
|---|
| 0,0 → 1,110 |
| #pragma checksum "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" "{406ea660-64cf-4c82-b6f0-42d48172a799}" "5F413214037FE2C590D0586359AABDF4" |
| //------------------------------------------------------------------------------ |
| // <auto-generated> |
| // Dieser Code wurde von einem Tool generiert. |
| // Laufzeitversion:4.0.30319.42000 |
| // |
| // Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn |
| // der Code erneut generiert wird. |
| // </auto-generated> |
| //------------------------------------------------------------------------------ |
| using System; |
| using System.Diagnostics; |
| using System.Windows; |
| using System.Windows.Automation; |
| using System.Windows.Controls; |
| using System.Windows.Controls.Primitives; |
| using System.Windows.Data; |
| using System.Windows.Documents; |
| using System.Windows.Ink; |
| using System.Windows.Input; |
| using System.Windows.Markup; |
| using System.Windows.Media; |
| using System.Windows.Media.Animation; |
| using System.Windows.Media.Effects; |
| using System.Windows.Media.Imaging; |
| using System.Windows.Media.Media3D; |
| using System.Windows.Media.TextFormatting; |
| using System.Windows.Navigation; |
| using System.Windows.Shapes; |
| namespace GMap.NET.WindowsPresentation { |
| /// <summary> |
| /// TilePrefetcher |
| /// </summary> |
| public partial class TilePrefetcher : System.Windows.Window, System.Windows.Markup.IComponentConnector { |
| #line 6 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.TextBlock label1; |
| #line default |
| #line hidden |
| #line 7 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.ProgressBar progressBar1; |
| #line default |
| #line hidden |
| #line 8 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.TextBlock label2; |
| #line default |
| #line hidden |
| private bool _contentLoaded; |
| /// <summary> |
| /// InitializeComponent |
| /// </summary> |
| [System.Diagnostics.DebuggerNonUserCodeAttribute()] |
| [System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")] |
| public void InitializeComponent() { |
| if (_contentLoaded) { |
| return; |
| } |
| _contentLoaded = true; |
| System.Uri resourceLocater = new System.Uri("/GMap.NET.WindowsPresentation;component/gmap.net.windowspresentation/tileprefetch" + |
| "er.xaml", System.UriKind.Relative); |
| #line 1 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| System.Windows.Application.LoadComponent(this, resourceLocater); |
| #line default |
| #line hidden |
| } |
| [System.Diagnostics.DebuggerNonUserCodeAttribute()] |
| [System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")] |
| [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes")] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")] |
| void System.Windows.Markup.IComponentConnector.Connect(int connectionId, object target) { |
| switch (connectionId) |
| { |
| case 1: |
| this.label1 = ((System.Windows.Controls.TextBlock)(target)); |
| return; |
| case 2: |
| this.progressBar1 = ((System.Windows.Controls.ProgressBar)(target)); |
| return; |
| case 3: |
| this.label2 = ((System.Windows.Controls.TextBlock)(target)); |
| return; |
| } |
| this._contentLoaded = true; |
| } |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Debug/GMap.NET.WindowsPresentation/TilePrefetcher.g.i.cs |
|---|
| 0,0 → 1,110 |
| #pragma checksum "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" "{406ea660-64cf-4c82-b6f0-42d48172a799}" "5F413214037FE2C590D0586359AABDF4" |
| //------------------------------------------------------------------------------ |
| // <auto-generated> |
| // Dieser Code wurde von einem Tool generiert. |
| // Laufzeitversion:4.0.30319.42000 |
| // |
| // Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn |
| // der Code erneut generiert wird. |
| // </auto-generated> |
| //------------------------------------------------------------------------------ |
| using System; |
| using System.Diagnostics; |
| using System.Windows; |
| using System.Windows.Automation; |
| using System.Windows.Controls; |
| using System.Windows.Controls.Primitives; |
| using System.Windows.Data; |
| using System.Windows.Documents; |
| using System.Windows.Ink; |
| using System.Windows.Input; |
| using System.Windows.Markup; |
| using System.Windows.Media; |
| using System.Windows.Media.Animation; |
| using System.Windows.Media.Effects; |
| using System.Windows.Media.Imaging; |
| using System.Windows.Media.Media3D; |
| using System.Windows.Media.TextFormatting; |
| using System.Windows.Navigation; |
| using System.Windows.Shapes; |
| namespace GMap.NET.WindowsPresentation { |
| /// <summary> |
| /// TilePrefetcher |
| /// </summary> |
| public partial class TilePrefetcher : System.Windows.Window, System.Windows.Markup.IComponentConnector { |
| #line 6 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.TextBlock label1; |
| #line default |
| #line hidden |
| #line 7 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.ProgressBar progressBar1; |
| #line default |
| #line hidden |
| #line 8 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.TextBlock label2; |
| #line default |
| #line hidden |
| private bool _contentLoaded; |
| /// <summary> |
| /// InitializeComponent |
| /// </summary> |
| [System.Diagnostics.DebuggerNonUserCodeAttribute()] |
| [System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")] |
| public void InitializeComponent() { |
| if (_contentLoaded) { |
| return; |
| } |
| _contentLoaded = true; |
| System.Uri resourceLocater = new System.Uri("/GMap.NET.WindowsPresentation;component/gmap.net.windowspresentation/tileprefetch" + |
| "er.xaml", System.UriKind.Relative); |
| #line 1 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| System.Windows.Application.LoadComponent(this, resourceLocater); |
| #line default |
| #line hidden |
| } |
| [System.Diagnostics.DebuggerNonUserCodeAttribute()] |
| [System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")] |
| [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes")] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")] |
| void System.Windows.Markup.IComponentConnector.Connect(int connectionId, object target) { |
| switch (connectionId) |
| { |
| case 1: |
| this.label1 = ((System.Windows.Controls.TextBlock)(target)); |
| return; |
| case 2: |
| this.progressBar1 = ((System.Windows.Controls.ProgressBar)(target)); |
| return; |
| case 3: |
| this.label2 = ((System.Windows.Controls.TextBlock)(target)); |
| return; |
| } |
| this._contentLoaded = true; |
| } |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Debug/GMap.NET.WindowsPresentation.csproj.FileListAbsolute.txt |
|---|
| 0,0 → 1,22 |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\obj\Debug\GMap.NET.WindowsPresentation\TilePrefetcher.baml |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\obj\Debug\GMap.NET.WindowsPresentation\TilePrefetcher.g.cs |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\obj\Debug\GMap.NET.WindowsPresentation_MarkupCompile.cache |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\obj\Debug\GMap.NET.WindowsPresentation.g.resources |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\bin\Debug\GMap.NET.WindowsPresentation.dll |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\bin\Debug\GMap.NET.WindowsPresentation.pdb |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\bin\Debug\GMap.NET.Core.dll |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\bin\Debug\GMap.NET.Core.pdb |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\obj\Debug\GMap.NET.WindowsPresentation.csprojResolveAssemblyReference.cache |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\obj\Debug\GMap.NET.WindowsPresentation.dll |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\obj\Debug\GMap.NET.WindowsPresentation.pdb |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\bin\Debug\GMap.NET.WindowsPresentation.dll |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\bin\Debug\GMap.NET.WindowsPresentation.pdb |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\bin\Debug\GMap.NET.Core.dll |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\bin\Debug\GMap.NET.Core.pdb |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Debug\GMap.NET.WindowsPresentation.csprojResolveAssemblyReference.cache |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Debug\GMap.NET.WindowsPresentation\TilePrefetcher.baml |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Debug\GMap.NET.WindowsPresentation\TilePrefetcher.g.cs |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Debug\GMap.NET.WindowsPresentation_MarkupCompile.cache |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Debug\GMap.NET.WindowsPresentation.g.resources |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Debug\GMap.NET.WindowsPresentation.dll |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Debug\GMap.NET.WindowsPresentation.pdb |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Debug/GMap.NET.WindowsPresentation.csprojResolveAssemblyReference.cache |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Debug/GMap.NET.WindowsPresentation.dll |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Debug/GMap.NET.WindowsPresentation.g.resources |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Debug/GMap.NET.WindowsPresentation.pdb |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Debug/GMap.NET.WindowsPresentation_MarkupCompile.cache |
|---|
| 0,0 → 1,20 |
| GMap.NET.WindowsPresentation |
| library |
| C# |
| .cs |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Debug\ |
| GMap.NET.WindowsPresentation |
| none |
| false |
| TRACE;DEBUG |
| 1544584187 |
| 81379478519 |
| 71028211644 |
| GMap.NET.WindowsPresentation\TilePrefetcher.xaml; |
| False |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Debug/GMap.NET.WindowsPresentation_MarkupCompile.i.cache |
|---|
| 0,0 → 1,20 |
| GMap.NET.WindowsPresentation |
| library |
| C# |
| .cs |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Debug\ |
| GMap.NET.WindowsPresentation |
| none |
| false |
| TRACE;DEBUG |
| 1544584187 |
| 81379478519 |
| 71028211644 |
| GMap.NET.WindowsPresentation\TilePrefetcher.xaml; |
| False |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Release/GMap.NET.WindowsPresentation/TilePrefetcher.baml |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Release/GMap.NET.WindowsPresentation/TilePrefetcher.g.cs |
|---|
| 0,0 → 1,110 |
| #pragma checksum "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" "{406ea660-64cf-4c82-b6f0-42d48172a799}" "5F413214037FE2C590D0586359AABDF4" |
| //------------------------------------------------------------------------------ |
| // <auto-generated> |
| // Dieser Code wurde von einem Tool generiert. |
| // Laufzeitversion:4.0.30319.42000 |
| // |
| // Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn |
| // der Code erneut generiert wird. |
| // </auto-generated> |
| //------------------------------------------------------------------------------ |
| using System; |
| using System.Diagnostics; |
| using System.Windows; |
| using System.Windows.Automation; |
| using System.Windows.Controls; |
| using System.Windows.Controls.Primitives; |
| using System.Windows.Data; |
| using System.Windows.Documents; |
| using System.Windows.Ink; |
| using System.Windows.Input; |
| using System.Windows.Markup; |
| using System.Windows.Media; |
| using System.Windows.Media.Animation; |
| using System.Windows.Media.Effects; |
| using System.Windows.Media.Imaging; |
| using System.Windows.Media.Media3D; |
| using System.Windows.Media.TextFormatting; |
| using System.Windows.Navigation; |
| using System.Windows.Shapes; |
| namespace GMap.NET.WindowsPresentation { |
| /// <summary> |
| /// TilePrefetcher |
| /// </summary> |
| public partial class TilePrefetcher : System.Windows.Window, System.Windows.Markup.IComponentConnector { |
| #line 6 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.TextBlock label1; |
| #line default |
| #line hidden |
| #line 7 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.ProgressBar progressBar1; |
| #line default |
| #line hidden |
| #line 8 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.TextBlock label2; |
| #line default |
| #line hidden |
| private bool _contentLoaded; |
| /// <summary> |
| /// InitializeComponent |
| /// </summary> |
| [System.Diagnostics.DebuggerNonUserCodeAttribute()] |
| [System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")] |
| public void InitializeComponent() { |
| if (_contentLoaded) { |
| return; |
| } |
| _contentLoaded = true; |
| System.Uri resourceLocater = new System.Uri("/GMap.NET.WindowsPresentation;component/gmap.net.windowspresentation/tileprefetch" + |
| "er.xaml", System.UriKind.Relative); |
| #line 1 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| System.Windows.Application.LoadComponent(this, resourceLocater); |
| #line default |
| #line hidden |
| } |
| [System.Diagnostics.DebuggerNonUserCodeAttribute()] |
| [System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")] |
| [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes")] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")] |
| void System.Windows.Markup.IComponentConnector.Connect(int connectionId, object target) { |
| switch (connectionId) |
| { |
| case 1: |
| this.label1 = ((System.Windows.Controls.TextBlock)(target)); |
| return; |
| case 2: |
| this.progressBar1 = ((System.Windows.Controls.ProgressBar)(target)); |
| return; |
| case 3: |
| this.label2 = ((System.Windows.Controls.TextBlock)(target)); |
| return; |
| } |
| this._contentLoaded = true; |
| } |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Release/GMap.NET.WindowsPresentation/TilePrefetcher.g.i.cs |
|---|
| 0,0 → 1,110 |
| #pragma checksum "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" "{406ea660-64cf-4c82-b6f0-42d48172a799}" "5F413214037FE2C590D0586359AABDF4" |
| //------------------------------------------------------------------------------ |
| // <auto-generated> |
| // Dieser Code wurde von einem Tool generiert. |
| // Laufzeitversion:4.0.30319.42000 |
| // |
| // Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn |
| // der Code erneut generiert wird. |
| // </auto-generated> |
| //------------------------------------------------------------------------------ |
| using System; |
| using System.Diagnostics; |
| using System.Windows; |
| using System.Windows.Automation; |
| using System.Windows.Controls; |
| using System.Windows.Controls.Primitives; |
| using System.Windows.Data; |
| using System.Windows.Documents; |
| using System.Windows.Ink; |
| using System.Windows.Input; |
| using System.Windows.Markup; |
| using System.Windows.Media; |
| using System.Windows.Media.Animation; |
| using System.Windows.Media.Effects; |
| using System.Windows.Media.Imaging; |
| using System.Windows.Media.Media3D; |
| using System.Windows.Media.TextFormatting; |
| using System.Windows.Navigation; |
| using System.Windows.Shapes; |
| namespace GMap.NET.WindowsPresentation { |
| /// <summary> |
| /// TilePrefetcher |
| /// </summary> |
| public partial class TilePrefetcher : System.Windows.Window, System.Windows.Markup.IComponentConnector { |
| #line 6 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.TextBlock label1; |
| #line default |
| #line hidden |
| #line 7 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.ProgressBar progressBar1; |
| #line default |
| #line hidden |
| #line 8 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] |
| internal System.Windows.Controls.TextBlock label2; |
| #line default |
| #line hidden |
| private bool _contentLoaded; |
| /// <summary> |
| /// InitializeComponent |
| /// </summary> |
| [System.Diagnostics.DebuggerNonUserCodeAttribute()] |
| [System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")] |
| public void InitializeComponent() { |
| if (_contentLoaded) { |
| return; |
| } |
| _contentLoaded = true; |
| System.Uri resourceLocater = new System.Uri("/GMap.NET.WindowsPresentation;component/gmap.net.windowspresentation/tileprefetch" + |
| "er.xaml", System.UriKind.Relative); |
| #line 1 "..\..\..\GMap.NET.WindowsPresentation\TilePrefetcher.xaml" |
| System.Windows.Application.LoadComponent(this, resourceLocater); |
| #line default |
| #line hidden |
| } |
| [System.Diagnostics.DebuggerNonUserCodeAttribute()] |
| [System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")] |
| [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes")] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")] |
| [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")] |
| void System.Windows.Markup.IComponentConnector.Connect(int connectionId, object target) { |
| switch (connectionId) |
| { |
| case 1: |
| this.label1 = ((System.Windows.Controls.TextBlock)(target)); |
| return; |
| case 2: |
| this.progressBar1 = ((System.Windows.Controls.ProgressBar)(target)); |
| return; |
| case 3: |
| this.label2 = ((System.Windows.Controls.TextBlock)(target)); |
| return; |
| } |
| this._contentLoaded = true; |
| } |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Release/GMap.NET.WindowsPresentation.csproj.FileListAbsolute.txt |
|---|
| 0,0 → 1,18 |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\bin\Release\GMap.NET.WindowsPresentation.dll |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\bin\Release\GMap.NET.WindowsPresentation.XML |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\bin\Release\GMap.NET.Core.dll |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\obj\Release\GMap.NET.WindowsPresentation.csprojResolveAssemblyReference.cache |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\obj\Release\GMap.NET.WindowsPresentation\TilePrefetcher.baml |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\obj\Release\GMap.NET.WindowsPresentation\TilePrefetcher.g.cs |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\obj\Release\GMap.NET.WindowsPresentation_MarkupCompile.cache |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\obj\Release\GMap.NET.WindowsPresentation.g.resources |
| E:\Documents\VS Projects\_Beispiele etc\greatmaps-master\GMap.NET.WindowsPresentation\obj\Release\GMap.NET.WindowsPresentation.dll |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\bin\Release\GMap.NET.WindowsPresentation.dll |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\bin\Release\GMap.NET.WindowsPresentation.XML |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\bin\Release\GMap.NET.Core.dll |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Release\GMap.NET.WindowsPresentation.csprojResolveAssemblyReference.cache |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Release\GMap.NET.WindowsPresentation\TilePrefetcher.baml |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Release\GMap.NET.WindowsPresentation\TilePrefetcher.g.cs |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Release\GMap.NET.WindowsPresentation_MarkupCompile.cache |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Release\GMap.NET.WindowsPresentation.g.resources |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Release\GMap.NET.WindowsPresentation.dll |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Release/GMap.NET.WindowsPresentation.csprojResolveAssemblyReference.cache |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Release/GMap.NET.WindowsPresentation.dll |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Release/GMap.NET.WindowsPresentation.g.resources |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Release/GMap.NET.WindowsPresentation_MarkupCompile.cache |
|---|
| 0,0 → 1,20 |
| GMap.NET.WindowsPresentation |
| library |
| C# |
| .cs |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Release\ |
| GMap.NET.WindowsPresentation |
| none |
| false |
| TRACE |
| 1544584187 |
| 81379478519 |
| 7213700877 |
| GMap.NET.WindowsPresentation\TilePrefetcher.xaml; |
| False |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/obj/Release/GMap.NET.WindowsPresentation_MarkupCompile.i.cache |
|---|
| 0,0 → 1,20 |
| GMap.NET.WindowsPresentation |
| library |
| C# |
| .cs |
| E:\Documents\VS Projects\MKLiveView\WPF\MKLiveView\GMap.NET.WindowsPresentation\obj\Release\ |
| GMap.NET.WindowsPresentation |
| none |
| false |
| TRACE |
| 1544584187 |
| 81379478519 |
| 7213700877 |
| GMap.NET.WindowsPresentation\TilePrefetcher.xaml; |
| False |
| /MKLiveView/v1.0/GMap.NET.WindowsPresentation/sn.snk |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |