public void ObstructionViewer_ScrollChanged(object sender, ScrollChangedEventArgs e)
{
ScrollViewer scrollviewer = sender as ScrollViewer;
MapScrollViewer.ScrollToVerticalOffset(scrollviewer.VerticalOffset);
MapScrollViewer.ScrollToHorizontalOffset(scrollviewer.HorizontalOffset);
}
private async void LoadImageFile_OnClick(object sender, RoutedEventArgs e)
{
var filePicker = new FileOpenPicker();
filePicker.FileTypeFilter.Add(".jpg");
filePicker.FileTypeFilter.Add(".jpeg");
filePicker.FileTypeFilter.Add(".ppm");
var result = await filePicker.PickSingleFileAsync();
if (result != null)
{
_map.DeleteImage();
MapScrollViewer.ChangeView(0, 0, 1);
if (result.FileType.Equals(".ppm"))
{
var ppm = new PpmFile();
await ppm.ReadPpmFile(result);
_map.CreateImage(ppm);
}
else
{
_map.CreateImage(result);
}
}
}
private void FitContent(int width, int height)
{
var currentZoom = MapScrollViewer.ZoomFactor;
double scaleX = MapScrollViewer.ActualWidth / width;
double scaleY = MapScrollViewer.ActualHeight / height;
var newZoom = (float)(currentZoom * Math.Min(scaleX, scaleY));
newZoom = Math.Max(newZoom, MapScrollViewer.MinZoomFactor);
newZoom = Math.Min(newZoom, MapScrollViewer.MaxZoomFactor);
var currentPan = new Vector2((float)MapScrollViewer.HorizontalOffset,
(float)MapScrollViewer.VerticalOffset);
var centerOffset = new Vector2((float)MapScrollViewer.ViewportWidth,
(float)MapScrollViewer.ViewportHeight) / 2;
var newPan = ((currentPan + centerOffset) * newZoom / currentZoom) - centerOffset;
if (double.IsNaN(newPan.X) || double.IsNaN(newPan.Y) || double.IsNaN(newZoom))
{
return;
}
MapScrollViewer.ChangeView(newPan.X, newPan.Y, newZoom);
}
private void MapScaleSlider_OnValueChanged(object sender, RoutedPropertyChangedEventArgs <double> e)
{
MapGridScaleTransform.ScaleX = e.NewValue;
MapGridScaleTransform.ScaleY = e.NewValue;
var centerOfViewport = new Point(MapScrollViewer.ViewportWidth / 2, MapScrollViewer.ViewportHeight / 2);
_lastCenterPositionOnTarget = MapScrollViewer.TranslatePoint(centerOfViewport, MapGrid);
}
private void Pan(Point curContentMousePoint)
{
Vector2 dragOffset = new Vector2((float)curContentMousePoint.X - (float)_mouseStart.X,
(float)curContentMousePoint.Y - (float)_mouseStart.Y);
var dragOffsetX = MapScrollViewer.HorizontalOffset - dragOffset.X * MapController.Instance.Zoom;
var dragOffsetY = MapScrollViewer.VerticalOffset - dragOffset.Y * MapController.Instance.Zoom;
MapScrollViewer.ChangeView(dragOffsetX, dragOffsetY, null);
}
private void MapScrollViewer_OnPointerCanceled(object sender, PointerRoutedEventArgs e)
{
_map.TemporaryGeometry_End(MapController.Instance.MousePosition);
MapScrollViewer.ReleasePointerCapture(e.Pointer);
e.Handled = true;
_map.UnlockAll();
if (_mouseMode == MouseHandlingMode.Panning)
{
_mouseMode = MouseHandlingMode.None;
UncheckTopToolbarButtons(null);
}
InstanceOnInvalidateMap();
}
private void MapScrollViewer_PreviewMouseWheel(object sender, MouseWheelEventArgs e)
{
var scrollControl = sender as ScrollViewer;
if (!e.Handled && sender != null)
{
Point point = e.GetPosition(MapGridCanvas);
e.Handled = true;
var eventArg = new MouseWheelEventArgs(e.MouseDevice, e.Timestamp, e.Delta);
eventArg.RoutedEvent = UIElement.MouseWheelEvent;
eventArg.Source = sender;
int delta = e.Delta;
if (delta != 0)
{
double steps = ((double)e.Delta) / 120.0;
double diff = Math.Pow(1.1, steps);
double mapWidthStart = MapScrollViewer.ScrollableWidth;
double mapHeightStart = MapScrollViewer.ScrollableHeight;
double offsetX = MapScrollViewer.HorizontalOffset;
double offsetY = MapScrollViewer.VerticalOffset;
UseScale = UseScale * diff;
double mapWidthEnd = mapWidthStart * diff;
double mapHeightEnd = mapHeightStart * diff;
double mapWidthDiff = mapWidthEnd - mapWidthStart;
double mapHeightDiff = mapHeightEnd - mapHeightStart;
MapScrollViewer.ScrollToHorizontalOffset(offsetX + mapWidthDiff / 2.0);
MapScrollViewer.ScrollToVerticalOffset(offsetY + mapHeightDiff / 2.0);
}
var parent = ((Control)sender).Parent as UIElement;
parent.RaiseEvent(eventArg);
}
}
private void MapScrollViewer_OnMouseMove(object sender, MouseEventArgs e)
{
if (_lastDragPoint.HasValue)
{
Point posNow = e.GetPosition(MapScrollViewer);
double dX = posNow.X - _lastDragPoint.Value.X;
double dY = posNow.Y - _lastDragPoint.Value.Y;
_lastDragPoint = posNow;
MapScrollViewer.ScrollToHorizontalOffset(MapScrollViewer.HorizontalOffset - dX);
MapScrollViewer.ScrollToVerticalOffset(MapScrollViewer.VerticalOffset - dY);
}
}
private void MapScrollViewer_OnScrollChanged(object sender, ScrollChangedEventArgs e)
{
if (e.ExtentHeightChange != 0 || e.ExtentWidthChange != 0)
{
Point?targetBefore = null;
Point?targetNow = null;
if (!_lastMousePositionOnTarget.HasValue)
{
if (_lastCenterPositionOnTarget.HasValue)
{
var centerOfViewport = new Point(MapScrollViewer.ViewportWidth / 2, MapScrollViewer.ViewportHeight / 2);
Point centerOfTargetNow = MapScrollViewer.TranslatePoint(centerOfViewport, MapGrid);
targetBefore = _lastCenterPositionOnTarget;
targetNow = centerOfTargetNow;
}
}
else
{
targetBefore = _lastMousePositionOnTarget;
targetNow = Mouse.GetPosition(MapGrid);
_lastMousePositionOnTarget = null;
}
if (targetBefore.HasValue)
{
double dXInTargetPixels = targetNow.Value.X - targetBefore.Value.X;
double dYInTargetPixels = targetNow.Value.Y - targetBefore.Value.Y;
double multiplicatorX = e.ExtentWidth / MapGrid.Width;
double multiplicatorY = e.ExtentHeight / MapGrid.Height;
double newOffsetX = MapScrollViewer.HorizontalOffset - dXInTargetPixels * multiplicatorX;
double newOffsetY = MapScrollViewer.VerticalOffset - dYInTargetPixels * multiplicatorY;
if (double.IsNaN(newOffsetX) || double.IsNaN(newOffsetY))
{
return;
}
MapScrollViewer.ScrollToHorizontalOffset(newOffsetX);
MapScrollViewer.ScrollToVerticalOffset(newOffsetY);
}
}
}
private void MapScrollViewer_PreviewMouseWheel(object sender, MouseWheelEventArgs e)
{
var scrollControl = sender as ScrollViewer;
if (!e.Handled && sender != null)
{
double steps = ((double)e.Delta) / 120.0;
e.Handled = true;
var eventArg = new MouseWheelEventArgs(e.MouseDevice, e.Timestamp, e.Delta);
eventArg.RoutedEvent = UIElement.MouseWheelEvent;
eventArg.Source = sender;
int delta = e.Delta;
if (delta != 0)
{
double diff = Math.Pow(1.1, steps);
Size mapSizeStart = new Size(MapScrollViewer.ViewportWidth, MapScrollViewer.ViewportHeight);
double vertOffset = MapScrollViewer.VerticalOffset;
double horzOffset = MapScrollViewer.HorizontalOffset;
UseScale = UseScale * diff;
Size mapSizeEnd = mapSizeStart.Multiply(diff);
Point mapSizeDiff = mapSizeEnd.Subtract(mapSizeStart).Divide(2.0);
double scrollOnSizeX = horzOffset * diff + mapSizeDiff.X;
double scrollOnSizeY = vertOffset * diff + mapSizeDiff.Y;
MapScrollViewer.ScrollTo(scrollOnSizeX, scrollOnSizeY);
}
var parent = ((Control)sender).Parent as UIElement;
parent.RaiseEvent(eventArg);
}
}
private void MapScrollViewer_OnPointerPressed(object sender, PointerRoutedEventArgs e)
{
MapScrollViewer.CapturePointer(e.Pointer);
if (e.GetCurrentPoint(MapScrollViewer).Properties.IsRightButtonPressed)
{
_mouseMode = MouseHandlingMode.Panning;
_mouseStart = e.GetCurrentPoint(MapCanvas).Position;
}
else if (e.GetCurrentPoint(MapScrollViewer).Properties.IsLeftButtonPressed)
{
InstanceOnInvalidateMap();
switch (_mouseMode)
{
case MouseHandlingMode.Move:
_map.LockGeometry(MapController.Instance.MousePosition);
_mouseStart = e.GetCurrentPoint(MapCanvas).Position;
break;
case MouseHandlingMode.Line:
_map.CreateGeometry(MapController.Instance.MousePosition, GeometryType.Line);
break;
case MouseHandlingMode.Rectangle:
_map.CreateGeometry(MapController.Instance.MousePosition, GeometryType.Rectangle);
break;
case MouseHandlingMode.Circle:
_map.CreateGeometry(MapController.Instance.MousePosition, GeometryType.Circle);
break;
case MouseHandlingMode.Resize:
_map.LockPointToMove(MapController.Instance.MousePosition);
break;
}
}
e.Handled = true;
}
private void MapGridCanvas_MouseMove(object sender, MouseEventArgs e)
{
Point p = e.GetPosition((Canvas)sender);
if (settingFog)
{
if (e.LeftButton == MouseButtonState.Released)
{
settingFog = false;
map.SaveMap(true);
}
else
{
GameMap.MapCell cell = PointToCell(p);
List <GameMap.MapCell> list = PointToCellArray(p, brushSize);
bool changed = false;
foreach (var c in list)
{
if (CellOnBoard(c))
{
if (map[c.X, c.Y] != newFogState)
{
map[c.X, c.Y] = newFogState;
changed = true;
}
}
}
if (changed)
{
map.FireFogOrMarkerChanged();
}
}
lastPosition = p;
}
else if (settingMarkers)
{
if (e.LeftButton == MouseButtonState.Released)
{
settingMarkers = false;
map.SaveMap(true);
}
else
{
SetMarkers(p);
}
}
if (draggingMap)
{
if (e.MiddleButton == MouseButtonState.Released)
{
draggingMap = false;
}
else
{
Vector v = p - lastPosition;
double newVerticalOffset = MapScrollViewer.VerticalOffset - v.Y;
double newHorizontalOffset = MapScrollViewer.HorizontalOffset - v.X;
double verticalDiff = 0;
double horizontalDiff = 0;
if (newVerticalOffset < 0)
{
verticalDiff = newVerticalOffset;
newVerticalOffset = 0;
}
else if (newVerticalOffset > MapScrollViewer.ScrollableHeight)
{
verticalDiff = newVerticalOffset - MapScrollViewer.ScrollableHeight;
newVerticalOffset = MapScrollViewer.ScrollableHeight;
}
if (newHorizontalOffset < 0)
{
horizontalDiff = newHorizontalOffset;
newHorizontalOffset = 0;
}
else if (newHorizontalOffset > MapScrollViewer.ScrollableWidth)
{
horizontalDiff = newHorizontalOffset - MapScrollViewer.ScrollableWidth;
newHorizontalOffset = MapScrollViewer.ScrollableWidth;
}
MapScrollViewer.ScrollToVerticalOffset(newVerticalOffset);
MapScrollViewer.ScrollToHorizontalOffset(newHorizontalOffset);
lastPosition.X = lastPosition.X - horizontalDiff;
lastPosition.Y = lastPosition.Y - verticalDiff;
}
}
}
private void MapScrollViewer_OnPreviewMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
MapScrollViewer.Cursor = Cursors.Arrow;
MapScrollViewer.ReleaseMouseCapture();
_lastDragPoint = null;
}
