void HandleRedrawEvent(ICanvasObject co, Area area)
{
if (!IgnoreRedraws)
{
widget.ReDraw(area);
}
}
protected virtual void HandleRedrawEvent(ICanvasObject co, Area area)
{
if (!IgnoreRedraws)
{
widget?.ReDraw(area);
}
}
void HandleClickedEvent(ICanvasObject co)
{
PlayerObject po = co as PlayerObject;
Player player = po.Player;
if (po == inpo)
{
if (outpo.Active)
{
outpo.Active = false;
drawingarea3.QueueDraw();
}
if (selectedPlayer != null)
{
SwitchPlayer(selectedPlayer, outPlayer);
}
}
else
{
if (inpo.Active)
{
inpo.Active = false;
drawingarea2.QueueDraw();
}
if (selectedPlayer != null)
{
SwitchPlayer(inPlayer, selectedPlayer);
}
}
}
void HandleTeamClickedEvent(ICanvasObject co)
{
if (TeamSelectionChangedEvent != null)
{
TeamSelectionChangedEvent(SelectedTeam);
}
}
public void InitializeDrag(IInputModeContext context)
{
this.inputModeContext = context;
// start using the calculated dummy bounds
emulate = true;
var labelLayout = label.GetLayout();
dummyLocation = labelLayout.GetAnchorLocation();
up = labelLayout.GetUp();
// TODO the reference point, can be determined from the parameter
rotationCenter = labelLayout.GetCenter();
var canvasControl = context.CanvasControl;
if (canvasControl != null)
{
// install the visual rectangle indicator in the SelectionGroup of the canvas
var template = LabelHighlightTemplate;
var installer = new LabelRotateIndicatorInstaller(this)
{
Template = template
};
sizeIndicator = installer.AddCanvasObject(canvasControl.CanvasContext, ((GraphControl)canvasControl).SelectionGroup, this);
}
}
public void CancelDrag(IInputModeContext context, PointD originalLocation)
{
wrappedHandler.CancelDrag(context, originalLocation);
shadowObject.Remove();
shadowObject = null;
shadowLocation = null;
emulatedOffset = PointD.Origin;
}
/// <summary>
/// Adds a new object to the canvas and a listener to its redraw event.
/// </summary>
/// <param name="co">The object to add.</param>
public void AddObject(ICanvasObject co)
{
Objects.Add(co);
co.RedrawEvent += HandleRedrawEvent;
if (co is CanvasContainer container)
{
container.CollectionChanged += HandleChildrenChanged;
}
}
/// <summary>
/// Removes the rectCanvasObject.
/// </summary>
private void RemoveRectangleVisualization()
{
if (rectCanvasObject != null)
{
rectCanvasObject.Remove();
rectCanvasObject = null;
}
rectangle = null;
}
public void DragFinished(IInputModeContext context, PointD originalLocation, PointD newLocation)
{
wrappedHandler.HandleMove(context, originalLocation, newLocation);
wrappedHandler.DragFinished(context, originalLocation, newLocation);
shadowObject.Remove();
shadowObject = null;
shadowLocation = null;
emulatedOffset = PointD.Origin;
}
void HandleSubsClicked(ICanvasObject co)
{
ResetSelection();
if (PlayersSelectionChangedEvent != null)
{
PlayersSelectionChangedEvent(SelectedPlayers);
}
SubstitutionMode = !SubstitutionMode;
}
protected override void OnCanceled(IInputModeContext context, PointD originalLocation)
{
base.OnCanceled(context, originalLocation);
if (canvasObject != null)
{
// clean up
canvasObject.Remove();
canvasObject = null;
}
}
/// <summary>
/// Removes and object from the canvas.
/// </summary>
/// <param name="co">The object to remove.</param>
public void RemoveObject(ICanvasObject co)
{
co.RedrawEvent -= HandleRedrawEvent;
if (co is CanvasContainer container)
{
container.CollectionChanged -= HandleChildrenChanged;
}
Objects.Remove(co);
co.Dispose();
}
/// <summary>
/// Called before the a layout run starts.
/// </summary>
private void OnLayoutStarting()
{
switch (state)
{
case GestureState.Initializing:
resetToOriginalGraphStageData = CreateGivenCoordinatesStageData(n => true, e => true);
executor = CreateInitializingLayoutExecutor();
// highlight the parent of the current subtree and make the connection to the root invisible
if (subtree.Parent != null)
{
canvasObjectEdge = graphControl.GraphModelManager.GetCanvasObject(subtree.ParentToRootEdge);
canvasObjectEdge.Visible = false;
subtree.NewParent = subtree.Parent;
UpdateComponents();
graphControl.HighlightIndicatorManager.AddHighlight(subtree.NewParent);
}
break;
case GestureState.Cancelling:
// make root edge visible
if (canvasObjectEdge != null)
{
canvasObjectEdge.Visible = true;
}
// remove highlight
if (subtree.NewParent != null)
{
graphControl.HighlightIndicatorManager.RemoveHighlight(subtree.NewParent);
}
// reset to original graph layout
executor = CreateCanceledLayoutExecutor();
break;
case GestureState.Finishing:
// before the last run starts, we have to reparent the subtree
if (ApplyNewParent())
{
canvasObjectEdge = graphControl.GraphModelManager.GetCanvasObject(subtree.ParentToRootEdge);
canvasObjectEdge.Visible = false;
}
// last layout run also includes subtree
executor = CreateFinishedLayoutExecutor();
// remove highlight
if (subtree.NewParent != null)
{
graphControl.HighlightIndicatorManager.RemoveHighlight(subtree.NewParent);
}
state = GestureState.Finished;
break;
}
}
private void MainCanvas_MouseMove(object sender, MouseEventArgs e)
{
Canvas canvas = sender as Canvas;
if (canvas == null)
{
return;
}
Point currentMousePosition = e.GetPosition(canvas);
Point cartesianPosition = ConvertToCartesianCoords(MainCanvas, currentMousePosition);
lbMousePosition.Text = $"X: {cartesianPosition.X} Y:{cartesianPosition.Y}";
if (currentSelection.Any())
{
ICanvasObject currentLine = lines[lastClickedLine];
lbEquation.Text = $"Уравнение: {lastClickedLine.GetLineConstants()}";
float radius = 10;
bool isMouseNearBegin = Math.Pow(lastClickedLine.X1 - previousMousePosition.X, 2) + Math.Pow(lastClickedLine.Y1 - previousMousePosition.Y, 2) < Math.Pow(radius, 2);
bool isMouseNearEnd = Math.Pow(lastClickedLine.X2 - previousMousePosition.X, 2) + Math.Pow(lastClickedLine.Y2 - previousMousePosition.Y, 2) < Math.Pow(radius, 2);
if (isMouseNearBegin || isMouseNearEnd)
{
lastClickedLine.Cursor = Cursors.SizeNWSE;
}
else
{
lastClickedLine.Cursor = Cursors.SizeAll;
}
if (isMousePressed)
{
if (isMouseNearBegin)
{
lastClickedLine.X1 = currentMousePosition.X;
lastClickedLine.Y1 = currentMousePosition.Y;
}
else if (isMouseNearEnd)
{
lastClickedLine.X2 = currentMousePosition.X;
lastClickedLine.Y2 = currentMousePosition.Y;
}
else
{
Vector delta = previousMousePosition - currentMousePosition;
currentLine.Move(delta);
}
}
}
previousMousePosition = currentMousePosition;
}
public void CancelDrag(IInputModeContext context, PointD originalLocation)
{
// use the normal label bounds if the drag gesture is over
emulate = false;
// remove the visual size indicator
if (sizeIndicator != null)
{
sizeIndicator.Remove();
sizeIndicator = null;
}
}
protected override void HandleTaggerClickedEvent(ICanvasObject co)
{
DashboardButtonObject tagger;
EventButton button;
Time start = null, stop = null, eventTime = null;
List<Tag> tags = null;
tagger = co as DashboardButtonObject;
if (tagger is TagObject) {
TagObject tag = tagger as TagObject;
if (tag.Active) {
/* All tag buttons from the same group that are active */
foreach (TagObject to in Objects.OfType<TagObject>().
Where (t => t.TagButton.Tag.Group == tag.TagButton.Tag.Group &&
t.Active && t != tagger)) {
to.Active = false;
}
}
return;
}
if (NewTagEvent == null || !(tagger.Button is EventButton)) {
return;
}
button = tagger.Button as EventButton;
if (Mode == DashboardMode.Edit) {
return;
}
if (button.TagMode == TagMode.Predefined) {
stop = CurrentTime + button.Stop;
start = CurrentTime - button.Start;
eventTime = CurrentTime;
} else {
stop = CurrentTime;
start = tagger.Start - button.Start;
eventTime = tagger.Start;
}
tags = new List<Tag> ();
if (tagger is CategoryObject) {
tags.AddRange ((tagger as CategoryObject).SelectedTags);
}
foreach (TagObject to in Objects.OfType<TagObject>()) {
if (to.Active) {
tags.Add (to.TagButton.Tag);
}
to.Active = false;
}
NewTagEvent (button.EventType, null, null, tags, start, stop, eventTime, button);
}
void HandleTeamClickedEvent(ICanvasObject co)
{
var button = co as ButtonObject;
if (button == homeButton)
{
ViewModel.HomeTeam.Tagged = button.Active;
}
else if (button == awayButton)
{
ViewModel.AwayTeam.Tagged = button.Active;
}
}
void HandleShowTooltipEvent(Point coords)
{
Selection sel = GetSelection(ToUserCoords(coords));
if (sel != null)
{
ICanvasObject co = sel.Drawable as ICanvasObject;
if (co != null && co.Description != null)
{
widget.ShowTooltip(co.Description);
}
}
}
private void CreateIndicatorRect(CanvasControl canvasControl)
{
if (canvasObject != null)
{
canvasObject.Remove();
}
// visualize it
var shapePaintable = new RectangleIndicatorInstaller(targetBounds)
{
Template = (DataTemplate)canvasControl.TryFindResource("LayerPaintableRectangleTemplateKey")
};
canvasObject = shapePaintable.AddCanvasObject(canvasControl.CanvasContext, ((GraphControl)canvasControl).BackgroundGroup, targetBounds);
}
public void InitializeDrag(IInputModeContext context)
{
// start using the calculated dummy bounds
emulate = true;
dummyPreferredSize = label.PreferredSize;
dummyLocation = label.GetLayout().GetAnchorLocation();
var canvasControl = context.CanvasControl;
if (canvasControl != null)
{
// install the visual size indicator in the SelectionGroup of the canvas
sizeIndicator = new LabelResizeIndicatorInstaller(this).AddCanvasObject(canvasControl.CanvasContext, ((GraphControl)canvasControl).SelectionGroup, this);
}
}
protected override void OnFinished(IInputModeContext context, PointD originalLocation, PointD newLocation)
{
base.OnFinished(context, originalLocation, newLocation);
if (canvasObject != null)
{
var canvasControl = context.CanvasControl;
// calculate the target layer
int newLayer = UpdateTargetBounds(canvasControl.LastEventLocation);
// clean up
canvasObject.Remove();
canvasObject = null;
// and register the new layer for the node
newLayerMapper[node] = newLayer;
}
}
public void InitializeDrag(IInputModeContext context)
{
wrappedHandler.InitializeDrag(context);
this.shadowLocation = node.Layout.GetTopLeft();
this.emulatedOffset = PointD.Origin;
var dummyNode = new SimpleNode {
Layout = new DynamicRectangle(shadowLocation, node.Layout),
Style =
new ShapeNodeStyle {
Shape = ShapeNodeShape.RoundRectangle,
Brush = Brushes.Transparent,
Pen = new Pen(Brushes.Gray, 2)
}
};
shadowObject = context.CanvasControl.RootGroup.AddChild(dummyNode, GraphModelManager.DefaultNodeDescriptor).ToFront();
}
public void InitializeReshape(IInputModeContext context)
{
simulationRectangle = new MutableRectangle(originalHandler.Bounds);
var node = new SimpleNode {
Layout = simulationRectangle,
Style =
new ShapeNodeStyle {
Shape = ShapeNodeShape.RoundRectangle,
Brush = Brushes.Transparent,
Pen = new Pen(Brushes.Gray, 2)
}
};
shadowObject = context.CanvasControl.RootGroup.AddChild(node, GraphModelManager.DefaultNodeDescriptor).ToFront();
originalHandler.InitializeReshape(context);
originalBounds = originalHandler.Bounds.ToRectD();
}
/// <summary>
/// Sets new ascending z-orders for <paramref name="viewNodes"/> starting from <paramref name="zOrder"/>
/// and sorts their <see cref="GraphModelManager.GetMainCanvasObject">canvas objects</see> as well.
/// </summary>
/// <param name="viewNodes">The children of one group node in their new z-order.</param>
/// <param name="zOrder">The z-order to start the new z-orders from.</param>
public void ArrangeNodes(IEnumerable <INode> viewNodes, int zOrder = 0)
{
ICanvasObject prev = null;
foreach (var node in viewNodes)
{
SetZOrder(MasterOf(node), zOrder++);
var canvasObject = GraphControl.GraphModelManager.GetMainCanvasObject(node);
if (prev == null)
{
canvasObject.ToBack();
}
else
{
canvasObject.Above(prev);
}
prev = canvasObject;
}
}
public void Resize(ICanvasObject obj, int x, int y, int w, int h)
{
if (w < 1 || h < 1)
{
return;
}
var preW = Math.Max(1, Math.Min(w, Width - Math.Max(0, x)));
var preH = Math.Max(1, Math.Min(h, Height - Math.Max(0, y)));
var realX = Math.Min(Math.Max(x, 0), Width - preW);
var realY = Math.Min(Math.Max(y, 0), Height - preH);
w += x - realX;
h += y - realY;
obj.X = realX;
obj.Y = realY;
obj.Width = Math.Max(1, Math.Min(w, Width - realX));
obj.Height = Math.Max(1, Math.Min(h, Height - realY));
}
/// <summary>
/// Initializes the handles, the reshapeHandler and enables the handleInputMode.
/// </summary>
private void ShowHandles()
{
var graphControl = InputModeContext.CanvasControl as GraphControl;
// collect all selected nodes as well as their descendents
var reshapeNodes = CollectReshapeNodes(graphControl.Graph, graphControl.Selection);
// create a mutable rectangle, that is updated by the ReshapeHandler
rectangle = new EncompassingRectangle(reshapeNodes, margins);
// and visualize it
var rectangleIndicator = new RectangleIndicatorInstaller(rectangle, RectangleIndicatorInstaller.SelectionTemplateKey);
rectCanvasObject = rectangleIndicator.AddCanvasObject(graphControl.CanvasContext, graphControl.InputModeGroup, rectangle);
rectCanvasObject.ToBack();
// Create a reshape handler factory depending on the current mode
Func <ReshapeHandlerBase> reshapeHandlerFactory;
if ((Mode == ResizeMode.Scale))
{
reshapeHandlerFactory = () => new ScalingReshapeHandler(rectangle);
}
else
{
reshapeHandlerFactory = () => new ResizingReshapeHandler(rectangle);
}
// create and add the handles to our HandleInputMode
handleInputMode.Handles = new DefaultObservableCollection <IHandle> {
CreateHandle(HandlePositions.North, reshapeHandlerFactory),
CreateHandle(HandlePositions.NorthWest, reshapeHandlerFactory),
CreateHandle(HandlePositions.West, reshapeHandlerFactory),
CreateHandle(HandlePositions.SouthWest, reshapeHandlerFactory),
CreateHandle(HandlePositions.South, reshapeHandlerFactory),
CreateHandle(HandlePositions.SouthEast, reshapeHandlerFactory),
CreateHandle(HandlePositions.East, reshapeHandlerFactory),
CreateHandle(HandlePositions.NorthEast, reshapeHandlerFactory)
};
handleInputMode.Enabled = true;
}
void HandlePlayerClickedEvent(ICanvasObject co)
{
PlayerObject player = co as PlayerObject;
if (SubstitutionMode)
{
if (substitutionPlayer == null)
{
substitutionPlayer = player;
}
else
{
if (substitutionPlayer.Team == player.Team)
{
EmitSubsitutionEvent(player, substitutionPlayer);
}
else
{
player.Active = false;
}
}
}
else
{
if (player.Active)
{
SelectedPlayers.Add(player.Player);
}
else
{
SelectedPlayers.Remove(player.Player);
}
if (PlayersSelectionChangedEvent != null)
{
PlayersSelectionChangedEvent(SelectedPlayers);
}
}
}
/// <summary>
/// Removes and object from the canvas.
/// </summary>
/// <param name="co">The object to remove.</param>
public void RemoveObject(ICanvasObject co)
{
co.RedrawEvent -= HandleRedrawEvent;
Objects.Remove (co);
co.Dispose ();
}
void HandleSubsClicked(ICanvasObject co)
{
ViewModel.SubstitutionMode = !ViewModel.SubstitutionMode;
}
void HandlePlayerClickedEvent(ICanvasObject co)
{
LMPlayerView player = co as LMPlayerView;
ViewModel.PlayerClick(player.ViewModel, modifier);
}
void HandleTeamClickedEvent(ICanvasObject co)
{
if (TeamSelectionChangedEvent != null)
TeamSelectionChangedEvent (SelectedTeams);
}
/// <summary>
/// Adds a new object to the canvas and a listener to its redraw event.
/// </summary>
/// <param name="co">The object to add.</param>
public void AddObject(ICanvasObject co)
{
Objects.Add (co);
co.RedrawEvent += HandleRedrawEvent;
}
void HandleSubsClicked(ICanvasObject co)
{
ResetSelection ();
if (PlayersSelectionChangedEvent != null) {
PlayersSelectionChangedEvent (SelectedPlayers);
}
SubstitutionMode = !SubstitutionMode;
}
protected void EmitRedrawEvent(ICanvasObject co, Area area)
{
RedrawEvent?.Invoke(co, area);
}
public bool IsDirty(ICanvasContext context, ICanvasObject canvasObject)
{
return(true);
}
void HandlePlayerClickedEvent(ICanvasObject co)
{
SportsPlayerObject player = co as SportsPlayerObject;
if (SubstitutionMode) {
if (substitutionPlayer == null) {
substitutionPlayer = player;
} else {
if (substitutionPlayer.Team == player.Team) {
EmitSubsitutionEvent (player, substitutionPlayer);
} else {
player.Active = false;
}
}
} else {
if (player.Active) {
SelectedPlayers.Add (player.Player);
} else {
SelectedPlayers.Remove (player.Player);
}
if (PlayersSelectionChangedEvent != null) {
PlayersSelectionChangedEvent (SelectedPlayers);
}
}
}
void HandleClickedEvent(ICanvasObject co)
{
SportsPlayerObject po = co as SportsPlayerObject;
if (po == inpo) {
if (outpo.Active) {
outpo.Active = false;
drawingarea3.QueueDraw ();
}
if (selectedPlayer != null) {
SwitchPlayer (selectedPlayer, outPlayer);
}
} else {
if (inpo.Active) {
inpo.Active = false;
drawingarea2.QueueDraw ();
}
if (selectedPlayer != null) {
SwitchPlayer (inPlayer, selectedPlayer);
}
}
}
void HandleRedrawEvent(ICanvasObject co, Area area)
{
if (!IgnoreRedraws) {
widget.ReDraw (area);
}
}
void HandleRedrawEvent(ICanvasObject co, Area area)
{
EmitRedrawEvent (co as CanvasObject, area);
}
